@tikoci/rosetta 0.8.9 → 0.8.10

package/src/canonicalize.ts

@@ -31,15 +31,56 @@ export interface CanonicalCommand {
   args: string[];
   /** For subshell commands extracted from [...], this is true */
   subshell?: boolean;
+  /**
+   * How well-formed the extraction was. Lets consumers filter prose-extracted
+   * results when they need higher precision (e.g. LSP hover).
+   * - 'high'   — absolute path with directly-identified verb (well-formed CLI)
+   * - 'medium' — relative-with-cwd, pure navigation, or block/subshell context
+   * - 'low'    — verb was inferred from a trailing path segment at flush time,
+   *              i.e. extracted from looser/prose-shaped input
+   */
+  confidence: 'high' | 'medium' | 'low';
 }
 
 export interface ParseResult {
   /** All commands extracted from the input, in order */
   commands: CanonicalCommand[];
+  /**
+   * Every distinct path the input *referenced* — including bare navigation
+   * (e.g. `/ip/firewall/filter` with no verb). Superset of `commands[i].path`.
+   * Used by `extractMentions()` for "what does this text reference?" queries.
+   */
+  mentions: string[];
   /** The cwd after executing all navigation (useful for interactive sessions) */
   finalPath: string;
 }
 
+/**
+ * Optional behaviour knobs. Keeping the module pure: the resolver is supplied
+ * by the caller, never imported. rosetta wires a DB-backed resolver against
+ * its `commands` table; lsp-routeros-ts wires a static `verbs.json`-backed
+ * one. The built-in universal-verb-set heuristic always remains active so
+ * resolvers only need to supply path-specific verbs, not every common command.
+ */
+export interface CanonicalizeOptions {
+  /**
+   * Path-aware verb classifier. Called when the parser is deciding whether a
+   * token at the end of an in-flight command is a verb or another path
+   * segment. Return `true` to treat `token` as the verb.
+   *
+   * `parentPath` is the absolute dir path the verb would attach to (the
+   * resolved path of all path segments seen so far, *without* this token).
+   * MUST be synchronous and side-effect-free.
+   *
+   * The small built-in universal verb set (GENERAL_COMMANDS + EXTRA_VERBS)
+   * is checked first; this resolver supplements it for path-context-specific
+   * verbs. That keeps callers from having to enumerate ubiquitous helpers
+   * like `find` while still allowing DB/live-router precision for ambiguous
+   * tokens (see issue #5, finding #4).
+   */
+  isVerb?: (token: string, parentPath: string) => boolean;
+}
+
 // ---------------------------------------------------------------------------
 // Known RouterOS general commands (verbs).
 // These appear at every menu level.  Used to distinguish "is this token a
@@ -47,10 +88,17 @@ export interface ParseResult {
 // ---------------------------------------------------------------------------
 
 const GENERAL_COMMANDS = new Set([
-  'add', 'comment', 'disable', 'edit', 'enable', 'export', 'find',
-  'get', 'move', 'print', 'remove', 'reset', 'set',
+  'add', 'clear', 'comment', 'disable', 'edit', 'enable', 'export', 'find',
+  'get', 'move', 'print', 'remove', 'reset', 'reset-counters',
+  'reset-counters-all', 'set', 'unset',
 ]);
 
+// Verbs that are NOT in this set despite being common at certain menus:
+//   'info', 'warning', 'error', 'debug' — used by /log, but `info` is also a
+//     dir at /interface/wireless, and /error is itself a top-level cmd.
+//     Adding them here would mis-resolve those paths. Use a path-aware verb
+//     resolver (see CanonicalizeOptions.isVerb) for menu-specific verbs.
+
 /**
  * Commands that are clearly verbs even though they only appear at certain
  * menu levels.  We keep this small — the heuristic is "if in doubt, treat
@@ -97,14 +145,21 @@ interface Token {
  */
 function tokenize(input: string): Token[] {
   const tokens: Token[] = [];
-  let i = 0;
+  // Strip leading BOM (U+FEFF) — common when input is read from a UTF-8 file
+  // with a BOM marker. Without this, the BOM ends up embedded in the first
+  // path segment.
+  let i = input.charCodeAt(0) === 0xfeff ? 1 : 0;
   const len = input.length;
 
   while (i < len) {
     const ch = input[i];
 
-    // Skip whitespace (except newlines)
-    if (ch === ' ' || ch === '\t' || ch === '\r') { i++; continue; }
+    // Skip whitespace (except newlines).
+    // Backticks (`) are treated as whitespace so markdown-style snippets like
+    // `/ip/address/print` extract cleanly from prose.
+    // Zero-width space (U+200B) is also stripped — sometimes copy-pasted from
+    // documentation and otherwise pollutes path segments.
+    if (ch === ' ' || ch === '\t' || ch === '\r' || ch === '`' || ch === '​') { i++; continue; }
 
     // Newline
     if (ch === '\n') { tokens.push({ type: Tok.Newline, value: '\n' }); i++; continue; }
@@ -164,6 +219,9 @@ function tokenize(input: string): Token[] {
     while (i < len) {
       const c = input[i];
       if (c === ' ' || c === '\t' || c === '\r' || c === '\n') break;
+      // Treat the same as outer loop: backtick + ZWSP are whitespace inside words too,
+      // so trailing markdown markers don't get glued onto path segments.
+      if (c === '`' || c === '​') break;
       if (c === '[' || c === ']' || c === '{' || c === '}' || c === ';') break;
       if (c === '#') break;
       // Slash breaks a word UNLESS it's inside a CIDR or we're at a slash
@@ -262,6 +320,46 @@ interface ParseContext {
   cwd: string;
   commands: CanonicalCommand[];
   subshell: boolean;
+  options: CanonicalizeOptions;
+  /**
+   * Accumulator for paths the input *navigated to* — including bare
+   * navigation that doesn't produce a CanonicalCommand. Surfaced via
+   * `ParseResult.mentions` and `extractMentions()`.
+   */
+  mentions: string[];
+}
+
+/**
+ * Resolve the absolute path for a token's `parentPath` argument when the
+ * parser is deciding whether the token is a verb. Mirrors the resolution
+ * `flushCommand` would do, *without* including the token itself.
+ */
+function resolveParentPath(
+  commandStartPath: string,
+  isAbsolute: boolean,
+  pathSegments: string[],
+): string {
+  let p = isAbsolute ? '/' : commandStartPath;
+  for (const seg of pathSegments) {
+    if (seg === '..') p = resolveParent(p);
+    else p = joinPath(p, seg);
+  }
+  return normalizePath(p);
+}
+
+/**
+ * Path-aware verb check. The curated universal verb set remains active even
+ * when a resolver is supplied because RouterOS introspection data does not
+ * necessarily enumerate helper verbs like `find` at every parent path.
+ * Resolver hits add path-specific verbs (for example, `info` at menus where
+ * it is actually a command).
+ */
+function isVerbAt(
+  token: string,
+  parentPath: string,
+  options: CanonicalizeOptions,
+): boolean {
+  return isKnownVerb(token) || options.isVerb?.(token, parentPath) === true;
 }
 
 /**
@@ -283,6 +381,10 @@ function parseCommands(ctx: ParseContext, stopAt?: Tok): string {
   let pathSegments: string[] = [];
   let isAbsolute = false;
   let verb = '';
+  // True when the verb was directly identified during Word handling (well-formed
+  // CLI). False when the verb is inferred from the trailing path segment in
+  // flushCommand — that path is prose-shaped / lower confidence.
+  let verbExplicit = false;
   let args: string[] = [];
   let inCommand = false; // true once we've seen at least one token in this command
   let inIce = false; // true if we're in an ICE command (: prefix)
@@ -303,25 +405,54 @@ function parseCommands(ctx: ParseContext, stopAt?: Tok): string {
     resolvedPath = normalizePath(resolvedPath);
 
     if (verb || args.length > 0 || pathSegments.length > 0) {
-      // If no explicit verb but we have path segments, the last segment might be a verb
+      // If no explicit verb but we have path segments, the last segment might
+      // be a verb. Use the resolver-aware check so path-specific verbs resolve
+      // when a resolver is wired, while staying conservative when not.
+      let verbInferred = false;
       if (!verb && pathSegments.length > 0) {
         const lastSeg = pathSegments[pathSegments.length - 1];
-        if (lastSeg !== '..' && isKnownVerb(lastSeg)) {
-          verb = lastSeg;
-          // Remove the verb from the resolved path
-          resolvedPath = resolveParent(resolvedPath);
+        if (lastSeg !== '..') {
+          const parentOfLast = resolveParent(resolvedPath);
+          if (isVerbAt(lastSeg, parentOfLast, ctx.options)) {
+            verb = lastSeg;
+            verbInferred = true;
+            // Remove the verb from the resolved path
+            resolvedPath = parentOfLast;
+          }
         }
       }
 
       if (verb || args.length > 0) {
+        // Confidence:
+        //  - 'low'    when the verb was inferred from a trailing path segment
+        //             at flush time (looser/prose-shaped input)
+        //  - 'high'   absolute path + directly-identified verb (well-formed)
+        //  - 'medium' everything else (relative-with-cwd, navigation, blocks)
+        let confidence: 'high' | 'medium' | 'low';
+        if (verbInferred) {
+          confidence = 'low';
+        } else if (isAbsolute && verbExplicit) {
+          confidence = 'high';
+        } else {
+          confidence = 'medium';
+        }
+
         ctx.commands.push({
           path: resolvedPath,
           verb,
           args: [...args],
           ...(ctx.subshell ? { subshell: true } : {}),
+          confidence,
         });
       }
 
+      // Track every path the input mentions, even when no command is emitted
+      // (pure navigation like `/ip/firewall/filter`). Surfaced via
+      // ParseResult.mentions and extractMentions().
+      if (pathSegments.length > 0 || isAbsolute) {
+        ctx.mentions.push(resolvedPath);
+      }
+
       // After a command with a verb, path does NOT change for next command in same scope
       // Only bare navigation (path without verb) changes the cwd
       if (!verb && pathSegments.length > 0) {
@@ -340,6 +471,7 @@ function parseCommands(ctx: ParseContext, stopAt?: Tok): string {
     pathSegments = [];
     isAbsolute = false;
     verb = '';
+    verbExplicit = false;
     args = [];
     inCommand = false;
     inIce = false;
@@ -429,6 +561,8 @@ function parseCommands(ctx: ParseContext, stopAt?: Tok): string {
           cwd: subshellCwd,
           commands: ctx.commands,
           subshell: true,
+          options: ctx.options,
+          mentions: ctx.mentions,
         };
         parseCommands(subCtx, Tok.RBracket);
         ctx.pos = subCtx.pos;
@@ -466,6 +600,8 @@ function parseCommands(ctx: ParseContext, stopAt?: Tok): string {
           cwd: blockPath,
           commands: ctx.commands,
           subshell: ctx.subshell,
+          options: ctx.options,
+          mentions: ctx.mentions,
         };
         parseCommands(blockCtx, Tok.RBrace);
         ctx.pos = blockCtx.pos;
@@ -507,10 +643,17 @@ function parseCommands(ctx: ParseContext, stopAt?: Tok): string {
 
         // Is this a known verb?
         // Recognized when we have a path prefix (explicit segments or absolute /),
-        // OR when cwd is non-root (e.g., inside a subshell or script context)
-        if (!verb && isKnownVerb(w) && (pathSegments.length > 0 || isAbsolute || commandStartPath !== '/')) {
-          verb = w;
-          break;
+        // OR when cwd is non-root (e.g., inside a subshell or script context).
+        // Path-aware: consults the optional resolver against the parent path of
+        // segments seen so far (without `w`), so menu-specific commands and
+        // same-named directories disambiguate correctly when a resolver is wired.
+        if (!verb && (pathSegments.length > 0 || isAbsolute || commandStartPath !== '/')) {
+          const parentPath = resolveParentPath(commandStartPath, isAbsolute, pathSegments);
+          if (isVerbAt(w, parentPath, ctx.options)) {
+            verb = w;
+            verbExplicit = true;
+            break;
+          }
         }
 
         // Is this an unnamed param (starts with * for item ID, or is a value after a verb)?
@@ -581,7 +724,11 @@ function parseCommands(ctx: ParseContext, stopAt?: Tok): string {
  * // ], finalPath: '/ip/address' }
  * ```
  */
-export function canonicalize(input: string, cwd = '/'): ParseResult {
+export function canonicalize(
+  input: string,
+  cwd = '/',
+  options: CanonicalizeOptions = {},
+): ParseResult {
   const tokens = tokenize(input);
   const ctx: ParseContext = {
     tokens,
@@ -589,18 +736,40 @@ export function canonicalize(input: string, cwd = '/'): ParseResult {
     cwd: normalizePath(cwd),
     commands: [],
     subshell: false,
+    options,
+    mentions: [],
   };
   const finalPath = parseCommands(ctx);
-  return { commands: ctx.commands, finalPath: normalizePath(finalPath) };
+  // Dedupe mentions in order of first appearance
+  const seenMentions = new Set<string>();
+  const mentions: string[] = [];
+  for (const m of ctx.mentions) {
+    if (!seenMentions.has(m)) {
+      seenMentions.add(m);
+      mentions.push(m);
+    }
+  }
+  return {
+    commands: ctx.commands,
+    mentions,
+    finalPath: normalizePath(finalPath),
+  };
 }
 
 /**
  * Convenience: extract just the canonical paths from an input.
  * Returns unique paths in order of first appearance.
  * Useful for "what commands does this script reference?" queries.
+ *
+ * Only includes paths attached to a verb. For navigation-only mentions
+ * (e.g. bare `/ip/firewall/filter`), use {@link extractMentions}.
  */
-export function extractPaths(input: string, cwd = '/'): string[] {
-  const { commands } = canonicalize(input, cwd);
+export function extractPaths(
+  input: string,
+  cwd = '/',
+  options: CanonicalizeOptions = {},
+): string[] {
+  const { commands } = canonicalize(input, cwd, options);
   const seen = new Set<string>();
   const paths: string[] = [];
   for (const cmd of commands) {
@@ -614,12 +783,63 @@ export function extractPaths(input: string, cwd = '/'): string[] {
   return paths;
 }
 
+/**
+ * "What does this text reference?" — every distinct RouterOS path the input
+ * mentions, including bare navigation with no verb (e.g. `/ip/firewall/filter`
+ * sitting alone in prose). Superset of {@link extractPaths}.
+ *
+ * Useful for the rosetta classifier, LSP document-link providers, and
+ * MCP context feeders that want to surface every path the user gestured at,
+ * not just well-formed CLI commands.
+ *
+ * @example
+ * ```ts
+ * extractMentions('/ip/firewall/filter ; /ip/firewall/nat')
+ * // => ['/ip/firewall/filter', '/ip/firewall/nat']
+ * ```
+ */
+export function extractMentions(
+  input: string,
+  cwd = '/',
+  options: CanonicalizeOptions = {},
+): string[] {
+  const { commands, mentions } = canonicalize(input, cwd, options);
+  const seen = new Set<string>();
+  const out: string[] = [];
+  // Verbed paths first (commands carry richer signal), then bare mentions.
+  for (const cmd of commands) {
+    const full = cmd.verb ? `${cmd.path}/${cmd.verb}` : cmd.path;
+    const normalized = normalizePath(full);
+    if (!seen.has(normalized)) {
+      seen.add(normalized);
+      out.push(normalized);
+    }
+    // Also surface the dir path itself (not just path/verb) so
+    // /ip/firewall/filter/print also mentions /ip/firewall/filter.
+    if (cmd.verb && !seen.has(cmd.path)) {
+      seen.add(cmd.path);
+      out.push(cmd.path);
+    }
+  }
+  for (const m of mentions) {
+    if (!seen.has(m)) {
+      seen.add(m);
+      out.push(m);
+    }
+  }
+  return out;
+}
+
 /**
  * Convenience: extract the primary command path (the first non-subshell command).
  * Useful for quick lookup: "what's the main path this user is asking about?"
  */
-export function primaryPath(input: string, cwd = '/'): string | null {
-  const { commands } = canonicalize(input, cwd);
+export function primaryPath(
+  input: string,
+  cwd = '/',
+  options: CanonicalizeOptions = {},
+): string | null {
+  const { commands } = canonicalize(input, cwd, options);
   const primary = commands.find(c => !c.subshell) ?? commands[0];
   if (!primary) return null;
   return normalizePath(primary.path);

package/src/classify.test.ts

@@ -13,6 +13,7 @@ type Expectation = {
   topics?: string[];        // must be a subset of detected topics (order-insensitive)
   topicsExact?: string[];   // exact match on detected topics (order-sensitive)
   command_path?: string;
+  command_path_confidence?: "high" | "medium" | "low";
   fragment_pairs?: Array<{ key: string; value: string }>;
   fragment_verbs?: string[];
   device?: string;
@@ -57,17 +58,27 @@ const CASES: Array<{ name: string; input: string; expect: Expectation }> = [
   {
     name: "absolute slash path",
     input: "/ip/firewall/filter",
-    expect: { command_path: "/ip/firewall/filter", topics: ["ip", "firewall", "filter"] },
+    expect: { command_path: "/ip/firewall/filter", command_path_confidence: "medium", topics: ["ip", "firewall", "filter"] },
   },
   {
     name: "space-separated absolute path",
     input: "/ip firewall filter",
-    expect: { command_path: "/ip/firewall/filter" },
+    expect: { command_path: "/ip/firewall/filter", command_path_confidence: "medium" },
   },
   {
     name: "path without leading slash",
     input: "ip firewall filter",
-    expect: { command_path: "/ip/firewall/filter" },
+    expect: { command_path: "/ip/firewall/filter", command_path_confidence: "medium" },
+  },
+  {
+    name: "absolute path with explicit verb has high confidence",
+    input: "/ip firewall filter add chain=forward",
+    expect: {
+      command_path: "/ip/firewall/filter",
+      command_path_confidence: "high",
+      fragment_pairs: [{ key: "chain", value: "forward" }],
+      fragment_verbs: ["add"],
+    },
   },
   {
     name: "system scheduler path",
@@ -142,6 +153,7 @@ describe("classifyQuery", () => {
       if (want.none) {
         expect(result.version).toBeUndefined();
         expect(result.command_path).toBeUndefined();
+        expect(result.command_path_confidence).toBeUndefined();
         expect(result.command_fragment).toBeUndefined();
         expect(result.device).toBeUndefined();
         expect(result.property).toBeUndefined();
@@ -151,6 +163,7 @@ describe("classifyQuery", () => {
 
       if (want.version !== undefined) expect(result.version).toBe(want.version);
       if (want.command_path !== undefined) expect(result.command_path).toBe(want.command_path);
+      if (want.command_path_confidence !== undefined) expect(result.command_path_confidence).toBe(want.command_path_confidence);
       if (want.device !== undefined) expect(result.device).toBe(want.device);
       if (want.property !== undefined) expect(result.property).toBe(want.property);
 

package/src/classify.ts

@@ -13,7 +13,7 @@
  * See DESIGN.md "North Star Architecture — Unified routeros_search".
  */
 
-import { canonicalize } from "./canonicalize.ts";
+import { type CanonicalCommand, type CanonicalizeOptions, canonicalize } from "./canonicalize.ts";
 
 /**
  * Known RouterOS topics — extracted from changelog categories, top-level
@@ -65,6 +65,8 @@ export type CommandFragment = {
   verbs: string[];
 };
 
+export type CommandPathConfidence = CanonicalCommand["confidence"];
+
 export type QueryClassification = {
   /** Raw input (unchanged). */
   input: string;
@@ -74,6 +76,8 @@ export type QueryClassification = {
   topics: string[];
   /** Canonical command path (e.g. `/ip/firewall/filter`) if the input looks path-ish. */
   command_path?: string;
+  /** Confidence reported by canonicalize for `command_path`; pure navigation is `medium`. */
+  command_path_confidence?: CommandPathConfidence;
   /** `key=value` pairs / verbs parsed from fragment-style input (`add chain=forward`). */
   command_fragment?: CommandFragment;
   /** Device model candidate (e.g. `RB1100AHx4`, `hAP`, `CCR2216`). DB resolution happens in searchAll. */
@@ -137,8 +141,13 @@ function detectVersion(input: string): string | undefined {
   return m ? m[0] : undefined;
 }
 
-/** Detect command path. Uses canonicalize.primaryPath for robust handling of `/ip address`, `ip/address`, etc. */
-function detectCommandPath(input: string): string | undefined {
+type CommandPathDetection = {
+  path: string;
+  confidence: CommandPathConfidence;
+};
+
+/** Detect command path. Uses canonicalize for robust handling of `/ip address`, `ip/address`, etc. */
+function detectCommandPath(input: string, options: CanonicalizeOptions): CommandPathDetection | undefined {
   // Heuristic: only run the canonicalizer if the input contains a forward slash
   // OR starts with a known top-level command word. Otherwise every "routing"
   // query would be classified as a command path.
@@ -151,11 +160,14 @@ function detectCommandPath(input: string): string | undefined {
   try {
     // Prefer the parsed command's dir path if a verb was recognized; otherwise
     // fall back to finalPath (pure navigation like `/ip/firewall/filter`).
-    const { commands, finalPath } = canonicalize(trimmed, "/");
+    const { commands, finalPath } = canonicalize(trimmed, "/", options);
     const primary = commands.find((c) => !c.subshell) ?? commands[0];
     const path = primary?.path ?? finalPath;
     if (!path || path === "/") return undefined;
-    return path;
+    return {
+      path,
+      confidence: primary?.confidence ?? "medium",
+    };
   } catch {
     return undefined;
   }
@@ -219,11 +231,23 @@ function detectProperty(
   return trimmed.toLowerCase();
 }
 
+/**
+ * Options for {@link classifyQuery}. Currently a thin pass-through to
+ * {@link CanonicalizeOptions}; rosetta's `searchAll()` wires a DB-backed
+ * `isVerb` resolver so `/log/info` and `/system/script/run` classify as
+ * commands instead of falling back to bare navigation. Kept generic so
+ * non-DB callers (TUI in offline mode, tests) work without a resolver.
+ */
+export interface ClassifyOptions {
+  /** See {@link CanonicalizeOptions.isVerb}. */
+  isVerb?: CanonicalizeOptions["isVerb"];
+}
+
 /**
  * Classify a user query. Detectors run independently; return object lists every
  * signal found so `searchAll()` can route parallel side queries.
  */
-export function classifyQuery(input: string): QueryClassification {
+export function classifyQuery(input: string, options: ClassifyOptions = {}): QueryClassification {
   const normalized = input ?? "";
   const result: QueryClassification = {
     input: normalized,
@@ -235,8 +259,12 @@ export function classifyQuery(input: string): QueryClassification {
   const version = detectVersion(normalized);
   if (version) result.version = version;
 
-  const commandPath = detectCommandPath(normalized);
-  if (commandPath) result.command_path = commandPath;
+  const canonOptions: CanonicalizeOptions = options.isVerb ? { isVerb: options.isVerb } : {};
+  const commandPath = detectCommandPath(normalized, canonOptions);
+  if (commandPath) {
+    result.command_path = commandPath.path;
+    result.command_path_confidence = commandPath.confidence;
+  }
 
   const fragment = detectCommandFragment(normalized);
   if (fragment) result.command_fragment = fragment;

package/src/extract-videos.ts

@@ -148,9 +148,51 @@ function checkYtDlp(ytdlp = YTDLP_DEFAULT): boolean {
 // ── VTT parsing ──
 
 const VTT_TIMESTAMP_RE = /^(\d{2}):(\d{2}):(\d{2})\.(\d{3}) --> /;
-const HTML_TAG_RE = /<[^>]+>/g;
 // Inline timestamp tags like <00:00:01.234>
 const INLINE_TS_RE = /<\d{2}:\d{2}:\d{2}\.\d{3}>/g;
+const VTT_CUE_TAG_RE =
+  /^<\/?(?:b|i|u|ruby|rt|c(?:\.[A-Za-z0-9_-]+)*|v(?:\s+[^<>]+)?|lang(?:\s+[A-Za-z0-9_-]+)?)>/;
+
+function stripHtmlLikeMarkup(input: string): string {
+  let output = "";
+  let i = 0;
+
+  while (i < input.length) {
+    const char = input[i];
+
+    if (char === "<") {
+      const validCueTag = input.slice(i).match(VTT_CUE_TAG_RE);
+      if (validCueTag) {
+        i += validCueTag[0].length;
+        continue;
+      }
+
+      let j = i + 1;
+      let lastClose = -1;
+      while (j < input.length) {
+        if (input[j] === ">") lastClose = j;
+        if (lastClose !== -1 && /\s/.test(input[j])) break;
+        j++;
+      }
+
+      if (lastClose > i && lastClose + 1 < j) {
+        output += input.slice(lastClose + 1, j).replace(/[<>]/g, "");
+      }
+      i = j;
+      continue;
+    }
+
+    if (char === ">") {
+      i++;
+      continue;
+    }
+
+    output += char;
+    i++;
+  }
+
+  return output;
+}
 
 function vttTimestampToSeconds(text: string): number {
   const m = text.match(VTT_TIMESTAMP_RE);
@@ -175,8 +217,8 @@ export function parseVtt(vttText: string): VttCue[] {
     if (currentLines.length === 0) return;
     const raw = currentLines.join(" ").trim();
     if (!raw) return;
-    // Strip HTML tags and inline timestamp tags
-    const clean = raw.replace(INLINE_TS_RE, "").replace(HTML_TAG_RE, "").replace(/\s+/g, " ").trim();
+    // Strip inline timestamp tags and HTML-shaped cue markup.
+    const clean = stripHtmlLikeMarkup(raw.replace(INLINE_TS_RE, "")).replace(/\s+/g, " ").trim();
     if (!clean) return;
     // Deduplicate: skip if clean text is a suffix of what we've already emitted
     if (prevAccumulated.endsWith(clean)) return;
@@ -186,7 +228,7 @@ export function parseVtt(vttText: string): VttCue[] {
   }
 
   for (const rawLine of lines) {
-    const line = rawLine.replace(/\r/, "");
+    const line = rawLine.replace(/\r/g, "");
 
     if (line.startsWith("WEBVTT") || line.startsWith("Kind:") || line.startsWith("Language:")) {
       inCueText = false;