@ai-react-markdown/engine 2.4.3 → 2.4.5

package/dist/index.d.cts

@@ -425,6 +425,49 @@ interface FreezeScanCheckpoint {
      *  tagBalance but not yet confirmed by a later `>` — reverted at the next
      *  blank line (a tag cannot span one). See TRUNCATED_TAG_RE. */
     pendingTruncatedTags: string[];
+    /** Line-truncated CLOSING tags (`</div` + EOL, no `>`) inside an html-flow
+     *  run, waiting for a `>` on a later line of the same run. Unlike opens
+     *  they are NOT counted up front: a close tag cannot carry attributes, so
+     *  `para </style` (prose to micromark, still-open element to parse5 —
+     *  RAWTEXT waits for the `>`) must not zero the balance (2026-08-19
+     *  review P1 — the boundary crossed an open `<style>`). Confirmed and
+     *  applied only when a later line of the run brings the `>` (parse5
+     *  completes the end tag; micromark's block ends at the blank anyway);
+     *  dropped unapplied at the blank (element stays counted — over-block).
+     *  Paragraph-context truncated closes are never pended: a `>` at block
+     *  indent on the next line is a blockquote to micromark, and the one
+     *  shape that would complete the inline close (`</b\n    >`, a 4+-space
+     *  lazy continuation) is not modelled — the element stays counted,
+     *  over-block. */
+    pendingTruncatedCloses: string[];
+    /** An html-flow line ended inside a tag (`<div`, `</div`, `<br` — open,
+     *  close or void, with or without attributes): parse5's tokenizer is
+     *  still in that tag, so on the following lines everything up to the
+     *  FIRST `>` is attribute garbage — `</div>` there does NOT close
+     *  anything (oracle review of 2.4.4: `<div>\n<div>\n</div\n</div>` froze
+     *  past the still-open outer div; pre-existing, 1-char slices). While
+     *  set: a line without `>` gets no tag scan at all; the line with the
+     *  `>` completes the pending close (if any), then only its text after
+     *  that `>` is scanned. Cleared there and at the blank line. */
+    tagAcrossLines: boolean;
+    /** Indent of the line that set `tagAcrossLines`. A following line that
+     *  DE-INDENTS below it may have left the container (a list item's html
+     *  block ends there; hast-util-raw resets the tokenizer at the li/ul
+     *  boundary, so a `<div>` on that line is a real start tag, not garbage)
+     *  — or may still be the same html block (root-level `  </div\n</div>`,
+     *  still garbage). Unknowable here → poison (oracle 3rd pass). */
+    tagAcrossLinesIndent: number;
+    /** The html-flow run since the last blank REALLY started as a micromark
+     *  html block (type 6 / type 1 / a paragraph-not-interrupting type 7) —
+     *  as opposed to `htmlFlowSinceBlank`, which any `<tag` / `</tag` line
+     *  start sets (over-approximation, fine for its over-blocking uses). Only
+     *  in a real run are the bytes raw to parse5 across line endings; the
+     *  cross-line-tag garbage model (`tagAcrossLines`, pended closes) is
+     *  gated on it — in a paragraph starting `</i` the next line's `<div>` /
+     *  `<!--` are REAL blocks (oracle re-check of 2.4.4: gating on
+     *  htmlFlowSinceBlank swallowed them — a new under-block). Sticky to the
+     *  blank; a type 6/1 start on a later line of a non-real run promotes it. */
+    htmlFlowReal: boolean;
 }
 declare function computeFreezeBoundary(text: string, options: FreezeBoundaryOptions, resume?: FreezeScanCheckpoint | null): FreezeScanResult;
 
@@ -1902,6 +1945,20 @@ declare function preprocessLaTeX(str: string): string;
  */
 declare function createIncrementalLatexPreprocessor(options?: {
     freezeThreshold?: number;
+    /** Failure backoff (default on). Tests that rely on `freezeThreshold: 0`
+     *  to attempt a freeze on EVERY call turn it off, so 1-char chunkings keep
+     *  exercising the cut rules instead of skipping most attempts; backoff
+     *  can only freeze LESS, so passing without it implies passing with it.
+     *  @internal */
+    backoff?: boolean;
+    /** Test hook: called once per freeze ATTEMPT (a scan of the active
+     *  region) with the region's length and how many source bytes the
+     *  attempt froze (0 = failed), so the backoff bound and freeze progress
+     *  can be pinned. @internal */
+    onAttempt?: (info: {
+        activeLength: number;
+        frozenBytes: number;
+    }) => void;
 }): (content: string) => string;
 
 /**

package/dist/index.d.ts

@@ -425,6 +425,49 @@ interface FreezeScanCheckpoint {
      *  tagBalance but not yet confirmed by a later `>` — reverted at the next
      *  blank line (a tag cannot span one). See TRUNCATED_TAG_RE. */
     pendingTruncatedTags: string[];
+    /** Line-truncated CLOSING tags (`</div` + EOL, no `>`) inside an html-flow
+     *  run, waiting for a `>` on a later line of the same run. Unlike opens
+     *  they are NOT counted up front: a close tag cannot carry attributes, so
+     *  `para </style` (prose to micromark, still-open element to parse5 —
+     *  RAWTEXT waits for the `>`) must not zero the balance (2026-08-19
+     *  review P1 — the boundary crossed an open `<style>`). Confirmed and
+     *  applied only when a later line of the run brings the `>` (parse5
+     *  completes the end tag; micromark's block ends at the blank anyway);
+     *  dropped unapplied at the blank (element stays counted — over-block).
+     *  Paragraph-context truncated closes are never pended: a `>` at block
+     *  indent on the next line is a blockquote to micromark, and the one
+     *  shape that would complete the inline close (`</b\n    >`, a 4+-space
+     *  lazy continuation) is not modelled — the element stays counted,
+     *  over-block. */
+    pendingTruncatedCloses: string[];
+    /** An html-flow line ended inside a tag (`<div`, `</div`, `<br` — open,
+     *  close or void, with or without attributes): parse5's tokenizer is
+     *  still in that tag, so on the following lines everything up to the
+     *  FIRST `>` is attribute garbage — `</div>` there does NOT close
+     *  anything (oracle review of 2.4.4: `<div>\n<div>\n</div\n</div>` froze
+     *  past the still-open outer div; pre-existing, 1-char slices). While
+     *  set: a line without `>` gets no tag scan at all; the line with the
+     *  `>` completes the pending close (if any), then only its text after
+     *  that `>` is scanned. Cleared there and at the blank line. */
+    tagAcrossLines: boolean;
+    /** Indent of the line that set `tagAcrossLines`. A following line that
+     *  DE-INDENTS below it may have left the container (a list item's html
+     *  block ends there; hast-util-raw resets the tokenizer at the li/ul
+     *  boundary, so a `<div>` on that line is a real start tag, not garbage)
+     *  — or may still be the same html block (root-level `  </div\n</div>`,
+     *  still garbage). Unknowable here → poison (oracle 3rd pass). */
+    tagAcrossLinesIndent: number;
+    /** The html-flow run since the last blank REALLY started as a micromark
+     *  html block (type 6 / type 1 / a paragraph-not-interrupting type 7) —
+     *  as opposed to `htmlFlowSinceBlank`, which any `<tag` / `</tag` line
+     *  start sets (over-approximation, fine for its over-blocking uses). Only
+     *  in a real run are the bytes raw to parse5 across line endings; the
+     *  cross-line-tag garbage model (`tagAcrossLines`, pended closes) is
+     *  gated on it — in a paragraph starting `</i` the next line's `<div>` /
+     *  `<!--` are REAL blocks (oracle re-check of 2.4.4: gating on
+     *  htmlFlowSinceBlank swallowed them — a new under-block). Sticky to the
+     *  blank; a type 6/1 start on a later line of a non-real run promotes it. */
+    htmlFlowReal: boolean;
 }
 declare function computeFreezeBoundary(text: string, options: FreezeBoundaryOptions, resume?: FreezeScanCheckpoint | null): FreezeScanResult;
 
@@ -1902,6 +1945,20 @@ declare function preprocessLaTeX(str: string): string;
  */
 declare function createIncrementalLatexPreprocessor(options?: {
     freezeThreshold?: number;
+    /** Failure backoff (default on). Tests that rely on `freezeThreshold: 0`
+     *  to attempt a freeze on EVERY call turn it off, so 1-char chunkings keep
+     *  exercising the cut rules instead of skipping most attempts; backoff
+     *  can only freeze LESS, so passing without it implies passing with it.
+     *  @internal */
+    backoff?: boolean;
+    /** Test hook: called once per freeze ATTEMPT (a scan of the active
+     *  region) with the region's length and how many source bytes the
+     *  attempt froze (0 = failed), so the backoff bound and freeze progress
+     *  can be pinned. @internal */
+    onAttempt?: (info: {
+        activeLength: number;
+        frozenBytes: number;
+    }) => void;
 }): (content: string) => string;
 
 /**

package/dist/index.dev.cjs

@@ -269,6 +269,11 @@ var defaultUrlTransform = (value) => {
 var import_micromark_util_html_tag_name = require("micromark-util-html-tag-name");
 var import_micromark_util_normalize_identifier = require("micromark-util-normalize-identifier");
 var TYPE6_NAMES = new Set(import_micromark_util_html_tag_name.htmlBlockNames);
+var TABLE_PART_NAMES = /* @__PURE__ */ new Set(["td", "th", "tr", "tbody", "thead", "tfoot", "caption", "col", "colgroup"]);
+var TYPE1_NAMES = /* @__PURE__ */ new Set(["script", "pre", "style", "textarea"]);
+var TYPE6_START_RE = /^<\/?([A-Za-z][A-Za-z0-9-]*)(?:[ \t\r]|\/?>|$)/;
+var TYPE1_START_RE = /^<(script|pre|style|textarea)(?:[ \t\r]|>|$)/i;
+var TYPE7_LINE_RE = /^<(\/?)([A-Za-z][A-Za-z0-9-]*)(?:[ \t\r][^>]*|\/)?>[ \t\r]*$/;
 var VOID_TAGS = /* @__PURE__ */ new Set([
   "area",
   "base",
@@ -407,7 +412,11 @@ function freshCheckpoint(defListEnabled, mathFlow, referenceTaint) {
     htmlFlowSinceBlank: false,
     htmlSeamPending: false,
     phasePoisonedAt: Infinity,
-    pendingTruncatedTags: []
+    pendingTruncatedTags: [],
+    pendingTruncatedCloses: [],
+    tagAcrossLines: false,
+    tagAcrossLinesIndent: 0,
+    htmlFlowReal: false
   };
 }
 function isPlausibleLinkDefRest(rest) {
@@ -704,6 +713,8 @@ function processConfirmedLine(cp, ln, text) {
       for (const tag of cp.pendingTruncatedTags) applyTag(tag, true);
       cp.pendingTruncatedTags = [];
     }
+    cp.pendingTruncatedCloses = [];
+    cp.tagAcrossLines = false;
     cp.blankRun += 1;
     cp.lastBlankStart = ln.start;
     cp.candidates.push({
@@ -717,6 +728,7 @@ function processConfirmedLine(cp, ln, text) {
     cp.paragraphHasUnpairedRun = false;
     cp.openBracket = null;
     cp.htmlFlowSinceBlank = false;
+    cp.htmlFlowReal = false;
     cp.prevLineBlank = true;
     cp.prevLineWasText = false;
     cp.prevLineWasValidDef = false;
@@ -732,6 +744,16 @@ function processConfirmedLine(cp, ln, text) {
   if (tagStart) {
     cp.htmlFlowSinceBlank = true;
     if (!TYPE6_NAMES.has(tagStart[1].toLowerCase())) cp.hazardVerdict = true;
+    if (!cp.htmlFlowReal) {
+      const t = mdTrimStart(ln.text);
+      const t6 = TYPE6_START_RE.exec(t);
+      const t7 = TYPE7_LINE_RE.exec(t);
+      if (t6 !== null && TYPE6_NAMES.has(t6[1].toLowerCase()) || TYPE1_START_RE.test(t) || // Type 7 cannot interrupt a paragraph, and excludes the raw-text
+      // names (those are type 1 as start tags, paragraph as end tags).
+      t7 !== null && !cp.prevLineWasText && !TYPE1_NAMES.has(t7[2].toLowerCase())) {
+        cp.htmlFlowReal = true;
+      }
+    }
   }
   const inRawText = cp.htmlFlowSinceBlank || rawOpenAtLineStart;
   const rawFlowStart = ln.indent <= 3 && /^<(?:!--|\?|![A-Za-z]|!\[CDATA\[)/.test(mdTrimStart(ln.text));
@@ -872,7 +894,21 @@ ${cont(scanText)}` };
   for (const [from, to] of rawSpans) {
     tagText = tagText.slice(0, from) + " ".repeat(to - from) + tagText.slice(to);
   }
-  {
+  let skipTagScan = false;
+  if (cp.tagAcrossLines) {
+    if (ln.indent < cp.tagAcrossLinesIndent) poisonRawDivergence();
+    const gt = ln.text.indexOf(">");
+    if (gt === -1) {
+      skipTagScan = true;
+    } else {
+      if (/["']/.test(ln.text.slice(0, gt))) poisonRawDivergence();
+      for (const tag of cp.pendingTruncatedCloses) applyTag(tag, true);
+      cp.pendingTruncatedCloses = [];
+      cp.tagAcrossLines = false;
+      tagText = " ".repeat(gt + 1) + tagText.slice(gt + 1);
+    }
+  }
+  if (!skipTagScan) {
     TAG_OR_COMMENT_RE.lastIndex = 0;
     let m;
     let lastCommentOpenerIdx = -1;
@@ -902,6 +938,7 @@ ${cont(scanText)}` };
       if (cp.commentOpen) continue;
       const closing = m[1] === "/";
       const tag = m[2].toLowerCase();
+      if (TABLE_PART_NAMES.has(tag)) cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start + m.index);
       const selfClosing = m[3] !== void 0 && /\/\s*$/.test(m[3]);
       if (VOID_TAGS.has(tag) || selfClosing) continue;
       applyTag(tag, closing);
@@ -922,6 +959,7 @@ ${cont(scanText)}` };
         if (startMasked || wholeVisible || inRaw(mr.index) || cp.commentOpen) continue;
         const closing = mr[1] === "/";
         const tag = mr[2].toLowerCase();
+        if (TABLE_PART_NAMES.has(tag)) cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start + mr.index);
         const selfClosing = mr[3] !== void 0 && /\/\s*$/.test(mr[3]);
         if (VOID_TAGS.has(tag) || selfClosing) continue;
         applyTag(tag, closing);
@@ -937,7 +975,14 @@ ${cont(scanText)}` };
         if (m2) {
           const closing = m2[1] === "/";
           const tag = m2[2].toLowerCase();
-          if (!VOID_TAGS.has(tag)) {
+          if (TABLE_PART_NAMES.has(tag)) cp.phasePoisonedAt = Math.min(cp.phasePoisonedAt, ln.start + lastLt);
+          if (cp.htmlFlowReal) {
+            cp.tagAcrossLines = true;
+            cp.tagAcrossLinesIndent = ln.indent;
+          }
+          if (closing) {
+            if (!VOID_TAGS.has(tag) && cp.htmlFlowReal) cp.pendingTruncatedCloses.push(tag);
+          } else if (!VOID_TAGS.has(tag)) {
             applyTag(tag, closing);
             const rawLastLt = ln.text.lastIndexOf("<");
             const rawTruncated = rawLastLt !== -1 && !ln.text.includes(">", rawLastLt);
@@ -1480,6 +1525,9 @@ function countTrailingNewlines(value) {
 function countNewlines(text, end = text.length) {
   let count = 0;
   for (let i = text.indexOf("\n"); i !== -1 && i < end; i = text.indexOf("\n", i + 1)) count += 1;
+  for (let i = text.indexOf("\r"); i !== -1 && i < end; i = text.indexOf("\r", i + 1)) {
+    if (text.charCodeAt(i + 1) !== 10) count += 1;
+  }
   return count;
 }
 
@@ -1599,7 +1647,7 @@ function normalizeId(s) {
   return (0, import_micromark_util_normalize_identifier3.normalizeIdentifier)(s);
 }
 function normalizeForMatch(s) {
-  return (0, import_micromark_util_normalize_identifier3.normalizeIdentifier)(s.replace(/\\(.)/g, "$1"));
+  return (0, import_micromark_util_normalize_identifier3.normalizeIdentifier)(s.replace(/\\([!-/:-@[-`{-~])/g, "$1"));
 }
 
 // src/components/collectDefLabels.ts
@@ -4037,10 +4085,16 @@ function lineIndentBefore(content, pos) {
 function findClosingBacktickRun(content, start, n) {
   let i = start;
   while (i < content.length) {
-    if (content[i] === "`") {
+    const ch = content[i];
+    if (ch === "`") {
       const runLen = getRepeatedMarkerLength(content, i, "`");
       if (runLen === n) return i;
       i += runLen;
+    } else if (ch === "\n") {
+      let j = i + 1;
+      while (j < content.length && (content[j] === " " || content[j] === "	" || content[j] === "\r")) j += 1;
+      if (j >= content.length || content[j] === "\n") return -1;
+      i += 1;
     } else {
       i += 1;
     }
@@ -4162,16 +4216,20 @@ function escapeCurrencyDollarSigns(text) {
       currentLineProcessed += segment;
     }
     let needEscape = true;
-    let restBeforeNextMatchOrEnd = "";
-    if (i < currencyMatches.length - 1) {
-      const nextMatch = currencyMatches[i + 1];
-      if (nextMatch.index - match.index > 1) {
-        restBeforeNextMatchOrEnd = text.substring(match.index + 1, nextMatch.index);
+    const restStart = match.index + 1;
+    const restEnd = i < currencyMatches.length - 1 ? currencyMatches[i + 1].index : text.length;
+    let firstLineBeforeNextMatch = "";
+    if (restEnd - restStart > 0) {
+      let eol = restEnd;
+      for (let k = restStart; k < restEnd; k++) {
+        const c = text.charCodeAt(k);
+        if (c === 10 || c === 13) {
+          eol = k;
+          break;
+        }
       }
-    } else {
-      restBeforeNextMatchOrEnd = text.substring(match.index + 1);
+      firstLineBeforeNextMatch = text.substring(restStart, eol);
     }
-    const firstLineBeforeNextMatch = restBeforeNextMatchOrEnd.split(/\r\n|\r|\n/g)[0];
     if (Array.from(firstLineBeforeNextMatch.matchAll(NO_ESCAPED_DOLLAR_REGEX)).length % 2 !== 0) {
       const wholeLineBeforeNextMatchWithoutCurrentDollar = currentLineProcessed + firstLineBeforeNextMatch;
       if (Array.from(wholeLineBeforeNextMatchWithoutCurrentDollar.matchAll(NO_ESCAPED_DOLLAR_REGEX)).length % 2 !== 0) {
@@ -4337,39 +4395,49 @@ function hasUnclosedTextCommand(text) {
   return false;
 }
 var RESIDUAL_OPEN_BRACKET_RE = /(?<!!)\\\[/;
-function processSliceInstrumented(slice) {
+var LEADING_DOUBLE_DOLLAR_RE = /^\s*\$\$/;
+function processSliceInstrumented(slice, probe = true) {
   const segments = splitByProtectedRegions(slice);
-  let out = "";
+  const parts = [];
   let quiescent = true;
   let truncatedAtSeamStart = false;
   for (let index = 0; index < segments.length; index++) {
     const segment = segments[index];
     if (segment.isCode) {
-      out += segment.text;
+      parts.push(segment.text);
       continue;
     }
     let text = segment.text;
     text = escapeMhchemCommands(text);
     text = escapeCurrencyDollarSigns(text);
     text = convertLatexDelimiters(text);
-    if (RESIDUAL_OPEN_BRACKET_RE.test(text)) quiescent = false;
+    if (probe && RESIDUAL_OPEN_BRACKET_RE.test(text)) quiescent = false;
     text = escapeLatexPipes(text);
-    if (findUnclosedDelimiterStart(text, "both") !== -1) quiescent = false;
+    if (probe && findUnclosedDelimiterStart(text, "both") !== -1) quiescent = false;
     text = escapeLatexPipesInUnclosed(text);
-    if (hasUnclosedTextCommand(text)) quiescent = false;
+    if (probe && hasUnclosedTextCommand(text)) quiescent = false;
     text = escapeTextUnderscores(text);
     text = convertSingleToDoubleDollar(text);
-    const unclosedDouble = findUnclosedDelimiterStart(text, "double-only");
-    if (unclosedDouble !== -1) {
-      quiescent = false;
-      if (index === 0 && text.slice(0, unclosedDouble).trim() === "") {
-        truncatedAtSeamStart = true;
+    if (probe || index === 0 && LEADING_DOUBLE_DOLLAR_RE.test(text)) {
+      const unclosedDouble = findUnclosedDelimiterStart(text, "double-only");
+      if (unclosedDouble !== -1) {
+        quiescent = false;
+        if (index === 0 && text.slice(0, unclosedDouble).trim() === "") {
+          truncatedAtSeamStart = true;
+        }
       }
     }
     text = truncateUnclosedLatexBlock(text);
-    out += text;
+    parts.push(text);
   }
-  return { out, quiescent, truncatedAtSeamStart };
+  return { out: parts.join(""), quiescent, truncatedAtSeamStart };
+}
+function isBlankRawLine(text, from, to) {
+  for (let i = from; i < to; i++) {
+    const c = text.charCodeAt(i);
+    if (c !== 32 && c !== 9 && c !== 13) return false;
+  }
+  return true;
 }
 function findRawSafeCut(active) {
   const segments = splitByProtectedRegions(active);
@@ -4384,10 +4452,12 @@ function findRawSafeCut(active) {
       continue;
     }
     const text = segment.text;
+    let atLineStart = offset === 0 || active.charCodeAt(offset - 1) === 10;
     let lineStart = 0;
     while (lineStart <= text.length) {
       const nl = text.indexOf("\n", lineStart);
       const lineEnd = nl === -1 ? text.length : nl;
+      if (atLineStart && nl !== -1 && isBlankRawLine(text, lineStart, lineEnd)) backtickHazard = false;
       for (let i = lineStart; i < lineEnd; i++) {
         const ch = text[i];
         if (ch === "`") backtickHazard = true;
@@ -4400,6 +4470,7 @@ function findRawSafeCut(active) {
       if (nl === -1) break;
       if (!backtickHazard && !latentLt) lastCut = offset + nl + 1;
       lineStart = nl + 1;
+      atLineStart = true;
     }
     offset += text.length;
   }
@@ -4408,11 +4479,14 @@ function findRawSafeCut(active) {
 var DEFAULT_FREEZE_ATTEMPT_THRESHOLD = 512;
 function createIncrementalLatexPreprocessor(options) {
   const freezeThreshold = options?.freezeThreshold ?? DEFAULT_FREEZE_ATTEMPT_THRESHOLD;
+  const onAttempt = options?.onAttempt;
+  const backoff = options?.backoff ?? true;
   let prevSource = "";
   let prevOutput = "";
   let frozenSrcEnd = 0;
   let frozenOut = "";
   let triggered = false;
+  let nextAttemptLen = 0;
   return function incrementalPreprocessLaTeX(source) {
     if (source === prevSource) return prevOutput;
     const isAppend = source.length > prevSource.length && source.startsWith(prevSource);
@@ -4420,6 +4494,7 @@ function createIncrementalLatexPreprocessor(options) {
       frozenSrcEnd = 0;
       frozenOut = "";
       triggered = false;
+      nextAttemptLen = 0;
     }
     if (!triggered) {
       const checkFrom = isAppend ? Math.max(0, prevSource.length - 1) : 0;
@@ -4431,18 +4506,26 @@ function createIncrementalLatexPreprocessor(options) {
       triggered = true;
     }
     let active = source.slice(frozenSrcEnd);
-    if (active.length > freezeThreshold) {
+    if (active.length > freezeThreshold && active.length >= nextAttemptLen) {
+      const activeLength = active.length;
+      let advanced = false;
+      let frozenBytes = 0;
+      const freeze = (cut2, slice) => {
+        frozenOut += slice.out;
+        frozenSrcEnd += cut2;
+        active = source.slice(frozenSrcEnd);
+        advanced = true;
+        frozenBytes = cut2;
+      };
       const cut = findRawSafeCut(active);
       if (cut > 0) {
         const candidate = processSliceInstrumented(active.slice(0, cut));
-        if (candidate.quiescent) {
-          frozenOut += candidate.out;
-          frozenSrcEnd += cut;
-          active = source.slice(frozenSrcEnd);
-        }
+        if (candidate.quiescent) freeze(cut, candidate);
       }
+      nextAttemptLen = advanced || !backoff ? 0 : active.length * 2;
+      onAttempt?.({ activeLength, frozenBytes });
     }
-    const tail = processSliceInstrumented(active);
+    const tail = processSliceInstrumented(active, false);
     const head = tail.truncatedAtSeamStart ? frozenOut.replace(/\s+$/, "") : frozenOut;
     const out = head + tail.out;
     prevSource = source;