@ai-matrx/content-ir 0.18.3 → 0.18.5

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.18.5
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/content-ir-core/v0.18.4..npm/content-ir-core/v0.18.5 -- apps/shared/content-ir-core`).
+No source changes intended and no consumer action required.
+
+## 0.18.4
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/content-ir-core/v0.18.3..npm/content-ir-core/v0.18.4 -- apps/shared/content-ir-core`).
+No source changes intended and no consumer action required.
+
+## Unreleased
+
+**`/source`: THE escaped-bracket rule** (verify-RC-B4 R3-2). `\[ … \]` is a
+display-math island only when its content is real TeX — a command, `^ { } =
+< > +`, or a subscript on a letter — and the `\[` is not an index on an
+identifier. Everything else is CommonMark's escaped brackets and stays text:
+citations `\[1\]`, dates `\[2026-09-25\]`, task boxes `- \[x\]`, `arr\[i\]`,
+editorial `\[was\]`, placeholders `\[site name\]`. New export
+`isEscapedBracketMath(content, before)`; the tokenizer asks it. Shared vectors:
+`__tests__/fixtures/escaped-bracket-vectors.json` (7 of 11 red before).
+No Python reader draws `\[ \]` math today (matrx-ai has no bracket-math
+detector), so the vectors are the contract for any future twin.
+- Consumer action: the renderer's math normalizer and the editor ask
+  `isEscapedBracketMath` instead of their own bracket rules (matrx-frontend
+  `components/markdown-core/math-normalizer.ts`).
+
 ## 0.18.3
 
 Automatic changed-only republish (docs/metadata drift since the last tag — see

package/dist/index.cjs

@@ -5296,6 +5296,7 @@ var FenceReader = class {
 function closeFence(src, open, opener) {
   const first = readFence(src, open, new FenceReader(opener));
   if (first.closed || !first.reader.sawNested || first.reader.nestedDepth <= 0) return { line: first.line, closed: first.closed };
+  if (src.streaming) return { line: first.line, closed: false };
   const strict = readFence(src, open, new FenceReader(opener, { nesting: false }));
   return { line: strict.line, closed: strict.closed };
 }
@@ -5559,6 +5560,8 @@ function fenceLineKinds(text) {
 function pendingCodeSpanStart(text) {
   const n = text.length;
   if (n === 0 || /\n[ \t]*\n[ \t]*$/.test(text)) return -1;
+  const lastLine = text.slice(text.lastIndexOf("\n") + 1);
+  if (lastLine && /^(?: {0,3}>[ \t]?)*[ \t]*$/.test(lastLine)) return pendingCodeSpanStart(`${text}x`);
   const s = scan(text);
   const para = s.pendingPara;
   if (s.endsInFence || para === -1) return -1;
@@ -5705,13 +5708,26 @@ var MATH_SHAPE_CHARS = /^[A-Za-z0-9'\s(),.*\/-]+$/;
 function isSingleDollarMath(content, after) {
   if (!content || content.length > 400) return false;
   if (/^\s/.test(content) || /\s$/.test(content)) return false;
-  if (after !== void 0 && /[0-9]/.test(after)) return false;
+  if (after !== void 0 && /^[0-9]/.test(after)) return false;
+  if (isVariableChain(content, after)) return false;
   if (/(?:^|[^\\])%/.test(content)) return false;
   if (/^[)\]}"/]/.test(content) || /[(\[{":;,/]$/.test(content)) return false;
-  if (/^[0-9]/.test(content) && after !== void 0 && /[A-Za-z]/.test(after)) return false;
+  if (/^[0-9]/.test(content) && after !== void 0 && /^[A-Za-z]/.test(after)) return false;
   if (isMathPlaceholder(content)) return false;
   return TEX_SIGNAL.test(content) || !readsAsProse(content);
 }
+var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var MATH_SUFFIX = /^(?:s|es|th|st|nd|rd)$/i;
+function isVariableChain(content, after) {
+  if (/^\{[A-Za-z_][\w.]*\}$/.test(content)) return true;
+  if (!after) return false;
+  if (after[0] === "{") return IDENTIFIER.test(content);
+  const run = /^[A-Za-z0-9_]+/.exec(after)?.[0];
+  if (!run) return false;
+  if (after.length === 1) return false;
+  if (/^[A-Za-z_][A-Za-z0-9_]*[.@-]$/.test(content)) return true;
+  return IDENTIFIER.test(content) && !MATH_SUFFIX.test(run);
+}
 var FUNCTION_NAMES = /* @__PURE__ */ new Set([
   "sin",
   "cos",
@@ -5755,6 +5771,12 @@ function isMathShape(content) {
   if (/[A-Za-z]'+[A-Za-z]/.test(content) || /(?:^|[\s(,])[A-Za-z]\.(?:[A-Za-z]\.|\s|$)/.test(content)) return false;
   return /[A-Za-z]'*\(|[A-Za-z]'|\b[A-Za-z]\s+[A-Za-z]\b|\([^)]*[A-Za-z][^)]*\)/.test(content);
 }
+var AFTER_WINDOW = 32;
+function singleDollarAfter(text, close) {
+  const rest = text.slice(close + 1, close + 1 + AFTER_WINDOW);
+  return rest.length < AFTER_WINDOW ? `${rest}
+` : rest;
+}
 function singleDollarMathEnd(text, open, limit = text.length) {
   const bound = Math.min(limit, open + 403);
   let close = -1;
@@ -5772,7 +5794,13 @@ function singleDollarMathEnd(text, open, limit = text.length) {
   }
   if (close === -1 || text[close + 1] === "$") return -1;
   const content = text.slice(open + 1, close);
-  return isSingleDollarMath(content, text[close + 1]) ? close + 1 : -1;
+  return isSingleDollarMath(content, singleDollarAfter(text, close)) ? close + 1 : -1;
+}
+var BRACKET_TEX_SIGNAL = /\\[A-Za-z]+|[\^{}=<>+]|_\{|(?:^|[^A-Za-z0-9])[A-Za-z]_[A-Za-z0-9](?![A-Za-z0-9])/;
+function isEscapedBracketMath(content, before) {
+  if (!content.trim()) return false;
+  if (before !== void 0 && /[A-Za-z0-9_)\]]/.test(before)) return false;
+  return BRACKET_TEX_SIGNAL.test(content);
 }
 
 // source/xml-tag.ts
@@ -6137,18 +6165,14 @@ var Tokenizer = class {
   /**
    * Streaming: an open last line that begins with `{` is undecided — each new
    * byte can balance or unbalance its braces and flip the whole line between
-   * prose and a JSON island — and so is a line that is exactly one allowed
-   * HTML tag so far; both are provisional until they end (G5).
+   * prose and a JSON island — so it is provisional until it ends (G5).
+   * (A lone HTML tag on that line is held by {@link holdUndecidedTail}.)
    */
   markOpenJsonTail() {
     const last = this.lineStarts.length - 1;
     if (!this.isOpenTail(last)) return;
-    const start = this.lineStarts[last];
-    const t = this.lineText(last).trim();
-    const oneTag = t.startsWith("<") ? readXmlTag(t, 0) : null;
-    const loneTag = !!oneTag && oneTag.raw === t && ALLOWED_RAW_HTML_TAGS.has(oneTag.tagName.toLowerCase());
-    if (t.startsWith("{") || loneTag) {
-      this.provisionalFrom = Math.min(this.provisionalFrom, start);
+    if (this.lineText(last).trim().startsWith("{")) {
+      this.provisionalFrom = Math.min(this.provisionalFrom, this.lineStarts[last]);
     }
   }
   /**
@@ -6181,11 +6205,22 @@ var Tokenizer = class {
   /** Streaming only: a paragraph ending at `pe` may still be continued by a line not yet arrived. */
   paragraphMayGrow(pe) {
     if (!this.streaming) return false;
+    if (this.undecidedBreaks.has(pe)) return true;
     const rest = this.n - pe;
     if (rest === 0) return true;
     const tail = this.text.slice(pe);
-    return tail === "\n" || tail === "\r\n" || tail === "\r";
+    return /^(?:\r\n|\r|\n)[ \t]*$/.test(tail);
+  }
+  /**
+   * Streaming: an open block that may still turn back into prose — a `$$`
+   * pair whose closer is on the open last line (prose after it makes it
+   * inline), or a JSON head whose braces have not balanced (it may never parse).
+   */
+  mayDissolve(block) {
+    return this.streaming && !block.complete && (block.type === "math_block" || block.type === "json");
   }
+  /** Streaming: paragraph ends where an undecided, dissolvable block cut them short. */
+  undecidedBreaks = /* @__PURE__ */ new Set();
   /** Streaming only: the final line, still waiting for its terminator. */
   isOpenTail(k) {
     return this.streaming && k === this.lineStarts.length - 1 && (this.lineEnds[k] === this.contentEnds[k] || this.pendingCR);
@@ -6234,8 +6269,103 @@ var Tokenizer = class {
       }
       pos = this.paragraph(pos, li);
     }
+    if (this.streaming) this.holdUndecidedTail();
     return this.blocks;
   }
+  /**
+   * Streaming: settle nothing the next bytes can still change (verify-RC-B3 F3).
+   *
+   * 1. A block island that ends on the open last line is undecided — the next
+   *    bytes on that line can re-read it or dissolve it (`<!--@a:k1-->` +
+   *    ` more` is an inline anchor, `<br>` + `x` is prose). It runs open to
+   *    the end of the text.
+   * 2. A box-drawing tree still forming at the end of the text claims, as its
+   *    root label, the lines directly above its first connector (the
+   *    renderer's `findTreeBlockStart`), and the open last line itself may
+   *    become one of its connector lines — so inlines on those lines are held
+   *    back as prose until a blank line, a heading or a tree line decides.
+   *    This also holds everything a closer still able to arrive on the open
+   *    last line could change (`$x$` + `5` is currency, G4; `{{v}}` + `}`).
+   */
+  holdUndecidedTail() {
+    const last = this.lineStarts.length - 1;
+    if (last < 0) return;
+    if (this.isOpenTail(last)) {
+      const lineStart = this.lineStarts[last];
+      for (const block2 of this.blocks) {
+        if (block2.kind === "prose" && block2.end > lineStart) {
+          block2.inlines = block2.inlines.filter((inline) => inline.end <= lineStart);
+        }
+      }
+      let b = this.blocks.length - 1;
+      while (b >= 0 && this.blocks[b].kind === "gap") b--;
+      const block = this.blocks[b];
+      if (block?.island?.complete && block.island.end > this.lineStarts[last]) {
+        block.island.complete = false;
+        block.island.end = this.n;
+        block.end = this.n;
+        this.blocks.length = b + 1;
+      }
+    }
+    const from = this.treeRootHoldFrom();
+    for (let b = this.blocks.length - 1; b >= 0; b--) {
+      const block = this.blocks[b];
+      if (block.end <= from) break;
+      if (block.kind === "prose") block.inlines = block.inlines.filter((inline) => inline.end <= from);
+      if (block.island) this.blocks[b] = { kind: "prose", start: block.start, end: block.end, island: null, inlines: [] };
+    }
+  }
+  /**
+   * Streaming: where a tree that may still form at the end of the text would
+   * start claiming lines (`n` when none can). Only paragraph lines can be
+   * claimed — a line that starts inside an island (a fence body, an XML
+   * region…) is never a tree line nor a root label, so it stops the walk.
+   */
+  treeRootHoldFrom() {
+    const claimable = (k2) => {
+      for (; ; ) {
+        const block = this.blockAt(this.lineStarts[k2]);
+        if (!block || block.kind !== "island" || block.island?.fromParagraph === true) return true;
+        const opened = this.lineOf(block.start);
+        if (this.lineStarts[opened] === block.start || opened === k2) return false;
+        k2 = opened;
+      }
+    };
+    let k = this.lineCount - 1;
+    let start = this.lineCount;
+    if (k >= 0 && this.isOpenTail(k)) {
+      if (!claimable(k)) return this.n;
+      start = k;
+      k--;
+    }
+    for (; k >= 0 && claimable(k); k--) {
+      this.tick(1);
+      if (this.lineIsBlank(k)) continue;
+      if (!TREE_GLYPHS.test(this.lineText(k))) break;
+      start = k;
+    }
+    let root = start;
+    for (let j = start - 1; j >= 0 && claimable(j); j--) {
+      const trimmed = this.lineText(j).trim();
+      this.tick(trimmed.length + 1);
+      if (!trimmed || isSplitterTreeLine(trimmed) || /^#{1,6}\s/.test(trimmed)) break;
+      root = j;
+    }
+    return root < this.lineCount ? this.lineStarts[root] : this.n;
+  }
+  /** The block (so far) containing offset `pos`, or null. */
+  blockAt(pos) {
+    let lo = 0;
+    let hi = this.blocks.length - 1;
+    while (lo <= hi) {
+      const mid = lo + hi >>> 1;
+      const block = this.blocks[mid];
+      if (pos < block.start) hi = mid - 1;
+      else if (pos >= block.end) lo = mid + 1;
+      else return block;
+    }
+    return null;
+  }
   push(block) {
     if (block.end <= block.start) return;
     if (block.kind === "prose" && this.isBlank(block.start, block.end)) {
@@ -6439,7 +6569,10 @@ var Tokenizer = class {
         continue;
       }
       if (this.isOpenTail(k)) return this.heldFootnote(p, open[1]);
-      if (FOOTNOTE_DEF.test(line.trimStart()) || this.detectBlock(this.lineStarts[k], k, false)) break;
+      if (FOOTNOTE_DEF.test(line.trimStart())) break;
+      const block = this.detectBlock(this.lineStarts[k], k, false);
+      if (block && this.mayDissolve(block)) return this.heldFootnote(p, open[1]);
+      if (block) break;
       last = k;
     }
     const end = this.contentEnds[last];
@@ -6455,7 +6588,8 @@ var Tokenizer = class {
     return {
       count: this.lineCount,
       line: (k) => this.lineText(k),
-      openTail: (k) => this.isOpenTail(k)
+      openTail: (k) => this.isOpenTail(k),
+      streaming: this.streaming
     };
   }
   /**
@@ -6515,6 +6649,10 @@ var Tokenizer = class {
       if (fenceOpenerOf(this.lineText(j))?.char === "~") continue;
       const inner = this.detectBlockUncached(start, j, false);
       if (!inner) continue;
+      if (this.streaming && inner.end >= tildeEnd && this.paragraphMayGrow(inner.end)) {
+        this.overflowComplete = false;
+        return this.n;
+      }
       if (inner.end > end) {
         end = inner.end;
         this.overflowComplete = inner.complete;
@@ -6643,12 +6781,7 @@ var Tokenizer = class {
       return this.island("html_block", p, close.index + close[0].length, true, { tag: name });
     }
     const typeSix = HTML_BLOCK_LEVEL_TAGS.has(name);
-    const loneTag = atParaStart && t.trimEnd() === tag.raw;
-    if (loneTag && this.isOpenTail(li)) {
-      this.provisionalFrom = Math.min(this.provisionalFrom, p);
-      return null;
-    }
-    const typeSeven = loneTag;
+    const typeSeven = atParaStart && t.trimEnd() === tag.raw;
     if (!typeSix && !typeSeven) return null;
     let end = this.contentEnds[li];
     for (let k = li + 1; k < this.lineCount && !this.lineIsBlank(k); k++) {
@@ -6706,6 +6839,13 @@ var Tokenizer = class {
       }
       return null;
     }
+    if (this.isOpenTail(lastLine)) {
+      if (isRecognizedJsonHead(this.text.slice(tp, tp + 512))) {
+        return this.island("json", p, this.n, false, jsonMeta(this.text.slice(tp)));
+      }
+      this.provisionalFrom = Math.min(this.provisionalFrom, p);
+      return null;
+    }
     if (net !== 0) return null;
     const end = this.contentEnds[lastLine];
     const content = this.text.slice(tp, end).trim();
@@ -6740,8 +6880,10 @@ var Tokenizer = class {
     let breakLine = -1;
     for (let k = li + 1; k < this.lineCount; k++) {
       if (this.lineIsBlank(k)) break;
-      if (this.detectBlock(this.lineStarts[k], k, false)) {
+      const block = this.detectBlock(this.lineStarts[k], k, false);
+      if (block) {
         breakLine = k;
+        if (this.mayDissolve(block)) this.undecidedBreaks.add(end);
         break;
       }
       end = this.contentEnds[k];
@@ -6779,7 +6921,7 @@ var Tokenizer = class {
       this.push({ kind: "prose", start: pos, end, island: null, inlines: scan2.inlines });
       return end;
     }
-    const br = scan2.breakIsland;
+    const br = { ...scan2.breakIsland, fromParagraph: true };
     if (scan2.orphan) {
       let start = pos;
       while (this.blocks.length) {
@@ -6802,6 +6944,15 @@ var Tokenizer = class {
     this.push({ kind: "island", start: br.start, end: br.end, island: br, inlines: [] });
     return br.end;
   }
+  /**
+   * An island that opens inside a paragraph and closes past its end becomes a
+   * block. Streaming: while the paragraph may still grow over its closer, the
+   * island may yet be inline — undecided, so it runs open to the end (F3).
+   */
+  spill(type, start, end, pe, meta) {
+    if (this.paragraphMayGrow(pe)) return this.island(type, start, this.n, false, meta);
+    return this.island(type, start, end, true, meta);
+  }
   scanInline(ps, pe) {
     const text = this.text;
     const inlines = [];
@@ -6830,11 +6981,15 @@ var Tokenizer = class {
         const nextCh = text[i + 1];
         if (nextCh === "(" || nextCh === "[") {
           const close = within(nextCh === "(" ? "\\)" : "\\]", i + 2);
-          if (close !== -1) {
+          const isMath = close !== -1 && (nextCh === "(" || isEscapedBracketMath(text.slice(i + 2, close), i > 0 ? text[i - 1] : void 0));
+          if (close !== -1 && isMath) {
             inlines.push(this.island("math_inline", i, close + 2, true, { delimiter: nextCh === "(" ? "\\(" : "\\[" }));
             i = close + 2;
             continue;
           }
+          if (close === -1 && this.streaming && this.paragraphMayGrow(pe)) {
+            return { inlines, breakIsland: null, orphan: false };
+          }
         }
         i += 2;
         continue;
@@ -6855,17 +7010,13 @@ var Tokenizer = class {
             i += 2;
             continue;
           }
-          if (close + 2 > pe) return stop(this.island("math_block", i, close + 2, true, { delimiter: "$$" }));
+          if (close + 2 > pe) return stop(this.spill("math_block", i, close + 2, pe, { delimiter: "$$" }));
           inlines.push(this.island("math_inline", i, close + 2, true, { delimiter: "$$" }));
           i = close + 2;
           continue;
         }
         const end = singleDollarMathEnd(text, i, pe);
         this.tick(end > 0 ? end - i : Math.min(403, pe - i));
-        if (end > 0 && this.streaming && end === this.n) {
-          this.provisionalFrom = Math.min(this.provisionalFrom, i);
-          return { inlines, breakIsland: null, orphan: false };
-        }
         if (end > 0) {
           inlines.push(this.island("math_inline", i, end, true, { delimiter: "$" }));
           i = end;
@@ -6943,7 +7094,7 @@ var Tokenizer = class {
           const anchor = end - i <= 64 ? PINNED_ANCHOR_RE.exec(text.slice(i, end)) : null;
           const type = anchor ? "anchor" : "html_comment";
           const meta = anchor ? { id: anchor[1] } : {};
-          if (end > pe) return stop(this.island(type, i, end, true, meta));
+          if (end > pe) return stop(this.spill(type, i, end, pe, meta));
           inlines.push(this.island(type, i, end, true, meta));
           i = end;
           continue;
@@ -6972,7 +7123,7 @@ var Tokenizer = class {
             const blockType = isAttr ? "xml_attr" : "xml_region";
             if (close === -1) return stop(this.island(blockType, i, this.n, false, { tag: name }));
             const end = close + closer.length;
-            if (end > pe) return stop(this.island(blockType, i, end, true, { tag: name }));
+            if (end > pe) return stop(this.spill(blockType, i, end, pe, { tag: name }));
             inlines.push(this.island("xml_inline", i, end, true, { tag: name }));
             i = end;
             continue;
@@ -7358,6 +7509,7 @@ function mapRange(changes, start, end, unit = "utf16") {
 }
 
 exports.ACTION_BY_CLASS = ACTION_BY_CLASS;
+exports.AFTER_WINDOW = AFTER_WINDOW;
 exports.BacktickRuns = BacktickRuns;
 exports.CALLOUT_NAMES = CALLOUT_NAMES;
 exports.CAPABILITY_BY_CLASS = CAPABILITY_BY_CLASS;
@@ -7440,6 +7592,7 @@ exports.isCanonicalBlockIR = isCanonicalBlockIR;
 exports.isDirectiveClass = isDirectiveClass;
 exports.isDuplicateBlockSlug = isDuplicateBlockSlug;
 exports.isEmptyResidue = isEmptyResidue;
+exports.isEscapedBracketMath = isEscapedBracketMath;
 exports.isIrEnvelopeCache = isIrEnvelopeCache;
 exports.isJsonAnyField = isJsonAnyField;
 exports.isKindDirective = isKindDirective;
@@ -7500,6 +7653,7 @@ exports.scalarArrayItemType = scalarArrayItemType;
 exports.schemaLayoutMode = schemaLayoutMode;
 exports.schemaStructureDepth = schemaStructureDepth;
 exports.setJsonRootKeyLookup = setJsonRootKeyLookup;
+exports.singleDollarAfter = singleDollarAfter;
 exports.singleDollarMathEnd = singleDollarMathEnd;
 exports.spliceSave = spliceSave;
 exports.splitsSurrogatePair = splitsSurrogatePair;