@ai-matrx/content-ir 0.14.1 → 0.14.3

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.14.3
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/content-ir-core/v0.14.2..npm/content-ir-core/v0.14.3 -- apps/shared/content-ir-core`).
+No source changes intended and no consumer action required.
+
+## 0.14.2 — 2026-09-25
+
+**`/source` — a tilde fence locks what the renderer draws inside it**
+(verify-RC-B3 residual R5). The renderer's splitter does not know `~~~`
+fences, so a ```` ``` ```` fence (or an XML section, a JSON block) that starts
+inside one can run past the tilde closer — and the tokenizer had left that
+overflow as editable prose. A tilde island now extends over every block the
+renderer would detect starting inside it (the union of both readings). Found
+by matrx-frontend's new `source-covers-renderer` property test (every fenced
+block the renderer draws must sit inside one tokenizer island; red on 0.14.1,
+green on 0.14.2 over 80k generated documents with tilde, nested-markdown,
+CRLF and exotic-whitespace fences). Guard here: 3 cases in
+`__tests__/source-verify-findings.test.ts`.
+
+**Consumer action:** none.
+
 ## 0.14.1 — 2026-09-25
 
 **Single-dollar math: an adversarial review of the widened rule** (RC-B2's

package/dist/index.cjs

@@ -5487,6 +5487,37 @@ var NOT_WHITESPACE = /\S/;
 var DIRECTIVE_OPEN = /^(:{2,})([A-Za-z][\w-]*)/;
 var MKDOCS_OPEN = /^(!!!|\?\?\?\+?)[ \t]+([A-Za-z][\w-]*)/;
 var CALLOUT_OPEN = /^>[ \t]*\[!([A-Za-z][\w-]*)\]([+-])?/;
+var CALLOUT_NAMES = /* @__PURE__ */ new Set([
+  "note",
+  "seealso",
+  "example",
+  "tip",
+  "hint",
+  "important",
+  "warning",
+  "warn",
+  "attention",
+  "caution",
+  "danger",
+  "error",
+  "failure",
+  "fail",
+  "missing",
+  "bug",
+  "info",
+  "abstract",
+  "summary",
+  "tldr",
+  "todo",
+  "success",
+  "check",
+  "done",
+  "question",
+  "help",
+  "faq",
+  "quote",
+  "cite"
+]);
 var FOOTNOTE_DEF = /^\[\^([^\]\s]+)\]:/;
 function countStructuralBraces(source) {
   let opens = 0;
@@ -5880,7 +5911,7 @@ var Tokenizer = class {
   /** A blockquote whose first line is `> [!TYPE]…` — every following `>` line belongs to it. */
   callout(p, li, t) {
     const open = CALLOUT_OPEN.exec(t);
-    if (!open) return null;
+    if (!open || !CALLOUT_NAMES.has(open[1].toLowerCase())) return null;
     let last = li;
     for (let k = li + 1; k < this.lineCount; k++) {
       if (!/^ {0,3}>/.test(this.lineText(k))) break;
@@ -6005,11 +6036,41 @@ var Tokenizer = class {
     for (let k = li + 1; k < this.lineCount; k++) {
       if (this.isOpenTail(k)) continue;
       if (close.test(this.lineText(k))) {
-        return this.island("fence", p, this.contentEnds[k], true, meta);
+        const tildeEnd = this.contentEnds[k];
+        const end = this.rendererOverflow(li + 1, k, tildeEnd);
+        return this.island("fence", p, end, end === this.n ? this.overflowComplete : true, meta);
       }
     }
     return this.island("fence", p, this.n, false, meta);
   }
+  /** Completion of the last `rendererOverflow` that ran to the end of the text. */
+  overflowComplete = true;
+  /**
+   * The renderer's splitter does not know ~~~ fences: it reads the lines inside
+   * one as ordinary lines, so a ```` ``` ```` fence (or an XML section, a JSON
+   * block…) that STARTS inside the tilde fence can run past its closer. The
+   * editor must lock at least what the renderer draws (verify-RC-B3 residual
+   * R5), so a tilde island extends over every block the renderer would detect
+   * starting inside it. Returns the island's end.
+   */
+  rendererOverflow(firstLine, closeLine, tildeEnd) {
+    let end = tildeEnd;
+    this.overflowComplete = true;
+    for (let j = firstLine; j <= closeLine && j < this.lineCount; j++) {
+      const start = this.lineStarts[j];
+      if (this.lineIsBlank(j)) continue;
+      if (this.lineText(j).trimStart().startsWith("~~~")) continue;
+      const inner = this.detectBlockUncached(start, j, false);
+      if (!inner) continue;
+      if (inner.end > end) {
+        end = inner.end;
+        this.overflowComplete = inner.complete;
+      }
+      const lastLine = this.lineOf(Math.max(start, inner.end - 1));
+      if (lastLine > j) j = lastLine;
+    }
+    return end;
+  }
   /**
    * A line-leading `$$` that OPENS a math pair (source/math-pairs.ts — the
    * core's rule). A closer, an unpaired `$$`, or a prose pair is never a block:
@@ -6830,6 +6891,7 @@ function mapRange(changes, start, end, unit = "utf16") {
 }
 
 exports.ACTION_BY_CLASS = ACTION_BY_CLASS;
+exports.CALLOUT_NAMES = CALLOUT_NAMES;
 exports.CAPABILITY_BY_CLASS = CAPABILITY_BY_CLASS;
 exports.CLASSES = CLASSES;
 exports.DIRECTIVE_VERSION = DIRECTIVE_VERSION;