@localix-ai/flowdown 0.0.0-stage → 0.5.0

package/dist/core/dollars.js

@@ -0,0 +1,88 @@
+import { closesInlineMath, opensInlineMath } from "./math-delimiters.js";
+import { isEscaped, markdownProseWithoutCode } from "./prose.js";
+// src/core/dollars.ts
+/**
+* Which `$` in a reply is a dollar sign rather than a math delimiter — one rule for the renderer
+* and for the streaming stabilizer.
+*
+* remark-math pairs ANY two single dollars in a paragraph, so the moment a reply held one real
+* formula, "costs $5 and $10" was typeset as the formula `5 and`, and "$HOME/bin and $PATH" became
+* italic math that also swallowed the backticks after it. The sniffer that decides whether to load
+* KaTeX already knew better; the parser did not. So the literal dollars are escaped (`\$`) before
+* the parser sees them, which CommonMark renders as a plain `$` — and the rule is kept here, once,
+* because the stabilizer must make the same call about the dollar a streaming tail ends on.
+*/
+/** A currency amount: digits, an optional magnitude, then a non-math character (`/` for a price per
+* unit, `$5/GB`) or the end. */
+const CURRENCY = /^\d[\d.,]*(?:[kKmMbB])?(?=[\s.,;:!?)\]'"`–—/-]|$)/;
+/** A shell or environment variable: an upper-case name, ended by a path or list separator. */
+const VARIABLE = /^[A-Z_][A-Z0-9_]+(?=[/:.,;)\]'"`]|$)/;
+/** A longer upper-case name also ends at a space (`$PATH before`); `$AB = CD$` stays math. */
+const LONG_VARIABLE = /^[A-Z_][A-Z0-9_]{2,}(?=\s)/;
+/**
+* Whether the `$` at `index` is a dollar sign by its own look: a price or a shell variable. A `$`
+* that pairs with no other (`$ x`, the shell line `$(seq 1 12) … $i`) is text as well, but that
+* takes the whole paragraph to tell: `literalDollars` asks both.
+*/
+function isLiteralDollar(text, index) {
+	if (text[index] !== "$" || isEscaped(text, index)) return false;
+	if (text[index - 1] === "$" || text[index + 1] === "$") return false;
+	const after = text.slice(index + 1, index + 48);
+	return CURRENCY.test(after) || VARIABLE.test(after) || LONG_VARIABLE.test(after);
+}
+/** A single `$`, neither escaped nor part of a `$$` run. */
+const isSingleDollar = (text, index) => text[index] === "$" && text[index - 1] !== "$" && text[index + 1] !== "$" && !isEscaped(text, index);
+/** Where the paragraph holding `index` ends: inline math never crosses a blank line. */
+function paragraphEnd(text, index) {
+	const blank = /\n[ \t]*\n/g;
+	blank.lastIndex = index;
+	return blank.exec(text)?.index ?? text.length;
+}
+/**
+* The single `$` that closes the formula opened at `open`, or -1 when none in its paragraph does.
+* A dollar sign (`$5`) is skipped: it is text, so it closes nothing.
+*/
+function inlineMathClose(text, open) {
+	const end = paragraphEnd(text, open);
+	for (let at = text.indexOf("$", open + 1); at !== -1 && at < end; at = text.indexOf("$", at + 1)) if (isSingleDollar(text, at) && !isLiteralDollar(text, at) && closesInlineMath(text, at)) return at;
+	return -1;
+}
+/**
+* Every single `$` in prose that is text rather than a delimiter, read left to right the way the
+* parser reads them: a price or a variable, a `$` that cannot open (`$ x`), and one that opens but
+* finds no closing `$` in its paragraph. A `$` that closes a formula is not in the list.
+*/
+function literalDollars(prose) {
+	const literal = [];
+	for (let index = prose.indexOf("$"); index !== -1; index = prose.indexOf("$", index + 1)) {
+		if (prose[index + 1] === "$") {
+			while (prose[index + 1] === "$") index += 1;
+			continue;
+		}
+		if (!isSingleDollar(prose, index)) continue;
+		const close = isLiteralDollar(prose, index) || !opensInlineMath(prose, index) ? -1 : inlineMathClose(prose, index);
+		if (close === -1) literal.push(index);
+		else index = close;
+	}
+	return literal;
+}
+/**
+* The source with every dollar in prose that is not a delimiter escaped (`\$`), so a parser
+* that pairs any two dollars (remark-math) reads the same formulas `<Markdown>` does. Code is left
+* byte for byte.
+*/
+function escapeLiteralDollars(markdown) {
+	if (!markdown.includes("$")) return markdown;
+	const literal = literalDollars(markdownProseWithoutCode(markdown));
+	if (literal.length === 0) return markdown;
+	let escaped = "";
+	let copied = 0;
+	for (const index of literal) {
+		escaped += `${markdown.slice(copied, index)}\\`;
+		copied = index;
+	}
+	return escaped + markdown.slice(copied);
+}
+export { escapeLiteralDollars, inlineMathClose, isLiteralDollar, literalDollars };
+
+//# sourceMappingURL=dollars.js.map

package/dist/core/dollars.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dollars.js","names":[],"sources":["../../src/core/dollars.ts"],"sourcesContent":["import { closesInlineMath, opensInlineMath } from './math-delimiters'\nimport { isEscaped, markdownProseWithoutCode } from './prose'\n\n/**\n * Which `$` in a reply is a dollar sign rather than a math delimiter — one rule for the renderer\n * and for the streaming stabilizer.\n *\n * remark-math pairs ANY two single dollars in a paragraph, so the moment a reply held one real\n * formula, \"costs $5 and $10\" was typeset as the formula `5 and`, and \"$HOME/bin and $PATH\" became\n * italic math that also swallowed the backticks after it. The sniffer that decides whether to load\n * KaTeX already knew better; the parser did not. So the literal dollars are escaped (`\\$`) before\n * the parser sees them, which CommonMark renders as a plain `$` — and the rule is kept here, once,\n * because the stabilizer must make the same call about the dollar a streaming tail ends on.\n */\n\n/** A currency amount: digits, an optional magnitude, then a non-math character (`/` for a price per\n * unit, `$5/GB`) or the end. */\nconst CURRENCY = /^\\d[\\d.,]*(?:[kKmMbB])?(?=[\\s.,;:!?)\\]'\"`–—/-]|$)/\n/** A shell or environment variable: an upper-case name, ended by a path or list separator. */\nconst VARIABLE = /^[A-Z_][A-Z0-9_]+(?=[/:.,;)\\]'\"`]|$)/\n/** A longer upper-case name also ends at a space (`$PATH before`); `$AB = CD$` stays math. */\nconst LONG_VARIABLE = /^[A-Z_][A-Z0-9_]{2,}(?=\\s)/\n\n/**\n * Whether the `$` at `index` is a dollar sign by its own look: a price or a shell variable. A `$`\n * that pairs with no other (`$ x`, the shell line `$(seq 1 12) … $i`) is text as well, but that\n * takes the whole paragraph to tell: `literalDollars` asks both.\n */\nexport function isLiteralDollar(text: string, index: number): boolean {\n  if (text[index] !== '$' || isEscaped(text, index)) return false\n  // `$$` is display math, never a dollar sign.\n  if (text[index - 1] === '$' || text[index + 1] === '$') return false\n  const after = text.slice(index + 1, index + 48)\n  return CURRENCY.test(after) || VARIABLE.test(after) || LONG_VARIABLE.test(after)\n}\n\n/** A single `$`, neither escaped nor part of a `$$` run. */\nconst isSingleDollar = (text: string, index: number) =>\n  text[index] === '$' &&\n  text[index - 1] !== '$' &&\n  text[index + 1] !== '$' &&\n  !isEscaped(text, index)\n\n/** Where the paragraph holding `index` ends: inline math never crosses a blank line. */\nfunction paragraphEnd(text: string, index: number): number {\n  const blank = /\\n[ \\t]*\\n/g\n  blank.lastIndex = index\n  return blank.exec(text)?.index ?? text.length\n}\n\n/**\n * The single `$` that closes the formula opened at `open`, or -1 when none in its paragraph does.\n * A dollar sign (`$5`) is skipped: it is text, so it closes nothing.\n */\nexport function inlineMathClose(text: string, open: number): number {\n  const end = paragraphEnd(text, open)\n  for (\n    let at = text.indexOf('$', open + 1);\n    at !== -1 && at < end;\n    at = text.indexOf('$', at + 1)\n  ) {\n    if (isSingleDollar(text, at) && !isLiteralDollar(text, at) && closesInlineMath(text, at))\n      return at\n  }\n  return -1\n}\n\n/**\n * Every single `$` in prose that is text rather than a delimiter, read left to right the way the\n * parser reads them: a price or a variable, a `$` that cannot open (`$ x`), and one that opens but\n * finds no closing `$` in its paragraph. A `$` that closes a formula is not in the list.\n */\nexport function literalDollars(prose: string): number[] {\n  const literal: number[] = []\n  for (let index = prose.indexOf('$'); index !== -1; index = prose.indexOf('$', index + 1)) {\n    if (prose[index + 1] === '$') {\n      // A `$$` run is display math, or the parser's to pair by length: skip the whole run.\n      while (prose[index + 1] === '$') index += 1\n      continue\n    }\n    if (!isSingleDollar(prose, index)) continue\n    const close =\n      isLiteralDollar(prose, index) || !opensInlineMath(prose, index)\n        ? -1\n        : inlineMathClose(prose, index)\n    if (close === -1) literal.push(index)\n    else index = close\n  }\n  return literal\n}\n\n/**\n * The source with every dollar in prose that is not a delimiter escaped (`\\$`), so a parser\n * that pairs any two dollars (remark-math) reads the same formulas `<Markdown>` does. Code is left\n * byte for byte.\n */\nexport function escapeLiteralDollars(markdown: string): string {\n  if (!markdown.includes('$')) return markdown\n  const literal = literalDollars(markdownProseWithoutCode(markdown))\n  if (literal.length === 0) return markdown\n  let escaped = ''\n  let copied = 0\n  for (const index of literal) {\n    escaped += `${markdown.slice(copied, index)}\\\\`\n    copied = index\n  }\n  return escaped + markdown.slice(copied)\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,MAAM,WAAW;;AAEjB,MAAM,WAAW;;AAEjB,MAAM,gBAAgB;;;;;;AAOtB,SAAgB,gBAAgB,MAAc,OAAwB;CACpE,IAAI,KAAK,WAAW,OAAO,UAAU,MAAM,KAAK,GAAG,OAAO;CAE1D,IAAI,KAAK,QAAQ,OAAO,OAAO,KAAK,QAAQ,OAAO,KAAK,OAAO;CAC/D,MAAM,QAAQ,KAAK,MAAM,QAAQ,GAAG,QAAQ,EAAE;CAC9C,OAAO,SAAS,KAAK,KAAK,KAAK,SAAS,KAAK,KAAK,KAAK,cAAc,KAAK,KAAK;AACjF;;AAGA,MAAM,kBAAkB,MAAc,UACpC,KAAK,WAAW,OAChB,KAAK,QAAQ,OAAO,OACpB,KAAK,QAAQ,OAAO,OACpB,CAAC,UAAU,MAAM,KAAK;;AAGxB,SAAS,aAAa,MAAc,OAAuB;CACzD,MAAM,QAAQ;CACd,MAAM,YAAY;CAClB,OAAO,MAAM,KAAK,IAAI,CAAC,EAAE,SAAS,KAAK;AACzC;;;;;AAMA,SAAgB,gBAAgB,MAAc,MAAsB;CAClE,MAAM,MAAM,aAAa,MAAM,IAAI;CACnC,KACE,IAAI,KAAK,KAAK,QAAQ,KAAK,OAAO,CAAC,GACnC,OAAO,MAAM,KAAK,KAClB,KAAK,KAAK,QAAQ,KAAK,KAAK,CAAC,GAE7B,IAAI,eAAe,MAAM,EAAE,KAAK,CAAC,gBAAgB,MAAM,EAAE,KAAK,iBAAiB,MAAM,EAAE,GACrF,OAAO;CAEX,OAAO;AACT;;;;;;AAOA,SAAgB,eAAe,OAAyB;CACtD,MAAM,UAAoB,CAAC;CAC3B,KAAK,IAAI,QAAQ,MAAM,QAAQ,GAAG,GAAG,UAAU,IAAI,QAAQ,MAAM,QAAQ,KAAK,QAAQ,CAAC,GAAG;EACxF,IAAI,MAAM,QAAQ,OAAO,KAAK;GAE5B,OAAO,MAAM,QAAQ,OAAO,KAAK,SAAS;GAC1C;EACF;EACA,IAAI,CAAC,eAAe,OAAO,KAAK,GAAG;EACnC,MAAM,QACJ,gBAAgB,OAAO,KAAK,KAAK,CAAC,gBAAgB,OAAO,KAAK,IAC1D,KACA,gBAAgB,OAAO,KAAK;EAClC,IAAI,UAAU,IAAI,QAAQ,KAAK,KAAK;OAC/B,QAAQ;CACf;CACA,OAAO;AACT;;;;;;AAOA,SAAgB,qBAAqB,UAA0B;CAC7D,IAAI,CAAC,SAAS,SAAS,GAAG,GAAG,OAAO;CACpC,MAAM,UAAU,eAAe,yBAAyB,QAAQ,CAAC;CACjE,IAAI,QAAQ,WAAW,GAAG,OAAO;CACjC,IAAI,UAAU;CACd,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,SAAS;EAC3B,WAAW,GAAG,SAAS,MAAM,QAAQ,KAAK,EAAE;EAC5C,SAAS;CACX;CACA,OAAO,UAAU,SAAS,MAAM,MAAM;AACxC"}

package/dist/core/fence-scan.js

@@ -0,0 +1,53 @@
+// src/core/fence-scan.ts
+const FENCE_LINE_RE = /^\s{0,3}(`{3,}|~{3,})(.*)$/;
+/** Complete lines scanned so far; tests read it to prove the scan resumes instead of restarting. */
+const fenceScanStats = { lines: 0 };
+/** The fence state after one line, given the state before it. */
+function step(open, line, lineEnd, textLength) {
+	const m = FENCE_LINE_RE.exec(line);
+	if (!m) return open;
+	if (open === null) {
+		if (m[1][0] === "`" && m[2].includes("`")) return null;
+		return {
+			marker: m[1],
+			bodyStart: Math.min(lineEnd, textLength)
+		};
+	}
+	return m[1][0] === open.marker[0] && m[1].length >= open.marker.length && m[2].trim() === "" ? null : open;
+}
+/**
+* A scan that remembers one growing text. Each rendered document has its own: two replies that
+* stream at once would otherwise take turns forgetting each other and scan from the start on
+* every token.
+*/
+function createFenceScanner() {
+	let cached = {
+		prefix: "",
+		open: null
+	};
+	return (text) => {
+		let { prefix, open } = cached;
+		if (!text.startsWith(prefix)) {
+			prefix = "";
+			open = null;
+		}
+		let offset = prefix.length;
+		const lastNewline = text.lastIndexOf("\n");
+		while (offset <= lastNewline) {
+			const nl = text.indexOf("\n", offset);
+			open = step(open, text.slice(offset, nl), nl + 1, text.length);
+			fenceScanStats.lines += 1;
+			offset = nl + 1;
+		}
+		if (offset !== prefix.length) cached = {
+			prefix: text.slice(0, offset),
+			open
+		};
+		return offset < text.length || lastNewline === -1 ? step(open, text.slice(offset), text.length + 1, text.length) : open;
+	};
+}
+/** The scan for a caller that follows one text at a time: `@localix-ai/flowdown/stream`'s functions. */
+const openFence = createFenceScanner();
+export { createFenceScanner, fenceScanStats, openFence };
+
+//# sourceMappingURL=fence-scan.js.map

package/dist/core/fence-scan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fence-scan.js","names":[],"sources":["../../src/core/fence-scan.ts"],"sourcesContent":["/**\n * Incremental fenced-code scan for streaming markdown.\n *\n * A streaming reply is re-stabilized on every token, and every call has to know whether the text\n * ends inside an open fence. Rescanning the whole reply each time is quadratic in its length, so\n * the scan state after the last complete line is remembered and resumed when the next text extends\n * it. Any other text simply rescans from the start.\n */\n\nexport interface OpenFence {\n  marker: string\n  bodyStart: number\n}\n\nconst FENCE_LINE_RE = /^\\s{0,3}(`{3,}|~{3,})(.*)$/\n\ninterface ScanState {\n  /** Text through the end of the last complete line (ends with `\\n`, or is empty). */\n  prefix: string\n  open: OpenFence | null\n}\n\n/** Complete lines scanned so far; tests read it to prove the scan resumes instead of restarting. */\nexport const fenceScanStats = { lines: 0 }\n\n/** The fence state after one line, given the state before it. */\nfunction step(\n  open: OpenFence | null,\n  line: string,\n  lineEnd: number,\n  textLength: number,\n): OpenFence | null {\n  const m = FENCE_LINE_RE.exec(line)\n  if (!m) return open\n  if (open === null) {\n    // A backtick fence has no backtick in its info string: ```` ```a``` ```` is inline code.\n    if (m[1]![0] === '`' && m[2]!.includes('`')) return null\n    return { marker: m[1]!, bodyStart: Math.min(lineEnd, textLength) }\n  }\n  const closes =\n    m[1]![0] === open.marker[0] && m[1]!.length >= open.marker.length && m[2]!.trim() === ''\n  return closes ? null : open\n}\n\n/**\n * The fence the text is currently inside — its marker (e.g. \"```\") and where its body starts —\n * or null when all fenced code blocks are closed. A closing fence must use the same character,\n * be at least as long as the opener, and carry no info string.\n */\nexport type FenceScanner = (text: string) => OpenFence | null\n\n/**\n * A scan that remembers one growing text. Each rendered document has its own: two replies that\n * stream at once would otherwise take turns forgetting each other and scan from the start on\n * every token.\n */\nexport function createFenceScanner(): FenceScanner {\n  let cached: ScanState = { prefix: '', open: null }\n\n  return (text) => {\n    let { prefix, open } = cached\n    if (!text.startsWith(prefix)) {\n      prefix = ''\n      open = null\n    }\n    let offset = prefix.length\n    const lastNewline = text.lastIndexOf('\\n')\n    while (offset <= lastNewline) {\n      const nl = text.indexOf('\\n', offset)\n      open = step(open, text.slice(offset, nl), nl + 1, text.length)\n      fenceScanStats.lines += 1\n      offset = nl + 1\n    }\n    if (offset !== prefix.length) cached = { prefix: text.slice(0, offset), open }\n    // The unterminated last line is evaluated but never committed: it may still change.\n    return offset < text.length || lastNewline === -1\n      ? step(open, text.slice(offset), text.length + 1, text.length)\n      : open\n  }\n}\n\n/** The scan for a caller that follows one text at a time: `@localix-ai/flowdown/stream`'s functions. */\nexport const openFence: FenceScanner = createFenceScanner()\n"],"mappings":";AAcA,MAAM,gBAAgB;;AAStB,MAAa,iBAAiB,EAAE,OAAO,EAAE;;AAGzC,SAAS,KACP,MACA,MACA,SACA,YACkB;CAClB,MAAM,IAAI,cAAc,KAAK,IAAI;CACjC,IAAI,CAAC,GAAG,OAAO;CACf,IAAI,SAAS,MAAM;EAEjB,IAAI,EAAE,EAAE,CAAE,OAAO,OAAO,EAAE,EAAE,CAAE,SAAS,GAAG,GAAG,OAAO;EACpD,OAAO;GAAE,QAAQ,EAAE;GAAK,WAAW,KAAK,IAAI,SAAS,UAAU;EAAE;CACnE;CAGA,OADE,EAAE,EAAE,CAAE,OAAO,KAAK,OAAO,MAAM,EAAE,EAAE,CAAE,UAAU,KAAK,OAAO,UAAU,EAAE,EAAE,CAAE,KAAK,MAAM,KACxE,OAAO;AACzB;;;;;;AAcA,SAAgB,qBAAmC;CACjD,IAAI,SAAoB;EAAE,QAAQ;EAAI,MAAM;CAAK;CAEjD,QAAQ,SAAS;EACf,IAAI,EAAE,QAAQ,SAAS;EACvB,IAAI,CAAC,KAAK,WAAW,MAAM,GAAG;GAC5B,SAAS;GACT,OAAO;EACT;EACA,IAAI,SAAS,OAAO;EACpB,MAAM,cAAc,KAAK,YAAY,IAAI;EACzC,OAAO,UAAU,aAAa;GAC5B,MAAM,KAAK,KAAK,QAAQ,MAAM,MAAM;GACpC,OAAO,KAAK,MAAM,KAAK,MAAM,QAAQ,EAAE,GAAG,KAAK,GAAG,KAAK,MAAM;GAC7D,eAAe,SAAS;GACxB,SAAS,KAAK;EAChB;EACA,IAAI,WAAW,OAAO,QAAQ,SAAS;GAAE,QAAQ,KAAK,MAAM,GAAG,MAAM;GAAG;EAAK;EAE7E,OAAO,SAAS,KAAK,UAAU,gBAAgB,KAC3C,KAAK,MAAM,KAAK,MAAM,MAAM,GAAG,KAAK,SAAS,GAAG,KAAK,MAAM,IAC3D;CACN;AACF;;AAGA,MAAa,YAA0B,mBAAmB"}

package/dist/core/file-tree-parse.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Reading a ```tree fence: the directory layout models already draw with box characters, as rows
+ * a renderer can lay out (`FileTree.tsx`).
+ *
+ *   src/
+ *   ├── app.ts          # entry point
+ *   └── features/
+ *       └── chat/
+ *
+ * Depth is the number of 4-column guides (`│   ` or four spaces) before a branch (`├── ` /
+ * `└── `); a line with no branch is a root. A row is a FOLDER when its name ends with `/` or the
+ * next row is deeper. A comment — after `#`, or after a run of two or more spaces — is set apart
+ * from the name. A line the grammar does not fit is kept as a plain row at its depth, so a tree
+ * still reads when a model draws it slightly off.
+ */
+export interface TreeRow {
+  depth: number;
+  name: string;
+  comment: string;
+  folder: boolean;
+  /** The row's place in the tree, `src/app/App.tsx` — a stable key for focus and collapse. */
+  path: string;
+  /** The nearest shallower row above it; null at the top level. */
+  parent: number | null;
+}
+export declare function parseFileTree(source: string): TreeRow[];

package/dist/core/file-tree-parse.js

@@ -0,0 +1,51 @@
+// src/core/file-tree-parse.ts
+const GUIDE = /^(?:│ {3}|\| {3}| {4})/;
+const BRANCH = /^(?:├──|└──|\|--|`--|\+--)\s?/;
+function readLine(line) {
+	let rest = line.replace(/\s+$/, "");
+	if (!rest.trim()) return null;
+	let depth = 0;
+	while (GUIDE.test(rest)) {
+		rest = rest.replace(GUIDE, "");
+		depth++;
+	}
+	const branch = BRANCH.exec(rest);
+	if (branch) {
+		rest = rest.slice(branch[0].length);
+		depth++;
+	} else rest = rest.trimStart();
+	const commentAt = rest.search(/\s+#|\s{2,}/);
+	const name = (commentAt === -1 ? rest : rest.slice(0, commentAt)).trim();
+	const comment = commentAt === -1 ? "" : rest.slice(commentAt).replace(/^\s*#?\s*/, "").trim();
+	return {
+		depth,
+		name,
+		comment
+	};
+}
+function parseFileTree(source) {
+	const rows = source.split("\n").flatMap((line) => {
+		const row = readLine(line);
+		return row ? [row] : [];
+	});
+	const parsed = [];
+	const plain = [];
+	rows.forEach((row, index) => {
+		let parent = null;
+		for (let above = index - 1; above >= 0; above--) if (rows[above].depth < row.depth) {
+			parent = above;
+			break;
+		}
+		plain.push(`${parent === null ? "" : `${plain[parent].replace(/\/$/, "")}/`}${row.name}`);
+		parsed.push({
+			...row,
+			folder: row.name.endsWith("/") || (rows[index + 1]?.depth ?? 0) > row.depth,
+			path: `${plain[index]}#${index}`,
+			parent
+		});
+	});
+	return parsed;
+}
+export { parseFileTree };
+
+//# sourceMappingURL=file-tree-parse.js.map

package/dist/core/file-tree-parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-tree-parse.js","names":[],"sources":["../../src/core/file-tree-parse.ts"],"sourcesContent":["/**\n * Reading a ```tree fence: the directory layout models already draw with box characters, as rows\n * a renderer can lay out (`FileTree.tsx`).\n *\n *   src/\n *   ├── app.ts          # entry point\n *   └── features/\n *       └── chat/\n *\n * Depth is the number of 4-column guides (`│   ` or four spaces) before a branch (`├── ` /\n * `└── `); a line with no branch is a root. A row is a FOLDER when its name ends with `/` or the\n * next row is deeper. A comment — after `#`, or after a run of two or more spaces — is set apart\n * from the name. A line the grammar does not fit is kept as a plain row at its depth, so a tree\n * still reads when a model draws it slightly off.\n */\nexport interface TreeRow {\n  depth: number\n  name: string\n  comment: string\n  folder: boolean\n  /** The row's place in the tree, `src/app/App.tsx` — a stable key for focus and collapse. */\n  path: string\n  /** The nearest shallower row above it; null at the top level. */\n  parent: number | null\n}\n\nconst GUIDE = /^(?:│ {3}|\\| {3}| {4})/\nconst BRANCH = /^(?:├──|└──|\\|--|`--|\\+--)\\s?/\n\nfunction readLine(line: string): Pick<TreeRow, 'depth' | 'name' | 'comment'> | null {\n  let rest = line.replace(/\\s+$/, '')\n  if (!rest.trim()) return null\n  let depth = 0\n  while (GUIDE.test(rest)) {\n    rest = rest.replace(GUIDE, '')\n    depth++\n  }\n  const branch = BRANCH.exec(rest)\n  if (branch) {\n    rest = rest.slice(branch[0].length)\n    depth++\n  } else rest = rest.trimStart()\n  const commentAt = rest.search(/\\s+#|\\s{2,}/)\n  const name = (commentAt === -1 ? rest : rest.slice(0, commentAt)).trim()\n  const comment =\n    commentAt === -1\n      ? ''\n      : rest\n          .slice(commentAt)\n          .replace(/^\\s*#?\\s*/, '')\n          .trim()\n  return { depth, name, comment }\n}\n\nexport function parseFileTree(source: string): TreeRow[] {\n  const rows = source.split('\\n').flatMap((line) => {\n    const row = readLine(line)\n    return row ? [row] : []\n  })\n  const parsed: TreeRow[] = []\n  const plain: string[] = []\n  rows.forEach((row, index) => {\n    let parent: number | null = null\n    for (let above = index - 1; above >= 0; above--)\n      if (rows[above]!.depth < row.depth) {\n        parent = above\n        break\n      }\n    plain.push(`${parent === null ? '' : `${plain[parent]!.replace(/\\/$/, '')}/`}${row.name}`)\n    parsed.push({\n      ...row,\n      folder: row.name.endsWith('/') || (rows[index + 1]?.depth ?? 0) > row.depth,\n      // Two rows may share a path when a model repeats a name; the index keeps the key unique.\n      path: `${plain[index]}#${index}`,\n      parent,\n    })\n  })\n  return parsed\n}\n"],"mappings":";AA0BA,MAAM,QAAQ;AACd,MAAM,SAAS;AAEf,SAAS,SAAS,MAAkE;CAClF,IAAI,OAAO,KAAK,QAAQ,QAAQ,EAAE;CAClC,IAAI,CAAC,KAAK,KAAK,GAAG,OAAO;CACzB,IAAI,QAAQ;CACZ,OAAO,MAAM,KAAK,IAAI,GAAG;EACvB,OAAO,KAAK,QAAQ,OAAO,EAAE;EAC7B;CACF;CACA,MAAM,SAAS,OAAO,KAAK,IAAI;CAC/B,IAAI,QAAQ;EACV,OAAO,KAAK,MAAM,OAAO,EAAE,CAAC,MAAM;EAClC;CACF,OAAO,OAAO,KAAK,UAAU;CAC7B,MAAM,YAAY,KAAK,OAAO,aAAa;CAC3C,MAAM,QAAQ,cAAc,KAAK,OAAO,KAAK,MAAM,GAAG,SAAS,EAAA,CAAG,KAAK;CACvE,MAAM,UACJ,cAAc,KACV,KACA,KACG,MAAM,SAAS,CAAC,CAChB,QAAQ,aAAa,EAAE,CAAC,CACxB,KAAK;CACd,OAAO;EAAE;EAAO;EAAM;CAAQ;AAChC;AAEA,SAAgB,cAAc,QAA2B;CACvD,MAAM,OAAO,OAAO,MAAM,IAAI,CAAC,CAAC,SAAS,SAAS;EAChD,MAAM,MAAM,SAAS,IAAI;EACzB,OAAO,MAAM,CAAC,GAAG,IAAI,CAAC;CACxB,CAAC;CACD,MAAM,SAAoB,CAAC;CAC3B,MAAM,QAAkB,CAAC;CACzB,KAAK,SAAS,KAAK,UAAU;EAC3B,IAAI,SAAwB;EAC5B,KAAK,IAAI,QAAQ,QAAQ,GAAG,SAAS,GAAG,SACtC,IAAI,KAAK,MAAM,CAAE,QAAQ,IAAI,OAAO;GAClC,SAAS;GACT;EACF;EACF,MAAM,KAAK,GAAG,WAAW,OAAO,KAAK,GAAG,MAAM,OAAO,CAAE,QAAQ,OAAO,EAAE,EAAE,KAAK,IAAI,MAAM;EACzF,OAAO,KAAK;GACV,GAAG;GACH,QAAQ,IAAI,KAAK,SAAS,GAAG,MAAM,KAAK,QAAQ,EAAE,EAAE,SAAS,KAAK,IAAI;GAEtE,MAAM,GAAG,MAAM,OAAO,GAAG;GACzB;EACF,CAAC;CACH,CAAC;CACD,OAAO;AACT"}

package/dist/core/forms-html.js

@@ -0,0 +1,63 @@
+// src/core/forms-html.ts
+/** The element a form becomes; a form not here keeps the element its node already is. */
+const TAGS = {
+	"quote-source": "footer",
+	figure: "figure",
+	caption: "figcaption",
+	"section-number": "span",
+	form: "div",
+	"step-head": "div",
+	"step-title": "span",
+	"step-meta": "span",
+	"step-body": "div",
+	stat: "div",
+	"stat-value": "span",
+	"stat-label": "span",
+	source: "div",
+	"source-title": "span",
+	"source-host": "span",
+	"source-note": "span",
+	tabs: "answer-tabs",
+	tab: "answer-tab",
+	verdict: "aside",
+	verdicts: "div",
+	details: "details",
+	summary: "summary"
+};
+/** Forms that are told apart by their element or an attribute, not by a class. */
+const UNCLASSED = /* @__PURE__ */ new Set([
+	"callout",
+	"code",
+	"caption",
+	"tabs",
+	"tab",
+	"summary"
+]);
+const lowerToHtml = (form, data) => {
+	const name = form.form;
+	if (name === "callout") return { hProperties: {
+		dataCallout: form.kind,
+		...form.title ? { dataCalloutTitle: form.title } : {}
+	} };
+	if (name === "code") return { hProperties: {
+		...data?.hProperties,
+		dataTitle: form.title
+	} };
+	const tag = TAGS[name];
+	const properties = {};
+	if (!UNCLASSED.has(name)) properties.className = [`fd-${name}`];
+	if (name === "tab") properties.dataLabel = form.label;
+	if (name === "verdict") properties.dataVerdict = form.kind;
+	let has = false;
+	for (const _ in properties) {
+		has = true;
+		break;
+	}
+	return {
+		...tag === void 0 ? null : { hName: tag },
+		...has ? { hProperties: properties } : null
+	};
+};
+export { lowerToHtml };
+
+//# sourceMappingURL=forms-html.js.map

package/dist/core/forms-html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forms-html.js","names":[],"sources":["../../src/core/forms-html.ts"],"sourcesContent":["/**\n * The dialect's forms as HTML: the element each becomes and the class the stylesheet draws it by,\n * in the two fields remark and the engine's renderer both read (`hName`, `hProperties`).\n */\nimport type { FormName, Lowering } from './forms'\n\n/** The element a form becomes; a form not here keeps the element its node already is. */\nconst TAGS: Partial<Record<FormName, string>> = {\n  'quote-source': 'footer',\n  figure: 'figure',\n  caption: 'figcaption',\n  'section-number': 'span',\n  form: 'div',\n  'step-head': 'div',\n  'step-title': 'span',\n  'step-meta': 'span',\n  'step-body': 'div',\n  stat: 'div',\n  'stat-value': 'span',\n  'stat-label': 'span',\n  source: 'div',\n  'source-title': 'span',\n  'source-host': 'span',\n  'source-note': 'span',\n  tabs: 'answer-tabs',\n  tab: 'answer-tab',\n  verdict: 'aside',\n  verdicts: 'div',\n  details: 'details',\n  summary: 'summary',\n}\n\n/** Forms that are told apart by their element or an attribute, not by a class. */\nconst UNCLASSED = new Set<FormName>(['callout', 'code', 'caption', 'tabs', 'tab', 'summary'])\n\nexport const lowerToHtml: Lowering = (form, data) => {\n  const name = form.form\n  if (name === 'callout')\n    return {\n      hProperties: {\n        dataCallout: form.kind,\n        ...(form.title ? { dataCalloutTitle: form.title } : {}),\n      },\n    }\n  // A fence's file rides on its <code>, beside what a stage before this one put there.\n  if (name === 'code')\n    return {\n      hProperties: { ...(data?.hProperties as Record<string, unknown>), dataTitle: form.title },\n    }\n  const tag = TAGS[name]\n  const properties: Record<string, unknown> = {}\n  if (!UNCLASSED.has(name)) properties.className = [`fd-${name}`]\n  if (name === 'tab') properties.dataLabel = form.label\n  if (name === 'verdict') properties.dataVerdict = form.kind\n  let has = false\n  for (const _ in properties) {\n    has = true\n    break\n  }\n  return {\n    ...(tag === undefined ? null : { hName: tag }),\n    ...(has ? { hProperties: properties } : null),\n  }\n}\n"],"mappings":";;AAOA,MAAM,OAA0C;CAC9C,gBAAgB;CAChB,QAAQ;CACR,SAAS;CACT,kBAAkB;CAClB,MAAM;CACN,aAAa;CACb,cAAc;CACd,aAAa;CACb,aAAa;CACb,MAAM;CACN,cAAc;CACd,cAAc;CACd,QAAQ;CACR,gBAAgB;CAChB,eAAe;CACf,eAAe;CACf,MAAM;CACN,KAAK;CACL,SAAS;CACT,UAAU;CACV,SAAS;CACT,SAAS;AACX;;AAGA,MAAM,4BAAY,IAAI,IAAc;CAAC;CAAW;CAAQ;CAAW;CAAQ;CAAO;AAAS,CAAC;AAE5F,MAAa,eAAyB,MAAM,SAAS;CACnD,MAAM,OAAO,KAAK;CAClB,IAAI,SAAS,WACX,OAAO,EACL,aAAa;EACX,aAAa,KAAK;EAClB,GAAI,KAAK,QAAQ,EAAE,kBAAkB,KAAK,MAAM,IAAI,CAAC;CACvD,EACF;CAEF,IAAI,SAAS,QACX,OAAO,EACL,aAAa;EAAE,GAAI,MAAM;EAAyC,WAAW,KAAK;CAAM,EAC1F;CACF,MAAM,MAAM,KAAK;CACjB,MAAM,aAAsC,CAAC;CAC7C,IAAI,CAAC,UAAU,IAAI,IAAI,GAAG,WAAW,YAAY,CAAC,MAAM,MAAM;CAC9D,IAAI,SAAS,OAAO,WAAW,YAAY,KAAK;CAChD,IAAI,SAAS,WAAW,WAAW,cAAc,KAAK;CACtD,IAAI,MAAM;CACV,KAAK,MAAM,KAAK,YAAY;EAC1B,MAAM;EACN;CACF;CACA,OAAO;EACL,GAAI,QAAQ,KAAA,IAAY,OAAO,EAAE,OAAO,IAAI;EAC5C,GAAI,MAAM,EAAE,aAAa,WAAW,IAAI;CAC1C;AACF"}

package/dist/core/forms.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What the dialect says a node IS, apart from how any target draws it.
+ *
+ * A pass of the dialect marks nodes with a {@link Form} (`data.flowdown`): this list is a timeline,
+ * this quote a warning, this paragraph the head of a step. A target reads the mark and draws the
+ * node its own way: a terminal prints a callout as a coloured bar, a page as an `<aside>`. What a
+ * form is in HTML is one table (`forms-html.ts`), handed to the pass by whoever wants HTML: the
+ * pass itself names no element and no class.
+ *
+ * A target that does not know a form draws the node as the Markdown it still is (a list, a quote,
+ * a paragraph), so a form added later reads as text everywhere before any target learns it.
+ */
+import { CalloutKind } from "../dialect.js";
+/** Every mark the dialect makes. A name is its own contract: targets switch on it. */
+export type FormName = 'callout' | 'quote-source' | 'figure' | 'caption' | 'section-number' | 'code' | 'form' | 'steps' | 'steps-title' | 'step-head' | 'step-title' | 'step-meta' | 'step-body' | 'stats' | 'stats-title' | 'stat' | 'stat-value' | 'stat-label' | 'sources' | 'sources-title' | 'source' | 'source-title' | 'source-host' | 'source-note' | 'tabs' | 'tabs-title' | 'tab' | 'verdict' | 'verdict-title' | 'verdict-list' | 'verdicts' | 'details' | 'summary';
+export interface Form {
+  form: FormName;
+  /** A callout's kind (`warning`), or which side a verdict argues (`pros`, `cons`). */
+  kind?: CalloutKind | 'pros' | 'cons';
+  /** The title the author wrote: on a callout, and the file a code fence names. */
+  title?: string;
+  /** A tab's label. */
+  label?: string;
+}
+/** The form a node was marked with, if any. */
+export declare const formOf: (node: {
+  data?: unknown;
+} | undefined) => Form | undefined;

package/dist/core/forms.js

@@ -0,0 +1,23 @@
+// src/core/forms.ts
+let lowering = null;
+/** Runs a pass with `lower` applied to every node it marks. A pass is synchronous. */
+function lowered(lower, pass) {
+	const before = lowering;
+	lowering = lower;
+	try {
+		return pass();
+	} finally {
+		lowering = before;
+	}
+}
+/** A node's data with `form` marked on it. Without `data`, the mark is all the node carries. */
+const marked = (form, data) => ({
+	...data,
+	flowdown: form,
+	...lowering?.(form, data)
+});
+/** The form a node was marked with, if any. */
+const formOf = (node) => (node?.data)?.flowdown;
+export { formOf, lowered, marked };
+
+//# sourceMappingURL=forms.js.map

package/dist/core/forms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forms.js","names":[],"sources":["../../src/core/forms.ts"],"sourcesContent":["/**\n * What the dialect says a node IS, apart from how any target draws it.\n *\n * A pass of the dialect marks nodes with a {@link Form} (`data.flowdown`): this list is a timeline,\n * this quote a warning, this paragraph the head of a step. A target reads the mark and draws the\n * node its own way: a terminal prints a callout as a coloured bar, a page as an `<aside>`. What a\n * form is in HTML is one table (`forms-html.ts`), handed to the pass by whoever wants HTML: the\n * pass itself names no element and no class.\n *\n * A target that does not know a form draws the node as the Markdown it still is (a list, a quote,\n * a paragraph), so a form added later reads as text everywhere before any target learns it.\n */\nimport type { CalloutKind } from '../dialect'\n\n/** Every mark the dialect makes. A name is its own contract: targets switch on it. */\nexport type FormName =\n  | 'callout'\n  | 'quote-source'\n  | 'figure'\n  | 'caption'\n  | 'section-number'\n  | 'code'\n  | 'form'\n  | 'steps'\n  | 'steps-title'\n  | 'step-head'\n  | 'step-title'\n  | 'step-meta'\n  | 'step-body'\n  | 'stats'\n  | 'stats-title'\n  | 'stat'\n  | 'stat-value'\n  | 'stat-label'\n  | 'sources'\n  | 'sources-title'\n  | 'source'\n  | 'source-title'\n  | 'source-host'\n  | 'source-note'\n  | 'tabs'\n  | 'tabs-title'\n  | 'tab'\n  | 'verdict'\n  | 'verdict-title'\n  | 'verdict-list'\n  | 'verdicts'\n  | 'details'\n  | 'summary'\n\nexport interface Form {\n  form: FormName\n  /** A callout's kind (`warning`), or which side a verdict argues (`pros`, `cons`). */\n  kind?: CalloutKind | 'pros' | 'cons'\n  /** The title the author wrote: on a callout, and the file a code fence names. */\n  title?: string\n  /** A tab's label. */\n  label?: string\n}\n\n/** A node's fields besides its own: what a pass has written on it. */\nexport type NodeData = Record<string, unknown> & { flowdown?: Form }\n\n/**\n * What a form is in one target's own terms, as fields to put on the node beside the mark. `data`\n * is what the node carried before, for a lowering that adds to it.\n */\nexport type Lowering = (form: Form, data: NodeData | undefined) => Record<string, unknown>\n\nlet lowering: Lowering | null = null\n\n/** Runs a pass with `lower` applied to every node it marks. A pass is synchronous. */\nexport function lowered<T>(lower: Lowering | null, pass: () => T): T {\n  const before = lowering\n  lowering = lower\n  try {\n    return pass()\n  } finally {\n    lowering = before\n  }\n}\n\n/** A node's data with `form` marked on it. Without `data`, the mark is all the node carries. */\nexport const marked = <D extends object>(form: Form, data?: D): D & { flowdown: Form } =>\n  ({ ...data, flowdown: form, ...lowering?.(form, data as NodeData | undefined) }) as D & {\n    flowdown: Form\n  }\n\n/** The form a node was marked with, if any. */\nexport const formOf = (node: { data?: unknown } | undefined): Form | undefined =>\n  (node?.data as NodeData | undefined)?.flowdown\n"],"mappings":";AAqEA,IAAI,WAA4B;;AAGhC,SAAgB,QAAW,OAAwB,MAAkB;CACnE,MAAM,SAAS;CACf,WAAW;CACX,IAAI;EACF,OAAO,KAAK;CACd,UAAU;EACR,WAAW;CACb;AACF;;AAGA,MAAa,UAA4B,MAAY,UAClD;CAAE,GAAG;CAAM,UAAU;CAAM,GAAG,WAAW,MAAM,IAA4B;AAAE;;AAKhF,MAAa,UAAU,UACpB,MAAM,KAAA,EAA+B"}

package/dist/core/headings.d.ts

@@ -0,0 +1,11 @@
+import { Tree } from "../engine/types.js";
+export interface MarkdownHeading {
+  depth: number;
+  text: string;
+  id: string;
+}
+export declare function extractMarkdownHeadings(content: string): MarkdownHeading[];
+/** remark: give every heading of an mdast tree its id (`data.hProperties.id`). */
+export declare function remarkHeadingIds(): (tree: Tree) => void;
+/** Every heading's id, keyed by where the heading starts in `content`. */
+export declare function headingIdsByOffset(content: string): Map<number, string>;

package/dist/core/headings.js

@@ -0,0 +1,74 @@
+import { parse } from "../engine/index.js";
+import { toText, visit } from "../engine/visit.js";
+// src/core/headings.ts
+function slugifyHeading(text) {
+	return text.toLowerCase().replace(/[`*_~]/g, "").replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "");
+}
+/** One pass owns both the outline and the rendered ids, repeated headings included. */
+function assignHeadings(tree) {
+	const headings = [];
+	const used = /* @__PURE__ */ new Set();
+	visit(tree, (node) => {
+		if (node.type !== "heading") return;
+		const text = toText(node);
+		const base = slugifyHeading(text) || "section";
+		let id = base;
+		let suffix = 1;
+		while (used.has(id)) id = `${base}-${suffix++}`;
+		used.add(id);
+		node.data = {
+			...node.data,
+			hProperties: {
+				...node.data?.hProperties,
+				id
+			}
+		};
+		headings.push({
+			depth: node.depth ?? 1,
+			text,
+			id
+		});
+	});
+	return headings;
+}
+function extractMarkdownHeadings(content) {
+	return assignHeadings(parse(content));
+}
+/** remark: give every heading of an mdast tree its id (`data.hProperties.id`). */
+function remarkHeadingIds() {
+	return (tree) => {
+		assignHeadings(tree);
+	};
+}
+/**
+* Every heading in `content` with where it starts and the text its id is made from, before
+* repeated ids are numbered: the numbering is the document's, done over all of its blocks.
+*/
+function headingBases(content) {
+	const bases = [];
+	visit(parse(content), (node) => {
+		const offset = node.position?.start.offset;
+		if (node.type === "heading" && offset !== void 0) bases.push({
+			offset,
+			base: slugifyHeading(toText(node)) || "section"
+		});
+	});
+	return bases;
+}
+/** Every heading's id, keyed by where the heading starts in `content`. */
+function headingIdsByOffset(content) {
+	const tree = parse(content);
+	const ids = /* @__PURE__ */ new Map();
+	const headings = assignHeadings(tree);
+	let at = 0;
+	visit(tree, (node) => {
+		if (node.type !== "heading") return;
+		const offset = node.position?.start.offset;
+		const id = headings[at++]?.id;
+		if (offset !== void 0 && id !== void 0) ids.set(offset, id);
+	});
+	return ids;
+}
+export { extractMarkdownHeadings, headingBases, headingIdsByOffset, remarkHeadingIds };
+
+//# sourceMappingURL=headings.js.map

package/dist/core/headings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headings.js","names":[],"sources":["../../src/core/headings.ts"],"sourcesContent":["import { parse } from '../engine'\nimport type { Node, Tree } from '../engine/types'\nimport { toText, visit } from '../engine/visit'\n\nexport interface MarkdownHeading {\n  depth: number\n  text: string\n  id: string\n}\n\nfunction slugifyHeading(text: string): string {\n  return text\n    .toLowerCase()\n    .replace(/[`*_~]/g, '')\n    .replace(/[^\\p{L}\\p{N}]+/gu, '-')\n    .replace(/^-+|-+$/g, '')\n}\n\n/** One pass owns both the outline and the rendered ids, repeated headings included. */\nfunction assignHeadings(tree: Node): MarkdownHeading[] {\n  const headings: MarkdownHeading[] = []\n  const used = new Set<string>()\n  visit(tree, (node) => {\n    if (node.type !== 'heading') return\n    const text = toText(node)\n    const base = slugifyHeading(text) || 'section'\n    let id = base\n    let suffix = 1\n    while (used.has(id)) id = `${base}-${suffix++}`\n    used.add(id)\n    node.data = { ...node.data, hProperties: { ...(node.data?.hProperties as object), id } }\n    headings.push({ depth: node.depth ?? 1, text, id })\n  })\n  return headings\n}\n\nexport function extractMarkdownHeadings(content: string): MarkdownHeading[] {\n  return assignHeadings(parse(content))\n}\n\n/** remark: give every heading of an mdast tree its id (`data.hProperties.id`). */\nexport function remarkHeadingIds() {\n  return (tree: Tree): void => {\n    assignHeadings(tree as Node)\n  }\n}\n\n/**\n * Every heading in `content` with where it starts and the text its id is made from, before\n * repeated ids are numbered: the numbering is the document's, done over all of its blocks.\n */\nexport function headingBases(content: string): Array<{ offset: number; base: string }> {\n  const bases: Array<{ offset: number; base: string }> = []\n  visit(parse(content), (node) => {\n    const offset = node.position?.start.offset\n    if (node.type === 'heading' && offset !== undefined)\n      bases.push({ offset, base: slugifyHeading(toText(node)) || 'section' })\n  })\n  return bases\n}\n\n/** Every heading's id, keyed by where the heading starts in `content`. */\nexport function headingIdsByOffset(content: string): Map<number, string> {\n  const tree = parse(content)\n  const ids = new Map<number, string>()\n  const headings = assignHeadings(tree)\n  let at = 0\n  visit(tree, (node) => {\n    if (node.type !== 'heading') return\n    const offset = node.position?.start.offset\n    const id = headings[at++]?.id\n    if (offset !== undefined && id !== undefined) ids.set(offset, id)\n  })\n  return ids\n}\n"],"mappings":";;;AAUA,SAAS,eAAe,MAAsB;CAC5C,OAAO,KACJ,YAAY,CAAC,CACb,QAAQ,WAAW,EAAE,CAAC,CACtB,QAAQ,oBAAoB,GAAG,CAAC,CAChC,QAAQ,YAAY,EAAE;AAC3B;;AAGA,SAAS,eAAe,MAA+B;CACrD,MAAM,WAA8B,CAAC;CACrC,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,OAAO,SAAS;EACpB,IAAI,KAAK,SAAS,WAAW;EAC7B,MAAM,OAAO,OAAO,IAAI;EACxB,MAAM,OAAO,eAAe,IAAI,KAAK;EACrC,IAAI,KAAK;EACT,IAAI,SAAS;EACb,OAAO,KAAK,IAAI,EAAE,GAAG,KAAK,GAAG,KAAK,GAAG;EACrC,KAAK,IAAI,EAAE;EACX,KAAK,OAAO;GAAE,GAAG,KAAK;GAAM,aAAa;IAAE,GAAI,KAAK,MAAM;IAAwB;GAAG;EAAE;EACvF,SAAS,KAAK;GAAE,OAAO,KAAK,SAAS;GAAG;GAAM;EAAG,CAAC;CACpD,CAAC;CACD,OAAO;AACT;AAEA,SAAgB,wBAAwB,SAAoC;CAC1E,OAAO,eAAe,MAAM,OAAO,CAAC;AACtC;;AAGA,SAAgB,mBAAmB;CACjC,QAAQ,SAAqB;EAC3B,eAAe,IAAY;CAC7B;AACF;;;;;AAMA,SAAgB,aAAa,SAA0D;CACrF,MAAM,QAAiD,CAAC;CACxD,MAAM,MAAM,OAAO,IAAI,SAAS;EAC9B,MAAM,SAAS,KAAK,UAAU,MAAM;EACpC,IAAI,KAAK,SAAS,aAAa,WAAW,KAAA,GACxC,MAAM,KAAK;GAAE;GAAQ,MAAM,eAAe,OAAO,IAAI,CAAC,KAAK;EAAU,CAAC;CAC1E,CAAC;CACD,OAAO;AACT;;AAGA,SAAgB,mBAAmB,SAAsC;CACvE,MAAM,OAAO,MAAM,OAAO;CAC1B,MAAM,sBAAM,IAAI,IAAoB;CACpC,MAAM,WAAW,eAAe,IAAI;CACpC,IAAI,KAAK;CACT,MAAM,OAAO,SAAS;EACpB,IAAI,KAAK,SAAS,WAAW;EAC7B,MAAM,SAAS,KAAK,UAAU,MAAM;EACpC,MAAM,KAAK,SAAS,KAAK,EAAE;EAC3B,IAAI,WAAW,KAAA,KAAa,OAAO,KAAA,GAAW,IAAI,IAAI,QAAQ,EAAE;CAClE,CAAC;CACD,OAAO;AACT"}

package/dist/core/heal.d.ts

@@ -0,0 +1,11 @@
+/** Whether a stabilized fence is the one incomplete body still being written. */
+export declare function isGrowingFence(growing: string | null, source: string): boolean;
+/**
+ * The body of the fence a streaming text ends inside, or null when every fence is closed.
+ *
+ * Only the LAST fence can be unterminated, so this is how a renderer tells the one block that is
+ * still being written from the finished blocks above it — a diagram above the tail is complete
+ * and can be drawn now, instead of waiting for the whole reply to settle.
+ */
+export declare function openFenceBody(text: string): string | null;
+export declare function closePartialMarkdown(text: string): string;