diff --git a/ui/raidboss/data/00-misc/test.ts b/ui/raidboss/data/00-misc/test.ts
index ec1eb779b8..c3c27e76ef 100644
--- a/ui/raidboss/data/00-misc/test.ts
+++ b/ui/raidboss/data/00-misc/test.ts
@@ -393,6 +393,7 @@ const triggerSet: TriggerSet<Data> = {
   timelineReplace: [
     {
       locale: 'de',
+      missingTranslations: true,
       replaceSync: {
         'You bid farewell to the striking dummy': 'Du winkst der Trainingspuppe zum Abschied zu',
         'You bow courteously to the striking dummy':
@@ -514,6 +515,7 @@ const triggerSet: TriggerSet<Data> = {
     },
     {
       locale: 'cn',
+      missingTranslations: true,
       replaceSync: {
         'You bid farewell to the striking dummy': '.*向木人告别',
         'You bow courteously to the striking dummy': '.*恭敬地对木人行礼',
@@ -552,6 +554,7 @@ const triggerSet: TriggerSet<Data> = {
     },
     {
       locale: 'ko',
+      missingTranslations: true,
       replaceSync: {
         'You bid farewell to the striking dummy': '.*나무인형에게 작별 인사를 합니다',
         'You bow courteously to the striking dummy': '.*나무인형에게 공손하게 인사합니다',
diff --git a/ui/raidboss/data/00-misc/test.txt b/ui/raidboss/data/00-misc/test.txt
index 14e7aee9c7..1127898107 100644
--- a/ui/raidboss/data/00-misc/test.txt
+++ b/ui/raidboss/data/00-misc/test.txt
@@ -18,6 +18,7 @@ hideall "--sync--"
 
 0 "--Reset--" sync /You bid farewell to the striking dummy/ window 10000 jump 0
 
+0 "--sync--" GameLog { "line": "testNetRegexTimeline" } window 100000,100000
 0 "--sync--" sync /:Engage!/ window 100000,100000
 0 "--sync--" sync /:You bow courteously to the striking dummy/ window 0,1
 3 "Almagest"
diff --git a/ui/raidboss/emulator/overrides/RaidEmulatorTimelineController.ts b/ui/raidboss/emulator/overrides/RaidEmulatorTimelineController.ts
index ef4fb0be7c..68052b182b 100644
--- a/ui/raidboss/emulator/overrides/RaidEmulatorTimelineController.ts
+++ b/ui/raidboss/emulator/overrides/RaidEmulatorTimelineController.ts
@@ -1,5 +1,5 @@
 import { UnreachableCode } from '../../../../resources/not_reached';
-import { LogEvent } from '../../../../types/event';
+import { EventResponses, LogEvent } from '../../../../types/event';
 import { LooseTimelineTrigger } from '../../../../types/trigger';
 import { TimelineController } from '../../timeline';
 import { TimelineReplacement, TimelineStyle } from '../../timeline_parser';
@@ -63,12 +63,17 @@ export default class RaidEmulatorTimelineController extends TimelineController {
     throw new UnreachableCode();
   }
 
+  public override OnNetLog(_e: EventResponses['LogLine']): void {
+    throw new UnreachableCode();
+  }
+
   public onEmulatorLogEvent(logs: LineEvent[]): void {
     if (!this.activeTimeline)
       return;
 
     for (const line of logs) {
       this.activeTimeline.OnLogLine(line.convertedLine, line.timestamp);
+      this.activeTimeline.OnNetLogLine(line.networkLine, line.timestamp);
       // Only call _OnUpdateTimer if we have a timebase from the previous call to OnLogLine
       // This avoids spamming the console with a ton of messages
       if (this.activeTimeline.timebase)
diff --git a/ui/raidboss/raidboss.ts b/ui/raidboss/raidboss.ts
index 8cacf93267..0aba28c6dd 100644
--- a/ui/raidboss/raidboss.ts
+++ b/ui/raidboss/raidboss.ts
@@ -95,4 +95,8 @@ UserConfig.getUserConfigLocation('raidboss', defaultOptions, () => {
   addOverlayListener('onLogEvent', (e) => {
     timelineController.OnLogEvent(e);
   });
+
+  addOverlayListener('LogLine', (e) => {
+    timelineController.OnNetLog(e);
+  });
 });
diff --git a/ui/raidboss/timeline.ts b/ui/raidboss/timeline.ts
index 8308acb12a..227e2bdc41 100644
--- a/ui/raidboss/timeline.ts
+++ b/ui/raidboss/timeline.ts
@@ -1,7 +1,7 @@
 import { commonNetRegex } from '../../resources/netregexes';
 import { UnreachableCode } from '../../resources/not_reached';
 import { LocaleRegex } from '../../resources/translations';
-import { LogEvent } from '../../types/event';
+import { EventResponses, LogEvent } from '../../types/event';
 import { CactbotBaseRegExp } from '../../types/net_trigger';
 import { LooseTimelineTrigger, RaidbossFileData } from '../../types/trigger';
 
@@ -137,6 +137,7 @@ export class Timeline {
   private activeText: string;
 
   protected activeSyncs: Sync[];
+  protected activeNetSyncs: Sync[];
   private activeEvents: Event[];
   private keepAliveEvents: {
     event: Event;
@@ -184,6 +185,7 @@ export class Timeline {
 
     // Not sorted.
     this.activeSyncs = [];
+    this.activeNetSyncs = [];
     // Sorted by event occurrence time.
     this.activeEvents = [];
     // Events that are no longer active but we are keeping on screen briefly.
@@ -281,10 +283,15 @@ export class Timeline {
 
   private _CollectActiveSyncs(fightNow: number): void {
     this.activeSyncs = [];
+    this.activeNetSyncs = [];
     for (let i = this.nextSyncEnd; i < this.syncEnds.length; ++i) {
       const syncEnd = this.syncEnds[i];
-      if (syncEnd && syncEnd.start <= fightNow)
-        this.activeSyncs.push(syncEnd);
+      if (syncEnd && syncEnd.start <= fightNow) {
+        if (syncEnd.regexType === 'parsed')
+          this.activeSyncs.push(syncEnd);
+        else
+          this.activeNetSyncs.push(syncEnd);
+      }
     }
 
     if (
@@ -292,25 +299,41 @@ export class Timeline {
       this.activeLastForceJumpSync.start <= fightNow &&
       this.activeLastForceJumpSync.end > fightNow
     ) {
-      this.activeSyncs.push(this.activeLastForceJumpSync);
+      if (this.activeLastForceJumpSync.regexType === 'parsed')
+        this.activeSyncs.push(this.activeLastForceJumpSync);
+      else
+        this.activeNetSyncs.push(this.activeLastForceJumpSync);
     } else {
       this.activeLastForceJumpSync = undefined;
     }
   }
 
+  public OnLogLineJump(sync: Sync, currentTime: number): void {
+    if ('jump' in sync) {
+      if (!sync.jump) {
+        this.SyncTo(0, currentTime, sync);
+        this.Stop();
+      } else {
+        this.SyncTo(sync.jump, currentTime, sync);
+      }
+    } else {
+      this.SyncTo(sync.time, currentTime, sync);
+    }
+  }
+
   public OnLogLine(line: string, currentTime: number): void {
     for (const sync of this.activeSyncs) {
       if (sync.regex.test(line)) {
-        if ('jump' in sync) {
-          if (!sync.jump) {
-            this.SyncTo(0, currentTime, sync);
-            this.Stop();
-          } else {
-            this.SyncTo(sync.jump, currentTime, sync);
-          }
-        } else {
-          this.SyncTo(sync.time, currentTime, sync);
-        }
+        this.OnLogLineJump(sync, currentTime);
+        break;
+      }
+    }
+  }
+
+  public OnNetLogLine(line: string, currentTime: number): void {
+    for (const sync of this.activeNetSyncs) {
+      if (sync.regex.test(line)) {
+        this.OnLogLineJump(sync, currentTime);
         break;
       }
     }
@@ -723,6 +746,16 @@ export class TimelineController {
     }
   }
 
+  OnNetLog(e: EventResponses['LogLine']): void {
+    if (!this.activeTimeline)
+      return;
+
+    const currentTime = Date.now();
+
+    // TODO: Check for the countdown => wipe => engage logic for network lines
+    this.activeTimeline.OnNetLogLine(e.rawLine, currentTime);
+  }
+
   public SetActiveTimeline(
     timelineFiles: string[],
     timelines: string[],
diff --git a/ui/raidboss/timeline_parser.ts b/ui/raidboss/timeline_parser.ts
index bfe16f151a..74995ac8a1 100644
--- a/ui/raidboss/timeline_parser.ts
+++ b/ui/raidboss/timeline_parser.ts
@@ -1,11 +1,51 @@
 import { Lang } from '../../resources/languages';
+import logDefinitions, { LogDefinitionTypes } from '../../resources/netlog_defs';
+import { buildNetRegexForTrigger } from '../../resources/netregexes';
 import { UnreachableCode } from '../../resources/not_reached';
 import Regexes from '../../resources/regexes';
 import { translateRegex, translateText } from '../../resources/translations';
+import { NetParams } from '../../types/net_props';
 import { LooseTimelineTrigger, TriggerAutoConfig } from '../../types/trigger';
 
 import defaultOptions, { RaidbossOptions, TimelineConfig } from './raidboss_options';
 
+const isLogDefinitionTypes = (type: string): type is LogDefinitionTypes => {
+  return type in logDefinitions;
+};
+
+const isStringArray = (value: unknown[]): value is string[] => {
+  return value.find((v) => typeof v !== 'string') === undefined;
+};
+
+const isStringOrStringArray = (value: unknown): value is string | string[] => {
+  if (Array.isArray(value)) {
+    if (isStringArray(value))
+      return true;
+    return false;
+  }
+  return typeof value === 'string';
+};
+
+const isValidNetParams = <T extends LogDefinitionTypes>(
+  type: T,
+  params: Record<string, unknown>,
+): params is NetParams[T] => {
+  for (const key in params) {
+    // Make sure all keys are present on our definition type
+    if (!(key in logDefinitions[type].fields))
+      return false;
+    // Make sure our value is either a string/int or an array of strings/ints
+    if (!isStringOrStringArray(params[key]))
+      return false;
+  }
+  return true;
+};
+
+const isObject = (x: unknown): x is { [key: string]: unknown } => {
+  // JavaScript considers [] to be an object, so check for that explicitly.
+  return x instanceof Object && !Array.isArray(x);
+};
+
 export type TimelineReplacement = {
   locale: Lang;
   missingTranslations?: boolean;
@@ -41,6 +81,7 @@ export type Error = {
 export type Sync = {
   id: number;
   origRegexStr: string;
+  regexType: 'parsed' | 'net';
   regex: RegExp;
   start: number;
   end: number;
@@ -71,6 +112,32 @@ export type ParsedText = ParsedPopupText | ParsedTriggerText;
 
 export type Text = ParsedText & { time: number };
 
+const regexes = {
+  comment: /^\s*#/,
+  commentLine: /#.*$/,
+  durationCommand: /(?:[^#]*?\s)?(?<text>duration\s+(?<seconds>[0-9]+(?:\.[0-9]+)?))(\s.*)?$/,
+  ignore: /^hideall\s+\"(?<id>[^"]+)\"(?:\s*#.*)?$/,
+  jumpCommand:
+    /(?:[^#]*?\s)?(?<text>(?<command>(?:force|)jump)\s+(?:"(?<label>[^"]*)"|(?<seconds>[0-9]+(?:\.[0-9]+)?)))(?:\s.*)?$/,
+  label: /^(?<time>[0-9]+(?:\.[0-9]+)?)\s+(?<text>label\s+"(?<label>[^"]*)")\s*$/,
+  line: /^(?<text>(?<time>[0-9]+(?:\.[0-9]+)?)\s+"(?<name>.*?)")(\s+(.*))?/,
+  popupText:
+    /^(?<type>info|alert|alarm)text\s+\"(?<id>[^"]+)\"\s+before\s+(?<beforeSeconds>-?[0-9]+(?:\.[0-9]+)?)(?:\s+\"(?<text>[^"]+)\")?$/,
+  soundAlert: /^define\s+soundalert\s+"[^"]*"\s+"[^"]*"$/,
+  speaker:
+    /define speaker "[^"]*"(\s+"[^"]*")?\s+(-?[0-9]+(?:\.[0-9]+)?)\s+(-?[0-9]+(?:\.[0-9]+)?)/,
+  syncRegexCommand: /(?:[^#]*?\s)?(?<text>sync\s*\/(?<regex>.*)\/)(?<args>\s.*)?$/,
+  syncNetRegex: new RegExp(
+    `(?:[^#]*?\\s)?(?<netRegexType>${
+      Object.keys(logDefinitions).join('|')
+    })\\s*(?<netRegex>\\{.*\\})(?<args>\\s.*)?$`,
+  ),
+  tts:
+    /^alertall\s+"(?<id>[^"]*)"\s+before\s+(?<beforeSeconds>-?[0-9]+(?:\.[0-9]+)?)\s+(?<command>sound|speak\s+"[^"]*")\s+"(?<text>[^"]*)"$/,
+  windowCommand:
+    /(?:[^#]*?\s)?(?<text>window\s+(?:(?<start>[0-9]+(?:\.[0-9]+)?),)?(?<end>[0-9]+(?:\.[0-9]+)?))(?:\s.*)?$/,
+};
+
 // This class reads the format of ACT Timeline plugin, described in
 // docs/TimelineGuide.md
 export class TimelineParser {
@@ -140,26 +207,6 @@ export class TimelineParser {
   ): void {
     let uniqueid = initialId;
     const texts: { [id: string]: ParsedText[] } = {};
-    const regexes = {
-      comment: /^\s*#/,
-      commentLine: /#.*$/,
-      durationCommand: /(?:[^#]*?\s)?(?<text>duration\s+(?<seconds>[0-9]+(?:\.[0-9]+)?))(\s.*)?$/,
-      ignore: /^hideall\s+\"(?<id>[^"]+)\"(?:\s*#.*)?$/,
-      jumpCommand:
-        /(?:[^#]*?\s)?(?<text>(?<command>(?:force|)jump)\s+(?:"(?<label>[^"]*)"|(?<seconds>[0-9]+(?:\.[0-9]+)?)))(?:\s.*)?$/,
-      label: /^(?<time>[0-9]+(?:\.[0-9]+)?)\s+(?<text>label\s+"(?<label>[^"]*)")\s*$/,
-      line: /^(?<text>(?<time>[0-9]+(?:\.[0-9]+)?)\s+"(?<name>.*?)")(\s+(.*))?/,
-      popupText:
-        /^(?<type>info|alert|alarm)text\s+\"(?<id>[^"]+)\"\s+before\s+(?<beforeSeconds>-?[0-9]+(?:\.[0-9]+)?)(?:\s+\"(?<text>[^"]+)\")?$/,
-      soundAlert: /^define\s+soundalert\s+"[^"]*"\s+"[^"]*"$/,
-      speaker:
-        /define speaker "[^"]*"(\s+"[^"]*")?\s+(-?[0-9]+(?:\.[0-9]+)?)\s+(-?[0-9]+(?:\.[0-9]+)?)/,
-      syncCommand: /(?:[^#]*?\s)?(?<text>sync\s*\/(?<regex>.*)\/)(?<args>\s.*)?$/,
-      tts:
-        /^alertall\s+"(?<id>[^"]*)"\s+before\s+(?<beforeSeconds>-?[0-9]+(?:\.[0-9]+)?)\s+(?<command>sound|speak\s+"[^"]*")\s+"(?<text>[^"]*)"$/,
-      windowCommand:
-        /(?:[^#]*?\s)?(?<text>window\s+(?:(?<start>[0-9]+(?:\.[0-9]+)?),)?(?<end>[0-9]+(?:\.[0-9]+)?))(?:\s.*)?$/,
-    };
 
     // Make all regexes case insensitive, and parse any special \y{} groups.
     for (const trigger of triggers ?? []) {
@@ -283,71 +330,11 @@ export class TimelineParser {
         sortKey: 0,
       };
       if (line) {
-        let commandMatch = regexes.durationCommand.exec(line);
-        if (commandMatch && commandMatch['groups']) {
-          const durationCommand = commandMatch['groups'];
-          if (durationCommand.text === undefined || durationCommand.seconds === undefined)
-            throw new UnreachableCode();
-          line = line.replace(durationCommand.text, '').trim();
-          e.duration = parseFloat(durationCommand.seconds);
-        }
+        line = this.matchDurationCommand(line, e);
 
-        commandMatch = regexes.syncCommand.exec(line);
-        if (commandMatch && commandMatch['groups']) {
-          const syncCommand = commandMatch['groups'];
-          if (syncCommand.text === undefined || syncCommand.regex === undefined)
-            throw new UnreachableCode();
-          line = line.replace(syncCommand.text, '').trim();
-          const sync: Sync = {
-            id: uniqueid,
-            origRegexStr: syncCommand.regex,
-            regex: Regexes.parse(this.GetReplacedSync(syncCommand.regex)),
-            start: seconds - 2.5,
-            end: seconds + 2.5,
-            time: seconds,
-            lineNumber: lineNumber,
-            event: e,
-          };
-          e.sync = sync;
-          if (syncCommand.args !== undefined) {
-            let argMatch = regexes.windowCommand.exec(syncCommand.args);
-            if (argMatch && argMatch['groups']) {
-              const windowCommand = argMatch['groups'];
-              if (windowCommand.text === undefined || windowCommand.end === undefined)
-                throw new UnreachableCode();
-              line = line.replace(windowCommand.text, '').trim();
-              if (windowCommand.start !== undefined) {
-                sync.start = seconds - parseFloat(windowCommand.start);
-                sync.end = seconds + parseFloat(windowCommand.end);
-              } else {
-                sync.start = seconds - parseFloat(windowCommand.end) / 2;
-                sync.end = seconds + parseFloat(windowCommand.end) / 2;
-              }
-            }
-            argMatch = regexes.jumpCommand.exec(syncCommand.args);
-            if (argMatch && argMatch['groups']) {
-              const jumpCommand = argMatch['groups'];
-              if (jumpCommand.text === undefined)
-                throw new UnreachableCode();
-              line = line.replace(jumpCommand.text, '').trim();
-
-              if (jumpCommand.seconds !== undefined)
-                sync.jump = parseFloat(jumpCommand.seconds);
-              else if (jumpCommand.label !== undefined)
-                (this.labelToSync[jumpCommand.label] ??= []).push(sync);
-              else
-                throw new UnreachableCode();
-              if (jumpCommand.command === 'forcejump')
-                sync.jumpType = 'force';
-              else
-                sync.jumpType = 'normal';
-            }
-          }
-          this.syncStarts.push(sync);
-          this.syncEnds.push(sync);
-          if (sync.jumpType === 'force')
-            this.forceJumps.push(sync);
-        }
+        line = this.matchSyncRegexCommand(line, uniqueid, seconds, lineNumber, e);
+
+        line = this.matchSyncNetRegex(line, lineNumber, originalLine, uniqueid, seconds, e);
       }
       // If there's text left that isn't a comment then we didn't parse that text so report it.
       if (line && !regexes.comment.exec(line)) {
@@ -461,6 +448,176 @@ export class TimelineParser {
     });
   }
 
+  private matchSyncNetRegex(
+    line: string,
+    lineNumber: number,
+    originalLine: string,
+    uniqueid: number,
+    seconds: number,
+    e: Event,
+  ) {
+    const commandMatch = regexes.syncNetRegex.exec(line);
+    if (!commandMatch || !commandMatch['groups'])
+      return line;
+
+    const syncCommand = commandMatch['groups'];
+    if (syncCommand.netRegexType === undefined || syncCommand.netRegex === undefined)
+      throw new UnreachableCode();
+
+    line = line.replace(syncCommand.netRegexType, '').trim();
+
+    const netRegexType = syncCommand.netRegexType;
+    if (!isLogDefinitionTypes(netRegexType)) {
+      this.errors.push({
+        lineNumber: lineNumber,
+        line: originalLine,
+        error: 'Invalid NetRegex type',
+      });
+      return line;
+    }
+
+    line = line.replace(syncCommand.netRegex, '').trim();
+
+    let params: unknown;
+    try {
+      // TODO: Use `exec` => `JSON.stringify` => `JSON.parse` instead?
+      // See https://github.com/quisquous/cactbot/pull/5939#issuecomment-1830484703
+      params = JSON.parse(syncCommand.netRegex);
+    } catch (e) {
+      this.errors.push({
+        lineNumber: lineNumber,
+        line: originalLine,
+        error: 'Invalid NetRegex JSON',
+      });
+      return line;
+    }
+
+    if (!isObject(params) || !isValidNetParams(netRegexType, params)) {
+      this.errors.push({
+        lineNumber: lineNumber,
+        line: originalLine,
+        error: 'Invalid NetRegex arguments',
+      });
+      return line;
+    }
+    return this.buildRegexSync(
+      uniqueid,
+      'net',
+      `${netRegexType} ${syncCommand.netRegex}`,
+      // TODO: Use `translateRegexBuildParam` instead, store off params for use elsewhere.
+      // See https://github.com/quisquous/cactbot/pull/5939#discussion_r1399453530
+      Regexes.parse(this.GetReplacedSync(buildNetRegexForTrigger(netRegexType, params))),
+      syncCommand.args,
+      seconds,
+      lineNumber,
+      e,
+      line,
+    );
+  }
+
+  private matchSyncRegexCommand(
+    line: string,
+    uniqueid: number,
+    seconds: number,
+    lineNumber: number,
+    e: Event,
+  ) {
+    const commandMatch = regexes.syncRegexCommand.exec(line);
+    if (!commandMatch || !commandMatch['groups'])
+      return line;
+    const syncCommand = commandMatch['groups'];
+    if (syncCommand.text === undefined || syncCommand.regex === undefined)
+      throw new UnreachableCode();
+    line = line.replace(syncCommand.text, '').trim();
+    return this.buildRegexSync(
+      uniqueid,
+      'parsed',
+      syncCommand.regex,
+      Regexes.parse(this.GetReplacedSync(syncCommand.regex)),
+      syncCommand.args,
+      seconds,
+      lineNumber,
+      e,
+      line,
+    );
+  }
+
+  private buildRegexSync(
+    uniqueid: number,
+    regexType: 'parsed' | 'net',
+    regex: string,
+    parsedRegex: RegExp,
+    args: string | undefined,
+    seconds: number,
+    lineNumber: number,
+    e: Event,
+    line: string,
+  ) {
+    const sync: Sync = {
+      id: uniqueid,
+      origRegexStr: regex,
+      regexType: regexType,
+      regex: parsedRegex,
+      start: seconds - 2.5,
+      end: seconds + 2.5,
+      time: seconds,
+      lineNumber: lineNumber,
+      event: e,
+    };
+    e.sync = sync;
+    if (args !== undefined) {
+      let argMatch = regexes.windowCommand.exec(args);
+      if (argMatch && argMatch['groups']) {
+        const windowCommand = argMatch['groups'];
+        if (windowCommand.text === undefined || windowCommand.end === undefined)
+          throw new UnreachableCode();
+        line = line.replace(windowCommand.text, '').trim();
+        if (windowCommand.start !== undefined) {
+          sync.start = seconds - parseFloat(windowCommand.start);
+          sync.end = seconds + parseFloat(windowCommand.end);
+        } else {
+          sync.start = seconds - parseFloat(windowCommand.end) / 2;
+          sync.end = seconds + parseFloat(windowCommand.end) / 2;
+        }
+      }
+      argMatch = regexes.jumpCommand.exec(args);
+      if (argMatch && argMatch['groups']) {
+        const jumpCommand = argMatch['groups'];
+        if (jumpCommand.text === undefined)
+          throw new UnreachableCode();
+        line = line.replace(jumpCommand.text, '').trim();
+
+        if (jumpCommand.seconds !== undefined)
+          sync.jump = parseFloat(jumpCommand.seconds);
+        else if (jumpCommand.label !== undefined)
+          (this.labelToSync[jumpCommand.label] ??= []).push(sync);
+        else
+          throw new UnreachableCode();
+        if (jumpCommand.command === 'forcejump')
+          sync.jumpType = 'force';
+        else
+          sync.jumpType = 'normal';
+      }
+    }
+    this.syncStarts.push(sync);
+    this.syncEnds.push(sync);
+    if (sync.jumpType === 'force')
+      this.forceJumps.push(sync);
+    return line;
+  }
+
+  private matchDurationCommand(line: string, e: Event) {
+    const commandMatch = regexes.durationCommand.exec(line);
+    if (commandMatch && commandMatch['groups']) {
+      const durationCommand = commandMatch['groups'];
+      if (durationCommand.text === undefined || durationCommand.seconds === undefined)
+        throw new UnreachableCode();
+      line = line.replace(durationCommand.text, '').trim();
+      e.duration = parseFloat(durationCommand.seconds);
+    }
+    return line;
+  }
+
   private GetReplacedText(text: string): string {
     // Anything in the timeline config takes precedence over timelineReplace sections in
     // the trigger file.  It is also a full replacement, vs the regex-style GetReplacedHelper.
@@ -472,7 +629,7 @@ export class TimelineParser {
     return translateText(text, replaceLang, this.replacements);
   }
 
-  private GetReplacedSync(sync: string): string {
+  private GetReplacedSync(sync: string | RegExp): string {
     const replaceLang = this.options.ParserLanguage ?? 'en';
     return translateRegex(sync, replaceLang, this.replacements);
   }
diff --git a/util/logtools/test_timeline.ts b/util/logtools/test_timeline.ts
index 29df9f1c5f..743d54f3cb 100644
--- a/util/logtools/test_timeline.ts
+++ b/util/logtools/test_timeline.ts
@@ -26,7 +26,9 @@ const defaultDriftWarn = 0.2;
 const defaultDriftFail = 1.0;
 
 const maxFieldId = (fields: { [fieldName: string]: number }): number => {
-  return Math.max(...Object.values(fields));
+  // +1 for the 0-indexing
+  // +1 for the always-excluded-from-field-mappings hash
+  return Math.max(...Object.values(fields)) + 2;
 };
 
 const maxAbilityFieldId = maxFieldId(logDefinitionsVersions.latest.Ability.fields);
@@ -116,6 +118,7 @@ const testLineEvents = async (
     testTimeline._OnUpdateTimer(line.timestamp);
     // If this log line matches, it will OnSync and adjust the time as needed.
     testTimeline.OnLogLine(line.convertedLine, line.timestamp);
+    testTimeline.OnNetLogLine(line.networkLine, line.timestamp);
   }
 
   console.log('Timeline:');