@ai-matrx/content-ir 0.11.6 → 0.12.0

package/dist/index.cjs

@@ -1266,18 +1266,18 @@ var KindStreamParser = class {
   completeTypedObject(path, objectValue, at) {
     const pathKey = this.pathKey(path);
     if (this.rawObjectPaths.has(pathKey)) return;
-    const declaredKind = readObjectKind(objectValue);
+    const declaredKind2 = readObjectKind(objectValue);
     const committedKind = this.objectKinds.get(pathKey);
     if (committedKind && this.pendingSchemaPaths.get(committedKind)?.has(pathKey)) {
       this.closedPendingPaths.add(pathKey);
       return;
     }
-    if (!declaredKind && committedKind && this.speculativeKinds.has(pathKey)) {
+    if (!declaredKind2 && committedKind && this.speculativeKinds.has(pathKey)) {
       this.speculativeKinds.delete(pathKey);
       this.finalizeSpeculatedObject(path, objectValue, committedKind, at);
       return;
     }
-    if (path.length === 0 && !declaredKind && !committedKind && this.rootSurfaceKind) {
+    if (path.length === 0 && !declaredKind2 && !committedKind && this.rootSurfaceKind) {
       const surfaceKind = this.rootSurfaceKind;
       this.rootSurfaceKind = null;
       this.objectKinds.set(pathKey, surfaceKind);
@@ -1293,7 +1293,7 @@ var KindStreamParser = class {
       this.finalizeSpeculatedObject(path, objectValue, surfaceKind, at);
       return;
     }
-    if (!declaredKind) {
+    if (!declaredKind2) {
       this.emitRawObject(
         path,
         objectValue,
@@ -3209,8 +3209,8 @@ function refToObjectField(resolved, path, ctx) {
 function isAnyValueSchema(node) {
   return node.type === void 0 && node.enum === void 0 && node.const === void 0 && node.properties === void 0 && node.items === void 0 && node.additionalProperties === void 0 && node.anyOf === void 0 && node.oneOf === void 0 && node.allOf === void 0 && node.$ref === void 0;
 }
-function registerDeclaredKindDraft(declaredKind, objectNode, path, ctx) {
-  if (ctx.blockSchemas.some((draft) => draft.slug === declaredKind)) return;
+function registerDeclaredKindDraft(declaredKind2, objectNode, path, ctx) {
+  if (ctx.blockSchemas.some((draft) => draft.slug === declaredKind2)) return;
   if (!isRecord4(objectNode.properties)) return;
   const memberRequired = new Set(
     Array.isArray(objectNode.required) ? objectNode.required.filter((k) => typeof k === "string") : []
@@ -3228,8 +3228,8 @@ function registerDeclaredKindDraft(declaredKind, objectNode, path, ctx) {
     );
   }
   ctx.blockSchemas.push({
-    slug: declaredKind,
-    label: formatBlockLabel(declaredKind),
+    slug: declaredKind2,
+    label: formatBlockLabel(declaredKind2),
     fields
   });
 }
@@ -4973,6 +4973,1421 @@ function asKindInstance(item, kind) {
   return { [KIND_KEY]: resolved, ...item };
 }
 
+// source/offsets.ts
+function isHigh(code) {
+  return code >= 55296 && code <= 56319;
+}
+function isLow(code) {
+  return code >= 56320 && code <= 57343;
+}
+function splitsSurrogatePair(text, offset) {
+  if (offset <= 0 || offset >= text.length) return false;
+  return isHigh(text.charCodeAt(offset - 1)) && isLow(text.charCodeAt(offset));
+}
+function buildCodePointIndex(text) {
+  const pairStarts = [];
+  for (let i = 0; i < text.length - 1; i++) {
+    if (isHigh(text.charCodeAt(i)) && isLow(text.charCodeAt(i + 1))) {
+      pairStarts.push(i);
+      i++;
+    }
+  }
+  const countBelow = (limit) => {
+    let lo = 0;
+    let hi = pairStarts.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (pairStarts[mid] < limit) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  };
+  const toCodePoint = (utf16) => {
+    return utf16 - countBelow(utf16 - 1);
+  };
+  const toUtf16 = (codePoint) => {
+    let lo = 0;
+    let hi = pairStarts.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      const start = pairStarts[mid];
+      if (start - mid < codePoint) lo = mid + 1;
+      else hi = mid;
+    }
+    return codePoint + lo;
+  };
+  return {
+    toCodePoint,
+    toUtf16,
+    lengthCp: text.length - pairStarts.length
+  };
+}
+function toCodePointOffset(text, utf16) {
+  return buildCodePointIndex(text).toCodePoint(utf16);
+}
+function toUtf16Offset(text, codePoint) {
+  return buildCodePointIndex(text).toUtf16(codePoint);
+}
+
+// source/constants.ts
+var XML_TAG_BLOCK_NAMES = [
+  "thinking",
+  "think",
+  "reasoning",
+  "info",
+  "task",
+  "database",
+  "private",
+  "plan",
+  "event",
+  "tool",
+  "questionnaire",
+  "flashcards",
+  "cooking_recipe",
+  "timeline",
+  "progress_tracker",
+  "troubleshooting",
+  "resources",
+  "research"
+];
+var THINKING_FAMILY = ["thinking", "think", "reasoning"];
+var ATTRIBUTE_XML_NAMES = [
+  "decision",
+  "artifact",
+  "editor_error",
+  "editor_code_snippet",
+  "audiocite"
+];
+var KNOWN_XML_TAG_NAMES = /* @__PURE__ */ new Set([
+  ...XML_TAG_BLOCK_NAMES,
+  ...ATTRIBUTE_XML_NAMES
+]);
+var ALLOWED_RAW_HTML_TAGS = /* @__PURE__ */ new Set([
+  "img",
+  "a",
+  "br",
+  "hr",
+  "span",
+  "p",
+  "strong",
+  "b",
+  "em",
+  "i",
+  "u",
+  "s",
+  "del",
+  "ins",
+  "sup",
+  "sub",
+  "mark",
+  "kbd",
+  "abbr",
+  "small",
+  "code",
+  "pre",
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "caption",
+  "colgroup",
+  "col",
+  "figure",
+  "figcaption"
+]);
+var HTML_BLOCK_LEVEL_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "hr",
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "caption",
+  "colgroup",
+  "col",
+  "figure",
+  "figcaption"
+]);
+var SPECIAL_CODE_LANGUAGES = /* @__PURE__ */ new Set([
+  "transcript",
+  "tasks",
+  "structured_info",
+  "questionnaire",
+  "flashcards",
+  "cooking_recipe",
+  "mermaid",
+  "svg",
+  "chart",
+  "map",
+  "stats",
+  "diff",
+  "html",
+  "react",
+  "matrx"
+]);
+var CODE_LANGUAGE_ALIASES = {
+  mmd: "mermaid",
+  jsx: "react",
+  tsx: "react"
+};
+var TYPED_JSON_ROOT_KEYS = {
+  quiz_title: "quiz",
+  presentation: "presentation",
+  decision_tree: "decision_tree",
+  comparison: "comparison_table",
+  diagram: "diagram",
+  math_problem: "math_problem",
+  item_presentation: "item_presentation",
+  name: "schema_proposal"
+};
+var TREE_GLYPHS = /[├└│┌┐┘┬┴┤┼─]/;
+var PINNED_ANCHOR_RE = /^<!--@a:([A-Za-z0-9_-]+)-->$/;
+var STRICT_VARIABLE_RE = /^\{\{([a-zA-Z_][a-zA-Z0-9_.]*)\}\}$/;
+var CITE_RE = /^<matrxcite\s+n="(\d+)"\s*\/>/;
+function normalizeFenceLanguage(language) {
+  const lower = language.toLowerCase();
+  return CODE_LANGUAGE_ALIASES[lower] ?? lower;
+}
+
+// source/math.ts
+var TEX_SIGNAL = /\\[A-Za-z]+|[\\^_{}=<>+]/;
+var LONE_VARIABLE = /^[A-Za-z](?:'|[0-9])?$/;
+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 (LONE_VARIABLE.test(content)) return true;
+  if (/^[0-9]/.test(content)) return /\\[A-Za-z]+|[\\^_{}]/.test(content);
+  return TEX_SIGNAL.test(content);
+}
+function singleDollarMathEnd(text, open, limit = text.length) {
+  let close = -1;
+  for (let k = open + 1; k < limit; k += 1) {
+    const c = text[k];
+    if (c === "\n") break;
+    if (c === "\\") {
+      k += 1;
+      continue;
+    }
+    if (c === "$") {
+      close = k;
+      break;
+    }
+  }
+  if (close === -1 || text[close + 1] === "$") return -1;
+  const content = text.slice(open + 1, close);
+  return isSingleDollarMath(content, text[close + 1]) ? close + 1 : -1;
+}
+
+// source/xml-tag.ts
+var XML_NAME_START = /[A-Za-z_]/;
+var XML_NAME_CHARACTER = /[\w.:-]/;
+var WHITESPACE = /\s/;
+function readXmlTag(content, start) {
+  let cursor = start + 1;
+  const isClosing = content[cursor] === "/";
+  if (isClosing) cursor++;
+  if (!XML_NAME_START.test(content[cursor] ?? "")) return null;
+  const nameStart = cursor;
+  while (XML_NAME_CHARACTER.test(content[cursor] ?? "")) cursor++;
+  const tagName = content.slice(nameStart, cursor);
+  const attributes = [];
+  if (isClosing) {
+    while (WHITESPACE.test(content[cursor] ?? "")) cursor++;
+    if (content[cursor] !== ">") return null;
+    return {
+      tagName,
+      raw: content.slice(start, cursor + 1),
+      isClosing,
+      isSelfClosing: false,
+      attributes
+    };
+  }
+  while (cursor < content.length) {
+    while (WHITESPACE.test(content[cursor] ?? "")) cursor++;
+    if (content[cursor] === ">")
+      return {
+        tagName,
+        raw: content.slice(start, cursor + 1),
+        isClosing,
+        isSelfClosing: false,
+        attributes
+      };
+    if (content[cursor] === "/") {
+      cursor++;
+      while (WHITESPACE.test(content[cursor] ?? "")) cursor++;
+      if (content[cursor] !== ">") return null;
+      return {
+        tagName,
+        raw: content.slice(start, cursor + 1),
+        isClosing,
+        isSelfClosing: true,
+        attributes
+      };
+    }
+    if (!XML_NAME_START.test(content[cursor] ?? "")) return null;
+    const attributeStart = cursor;
+    while (XML_NAME_CHARACTER.test(content[cursor] ?? "")) cursor++;
+    const name = content.slice(attributeStart, cursor);
+    while (WHITESPACE.test(content[cursor] ?? "")) cursor++;
+    if (content[cursor] !== "=") return null;
+    cursor++;
+    while (WHITESPACE.test(content[cursor] ?? "")) cursor++;
+    const quote = content[cursor];
+    if (quote !== '"' && quote !== "'") return null;
+    const valueStart = ++cursor;
+    while (cursor < content.length && content[cursor] !== quote) cursor++;
+    if (cursor === content.length) return null;
+    attributes.push({ name, value: content.slice(valueStart, cursor) });
+    cursor++;
+  }
+  return null;
+}
+function isEscapedBacktick(line, offset) {
+  let slashes = 0;
+  for (let i = offset - 1; line[i] === "\\"; i--) slashes++;
+  return slashes % 2 === 1;
+}
+var XmlContainerTracker = class {
+  constructor(rootTag) {
+    this.rootTag = rootTag;
+  }
+  rootTag;
+  depth = 0;
+  inComment = false;
+  inCdata = false;
+  inlineTicks = 0;
+  fenceMarker = null;
+  consumeLine(line, startOffset = 0) {
+    const fence = /^[ \t]*(`{3,}|~{3,})(.*)$/.exec(line);
+    if (!this.inComment && !this.inCdata && this.inlineTicks === 0 && fence) {
+      const marker = fence[1];
+      const char = marker[0];
+      const suffix = fence[2];
+      if (marker.length >= 3) {
+        if (!this.fenceMarker) {
+          this.fenceMarker = { char, ticks: marker.length };
+          return null;
+        }
+        if (char === this.fenceMarker.char && marker.length >= this.fenceMarker.ticks && suffix.trim() === "") {
+          this.fenceMarker = null;
+        }
+        return null;
+      }
+    }
+    if (this.fenceMarker) return null;
+    for (let i = startOffset; i < line.length; i++) {
+      if (this.inlineTicks > 0) {
+        if (line[i] === "`") {
+          let end = i;
+          while (line[end] === "`") end++;
+          if (end - i === this.inlineTicks) this.inlineTicks = 0;
+          i = end - 1;
+        }
+        continue;
+      }
+      if (this.inComment) {
+        const end = line.indexOf("-->", i);
+        if (end === -1) return null;
+        this.inComment = false;
+        i = end + 2;
+        continue;
+      }
+      if (this.inCdata) {
+        const end = line.indexOf("]]>", i);
+        if (end === -1) return null;
+        this.inCdata = false;
+        i = end + 2;
+        continue;
+      }
+      if (line.startsWith("<!--", i)) {
+        this.inComment = true;
+        i += 3;
+        continue;
+      }
+      if (line.startsWith("<![CDATA[", i)) {
+        this.inCdata = true;
+        i += 8;
+        continue;
+      }
+      if (line[i] === "`" && !isEscapedBacktick(line, i)) {
+        let end = i;
+        while (line[end] === "`") end++;
+        this.inlineTicks = end - i;
+        i = end - 1;
+        continue;
+      }
+      if (line[i] !== "<") continue;
+      const tag = readXmlTag(line, i);
+      if (!tag) continue;
+      const tagEnd = i + tag.raw.length;
+      if (tag.tagName === this.rootTag) {
+        if (tag.isClosing) this.depth--;
+        else if (!tag.isSelfClosing) this.depth++;
+        if (this.depth === 0) return tagEnd;
+      }
+      i = tagEnd - 1;
+    }
+    return null;
+  }
+};
+
+// source/tokenize.ts
+var NOT_WHITESPACE = /\S/;
+function countStructuralBraces(source) {
+  let opens = 0;
+  let closes = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < source.length; i++) {
+    const char = source[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') inString = true;
+    else if (char === "{") opens++;
+    else if (char === "}") closes++;
+  }
+  return { opens, closes };
+}
+function firstJsonKey(content) {
+  const match = /^\{\s*"([^"]+)"/.exec(content.trimStart());
+  return match ? match[1] : null;
+}
+function jsonMeta(content) {
+  const meta = {};
+  const key = firstJsonKey(content);
+  if (key) meta.firstKey = key;
+  try {
+    const parsed = JSON.parse(content.trim());
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      const kind = parsed.__kind;
+      if (typeof kind === "string" && kind.trim()) meta.kind = kind;
+    }
+  } catch {
+    const head = /^\{\s*"__kind"\s*:\s*"([^"]*)"/.exec(content.trimStart());
+    if (head) meta.kind = head[1];
+  }
+  if (typeof meta.kind === "string" && meta.kind.startsWith("directive_v")) {
+    meta.directive = true;
+  }
+  if (key === "matrx_version") meta.directive = true;
+  if (key && TYPED_JSON_ROOT_KEYS[key]) meta.typed = TYPED_JSON_ROOT_KEYS[key];
+  return meta;
+}
+function isRecognizedJsonHead(content) {
+  const key = firstJsonKey(content);
+  if (!key) return false;
+  return key === "__kind" || key === "matrx_version" || key in TYPED_JSON_ROOT_KEYS;
+}
+function matchingJsonObjectEnd(source, start, limit) {
+  if (source[start] !== "{") return null;
+  const stack = ["{"];
+  let inString = false;
+  let escaped = false;
+  for (let index = start + 1; index < limit; index++) {
+    const char = source[index];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      stack.push(char);
+      continue;
+    }
+    if (char !== "}" && char !== "]") continue;
+    const opening = stack.pop();
+    if (char === "}" && opening !== "{" || char === "]" && opening !== "[") return null;
+    if (stack.length === 0) return index + 1;
+  }
+  return null;
+}
+function declaredKind(candidate) {
+  try {
+    const parsed = JSON.parse(candidate);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    const kind = parsed.__kind;
+    return typeof kind === "string" && kind.trim() ? kind : null;
+  } catch {
+    return null;
+  }
+}
+function isUnclosedGenericXmlOpening(source) {
+  const text = source.trimStart();
+  const prefix = /^<([A-Za-z_][\w.:-]*)(?=\s|\/|$)/.exec(text);
+  if (!prefix || KNOWN_XML_TAG_NAMES.has(prefix[1]) || ALLOWED_RAW_HTML_TAGS.has(prefix[1].toLowerCase()))
+    return false;
+  let quote = null;
+  for (let i = prefix[0].length; i < text.length; i++) {
+    if (quote) {
+      if (text[i] === quote) quote = null;
+    } else if (text[i] === "'" || text[i] === '"') quote = text[i];
+    else if (text[i] === ">") return false;
+  }
+  return true;
+}
+function jsonStringState(line, from, upTo, state) {
+  let { inString, escaped } = state;
+  for (let idx = from; idx < upTo; idx++) {
+    const ch = line[idx];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') inString = !inString;
+  }
+  return { inString, escaped };
+}
+function backtickRunLength(str2, pos) {
+  let n = 0;
+  while (pos + n < str2.length && str2[pos + n] === "`") n++;
+  return n;
+}
+var MEDIA_REF_PREFIXES = ["[Image URL:", "[Video URL:", "[Audio URL:"];
+var Tokenizer = class {
+  constructor(text) {
+    this.text = text;
+    this.n = text.length;
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+      if (text.charCodeAt(i) === 10) {
+        this.lineStarts.push(start);
+        this.contentEnds.push(i > start && text.charCodeAt(i - 1) === 13 ? i - 1 : i);
+        this.lineEnds.push(i + 1);
+        start = i + 1;
+      }
+    }
+    if (start < text.length || text.length === 0) {
+      this.lineStarts.push(start);
+      this.contentEnds.push(text.length);
+      this.lineEnds.push(text.length);
+    }
+  }
+  text;
+  n;
+  lineStarts = [];
+  contentEnds = [];
+  lineEnds = [];
+  blocks = [];
+  blockCache = /* @__PURE__ */ new Map();
+  /** Lazily built: for line i, first line j >= i where brace net from i drops to <= 0. */
+  braceStop = null;
+  braceNet = null;
+  get lineCount() {
+    return this.lineStarts.length;
+  }
+  lineOf(pos) {
+    let lo = 0;
+    let hi = this.lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (this.lineStarts[mid] <= pos) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo;
+  }
+  isBlank(from, to) {
+    return !NOT_WHITESPACE.test(this.text.slice(from, to));
+  }
+  lineIsBlank(li) {
+    return this.isBlank(this.lineStarts[li], this.contentEnds[li]);
+  }
+  lineText(li) {
+    return this.text.slice(this.lineStarts[li], this.contentEnds[li]);
+  }
+  run() {
+    let pos = 0;
+    while (pos < this.n) {
+      const li = this.lineOf(pos);
+      const ce = this.contentEnds[li];
+      if (this.isBlank(pos, ce)) {
+        pos = this.gap(pos, li);
+        continue;
+      }
+      const island = this.detectBlock(pos, li, true);
+      if (island) {
+        this.push({ kind: "island", start: island.start, end: island.end, island, inlines: [] });
+        pos = island.end;
+        continue;
+      }
+      pos = this.paragraph(pos, li);
+    }
+    return this.blocks;
+  }
+  push(block) {
+    if (block.end <= block.start) return;
+    if (block.kind === "prose" && this.isBlank(block.start, block.end)) {
+      block = { kind: "gap", start: block.start, end: block.end, island: null, inlines: [] };
+    }
+    const last = this.blocks[this.blocks.length - 1];
+    if (block.kind === "gap" && last && last.kind === "gap" && last.end === block.start) {
+      last.end = block.end;
+      return;
+    }
+    this.blocks.push(block);
+  }
+  gap(pos, li) {
+    let end = this.lineEnds[li];
+    let k = li + 1;
+    while (k < this.lineCount && this.lineIsBlank(k)) {
+      end = this.lineEnds[k];
+      k++;
+    }
+    this.push({ kind: "gap", start: pos, end, island: null, inlines: [] });
+    return end;
+  }
+  // ── block detection ────────────────────────────────────────────────────
+  detectBlock(p, li, atParaStart) {
+    const cacheKey = atParaStart ? -1 - p : p;
+    if (this.blockCache.has(cacheKey)) return this.blockCache.get(cacheKey) ?? null;
+    const found = this.detectBlockUncached(p, li, atParaStart);
+    this.blockCache.set(cacheKey, found);
+    return found;
+  }
+  detectBlockUncached(p, li, atParaStart) {
+    const ce = this.contentEnds[li];
+    const seg = this.text.slice(p, ce);
+    const t = seg.trimStart();
+    const indent = seg.length - t.length;
+    const tp = p + indent;
+    if (p === 0) {
+      const fm = this.frontMatter(li, t);
+      if (fm) return fm;
+    }
+    if (t.startsWith("```")) return this.backtickFence(p, li, t);
+    if (indent <= 3 && t.startsWith("~~~")) {
+      const tilde = this.tildeFence(p, li, t);
+      if (tilde) return tilde;
+    }
+    if (t.startsWith("$$")) {
+      const math = this.mathBlock(p, tp);
+      if (math) return math;
+    }
+    if (t.startsWith("<")) {
+      const attr = this.attributeXml(p, tp, t);
+      if (attr) return attr;
+      const region = this.xmlRegion(p, tp, t);
+      if (region) return region;
+      const container = this.genericXml(p, li, seg, indent);
+      if (container) return container;
+      if (t.startsWith("<!--")) {
+        const comment = this.blockComment(p, tp, li);
+        if (comment) return comment;
+      }
+      const html = this.htmlBlock(p, li, t, tp, atParaStart);
+      if (html) return html;
+    }
+    if (t.startsWith("{")) {
+      const json = this.bareJson(p, li, tp);
+      if (json) return json;
+    }
+    if (TREE_GLYPHS.test(t)) {
+      const tree = this.tree(p, li);
+      if (tree) return tree;
+    }
+    return null;
+  }
+  island(type, start, end, complete, meta = {}) {
+    return { type, start, end, complete, meta };
+  }
+  frontMatter(li, t) {
+    if (this.lineText(li) !== "---" || t !== "---") return null;
+    let sawContent = false;
+    for (let k = li + 1; k < this.lineCount; k++) {
+      const line = this.lineText(k);
+      if (line === "---" || line === "...") {
+        return sawContent ? this.island("front_matter", 0, this.contentEnds[k], true) : null;
+      }
+      if (!NOT_WHITESPACE.test(line)) continue;
+      if (!/^(?:[A-Za-z0-9_"'-][^:]*:(?:\s|$)|\s+\S|-\s)/.test(line)) return null;
+      sawContent = true;
+    }
+    return null;
+  }
+  /** Backtick fence — the splitter's close rules, JSON-string aware for ```json. */
+  backtickFence(p, li, t) {
+    const openTicks = backtickRunLength(t, 0);
+    const info = t.slice(openTicks).trim();
+    const lang = info.split(/\s/)[0] ?? "";
+    const isJson = lang === "json";
+    const normalized = normalizeFenceLanguage(lang);
+    const meta = { fence: "`", ticks: openTicks, lang };
+    if (normalized && SPECIAL_CODE_LANGUAGES.has(normalized)) meta.special = normalized;
+    let state = { inString: false, escaped: false };
+    for (let k = li + 1; k < this.lineCount; k++) {
+      const line = this.lineText(k);
+      const trimmedLine = line.trim();
+      if (trimmedLine.startsWith("```")) {
+        const at2 = line.indexOf("```");
+        if (isJson) {
+          const probe = jsonStringState(line, 0, at2, state);
+          if (probe.inString) {
+            state = jsonStringState(line, at2, line.length, probe);
+            continue;
+          }
+        }
+        const closeTicks = backtickRunLength(trimmedLine, 0);
+        const isBare = trimmedLine.slice(closeTicks).trim() === "";
+        if (isBare && closeTicks >= openTicks) {
+          return this.fenceIsland(p, this.contentEnds[k], true, meta, li, k, isJson);
+        }
+        if (isJson) state = jsonStringState(line, 0, line.length, state);
+        continue;
+      }
+      const at = line.indexOf("```");
+      if (at !== -1) {
+        if (isJson) {
+          const probe = jsonStringState(line, 0, at, state);
+          if (probe.inString) {
+            state = jsonStringState(line, at, line.length, probe);
+            continue;
+          }
+        }
+        const closeTicks = backtickRunLength(line, at);
+        const after = line.slice(at + closeTicks).trim();
+        if (closeTicks >= openTicks && after === "") {
+          return this.fenceIsland(p, this.contentEnds[k], true, meta, li, k, isJson);
+        }
+        if (isJson) state = jsonStringState(line, 0, line.length, state);
+        continue;
+      }
+      if (isJson) state = jsonStringState(line, 0, line.length, state);
+    }
+    return this.fenceIsland(p, this.n, false, meta, li, this.lineCount, isJson);
+  }
+  fenceIsland(p, end, complete, meta, openLine, closeLine, isJson) {
+    if (isJson && openLine + 1 < this.lineCount) {
+      const bodyEnd = closeLine < this.lineCount ? this.lineStarts[closeLine] : this.n;
+      const body = this.text.slice(this.lineStarts[openLine + 1], Math.max(bodyEnd, this.lineStarts[openLine + 1]));
+      if (body.trimStart().startsWith("{")) Object.assign(meta, jsonMeta(body));
+    }
+    return this.island("fence", p, end, complete, meta);
+  }
+  tildeFence(p, li, t) {
+    const open = /^(~{3,})(.*)$/.exec(t);
+    if (!open) return null;
+    const ticks = open[1].length;
+    const lang = open[2].trim().split(/\s/)[0] ?? "";
+    const meta = { fence: "~", ticks, lang };
+    const normalized = normalizeFenceLanguage(lang);
+    if (normalized && SPECIAL_CODE_LANGUAGES.has(normalized)) meta.special = normalized;
+    const close = new RegExp(`^ {0,3}~{${ticks},}[ \\t]*$`);
+    for (let k = li + 1; k < this.lineCount; k++) {
+      if (close.test(this.lineText(k))) {
+        return this.island("fence", p, this.contentEnds[k], true, meta);
+      }
+    }
+    return this.island("fence", p, this.n, false, meta);
+  }
+  mathBlock(p, tp) {
+    const li = this.lineOf(tp);
+    const ce = this.contentEnds[li];
+    const sameLine = this.text.indexOf("$$", tp + 2);
+    if (sameLine !== -1 && sameLine + 2 <= ce) {
+      if (!this.isBlank(sameLine + 2, ce)) return null;
+      if (sameLine === tp + 2) return null;
+      return this.island("math_block", p, sameLine + 2, true, { delimiter: "$$" });
+    }
+    const close = this.text.indexOf("$$", tp + 2);
+    if (close === -1) return this.island("math_block", p, this.n, false, { delimiter: "$$" });
+    return this.island("math_block", p, close + 2, true, { delimiter: "$$" });
+  }
+  /** `<artifact …>`, `<decision …>`, … at the start of a line. */
+  attributeXml(p, tp, t) {
+    for (const name of ATTRIBUTE_XML_NAMES) {
+      const prefix = `<${name}`;
+      if (!t.startsWith(prefix)) continue;
+      const next = t[prefix.length];
+      if (next !== " " && next !== ">" && next !== "/" && next !== "	") continue;
+      return this.attributeElement(name, p, tp, "xml_attr");
+    }
+    return null;
+  }
+  /** Opening tag at `tp` through its `</name>` (or to EOF when still streaming). */
+  attributeElement(name, p, tp, type) {
+    const li = this.lineOf(tp);
+    const ce = this.contentEnds[li];
+    const tag = readXmlTag(this.text, tp);
+    let openEnd;
+    if (tag && !tag.isClosing) {
+      if (tag.isSelfClosing) {
+        return this.island(type, p, tp + tag.raw.length, true, { tag: name, selfClosing: true });
+      }
+      openEnd = tp + tag.raw.length;
+    } else {
+      const gt = this.text.indexOf(">", tp);
+      if (gt === -1) return this.island(type, p, this.n, false, { tag: name });
+      if (gt >= ce) return null;
+      openEnd = gt + 1;
+    }
+    const closer = `</${name}>`;
+    const close = this.text.indexOf(closer, openEnd);
+    if (close === -1) return this.island(type, p, this.n, false, { tag: name });
+    return this.island(type, p, close + closer.length, true, { tag: name });
+  }
+  /** `<thinking>`, `<flashcards>`, … — exact attribute-less openers. */
+  xmlRegion(p, tp, t) {
+    for (const name of XML_TAG_BLOCK_NAMES) {
+      const opener = `<${name}>`;
+      if (!t.startsWith(opener)) continue;
+      const closer = `</${name}>`;
+      const close = this.text.indexOf(closer, tp + opener.length);
+      if (close === -1) return this.island("xml_region", p, this.n, false, { tag: name });
+      return this.island("xml_region", p, close + closer.length, true, { tag: name });
+    }
+    return null;
+  }
+  /** Line-leading unknown XML element — balanced by the renderer's own tracker. */
+  genericXml(p, li, seg, indent) {
+    const first = seg.slice(indent);
+    const opening = readXmlTag(first, 0);
+    if (opening && !opening.isClosing) {
+      const root = opening.tagName;
+      if (KNOWN_XML_TAG_NAMES.has(root) || ALLOWED_RAW_HTML_TAGS.has(root.toLowerCase())) {
+        return null;
+      }
+      const tracker = new XmlContainerTracker(root);
+      const firstEnd = tracker.consumeLine(seg, indent);
+      if (firstEnd !== null) {
+        return this.island("xml_container", p, p + firstEnd, true, { tag: root });
+      }
+      for (let k = li + 1; k < this.lineCount; k++) {
+        const end = tracker.consumeLine(this.lineText(k));
+        if (end !== null) {
+          return this.island("xml_container", p, this.lineStarts[k] + end, true, {
+            tag: root
+          });
+        }
+      }
+      return this.island("xml_container", p, this.n, false, { tag: root });
+    }
+    if (isUnclosedGenericXmlOpening(seg)) {
+      return this.island("xml_container", p, this.n, false, {});
+    }
+    return null;
+  }
+  blockComment(p, tp, li) {
+    const close = this.text.indexOf("-->", tp + 4);
+    if (close === -1) return this.island("html_comment", p, this.n, false);
+    const end = close + 3;
+    const raw = this.text.slice(tp, end);
+    const anchor = PINNED_ANCHOR_RE.exec(raw);
+    const ce = this.contentEnds[li];
+    if (anchor) {
+      if (end <= ce && !this.isBlank(end, ce)) return null;
+      return this.island("anchor", p, end, true, { id: anchor[1] });
+    }
+    return this.island("html_comment", p, end, true);
+  }
+  htmlBlock(p, li, t, tp, atParaStart) {
+    const tag = readXmlTag(t, 0);
+    if (!tag) return null;
+    const name = tag.tagName.toLowerCase();
+    if (!ALLOWED_RAW_HTML_TAGS.has(name)) return null;
+    if (name === "pre" && !tag.isClosing) {
+      const closer = /<\/pre\s*>/gi;
+      closer.lastIndex = tp;
+      const close = closer.exec(this.text);
+      if (!close) return this.island("html_block", p, this.n, false, { tag: name });
+      return this.island("html_block", p, close.index + close[0].length, true, { tag: name });
+    }
+    const typeSix = HTML_BLOCK_LEVEL_TAGS.has(name);
+    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++) {
+      end = this.contentEnds[k];
+    }
+    return this.island("html_block", p, end, true, { tag: name });
+  }
+  buildBraceTables() {
+    const count = this.lineCount;
+    const prefix = new Int32Array(count + 1);
+    for (let i = 0; i < count; i++) {
+      const { opens, closes } = countStructuralBraces(this.lineText(i));
+      prefix[i + 1] = prefix[i] + opens - closes;
+    }
+    const stop = new Int32Array(count).fill(-1);
+    const stack = [];
+    for (let m = 0; m <= count; m++) {
+      const value = prefix[m];
+      while (stack.length && prefix[stack[stack.length - 1]] >= value) {
+        const i = stack.pop();
+        if (i < count) stop[i] = m - 1;
+      }
+      stack.push(m);
+    }
+    this.braceNet = prefix;
+    this.braceStop = stop;
+  }
+  /** A line-leading bare JSON object — the splitter's structural brace walk. */
+  bareJson(p, li, tp) {
+    let lastLine = null;
+    let net = 0;
+    if (p === this.lineStarts[li]) {
+      if (!this.braceStop || !this.braceNet) this.buildBraceTables();
+      const stop = this.braceStop[li];
+      if (stop !== -1) {
+        lastLine = stop;
+        net = this.braceNet[stop + 1] - this.braceNet[li];
+      }
+    } else {
+      let running = 0;
+      for (let k = li; k < this.lineCount; k++) {
+        const line = k === li ? this.text.slice(tp, this.contentEnds[li]) : this.lineText(k);
+        const { opens, closes } = countStructuralBraces(line);
+        running += opens - closes;
+        if (running <= 0) {
+          lastLine = k;
+          net = running;
+          break;
+        }
+      }
+    }
+    if (lastLine === null) {
+      const partial = this.text.slice(tp);
+      if (isRecognizedJsonHead(partial)) {
+        return this.island("json", p, this.n, false, jsonMeta(partial));
+      }
+      return null;
+    }
+    if (net !== 0) return null;
+    const end = this.contentEnds[lastLine];
+    const content = this.text.slice(tp, end).trim();
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed === null || typeof parsed !== "object") return null;
+    } catch {
+      return null;
+    }
+    return this.island("json", p, end, true, jsonMeta(content));
+  }
+  tree(p, li) {
+    let treeLines = 0;
+    let lastTree = li;
+    let k = li;
+    while (k < this.lineCount) {
+      if (this.lineIsBlank(k)) {
+        k++;
+        continue;
+      }
+      if (!TREE_GLYPHS.test(this.lineText(k))) break;
+      treeLines++;
+      lastTree = k;
+      k++;
+    }
+    if (treeLines < 3) return null;
+    return this.island("tree", p, this.contentEnds[lastTree], true);
+  }
+  // ── prose ──────────────────────────────────────────────────────────────
+  paragraph(pos, li) {
+    let end = this.contentEnds[li];
+    for (let k = li + 1; k < this.lineCount; k++) {
+      if (this.lineIsBlank(k)) break;
+      if (this.detectBlock(this.lineStarts[k], k, false)) break;
+      end = this.contentEnds[k];
+    }
+    const scan = this.scanInline(pos, end);
+    if (!scan.breakIsland) {
+      this.push({ kind: "prose", start: pos, end, island: null, inlines: scan.inlines });
+      return end;
+    }
+    const br = scan.breakIsland;
+    if (scan.orphan) {
+      let start = pos;
+      while (this.blocks.length) {
+        const last = this.blocks[this.blocks.length - 1];
+        if (last.kind === "island") break;
+        this.blocks.pop();
+        start = last.start;
+      }
+      const island = { ...br, start };
+      this.push({ kind: "island", start, end: island.end, island, inlines: [] });
+      return island.end;
+    }
+    this.push({
+      kind: "prose",
+      start: pos,
+      end: br.start,
+      island: null,
+      inlines: scan.inlines.filter((inline) => inline.end <= br.start)
+    });
+    this.push({ kind: "island", start: br.start, end: br.end, island: br, inlines: [] });
+    return br.end;
+  }
+  scanInline(ps, pe) {
+    const text = this.text;
+    const inlines = [];
+    const hasKind = text.slice(ps, pe).includes("__kind");
+    const stop = (island, orphan = false) => ({ inlines, breakIsland: island, orphan });
+    let i = ps;
+    while (i < pe) {
+      const ch = text[i];
+      if (ch === "\\") {
+        const next = text[i + 1];
+        if (next === "(" || next === "[") {
+          const closer = next === "(" ? "\\)" : "\\]";
+          const close = text.indexOf(closer, i + 2);
+          if (close !== -1 && close + 2 <= pe) {
+            inlines.push(this.island("math_inline", i, close + 2, true, { delimiter: next === "(" ? "\\(" : "\\[" }));
+            i = close + 2;
+            continue;
+          }
+        }
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        const n = backtickRunLength(text, i);
+        const run = "`".repeat(n);
+        let k = i + n;
+        let close = -1;
+        while (k < pe) {
+          const idx = text.indexOf(run, k);
+          if (idx === -1 || idx >= pe) break;
+          if (text[idx + n] === "`") {
+            let m = idx;
+            while (text[m] === "`") m++;
+            k = m;
+            continue;
+          }
+          close = idx;
+          break;
+        }
+        i = close === -1 ? i + n : close + n;
+        continue;
+      }
+      if (ch === "$") {
+        if (text[i + 1] === "$") {
+          const close = text.indexOf("$$", i + 2);
+          if (close !== -1 && close + 2 <= pe && close > i + 2) {
+            inlines.push(this.island("math_inline", i, close + 2, true, { delimiter: "$$" }));
+            i = close + 2;
+          } else {
+            i += 2;
+          }
+          continue;
+        }
+        const end = singleDollarMathEnd(text, i, pe);
+        if (end > 0) {
+          inlines.push(this.island("math_inline", i, end, true, { delimiter: "$" }));
+          i = end;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (ch === "{") {
+        if (text[i + 1] === "{") {
+          const close = text.indexOf("}}", i + 2);
+          if (close !== -1 && close + 2 <= pe && close - i <= 200 && !text.slice(i, close).includes("\n")) {
+            const raw = text.slice(i, close + 2);
+            const strict = STRICT_VARIABLE_RE.exec(raw);
+            inlines.push(
+              this.island("variable", i, close + 2, true, strict ? { name: strict[1] } : { template: true })
+            );
+            i = close + 2;
+            continue;
+          }
+          i += 2;
+          continue;
+        }
+        if (hasKind) {
+          const end = matchingJsonObjectEnd(text, i, pe);
+          if (end !== null) {
+            const kind = declaredKind(text.slice(i, end));
+            if (kind) {
+              inlines.push(this.island("kind_json", i, end, true, jsonMeta(text.slice(i, end))));
+              i = end;
+              continue;
+            }
+          }
+        }
+        i++;
+        continue;
+      }
+      if (ch === "[") {
+        const media = MEDIA_REF_PREFIXES.find((prefix) => text.startsWith(prefix, i));
+        if (media) {
+          const close = text.indexOf("]", i + media.length);
+          if (close !== -1 && close < pe && !text.slice(i, close).includes("\n")) {
+            inlines.push(this.island("media_ref", i, close + 1, true, { media: media.slice(1, 6).toLowerCase() }));
+            i = close + 1;
+            continue;
+          }
+        }
+        i++;
+        continue;
+      }
+      if (ch === "<") {
+        if (text.startsWith("<!--", i)) {
+          const close = text.indexOf("-->", i + 4);
+          if (close === -1) return stop(this.island("html_comment", i, this.n, false));
+          const end = close + 3;
+          const anchor = PINNED_ANCHOR_RE.exec(text.slice(i, end));
+          const type = anchor ? "anchor" : "html_comment";
+          const meta = anchor ? { id: anchor[1] } : {};
+          if (end > pe) return stop(this.island(type, i, end, true, meta));
+          inlines.push(this.island(type, i, end, true, meta));
+          i = end;
+          continue;
+        }
+        const cite = CITE_RE.exec(text.slice(i, i + 64));
+        if (cite) {
+          inlines.push(this.island("cite", i, i + cite[0].length, true, { n: Number(cite[1]) }));
+          i += cite[0].length;
+          continue;
+        }
+        const tag = readXmlTag(text, i);
+        if (tag && i + tag.raw.length <= pe) {
+          const name = tag.tagName;
+          const tagEnd = i + tag.raw.length;
+          const isAttr = ATTRIBUTE_XML_NAMES.includes(name);
+          const isThinking = THINKING_FAMILY.includes(name) && tag.raw === `<${name}>`;
+          if (!tag.isClosing && (isAttr || isThinking)) {
+            if (tag.isSelfClosing) {
+              inlines.push(this.island("xml_inline", i, tagEnd, true, { tag: name, selfClosing: true }));
+              i = tagEnd;
+              continue;
+            }
+            const closer = `</${name}>`;
+            const close = text.indexOf(closer, tagEnd);
+            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 }));
+            inlines.push(this.island("xml_inline", i, end, true, { tag: name }));
+            i = end;
+            continue;
+          }
+          if (tag.isClosing && THINKING_FAMILY.includes(name)) {
+            return stop(this.island("xml_region", i, tagEnd, true, { tag: name, continuation: true }), true);
+          }
+          const lower = name.toLowerCase();
+          inlines.push(
+            this.island(ALLOWED_RAW_HTML_TAGS.has(lower) ? "html_tag" : "xml_tag", i, tagEnd, true, {
+              tag: name
+            })
+          );
+          i = tagEnd;
+          continue;
+        }
+        const pending = ATTRIBUTE_XML_NAMES.find(
+          (name) => text.startsWith(`<${name}`, i) && /\s/.test(text[i + name.length + 1] ?? "")
+        );
+        if (pending && text.indexOf(">", i) === -1) {
+          return stop(this.island("xml_attr", i, this.n, false, { tag: pending }));
+        }
+        i++;
+        continue;
+      }
+      i++;
+    }
+    return { inlines, breakIsland: null, orphan: false };
+  }
+};
+function tokenizeSource(text) {
+  const raw = new Tokenizer(text).run();
+  const cp = buildCodePointIndex(text);
+  const inline = (island) => ({
+    islandType: island.type,
+    inline: true,
+    complete: island.complete,
+    meta: island.meta,
+    start: island.start,
+    end: island.end,
+    startCp: cp.toCodePoint(island.start),
+    endCp: cp.toCodePoint(island.end),
+    raw: text.slice(island.start, island.end)
+  });
+  return raw.map(
+    (block) => ({
+      kind: block.kind,
+      islandType: block.island?.type ?? null,
+      complete: block.island ? block.island.complete : true,
+      meta: block.island?.meta ?? {},
+      inlines: block.inlines.map(inline),
+      start: block.start,
+      end: block.end,
+      startCp: cp.toCodePoint(block.start),
+      endCp: cp.toCodePoint(block.end),
+      raw: text.slice(block.start, block.end)
+    })
+  );
+}
+function joinSource(blocks) {
+  let out = "";
+  for (const block of blocks) out += block.raw;
+  return out;
+}
+function listIslands(blocks) {
+  const out = [];
+  for (const block of blocks) {
+    if (block.kind === "island" && block.islandType) {
+      out.push({
+        islandType: block.islandType,
+        inline: false,
+        complete: block.complete,
+        meta: block.meta,
+        start: block.start,
+        end: block.end,
+        startCp: block.startCp,
+        endCp: block.endCp,
+        raw: block.raw
+      });
+    } else {
+      out.push(...block.inlines);
+    }
+  }
+  return out;
+}
+function blockAt(blocks, offset) {
+  let lo = 0;
+  let hi = blocks.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const block = blocks[mid];
+    if (offset < block.start) hi = mid - 1;
+    else if (offset >= block.end) lo = mid + 1;
+    else return block;
+  }
+  return null;
+}
+
+// source/splice.ts
+var SourceSpliceError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SourceSpliceError";
+  }
+  code;
+};
+function blockEdit(block, text) {
+  return { start: block.start, end: block.end, text };
+}
+function blockRangeEdit(first, last, text) {
+  return { start: first.start, end: last.end, text };
+}
+function commonPrefix(a, b) {
+  const max = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < max && a.charCodeAt(i) === b.charCodeAt(i)) i++;
+  if (i > 0 && (splitsSurrogatePair(a, i) || splitsSurrogatePair(b, i))) i--;
+  return i;
+}
+function commonSuffix(a, b, prefix) {
+  const max = Math.min(a.length, b.length) - prefix;
+  let i = 0;
+  while (i < max && a.charCodeAt(a.length - 1 - i) === b.charCodeAt(b.length - 1 - i)) i++;
+  if (i > 0 && (splitsSurrogatePair(a, a.length - i) || splitsSurrogatePair(b, b.length - i))) i--;
+  return i;
+}
+function spliceSave(original, edits, options = {}) {
+  const blocks = options.blocks ?? tokenizeSource(original);
+  if (options.blocks && joinSource(blocks) !== original) {
+    throw new SourceSpliceError("stale_blocks", "the blocks passed in were not cut from this original text");
+  }
+  const boundaries = /* @__PURE__ */ new Set([0, original.length]);
+  for (const block of blocks) {
+    boundaries.add(block.start);
+    boundaries.add(block.end);
+  }
+  const sorted = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+  let previousEnd = -1;
+  for (const edit of sorted) {
+    if (edit.start < 0 || edit.end > original.length || edit.start > edit.end) {
+      throw new SourceSpliceError("out_of_range", `edit [${edit.start}, ${edit.end}) is outside the text`);
+    }
+    if (!boundaries.has(edit.start) || !boundaries.has(edit.end)) {
+      throw new SourceSpliceError(
+        "misaligned",
+        `edit [${edit.start}, ${edit.end}) does not start and end on block boundaries`
+      );
+    }
+    if (edit.start < previousEnd) {
+      throw new SourceSpliceError("overlap", `edit [${edit.start}, ${edit.end}) overlaps the previous edit`);
+    }
+    previousEnd = edit.end;
+  }
+  const effective = [];
+  for (const edit of sorted) {
+    const old = original.slice(edit.start, edit.end);
+    if (old === edit.text) continue;
+    const prefix = commonPrefix(old, edit.text);
+    const suffix = commonSuffix(old, edit.text, prefix);
+    effective.push({
+      blockStart: edit.start,
+      blockEnd: edit.end,
+      oldStart: edit.start + prefix,
+      oldEnd: edit.end - suffix,
+      replacement: edit.text.slice(prefix, edit.text.length - suffix)
+    });
+  }
+  if (effective.length === 0) {
+    return {
+      text: original,
+      changed: false,
+      changes: [],
+      integrity: { ok: true, bytesOutsideEditsIdentical: true, disturbed: [] },
+      blocks
+    };
+  }
+  let text = "";
+  let cursor = 0;
+  let delta = 0;
+  const pending = [];
+  for (const edit of effective) {
+    text += original.slice(cursor, edit.oldStart);
+    const newStart = edit.oldStart + delta;
+    text += edit.replacement;
+    const newEnd = newStart + edit.replacement.length;
+    pending.push({
+      blockStart: edit.blockStart,
+      blockEnd: edit.blockEnd,
+      oldStart: edit.oldStart,
+      oldEnd: edit.oldEnd,
+      newStart,
+      newEnd
+    });
+    delta += edit.replacement.length - (edit.oldEnd - edit.oldStart);
+    cursor = edit.oldEnd;
+  }
+  text += original.slice(cursor);
+  const oldCp = buildCodePointIndex(original);
+  const newCp = buildCodePointIndex(text);
+  const changes = pending.map((change) => ({
+    ...change,
+    oldStartCp: oldCp.toCodePoint(change.oldStart),
+    oldEndCp: oldCp.toCodePoint(change.oldEnd),
+    newStartCp: newCp.toCodePoint(change.newStart),
+    newEndCp: newCp.toCodePoint(change.newEnd)
+  }));
+  let bytesOutsideEditsIdentical = true;
+  let oldCursor = 0;
+  let newCursor = 0;
+  for (const change of changes) {
+    if (original.slice(oldCursor, change.oldStart) !== text.slice(newCursor, change.newStart)) {
+      bytesOutsideEditsIdentical = false;
+    }
+    oldCursor = change.oldEnd;
+    newCursor = change.newEnd;
+  }
+  if (original.slice(oldCursor) !== text.slice(newCursor)) bytesOutsideEditsIdentical = false;
+  const newBlocks = tokenizeSource(text);
+  const newIslandsByStart = /* @__PURE__ */ new Map();
+  for (const island of listIslands(newBlocks)) {
+    const list = newIslandsByStart.get(island.start);
+    if (list) list.push(island.raw);
+    else newIslandsByStart.set(island.start, [island.raw]);
+  }
+  const disturbed = [];
+  for (const island of listIslands(blocks)) {
+    const touched = effective.some(
+      (edit) => island.start < edit.blockEnd && island.end > edit.blockStart
+    );
+    if (touched) continue;
+    const mappedStart = mapPosition(changes, island.start, { assoc: 1 }).pos;
+    const candidates = newIslandsByStart.get(mappedStart);
+    if (!candidates || !candidates.includes(island.raw)) {
+      disturbed.push({
+        islandType: island.islandType,
+        inline: island.inline,
+        start: island.start,
+        end: island.end,
+        mappedStart
+      });
+    }
+  }
+  const integrity = {
+    ok: bytesOutsideEditsIdentical && disturbed.length === 0,
+    bytesOutsideEditsIdentical,
+    disturbed
+  };
+  if (options.requireIntegrity && !integrity.ok) {
+    throw new SourceSpliceError(
+      "integrity",
+      `the edit disturbed ${disturbed.length} protected island(s) outside the edited blocks`
+    );
+  }
+  return { text, changed: true, changes, integrity, blocks: newBlocks };
+}
+function mapPosition(changes, pos, options = {}) {
+  const assoc = options.assoc ?? 1;
+  const cp = options.unit === "codepoint";
+  let delta = 0;
+  for (const change of changes) {
+    const oldStart = cp ? change.oldStartCp : change.oldStart;
+    const oldEnd = cp ? change.oldEndCp : change.oldEnd;
+    const newStart = cp ? change.newStartCp : change.newStart;
+    const newEnd = cp ? change.newEndCp : change.newEnd;
+    if (pos < oldStart) break;
+    if (pos > oldEnd) {
+      delta = newEnd - oldEnd;
+      continue;
+    }
+    if (oldStart === oldEnd) {
+      return { pos: assoc < 0 ? newStart : newEnd, deleted: false };
+    }
+    if (pos === oldStart) return { pos: newStart, deleted: false };
+    if (pos === oldEnd) return { pos: newEnd, deleted: false };
+    return { pos: assoc < 0 ? newStart : newEnd, deleted: true };
+  }
+  return { pos: pos + delta, deleted: false };
+}
+function mapRange(changes, start, end, unit = "utf16") {
+  const cp = unit === "codepoint";
+  const mappedStart = mapPosition(changes, start, { assoc: 1, unit });
+  const mappedEnd = mapPosition(changes, end, { assoc: -1, unit });
+  const touched = changes.some((change) => {
+    const oldStart = cp ? change.oldStartCp : change.oldStart;
+    const oldEnd = cp ? change.oldEndCp : change.oldEnd;
+    return oldStart < end && oldEnd > start;
+  });
+  const newStart = mappedStart.pos;
+  const newEnd = Math.max(newStart, mappedEnd.pos);
+  return { start: newStart, end: newEnd, touched, collapsed: newEnd === newStart && end > start };
+}
+
 exports.ACTION_BY_CLASS = ACTION_BY_CLASS;
 exports.CAPABILITY_BY_CLASS = CAPABILITY_BY_CLASS;
 exports.CLASSES = CLASSES;
@@ -4996,9 +6411,15 @@ exports.ROOT_STORAGE_NAME = ROOT_STORAGE_NAME;
 exports.RUN_RESULT_KIND = RUN_RESULT_KIND;
 exports.SIDE_EFFECT_CLASSES = SIDE_EFFECT_CLASSES;
 exports.SLUG_PREFIX = SLUG_PREFIX;
+exports.SourceSpliceError = SourceSpliceError;
+exports.XmlContainerTracker = XmlContainerTracker;
 exports.advancePartialKind = advancePartialKind;
 exports.asKindInstance = asKindInstance;
+exports.blockAt = blockAt;
+exports.blockEdit = blockEdit;
+exports.blockRangeEdit = blockRangeEdit;
 exports.buildAgentSchemaWithRenderBlockSupport = buildAgentSchemaWithRenderBlockSupport;
+exports.buildCodePointIndex = buildCodePointIndex;
 exports.buildCompliantKindSnapshot = buildCompliantKindSnapshot;
 exports.buildDirectiveSlug = buildDirectiveSlug;
 exports.buildKindDirective = buildKindDirective;
@@ -5043,17 +6464,22 @@ exports.isLegacyShell = isLegacyShell;
 exports.isProvisionalKind = isProvisionalKind;
 exports.isReservedDirectiveSlug = isReservedDirectiveSlug;
 exports.isScalarArrayType = isScalarArrayType;
+exports.isSingleDollarMath = isSingleDollarMath;
 exports.isTerminalKindEvent = isTerminalKindEvent;
 exports.itemFacts = itemFacts;
 exports.itemSubtitle = itemSubtitle;
 exports.itemTitle = itemTitle;
+exports.joinSource = joinSource;
 exports.kindSchemaFromJsonSchema = kindSchemaFromJsonSchema;
 exports.kindSchemaToJsonSchema = kindSchemaToJsonSchema;
 exports.kindSchemaToStorage = kindSchemaToStorage;
 exports.kindVerdictOf = kindVerdictOf;
 exports.legacyShellUses = legacyShellUses;
+exports.listIslands = listIslands;
 exports.looksLikeDirectiveHead = looksLikeDirectiveHead;
 exports.makePartialKindStalenessGate = makePartialKindStalenessGate;
+exports.mapPosition = mapPosition;
+exports.mapRange = mapRange;
 exports.mergeResidueIntoValue = mergeResidueIntoValue;
 exports.normalizeAiSchemaInput = normalizeAiSchemaInput;
 exports.normalizeJsonRegion = normalizeJsonRegion;
@@ -5068,6 +6494,7 @@ exports.readObjectKind = readObjectKind;
 exports.readOutputRef = readOutputRef;
 exports.readPartialKindEvent = readPartialKindEvent;
 exports.readRunResultValue = readRunResultValue;
+exports.readXmlTag = readXmlTag;
 exports.reconstructRegionValue = reconstructRegionValue;
 exports.rehydrateNodeOutcome = rehydrateNodeOutcome;
 exports.rehydrateRunResult = rehydrateRunResult;
@@ -5082,9 +6509,15 @@ exports.scalarArrayItemType = scalarArrayItemType;
 exports.schemaLayoutMode = schemaLayoutMode;
 exports.schemaStructureDepth = schemaStructureDepth;
 exports.setJsonRootKeyLookup = setJsonRootKeyLookup;
+exports.singleDollarMathEnd = singleDollarMathEnd;
+exports.spliceSave = spliceSave;
+exports.splitsSurrogatePair = splitsSurrogatePair;
 exports.storageToKindSchema = storageToKindSchema;
 exports.stripKindDeep = stripKindDeep;
 exports.titleCaseToken = titleCaseToken;
+exports.toCodePointOffset = toCodePointOffset;
+exports.toUtf16Offset = toUtf16Offset;
+exports.tokenizeSource = tokenizeSource;
 exports.tryDecodeDirective = tryDecodeDirective;
 exports.tryDecodeDirectiveContent = tryDecodeDirectiveContent;
 exports.validateBlockSchemaSavePlan = validateBlockSchemaSavePlan;