@ai-matrx/content-ir 0.21.1 → 0.22.1

package/dist/surfaces.cjs

@@ -0,0 +1,3437 @@
+'use strict';
+
+// source/fence-nesting.ts
+var NESTING_FENCE_LANGUAGES = /* @__PURE__ */ new Set([
+  "markdown",
+  "md",
+  "mdx"
+]);
+function fenceNestsInnerFences(language) {
+  return !!language && NESTING_FENCE_LANGUAGES.has(language.toLowerCase());
+}
+var FENCE_WHITESPACE = " 	\n\r\f\v";
+function isFenceWhitespace(ch) {
+  return ch !== void 0 && ch !== "" && FENCE_WHITESPACE.includes(ch);
+}
+function trimFenceLine(line) {
+  let start = 0;
+  let end = line.length;
+  while (start < end && isFenceWhitespace(line[start])) start++;
+  while (end > start && isFenceWhitespace(line[end - 1])) end--;
+  return start === 0 && end === line.length ? line : line.slice(start, end);
+}
+var FENCE_OPENER_WHITESPACE = "	\n\v\f\r \xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF";
+function isOpenerWhitespace(ch) {
+  return ch !== void 0 && ch !== "" && FENCE_OPENER_WHITESPACE.includes(ch);
+}
+function parseFenceOpener(line) {
+  let start = 0;
+  let end = line.length;
+  while (start < end && isOpenerWhitespace(line[start])) start++;
+  while (end > start && isOpenerWhitespace(line[end - 1])) end--;
+  let ticks = 0;
+  while (start + ticks < end && line[start + ticks] === "`") ticks++;
+  if (ticks < 3) return null;
+  if (line.slice(start + ticks, end).includes("`")) return null;
+  let infoStart = start + ticks;
+  while (infoStart < end && isOpenerWhitespace(line[infoStart])) infoStart++;
+  let langEnd = infoStart;
+  while (langEnd < end && !isOpenerWhitespace(line[langEnd])) langEnd++;
+  return { ticks, lang: line.slice(infoStart, langEnd) };
+}
+function classifyInnerFenceLine(trimmed, openTicks, nests, nestedDepth) {
+  let ticks = 0;
+  while (ticks < trimmed.length && trimmed[ticks] === "`") ticks++;
+  if (ticks < 3) return "content";
+  const info = trimFenceLine(trimmed.slice(ticks));
+  if (info === "") {
+    if (ticks < openTicks) return "content";
+    if (nests && nestedDepth > 0) return "close-nested";
+    return "close-outer";
+  }
+  if (nests && ticks >= openTicks && !info.includes("`")) return "open-nested";
+  return "content";
+}
+
+// source/code-ranges.ts
+function fenceOpenerOf(content) {
+  const t = content.trimStart();
+  if (t.startsWith("```")) {
+    const parsed = parseFenceOpener(t);
+    if (!parsed) return null;
+    return { char: "`", ticks: parsed.ticks, lang: parsed.lang };
+  }
+  if (content.length - t.length <= 3 && t.startsWith("~~~")) {
+    const open = /^(~{3,})(.*)$/.exec(t);
+    if (!open) return null;
+    return { char: "~", ticks: open[1].length, lang: open[2].trim().split(/\s/)[0] ?? "" };
+  }
+  return null;
+}
+var LINE_START = { inString: false, escaped: false };
+var FenceReader = class {
+  opener;
+  depth = 0;
+  /** A nested fence was opened at some point. */
+  sawNested = false;
+  isJson;
+  nesting;
+  tildeCloser;
+  constructor(opener, options = {}) {
+    this.opener = opener;
+    this.isJson = opener.char === "`" && opener.lang === "json";
+    this.nesting = opener.char === "`" && (options.nesting ?? fenceNestsInnerFences(opener.lang));
+    this.tildeCloser = opener.char === "~" ? new RegExp(`^ {0,3}~{${opener.ticks},}[ \\t]*$`) : null;
+  }
+  /** How many nested fences are open right now. */
+  get nestedDepth() {
+    return this.depth;
+  }
+  feed(line) {
+    if (this.tildeCloser) return this.tildeCloser.test(line);
+    const trimmedLine = trimFenceLine(line);
+    const at = line.indexOf("```");
+    if (at === -1) return false;
+    if (this.isJson && jsonStringState(line, 0, at, LINE_START).inString) return false;
+    if (trimmedLine.startsWith("```")) {
+      const kind = classifyInnerFenceLine(trimmedLine, this.opener.ticks, this.nesting, this.depth);
+      if (kind === "close-outer") return true;
+      if (kind === "open-nested") {
+        this.depth++;
+        this.sawNested = true;
+      }
+      if (kind === "close-nested") this.depth--;
+    } else {
+      const closeTicks = backtickRunLength(line, at);
+      const after = trimFenceLine(line.slice(at + closeTicks));
+      if (closeTicks >= this.opener.ticks && after === "" && this.depth === 0) return true;
+    }
+    return false;
+  }
+};
+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 };
+}
+function readFence(src, open, reader) {
+  for (let k = open + 1; k < src.count; k++) {
+    if (src.openTail?.(k)) continue;
+    const line = src.line(k);
+    if (line === null) return { line: k - 1, closed: false, reader };
+    if (reader.feed(line)) return { line: k, closed: true, reader };
+  }
+  return { line: src.count - 1, closed: false, reader };
+}
+function jsonStringState(line, from, upTo, state2) {
+  let { inString, escaped } = state2;
+  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(str, pos) {
+  let n = 0;
+  while (pos + n < str.length && str[pos + n] === "`") n++;
+  return n;
+}
+function quotePrefix(line) {
+  let depth = 0;
+  let offset = 0;
+  for (; ; ) {
+    const m = /^ {0,3}> ?/.exec(line.slice(offset));
+    if (!m) return { depth, offset };
+    depth++;
+    offset += m[0].length;
+  }
+}
+function stripQuotes(line, depth) {
+  let offset = 0;
+  for (let d = 0; d < depth; d++) {
+    const m = /^ {0,3}> ?/.exec(line.slice(offset));
+    if (!m) return null;
+    offset += m[0].length;
+  }
+  return line.slice(offset);
+}
+var LIST_ITEM = /^( *)([-*+]|\d{1,9}[.)])( +|\t|$)/;
+function leadingSpaces(s) {
+  let i = 0;
+  while (i < s.length && s[i] === " ") i++;
+  return i;
+}
+function scan(text) {
+  const starts = [];
+  const ends = [];
+  for (let pos = 0; ; ) {
+    const nl = text.indexOf("\n", pos);
+    const lineEnd = nl === -1 ? text.length : nl;
+    starts.push(pos);
+    ends.push(lineEnd > pos && text.charCodeAt(lineEnd - 1) === 13 ? lineEnd - 1 : lineEnd);
+    if (nl === -1) break;
+    pos = nl + 1;
+  }
+  const count = starts.length;
+  const raw = (k) => text.slice(starts[k], ends[k]);
+  const out = { ranges: [], fences: [], paragraphs: [], endsInFence: false, pendingPara: -1 };
+  const rawLines = { count, line: raw };
+  let segment = 0;
+  for (let k = 0; k < count; k++) {
+    const opener = fenceOpenerOf(raw(k));
+    if (!opener || opener.char !== "`") continue;
+    prose(text, starts, ends, raw, segment, k, out);
+    const end = closeFence(rawLines, k, opener);
+    out.ranges.push({ start: starts[k], end: ends[end.line], kind: "fence" });
+    out.fences.push([k, end.line, end.closed]);
+    out.pendingPara = -1;
+    if (!end.closed && end.line === count - 1) out.endsInFence = true;
+    k = end.line;
+    segment = k + 1;
+  }
+  prose(text, starts, ends, raw, segment, count, out);
+  return out;
+}
+function prose(text, starts, ends, raw, from, to, out) {
+  let para = -1;
+  let quoteDepth2 = 0;
+  let lists = [];
+  const closePara = (at) => {
+    if (para !== -1) out.paragraphs.push([para, at]);
+    para = -1;
+  };
+  for (let k = from; k < to; k++) {
+    const line = raw(k);
+    const { depth, offset } = quotePrefix(line);
+    if (depth !== quoteDepth2) {
+      quoteDepth2 = depth;
+      lists = [];
+    }
+    let content = line.slice(offset);
+    if (content.trim() === "") {
+      closePara(starts[k]);
+      if (!(k === starts.length - 1 && line === "")) out.pendingPara = -1;
+      continue;
+    }
+    const indent = leadingSpaces(content);
+    while (lists.length && indent < lists[lists.length - 1]) lists.pop();
+    const item = LIST_ITEM.exec(content);
+    let column = lists.length ? lists[lists.length - 1] : 0;
+    if (item) {
+      const gap = item[3].length;
+      column = item[1].length + item[2].length + (gap >= 1 && gap <= 4 ? gap : 1);
+      lists.push(column);
+      content = content.slice(Math.min(column, content.length));
+    } else {
+      content = content.slice(Math.min(indent, column));
+    }
+    const opener = fenceOpenerOf(content);
+    if (!opener) {
+      if (para === -1) para = starts[k];
+      if (out.pendingPara === -1) out.pendingPara = starts[k];
+      continue;
+    }
+    closePara(starts[k]);
+    out.pendingPara = -1;
+    const col = column;
+    const src = {
+      count: to,
+      line: (j) => {
+        const inner = stripQuotes(raw(j), depth);
+        if (inner === null) return null;
+        if (opener.char === "~" && col > 0) {
+          const ind = leadingSpaces(inner);
+          if (inner.trim() !== "" && ind < col) return null;
+          return inner.slice(Math.min(ind, col));
+        }
+        return inner;
+      }
+    };
+    const end = closeFence(src, k, opener);
+    out.ranges.push({ start: starts[k], end: ends[end.line], kind: "fence" });
+    out.fences.push([k, end.line, end.closed]);
+    if (!end.closed && end.line === starts.length - 1) out.endsInFence = true;
+    k = end.line;
+  }
+  closePara(to < starts.length ? starts[to] : text.length);
+}
+var BacktickRuns = class {
+  /** Every run, in order: [start, length]. */
+  all = [];
+  byLength = /* @__PURE__ */ new Map();
+  indexOf = /* @__PURE__ */ new Map();
+  constructor(text, from, to) {
+    for (let k = from; k < to; ) {
+      if (text.charCodeAt(k) !== 96) {
+        k++;
+        continue;
+      }
+      let len = 1;
+      while (k + len < to && text.charCodeAt(k + len) === 96) len++;
+      this.indexOf.set(k, this.all.length);
+      this.all.push([k, len]);
+      const list = this.byLength.get(len);
+      if (list) list.push(k);
+      else this.byLength.set(len, [k]);
+      k += len;
+    }
+  }
+  /** Start of the first run of exactly `n` backticks at or after `after`, or -1. */
+  next(n, after) {
+    const list = this.byLength.get(n);
+    if (!list) return -1;
+    let lo = 0;
+    let hi = list.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (list[mid] < after) lo = mid + 1;
+      else hi = mid;
+    }
+    return list[lo] ?? -1;
+  }
+  /** Index of the run starting at `start` in `all`. */
+  index(start) {
+    return this.indexOf.get(start) ?? -1;
+  }
+};
+function codeSpans(text, from, to, out) {
+  let runs = null;
+  for (let i = from; i < to; ) {
+    const ch = text.charCodeAt(i);
+    if (ch === 92) {
+      i += 2;
+      continue;
+    }
+    if (ch !== 96) {
+      i++;
+      continue;
+    }
+    const n = backtickRunLength(text, i);
+    const len = Math.min(n, to - i);
+    runs ??= new BacktickRuns(text, from, to);
+    const close = runs.next(len, i + len);
+    if (close === -1) {
+      i += len;
+      continue;
+    }
+    out.push({ start: i, end: close + len, kind: "span" });
+    i = close + len;
+  }
+}
+function findCodeRanges(text) {
+  const s = scan(text);
+  const ranges = [...s.ranges];
+  for (const [from, to] of s.paragraphs) codeSpans(text, from, to, ranges);
+  return ranges.sort((a, b) => a.start - b.start);
+}
+function fenceParts(raw) {
+  const lines = raw.split("\n").map((l) => l.endsWith("\r") ? l.slice(0, -1) : l);
+  const { offset } = quotePrefix(lines[0] ?? "");
+  const opener = fenceOpenerOf((lines[0] ?? "").slice(offset).replace(/^ *(?:[-*+]|\d{1,9}[.)])(?= |\t|$) ?/, ""));
+  if (!opener) return null;
+  const rest = lines.slice(1);
+  const closed = rest.length > 0 && new FenceReader(opener, { nesting: false }).feed(rest[rest.length - 1]);
+  if (!closed) return { opener, body: rest.join("\n"), closed };
+  const last = rest[rest.length - 1];
+  const before = trimFenceLine(last).startsWith("```") ? "" : last.slice(0, last.indexOf("```"));
+  return { opener, body: [...rest.slice(0, -1), ...before.trim() ? [before] : []].join("\n"), closed };
+}
+
+// source/xml-tag.ts
+var XML_NAME_START = /[A-Za-z_]/;
+var XML_NAME_CHARACTER = /[\w.:-]/;
+var WHITESPACE = /\s/;
+function readXmlTag(content, start, find = (needle, from) => content.indexOf(needle, from)) {
+  if (content[start] !== "<") return null;
+  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;
+    const valueEnd = find(quote, valueStart);
+    if (valueEnd === -1) return null;
+    cursor = valueEnd;
+    attributes.push({ name, value: content.slice(valueStart, cursor) });
+    cursor++;
+  }
+  return null;
+}
+
+// surfaces/json-kind-signal.ts
+var UNDECIDED_LIMIT_CHARS = 2e3;
+var KIND_KEY_BODY = [..."__kind"].map((ch) => {
+  const hex = ch.charCodeAt(0).toString(16).padStart(4, "0");
+  const escaped = [...hex].map((d) => /[a-f]/.test(d) ? `[${d}${d.toUpperCase()}]` : d).join("");
+  return `(?:${ch}|\\\\u${escaped})`;
+}).join("");
+var KIND_KEY = new RegExp(String.raw`(?<!\\)"${KIND_KEY_BODY}"\s*:`);
+var JSON5_KIND_KEY = /(?:^|[{,]\s*|\n\s*)(?:__kind|'__kind')\s*:/;
+var JSON5_KIND_SLUG = /(?:^|[{,]\s*|\n\s*)(?:__kind|'__kind'|"__kind")\s*:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/;
+var MARKDOWN_KIND_KEY = /(?<!\\)"(?:\\_\\_|\\__|_\\_)kind"\s*:/;
+var ESCAPED_KIND_KEY = /\\+"__kind\\+"\s*:/;
+var ESCAPED_KIND_SLUG = /\\+"__kind\\+"\s*:\s*\\+"([A-Za-z0-9_.:-]+)\\+"/;
+var ALL_KIND_SPELLINGS = Object.freeze({
+  markdown: true,
+  escaped: true,
+  python: true,
+  smart: true,
+  entity: true,
+  js: true
+});
+var JSON_KIND_SPELLINGS = Object.freeze({ markdown: true });
+function hasJsonKindKey(source) {
+  return hasKindKey(source, JSON_KIND_SPELLINGS);
+}
+function hasDetectionOnlyKindKey(source) {
+  return !hasJsonKindKey(source) && (hasKindKey(source, ALL_KIND_SPELLINGS) || hasExoticKindKey(source));
+}
+var ZERO_WIDTH = /[\u200B-\u200D\u2060\uFEFF\u00AD]/g;
+var HAS_ZERO_WIDTH = /[\u200B-\u200D\u2060\uFEFF\u00AD]/;
+function withoutZeroWidth(text) {
+  return HAS_ZERO_WIDTH.test(text) ? text.replace(ZERO_WIDTH, "") : text;
+}
+var PYTHON_KIND_KEY = /[{,]\s*'__kind'\s*:\s*['"]/;
+var PYTHON_KIND_SLUG = /[{,]\s*'__kind'\s*:\s*(?:'([A-Za-z0-9_.:-]+)'|"([A-Za-z0-9_.:-]+)")/;
+var SMART_DOUBLE = "\u201C\u201D\u201E\u201F\u2033";
+var SMART_SINGLE = "\u2018\u2019\u201A\u201B\u2032";
+var SMART_KIND_KEY = new RegExp(`[${SMART_DOUBLE}${SMART_SINGLE}]__kind[${SMART_DOUBLE}${SMART_SINGLE}"']\\s*:`);
+var ENTITY_QUOTE = "&(?:[qQ][uU][oO][tT]|[aA][pP][oO][sS]|#0*3[49]|#[xX]0*2[27]);";
+var ENTITY_KIND_KEY = new RegExp(`${ENTITY_QUOTE}__kind${ENTITY_QUOTE}\\s*:`);
+function isJson5Language(lang) {
+  return (lang ?? "").trim().toLowerCase() === "json5";
+}
+function hasKindKey(source, options = {}) {
+  const text = withoutZeroWidth(source);
+  return KIND_KEY.test(text) || options.python === true && PYTHON_KIND_KEY.test(text) || options.json5 === true && JSON5_KIND_KEY.test(text) || options.markdown === true && MARKDOWN_KIND_KEY.test(text) || options.escaped === true && ESCAPED_KIND_KEY.test(text) || options.smart === true && SMART_KIND_KEY.test(text) || options.entity === true && ENTITY_KIND_KEY.test(text) || options.js === true && JS_KIND_KEY.test(text) || // Every realistic spelling COMBINED in one key (escaped + zero-width,
+  // repr + zero-width, `"\__kind"`, `{\"\\_\\_kind\"…}` — L-1, round 9).
+  options.escaped === true && options.python === true && options.smart === true && options.markdown === true && hasSpelledKey(source);
+}
+var JS_KIND_KEY = /[{,]\s*__kind\s*:\s*['"]/;
+function hasExoticKindKey(text) {
+  if (!/kind|&#|&amp;|\uFF3F/i.test(text)) return false;
+  let plain = text.replace(EXOTIC_INVISIBLE, "").replace(/\uFF02/g, '"').replace(/\uFF07/g, "'").replace(/\uFF3F/g, "_");
+  for (let pass = 0; pass < 3 && plain.includes("&"); pass++) plain = plain.replace(LOOSE_ENTITY, looseEntity);
+  return plain !== text && hasKindKey(plain, ALL_KIND_SPELLINGS);
+}
+var EXOTIC_INVISIBLE = /[\p{Cf}\u034F\u115F\u1160\u17B4\u17B5\u180E\u3164\uFFA0]/gu;
+var LOOSE_ENTITY = /&(#[xX][0-9a-fA-F]{1,8}|#\d{1,8}|[A-Za-z]{2,8});/g;
+var LOOSE_NAMED = { quot: '"', apos: "'", amp: "&", lt: "<", gt: ">", lowbar: "_" };
+function looseEntity(whole, body) {
+  if (body.startsWith("#")) {
+    const code = body[1] === "x" || body[1] === "X" ? Number.parseInt(body.slice(2), 16) : Number.parseInt(body.slice(1), 10);
+    return Number.isFinite(code) && code > 0 && code < 1114112 ? String.fromCodePoint(code) : whole;
+  }
+  return LOOSE_NAMED[body.toLowerCase()] ?? whole;
+}
+function hasKindKeyAnySpelling(source) {
+  return hasKindKey(source, ALL_KIND_SPELLINGS);
+}
+var KIND_SLUG = new RegExp(
+  String.raw`(?<!\\)"${KIND_KEY_BODY}"\s*:\s*("(?:[^"\\]|\\.)*")`
+);
+var SLUG_TEXT = /^[A-Za-z0-9_.:-]+$/;
+function isKindSlug(value) {
+  return typeof value === "string" && SLUG_TEXT.test(value);
+}
+function firstKindSlug(source, options = {}) {
+  const text = withoutZeroWidth(source);
+  let literal = KIND_SLUG.exec(text)?.[1];
+  if (!literal && (options.json5 || options.js)) {
+    const json5 = JSON5_KIND_SLUG.exec(text)?.[1];
+    literal = json5?.startsWith("'") ? JSON.stringify(json5.slice(1, -1)) : json5;
+  }
+  if (!literal && options.escaped) {
+    const escaped = ESCAPED_KIND_SLUG.exec(text)?.[1];
+    if (escaped) return escaped;
+  }
+  if (!literal && options.python) {
+    const python = PYTHON_KIND_SLUG.exec(text);
+    if (python) return python[1] ?? python[2] ?? null;
+  }
+  if (!literal && (options.smart || options.entity || options.markdown)) {
+    const canonical = normalizeKindSpellings(text);
+    if (canonical !== text) return firstKindSlug(canonical, { ...options, smart: false, entity: false, markdown: false });
+  }
+  if (!literal) return null;
+  let slug;
+  try {
+    slug = JSON.parse(literal);
+  } catch {
+    return null;
+  }
+  return typeof slug === "string" && SLUG_TEXT.test(slug) ? slug : null;
+}
+var PARTIAL_KIND_KEY_TAIL = /"__k(?:i(?:n(?:d(?:"\s*)?)?)?)?$/;
+function endsInPartialKindKey(text) {
+  const tail = PARTIAL_KIND_KEY_TAIL.exec(text);
+  if (!tail) return false;
+  return isObjectKeyPosition(text, tail.index);
+}
+function isObjectKeyPosition(text, quoteAt) {
+  const stack = [];
+  let expectKey = false;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < quoteAt; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      expectKey = false;
+    } else if (ch === "{" || ch === "[") {
+      stack.push(ch);
+      expectKey = ch === "{";
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      expectKey = false;
+    } else if (ch === ",") {
+      expectKey = stack[stack.length - 1] === "{";
+    } else if (ch === ":") {
+      expectKey = false;
+    }
+  }
+  return !inString && expectKey;
+}
+function withoutLeadingJsonComments(text) {
+  let i = 0;
+  for (; ; ) {
+    i = skipWs(text, i);
+    if (text.startsWith("//", i)) {
+      const end = text.indexOf("\n", i);
+      if (end === -1) return "";
+      i = end + 1;
+    } else if (text.startsWith("/*", i)) {
+      const end = text.indexOf("*/", i + 2);
+      if (end === -1) return "";
+      i = end + 2;
+    } else {
+      return i === 0 ? text : text.slice(i);
+    }
+  }
+}
+function jsonKindSignal(text, options = {}) {
+  const source = withoutLeadingJsonComments(text ?? "");
+  if (hasKindKey(source, options)) return "kind";
+  let i = skipWs(source, 0);
+  if (i >= source.length) return "undecided";
+  if (source[i] === "[") {
+    i = skipWs(source, i + 1);
+    if (i >= source.length) return capped(source);
+    if (source[i] !== "{") return notKindUnlessPartialKey(source);
+  }
+  if (source[i] !== "{") return notKindUnlessPartialKey(source);
+  i = skipWs(source, i + 1);
+  if (i >= source.length) return capped(source);
+  if (source[i] !== '"') return notKindUnlessPartialKey(source);
+  let j = i + 1;
+  while (j < source.length) {
+    const ch = source[j];
+    if (ch === "\\") {
+      j += 2;
+      continue;
+    }
+    if (ch === '"') {
+      return withoutZeroWidth(decodedKey(source.slice(i, j + 1))) === "__kind" ? "kind" : notKindUnlessPartialKey(source);
+    }
+    j++;
+  }
+  return capped(source);
+}
+function notKindUnlessPartialKey(source) {
+  return endsInPartialKindKey(source) ? "undecided" : "not_kind";
+}
+function decodedKey(literal) {
+  try {
+    const key = JSON.parse(literal);
+    return typeof key === "string" ? key : literal.slice(1, -1);
+  } catch {
+    return literal.slice(1, -1);
+  }
+}
+function capped(source) {
+  return source.length > UNDECIDED_LIMIT_CHARS ? "not_kind" : "undecided";
+}
+function skipWs(source, from) {
+  let i = from;
+  while (i < source.length && /\s/.test(source[i] ?? "")) i++;
+  return i;
+}
+function json5AsJson(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"' || ch === "'") {
+      let j = i + 1;
+      let body = "";
+      while (j < text.length && text[j] !== ch) {
+        if (text[j] === "\\") {
+          body += text[j] + (text[j + 1] ?? "");
+          j += 2;
+          continue;
+        }
+        body += ch === "'" && text[j] === '"' ? '\\"' : text[j];
+        j++;
+      }
+      out += `"${body}"`;
+      i = j + 1;
+      continue;
+    }
+    if (text.startsWith("//", i)) {
+      const end = text.indexOf("\n", i);
+      i = end === -1 ? text.length : end;
+      continue;
+    }
+    if (text.startsWith("/*", i)) {
+      const end = text.indexOf("*/", i + 2);
+      i = end === -1 ? text.length : end + 2;
+      continue;
+    }
+    const key = /^[A-Za-z_$][\w$]*(?=\s*:)/.exec(text.slice(i));
+    if (key && /[{,]\s*$/.test(out)) {
+      out += `"${key[0]}"`;
+      i += key[0].length;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  out = out.replace(/,(\s*[}\]])/g, "$1");
+  try {
+    JSON.parse(out);
+    return out;
+  } catch {
+    return null;
+  }
+}
+function pythonReprAsJson(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "'" || ch === '"') {
+      let j = i + 1;
+      let body = "";
+      while (j < text.length && text[j] !== ch) {
+        if (text[j] === "\\") {
+          const next = text[j + 1] ?? "";
+          body += next === "'" ? "'" : `\\${next}`;
+          j += 2;
+          continue;
+        }
+        body += text[j] === '"' ? '\\"' : text[j];
+        j++;
+      }
+      if (j >= text.length) return null;
+      out += `"${body}"`;
+      i = j + 1;
+      continue;
+    }
+    const word = /^(?:True|False|None)\b/.exec(text.slice(i, i + 5));
+    if (word) {
+      out += word[0] === "True" ? "true" : word[0] === "False" ? "false" : "null";
+      i += word[0].length;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  try {
+    JSON.parse(out);
+    return out;
+  } catch {
+    return null;
+  }
+}
+function hasPythonKindKey(text) {
+  return PYTHON_KIND_KEY.test(withoutZeroWidth(text));
+}
+function pythonBalancedEnd(text, start) {
+  let depth = 0;
+  let quote = null;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === "\\") i++;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') quote = ch;
+    else if (ch === "{" || ch === "[") depth++;
+    else if (ch === "}" || ch === "]") {
+      depth--;
+      if (depth === 0) return i + 1;
+    }
+  }
+  return null;
+}
+function normalizeKindSpellings(source) {
+  if (!mayHoldKindKey(source)) return source;
+  if (/^[{[]/.test(source.trimStart())) {
+    try {
+      JSON.parse(source);
+      return withoutZeroWidthInKeys(source);
+    } catch {
+    }
+  }
+  let out = "";
+  let cursor = 0;
+  for (const region of scanKindSpellingRegions(source)) {
+    const rewritten = canonicalRegionText(source, region);
+    if (rewritten === null) continue;
+    out += source.slice(cursor, region.rewriteStart) + rewritten;
+    cursor = region.rewriteEnd;
+  }
+  return cursor === 0 ? source : out + source.slice(cursor);
+}
+function canonicalRegionText(source, region) {
+  if (region.family === "lifted") {
+    if (region.markdown) return region.status === "broken" ? closedJson(region) ?? region.decoded : region.decoded;
+    const key = source.slice(region.rewriteStart, region.rewriteEnd);
+    return region.keyText === void 0 || key === region.keyText ? null : region.keyText;
+  }
+  if (region.status === "complete") {
+    const json = regionJson(region);
+    if (json !== null) return json;
+    return region.family === "python" || region.family === "js" ? null : region.decoded;
+  }
+  if (region.status === "broken") return closedJson(region) ?? region.decoded;
+  return region.family === "python" || region.family === "js" ? null : region.decoded;
+}
+var ZW = "[\\u200B-\\u200D\\u2060\\uFEFF\\u00AD]";
+var KEY_UNDERSCORE = String.raw`(?:\\*_|\\u005[fF]|&#0*95;|&#[xX]0*5[fF];|&lowbar;|&UnderBar;)`;
+var KEY_CORE = `${ZW}*${KEY_UNDERSCORE}${ZW}*${KEY_UNDERSCORE}${ZW}*k${ZW}*i${ZW}*n${ZW}*d${ZW}*`;
+var SMART_ANY = `[${SMART_DOUBLE}${SMART_SINGLE}]`;
+var SPELLED_KEY_SOURCE = [
+  String.raw`(\\*)"(${KEY_CORE})\\*"\s*:`,
+  String.raw`(?<=[{,]\s*)'(${KEY_CORE})'\s*:(?=\s*['"])`,
+  `${SMART_ANY}(${KEY_CORE})[${SMART_DOUBLE}${SMART_SINGLE}"']\\s*:`,
+  `${ENTITY_QUOTE}(${KEY_CORE})${ENTITY_QUOTE}\\s*:`,
+  String.raw`(?<=[{,]\s*)(${KEY_CORE})\s*:(?=\s*['"])`
+].join("|");
+var SPELLED_KEY = new RegExp(SPELLED_KEY_SOURCE);
+var SPELLED_KEY_G = new RegExp(SPELLED_KEY_SOURCE, "g");
+function hasSpelledKey(text) {
+  return mayHoldKindKey(text) && SPELLED_KEY.test(text);
+}
+function mayHoldKindKey(text) {
+  return text.includes("kind") || text.includes("_") && HAS_ZERO_WIDTH.test(text);
+}
+var MAX_REGIONS_PER_CALL = 2e3;
+var KEY_LOOKBEHIND = 64;
+function nextKindHit(text, from, zeroWidth) {
+  if (!zeroWidth) return text.indexOf("kind", from);
+  KIND_LETTERS_G.lastIndex = from;
+  const m = KIND_LETTERS_G.exec(text);
+  return m ? m.index : -1;
+}
+var KIND_LETTERS_G = new RegExp(`k${ZW}*i${ZW}*n${ZW}*d`, "g");
+function keyFamily(m) {
+  if (m[3] !== void 0) return { family: "python", core: m[3], levels: 0 };
+  if (m[4] !== void 0) return { family: "smart", core: m[4], levels: 0 };
+  if (m[5] !== void 0) return { family: "entity", core: m[5], levels: 0 };
+  if (m[6] !== void 0) return { family: "js", core: m[6], levels: 0 };
+  const backslashes = m[1].length;
+  const core = m[2];
+  if (core.includes("&")) return { family: "entity", core, levels: 0 };
+  if (backslashes > 0) {
+    return { family: "escaped", core, levels: Math.min(4, Math.ceil(Math.log2(backslashes + 1))) };
+  }
+  const plain = core.replace(ZERO_WIDTH, "");
+  if (plain === "__kind" || /^\\u005[fF]_kind$/.test(plain)) return { family: "lifted", core, levels: 0 };
+  if (plain === "\\_\\_kind") return { family: "lifted", core, levels: 0 };
+  return { family: "markdown", core, levels: 0 };
+}
+function scanKindSpellingRegions(text, options = {}) {
+  const jsonOnly = options.families !== "all";
+  const from = options.from ?? 0;
+  const regions = [];
+  if (!mayHoldKindKey(text)) return regions;
+  const zeroWidth = HAS_ZERO_WIDTH.test(text);
+  let quoted = null;
+  const inQuoted = (at) => {
+    quoted ??= quotedSourceRanges(text);
+    let lo = 0;
+    let hi = quoted.length - 1;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const [a, b] = quoted[mid];
+      if (at < a) hi = mid - 1;
+      else if (at >= b) lo = mid + 1;
+      else return true;
+    }
+    return false;
+  };
+  let cursor = from;
+  let braceScan = from;
+  let lastBrace = -1;
+  let deadBraceFloor = from;
+  const reach = { left: REACH_BUDGET_FACTOR * text.length + REACH_BUDGET_FLOOR };
+  let hit = nextKindHit(text, from, zeroWidth);
+  while (hit >= 0 && regions.length < MAX_REGIONS_PER_CALL) {
+    const windowStart = Math.max(cursor, hit - KEY_LOOKBEHIND);
+    const windowEnd = Math.min(text.length, hit + KEY_LOOKBEHIND);
+    SPELLED_KEY_G.lastIndex = 0;
+    const window = text.slice(windowStart, windowEnd);
+    let m = null;
+    for (let candidate = SPELLED_KEY_G.exec(window); candidate; candidate = SPELLED_KEY_G.exec(window)) {
+      if (windowStart + candidate.index + candidate[0].length > hit) {
+        m = candidate;
+        break;
+      }
+    }
+    if (!m) {
+      hit = nextKindHit(text, hit + 1, zeroWidth);
+      continue;
+    }
+    const keyAt = windowStart + m.index;
+    const keyEnd = keyAt + m[0].length;
+    const next = () => nextKindHit(text, keyEnd, zeroWidth);
+    while (braceScan < keyAt) {
+      if (text.charCodeAt(braceScan) === 123) lastBrace = braceScan;
+      braceScan++;
+    }
+    const brace = lastBrace >= Math.max(cursor, deadBraceFloor) ? lastBrace : -1;
+    if (brace < 0 || inQuoted(keyAt) || inQuoted(brace)) {
+      hit = next();
+      continue;
+    }
+    const { family, core, levels } = keyFamily(m);
+    if (jsonOnly && family !== "lifted" && family !== "markdown") {
+      hit = next();
+      continue;
+    }
+    const markdown = /\\_/.test(core) || family === "escaped" && /\\{2}_/.test(core);
+    const plan = decodePlan(family, levels, markdown);
+    const region = boundRegion(text, brace, keyAt, plan, reach);
+    if (!region) {
+      deadBraceFloor = brace + 1;
+      hit = next();
+      continue;
+    }
+    if (family === "lifted" && !markdown) {
+      regions.push({
+        start: brace,
+        end: region.end,
+        rewriteStart: keyAt,
+        rewriteEnd: keyEnd,
+        keyText: m[0].replace(ZERO_WIDTH, ""),
+        family,
+        status: region.status,
+        decoded: withoutZeroWidthInKeys(region.decoded),
+        markdown: false
+      });
+    } else {
+      regions.push({
+        start: brace,
+        end: region.end,
+        rewriteStart: brace,
+        rewriteEnd: region.end,
+        family,
+        status: region.status,
+        decoded: withoutZeroWidthInKeys(region.decoded),
+        markdown
+      });
+    }
+    cursor = region.end;
+    if (region.status === "prefix") break;
+    hit = nextKindHit(text, cursor, zeroWidth);
+  }
+  return regions;
+}
+var ZW_KEY_IN_DECODED = new RegExp(`(["'])${ZW}*_${ZW}*_${ZW}*k${ZW}*i${ZW}*n${ZW}*d${ZW}*\\1(?=\\s*:)`, "g");
+function withoutZeroWidthInKeys(decoded) {
+  return HAS_ZERO_WIDTH.test(decoded) ? decoded.replace(ZW_KEY_IN_DECODED, (key) => key.replace(ZERO_WIDTH, "")) : decoded;
+}
+function decodePlan(family, levels, markdown) {
+  const steps = [];
+  if (family === "entity") steps.push(entityStep);
+  if (family === "smart") steps.push(smartStep);
+  for (let level = 0; level < levels; level++) steps.push(escapeStep);
+  if (markdown) steps.push(markdownStep);
+  const grammar = family === "js" ? "js" : family === "python" || family === "smart" || family === "entity" ? "python" : "json";
+  return { steps, grammar };
+}
+function decodeWith(raw, step) {
+  let text = "";
+  const map = [];
+  for (let i = 0; i < raw.length; ) {
+    const [out, consumed] = step(raw, i);
+    for (let k = 0; k < out.length; k++) map.push(i);
+    text += out;
+    i += Math.max(1, consumed);
+  }
+  map.push(raw.length);
+  return { text, map };
+}
+function decodeChain(raw, steps) {
+  if (steps.length === 0) {
+    const map = new Array(raw.length + 1);
+    for (let i = 0; i <= raw.length; i++) map[i] = i;
+    return { text: raw, map };
+  }
+  let current = decodeWith(raw, steps[0]);
+  for (let s = 1; s < steps.length; s++) {
+    const next = decodeWith(current.text, steps[s]);
+    const prior = current.map;
+    current = { text: next.text, map: next.map.map((at) => prior[at]) };
+  }
+  return current;
+}
+var ENTITY_STEP_RE = /^&(?:(quot|apos|amp|lt|gt|lowbar|UnderBar)|#(\d{1,6})|#[xX]([0-9a-fA-F]{1,6}));/i;
+var NAMED_ENTITIES = { quot: '"', apos: "'", amp: "&", lt: "<", gt: ">", lowbar: "_", underbar: "_" };
+var ESCAPE_CHARS = { '"': '"', "\\": "\\", "/": "/", n: "\n", t: "	", r: "\r", b: "", f: "" };
+var entityStep = (raw, i) => {
+  if (raw[i] !== "&") return [raw[i], 1];
+  const m = ENTITY_STEP_RE.exec(raw.slice(i, i + 12));
+  if (!m) return ["&", 1];
+  const ch = m[1] ? NAMED_ENTITIES[m[1].toLowerCase()] : String.fromCodePoint(Number.parseInt(m[2] ?? m[3], m[2] ? 10 : 16));
+  return [ch, m[0].length];
+};
+var smartStep = (raw, i) => {
+  const ch = raw[i];
+  if (SMART_DOUBLE.includes(ch)) return ['"', 1];
+  if (SMART_SINGLE.includes(ch)) return ["'", 1];
+  return [ch, 1];
+};
+var escapeStep = (raw, i) => {
+  if (raw[i] !== "\\") return [raw[i], 1];
+  const next = raw[i + 1] ?? "";
+  if (next in ESCAPE_CHARS) return [ESCAPE_CHARS[next], 2];
+  if (next === "u" && /^[0-9a-fA-F]{4}$/.test(raw.slice(i + 2, i + 6))) return [raw.slice(i, i + 6), 6];
+  return [raw.slice(i, i + 2), 2];
+};
+var markdownStep = (raw, i) => raw[i] === "\\" && raw[i + 1] === "_" ? ["_", 2] : [raw[i], 1];
+var FIRST_WINDOW = 128;
+var REACH_BUDGET_FACTOR = 4;
+var REACH_BUDGET_FLOOR = 65536;
+function boundRegion(text, brace, keyAt, plan, reach = { left: Number.POSITIVE_INFINITY }) {
+  for (let width = FIRST_WINDOW; ; width *= 4) {
+    const hi = Math.min(text.length, brace + width);
+    const atEnd = hi === text.length;
+    const decoded = decodeChain(text.slice(brace, hi), plan.steps);
+    const keyDecoded = firstAtOrAfter(decoded.map, keyAt - brace);
+    const verdict = kindGrammar(decoded.text, plan.grammar);
+    if (verdict.status === "complete") {
+      if (verdict.end <= keyDecoded) return null;
+      return { end: brace + decoded.map[verdict.end], status: "complete", decoded: decoded.text.slice(0, verdict.end) };
+    }
+    if (verdict.status === "broken") {
+      if (!atEnd && decoded.map[verdict.at] >= hi - brace - 16) continue;
+      if (!verdict.prose) {
+        const end = balancedEnd(decoded.text, plan.grammar !== "json");
+        if (end === null && !atEnd) {
+          const past = hi - brace - verdict.at;
+          if (reach.left > past) {
+            reach.left -= past;
+            continue;
+          }
+        }
+        if (end !== null && end > keyDecoded && lenientlyParses(decoded.text.slice(0, end), plan.grammar)) {
+          return { end: brace + decoded.map[end], status: "complete", decoded: decoded.text.slice(0, end) };
+        }
+      }
+      if (atEnd && ARRIVING_SPELLING_TAIL.test(text.slice(brace + decoded.map[verdict.at]))) {
+        if (verdict.at <= keyDecoded) return null;
+        return { end: text.length, status: "prefix", decoded: decoded.text };
+      }
+      if (verdict.cut <= keyDecoded) return null;
+      return { end: brace + decoded.map[verdict.cut], status: "broken", decoded: decoded.text.slice(0, verdict.cut) };
+    }
+    if (!atEnd) continue;
+    return { end: text.length, status: "prefix", decoded: decoded.text };
+  }
+}
+var BARE_REGION_GRAMMAR_BUDGET = 16384;
+function bareRegionBreaksIntoProse(text, options = {}) {
+  let region = text;
+  if (region.length > BARE_REGION_GRAMMAR_BUDGET) {
+    if (!options.firstBudget) return false;
+    region = region.slice(0, BARE_REGION_GRAMMAR_BUDGET);
+  }
+  const start = region.search(/\S/);
+  if (start < 0) return false;
+  const verdict = kindGrammar(region, "json", start);
+  return verdict.status === "broken" && verdict.prose;
+}
+function lenientlyParses(span, grammar) {
+  const body = span.replace(/,(\s*[}\]])/g, "$1");
+  if (grammar !== "json") return true;
+  try {
+    JSON.parse(body);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function balancedEnd(text, singleQuotes) {
+  let depth = 0;
+  let quote = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === "\\") i++;
+      else if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || singleQuotes && ch === "'") quote = ch;
+    else if (ch === "{" || ch === "[") depth++;
+    else if (ch === "}" || ch === "]") {
+      depth--;
+      if (depth === 0) return i + 1;
+    }
+  }
+  return null;
+}
+function kindObjectProseBreak(text) {
+  const key = text.search(LITERAL_KIND_KEY);
+  if (key < 0) return null;
+  const verdict = kindGrammar(text);
+  return verdict.status === "broken" && verdict.prose && verdict.cut > key ? verdict.cut : null;
+}
+var LITERAL_KIND_KEY = new RegExp(String.raw`(?<!\\)"${KIND_KEY_BODY}"\s*:`);
+var ARRIVING_SPELLING_TAIL = /^(?:\\+"?|&#?[A-Za-z0-9]{0,6})$/;
+function firstAtOrAfter(map, raw) {
+  let lo = 0;
+  let hi = map.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (map[mid] < raw) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function kindGrammar(s, dialect = "json", from = 0) {
+  const closers = [];
+  const singleQuotes = dialect !== "json";
+  const bareKeys = dialect === "js";
+  const trailingCommas = dialect !== "json";
+  let expect = 0;
+  let lastGood = from;
+  const n = s.length;
+  const broken = (at) => ({
+    status: "broken",
+    at,
+    cut: lastGood,
+    prose: !/^[{}[\]:,"'0-9.+-]$/.test(s[at] ?? "")
+  });
+  let i = from;
+  while (i < n) {
+    const c = s.charCodeAt(i);
+    if (c === 32 || c === 9 || c === 10 || c === 13) {
+      i++;
+      continue;
+    }
+    if (expect === 4 || expect === 1 || expect === 2) {
+      if (c === 125 || c === 93) {
+        if (closers.length === 0 || closers[closers.length - 1] !== c) return broken(i);
+        if (expect === 4 || trailingCommas || lastCharWasOpener(s, i)) {
+          closers.pop();
+          i++;
+          lastGood = i;
+          if (closers.length === 0) return { status: "complete", end: i };
+          expect = 4;
+          continue;
+        }
+        return broken(i);
+      }
+      if (expect === 4) {
+        if (c !== 44) return broken(i);
+        i++;
+        lastGood = i;
+        expect = closers[closers.length - 1] === 125 ? 2 : 1;
+        continue;
+      }
+    }
+    if (expect === 3) {
+      if (c !== 58) return broken(i);
+      i++;
+      expect = 0;
+      continue;
+    }
+    const keyPosition = expect === 2;
+    if (c === 34 || singleQuotes && c === 39) {
+      let j = i + 1;
+      for (; ; ) {
+        if (j >= n) return { status: "prefix" };
+        const d = s.charCodeAt(j);
+        if (d === 92) {
+          j += 2;
+          continue;
+        }
+        if (d === 10 || d === 13) return broken(j);
+        if (d === c) break;
+        j++;
+      }
+      i = j + 1;
+      if (keyPosition) expect = 3;
+      else {
+        expect = 4;
+        lastGood = i;
+      }
+      continue;
+    }
+    if (keyPosition) {
+      if (!bareKeys || !isIdentStart(c)) return broken(i);
+      let j = i + 1;
+      while (j < n && isIdentPart(s.charCodeAt(j))) j++;
+      if (j >= n) return { status: "prefix" };
+      i = j;
+      expect = 3;
+      continue;
+    }
+    if (c === 123 || c === 91) {
+      closers.push(c === 123 ? 125 : 93);
+      i++;
+      lastGood = i;
+      expect = c === 123 ? 2 : 1;
+      continue;
+    }
+    if (c === 45 || c >= 48 && c <= 57) {
+      let j = i + 1;
+      while (j < n && /[0-9eE.+-]/.test(s[j])) j++;
+      if (j >= n) return { status: "prefix" };
+      i = j;
+      lastGood = i;
+      expect = 4;
+      continue;
+    }
+    if (isIdentStart(c)) {
+      let j = i + 1;
+      while (j < n && isIdentPart(s.charCodeAt(j))) j++;
+      const word = s.slice(i, j);
+      if (j >= n) return VALUE_WORDS[dialect].some((w) => w.startsWith(word)) ? { status: "prefix" } : broken(i);
+      if (!VALUE_WORDS[dialect].includes(word)) return broken(i);
+      i = j;
+      lastGood = i;
+      expect = 4;
+      continue;
+    }
+    return broken(i);
+  }
+  return { status: "prefix" };
+}
+var VALUE_WORDS = {
+  json: ["true", "false", "null"],
+  python: ["True", "False", "None", "true", "false", "null"],
+  js: ["true", "false", "null", "undefined", "NaN", "Infinity"]
+};
+function isIdentStart(c) {
+  return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95 || c === 36;
+}
+function isIdentPart(c) {
+  return isIdentStart(c) || c >= 48 && c <= 57;
+}
+function lastCharWasOpener(s, at) {
+  for (let k = at - 1; k >= 0; k--) {
+    const c = s.charCodeAt(k);
+    if (c === 32 || c === 9 || c === 10 || c === 13) continue;
+    return c === 123 || c === 91;
+  }
+  return false;
+}
+var JSON_ONLY_FAMILIES = /* @__PURE__ */ new Set(["lifted", "escaped", "markdown"]);
+function regionJson(region) {
+  const text = region.decoded;
+  if (region.family === "js") return json5AsJson(text);
+  if (region.family !== "python") {
+    try {
+      JSON.parse(text);
+      return text;
+    } catch {
+    }
+  }
+  return pythonReprAsJson(text);
+}
+function closedJson(region) {
+  let body = region.decoded.replace(/\s+$/, "");
+  body = body.replace(/,?\s*(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[A-Za-z_$][\w$]*)\s*:\s*$/, "");
+  body = body.replace(/,\s*$/, "");
+  const closers = [];
+  let quote = "";
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (quote) {
+      if (ch === "\\") i++;
+      else if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'" && !JSON_ONLY_FAMILIES.has(region.family)) quote = ch;
+    else if (ch === "{") closers.push("}");
+    else if (ch === "[") closers.push("]");
+    else if (ch === "}" || ch === "]") closers.pop();
+  }
+  if (quote) return null;
+  return regionJson({ family: region.family, decoded: body + closers.reverse().join("") });
+}
+function valueCarriesKind(value) {
+  return carriesKind(value, 0, /* @__PURE__ */ new Set());
+}
+var VALUE_SEARCH_DEPTH = 64;
+function carriesKind(value, depth, seen) {
+  if (typeof value === "string") return textCarriesKind(value);
+  if (value === null || typeof value !== "object") return false;
+  if (depth > VALUE_SEARCH_DEPTH || seen.has(value)) return false;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.some((item) => carriesKind(item, depth + 1, seen));
+  }
+  const record = value;
+  if (typeof record.__kind === "string" && record.__kind.trim()) return true;
+  for (const item of Object.values(record)) {
+    if (carriesKind(item, depth + 1, seen)) return true;
+  }
+  return false;
+}
+function textCarriesKind(text) {
+  if (isKindJsonText(text) || markdownCarriesKind(text)) return true;
+  if (!mayHoldKindKey(text) || !/^[{[]/.test(text.trimStart())) return false;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return false;
+  }
+  return typeof parsed === "object" && parsed !== null && valueCarriesKind(parsed);
+}
+function isKindJsonText(text) {
+  const first = text.trimStart()[0];
+  return (first === "{" || first === "[") && hasKindKey(text);
+}
+function rootKindSlug(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+  const kind = value.__kind;
+  return typeof kind === "string" && kind.trim() ? kind : null;
+}
+var JSON_FENCE_LANGS = /* @__PURE__ */ new Set(["", "json", "jsonc", "json5"]);
+function isJsonFenceLanguage(lang) {
+  return JSON_FENCE_LANGS.has((lang ?? "").trim().toLowerCase());
+}
+function quotedSourceRanges(text) {
+  const ranges = [];
+  for (const range of findCodeRanges(text)) {
+    if (range.kind === "span") {
+      ranges.push([range.start, range.end]);
+      continue;
+    }
+    const raw = text.slice(range.start, range.end);
+    const newline = raw.indexOf("\n");
+    const firstLine = (newline === -1 ? raw : raw.slice(0, newline)).replace(/^ {0,3}(?:> ?)*/, "");
+    const opener = fenceOpenerOf(firstLine.trimStart());
+    if (!opener || !isJsonFenceLanguage(opener.lang)) {
+      ranges.push([range.start, range.end]);
+    }
+  }
+  return ranges;
+}
+function isQuotedSourceXmlBlock(block) {
+  return block.metadata?.genericXmlContainer !== true;
+}
+function frontMatterEnd(source) {
+  const body = source.charCodeAt(0) === 65279 ? 1 : 0;
+  const firstBreak = source.indexOf("\n", body);
+  if (firstBreak < 0) return 0;
+  const opener = source.slice(body, firstBreak).replace(/\r$/, "");
+  if (opener !== "---" && opener !== "+++") return 0;
+  for (let pos = firstBreak + 1; pos < source.length; ) {
+    const next = source.indexOf("\n", pos);
+    const end = next < 0 ? source.length : next;
+    const line = source.slice(pos, end).replace(/\r$/, "");
+    if (line === opener || opener === "---" && line === "...") return end;
+    if (next < 0) break;
+    pos = next + 1;
+  }
+  return 0;
+}
+function markdownCarriesKind(source) {
+  const text = source.slice(frontMatterEnd(source));
+  if (!hasKindKey(text, JSON_KIND_SPELLINGS)) return false;
+  if (isKindJsonText(text)) return true;
+  const quoted = quotedSourceRanges(text);
+  if (quoted.length === 0) return true;
+  let outside = "";
+  let cursor = 0;
+  for (const [start, end] of quoted) {
+    if (start < cursor) continue;
+    outside += text.slice(cursor, start) + " ";
+    cursor = end;
+  }
+  outside += text.slice(cursor);
+  return hasKindKey(outside, JSON_KIND_SPELLINGS);
+}
+
+// surfaces/embedded-kind-json.ts
+function matchingJsonObjectEnd(source, start) {
+  if (source[start] !== "{" && source[start] !== "[") return null;
+  const stack = [source[start]];
+  let inString = false;
+  let escaped = false;
+  for (let index = start + 1; index < source.length; 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 balancedEnds(text) {
+  const ends = new Int32Array(text.length).fill(-1);
+  const stack = [];
+  for (let start = text.length - 1; start >= 0; start--) {
+    const open = text[start];
+    if (open !== "{" && open !== "[") continue;
+    stack.length = 0;
+    stack.push(open === "{" ? "}" : "]");
+    let inString = false;
+    for (let i = start + 1; i < text.length; i++) {
+      const ch = text[i];
+      if (inString) {
+        if (ch === "\\") i++;
+        else if (ch === '"') inString = false;
+        continue;
+      }
+      if (ch === '"') inString = true;
+      else if (ch === "{" || ch === "[") {
+        const end = ends[i];
+        if (end < 0) break;
+        i = end - 1;
+      } else if (ch === "}" || ch === "]") {
+        if (stack.pop() !== ch) break;
+        ends[start] = i + 1;
+        break;
+      }
+    }
+  }
+  return ends;
+}
+function lazyJsonEnds(source) {
+  let table;
+  return (start) => {
+    if (source[start] !== "{" && source[start] !== "[") return null;
+    table ??= balancedEnds(source);
+    const end = table[start];
+    return end < 0 ? null : end;
+  };
+}
+function skipWhitespace(source, cursor) {
+  while (/\s/.test(source[cursor] ?? "")) cursor++;
+  return cursor;
+}
+function jsonStringEnd(source, start) {
+  if (source[start] !== '"') return null;
+  let escaped = false;
+  for (let cursor = start + 1; cursor < source.length; cursor++) {
+    const char = source[cursor];
+    if (escaped) {
+      escaped = false;
+    } else if (char === "\\") {
+      escaped = true;
+    } else if (char === '"') {
+      return cursor + 1;
+    }
+  }
+  return null;
+}
+function jsonValueEnd(source, start) {
+  const char = source[start];
+  if (char === '"') return jsonStringEnd(source, start);
+  if (char === "{" || char === "[") return matchingJsonObjectEnd(source, start);
+  const end = source.slice(start).search(/[\s,}\]]/);
+  const tokenEnd = end === -1 ? source.length : start + end;
+  const token = source.slice(start, tokenEnd);
+  return /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)$/.test(
+    token
+  ) ? tokenEnd : null;
+}
+function malformedKindOwnerEnd(source, start, boundary = source.length) {
+  let cursor = skipWhitespace(source, start + 1);
+  let kindFound = false;
+  const ownerEnd = () => kindFound ? boundary : null;
+  while (cursor < boundary) {
+    const keyStart = cursor;
+    const keyEnd = jsonStringEnd(source, keyStart);
+    if (keyEnd === null || keyEnd > boundary) return ownerEnd();
+    let key;
+    try {
+      key = JSON.parse(source.slice(keyStart, keyEnd));
+    } catch {
+      return ownerEnd();
+    }
+    cursor = skipWhitespace(source, keyEnd);
+    if (cursor >= boundary || source[cursor] !== ":") return ownerEnd();
+    cursor = skipWhitespace(source, cursor + 1);
+    const valueStart = cursor;
+    const valueEnd = jsonValueEnd(source, valueStart);
+    if (valueEnd === null || valueEnd > boundary) return ownerEnd();
+    if (key === "__kind") {
+      try {
+        const value = JSON.parse(source.slice(valueStart, valueEnd));
+        kindFound ||= typeof value === "string" && value.trim().length > 0;
+      } catch {
+        return ownerEnd();
+      }
+    }
+    cursor = skipWhitespace(source, valueEnd);
+    if (source[cursor] === "}") return kindFound ? cursor + 1 : null;
+    if (cursor >= boundary || source[cursor] !== ",") return ownerEnd();
+    cursor = skipWhitespace(source, cursor + 1);
+  }
+  return ownerEnd();
+}
+function jsonStringRanges(source, start, end) {
+  const ranges = [];
+  for (let cursor = start; cursor < end; cursor++) {
+    if (source[cursor] !== '"') continue;
+    const stringEnd = jsonStringEnd(source, cursor);
+    if (stringEnd === null || stringEnd > end) break;
+    ranges.push([cursor, stringEnd]);
+    cursor = stringEnd - 1;
+  }
+  return ranges;
+}
+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 literalRanges(source, liftJsonFences = false) {
+  const ranges = [];
+  const code = liftJsonFences ? findCodeRanges(source).filter((range) => !isJsonFenceRange(source, range)) : findCodeRanges(source);
+  let next = 0;
+  let cursor = 0;
+  while (cursor < source.length) {
+    while (next < code.length && code[next].start < cursor) next++;
+    const range = code[next];
+    if (range && range.start === cursor) {
+      ranges.push([range.start, range.end]);
+      cursor = range.end;
+      next++;
+      continue;
+    }
+    if (source.startsWith("<!--", cursor)) {
+      const end = source.indexOf("-->", cursor + 4);
+      const rangeEnd = end === -1 ? source.length : end + 3;
+      ranges.push([cursor, rangeEnd]);
+      cursor = rangeEnd;
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", cursor)) {
+      const end = source.indexOf("]]>", cursor + 9);
+      const rangeEnd = end === -1 ? source.length : end + 3;
+      ranges.push([cursor, rangeEnd]);
+      cursor = rangeEnd;
+      continue;
+    }
+    if (source[cursor] === "<") {
+      const tag = readXmlTag(source, cursor);
+      if (tag) {
+        const end = cursor + tag.raw.length;
+        ranges.push([cursor, end]);
+        cursor = end;
+        continue;
+      }
+      if (/^<[A-Za-z_][\w.:-]*\s/.test(source.slice(cursor, cursor + 64)) && !tagCloses(source, cursor)) {
+        ranges.push([cursor, source.length]);
+        break;
+      }
+    }
+    cursor++;
+  }
+  return ranges;
+}
+function tagCloses(source, start) {
+  let quote = null;
+  for (let i = start + 1; i < source.length; i++) {
+    const ch = source[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+    } else if (ch === "'" || ch === '"') quote = ch;
+    else if (ch === ">") return true;
+  }
+  return false;
+}
+function isJsonFenceRange(source, range) {
+  if (range.kind !== "fence") return false;
+  const raw = source.slice(range.start, range.end);
+  const newline = raw.indexOf("\n");
+  const opener = fenceOpenerOf((newline === -1 ? raw : raw.slice(0, newline)).trimStart());
+  return opener !== null && isJsonFenceLanguage(opener.lang);
+}
+function jsonFenceChromeSpans(source, regions) {
+  const spans = [];
+  for (const range of findCodeRanges(source)) {
+    if (!isJsonFenceRange(source, range)) continue;
+    const inside2 = regions.filter((r) => r.start >= range.start && r.end <= range.end);
+    if (inside2.length !== 1) continue;
+    const region = inside2[0];
+    const head = source.slice(range.start, region.start);
+    const tail = source.slice(region.end, range.end);
+    if (!/^[^\n]*\n\s*$/.test(head) || !/^\s*(?:[`~]{3,}[ \t]*)?$/.test(tail)) continue;
+    spans.push([range.start, region.start]);
+    if (region.end < range.end) spans.push([region.end, range.end]);
+  }
+  return spans;
+}
+function findEmbeddedKindJsonRegions(source, options = {}) {
+  const regions = [];
+  const endOf = lazyJsonEnds(source);
+  const excluded = [
+    ...options.excludeLiteralContexts ? literalRanges(source, options.liftJsonFences === true) : [],
+    ...options.excludeQuotedSource ? quotedSourceRanges(source) : []
+  ].sort((a, b) => a[0] - b[0]);
+  const jsonStrings = [];
+  let excludedIndex = 0;
+  let jsonStringIndex = 0;
+  for (let start = frontMatterEnd(source); start < source.length; start++) {
+    while (excludedIndex < excluded.length && excluded[excludedIndex][1] <= start) {
+      excludedIndex++;
+    }
+    while (jsonStringIndex < jsonStrings.length && jsonStrings[jsonStringIndex][1] <= start) {
+      jsonStringIndex++;
+    }
+    if (excludedIndex < excluded.length && start >= excluded[excludedIndex][0] && start < excluded[excludedIndex][1])
+      continue;
+    if (jsonStringIndex < jsonStrings.length && start >= jsonStrings[jsonStringIndex][0] && start < jsonStrings[jsonStringIndex][1])
+      continue;
+    if (source[start] !== "{") continue;
+    const end = endOf(start);
+    if (end === null) {
+      const verdict = kindGrammar(source, "json", start);
+      const bound = verdict.status === "broken" ? verdict.cut : source.length;
+      const ownerEnd = bound > start ? malformedKindOwnerEnd(source, start, bound) : null;
+      if (ownerEnd !== null) start = ownerEnd - 1;
+      continue;
+    }
+    const content = source.slice(start, end);
+    const kind = declaredKind(content);
+    if (!kind) {
+      const ownerEnd = malformedKindOwnerEnd(source, start, end);
+      if (ownerEnd !== null) {
+        start = ownerEnd - 1;
+        continue;
+      }
+      for (const range of jsonStringRanges(source, start, end)) jsonStrings.push(range);
+      continue;
+    }
+    regions.push({ start, end, content, kind });
+    start = end - 1;
+  }
+  return regions;
+}
+function kindArrayChromeSpans(source, regions) {
+  const spans = [];
+  let first = 0;
+  while (first < regions.length) {
+    let last = first;
+    while (last + 1 < regions.length && /^\s*,\s*$/.test(source.slice(regions[last].end, regions[last + 1].start))) {
+      last++;
+    }
+    const before = source.slice(0, regions[first].start);
+    const open = /\[\s*$/.exec(before);
+    const after = source.slice(regions[last].end);
+    const close = /^\s*\]/.exec(after);
+    if (open && close) {
+      spans.push([open.index, regions[first].start]);
+      for (let k = first; k < last; k++) {
+        spans.push([regions[k].end, regions[k + 1].start]);
+      }
+      spans.push([regions[last].end, regions[last].end + close[0].length]);
+    }
+    first = last + 1;
+  }
+  return spans;
+}
+function isKindValue(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const kind = value.__kind;
+  return typeof kind === "string" && kind.trim().length > 0;
+}
+function withoutKinds(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => !isKindValue(item)).map(withoutKinds);
+  }
+  if (typeof value === "object" && value !== null) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (!isKindValue(item)) out[key] = withoutKinds(item);
+    }
+    return out;
+  }
+  return value;
+}
+function carriesData(value) {
+  if (Array.isArray(value)) return value.some(carriesData);
+  if (typeof value === "object" && value !== null) {
+    return Object.values(value).some(carriesData);
+  }
+  return true;
+}
+function isPureJsonStructure(span) {
+  return /^[\s{}[\],:]*$/.test(
+    span.replace(/"(?:[^"\\]|\\.)*"\s*:/g, "")
+  );
+}
+function wrapperPieces(source, regions) {
+  const trimmed = source.trim();
+  if (!/^[[{]/.test(trimmed)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || isKindValue(parsed)) {
+    return null;
+  }
+  const residual = withoutKinds(parsed);
+  const residualJson = carriesData(residual) ? JSON.stringify(residual, null, 2) : null;
+  const pieces = [];
+  let residualPlaced = residualJson === null;
+  const pushSpan = (content) => {
+    if (!content) return;
+    if (!residualPlaced && !isPureJsonStructure(content)) {
+      pieces.push({ type: "residual", content, json: residualJson });
+      residualPlaced = true;
+      return;
+    }
+    pieces.push({ type: "chrome", content });
+  };
+  let cursor = 0;
+  for (const region of regions) {
+    pushSpan(source.slice(cursor, region.start));
+    pieces.push({ type: "kind", content: region.content, kind: region.kind });
+    cursor = region.end;
+  }
+  pushSpan(source.slice(cursor));
+  if (!residualPlaced) {
+    pieces.push({ type: "residual", content: "", json: residualJson });
+  }
+  return pieces;
+}
+function splitAroundEmbeddedKindJson(source, options = {}) {
+  const regions = findEmbeddedKindJsonRegions(source, options);
+  if (regions.length === 0) return [{ type: "container", content: source }];
+  const wrapped = wrapperPieces(source, regions);
+  if (wrapped) return wrapped;
+  const marks = [
+    ...regions.map((r) => ({ start: r.start, end: r.end, type: "kind", kind: r.kind })),
+    ...[
+      ...kindArrayChromeSpans(source, regions),
+      ...options.excludeLiteralContexts && options.liftJsonFences ? jsonFenceChromeSpans(source, regions) : []
+    ].map(([start, end]) => ({
+      start,
+      end,
+      type: "chrome"
+    }))
+  ].sort((a, b) => a.start - b.start);
+  const pieces = [];
+  let cursor = 0;
+  for (const mark of marks) {
+    if (mark.start > cursor) {
+      pieces.push({
+        type: "container",
+        content: source.slice(cursor, mark.start)
+      });
+    }
+    if (mark.end > mark.start) {
+      pieces.push(
+        mark.type === "kind" ? { type: "kind", content: source.slice(mark.start, mark.end), kind: mark.kind } : { type: "chrome", content: source.slice(mark.start, mark.end) }
+      );
+    }
+    cursor = Math.max(cursor, mark.end);
+  }
+  if (cursor < source.length) {
+    pieces.push({ type: "container", content: source.slice(cursor) });
+  }
+  return pieces;
+}
+function normalizeRecoveredProsePiece(content, followsKind) {
+  const start = followsKind ? content.replace(/^[ \t]*(?:\r?\n)?/, "") : content;
+  return start.trimEnd();
+}
+function normalizeRecoveredContainerPiece(content, containerType, followsKind) {
+  if (containerType === "text") {
+    return normalizeRecoveredProsePiece(content, followsKind);
+  }
+  if (containerType === "code") return content;
+  return content.trim();
+}
+function findKindCarryingJsonValues(source, options = {}) {
+  const kinds = findEmbeddedKindJsonRegions(source, options);
+  if (kinds.length === 0) return [];
+  const excluded = options.excludeLiteralContexts ? literalRanges(source) : [];
+  const inLiteral = (index) => excluded.some(([start, end]) => index >= start && index < end);
+  const ends = balancedEnds(source);
+  const regions = [];
+  let floor = frontMatterEnd(source);
+  for (const region of kinds) {
+    if (region.start < floor) continue;
+    let best = { start: region.start, end: region.end, value: JSON.parse(region.content) };
+    for (let open = floor; open < region.start; open++) {
+      const char = source[open];
+      if (char !== "{" && char !== "[" || inLiteral(open)) continue;
+      const found = ends[open];
+      if (found < 0 || found < region.end) continue;
+      const end = found;
+      try {
+        best = { start: open, end, value: JSON.parse(source.slice(open, end)) };
+        break;
+      } catch {
+        continue;
+      }
+    }
+    regions.push({ ...best, content: source.slice(best.start, best.end) });
+    floor = best.end;
+  }
+  return regions;
+}
+var KIND_KEY_TEXT = /(?<!\\)"__kind"\s*:/;
+var KIND_KEY_TEXT_G = /(?<!\\)"__kind"\s*:/g;
+function findBrokenKindJsonRegions(source, options = {}) {
+  const broken = [];
+  if (!KIND_KEY_TEXT.test(source)) return broken;
+  const endOf = lazyJsonEnds(source);
+  const keys = [];
+  KIND_KEY_TEXT_G.lastIndex = 0;
+  for (let m = KIND_KEY_TEXT_G.exec(source); m; m = KIND_KEY_TEXT_G.exec(source)) keys.push(m.index);
+  let keyIndex = 0;
+  const excluded = options.excludeLiteralContexts ? literalRanges(source) : [];
+  let excludedIndex = 0;
+  for (let start = frontMatterEnd(source); start < source.length; start++) {
+    while (excludedIndex < excluded.length && excluded[excludedIndex][1] <= start) {
+      excludedIndex++;
+    }
+    if (excludedIndex < excluded.length && start >= excluded[excludedIndex][0] && start < excluded[excludedIndex][1]) {
+      start = excluded[excludedIndex][1] - 1;
+      continue;
+    }
+    const char = source[start];
+    if (char !== "{" && char !== "[") continue;
+    while (keyIndex < keys.length && keys[keyIndex] < start) keyIndex++;
+    if (keyIndex >= keys.length) break;
+    const key = keys[keyIndex];
+    const verdict = kindGrammar(source, "json", start);
+    if (verdict.status === "complete") {
+      try {
+        JSON.parse(source.slice(start, verdict.end));
+        start = verdict.end - 1;
+      } catch {
+      }
+      continue;
+    }
+    if (verdict.status === "prefix") {
+      broken.push({ start, end: source.length, content: source.slice(start) });
+      break;
+    }
+    if (verdict.at <= key) continue;
+    const end = endOf(start);
+    if (end !== null && lenientJson(source.slice(start, end))) {
+      broken.push({ start, end, content: source.slice(start, end) });
+      start = end - 1;
+      continue;
+    }
+    if (verdict.cut <= key) continue;
+    broken.push({ start, end: verdict.cut, content: source.slice(start, verdict.cut) });
+    start = verdict.cut - 1;
+  }
+  return broken;
+}
+function lenientJson(span) {
+  try {
+    JSON.parse(span.replace(/,(\s*[}\]])/g, "$1"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// core/kind-schema.types.ts
+var KIND_KEY2 = "__kind";
+function readObjectKind(value) {
+  const kind = value[KIND_KEY2];
+  return typeof kind === "string" ? kind : null;
+}
+
+// surfaces/instance-title.ts
+var INSTANCE_TITLE_KEYS = [
+  "title",
+  "name",
+  "label",
+  "heading",
+  "subject",
+  "customer"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function kindTitleKeyFromMetadata(metadata) {
+  if (!isRecord(metadata)) return null;
+  const value = metadata["title_key"];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function scalarTitle(value) {
+  if (typeof value === "string") return value.trim() || null;
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : null;
+  return null;
+}
+function deriveInstanceTitle(data, explicit, titleKey) {
+  if (explicit && explicit.trim()) return explicit.trim();
+  if (titleKey) {
+    const override = scalarTitle(data[titleKey]);
+    if (override) return override;
+  }
+  for (const key of INSTANCE_TITLE_KEYS) {
+    const value = data[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+var IDENTIFIER_ACRONYMS = [
+  "ID",
+  "URL",
+  "PDF",
+  "HTML",
+  "JSON",
+  "API",
+  "AI",
+  "UI",
+  "CSV",
+  "SMS",
+  "SEO",
+  "LLM",
+  "MCP",
+  "UUID",
+  "ISO"
+];
+var IDENTIFIER_ACRONYM_SET = new Set(IDENTIFIER_ACRONYMS.map((a) => a.toLowerCase()));
+function humanizeIdentifier(identifier) {
+  const text = (identifier ?? "").trim();
+  if (text === "") return "";
+  if (!text.includes("_") && /\s/.test(text)) {
+    return /^\p{Ll}/u.test(text) ? text.charAt(0).toUpperCase() + text.slice(1) : text;
+  }
+  return text.replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)(?![A-Z]s(?![a-z]))([A-Z][a-z])/g, "$1 $2").split(/[_\-.\s]+/).filter((part) => part.length > 0).map(identifierWord).join(" ");
+}
+function identifierWord(part) {
+  const lower = part.toLowerCase();
+  if (IDENTIFIER_ACRONYM_SET.has(lower)) return part.toUpperCase();
+  if (lower.length > 1 && lower.endsWith("s") && IDENTIFIER_ACRONYM_SET.has(lower.slice(0, -1))) {
+    return `${lower.slice(0, -1).toUpperCase()}s`;
+  }
+  return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
+}
+
+// surfaces/kind-markdown-utils.ts
+function isRecordValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isScalar(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function formatInlineValue(value) {
+  if (value === null || value === void 0) return "\u2014";
+  if (isScalar(value)) return String(value);
+  if (Array.isArray(value) && value.every(isScalar)) {
+    return value.map(String).join(", ");
+  }
+  try {
+    return `\`${JSON.stringify(stripKindForDisplay(value))}\``;
+  } catch {
+    return String(value);
+  }
+}
+function stripKindForDisplay(value) {
+  if (Array.isArray(value)) return value.map(stripKindForDisplay);
+  if (isRecordValue(value)) {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (key === KIND_KEY2) continue;
+      out[key] = stripKindForDisplay(child);
+    }
+    return out;
+  }
+  return value;
+}
+function collectExtras(value, knownKeys) {
+  const known = new Set(knownKeys);
+  known.add(KIND_KEY2);
+  known.add("additionalDetails");
+  const extras = {};
+  const details = value.additionalDetails;
+  if (isRecordValue(details)) {
+    for (const [key, child] of Object.entries(details)) {
+      if (key === KIND_KEY2 || child === null || child === void 0) continue;
+      extras[key] = child;
+    }
+  } else if (details !== null && details !== void 0) {
+    extras.additionalDetails = details;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (known.has(key) || child === null || child === void 0) continue;
+    extras[key] = child;
+  }
+  return extras;
+}
+function plainFieldLabel(key) {
+  const words = key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim().toLowerCase();
+  if (!words) return key;
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function extrasList(extras) {
+  const entries = Object.entries(extras);
+  if (entries.length === 0) return null;
+  return entries.map(([key, value]) => `- **${key}:** ${formatInlineValue(value)}`).join("\n");
+}
+function additionalDetailsSection(extras, headingLevel = "##") {
+  const list = extrasList(extras);
+  if (!list) return null;
+  return `${headingLevel} Additional details
+
+${list}`;
+}
+function joinBlocks(blocks) {
+  return blocks.map((block) => typeof block === "string" ? block.trim() : "").filter((block) => block.length > 0).join("\n\n");
+}
+function humanizeKind(kind) {
+  return humanizeIdentifier(kind) || "Artifact";
+}
+function isKindValue2(value) {
+  return isRecordValue(value) && typeof value[KIND_KEY2] === "string" && value[KIND_KEY2].trim().length > 0;
+}
+function scalarText(value) {
+  if (typeof value === "boolean") return value ? "Yes" : "No";
+  return String(value);
+}
+function cellText(value) {
+  return scalarText(value).replace(/\r?\n/g, " ").replace(/\|/g, "\\|");
+}
+function visibleEntries(value) {
+  return Object.entries(value).filter(
+    ([key, child]) => key !== KIND_KEY2 && child !== null && child !== void 0 && !(typeof child === "string" && child.trim() === "") && !(Array.isArray(child) && child.length === 0)
+  );
+}
+function uniformTable(items) {
+  if (items.length === 0) return null;
+  let columns = null;
+  for (const item of items) {
+    if (!isRecordValue(item) || isKindValue2(item)) return null;
+    const keys = Object.keys(item).filter((key) => key !== KIND_KEY2);
+    if (keys.length === 0) return null;
+    if (!keys.every((key) => item[key] === null || isScalar(item[key]))) return null;
+    if (columns === null) columns = keys;
+    else if (keys.length !== columns.length || !keys.every((k, i) => k === columns[i]))
+      return null;
+  }
+  const cols = columns;
+  const head = `| ${cols.map(plainFieldLabel).join(" | ")} |`;
+  const rule = `| ${cols.map(() => "---").join(" | ")} |`;
+  const rows = items.map(
+    (item) => `| ${cols.map((key) => {
+      const cell = item[key];
+      return cell === null || cell === void 0 ? "\u2014" : cellText(cell);
+    }).join(" | ")} |`
+  );
+  return [head, rule, ...rows].join("\n");
+}
+function indentBlock(text, indent) {
+  return text.split("\n").map((line) => line.trim() ? indent + line : line).join("\n");
+}
+function listLines(value, indent, nested) {
+  if (Array.isArray(value)) {
+    const lines = [];
+    for (const item of value) {
+      if (item === null || item === void 0) continue;
+      if (isScalar(item)) lines.push(`${indent}- ${scalarText(item)}`);
+      else if (isKindValue2(item)) {
+        lines.push(`${indent}-`);
+        lines.push(indentBlock(nested(item), indent + "  "));
+      } else if (Array.isArray(item)) {
+        lines.push(`${indent}-`);
+        lines.push(...listLines(item, indent + "  ", nested));
+      } else if (isRecordValue(item)) {
+        const fields = listLines(item, indent + "  ", nested);
+        if (fields.length > 0) {
+          lines.push(`${indent}- ${fields[0].trimStart().replace(/^- /, "")}`);
+          lines.push(...fields.slice(1));
+        }
+      }
+    }
+    return lines;
+  }
+  if (isRecordValue(value)) {
+    if (isKindValue2(value)) return [indentBlock(nested(value), indent)];
+    const lines = [];
+    for (const [key, child] of visibleEntries(value)) {
+      const label = `**${plainFieldLabel(key)}:**`;
+      if (isScalar(child)) lines.push(`${indent}- ${label} ${scalarText(child)}`);
+      else if (Array.isArray(child) && child.every(isScalar))
+        lines.push(`${indent}- ${label} ${child.map(scalarText).join(", ")}`);
+      else {
+        lines.push(`${indent}- ${label}`);
+        lines.push(...listLines(child, indent + "  ", nested));
+      }
+    }
+    return lines;
+  }
+  return isScalar(value) ? [`${indent}- ${scalarText(value)}`] : [];
+}
+function headingFor(depth) {
+  return "#".repeat(Math.min(Math.max(depth, 1), 6));
+}
+function recordBody(value, depth, nested, skipKey) {
+  const scalars = [];
+  const sections = [];
+  for (const [key, child] of visibleEntries(value)) {
+    if (key === skipKey) continue;
+    const label = plainFieldLabel(key);
+    if (isScalar(child)) {
+      scalars.push(`- **${label}:** ${scalarText(child)}`);
+    } else if (Array.isArray(child) && child.every(isScalar)) {
+      scalars.push(`- **${label}:** ${child.map(scalarText).join(", ")}`);
+    } else if (isKindValue2(child)) {
+      sections.push(joinBlocks([`${headingFor(depth + 1)} ${label}`, nested(child)]));
+    } else if (Array.isArray(child)) {
+      sections.push(
+        joinBlocks([
+          `${headingFor(depth + 1)} ${label}`,
+          uniformTable(child) ?? listLines(child, "", nested).join("\n")
+        ])
+      );
+    } else if (isRecordValue(child)) {
+      sections.push(
+        joinBlocks([
+          `${headingFor(depth + 1)} ${label}`,
+          ...recordBody(child, depth + 1, nested, null)
+        ])
+      );
+    }
+  }
+  return [scalars.length ? scalars.join("\n") : null, ...sections].filter(
+    (block) => block !== null
+  );
+}
+function titleSourceKey(value, title) {
+  if (!title) return null;
+  for (const key of INSTANCE_TITLE_KEYS) {
+    const v = value[key];
+    if (typeof v === "string" && v.trim() === title) return key;
+  }
+  return null;
+}
+function genericKindMarkdown(kind, value, nested) {
+  const renderNested = nested ?? ((child) => genericKindMarkdown(String(child[KIND_KEY2] ?? "artifact"), child));
+  const title = deriveInstanceTitle(value);
+  return joinBlocks([
+    `# ${title ?? humanizeKind(kind)}`,
+    `*${humanizeKind(kind)}*`,
+    ...recordBody(value, 1, renderNested, titleSourceKey(value, title))
+  ]);
+}
+function plainValueMarkdown(value, nested) {
+  const renderNested = nested ?? ((child) => genericKindMarkdown(String(child[KIND_KEY2] ?? "artifact"), child));
+  if (value === null || value === void 0) return "";
+  if (isKindValue2(value)) return renderNested(value);
+  if (Array.isArray(value)) {
+    return uniformTable(value) ?? listLines(value, "", renderNested).join("\n");
+  }
+  if (isRecordValue(value)) return joinBlocks(recordBody(value, 1, renderNested, null));
+  return isScalar(value) ? scalarText(value) : String(value);
+}
+
+// surfaces/kind-value-markdown.ts
+var STATE_KEY = /* @__PURE__ */ Symbol.for("ai-matrx.content-ir.kind-value-markdown");
+function state() {
+  const g = globalThis;
+  let s = g[STATE_KEY];
+  if (!s) {
+    s = { impl: null, announced: false };
+    g[STATE_KEY] = s;
+  }
+  return s;
+}
+function registerKindValueMarkdown(impl) {
+  state().impl = impl;
+}
+function kindValueToMarkdown(value, fallbackKind = "artifact") {
+  const s = state();
+  if (s.impl) return s.impl(value, fallbackKind);
+  if (!s.announced) {
+    s.announced = true;
+    console.warn(
+      `[@ai-matrx/content-ir] No "kindValueMarkdown" registered, so kind values render through the generic readable form, not the host's kind registry.`
+    );
+  }
+  const nested = (child) => kindValueToMarkdown(child);
+  return genericKindMarkdown(readObjectKind(value) ?? fallbackKind, value, nested);
+}
+
+// surfaces/kind-text-to-markdown.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isKindObject(value) {
+  return isRecord2(value) && typeof value.__kind === "string" && value.__kind.trim().length > 0;
+}
+function unfinishedKindLabel(kind) {
+  return kind ? `${humanizeKind(kind)} did not finish` : "Result did not finish";
+}
+var UNREADABLE_KIND_NOTE = "Structured output could not be read";
+var KIND_SLUG_TEXT = /^[A-Za-z0-9_.:-]+$/;
+function carriesBrokenKind(value, depth = 0) {
+  if (depth > 64 || value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return value.some((item) => carriesBrokenKind(item, depth + 1));
+  const record = value;
+  if (Object.prototype.hasOwnProperty.call(record, "__kind")) {
+    const kind = record.__kind;
+    const shape = typeof kind === "object" && kind !== null && !Array.isArray(kind);
+    if (!shape && (typeof kind !== "string" || !KIND_SLUG_TEXT.test(kind))) return true;
+  }
+  return Object.values(record).some((item) => carriesBrokenKind(item, depth + 1));
+}
+function rangeCursor(ranges) {
+  const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+  let k = 0;
+  return (at) => {
+    while (k < sorted.length && sorted[k][1] <= at) k++;
+    for (let j = k; j < sorted.length && sorted[j][0] <= at; j++) if (at < sorted[j][1]) return sorted[j];
+    return void 0;
+  };
+}
+function quotedCodeRanges(text) {
+  return findCodeRanges(text).filter((range) => {
+    if (range.kind !== "fence") return true;
+    const parts = fenceParts(text.slice(range.start, range.end));
+    return !parts || !JSON_FENCE_LANGS2.has(parts.opener.lang.toLowerCase());
+  }).map((range) => [range.start, range.end]);
+}
+function noteUnreadableKinds(text) {
+  if (!hasKindKey(text)) return text;
+  const quoted = quotedCodeRanges(text);
+  const fences = findCodeRanges(text).filter((range) => range.kind === "fence");
+  const spans = [];
+  const ends = balancedEnds(text);
+  const quotedAt = rangeCursor(quoted);
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch !== "{" && ch !== "[") continue;
+    const range = quotedAt(i);
+    if (range) {
+      i = range[1] - 1;
+      continue;
+    }
+    const end = ends[i];
+    if (end < 0) continue;
+    let value;
+    try {
+      value = JSON.parse(text.slice(i, end));
+    } catch {
+      continue;
+    }
+    if (carriesBrokenKind(value)) spans.push([i, end]);
+    i = end - 1;
+  }
+  let kept = text.length;
+  let tail = "";
+  let tailHead = "";
+  for (let k = spans.length - 1; k >= 0; k--) {
+    let [start, end] = spans[k];
+    const fence = fences.find((range) => start >= range.start && end <= range.end);
+    if (fence) {
+      const parts = fenceParts(text.slice(fence.start, fence.end));
+      const inner = parts ? text.slice(fence.start, fence.end).split("\n").slice(1, parts.closed ? -1 : void 0).join("\n").trim() : "";
+      if (parts && inner === text.slice(start, end).trim()) {
+        start = fence.start;
+        end = fence.end;
+      }
+    }
+    const before = closeBeforeAt(text, start);
+    const following = end <= kept ? text.slice(end, kept) : "";
+    const after = end <= kept ? openAfterJoined(following, tail, tailHead) : openAfter(tail.slice(end - kept));
+    kept = before.cut;
+    tailHead = before.add + UNREADABLE_KIND_NOTE;
+    tail = tailHead + after;
+  }
+  return text.slice(0, kept) + tail;
+}
+function liftKindStrings(value, depth = 0) {
+  if (depth > 64) return value;
+  if (typeof value === "string") {
+    if (!isKindJsonText(value)) return value;
+    try {
+      const parsed = JSON.parse(value);
+      return valueCarriesKind(parsed) ? parsed : value;
+    } catch {
+      return value;
+    }
+  }
+  if (Array.isArray(value)) return value.map((item) => liftKindStrings(item, depth + 1));
+  if (isRecord2(value)) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) out[key] = liftKindStrings(item, depth + 1);
+    return out;
+  }
+  return value;
+}
+function valueMarkdown(raw) {
+  const value = liftKindStrings(raw);
+  const nested = (child) => kindValueToMarkdown(child);
+  if (isKindObject(value)) return kindValueToMarkdown(value);
+  if (Array.isArray(value)) {
+    const blocks = [];
+    let run = [];
+    const flush = () => {
+      if (run.length) blocks.push(plainValueMarkdown(run, nested));
+      run = [];
+    };
+    for (const item of value) {
+      if (isKindObject(item)) {
+        flush();
+        blocks.push(kindValueToMarkdown(item));
+      } else if (Array.isArray(item) || isRecord2(item)) {
+        if (valueCarriesKind(item)) {
+          flush();
+          blocks.push(valueMarkdown(item));
+        } else run.push(item);
+      } else run.push(item);
+    }
+    flush();
+    return blocks.filter((block) => block.trim()).join("\n\n");
+  }
+  return plainValueMarkdown(value, nested);
+}
+function jsonKindValueMarkdown(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  return valueCarriesKind(parsed) ? valueMarkdown(parsed) : null;
+}
+function closeBefore(text) {
+  const { cut, add } = closeBeforeAt(text, text.length);
+  return text.slice(0, cut) + add;
+}
+var isLineSpace = (ch) => ch === " " || ch === "	" || ch === "\r";
+function closeBeforeAt(text, at) {
+  let cut = at;
+  while (cut > 0 && isLineSpace(text[cut - 1])) cut--;
+  if (cut === 0) return { cut, add: "" };
+  if (text[cut - 1] !== "\n") return { cut, add: "\n\n" };
+  return { cut, add: cut > 1 && text[cut - 2] === "\n" ? "" : "\n" };
+}
+function openAfterJoined(head, tail, tailHead) {
+  let from = 0;
+  while (from < head.length && isLineSpace(head[from])) from++;
+  const rest = head.slice(from);
+  const lead = rest + tailHead.slice(0, 4);
+  if (!lead) return "";
+  const joined = rest + tail;
+  if (lead.startsWith("\n\n") || lead.startsWith("\r\n\r\n")) return joined;
+  if (lead.startsWith("\n")) return `
+${joined}`;
+  return `
+
+${joined}`;
+}
+function openAfter(text) {
+  const out = text.replace(/^[ \t\r]+/, "");
+  if (!out) return out;
+  if (out.startsWith("\n\n") || out.startsWith("\r\n\r\n")) return out;
+  if (out.startsWith("\n")) return `
+${out}`;
+  return `
+
+${out}`;
+}
+function convertRegions(text, excludeLiteralContexts, options, leftover = (piece) => piece) {
+  const spans = findKindCarryingJsonValues(text, { excludeLiteralContexts }).map(
+    (region) => ({ start: region.start, end: region.end, md: valueMarkdown(region.value) })
+  );
+  if (options.broken === "note") {
+    for (const region of findBrokenKindJsonRegions(text, { excludeLiteralContexts })) {
+      spans.push({
+        start: region.start,
+        end: region.end,
+        md: unfinishedKindLabel(firstKindSlug(region.content))
+      });
+    }
+  }
+  if (spans.length === 0) return null;
+  spans.sort((a, b) => a.start - b.start);
+  const parts = [];
+  const push = (piece) => {
+    if (piece) parts.push(piece);
+  };
+  const closeBeforeParts = () => {
+    while (parts.length > 0) {
+      const last2 = parts[parts.length - 1];
+      const trimmed = last2.replace(/[ \t\r]+$/, "");
+      if (trimmed) {
+        parts[parts.length - 1] = trimmed;
+        break;
+      }
+      parts.pop();
+    }
+    if (parts.length === 0) return;
+    const last = parts[parts.length - 1];
+    if (last[last.length - 1] !== "\n") {
+      parts.push("\n\n");
+      return;
+    }
+    const before = last.length > 1 ? last[last.length - 2] : parts.length > 1 ? parts[parts.length - 2].slice(-1) : "";
+    if (before !== "\n") parts.push("\n");
+  };
+  let cursor = 0;
+  let afterBlock = false;
+  for (const span of spans) {
+    if (span.start < cursor) continue;
+    const between = leftover(text.slice(cursor, span.start));
+    push(afterBlock ? openAfter(between) : between);
+    closeBeforeParts();
+    push(span.md);
+    cursor = span.end;
+    afterBlock = true;
+  }
+  const tail = leftover(text.slice(cursor));
+  push(afterBlock ? openAfter(tail) : tail);
+  return parts.join("");
+}
+var JSON_FENCE_LANGS2 = /* @__PURE__ */ new Set(["", "json", "jsonc", "json5"]);
+var QUOTE_PREFIX = /^(?: {0,3}> ?)*/;
+function convertKindFences(text, options) {
+  const fences = findCodeRanges(text).filter((range) => range.kind === "fence");
+  let out = text;
+  for (let i = fences.length - 1; i >= 0; i--) {
+    const range = fences[i];
+    const raw = text.slice(range.start, range.end);
+    if (!hasKindKey(raw)) continue;
+    const parts = fenceParts(raw);
+    if (!parts || !JSON_FENCE_LANGS2.has(parts.opener.lang.toLowerCase())) continue;
+    const lines = raw.split("\n").map((line) => line.replace(/\r$/, ""));
+    const prefix = QUOTE_PREFIX.exec(lines[0] ?? "")?.[0] ?? "";
+    const strip = (line) => prefix ? line.replace(QUOTE_PREFIX, "") : line;
+    const opener = strip(lines[0] ?? "").trim();
+    const fence = parts.opener.char.repeat(parts.opener.ticks);
+    const body = lines.slice(1, parts.closed ? -1 : void 0).map(strip).join("\n");
+    const md = jsonKindValueMarkdown(body) ?? convertRegions(
+      body,
+      false,
+      options,
+      (piece) => /^[\s,[\]{}]*$/.test(piece) ? "" : `${opener}
+${piece.trim()}
+${fence}`
+    );
+    if (md === null) continue;
+    const block = prefix ? md.split("\n").map((line) => line ? `${prefix}${line}` : prefix.trimEnd()).join("\n") : md;
+    out = closeBefore(out.slice(0, range.start)) + block + openAfter(out.slice(range.end));
+  }
+  return out;
+}
+function convertKindText(text, options) {
+  text = noteUnreadableKinds(convertFrontMatterKind(text, options));
+  const whole = jsonKindValueMarkdown(text);
+  if (whole !== null) return whole;
+  let out = convertKindFences(text, options);
+  if (!hasKindKey(out)) return out;
+  out = convertRegions(out, true, options) ?? out;
+  out = convertCommentKinds(out, options);
+  return noteEscapedCutOffKind(out, options);
+}
+function convertFrontMatterKind(text, options) {
+  const end = frontMatterEnd(text);
+  if (end === 0 || !hasKindKey(text.slice(0, end))) return text;
+  const block = text.slice(0, end);
+  const lines = block.split("\n");
+  const body = lines.slice(1, -1).join("\n").replace(/\r$/, "");
+  const md = convertRegions(
+    body,
+    false,
+    options,
+    (piece) => /^[\s,[\]{}]*$/.test(piece) ? "" : piece.trim()
+  );
+  if (md === null) return text;
+  return md + openAfter(text.slice(end));
+}
+function convertCommentKinds(text, options) {
+  const quoted = quotedCodeRanges(text);
+  const comments = [...text.matchAll(/<!--[\s\S]*?(?:-->|$)/g)].filter(
+    (m) => hasKindKey(m[0]) && !quoted.some(([a, b]) => m.index >= a && m.index < b)
+  );
+  let out = text;
+  for (let i = comments.length - 1; i >= 0; i--) {
+    const m = comments[i];
+    const body = m[0].replace(/^<!--/, "").replace(/-->$/, "");
+    const md = convertRegions(
+      body,
+      false,
+      options,
+      (piece) => piece.trim() ? `<!-- ${piece.trim()} -->` : ""
+    );
+    if (md === null) continue;
+    const start = m.index;
+    const end = start + m[0].length;
+    out = closeBefore(out.slice(0, start)) + md + openAfter(out.slice(end));
+  }
+  return out;
+}
+var KIND_KEY_PLAIN = /(?<!\\)"__kind"\s*:/;
+function noteEscapedCutOffKind(text, options) {
+  if (options.broken !== "note" || !hasKindKey(text) || KIND_KEY_PLAIN.test(text)) return text;
+  const quotedAt = rangeCursor(quotedCodeRanges(text));
+  const ends = balancedEnds(text);
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch !== "{" && ch !== "[") continue;
+    const range = quotedAt(i);
+    if (range) {
+      i = range[1] - 1;
+      continue;
+    }
+    const end = ends[i];
+    if (end >= 0) {
+      i = end - 1;
+      continue;
+    }
+    const tail = text.slice(i);
+    if (/^[{[]\s*["{[]/.test(tail) && hasKindKey(tail)) {
+      return closeBefore(text.slice(0, i)).trimEnd() + (i > 0 ? "\n\n" : "") + unfinishedKindLabel(firstKindSlug(tail));
+    }
+  }
+  return text;
+}
+function kindTextToMarkdown(raw) {
+  if (!raw) return "";
+  const text = normalizeKindSpellings(raw);
+  if (!hasKindKey(text)) return text;
+  return convertKindText(text, { broken: "note" });
+}
+function owningObjectStart(text, keyIndex) {
+  const open = [];
+  let inString = false;
+  for (let i = 0; i < keyIndex; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (ch === "\\") i++;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") open.push(i);
+    else if (ch === "}") open.pop();
+  }
+  return open[0] ?? -1;
+}
+function kindKeyIndex(text) {
+  if (!hasKindKey(text)) return -1;
+  let lo = 0;
+  let hi = text.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (hasKindKey(text.slice(0, mid))) hi = mid;
+    else lo = mid + 1;
+  }
+  let i = lo - 1;
+  while (i > 0 && /\s/.test(text[i - 1])) i--;
+  const closing = i - 1;
+  return text.lastIndexOf('"', closing - 1);
+}
+function kindTextPreview(raw) {
+  const text = raw ? normalizeKindSpellings(raw) : raw;
+  const md = !text ? "" : hasKindKey(text) ? convertKindText(text, { broken: "keep" }) : text;
+  const keyIndex = kindKeyIndex(md);
+  if (keyIndex < 0) return { text: md, pendingKind: null, pendingUnnamed: false };
+  const start = owningObjectStart(md, keyIndex);
+  const cutAt = start < 0 ? keyIndex : start;
+  const head = md.slice(0, cutAt).replace(/(^|\n)[ \t]*(`{3,}|~{3,})[^\n]*\n?[ \t]*$/, "$1");
+  const slug = firstKindSlug(md.slice(keyIndex));
+  return { text: head.trimEnd(), pendingKind: slug, pendingUnnamed: slug === null };
+}
+
+// surfaces/kind-one-line.ts
+var UNNAMED = "Structured output";
+function kindName(slug) {
+  return slug && humanizeIdentifier(slug) || UNNAMED;
+}
+function kindOneLine(value, options = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return UNNAMED;
+  const record = value;
+  const slug = typeof record.__kind === "string" ? record.__kind : null;
+  const title = deriveInstanceTitle(record);
+  const name = kindName(slug);
+  if (!(title && title !== name)) return name;
+  const clean = title.replace(/[*_`[\]]/g, "");
+  return options.plain ? `${clean} \xB7 ${name}` : `**${clean}** \xB7 ${name}`;
+}
+function inside(ranges, at) {
+  return ranges.some(([start, end]) => at >= start && at < end);
+}
+function inlineKindText(raw, options = {}) {
+  const source = raw ? normalizeKindSpellings(raw) : raw;
+  if (!source || !hasKindKey(source)) return source;
+  const spans = [];
+  for (const region of findEmbeddedKindJsonRegions(source, { excludeQuotedSource: true })) {
+    let value = null;
+    try {
+      value = JSON.parse(region.content);
+    } catch {
+      value = { __kind: region.kind };
+    }
+    spans.push({ start: region.start, end: region.end, line: kindOneLine(value, options) });
+  }
+  const quoted = quotedSourceRanges(source);
+  for (const region of findBrokenKindJsonRegions(source)) {
+    if (inside(quoted, region.start)) continue;
+    spans.push({ start: region.start, end: region.end, line: kindName(firstKindSlug(region.content)) });
+  }
+  spans.sort((a, b) => a.start - b.start);
+  let out = "";
+  let cursor = 0;
+  for (const span of spans) {
+    if (span.start < cursor) continue;
+    out += source.slice(cursor, span.start) + span.line;
+    cursor = span.end;
+  }
+  out += source.slice(cursor);
+  if (hasKindKey(out)) {
+    const key = out.search(/(?<!\\)"(?:__kind|\\u005[fF]_kind)"\s*:/);
+    const brace = key >= 0 ? out.lastIndexOf("{", key) : -1;
+    if (brace >= 0 && !inside(quotedSourceRanges(out), brace)) {
+      const verdict = kindGrammar(out, "json", brace);
+      const end = verdict.status === "prefix" ? out.length : verdict.status === "broken" && verdict.at > key ? verdict.cut : -1;
+      if (end > key) out = out.slice(0, brace) + kindName(firstKindSlug(out.slice(key, end))) + out.slice(end);
+    }
+  }
+  return unreadableKindsAsNote(out);
+}
+function holdsUnreadableKind(json) {
+  let value;
+  try {
+    value = JSON.parse(json);
+  } catch {
+    return false;
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  if (!Object.prototype.hasOwnProperty.call(value, "__kind")) return false;
+  const kind = value.__kind;
+  if (typeof kind === "string") return false;
+  return !(typeof kind === "object" && kind !== null && !Array.isArray(kind));
+}
+function unreadableKindsAsNote(text) {
+  if (!text || !mayHoldKindKey(text) || !hasJsonKindKey(text)) return text;
+  let out = "";
+  let cursor = 0;
+  for (const region of scanKindSpellingRegions(text)) {
+    if (region.status !== "complete") continue;
+    const json = regionJson(region);
+    if (json === null || !holdsUnreadableKind(json)) continue;
+    out += text.slice(cursor, region.start) + UNREADABLE_KIND_NOTE;
+    cursor = region.end;
+  }
+  return cursor === 0 ? text : out + text.slice(cursor);
+}
+function catalogProseText(text) {
+  if (!text) return "";
+  return inlineKindText(text, { plain: true });
+}
+function regionOneLine(region) {
+  const json = region.status === "complete" ? regionJson(region) : region.status === "broken" ? closedJson(region) : null;
+  if (json !== null) {
+    try {
+      const value = JSON.parse(json);
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) return kindOneLine(value);
+    } catch {
+    }
+  }
+  return kindName(firstKindSlug(json ?? region.decoded));
+}
+var ONE_LINE_CACHE = /* @__PURE__ */ new Map();
+var ONE_LINE_CACHE_SIZE = 16;
+function spelledKindsAsOneLine(text) {
+  if (!text || !mayHoldKindKey(text)) return text;
+  const cached = ONE_LINE_CACHE.get(text);
+  if (cached !== void 0) return cached;
+  const out = computeSpelledKindsAsOneLine(text);
+  if (ONE_LINE_CACHE.size >= ONE_LINE_CACHE_SIZE) ONE_LINE_CACHE.delete(ONE_LINE_CACHE.keys().next().value);
+  ONE_LINE_CACHE.set(text, out);
+  return out;
+}
+function computeSpelledKindsAsOneLine(text) {
+  let out = "";
+  let cursor = 0;
+  for (const region of scanKindSpellingRegions(text)) {
+    if (region.family === "lifted" && !region.markdown && region.status !== "broken") {
+      const json = region.status === "complete" ? regionJson(region) : null;
+      if (json === null || !holdsUnreadableKind(json)) continue;
+      out += text.slice(cursor, region.start) + UNREADABLE_KIND_NOTE;
+      cursor = region.end;
+      continue;
+    }
+    out += text.slice(cursor, region.start) + regionOneLine(region);
+    cursor = region.end;
+  }
+  return cursor === 0 ? text : out + text.slice(cursor);
+}
+var AS_CODE_CACHE = /* @__PURE__ */ new Map();
+function nonJsonKindsAsCode(text) {
+  if (!text || !mayHoldKindKey(text)) return text;
+  const cached = AS_CODE_CACHE.get(text);
+  if (cached !== void 0) return cached;
+  let out = "";
+  let cursor = 0;
+  let paragraphs = null;
+  let p = 0;
+  for (const region of scanKindSpellingRegions(text, { families: "all" })) {
+    if (region.family === "lifted" || region.family === "markdown") continue;
+    paragraphs ??= codeSpanParagraphs(text);
+    while (p < paragraphs.length - 1 && paragraphs[p].end <= region.start) p++;
+    const fence = safeCodeSpanFence(text, region.start, region.end, paragraphs[p]);
+    if (fence === null) continue;
+    out += text.slice(cursor, region.start) + fence + text.slice(region.start, region.end) + fence;
+    cursor = region.end;
+  }
+  const result = cursor === 0 ? text : out + text.slice(cursor);
+  if (AS_CODE_CACHE.size >= ONE_LINE_CACHE_SIZE) AS_CODE_CACHE.delete(AS_CODE_CACHE.keys().next().value);
+  AS_CODE_CACHE.set(text, result);
+  return result;
+}
+var HTML_TAG = /^ {0,3}<\/?[A-Za-z][A-Za-z0-9-]*(?:[\s/>]|$)/m;
+var TABLE_ROW = /^[ \t]*\|/m;
+function codeSpanParagraphs(text) {
+  const out = [];
+  const blank = /\n[ \t]*\n/g;
+  let start = 0;
+  for (; ; ) {
+    const m = blank.exec(text);
+    const end = m ? m.index + 1 : text.length;
+    const body = text.slice(start, end);
+    const runs = /* @__PURE__ */ new Set();
+    for (let i = 0; i < body.length; ) {
+      if (body[i] !== "`") {
+        i++;
+        continue;
+      }
+      let n = 0;
+      while (body[i + n] === "`") n++;
+      runs.add(n);
+      i += n;
+    }
+    out.push({ start, end, html: HTML_TAG.test(body), table: TABLE_ROW.test(body), runs });
+    if (!m) break;
+    start = m.index + m[0].length - 1;
+  }
+  return out;
+}
+function safeCodeSpanFence(text, start, end, paragraph) {
+  const source = text.slice(start, end);
+  if (/\n[ \t]*\n/.test(source) || source.includes("`")) return null;
+  if (paragraph.html || paragraph.table && source.includes("|")) return null;
+  if (text[start - 1] === "`" || text[end] === "`") return null;
+  let ticks = 1;
+  while (paragraph.runs.has(ticks)) ticks++;
+  return "`".repeat(ticks);
+}
+
+// surfaces/quoted-kind-lift.ts
+var JSON_FENCE_LANGS3 = /* @__PURE__ */ new Set(["", "json", "jsonc", "json5"]);
+var QUOTE_PREFIX2 = /^ {0,3}>(?: ?>)* ?/;
+function quoteDepth(prefix) {
+  return (prefix.match(/>/g) ?? []).length;
+}
+function prefixOfDepth(line, depth) {
+  const match = new RegExp(`^ {0,3}>(?: ?>){${depth - 1}} ?`).exec(line);
+  return match ? match[0] : null;
+}
+function bracketDelta(line) {
+  let delta = 0;
+  let inString = false;
+  let escaped = false;
+  for (const ch of line) {
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{" || ch === "[") delta++;
+    else if (ch === "}" || ch === "]") delta--;
+  }
+  return delta;
+}
+var QuotedKindLift = class {
+  mode = { kind: "none" };
+  /** The current line's bytes not yet handed on (held while undecided). */
+  held = "";
+  /** The current line's bytes so far (handed on or not), as received. */
+  line = "";
+  /** Whether the rest of the current line passes straight through. */
+  passing = false;
+  /** Prefix stripped from the current line's handed-on bytes (passing lines). */
+  stripping = 0;
+  push(text) {
+    let out = "";
+    for (const ch of text) out += this.pushChar(ch);
+    return out;
+  }
+  flush() {
+    let out = "";
+    if (this.mode.kind === "candidate") {
+      out += this.mode.raw.join("\n") + (this.mode.raw.length ? "\n" : "");
+      this.mode = { kind: "none" };
+    }
+    out += this.held;
+    this.held = "";
+    this.line = "";
+    this.passing = false;
+    this.stripping = 0;
+    return out;
+  }
+  pushChar(ch) {
+    if (ch === "\n") return this.endLine();
+    this.line += ch;
+    if (this.passing) {
+      if (this.stripping > 0) {
+        this.stripping--;
+        return "";
+      }
+      return ch;
+    }
+    this.held += ch;
+    return this.decideMidLine();
+  }
+  /** Try to decide the current line before it ends; returns bytes released. */
+  decideMidLine() {
+    const mode = this.mode;
+    if (mode.kind === "source_fence") {
+      return this.release(this.held, 0);
+    }
+    if (mode.kind === "lifted_fence" || mode.kind === "lifted_bare") {
+      const prefix2 = prefixOfDepth(this.held, mode.depth);
+      if (prefix2 !== null && (this.held.length > prefix2.length || /> $/.test(prefix2))) {
+        const rest2 = this.held.slice(prefix2.length);
+        if (mode.kind === "lifted_fence" && /^\s*[`~]/.test(rest2)) return "";
+        return this.release(rest2, 0);
+      }
+      if (!/^ {0,3}(?:> ?)*$/.test(this.held)) {
+        return this.release(this.held, 0);
+      }
+      return "";
+    }
+    if (mode.kind === "candidate") return "";
+    if (!/^ {0,3}(?:>|$)/.test(this.held) && !/^ {0,3}$/.test(this.held)) {
+      return this.release(this.held, 0);
+    }
+    const prefix = QUOTE_PREFIX2.exec(this.held)?.[0];
+    if (!prefix) return "";
+    const rest = this.held.slice(prefix.length);
+    if (!rest.trim()) return "";
+    const first = rest.trimStart()[0];
+    if (first === "`" || first === "~") return "";
+    if (first === "{" || first === "[") {
+      if (jsonKindSignal(rest) === "kind") {
+        this.mode = { kind: "lifted_bare", depth: quoteDepth(prefix), balance: 0 };
+        return this.release(rest, 0);
+      }
+      return "";
+    }
+    return this.release(this.held, 0);
+  }
+  /** Hand on `bytes` and let the rest of the line pass straight through. */
+  release(bytes, strip) {
+    this.held = "";
+    this.passing = true;
+    this.stripping = strip;
+    return bytes;
+  }
+  endLine() {
+    const line = this.line;
+    const held = this.held;
+    this.line = "";
+    this.held = "";
+    this.passing = false;
+    this.stripping = 0;
+    const mode = this.mode;
+    if (mode.kind === "source_fence") {
+      const content = mode.depth > 0 ? line.replace(QUOTE_PREFIX2, "") : line;
+      if (mode.reader.feed(content)) this.mode = { kind: "none" };
+      return held + "\n";
+    }
+    if (mode.kind === "lifted_fence") {
+      const prefix = prefixOfDepth(line, mode.depth);
+      const content = prefix !== null ? line.slice(prefix.length) : line;
+      if (mode.reader.feed(content)) this.mode = { kind: "none" };
+      const sent = line.length - held.length;
+      const contentSent = Math.max(0, sent - (prefix?.length ?? 0));
+      return content.slice(contentSent) + "\n";
+    }
+    if (mode.kind === "lifted_bare") {
+      const prefix = prefixOfDepth(line, mode.depth);
+      const content = prefix !== null ? line.slice(prefix.length) : line;
+      mode.balance += bracketDelta(content);
+      if (mode.balance <= 0) this.mode = { kind: "none" };
+      const sent = line.length - held.length;
+      const contentSent = Math.max(0, sent - (prefix?.length ?? 0));
+      return content.slice(contentSent) + "\n";
+    }
+    if (mode.kind === "candidate") {
+      const prefix = prefixOfDepth(line, mode.depth);
+      if (prefix === null) {
+        const out = mode.raw.join("\n") + "\n";
+        this.mode = { kind: "none" };
+        return out + this.lineFromNone(line);
+      }
+      mode.raw.push(line);
+      mode.stripped.push(line.slice(prefix.length));
+      return this.settleCandidate(mode);
+    }
+    return this.lineFromNone(line, held);
+  }
+  /**
+   * A complete line met with no region open. `held` is what was not handed
+   * on yet: the whole line when it was held to the end, otherwise "" (it was
+   * released mid-line as prose or as an unquoted line).
+   */
+  lineFromNone(line, held = line) {
+    const prefix = QUOTE_PREFIX2.exec(line)?.[0];
+    if (held.length < line.length || !prefix) {
+      if (!prefix) {
+        const opener = fenceOpenerOf(line);
+        if (opener) {
+          this.mode = { kind: "source_fence", reader: new FenceReader(opener), depth: 0 };
+        }
+      }
+      return held + "\n";
+    }
+    const rest = line.slice(prefix.length);
+    const depth = quoteDepth(prefix);
+    const trimmed = rest.trimStart();
+    if (trimmed.startsWith("`") || trimmed.startsWith("~")) {
+      const opener = fenceOpenerOf(rest);
+      if (opener && JSON_FENCE_LANGS3.has(opener.lang.toLowerCase())) {
+        this.mode = { kind: "lifted_fence", reader: new FenceReader(opener), depth };
+        return rest + "\n";
+      }
+      if (opener) {
+        this.mode = { kind: "source_fence", reader: new FenceReader(opener), depth };
+      }
+      return held + "\n";
+    }
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      const candidate = { kind: "candidate", depth, raw: [line], stripped: [rest] };
+      this.mode = candidate;
+      return this.settleCandidate(candidate);
+    }
+    return held + "\n";
+  }
+  /** A held quoted JSON start, re-judged after each complete line. */
+  settleCandidate(mode) {
+    const signal = jsonKindSignal(mode.stripped.join("\n"));
+    if (signal === "undecided") return "";
+    if (signal === "not_kind") {
+      this.mode = { kind: "none" };
+      return mode.raw.join("\n") + "\n";
+    }
+    const balance = mode.stripped.reduce((sum, l) => sum + bracketDelta(l), 0);
+    this.mode = balance > 0 ? { kind: "lifted_bare", depth: mode.depth, balance } : { kind: "none" };
+    return mode.stripped.join("\n") + "\n";
+  }
+};
+function liftQuotedKindRegions(source) {
+  if (!source.includes(">")) return source;
+  const lift = new QuotedKindLift();
+  return lift.push(source) + lift.flush();
+}
+
+// surfaces/markdown-escaped-kind.ts
+var TARGET = '"\\_\\_kind"';
+var KEY = '"__kind"';
+var HAS_ZERO_WIDTH2 = /[\u200B-\u200D\u2060\uFEFF\u00AD]/;
+var ZeroWidthKindKey = class {
+  /** Bytes that may still become the key — held, never shown. */
+  pending = "";
+  push(text) {
+    let out = "";
+    for (const ch of text) out += this.pushChar(ch);
+    return out;
+  }
+  flush() {
+    const out = this.pending;
+    this.pending = "";
+    return out;
+  }
+  pushChar(ch) {
+    let candidate = this.pending + ch;
+    let out = "";
+    while (candidate && !(candidate.startsWith('"') && KEY.startsWith(withoutZeroWidth(candidate)))) {
+      const next = candidate.indexOf('"', 1);
+      if (next < 0) {
+        out += candidate;
+        candidate = "";
+      } else {
+        out += candidate.slice(0, next);
+        candidate = candidate.slice(next);
+      }
+    }
+    if (withoutZeroWidth(candidate) === KEY) {
+      this.pending = "";
+      return out + KEY;
+    }
+    this.pending = candidate;
+    return out;
+  }
+};
+var MarkdownEscapedKindJson = class {
+  /** The zero-width key spelling is read first (round 8) — one transform, both hosts. */
+  zeroWidth = new ZeroWidthKindKey();
+  /** Bytes that may still become the escaped key — held, never shown. */
+  pending = "";
+  /** Inside the object holding a rewritten key: bracket depth (0 = outside). */
+  depth = 0;
+  inString = false;
+  /** A held backslash inside the object (its fate depends on the next char). */
+  escape = false;
+  push(text) {
+    return this.pushUnescape(this.zeroWidth.push(text));
+  }
+  pushUnescape(text) {
+    let out = "";
+    for (const ch of text) out += this.pushChar(ch);
+    return out;
+  }
+  flush() {
+    const held = this.pushUnescape(this.zeroWidth.flush());
+    const out = held + this.pending + (this.escape ? "\\" : "");
+    this.pending = "";
+    this.escape = false;
+    this.depth = 0;
+    this.inString = false;
+    return out;
+  }
+  pushChar(ch) {
+    if (this.depth > 0) return this.insideObject(ch);
+    let candidate = this.pending + ch;
+    let out = "";
+    while (candidate && !(candidate.startsWith('"') && TARGET.startsWith(withoutZeroWidth(candidate)))) {
+      const next = candidate.indexOf('"', 1);
+      if (next < 0) {
+        out += candidate;
+        candidate = "";
+      } else {
+        out += candidate.slice(0, next);
+        candidate = candidate.slice(next);
+      }
+    }
+    if (withoutZeroWidth(candidate) === TARGET) {
+      this.pending = "";
+      this.depth = 1;
+      this.inString = false;
+      return out + KEY;
+    }
+    this.pending = candidate;
+    return out;
+  }
+  insideObject(ch) {
+    if (this.escape) {
+      this.escape = false;
+      return ch === "_" ? "_" : `\\${ch}`;
+    }
+    if (ch === "\\") {
+      this.escape = true;
+      return "";
+    }
+    if (this.inString) {
+      if (ch === '"') this.inString = false;
+      return ch;
+    }
+    if (ch === '"') this.inString = true;
+    else if (ch === "{" || ch === "[") this.depth += 1;
+    else if (ch === "}" || ch === "]") this.depth -= 1;
+    return ch;
+  }
+};
+function unescapeMarkdownKindJson(source) {
+  if (!source.includes(TARGET) && !HAS_ZERO_WIDTH2.test(source)) return source;
+  const transform = new MarkdownEscapedKindJson();
+  return transform.push(source) + transform.flush();
+}
+function decodeDoubleEncodedKindText(source) {
+  const trimmed = source.trim();
+  if (!trimmed.startsWith('"') || !trimmed.endsWith('"') || !trimmed.includes('\\"__kind\\"')) return source;
+  try {
+    const inner = JSON.parse(trimmed);
+    return typeof inner === "string" && isKindJsonText(inner.trim()) ? inner.trim() : source;
+  } catch {
+    return source;
+  }
+}
+
+// surfaces/kind-image-alt.ts
+var HEAD_LIMIT = 2e3;
+var KindImageAltUnwrap = class {
+  mode = "scan";
+  /** Held: `!` / `![` (scan), the object so far (head), `](…` (tail). */
+  held = "";
+  depth = 0;
+  inString = false;
+  escape = false;
+  push(text) {
+    let out = "";
+    for (const ch of text) out += this.pushChar(ch);
+    return out;
+  }
+  flush() {
+    const out = this.mode === "head" ? `![${this.held}` : this.held;
+    this.mode = "scan";
+    this.held = "";
+    this.depth = 0;
+    this.inString = false;
+    this.escape = false;
+    return out;
+  }
+  /** Track JSON structure; returns true when the object just closed. */
+  track(ch) {
+    if (this.escape) {
+      this.escape = false;
+      return false;
+    }
+    if (this.inString) {
+      if (ch === "\\") this.escape = true;
+      else if (ch === '"') this.inString = false;
+      return false;
+    }
+    if (ch === '"') this.inString = true;
+    else if (ch === "{" || ch === "[") this.depth += 1;
+    else if (ch === "}" || ch === "]") {
+      this.depth -= 1;
+      return this.depth === 0;
+    }
+    return false;
+  }
+  pushChar(ch) {
+    switch (this.mode) {
+      case "scan": {
+        if (this.held === "" && ch === "!") {
+          this.held = "!";
+          return "";
+        }
+        if (this.held === "!" && ch === "[") {
+          this.held = "![";
+          return "";
+        }
+        if (this.held === "![" && ch === "{") {
+          this.mode = "head";
+          this.held = "{";
+          this.depth = 1;
+          this.inString = false;
+          this.escape = false;
+          return "";
+        }
+        if (this.held === "") return ch;
+        const out = this.held;
+        this.held = "";
+        return out + this.pushChar(ch);
+      }
+      case "head": {
+        this.held += ch;
+        const closed = this.track(ch);
+        const signal = jsonKindSignal(this.held);
+        if (signal === "kind") {
+          const out = this.held;
+          this.held = "";
+          if (closed) {
+            this.mode = "tail";
+            return out;
+          }
+          this.mode = "body";
+          return out;
+        }
+        if (signal === "not_kind" || closed || this.held.length > HEAD_LIMIT) {
+          const out = `![${this.held}`;
+          this.held = "";
+          this.mode = "scan";
+          return out;
+        }
+        return "";
+      }
+      case "body": {
+        if (this.track(ch)) this.mode = "tail";
+        return ch;
+      }
+      case "tail": {
+        this.held += ch;
+        if (/^\]\([^)\n]*\)$/.test(this.held)) {
+          this.held = "";
+          this.mode = "scan";
+          return "";
+        }
+        if (/^\](?:\([^)\n]*)?$/.test(this.held)) return "";
+        const out = this.held;
+        this.held = "";
+        this.mode = "scan";
+        return out;
+      }
+    }
+  }
+};
+function unwrapKindImageAlt(source) {
+  if (!source.includes("![{")) return source;
+  const transform = new KindImageAltUnwrap();
+  return transform.push(source) + transform.flush();
+}
+
+// surfaces/kind-text-label.ts
+function clip(text, max) {
+  return text.length > max ? `${text.slice(0, Math.max(0, max - 1)).trimEnd()}\u2026` : text;
+}
+function wholeKindLabel(text) {
+  let body = text.trim();
+  const fence = body.match(/^(?:`{3,}|~{3,})[a-zA-Z0-9]*\s*\n([\s\S]*?)\n?(?:`{3,}|~{3,})$/);
+  if (fence) body = fence[1].trim();
+  if (!body.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(body);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const record = parsed;
+    if (typeof record.__kind !== "string" || !record.__kind.trim()) return null;
+    const name = humanizeKind(record.__kind.trim());
+    const title = deriveInstanceTitle(record);
+    return title ? `${name} \xB7 ${title}` : name;
+  } catch {
+    return null;
+  }
+}
+function firstReadableLine(markdown) {
+  for (const raw of markdown.split("\n")) {
+    const line = raw.replace(/^\s*(?:#{1,6}\s+|>\s*|[-*+]\s+|\d+[.)]\s+)/, "").replace(/<\/?[A-Za-z][\w:-]*(\s[^<>]*)?\/?>/g, "").replace(/[*_`]+/g, "").replace(/\s+/g, " ").trim();
+    if (line) return line;
+  }
+  return "";
+}
+function kindTextLabel(raw, max = 90) {
+  if (!raw) return "";
+  const text = normalizeKindSpellings(raw);
+  if (!hasKindKey(text)) return clip(text.replace(/\s+/g, " ").trim(), max);
+  const whole = wholeKindLabel(text);
+  if (whole) return clip(whole, max);
+  const line = firstReadableLine(kindTextToMarkdown(text));
+  if (line) return clip(line, max);
+  const slug = firstKindSlug(text);
+  return clip(slug ? humanizeKind(slug) : "Structured output", max);
+}
+function conversationTitleText(title) {
+  if (title == null) return null;
+  return hasJsonKindKey(title) ? kindTextLabel(title, 200) : title;
+}
+
+// surfaces/legacy-quiz-envelope.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonicalizeCompletedLegacyQuizEnvelope(envelope, sourceText) {
+  if (envelope.root.kind !== "quiz_set" || envelope.root.status !== "complete") {
+    return envelope;
+  }
+  let source;
+  try {
+    source = JSON.parse(sourceText);
+  } catch {
+    return envelope;
+  }
+  if (!isRecord3(source)) return envelope;
+  const hasLegacyAliases = typeof source.quiz_title === "string" || typeof source.quizTitle === "string" || Array.isArray(source.multiple_choice) || Array.isArray(source.multipleChoice);
+  if (source.__kind !== void 0 || !hasLegacyAliases) return envelope;
+  const title = typeof source.quiz_title === "string" ? source.quiz_title : typeof source.quizTitle === "string" ? source.quizTitle : null;
+  const sourceQuestions = source.questions ?? source.multiple_choice ?? source.multipleChoice;
+  if (title === null || !Array.isArray(sourceQuestions)) return envelope;
+  const questions = sourceQuestions.flatMap((candidate) => {
+    if (!isRecord3(candidate)) return [];
+    const { __kind: _legacyKind, ...legacyQuestion } = candidate;
+    const options = Array.isArray(candidate.options) ? candidate.options : [];
+    const answer = candidate.correct_answer ?? candidate.correctAnswer ?? "";
+    const correctAnswer = typeof answer === "number" && Number.isInteger(answer) && answer >= 0 && answer < options.length ? options[answer] : answer;
+    return [{
+      ...legacyQuestion,
+      type: typeof candidate.type === "string" ? candidate.type : "multiple_choice",
+      question: typeof candidate.question === "string" ? candidate.question : "",
+      options,
+      correct_answer: typeof correctAnswer === "string" ? correctAnswer : String(correctAnswer),
+      explanation: typeof candidate.explanation === "string" ? candidate.explanation : null
+    }];
+  });
+  return {
+    ...envelope,
+    root: {
+      ...envelope.root,
+      value: { ...envelope.root.value, title, questions }
+    }
+  };
+}
+
+// core/ir-types.ts
+function isEmptyResidue(residue) {
+  return (residue.extra === null || Object.keys(residue.extra).length === 0) && (residue.optionalMissing === null || residue.optionalMissing.length === 0) && (residue.notices === null || residue.notices.length === 0);
+}
+
+// core/envelope-value.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function reconstructRegionValue(envelope) {
+  const cloned = structuredClone(envelope.root.value);
+  const applyExtras = (target, extras) => {
+    if (!extras) return;
+    for (const [key, value] of Object.entries(extras)) {
+      target[key] = structuredClone(value);
+    }
+  };
+  applyExtras(cloned, envelope.root.residue?.extra);
+  for (const [pathKey, meta] of Object.entries(envelope.nodeIndex ?? {})) {
+    const residue = meta.residue;
+    if (!residue || isEmptyResidue(residue) || !residue.extra) continue;
+    const segments = pathKey.split(".");
+    let cursor = cloned;
+    for (const segment of segments) {
+      if (Array.isArray(cursor)) {
+        cursor = cursor[Number(segment)];
+      } else if (isRecord4(cursor)) {
+        cursor = cursor[segment];
+      } else {
+        cursor = void 0;
+        break;
+      }
+    }
+    if (isRecord4(cursor)) {
+      applyExtras(cursor, residue.extra);
+    }
+  }
+  return cloned;
+}
+function stripKindDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(stripKindDeep);
+  }
+  if (isRecord4(value)) {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (key === KIND_KEY2) continue;
+      out[key] = stripKindDeep(child);
+    }
+    return out;
+  }
+  return value;
+}
+
+// surfaces/envelope-parity.ts
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) return false;
+    for (let i = 0; i < left.length; i++) {
+      if (!deepEqual(left[i], right[i])) return false;
+    }
+    return true;
+  }
+  if (isRecord5(left) && isRecord5(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length) return false;
+    for (const key of leftKeys) {
+      if (!(key in right)) return false;
+      if (!deepEqual(left[key], right[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+function envelopeMatchesParsedSource(envelope, parsedSource) {
+  if (!isRecord5(parsedSource)) return false;
+  return deepEqual(stripKindDeep(reconstructRegionValue(envelope)), stripKindDeep(parsedSource));
+}
+
+// surfaces/decision-answers-ids.ts
+var DECISION_ANSWERS_KIND = "decision_answers";
+var DECISION_ANSWERS_BLOCK_TYPE = "decision_answers";
+
+exports.ALL_KIND_SPELLINGS = ALL_KIND_SPELLINGS;
+exports.BARE_REGION_GRAMMAR_BUDGET = BARE_REGION_GRAMMAR_BUDGET;
+exports.DECISION_ANSWERS_BLOCK_TYPE = DECISION_ANSWERS_BLOCK_TYPE;
+exports.DECISION_ANSWERS_KIND = DECISION_ANSWERS_KIND;
+exports.INSTANCE_TITLE_KEYS = INSTANCE_TITLE_KEYS;
+exports.JSON_KIND_SPELLINGS = JSON_KIND_SPELLINGS;
+exports.KindImageAltUnwrap = KindImageAltUnwrap;
+exports.MarkdownEscapedKindJson = MarkdownEscapedKindJson;
+exports.QuotedKindLift = QuotedKindLift;
+exports.UNREADABLE_KIND_NOTE = UNREADABLE_KIND_NOTE;
+exports.ZeroWidthKindKey = ZeroWidthKindKey;
+exports.additionalDetailsSection = additionalDetailsSection;
+exports.balancedEnds = balancedEnds;
+exports.bareRegionBreaksIntoProse = bareRegionBreaksIntoProse;
+exports.canonicalizeCompletedLegacyQuizEnvelope = canonicalizeCompletedLegacyQuizEnvelope;
+exports.catalogProseText = catalogProseText;
+exports.closedJson = closedJson;
+exports.collectExtras = collectExtras;
+exports.conversationTitleText = conversationTitleText;
+exports.decodeDoubleEncodedKindText = decodeDoubleEncodedKindText;
+exports.deriveInstanceTitle = deriveInstanceTitle;
+exports.endsInPartialKindKey = endsInPartialKindKey;
+exports.envelopeMatchesParsedSource = envelopeMatchesParsedSource;
+exports.extrasList = extrasList;
+exports.findBrokenKindJsonRegions = findBrokenKindJsonRegions;
+exports.findEmbeddedKindJsonRegions = findEmbeddedKindJsonRegions;
+exports.findKindCarryingJsonValues = findKindCarryingJsonValues;
+exports.firstKindSlug = firstKindSlug;
+exports.formatInlineValue = formatInlineValue;
+exports.frontMatterEnd = frontMatterEnd;
+exports.genericKindMarkdown = genericKindMarkdown;
+exports.hasDetectionOnlyKindKey = hasDetectionOnlyKindKey;
+exports.hasExoticKindKey = hasExoticKindKey;
+exports.hasJsonKindKey = hasJsonKindKey;
+exports.hasKindKey = hasKindKey;
+exports.hasKindKeyAnySpelling = hasKindKeyAnySpelling;
+exports.hasPythonKindKey = hasPythonKindKey;
+exports.humanizeKind = humanizeKind;
+exports.inlineKindText = inlineKindText;
+exports.isJson5Language = isJson5Language;
+exports.isJsonFenceLanguage = isJsonFenceLanguage;
+exports.isKindJsonText = isKindJsonText;
+exports.isKindSlug = isKindSlug;
+exports.isQuotedSourceXmlBlock = isQuotedSourceXmlBlock;
+exports.isRecordValue = isRecordValue;
+exports.joinBlocks = joinBlocks;
+exports.json5AsJson = json5AsJson;
+exports.jsonKindSignal = jsonKindSignal;
+exports.kindGrammar = kindGrammar;
+exports.kindObjectProseBreak = kindObjectProseBreak;
+exports.kindOneLine = kindOneLine;
+exports.kindTextLabel = kindTextLabel;
+exports.kindTextPreview = kindTextPreview;
+exports.kindTextToMarkdown = kindTextToMarkdown;
+exports.kindTitleKeyFromMetadata = kindTitleKeyFromMetadata;
+exports.kindValueToMarkdown = kindValueToMarkdown;
+exports.liftQuotedKindRegions = liftQuotedKindRegions;
+exports.markdownCarriesKind = markdownCarriesKind;
+exports.mayHoldKindKey = mayHoldKindKey;
+exports.nonJsonKindsAsCode = nonJsonKindsAsCode;
+exports.normalizeKindSpellings = normalizeKindSpellings;
+exports.normalizeRecoveredContainerPiece = normalizeRecoveredContainerPiece;
+exports.normalizeRecoveredProsePiece = normalizeRecoveredProsePiece;
+exports.plainFieldLabel = plainFieldLabel;
+exports.plainValueMarkdown = plainValueMarkdown;
+exports.pythonBalancedEnd = pythonBalancedEnd;
+exports.pythonReprAsJson = pythonReprAsJson;
+exports.quotedSourceRanges = quotedSourceRanges;
+exports.regionJson = regionJson;
+exports.registerKindValueMarkdown = registerKindValueMarkdown;
+exports.rootKindSlug = rootKindSlug;
+exports.scanKindSpellingRegions = scanKindSpellingRegions;
+exports.spelledKindsAsOneLine = spelledKindsAsOneLine;
+exports.splitAroundEmbeddedKindJson = splitAroundEmbeddedKindJson;
+exports.textCarriesKind = textCarriesKind;
+exports.unescapeMarkdownKindJson = unescapeMarkdownKindJson;
+exports.unfinishedKindLabel = unfinishedKindLabel;
+exports.unreadableKindsAsNote = unreadableKindsAsNote;
+exports.unwrapKindImageAlt = unwrapKindImageAlt;
+exports.valueCarriesKind = valueCarriesKind;
+exports.withoutLeadingJsonComments = withoutLeadingJsonComments;
+exports.withoutZeroWidth = withoutZeroWidth;
+//# sourceMappingURL=surfaces.cjs.map
+//# sourceMappingURL=surfaces.cjs.map