@dev.fast/whiteboard 0.0.0-stage → 0.2.1-preview.20261005.98

package/dist/stored-document-migration-DHeMpLMb.js

@@ -0,0 +1,2671 @@
+import { f as isNumberValue, l as jsonValueSchema, m as isStringValue, n as isJsonObject } from "./src-X9phtB2j.js";
+import "./src-DnwdaQ2r.js";
+import { t as ReviewInputError } from "./input-error-OLgB_h31.js";
+import { z } from "zod";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { mathFromMarkdown } from "mdast-util-math";
+import { gfm } from "micromark-extension-gfm";
+//#region src/viewed-coverage.ts
+const coverageSchema = z.object({
+	base: z.array(z.tuple([z.number().int().nonnegative(), z.number().int().nonnegative()])),
+	head: z.array(z.tuple([z.number().int().nonnegative(), z.number().int().nonnegative()]))
+});
+const emptyCoverage = () => ({
+	base: [],
+	head: []
+});
+function unionIntervals(ranges) {
+	const result = [];
+	for (const [start, end] of [...ranges].sort((a, b) => a[0] - b[0])) {
+		if (end <= start) continue;
+		const last = result.at(-1);
+		if (last && start <= last[1]) last[1] = Math.max(last[1], end);
+		else result.push([start, end]);
+	}
+	return result;
+}
+function intersectIntervals(left, right) {
+	const result = [];
+	const a = unionIntervals(left), b = unionIntervals(right);
+	let i = 0, j = 0;
+	while (i < a.length && j < b.length) {
+		const start = Math.max(a[i][0], b[j][0]), end = Math.min(a[i][1], b[j][1]);
+		if (start < end) result.push([start, end]);
+		if (a[i][1] < b[j][1]) i++;
+		else j++;
+	}
+	return result;
+}
+function subtractIntervals(left, right) {
+	const result = [];
+	const removed = unionIntervals(right);
+	for (const [start, end] of unionIntervals(left)) {
+		let cursor = start;
+		for (const [from, to] of removed) {
+			if (to <= cursor) continue;
+			if (from >= end) break;
+			if (from > cursor) result.push([cursor, from]);
+			cursor = Math.min(end, Math.max(cursor, to));
+		}
+		if (cursor < end) result.push([cursor, end]);
+	}
+	return result;
+}
+function updateCoverage(current, scope, viewed) {
+	const apply = (side) => viewed ? unionIntervals([...current[side], ...scope[side]]) : subtractIntervals(current[side], scope[side]);
+	return {
+		base: apply("base"),
+		head: apply("head")
+	};
+}
+function scopedCoverage(file, sources) {
+	if (!sources) return file.changed;
+	const side = (side) => intersectIntervals(file.changed[side], sources.flatMap((source) => source.side === side && source.file === (side === "base" ? file.previousPath ?? file.path : file.path) ? [[source.fromLine - 1, source.toLine]] : []));
+	return {
+		base: side("base"),
+		head: side("head")
+	};
+}
+function coverageSources(file, coverage = file.viewed) {
+	return ["base", "head"].flatMap((side) => coverage[side].map(([start, end]) => ({
+		side,
+		file: side === "base" ? file.previousPath ?? file.path : file.path,
+		fromLine: start + 1,
+		toLine: end
+	})));
+}
+//#endregion
+//#region src/lens-selection.ts
+const ANCHOR_FORMS = "\"head/path#L10-L24\" or \"base/path#L7\" (one side, lines 10–24 or line 7); across sides, GitHub diff style \"diff/path#L84-R90\" (L = base line, R = head line)";
+const sameSideAnchor = /^(head|base)\/(.+)#L(\d+)(?:-L(\d+))?$/;
+const crossSideAnchor = /^diff\/(.+)#([LR])(\d+)-([LR])(\d+)$/;
+/** An anchor's selection, as markdown source links write it too (without
+* their `review-source:` scheme). Undefined when it isn't one. */
+function parseAnchor(text) {
+	const same = sameSideAnchor.exec(text);
+	if (same) {
+		const side = same[1] === "base" ? "base" : "head";
+		return {
+			file: same[2],
+			start: {
+				side,
+				line: Number(same[3])
+			},
+			end: {
+				side,
+				line: Number(same[4] ?? same[3])
+			}
+		};
+	}
+	const cross = crossSideAnchor.exec(text);
+	if (!cross || cross[2] === cross[4]) return void 0;
+	const side = (letter) => letter === "L" ? "base" : "head";
+	return {
+		file: cross[1],
+		start: {
+			side: side(cross[2]),
+			line: Number(cross[3])
+		},
+		end: {
+			side: side(cross[4]),
+			line: Number(cross[5])
+		}
+	};
+}
+/** Why a parsed selection can't be quoted, or undefined when it can. */
+function selectionProblem(selection) {
+	if (selection.start.line < 1 || selection.end.line < 1) return "Source lines count from 1.";
+	if (selection.start.side === selection.end.side && selection.start.line > selection.end.line) return "Source range ends before it starts.";
+	if (selection.pins && selection.pins.base === void 0 && (selection.start.side === "base" || selection.end.side === "base")) return "A base-side anchor needs base pins.";
+}
+const anchorSchema = z.string({ error: `Expected a source anchor: ${ANCHOR_FORMS}.` }).superRefine((text, context) => {
+	const selection = parseAnchor(text);
+	const problem = selection ? selectionProblem(selection) : `Use ${ANCHOR_FORMS} for a source anchor.`;
+	if (problem) context.addIssue({
+		code: "custom",
+		message: problem
+	});
+}).describe("head/path#L10-L24, base/path#L7, or diff/path#L84-R90");
+/** A stored anchor's selection, read at the pins of whatever holds it. */
+function anchorSelection(anchor, pins) {
+	const selection = parseAnchor(anchor);
+	if (!selection) throw new Error(`Not a source anchor: ${anchor}`);
+	return pins ? {
+		...selection,
+		pins
+	} : selection;
+}
+/** The anchor that writes a selection; its pins belong to its holder. */
+function formatAnchor(selection) {
+	const { file, start, end } = selection;
+	if (start.side === end.side) return start.line === end.line ? `${start.side}/${file}#L${start.line}` : `${start.side}/${file}#L${start.line}-L${end.line}`;
+	const letter = (side) => side === "base" ? "L" : "R";
+	return `diff/${file}#${letter(start.side)}${start.line}-${letter(end.side)}${end.line}`;
+}
+/** Pins-less selections keep the key they always had. */
+function selectionKey(source) {
+	return JSON.stringify([
+		source.file,
+		source.start.side,
+		source.start.line,
+		source.end.side,
+		source.end.line,
+		...source.pins ? [sourcePinsKey(source.pins)] : []
+	]);
+}
+function sourcePinsKey(pins) {
+	return `${pins.repositoryId}:${pins.base ?? ""}:${pins.head}`;
+}
+/** The comparison a source's pins name: head alone means head against
+* itself. Reference coverage is grouped under this key on both sides. */
+function comparisonKey(pins) {
+	return `${pins.repositoryId}:${pins.base ?? pins.head}:${pins.head}`;
+}
+/** Navigation/quote anchors only; never use these as lens coverage. */
+function sourceAnchors(source) {
+	return ["head", "base"].flatMap((side) => {
+		const lines = [source.start, source.end].flatMap((endpoint) => endpoint.side === side ? [endpoint.line] : []);
+		if (!lines.length) return [];
+		const anchor = {
+			file: source.file,
+			side,
+			fromLine: Math.min(...lines),
+			toLine: Math.max(...lines)
+		};
+		if (source.pins) anchor.pins = source.pins;
+		return [anchor];
+	});
+}
+/** Resolve once against the renderer's rows. No matching or context expansion. */
+function resolveDiffSelection(source, rows, file) {
+	const locate = (endpoint) => rows.findIndex((row) => row[endpoint.side === "base" ? 0 : 1] === endpoint.line - 1);
+	const start = locate(source.start);
+	const end = locate(source.end);
+	if (start < 0 || end < start) throw new Error("Lens endpoints do not identify an ordered interval in this diff.");
+	const selected = rows.slice(start, end + 1);
+	return ["base", "head"].flatMap((side, index) => unionIntervals(selected.flatMap((row) => row[index] === null ? [] : [[row[index], row[index] + 1]])).map(([from, to]) => ({
+		file: side === "base" ? file.previousPath ?? file.path : file.path,
+		side,
+		fromLine: from + 1,
+		toLine: to
+	})));
+}
+/**
+* Check whether a character code is a markdown line ending.
+*
+* A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
+* LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
+*
+* In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
+* RETURN (CR) are replaced by these virtual characters depending on whether
+* they occurred together.
+*
+* @param {Code} code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+function markdownLineEnding(code) {
+	return code !== null && code < -2;
+}
+/**
+* Check whether a character code is a markdown space.
+*
+* A **markdown space** is the concrete character U+0020 SPACE (SP) and the
+* virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
+*
+* In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
+* replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
+* SPACE (VS) characters, depending on the column at which the tab occurred.
+*
+* @param {Code} code
+*   Code.
+* @returns {boolean}
+*   Whether it matches.
+*/
+function markdownSpace(code) {
+	return code === -2 || code === -1 || code === 32;
+}
+//#endregion
+//#region ../../node_modules/micromark-factory-space/index.js
+/**
+* @import {Effects, State, TokenType} from 'micromark-util-types'
+*/
+/**
+* Parse spaces and tabs.
+*
+* There is no `nok` parameter:
+*
+* *   spaces in markdown are often optional, in which case this factory can be
+*     used and `ok` will be switched to whether spaces were found or not
+* *   one line ending or space can be detected with `markdownSpace(code)` right
+*     before using `factorySpace`
+*
+* ###### Examples
+*
+* Where `␉` represents a tab (plus how much it expands) and `␠` represents a
+* single space.
+*
+* ```markdown
+* ␉
+* ␠␠␠␠
+* ␉␠
+* ```
+*
+* @param {Effects} effects
+*   Context.
+* @param {State} ok
+*   State switched to when successful.
+* @param {TokenType} type
+*   Type (`' \t'`).
+* @param {number | undefined} [max=Infinity]
+*   Max (exclusive).
+* @returns {State}
+*   Start state.
+*/
+function factorySpace(effects, ok, type, max) {
+	const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+	let size = 0;
+	return start;
+	/** @type {State} */
+	function start(code) {
+		if (markdownSpace(code)) {
+			effects.enter(type);
+			return prefix(code);
+		}
+		return ok(code);
+	}
+	/** @type {State} */
+	function prefix(code) {
+		if (markdownSpace(code) && size++ < limit) {
+			effects.consume(code);
+			return prefix;
+		}
+		effects.exit(type);
+		return ok(code);
+	}
+}
+//#endregion
+//#region ../../node_modules/micromark-extension-math/lib/math-flow.js
+/**
+* @import {Construct, State, TokenizeContext, Tokenizer} from 'micromark-util-types'
+*/
+/** @type {Construct} */
+const mathFlow = {
+	tokenize: tokenizeMathFenced,
+	concrete: true,
+	name: "mathFlow"
+};
+/** @type {Construct} */
+const nonLazyContinuation = {
+	tokenize: tokenizeNonLazyContinuation,
+	partial: true
+};
+/**
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeMathFenced(effects, ok, nok) {
+	const self = this;
+	const tail = self.events[self.events.length - 1];
+	const initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
+	let sizeOpen = 0;
+	return start;
+	/**
+	* Start of math.
+	*
+	* ```markdown
+	* > | $$
+	*     ^
+	*   | \frac{1}{2}
+	*   | $$
+	* ```
+	*
+	* @type {State}
+	*/
+	function start(code) {
+		effects.enter("mathFlow");
+		effects.enter("mathFlowFence");
+		effects.enter("mathFlowFenceSequence");
+		return sequenceOpen(code);
+	}
+	/**
+	* In opening fence sequence.
+	*
+	* ```markdown
+	* > | $$
+	*      ^
+	*   | \frac{1}{2}
+	*   | $$
+	* ```
+	*
+	* @type {State}
+	*/
+	function sequenceOpen(code) {
+		if (code === 36) {
+			effects.consume(code);
+			sizeOpen++;
+			return sequenceOpen;
+		}
+		if (sizeOpen < 2) return nok(code);
+		effects.exit("mathFlowFenceSequence");
+		return factorySpace(effects, metaBefore, "whitespace")(code);
+	}
+	/**
+	* In opening fence, before meta.
+	*
+	* ```markdown
+	* > | $$asciimath
+	*       ^
+	*   | x < y
+	*   | $$
+	* ```
+	*
+	* @type {State}
+	*/
+	function metaBefore(code) {
+		if (code === null || markdownLineEnding(code)) return metaAfter(code);
+		effects.enter("mathFlowFenceMeta");
+		effects.enter("chunkString", { contentType: "string" });
+		return meta(code);
+	}
+	/**
+	* In meta.
+	*
+	* ```markdown
+	* > | $$asciimath
+	*        ^
+	*   | x < y
+	*   | $$
+	* ```
+	*
+	* @type {State}
+	*/
+	function meta(code) {
+		if (code === null || markdownLineEnding(code)) {
+			effects.exit("chunkString");
+			effects.exit("mathFlowFenceMeta");
+			return metaAfter(code);
+		}
+		if (code === 36) return nok(code);
+		effects.consume(code);
+		return meta;
+	}
+	/**
+	* After meta.
+	*
+	* ```markdown
+	* > | $$
+	*       ^
+	*   | \frac{1}{2}
+	*   | $$
+	* ```
+	*
+	* @type {State}
+	*/
+	function metaAfter(code) {
+		effects.exit("mathFlowFence");
+		if (self.interrupt) return ok(code);
+		return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+	}
+	/**
+	* After eol/eof in math, at a non-lazy closing fence or content.
+	*
+	* ```markdown
+	*   | $$
+	* > | \frac{1}{2}
+	*     ^
+	* > | $$
+	*     ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function beforeNonLazyContinuation(code) {
+		return effects.attempt({
+			tokenize: tokenizeClosingFence,
+			partial: true
+		}, after, contentStart)(code);
+	}
+	/**
+	* Before math content, definitely not before a closing fence.
+	*
+	* ```markdown
+	*   | $$
+	* > | \frac{1}{2}
+	*     ^
+	*   | $$
+	* ```
+	*
+	* @type {State}
+	*/
+	function contentStart(code) {
+		return (initialSize ? factorySpace(effects, beforeContentChunk, "linePrefix", initialSize + 1) : beforeContentChunk)(code);
+	}
+	/**
+	* Before math content, after optional prefix.
+	*
+	* ```markdown
+	*   | $$
+	* > | \frac{1}{2}
+	*     ^
+	*   | $$
+	* ```
+	*
+	* @type {State}
+	*/
+	function beforeContentChunk(code) {
+		if (code === null) return after(code);
+		if (markdownLineEnding(code)) return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+		effects.enter("mathFlowValue");
+		return contentChunk(code);
+	}
+	/**
+	* In math content.
+	*
+	* ```markdown
+	*   | $$
+	* > | \frac{1}{2}
+	*      ^
+	*   | $$
+	* ```
+	*
+	* @type {State}
+	*/
+	function contentChunk(code) {
+		if (code === null || markdownLineEnding(code)) {
+			effects.exit("mathFlowValue");
+			return beforeContentChunk(code);
+		}
+		effects.consume(code);
+		return contentChunk;
+	}
+	/**
+	* After math (ha!).
+	*
+	* ```markdown
+	*   | $$
+	*   | \frac{1}{2}
+	* > | $$
+	*       ^
+	* ```
+	*
+	* @type {State}
+	*/
+	function after(code) {
+		effects.exit("mathFlow");
+		return ok(code);
+	}
+	/** @type {Tokenizer} */
+	function tokenizeClosingFence(effects, ok, nok) {
+		let size = 0;
+		/**
+		* Before closing fence, at optional whitespace.
+		*
+		* ```markdown
+		*   | $$
+		*   | \frac{1}{2}
+		* > | $$
+		*     ^
+		* ```
+		*/
+		return factorySpace(effects, beforeSequenceClose, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
+		/**
+		* In closing fence, after optional whitespace, at sequence.
+		*
+		* ```markdown
+		*   | $$
+		*   | \frac{1}{2}
+		* > | $$
+		*     ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function beforeSequenceClose(code) {
+			effects.enter("mathFlowFence");
+			effects.enter("mathFlowFenceSequence");
+			return sequenceClose(code);
+		}
+		/**
+		* In closing fence sequence.
+		*
+		* ```markdown
+		*   | $$
+		*   | \frac{1}{2}
+		* > | $$
+		*      ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function sequenceClose(code) {
+			if (code === 36) {
+				size++;
+				effects.consume(code);
+				return sequenceClose;
+			}
+			if (size < sizeOpen) return nok(code);
+			effects.exit("mathFlowFenceSequence");
+			return factorySpace(effects, afterSequenceClose, "whitespace")(code);
+		}
+		/**
+		* After closing fence sequence, after optional whitespace.
+		*
+		* ```markdown
+		*   | $$
+		*   | \frac{1}{2}
+		* > | $$
+		*       ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function afterSequenceClose(code) {
+			if (code === null || markdownLineEnding(code)) {
+				effects.exit("mathFlowFence");
+				return ok(code);
+			}
+			return nok(code);
+		}
+	}
+}
+/**
+* @this {TokenizeContext}
+* @type {Tokenizer}
+*/
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+	const self = this;
+	return start;
+	/** @type {State} */
+	function start(code) {
+		if (code === null) return ok(code);
+		effects.enter("lineEnding");
+		effects.consume(code);
+		effects.exit("lineEnding");
+		return lineStart;
+	}
+	/** @type {State} */
+	function lineStart(code) {
+		return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+	}
+}
+//#endregion
+//#region ../../node_modules/micromark-extension-math/lib/math-text.js
+/**
+* @import {Options} from 'micromark-extension-math'
+* @import {Construct, Previous, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'
+*/
+/**
+* @param {Options | null | undefined} [options={}]
+*   Configuration (default: `{}`).
+* @returns {Construct}
+*   Construct.
+*/
+function mathText(options) {
+	let single = (options || {}).singleDollarTextMath;
+	if (single === null || single === void 0) single = true;
+	return {
+		tokenize: tokenizeMathText,
+		resolve: resolveMathText,
+		previous,
+		name: "mathText"
+	};
+	/**
+	* @this {TokenizeContext}
+	* @type {Tokenizer}
+	*/
+	function tokenizeMathText(effects, ok, nok) {
+		let sizeOpen = 0;
+		/** @type {number} */
+		let size;
+		/** @type {Token} */
+		let token;
+		return start;
+		/**
+		* Start of math (text).
+		*
+		* ```markdown
+		* > | $a$
+		*     ^
+		* > | \$a$
+		*      ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function start(code) {
+			effects.enter("mathText");
+			effects.enter("mathTextSequence");
+			return sequenceOpen(code);
+		}
+		/**
+		* In opening sequence.
+		*
+		* ```markdown
+		* > | $a$
+		*     ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function sequenceOpen(code) {
+			if (code === 36) {
+				effects.consume(code);
+				sizeOpen++;
+				return sequenceOpen;
+			}
+			if (sizeOpen < 2 && !single) return nok(code);
+			effects.exit("mathTextSequence");
+			return between(code);
+		}
+		/**
+		* Between something and something else.
+		*
+		* ```markdown
+		* > | $a$
+		*      ^^
+		* ```
+		*
+		* @type {State}
+		*/
+		function between(code) {
+			if (code === null) return nok(code);
+			if (code === 36) {
+				token = effects.enter("mathTextSequence");
+				size = 0;
+				return sequenceClose(code);
+			}
+			if (code === 32) {
+				effects.enter("space");
+				effects.consume(code);
+				effects.exit("space");
+				return between;
+			}
+			if (markdownLineEnding(code)) {
+				effects.enter("lineEnding");
+				effects.consume(code);
+				effects.exit("lineEnding");
+				return between;
+			}
+			effects.enter("mathTextData");
+			return data(code);
+		}
+		/**
+		* In data.
+		*
+		* ```markdown
+		* > | $a$
+		*      ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function data(code) {
+			if (code === null || code === 32 || code === 36 || markdownLineEnding(code)) {
+				effects.exit("mathTextData");
+				return between(code);
+			}
+			effects.consume(code);
+			return data;
+		}
+		/**
+		* In closing sequence.
+		*
+		* ```markdown
+		* > | `a`
+		*       ^
+		* ```
+		*
+		* @type {State}
+		*/
+		function sequenceClose(code) {
+			if (code === 36) {
+				effects.consume(code);
+				size++;
+				return sequenceClose;
+			}
+			if (size === sizeOpen) {
+				effects.exit("mathTextSequence");
+				effects.exit("mathText");
+				return ok(code);
+			}
+			token.type = "mathTextData";
+			return data(code);
+		}
+	}
+}
+/** @type {Resolver} */
+function resolveMathText(events) {
+	let tailExitIndex = events.length - 4;
+	let headEnterIndex = 3;
+	/** @type {number} */
+	let index;
+	/** @type {number | undefined} */
+	let enter;
+	if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === "space")) {
+		index = headEnterIndex;
+		while (++index < tailExitIndex) if (events[index][1].type === "mathTextData") {
+			events[tailExitIndex][1].type = "mathTextPadding";
+			events[headEnterIndex][1].type = "mathTextPadding";
+			headEnterIndex += 2;
+			tailExitIndex -= 2;
+			break;
+		}
+	}
+	index = headEnterIndex - 1;
+	tailExitIndex++;
+	while (++index <= tailExitIndex) if (enter === void 0) {
+		if (index !== tailExitIndex && events[index][1].type !== "lineEnding") enter = index;
+	} else if (index === tailExitIndex || events[index][1].type === "lineEnding") {
+		events[enter][1].type = "mathTextData";
+		if (index !== enter + 2) {
+			events[enter][1].end = events[index - 1][1].end;
+			events.splice(enter + 2, index - enter - 2);
+			tailExitIndex -= index - enter - 2;
+			index = enter + 2;
+		}
+		enter = void 0;
+	}
+	return events;
+}
+/**
+* @this {TokenizeContext}
+* @type {Previous}
+*/
+function previous(code) {
+	return code !== 36 || this.events[this.events.length - 1][1].type === "characterEscape";
+}
+//#endregion
+//#region ../../node_modules/micromark-extension-math/lib/syntax.js
+/**
+* @import {Options} from 'micromark-extension-math'
+* @import {Extension} from 'micromark-util-types'
+*/
+/**
+* Create an extension for `micromark` to enable math syntax.
+*
+* @param {Options | null | undefined} [options={}]
+*   Configuration (default: `{}`).
+* @returns {Extension}
+*   Extension for `micromark` that can be passed in `extensions`, to
+*   enable math syntax.
+*/
+function math(options) {
+	return {
+		flow: { [36]: mathFlow },
+		text: { [36]: mathText(options) }
+	};
+}
+//#endregion
+//#region src/markdown-latex-math.ts
+const backslash = 92;
+/**
+* `\(…\)` inline and `\[…\]` display math, read ahead of character escapes.
+* `\[` and `\]` count only on their own lines, so an escaped `\[1\]` stays prose.
+*/
+function latexMath() {
+	return { text: { [backslash]: [delimitedMath("latexInlineMath", 40, 41, false), delimitedMath("latexDisplayMath", 91, 93, true)] } };
+}
+/** Builds the nodes `$` and `$$` produce. */
+function latexMathFromMarkdown() {
+	return {
+		enter: {
+			latexInlineMath(token) {
+				this.enter({
+					type: "inlineMath",
+					value: ""
+				}, token);
+				this.buffer();
+			},
+			latexDisplayMath(token) {
+				this.enter({
+					type: "math",
+					value: ""
+				}, token);
+				this.buffer();
+			}
+		},
+		exit: {
+			latexInlineMath: exitMath,
+			latexDisplayMath: exitMath,
+			latexMathData(token) {
+				this.config.enter.data.call(this, token);
+				this.config.exit.data.call(this, token);
+			}
+		}
+	};
+}
+const exitMath = function(token) {
+	const value = this.resume().trim();
+	const node = this.stack.at(-1);
+	if (node?.type !== "inlineMath" && node?.type !== "math") throw new Error(`Expected a math node, found ${node?.type}.`);
+	node.value = value;
+	this.exit(token);
+};
+const lineEnding = (code) => code !== null && code < -2;
+const lineSpace = (code) => code === 32 || code === -2 || code === -1;
+function delimitedMath(type, open, close, ownLine) {
+	const closing = {
+		tokenize: tokenizeClosing,
+		partial: true
+	};
+	return {
+		name: type,
+		tokenize: tokenizeMath
+	};
+	function tokenizeMath(effects, ok, nok) {
+		let lineStart = false;
+		return start;
+		function start(code) {
+			effects.enter(type);
+			effects.enter("latexMathSequence");
+			effects.consume(code);
+			return opening;
+		}
+		function opening(code) {
+			if (code !== open) return nok(code);
+			effects.consume(code);
+			return ownLine ? openingLine : openingEnd;
+		}
+		function openingLine(code) {
+			if (lineSpace(code)) {
+				effects.consume(code);
+				return openingLine;
+			}
+			return lineEnding(code) ? openingEnd(code) : nok(code);
+		}
+		function openingEnd(code) {
+			effects.exit("latexMathSequence");
+			return between(code);
+		}
+		function between(code) {
+			if (code === null) return nok(code);
+			if (code === backslash) return ownLine && !lineStart ? escape(code) : effects.attempt(closing, after, escape)(code);
+			if (lineEnding(code)) {
+				effects.enter("lineEnding");
+				effects.consume(code);
+				effects.exit("lineEnding");
+				lineStart = true;
+				return between;
+			}
+			effects.enter("latexMathData");
+			return data(code);
+		}
+		function escape(code) {
+			effects.enter("latexMathData");
+			effects.consume(code);
+			lineStart = false;
+			return escaped;
+		}
+		function escaped(code) {
+			if (code === null || lineEnding(code)) {
+				effects.exit("latexMathData");
+				return between(code);
+			}
+			effects.consume(code);
+			return data;
+		}
+		function data(code) {
+			if (code === null || code === backslash || lineEnding(code)) {
+				effects.exit("latexMathData");
+				return between(code);
+			}
+			if (!lineSpace(code)) lineStart = false;
+			effects.consume(code);
+			return data;
+		}
+		function after(code) {
+			effects.exit(type);
+			return ok(code);
+		}
+	}
+	function tokenizeClosing(effects, ok, nok) {
+		return start;
+		function start(code) {
+			effects.enter("latexMathSequence");
+			effects.consume(code);
+			return closer;
+		}
+		function closer(code) {
+			if (code !== close) return nok(code);
+			effects.consume(code);
+			return ownLine ? closingLine : closingEnd;
+		}
+		function closingLine(code) {
+			if (lineSpace(code)) {
+				effects.consume(code);
+				return closingLine;
+			}
+			return code === null || lineEnding(code) ? closingEnd(code) : nok(code);
+		}
+		function closingEnd(code) {
+			effects.exit("latexMathSequence");
+			return ok(code);
+		}
+	}
+}
+//#endregion
+//#region src/markdown.ts
+function* markdownNodes(node) {
+	yield node;
+	for (const child of node.children ?? []) yield* markdownNodes(child);
+}
+/** The text a node carries, its own and every descendant's. */
+function markdownText(node) {
+	return [...markdownNodes(node)].map((child) => child.value ?? "").join("");
+}
+/** Shared syntax for submit-time source checks and safe Markdown rendering. */
+function parseMarkdown(source) {
+	const tree = fromMarkdown(source, {
+		extensions: [
+			gfm(),
+			math(),
+			latexMath()
+		],
+		mdastExtensions: [
+			gfmFromMarkdown(),
+			mathFromMarkdown(),
+			latexMathFromMarkdown()
+		]
+	});
+	for (const node of markdownNodes(tree)) {
+		const [only, ...others] = node.children ?? [];
+		if (node.type === "paragraph" && only?.type === "inlineMath" && others.length === 0 && source.startsWith("$$", only.position?.start.offset)) only.type = "math";
+	}
+	const definitions = /* @__PURE__ */ new Map();
+	for (const node of markdownNodes(tree)) if (node.type === "definition" && !definitions.has(node.identifier)) definitions.set(node.identifier, node);
+	for (const node of markdownNodes(tree)) {
+		if (node.type !== "linkReference") continue;
+		const definition = definitions.get(node.identifier);
+		if (definition) Object.assign(node, {
+			type: "link",
+			url: definition.url,
+			title: definition.title
+		});
+	}
+	return tree;
+}
+//#endregion
+//#region src/source.ts
+const label$2 = z.string().trim().min(1);
+/** The repository and commits one source reference was read from. A
+* reference without pins resolves against its document's pins; one with
+* pins names them itself, so a document can quote several repositories or
+* commits. `base` is only needed by references to the base side. */
+const sourcePinsSchema = z.strictObject({
+	repositoryId: label$2,
+	head: label$2,
+	base: label$2.optional()
+});
+/** Internal coordinates for reading one revision or storing resolved coverage.
+* Authored document attachments use DiffSelection instead. */
+const fileLineRangeSchema = z.strictObject({
+	side: z.enum(["base", "head"]).default("head"),
+	file: label$2,
+	fromLine: z.number().int().positive(),
+	toLine: z.number().int().positive(),
+	pins: sourcePinsSchema.optional()
+}).refine((s) => s.toLine >= s.fromLine, "Source range ends before it starts.").refine((s) => s.side === "head" || !s.pins || s.pins.base !== void 0, "A base-side source needs base pins.");
+/** Thrown by the pure checks; each boundary translates it for its clients. */
+var SourceRangeError = class extends Error {};
+/** Git and jj read committed objects, so a lexical check suffices: nothing
+* here follows a working-copy symlink. An empty string names the root. */
+function checkSourcePath(file) {
+	if (file.startsWith("/") || file.includes("\\") || file.split("/").some((part) => part === ".." || part === ".") || /[\u0000-\u001f]/.test(file)) throw new SourceRangeError("Source file must be a repository-relative path.");
+}
+/** The range's text from a whole file. A trailing newline is not a line. */
+function sliceSourceRange(text, range) {
+	const lines = text.split(/\r?\n/);
+	if (text.endsWith("\n")) lines.pop();
+	if (text === "" || range.toLine > lines.length) throw new SourceRangeError(`Source range ${range.file}:${range.fromLine}-${range.toLine} exceeds the pinned file (${lines.length} lines).`);
+	return lines.slice(range.fromLine - 1, range.toLine).join("\n");
+}
+/** A source shown as a peek must contain visible text; a whitespace-only
+* range is an authoring mistake. Prose links may point at blank lines, so
+* only peek-rendering references call this. */
+function requireVisibleSource(text, range) {
+	if (text.trim() === "") throw new SourceRangeError(`Source range ${range.file}:${range.fromLine}-${range.toLine} contains only whitespace.`);
+}
+//#endregion
+//#region src/review-api/blocks/definition.ts
+const text$1 = z.string();
+const label$1 = text$1.trim().min(1);
+const identity = { id: text$1.optional() };
+/** The repository and commits an element's anchors quote. A step, frame,
+* attachment or operation without them reads its block's; a block without
+* them reads its document's. */
+const elementPins = sourcePinsSchema.optional().describe("Pins for the anchors here; needed on the scratchpad.");
+/** The strict schema for a block's own fields; id and type are added here. */
+function defineBlock(type, props) {
+	return z.strictObject({
+		...identity,
+		type: z.literal(type),
+		...props
+	});
+}
+/** Shared by every check that resolves a component-local name. */
+function requireKey(record, name) {
+	if (!Object.hasOwn(record, name)) throw new ReviewInputError(`Unknown component name: ${name}`);
+}
+//#endregion
+//#region src/review-api/diff-lenses.ts
+/**
+* Lenses partition a review's change for the Diff view. They live on the
+* snapshot beside the document, are versioned with it, and are written one
+* at a time with the lens command; the document never holds them.
+*/
+const patternsSchema = z.array(label$1).min(1).max(1e3);
+const lensTargetSchema = z.discriminatedUnion("kind", [z.strictObject({
+	kind: z.literal("files"),
+	patterns: patternsSchema
+}), z.strictObject({
+	kind: z.literal("ranges"),
+	sources: z.array(anchorSchema).min(1).max(1e4)
+})]);
+const lensTargetsSchema = z.array(lensTargetSchema).min(1).max(1e3).describe("Select changed lines using repository-relative paths/globs or source ranges. Counts and viewed actions apply only to those lines.");
+const lensSchema = z.strictObject({
+	id: label$1,
+	title: label$1,
+	targets: lensTargetsSchema
+});
+/** One lens edit. Ids are host-assigned (`lens-N`); an update patches only
+* the fields it names. */
+const lensEditSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("insert"),
+		title: label$1,
+		targets: lensTargetsSchema,
+		afterId: label$1.optional().describe("The lens this one follows. Omitted appends.")
+	}),
+	z.strictObject({
+		type: z.literal("update"),
+		targetId: label$1,
+		title: label$1.optional(),
+		targets: lensTargetsSchema.optional()
+	}),
+	z.strictObject({
+		type: z.literal("remove"),
+		targetId: label$1
+	})
+]);
+/** Patterns are evaluated against the changed-file list, never the
+* filesystem, but must still read as repository-relative globs. */
+function checkLensTargets(targets) {
+	for (const pattern of targets.flatMap((target) => target.kind === "files" ? target.patterns : [])) if (pattern.startsWith("/") || pattern.split("/").includes("..") || pattern.includes("\\") || pattern.includes("\0")) throw new ReviewInputError("File lens patterns must be repository-relative paths or globs using forward slashes.");
+}
+/** Apply one edit in place and return the lens it landed on. */
+function applyLensEdit(lenses, edit, allocate) {
+	const index = (id) => {
+		const at = lenses.findIndex((lens) => lens.id === id);
+		if (at < 0) throw new ReviewInputError(`Lens ${id} does not exist.`);
+		return at;
+	};
+	if (edit.type === "insert") {
+		if (lenses.length >= 200) throw new ReviewInputError(`A review holds at most 200 lenses.`);
+		checkLensTargets(edit.targets);
+		const lens = {
+			id: allocate(),
+			title: edit.title,
+			targets: edit.targets
+		};
+		lenses.splice(edit.afterId === void 0 ? lenses.length : index(edit.afterId) + 1, 0, lens);
+		return lens;
+	}
+	const at = index(edit.targetId);
+	const lens = lenses[at];
+	if (edit.type === "remove") {
+		lenses.splice(at, 1);
+		return lens;
+	}
+	if (edit.title === void 0 && edit.targets === void 0) throw new ReviewInputError("A lens update names a title or targets.");
+	if (edit.targets) checkLensTargets(edit.targets);
+	const next = {
+		...lens,
+		...edit.title !== void 0 && { title: edit.title },
+		...edit.targets !== void 0 && { targets: edit.targets }
+	};
+	lenses[at] = next;
+	return next;
+}
+/** Every range a lens selects, with an id stable for its position. Lens
+* ranges read at the review's pins. */
+function lensSelections(lenses) {
+	return lenses.flatMap((lens) => lens.targets.flatMap((target, index) => target.kind === "ranges" ? target.sources.map((source, range) => ({
+		id: `${lens.id}:target:${index}:${range}`,
+		source: anchorSelection(source)
+	})) : []));
+}
+/** The lens id the Diff view gives changed lines no lens selects. */
+const UNCATEGORIZED_LENS_ID = "automatic-uncategorized";
+//#endregion
+//#region src/review-api/blocks/flow_diagram.ts
+/** Nodes and edges are the diagram's children: each is its own edit target,
+* so an agent can draw a diagram one unit at a time. Edges still name nodes
+* by their diagram-local key. */
+const flowNodeSchema = z.strictObject({
+	...identity,
+	type: z.literal("flow_node").default("flow_node"),
+	key: label$1,
+	label: label$1,
+	description: z.string().optional(),
+	kind: z.enum([
+		"process",
+		"decision",
+		"terminal"
+	]).optional(),
+	attachments: z.array(z.strictObject({
+		label: label$1,
+		sources: z.array(anchorSchema).min(1),
+		pins: elementPins
+	})).default([]).describe("Code evidence for this node. Omit for nodes no code backs, such as start or exit states.")
+});
+const flowEdgeSchema = z.strictObject({
+	...identity,
+	type: z.literal("flow_edge").default("flow_edge"),
+	from: label$1,
+	to: label$1,
+	label: z.string().optional(),
+	style: z.enum(["solid", "dashed"]).optional()
+});
+/** The edge a new node arrives with: `from` a node already drawn to this
+* one, or from this one `to` a node already drawn. Insert-time only; the
+* server stores it as an ordinary edge. */
+const flowLinkSchema = z.strictObject({
+	from: label$1.optional(),
+	to: label$1.optional(),
+	label: z.string().optional(),
+	style: z.enum(["solid", "dashed"]).optional()
+});
+const flowNodeInsertSchema = flowNodeSchema.extend({ link: flowLinkSchema.optional() });
+const flow_diagram = {
+	type: "flow_diagram",
+	schema: defineBlock("flow_diagram", {
+		title: label$1,
+		description: z.string().optional(),
+		direction: z.enum(["right", "down"]).optional(),
+		nodes: z.array(flowNodeSchema).min(1).max(100),
+		edges: z.array(flowEdgeSchema).max(300),
+		pins: elementPins
+	}),
+	check(block) {
+		const keys = new Set(block.nodes.map((node) => node.key));
+		if (keys.size !== block.nodes.length) throw new ReviewInputError("Flow node keys must be unique within the diagram.");
+		for (const edge of block.edges) if (!keys.has(edge.from) || !keys.has(edge.to)) throw new ReviewInputError(`Unknown flow endpoint: ${edge.from} → ${edge.to}`);
+	}
+};
+//#endregion
+//#region src/review-api/blocks/call_stack_diff.ts
+const frameSchema = z.strictObject({
+	...identity,
+	key: label$1.optional(),
+	parentKey: label$1.nullable().optional(),
+	callSite: anchorSchema.optional(),
+	source: anchorSchema,
+	contextSources: z.array(anchorSchema).max(1e3).optional().describe("Supporting code owned by this frame, such as field initializers. These ranges share the frame’s diff section and coverage; they do not create call edges."),
+	label: label$1.optional(),
+	pins: elementPins,
+	via: z.strictObject({
+		kind: z.enum([
+			"call",
+			"queue",
+			"callback",
+			"rpc"
+		]),
+		reason: label$1
+	}).optional()
+});
+const call_stack_diff = {
+	type: "call_stack_diff",
+	schema: defineBlock("call_stack_diff", {
+		title: label$1,
+		base: z.array(frameSchema),
+		head: z.array(frameSchema),
+		pins: elementPins
+	}),
+	check(block) {
+		for (const side of ["base", "head"]) {
+			const keys = block[side].flatMap((frame) => frame.key ? [frame.key] : []);
+			if (new Set(keys).size !== keys.length) throw new ReviewInputError(`Frame keys must be unique within ${side}.`);
+			for (const [index, frame] of block[side].entries()) if (frame.parentKey && !block[side].slice(0, index).some((parent) => parent.key === frame.parentKey)) throw new ReviewInputError("A frame parentKey must name an earlier frame on the same side.");
+		}
+	}
+};
+//#endregion
+//#region src/review-api/blocks/callout.ts
+const calloutSchema = defineBlock("callout", {
+	title: label$1.optional(),
+	tone: z.enum([
+		"info",
+		"warning",
+		"danger",
+		"success"
+	]).default("info"),
+	children: z.array(z.lazy(() => blockSchema))
+});
+const callout = {
+	type: "callout",
+	schema: calloutSchema
+};
+//#endregion
+//#region src/review-api/blocks/code.ts
+/** Shared with sequence steps. */
+const codeFields = {
+	language: text$1.default("text"),
+	text: text$1
+};
+const code = {
+	type: "code",
+	schema: defineBlock("code", {
+		...codeFields,
+		caption: text$1.optional()
+	})
+};
+//#endregion
+//#region src/review-api/blocks/code_peek.ts
+const code_peek = {
+	type: "code_peek",
+	schema: defineBlock("code_peek", {
+		source: anchorSchema,
+		pins: elementPins,
+		caption: text$1.optional()
+	})
+};
+//#endregion
+//#region src/review-api/blocks/database_lens.ts
+const fieldSchema = z.lazy(() => z.strictObject({
+	label: label$1,
+	dataType: label$1,
+	nullable: z.boolean().optional(),
+	primaryKey: z.boolean().optional(),
+	references: z.strictObject({
+		store: label$1,
+		collection: label$1,
+		field: label$1
+	}).optional(),
+	example: jsonValueSchema.optional(),
+	fields: z.record(text$1, fieldSchema).optional()
+}));
+const databaseActorSchema = z.union([label$1, z.strictObject({
+	label: label$1,
+	softwareMapPath: label$1.optional()
+})]);
+const storeSchema = z.strictObject({
+	label: label$1,
+	storage: z.enum(["relational", "document"]),
+	dataStoreKind: z.enum([
+		"database",
+		"objectStore",
+		"bucket",
+		"artifactStore",
+		"fileStore"
+	]).optional(),
+	softwareMapPath: label$1.optional(),
+	collections: z.record(text$1, z.strictObject({
+		label: label$1,
+		key: label$1.optional(),
+		fields: z.record(text$1, fieldSchema)
+	}))
+});
+const operationSchema = z.strictObject({
+	...identity,
+	kind: z.enum(["read", "write"]),
+	store: label$1,
+	collection: label$1,
+	field: label$1.optional(),
+	actor: label$1,
+	label: label$1,
+	detail: label$1.optional(),
+	source: anchorSchema,
+	pins: elementPins
+});
+const database_lens = {
+	type: "database_lens",
+	schema: defineBlock("database_lens", {
+		title: label$1,
+		actors: z.record(text$1, databaseActorSchema),
+		stores: z.record(text$1, storeSchema).refine((stores) => Object.keys(stores).length > 0, "A database lens needs at least one store."),
+		useCases: z.array(z.strictObject({
+			...identity,
+			label: label$1,
+			summary: text$1.optional(),
+			operations: z.array(operationSchema).min(1, "A use case needs at least one operation.")
+		})).min(1, "A database lens needs at least one use case."),
+		pins: elementPins
+	}),
+	check(block) {
+		const field = (store, collection, name) => {
+			requireKey(block.stores, store);
+			const collections = block.stores[store].collections;
+			requireKey(collections, collection);
+			if (name === void 0) return;
+			let fields = collections[collection].fields;
+			for (const part of name.split(".")) {
+				if (!fields) throw new ReviewInputError(`Unknown component name: ${name}`);
+				requireKey(fields, part);
+				fields = fields[part].fields;
+			}
+		};
+		for (const useCase of block.useCases) for (const op of useCase.operations) {
+			requireKey(block.actors, op.actor);
+			field(op.store, op.collection, op.field);
+		}
+		for (const store of Object.values(block.stores)) for (const collection of Object.values(store.collections)) for (const value of Object.values(collection.fields)) if (value.references) field(value.references.store, value.references.collection, value.references.field);
+	}
+};
+//#endregion
+//#region src/review-api/blocks/divider.ts
+const divider = {
+	type: "divider",
+	schema: defineBlock("divider", {})
+};
+//#endregion
+//#region src/review-api/blocks/image.ts
+const image = {
+	type: "image",
+	schema: defineBlock("image", {
+		assetId: label$1,
+		alt: label$1,
+		caption: text$1.optional()
+	})
+};
+//#endregion
+//#region src/review-api/blocks/markdown.ts
+const markdown = {
+	type: "markdown",
+	schema: defineBlock("markdown", {
+		markdown: text$1.describe("Safe Markdown. Repository file links must use [label](review-source:head/path#L10-L24) or review-source:base/path#L10-L24, with a repository-relative path and verified line numbers. Relative paths, absolute filesystem paths, and file/editor URLs are rejected. External links use https://, http://, or mailto:; document anchors use #heading."),
+		pins: sourcePinsSchema.optional().describe("Repository and commits this block's review-source links resolve against, instead of the document's pins.")
+	})
+};
+//#endregion
+//#region src/review-api/blocks/section.ts
+const sectionSchema = defineBlock("section", {
+	title: label$1,
+	defaultCollapsed: z.boolean().optional(),
+	children: z.array(z.lazy(() => blockSchema))
+});
+const section = {
+	type: "section",
+	schema: sectionSchema
+};
+//#endregion
+//#region src/review-api/blocks/sequence.ts
+const stepSchema = z.strictObject({
+	...identity,
+	type: z.literal("step").default("step"),
+	from: label$1,
+	to: label$1,
+	label: label$1,
+	style: z.enum([
+		"call",
+		"return",
+		"async"
+	]).default("call"),
+	source: anchorSchema.optional(),
+	pins: elementPins,
+	explanation: label$1.optional(),
+	code: z.strictObject(codeFields).optional()
+}).refine((s) => [
+	s.source,
+	s.explanation,
+	s.code
+].filter((v) => v !== void 0).length === 1, "A step needs exactly one of source, explanation, or code.");
+const sequence = {
+	type: "sequence",
+	schema: defineBlock("sequence", {
+		title: label$1,
+		actors: z.record(text$1, label$1),
+		steps: z.array(stepSchema),
+		pins: elementPins
+	}),
+	check(block) {
+		for (const step of block.steps) {
+			requireKey(block.actors, step.from);
+			requireKey(block.actors, step.to);
+		}
+	}
+};
+//#endregion
+//#region src/review-api/blocks/software_map.ts
+const software_map = {
+	type: "software_map",
+	schema: defineBlock("software_map", {
+		mapVersionId: label$1,
+		focusElementId: label$1.optional()
+	})
+};
+//#endregion
+//#region src/review-api/blocks/trace_quote.ts
+const trace_quote = {
+	type: "trace_quote",
+	schema: defineBlock("trace_quote", {
+		traceId: label$1,
+		eventId: label$1,
+		text: label$1
+	})
+};
+//#endregion
+//#region src/tutorial-conversation.ts
+const tutorialAuthoringConversationSchema = z.strictObject({
+	version: z.literal(1),
+	title: z.string().trim().min(1),
+	messages: z.array(z.strictObject({
+		role: z.enum(["user", "assistant"]),
+		body: z.string().trim().min(1)
+	})).min(2)
+});
+//#endregion
+//#region src/review-api/blocks/tutorial.ts
+const tutorialSchema = z.discriminatedUnion("kind", [
+	defineBlock("tutorial", { kind: z.literal("keymap") }),
+	defineBlock("tutorial", {
+		kind: z.literal("conversation"),
+		conversation: tutorialAuthoringConversationSchema
+	}),
+	defineBlock("tutorial", {
+		kind: z.literal("view"),
+		view: z.enum([
+			"review",
+			"commits",
+			"diff",
+			"map"
+		]),
+		label: z.string()
+	}),
+	defineBlock("tutorial", {
+		kind: z.literal("feature"),
+		feature: z.literal("softwareMap"),
+		children: z.array(z.lazy(() => blockSchema))
+	})
+]);
+const tutorial = {
+	type: "tutorial",
+	schema: tutorialSchema
+};
+//#endregion
+//#region src/review-api/blocks/index.ts
+/** Leaf kinds share one discriminated union so unknown types read as they always have. */
+const leafSchema = z.discriminatedUnion("type", [
+	markdown.schema,
+	code.schema,
+	divider.schema,
+	code_peek.schema,
+	sequence.schema,
+	call_stack_diff.schema,
+	database_lens.schema,
+	image.schema,
+	trace_quote.schema,
+	software_map.schema,
+	flow_diagram.schema
+]);
+/** Every block kind, keyed by type. A kind without a definition is a compile error. */
+const blocks = {
+	markdown,
+	code,
+	divider,
+	code_peek,
+	sequence,
+	call_stack_diff,
+	database_lens,
+	image,
+	trace_quote,
+	software_map,
+	flow_diagram,
+	section,
+	callout,
+	tutorial
+};
+/** Discriminated by type, so a malformed block reports its own kind's
+* issues rather than every kind's. */
+const blockSchema = z.lazy(() => z.discriminatedUnion("type", blockKindSchemas()));
+/** Each block kind's schema, for unions that add kinds of their own. Read
+* lazily: the container modules import this one. */
+const blockKindSchemas = () => [
+	leafSchema,
+	sectionSchema,
+	calloutSchema,
+	tutorialSchema
+];
+function checkBlock(type, block) {
+	blocks[type].check?.(block);
+}
+/** Relationships not expressible in a field schema. Sources/resources are checked by host providers. */
+function checkReferences(document) {
+	const visit = (block) => {
+		checkBlock(block.type, block);
+		if ("children" in block) block.children.forEach(visit);
+	};
+	document.forEach(visit);
+}
+//#endregion
+//#region src/review-api/document.ts
+const text = z.string();
+const label = text.trim().min(1);
+const pinsSchema = z.strictObject({
+	repositoryId: label,
+	base: label,
+	head: label
+});
+/** The pins one source reference reads at: its own when it names them,
+* otherwise its document's. A reference with base-less pins reads base at
+* head, like a commits target without a base. */
+function anchorPins(source, documentPins) {
+	if (source.pins) return {
+		repositoryId: source.pins.repositoryId,
+		base: source.pins.base ?? source.pins.head,
+		head: source.pins.head
+	};
+	if (!documentPins) throw new ReviewInputError("This source names no repository or commit, and the document has no pins.");
+	return documentPins;
+}
+/** Distinct explicit pins named by a document's references, for validation. */
+function explicitPins(references) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const { source } of references) if (source.pins) {
+		const pins = anchorPins(source, void 0);
+		seen.set(JSON.stringify(pins), pins);
+	}
+	return [...seen.values()];
+}
+const targets = (repository) => z.discriminatedUnion("kind", [z.strictObject({
+	kind: z.literal("worktree"),
+	...repository,
+	base: label.optional()
+}), z.strictObject({
+	kind: z.literal("commits"),
+	...repository,
+	head: label,
+	base: label.optional()
+})]);
+const reviewTargetSchema = targets({ repositoryId: label });
+/** How agents name a target: by the checkout's path, registered on acceptance. */
+const pathTargetSchema = targets({ repositoryPath: label });
+const unitTypes = /* @__PURE__ */ new Set([
+	"step",
+	"flow_node",
+	"flow_edge"
+]);
+const isUnit = (element) => unitTypes.has(element.type);
+/** Inline trace quotes keep paragraph/list layout while using retained resources. */
+function traceQuoteLink(href) {
+	const match = /^review-trace:([^#]+)#(.+)$/.exec(href);
+	return match ? {
+		traceId: decodeURIComponent(match[1]),
+		eventId: decodeURIComponent(match[2])
+	} : void 0;
+}
+function resourceReference(block) {
+	switch (block.type) {
+		case "image": return {
+			id: block.assetId,
+			kind: "image"
+		};
+		case "trace_quote": return {
+			id: block.traceId,
+			kind: "trace"
+		};
+		case "software_map": return {
+			id: block.mapVersionId,
+			kind: "map"
+		};
+		default: return;
+	}
+}
+function resourceReferences(document) {
+	return elements(document).flatMap((block) => {
+		if (block.type !== "markdown") return block.type === "image" || block.type === "trace_quote" || block.type === "software_map" ? [block] : [];
+		return [...markdownNodes(parseMarkdown(block.markdown))].flatMap((node) => {
+			if (node.type !== "link" || !node.url?.startsWith("review-trace:")) return [];
+			const quote = traceQuoteLink(node.url);
+			if (!quote) throw new ReviewInputError("Invalid trace quote link.");
+			return [{
+				type: "trace_quote",
+				...quote,
+				text: markdownText(node)
+			}];
+		});
+	});
+}
+/**
+* Source-bearing items share their owning element's stable identity.
+* `tolerant` skips malformed Markdown source links instead of rejecting, for
+* content that is already stored.
+*/
+function documentReferences(document, { tolerant = false } = {}) {
+	const reject = (message) => {
+		if (tolerant) return [];
+		throw new ReviewInputError(message);
+	};
+	const select = (anchor, pins) => {
+		const parsed = parseAnchor(anchor);
+		if (!parsed) return reject(`Not a source anchor: ${anchor}`);
+		const source = pins ? {
+			...parsed,
+			pins
+		} : parsed;
+		const problem = selectionProblem(source);
+		return problem ? reject(problem) : [source];
+	};
+	return elements(document).flatMap((element) => {
+		if (element.type === "markdown") return [...markdownNodes(parseMarkdown(element.markdown))].flatMap((node) => {
+			if (node.type !== "link") return [];
+			const href = node.url ?? "";
+			if (!/^review-source:/i.test(href)) {
+				if (href.startsWith("review-trace:")) return [];
+				if (/^(?:https?:\/\/|mailto:|#)/i.test(href)) return [];
+				return reject(`Unsupported Markdown link ${JSON.stringify(href)} in block ${element.id}. Use [label](review-source:head/path#L10-L24) or review-source:base/path#L10-L24 for repository files, or review-source:diff/path#L84-R90 across sides, with a repository-relative path and verified line numbers. External links must use https://, http://, or mailto:; document anchors use #heading.`);
+			}
+			let target;
+			try {
+				target = decodeURIComponent(href.slice(14));
+			} catch {
+				return reject("Invalid URL encoding in source link.");
+			}
+			const anchor = target.replace(/^(head|base|diff)\//i, (side) => side.toLowerCase());
+			if (!parseAnchor(anchor)) return reject("Use review-source:head/path#L10-L24 (or base, or diff/path#L84-R90 across sides) for a source link.");
+			return select(anchor, element.pins).map((source) => ({
+				id: `${element.id}:${node.url}`,
+				source
+			}));
+		});
+		if (element.type === "code_peek") return select(element.source, element.pins).map((source) => ({
+			id: element.id,
+			source,
+			label: element.caption,
+			peek: true
+		}));
+		if (element.type === "sequence") return element.steps.flatMap((step) => step.source ? select(step.source, step.pins ?? element.pins).map((source) => ({
+			id: step.id,
+			source,
+			label: step.label,
+			peek: true
+		})) : []);
+		if (element.type === "flow_diagram") return element.nodes.flatMap((node) => node.attachments.flatMap((attachment, index) => attachment.sources.flatMap((anchor, sourceIndex) => select(anchor, attachment.pins ?? element.pins).map((source) => ({
+			id: `${element.id}:${node.key}:${index}:${sourceIndex}`,
+			source,
+			label: attachment.label,
+			peek: true
+		})))));
+		if (element.type === "call_stack_diff") return [...element.base, ...element.head].flatMap((frame) => {
+			const pins = frame.pins ?? element.pins;
+			return [
+				...select(frame.source, pins).map((source) => ({
+					id: frame.id,
+					source,
+					label: frame.label,
+					peek: true
+				})),
+				...(frame.contextSources ?? []).flatMap((anchor, index) => select(anchor, pins).map((source) => ({
+					id: `${frame.id}:context:${index}`,
+					source
+				}))),
+				...frame.callSite ? select(frame.callSite, pins).map((source) => ({
+					id: `${frame.id}:call-site`,
+					source,
+					label: frame.label,
+					peek: true
+				})) : []
+			];
+		});
+		if (element.type === "database_lens") return element.useCases.flatMap((useCase) => useCase.operations.flatMap((operation) => select(operation.source, operation.pins ?? element.pins).map((source) => ({
+			id: operation.id,
+			source,
+			label: operation.label,
+			peek: true
+		}))));
+		return [];
+	});
+}
+/** All authored attachments, including code peeks, select the aligned diff. */
+const selectionReferences = documentReferences;
+/** Per-side read coordinates for endpoint validation and retained source quotes. */
+function sourceReferences(document, options = {}) {
+	return selectionReferences(document, options).flatMap((ref) => sourceAnchors(ref.source).map((source) => ({
+		...ref,
+		source
+	})));
+}
+/** Includes lenses and maps without inline ranges. */
+function hasCodeReferences(review) {
+	return Boolean(sourceReferences(review.document).length || review.lenses?.length || resourceReferences(review.document).some((block) => block.type === "software_map"));
+}
+const documentSchema = z.array(blockSchema);
+/** Discriminated by type, like blockSchema, so a malformed insert reports
+* its own kind's issues. */
+const contentSchema = z.discriminatedUnion("type", [
+	...blockKindSchemas(),
+	stepSchema,
+	flowNodeInsertSchema,
+	flowEdgeSchema
+]);
+const placement = {
+	parentId: label.optional(),
+	afterId: label.optional()
+};
+function edits(content, replacement, value) {
+	return z.discriminatedUnion("type", [
+		z.strictObject({
+			type: z.literal("insert"),
+			content,
+			...placement
+		}),
+		z.strictObject({
+			type: z.literal("replace"),
+			targetId: label,
+			content: replacement
+		}),
+		z.strictObject({
+			type: z.literal("update"),
+			targetId: label,
+			changes: z.record(text, value)
+		}),
+		z.strictObject({
+			type: z.literal("move"),
+			targetId: label,
+			...placement
+		}),
+		z.strictObject({
+			type: z.literal("remove"),
+			targetId: label
+		})
+	]);
+}
+const editSchema = edits(contentSchema, blockSchema, z.json());
+const writableBlockTypes = Object.keys(blocks).filter((type) => type !== "tutorial");
+const namedByType = (types) => z.looseObject({ type: z.enum(types) }).describe("Fields depend on type; see the tool description.");
+/** What agents are shown: content names only its type. The host parses
+* editSchema, reporting the named kind's issues. */
+const publishedEditSchema = edits(namedByType([
+	...writableBlockTypes,
+	"step",
+	"flow_node",
+	"flow_edge"
+]), namedByType(writableBlockTypes), z.unknown());
+/** The block an element belongs to: itself, or the diagram around a unit. */
+function enclosingBlock(document, id) {
+	for (const block of elements(document)) {
+		if (block.id === id) return {
+			block,
+			element: block
+		};
+		for (const list of childLists(block)) for (const element of list) if (element.id === id && isUnit(element)) return {
+			block,
+			element
+		};
+	}
+}
+/** Summarize an edit against the document it was applied to. A removed
+* element is found in the document before the edit; everything else after. */
+function summarizeEdit(edit, applied, before, after) {
+	const found = enclosingBlock(edit.type === "remove" ? before : after, applied.targetId);
+	if (!found?.block.id) return void 0;
+	const summary = {
+		type: edit.type,
+		targetId: applied.targetId,
+		blockId: found.block.id,
+		kind: found.element.type
+	};
+	if (isUnit(found.element)) summary.unit = found.element.type;
+	if (applied.linkId) summary.linkId = applied.linkId;
+	if (edit.type === "update") summary.fields = Object.keys(edit.changes);
+	if (edit.type === "insert" || edit.type === "replace") {
+		const units = drawOrder(found.element);
+		if (units.length) summary.units = units;
+	}
+	return summary;
+}
+/** The order a hand draws a diagram: a sequence step by step; a flow node by
+* node, each edge as soon as both of its ends are on the board. */
+function drawOrder(element) {
+	if (element.type === "sequence") return element.steps.flatMap((step) => step.id ? [step.id] : []);
+	if (element.type !== "flow_diagram") return [];
+	const order = [];
+	const drawn = /* @__PURE__ */ new Set();
+	const waiting = [...element.edges];
+	for (const node of element.nodes) {
+		if (node.id) order.push(node.id);
+		drawn.add(node.key);
+		for (let i = 0; i < waiting.length;) {
+			const edge = waiting[i];
+			if (drawn.has(edge.from) && drawn.has(edge.to)) {
+				if (edge.id) order.push(edge.id);
+				waiting.splice(i, 1);
+			} else i++;
+		}
+	}
+	return order;
+}
+/** The arrays an element's children live in, so an edit can splice the
+* real list. A flow diagram keeps its nodes and edges apart. */
+function childLists(element) {
+	if ("children" in element) return [element.children];
+	if (element.type === "sequence") return [element.steps];
+	if (element.type === "flow_diagram") return [element.nodes, element.edges];
+	return [];
+}
+function children(element) {
+	return childLists(element).flat();
+}
+function elements(document) {
+	return document.flatMap((element) => [element, ...elements(children(element))]);
+}
+const unitParent = {
+	step: "sequence",
+	flow_node: "flow_diagram",
+	flow_edge: "flow_diagram"
+};
+/** What to do instead of patching a field an update can't reach. */
+function patchRefusal(key, element) {
+	if (key === "base" || key === "head") return `A call stack's frames change only by replacing it: send {type:"replace", targetId:"${element.id}", content} with the whole call_stack_diff.`;
+	if (key === "nodes" || key === "edges" || key === "steps") return `Edit a diagram's ${key} one at a time by their own IDs (session_get lists them), or replace the diagram.`;
+	if (key === "children") return `Edit a ${element.type}'s children by their own IDs, or insert into it with parentId "${element.id}".`;
+	if (key === "id" || key === "type") return `A component's ${key} can't change; replace it instead.`;
+	return `Cannot patch ${key}; replace the ${element.type} instead.`;
+}
+const structural = /* @__PURE__ */ new Set([
+	"nodes",
+	"edges",
+	"id",
+	"type",
+	"children",
+	"steps",
+	"actors",
+	"stores",
+	"useCases",
+	"base",
+	"head"
+]);
+const idPrefix = (element) => element.type === "sequence" || element.type === "flow_diagram" ? "diagram" : element.type === "step" ? "step" : element.type === "flow_node" ? "node" : element.type === "flow_edge" ? "edge" : "block";
+/** Flow units saved before they had ids or types get both on the next
+* write, so a stored diagram can be drawn on unit by unit. */
+function adoptFlowUnits(document, allocate) {
+	for (const element of elements(document)) {
+		if (element.type === "flow_diagram") {
+			for (const node of element.nodes) node.type ??= "flow_node";
+			for (const edge of element.edges) edge.type ??= "flow_edge";
+		}
+		if (isUnit(element) && element.id === void 0) element.id = allocate(idPrefix(element));
+	}
+}
+/** Mutate a private candidate. Only the store owns allocation and commits. */
+/** Assign server ids to an element tree that arrives without any. */
+function assignFreshIds(element, allocate) {
+	if (element.id !== void 0) throw new ReviewInputError("IDs are assigned by the server.");
+	element.id = allocate(idPrefix(element));
+	for (const child of children(element)) assignFreshIds(child, allocate);
+	const assign = (item, prefix) => {
+		if (item.id !== void 0) throw new ReviewInputError("IDs are assigned by the server.");
+		item.id = allocate(prefix);
+	};
+	if (element.type === "call_stack_diff") for (const frame of [...element.base, ...element.head]) assign(frame, "frame");
+	if (element.type === "database_lens") for (const useCase of element.useCases) {
+		assign(useCase, "case");
+		for (const op of useCase.operations) assign(op, "operation");
+	}
+}
+function applyEdit(document, edit, allocate, options = {}) {
+	adoptFlowUnits(document, allocate);
+	const locate = (id) => {
+		const find = (siblings) => {
+			for (const element of siblings) {
+				if (element.id === id) return {
+					element,
+					siblings
+				};
+				for (const list of childLists(element)) {
+					const found = find(list);
+					if (found) return found;
+				}
+			}
+		};
+		const found = find(document);
+		if (!found) throw new ReviewInputError(`Target ${id} does not exist.`);
+		return found;
+	};
+	const fresh = (element) => assignFreshIds(element, allocate);
+	const place = (element, parentId, afterId, from) => {
+		const parent = parentId ? locate(parentId).element : void 0;
+		if (parent && elements([element]).includes(parent)) throw new ReviewInputError("Cannot move a block inside itself.");
+		if (!isUnit(element) && parent && !("children" in parent)) throw new ReviewInputError(`${parentId} is a ${parent.type}, which holds no components: insert into a section or callout, or at the top level.`);
+		if (isUnit(element) && parent?.type !== unitParent[element.type]) throw new ReviewInputError(`A ${element.type} belongs inside a ${unitParent[element.type]}.`);
+		const siblings = parent ? childLists(parent)[element.type === "flow_edge" ? 1 : 0] ?? document : document;
+		if (afterId === element.id) throw new ReviewInputError("An element cannot follow itself.");
+		if (afterId !== void 0 && !siblings.some((s) => s.id === afterId)) throw new ReviewInputError("afterId must identify a sibling.");
+		if (from) from.splice(from.indexOf(element), 1);
+		const index = afterId !== void 0 ? siblings.findIndex((s) => s.id === afterId) + 1 : !parent && !from && options.placement === "first" ? 0 : siblings.length;
+		siblings.splice(index, 0, element);
+	};
+	if (edit.type === "insert") {
+		if (edit.content.type === "flow_node" && edit.content.link) {
+			const { link, ...node } = edit.content;
+			if (link.from === void 0 === (link.to === void 0)) throw new ReviewInputError("A link names exactly one of from or to: the node already on the board.");
+			fresh(node);
+			place(node, edit.parentId, edit.afterId);
+			const edge = {
+				type: "flow_edge",
+				from: link.from ?? node.key,
+				to: link.to ?? node.key
+			};
+			if (link.label !== void 0) edge.label = link.label;
+			if (link.style !== void 0) edge.style = link.style;
+			fresh(edge);
+			place(edge, edit.parentId);
+			return {
+				targetId: node.id,
+				type: node.type,
+				linkId: edge.id
+			};
+		}
+		fresh(edit.content);
+		place(edit.content, edit.parentId, edit.afterId);
+		return written(edit.content);
+	}
+	const { element, siblings } = locate(edit.targetId);
+	const index = siblings.indexOf(element);
+	switch (edit.type) {
+		case "update": {
+			if (!Object.keys(edit.changes).length) throw new ReviewInputError("Supply at least one field to update.");
+			for (const key of Object.keys(edit.changes)) if (structural.has(key) || [
+				"__proto__",
+				"constructor",
+				"prototype"
+			].includes(key)) throw new ReviewInputError(patchRefusal(key, element));
+			if ("link" in edit.changes) throw new ReviewInputError("A link only comes with a new node; insert a flow_edge instead.");
+			const merged = Object.fromEntries(Object.entries({
+				...element,
+				...edit.changes
+			}).filter(([, value]) => value !== null));
+			siblings[index] = contentSchema.parse(merged);
+			break;
+		}
+		case "remove":
+			siblings.splice(index, 1);
+			if (element.type === "flow_node") {
+				const diagram = elements(document).find((candidate) => candidate.type === "flow_diagram" && candidate.nodes === siblings);
+				if (diagram?.type === "flow_diagram") diagram.edges = diagram.edges.filter((edge) => edge.from !== element.key && edge.to !== element.key);
+			}
+			break;
+		case "replace":
+			if (isUnit(element)) throw new ReviewInputError(`Patch the ${element.type} or replace its diagram.`);
+			fresh(edit.content);
+			edit.content.id = element.id;
+			siblings[index] = edit.content;
+			return written(edit.content);
+		case "move":
+			if (isUnit(element) && !childLists(locate(edit.parentId ?? "").element).includes(siblings)) throw new ReviewInputError(`Move a ${element.type} within its own diagram.`);
+			place(element, edit.parentId, edit.afterId, siblings);
+	}
+	return {
+		targetId: edit.targetId,
+		type: element.type
+	};
+}
+/** An inserted or replaced component and its first-level children: blocks
+* in a container, or a diagram's steps, or its nodes then its edges. */
+function written(element) {
+	const applied = {
+		targetId: element.id,
+		type: element.type
+	};
+	const list = children(element).map((child) => ({
+		id: child.id,
+		type: child.type
+	}));
+	if (list.length) applied.children = list;
+	return applied;
+}
+//#endregion
+//#region src/evidence.ts
+/** Quote matching shared by legacy publish and JSON accept: authors paste
+* transcript text with arbitrary line wrapping, so both sides compare on
+* whitespace-normalized text. */
+function normalizeQuoteText(text) {
+	return text.trim().replace(/\s+/g, " ");
+}
+function textIncludesQuote(text, quote) {
+	const normalizedQuote = normalizeQuoteText(quote);
+	return normalizedQuote !== "" && normalizeQuoteText(text).includes(normalizedQuote);
+}
+//#endregion
+//#region src/review-api/trace-schema.ts
+const traceSchema = z.strictObject({
+	label: z.string(),
+	events: z.array(z.strictObject({
+		id: z.string().min(1),
+		role: z.enum([
+			"user",
+			"assistant",
+			"tool"
+		]),
+		text: z.string()
+	})),
+	provenance: z.enum(["client_supplied", "legacy_import"]).optional()
+});
+//#endregion
+//#region src/software-map-model.ts
+const softwareElementTypeSchema = z.enum([
+	"person",
+	"softwareSystem",
+	"container",
+	"dataStore",
+	"component",
+	"codeElement"
+]);
+const softwareChangeStatusSchema = z.enum([
+	"added",
+	"removed",
+	"modified",
+	"unchanged"
+]);
+const softwareDataStoreKindSchema = z.enum([
+	"database",
+	"objectStore",
+	"bucket",
+	"artifactStore",
+	"fileStore"
+]);
+const softwareLineRangeSchema = z.strictObject({
+	fromLine: z.int().positive(),
+	toLine: z.int().positive()
+});
+const softwareSourceRangeSchema = softwareLineRangeSchema.extend({ file: z.string() });
+const softwareDataStoreForeignKeyRefDataSchema = z.union([z.string(), z.strictObject({
+	store: z.string().optional(),
+	table: z.string(),
+	field: z.string(),
+	label: z.string().optional(),
+	cardinality: z.enum(["one-to-one", "many-to-one"]).optional(),
+	onDelete: z.string().optional(),
+	onUpdate: z.string().optional()
+})]);
+const softwareDataStoreFieldDataSchema = z.lazy(() => z.record(z.string(), z.union([z.strictObject({
+	type: z.string(),
+	example: jsonValueSchema.optional(),
+	pk: z.boolean().optional(),
+	fk: softwareDataStoreForeignKeyRefDataSchema.optional(),
+	schema: softwareDataStoreFieldDataSchema.optional()
+}), softwareDataStoreFieldDataSchema])));
+const normalizedSoftwareDataStoreCollectionSchema = z.strictObject({
+	id: z.string(),
+	label: z.string(),
+	key: z.string().optional(),
+	schema: softwareDataStoreFieldDataSchema
+});
+const normalizedSoftwareDataStoreSchemaSchema = z.strictObject({
+	tables: z.record(z.string(), normalizedSoftwareDataStoreCollectionSchema),
+	documents: z.record(z.string(), normalizedSoftwareDataStoreCollectionSchema)
+});
+const normalizedSoftwareCoverageFileSchema = z.strictObject({
+	path: z.string(),
+	ranges: z.array(softwareLineRangeSchema)
+});
+const normalizedSoftwareCoverageSchema = z.strictObject({
+	files: z.array(normalizedSoftwareCoverageFileSchema),
+	globs: z.array(z.string())
+});
+const normalizedSoftwareElementSchema = z.strictObject({
+	type: softwareElementTypeSchema,
+	id: z.string(),
+	path: z.string(),
+	parentPath: z.string().optional(),
+	label: z.string(),
+	description: z.string().optional(),
+	changeStatus: softwareChangeStatusSchema.optional(),
+	coverage: normalizedSoftwareCoverageSchema.optional(),
+	external: z.boolean().optional(),
+	dataStoreKind: softwareDataStoreKindSchema.optional(),
+	dataStoreSchema: normalizedSoftwareDataStoreSchemaSchema.optional(),
+	sourceRanges: z.array(softwareSourceRangeSchema).optional(),
+	children: z.array(z.string())
+});
+const normalizedRelationshipFields = {
+	id: z.string(),
+	from: z.string(),
+	to: z.string(),
+	scopePath: z.string().optional(),
+	label: z.string().optional(),
+	description: z.string().optional()
+};
+const normalizedSoftwareRelationshipSchema = z.discriminatedUnion("kind", [z.strictObject({
+	...normalizedRelationshipFields,
+	kind: z.literal("call"),
+	nthCallSite: z.int().nonnegative()
+}), z.strictObject({
+	...normalizedRelationshipFields,
+	kind: z.literal("semantic"),
+	semanticKind: z.string().optional(),
+	sourceRanges: z.array(softwareLineRangeSchema).optional()
+})]);
+var SoftwareModelValidationError = class extends Error {
+	errors;
+	constructor(errors) {
+		super(`Invalid software model:\n- ${errors.join("\n- ")}`);
+		this.name = "SoftwareModelValidationError";
+		this.errors = errors;
+	}
+};
+function defineSoftwareMap(input) {
+	const errors = [];
+	const elements = [];
+	const elementsByPath = /* @__PURE__ */ new Map();
+	const pendingRelationships = [];
+	if ("views" in input) errors.push("Software model must not author views; SoftwareMap derives inline C4 projection from elements, relationships, and expansion state.");
+	flattenElements({
+		collection: input.people,
+		type: "person",
+		parentPath: void 0,
+		elements,
+		elementsByPath,
+		pendingRelationships,
+		errors
+	});
+	flattenElements({
+		collection: input.systems,
+		type: "softwareSystem",
+		parentPath: void 0,
+		elements,
+		elementsByPath,
+		pendingRelationships,
+		errors
+	});
+	for (const [index, relationship] of (input.relationships ?? []).entries()) pendingRelationships.push({
+		input: relationship,
+		index
+	});
+	const relationships = normalizeRelationships(pendingRelationships, elementsByPath, errors);
+	if (errors.length > 0) throw new SoftwareModelValidationError(errors);
+	const normalizedElements = elements.map((element) => Object.freeze(element));
+	return Object.freeze({
+		elements: normalizedElements,
+		elementsByPath: new Map(normalizedElements.map((element) => [element.path, element])),
+		relationships
+	});
+}
+function flattenElements({ collection, type, parentPath, elements, elementsByPath, pendingRelationships, errors }) {
+	if (!collection) return;
+	const siblings = entriesForCollection(collection);
+	const siblingIds = /* @__PURE__ */ new Set();
+	for (const [collectionKey, input] of siblings) {
+		const id = input.id ?? collectionKey;
+		const path = parentPath ? `${parentPath}.${id}` : id;
+		if (!id) {
+			errors.push(`Software ${type} under ${parentPath ?? "model"} has no id.`);
+			continue;
+		}
+		if (siblingIds.has(id)) {
+			errors.push(`Duplicate ${type} id "${id}" under ${parentPath ?? "model"}.`);
+			continue;
+		}
+		siblingIds.add(id);
+		if (elementsByPath.has(path)) {
+			errors.push(`Duplicate element path "${path}".`);
+			continue;
+		}
+		validateElementFields(type, path, input, errors);
+		const draft = {
+			type,
+			id,
+			path,
+			parentPath,
+			label: input.label ?? id,
+			description: input.description,
+			changeStatus: input.changeStatus,
+			coverage: normalizeCoverage(type, path, input.coverage, errors),
+			children: []
+		};
+		if (parentPath) elementsByPath.get(parentPath)?.children.push(path);
+		if (type === "softwareSystem") draft.external = input.external;
+		if (type === "dataStore") {
+			const dataStore = input;
+			draft.dataStoreKind = dataStore.kind ?? "database";
+			draft.dataStoreSchema = normalizeDataStoreSchema(path, dataStore, errors);
+		}
+		if (type === "codeElement") {
+			const codeElement = input;
+			draft.sourceRanges = codeElement.sourceRanges;
+			validateSourceRanges(codeElement.sourceRanges, `Code element "${path}" sourceRanges`, errors);
+		}
+		elements.push(draft);
+		elementsByPath.set(path, draft);
+		for (const [index, relationship] of (input.relationships ?? []).entries()) pendingRelationships.push({
+			input: relationship,
+			scopePath: path,
+			index
+		});
+		if (type === "softwareSystem") {
+			const system = input;
+			flattenElements({
+				collection: system.containers,
+				type: "container",
+				parentPath: path,
+				elements,
+				elementsByPath,
+				pendingRelationships,
+				errors
+			});
+			flattenElements({
+				collection: system.dataStores,
+				type: "dataStore",
+				parentPath: path,
+				elements,
+				elementsByPath,
+				pendingRelationships,
+				errors
+			});
+		}
+		if (type === "container" || type === "dataStore") flattenElements({
+			collection: input.components,
+			type: "component",
+			parentPath: path,
+			elements,
+			elementsByPath,
+			pendingRelationships,
+			errors
+		});
+		if (type === "component") flattenElements({
+			collection: input.codeElements,
+			type: "codeElement",
+			parentPath: path,
+			elements,
+			elementsByPath,
+			pendingRelationships,
+			errors
+		});
+	}
+}
+function entriesForCollection(collection) {
+	if (Array.isArray(collection)) return collection.map((item, index) => [item.id ?? String(index), item]);
+	return Object.entries(collection);
+}
+function validateElementFields(type, path, input, errors) {
+	if ("additions" in input || "deletions" in input) errors.push(`Element "${path}" must not author additions or deletions; diff counts are computed automatically.`);
+	if ("changeStatus" in input && input.changeStatus !== void 0 && input.changeStatus !== "added" && input.changeStatus !== "removed" && input.changeStatus !== "modified" && input.changeStatus !== "unchanged") errors.push(`Element "${path}" changeStatus must be one of "added", "removed", "modified", or "unchanged".`);
+	if (type === "dataStore" && "kind" in input && input.kind !== void 0 && input.kind !== "database" && input.kind !== "objectStore" && input.kind !== "bucket" && input.kind !== "artifactStore" && input.kind !== "fileStore") errors.push(`Data store "${path}" kind must be one of "database", "objectStore", "bucket", "artifactStore", or "fileStore".`);
+	if (type !== "dataStore" && "kind" in input) errors.push(`Only data stores may define kind: "${path}".`);
+	if (type !== "dataStore" && ("tables" in input || "documents" in input)) errors.push(`Only data stores may define tables or documents: "${path}".`);
+	if (type === "codeElement") {
+		if ("codeElements" in input) errors.push(`Code element "${path}" cannot contain code elements.`);
+	}
+	if ("coverage" in input && input.coverage !== void 0 && type !== "softwareSystem" && type !== "container" && type !== "dataStore" && type !== "component") errors.push(`Element "${path}" coverage may only be authored on systems, containers, data stores, or components.`);
+}
+function normalizeDataStoreSchema(path, dataStore, errors) {
+	validateDataStoreCollectionRecord(path, "tables", dataStore.tables, errors);
+	validateDataStoreCollectionRecord(path, "documents", dataStore.documents, errors);
+	const tables = normalizeDataStoreCollections(dataStore.tables);
+	const documents = normalizeDataStoreCollections(dataStore.documents);
+	if (Object.keys(tables).length === 0 && Object.keys(documents).length === 0) return;
+	return Object.freeze({
+		tables: Object.freeze(tables),
+		documents: Object.freeze(documents)
+	});
+}
+function validateDataStoreCollectionRecord(path, property, collections, errors) {
+	if (collections === void 0) return;
+	if (!isAuthoredObject(collections)) {
+		errors.push(`Data store "${path}" ${property} must be an object.`);
+		return;
+	}
+	for (const [collectionId, collection] of Object.entries(collections)) {
+		if (!collectionId.trim()) {
+			errors.push(`Data store "${path}" ${property} contains an empty id.`);
+			continue;
+		}
+		if (!isAuthoredObject(collection)) {
+			errors.push(`Data store "${path}" ${property}.${collectionId} must be an object.`);
+			continue;
+		}
+		validateDataStoreFieldSchema(collection.schema, `Data store "${path}" ${property}.${collectionId}.schema`, errors);
+	}
+}
+function normalizeDataStoreCollections(collections) {
+	return Object.fromEntries(Object.entries(collections ?? {}).map(([id, collection]) => [id, Object.freeze({
+		id,
+		label: collection.label ?? id,
+		key: collection.key,
+		schema: collection.schema
+	})]));
+}
+function validateDataStoreFieldSchema(schema, path, errors) {
+	if (!isAuthoredObject(schema)) {
+		errors.push(`${path} must be an object.`);
+		return;
+	}
+	for (const [field, value] of Object.entries(schema)) {
+		if (!field.trim()) {
+			errors.push(`${path} contains an empty field name.`);
+			continue;
+		}
+		const fieldPath = `${path}.${field}`;
+		if (!isAuthoredObject(value)) {
+			errors.push(`${fieldPath} must be a field object or nested schema.`);
+			continue;
+		}
+		if (isDataStoreFieldLeaf(value)) {
+			if (!value.type.trim()) errors.push(`${fieldPath}.type must not be empty.`);
+			if (value.schema) validateDataStoreFieldSchema(value.schema, `${fieldPath}.schema`, errors);
+			continue;
+		}
+		validateDataStoreFieldSchema(value, fieldPath, errors);
+	}
+}
+const DataStoreFieldLeafSchema = z.object({ type: z.string() });
+function isDataStoreFieldLeaf(value) {
+	return DataStoreFieldLeafSchema.safeParse(value).success;
+}
+function normalizeCoverage(type, path, coverage, errors) {
+	if (!coverage) return void 0;
+	if (type !== "softwareSystem" && type !== "container" && type !== "dataStore" && type !== "component") return;
+	const files = [];
+	const globs = [];
+	if (coverage.files !== void 0 && !Array.isArray(coverage.files)) errors.push(`Element "${path}" coverage.files must be an array.`);
+	for (const [index, file] of (coverage.files ?? []).entries()) {
+		if (isAuthoredString(file)) {
+			if (!file.trim()) {
+				errors.push(`Element "${path}" coverage.files[${index}] is empty.`);
+				continue;
+			}
+			files.push({
+				path: file,
+				ranges: []
+			});
+			continue;
+		}
+		if (!isAuthoredObject(file) || !file.path) {
+			errors.push(`Element "${path}" coverage.files[${index}] must be a file path or object with path.`);
+			continue;
+		}
+		files.push({
+			path: file.path,
+			ranges: file.ranges ?? []
+		});
+		validateLineRanges(file.ranges, `Element "${path}" coverage.files[${index}].ranges`, errors);
+	}
+	if (coverage.globs !== void 0 && !Array.isArray(coverage.globs)) errors.push(`Element "${path}" coverage.globs must be an array.`);
+	for (const [index, glob] of (coverage.globs ?? []).entries()) {
+		if (!isAuthoredString(glob) || !glob.trim()) {
+			errors.push(`Element "${path}" coverage.globs[${index}] is empty.`);
+			continue;
+		}
+		globs.push(glob);
+	}
+	if (files.length === 0 && globs.length === 0) return void 0;
+	return Object.freeze({
+		files: files.map((file) => Object.freeze(file)),
+		globs
+	});
+}
+function normalizeRelationships(pendingRelationships, elementsByPath, errors) {
+	const relationships = [];
+	for (const pending of pendingRelationships) {
+		const from = resolveEndpoint(pending.input.from, pending.scopePath, elementsByPath);
+		const to = resolveEndpoint(pending.input.to, pending.scopePath, elementsByPath);
+		const relationshipLabel = `relationships[${pending.index}] at ${pending.scopePath ?? "model"}`;
+		if (!from) errors.push(`${relationshipLabel}.from: "${pending.input.from}" does not match an element path or data store schema path. Use an existing full path or a name relative to this scope or its parent.`);
+		if (!to) errors.push(`${relationshipLabel}.to: "${pending.input.to}" does not match an element path or data store schema path. Use an existing full path or a name relative to this scope or its parent.`);
+		validateRelationshipFields(pending, errors);
+		if (!from || !to) continue;
+		const base = {
+			id: relationshipIdForPending(pending),
+			from,
+			to,
+			scopePath: pending.scopePath,
+			label: pending.input.label,
+			description: pending.input.description
+		};
+		if (pending.input.kind === "call") relationships.push(Object.freeze({
+			...base,
+			kind: "call",
+			nthCallSite: pending.input.nthCallSite ?? 0
+		}));
+		else relationships.push(Object.freeze({
+			...base,
+			kind: "semantic",
+			semanticKind: pending.input.semanticKind,
+			sourceRanges: pending.input.sourceRanges
+		}));
+	}
+	return relationships;
+}
+function validateRelationshipFields(pending, errors) {
+	if (pending.input.kind === "call") {
+		const nthCallSite = pending.input.nthCallSite ?? 0;
+		if (!Number.isInteger(nthCallSite) || nthCallSite < 0) errors.push(`Call relationship "${relationshipIdForPending(pending)}" must use a non-negative integer nthCallSite.`);
+		return;
+	}
+	validateLineRanges(pending.input.sourceRanges, `Semantic relationship "${relationshipIdForPending(pending)}" sourceRanges`, errors);
+}
+function resolveEndpoint(endpoint, scopePath, elementsByPath) {
+	const candidates = [];
+	if (scopePath && endpoint === ".") candidates.push(scopePath);
+	if (scopePath && endpoint !== ".") {
+		candidates.push(`${scopePath}.${endpoint}`);
+		const parentPath = parentPathFor(scopePath);
+		if (parentPath) candidates.push(`${parentPath}.${endpoint}`);
+	}
+	candidates.push(endpoint);
+	for (const candidate of candidates) {
+		if (elementsByPath.has(candidate)) return candidate;
+		const schemaEndpoint = resolveDataStoreSchemaEndpoint(candidate, elementsByPath);
+		if (schemaEndpoint) return schemaEndpoint;
+	}
+}
+function parseDataStoreSchemaEndpoint(endpoint, elementsByPath) {
+	for (const [dataStorePath, element] of elementsByPath) {
+		if (element.type !== "dataStore" || !element.dataStoreSchema) continue;
+		const parsed = parseDataStoreSchemaEndpointForStore(endpoint, dataStorePath, element.dataStoreSchema);
+		if (parsed) return parsed;
+	}
+}
+function resolveDataStoreSchemaEndpoint(endpoint, elementsByPath) {
+	return parseDataStoreSchemaEndpoint(endpoint, elementsByPath) ? endpoint : void 0;
+}
+function parseDataStoreSchemaEndpointForStore(endpoint, dataStorePath, schema) {
+	for (const collectionKind of ["tables", "documents"]) {
+		const prefix = `${dataStorePath}.${collectionKind}.`;
+		if (!endpoint.startsWith(prefix)) continue;
+		const parts = endpoint.slice(prefix.length).split(".").filter(Boolean);
+		if (parts.length === 0) continue;
+		const [collectionId, ...fieldPath] = parts;
+		const collection = schema[collectionKind][collectionId];
+		if (!collection) continue;
+		if (fieldPath.length > 0 && !dataStoreFieldPathExists(collection.schema, fieldPath)) continue;
+		return {
+			dataStorePath,
+			collectionKind,
+			collectionId,
+			fieldPath
+		};
+	}
+}
+function dataStoreFieldPathExists(schema, fieldPath) {
+	let current = schema;
+	for (const [index, part] of fieldPath.entries()) {
+		const next = current[part];
+		if (!next) return false;
+		if (index === fieldPath.length - 1) return true;
+		if (isDataStoreFieldLeaf(next)) {
+			if (!next.schema) return false;
+			current = next.schema;
+		} else current = next;
+	}
+	return fieldPath.length === 0;
+}
+function validateSourceRanges(sourceRanges, label, errors) {
+	for (const [index, range] of (sourceRanges ?? []).entries()) {
+		if (!isAuthoredString(range.file) || range.file.trim().length === 0) errors.push(`${label}[${index}].file must be a non-empty string.`);
+		if (!Number.isInteger(range.fromLine) || !Number.isInteger(range.toLine) || range.fromLine < 1 || range.toLine < range.fromLine) errors.push(`${label}[${index}] must use positive inclusive line numbers with fromLine <= toLine.`);
+	}
+}
+function validateLineRanges(ranges, label, errors) {
+	for (const [index, range] of (ranges ?? []).entries()) if (!Number.isInteger(range.fromLine) || !Number.isInteger(range.toLine) || range.fromLine < 1 || range.toLine < range.fromLine) errors.push(`${label}[${index}] must use positive inclusive line numbers with fromLine <= toLine.`);
+}
+function relationshipIdForPending(pending) {
+	return `${pending.scopePath ?? "model"}.relationship.${pending.index}`;
+}
+function parentPathFor(path) {
+	const lastDot = path.lastIndexOf(".");
+	if (lastDot === -1) return void 0;
+	return path.slice(0, lastDot);
+}
+const AuthoredObjectSchema = z.object({});
+const AuthoredStringSchema = z.string();
+function isAuthoredObject(value) {
+	return AuthoredObjectSchema.safeParse(value).success;
+}
+function isAuthoredString(value) {
+	return AuthoredStringSchema.safeParse(value).success;
+}
+z.strictObject({
+	elements: z.array(normalizedSoftwareElementSchema),
+	relationships: z.array(normalizedSoftwareRelationshipSchema)
+}).extend({ format: z.literal("software-map/1") });
+//#endregion
+//#region src/diff-selection-migration.ts
+/** Upgrade retained document attachments at the read/import boundary. New edits
+* use the strict DiffSelection schema and never accept these retired forms. */
+function migrateDiffSelections(input) {
+	return migrateNode(jsonValueSchema.parse(input));
+}
+function migrateNode(value, attachment = false) {
+	if (Array.isArray(value)) return value.map((child) => migrateNode(child, attachment));
+	if (!isJsonObject(value)) return value;
+	if (attachment && isStringValue(value.file)) {
+		if (isNumberValue(value.fromLine) && isNumberValue(value.toLine)) {
+			const side = value.side ?? value.graph ?? "head";
+			return {
+				file: value.file,
+				start: {
+					side,
+					line: value.fromLine
+				},
+				end: {
+					side,
+					line: value.toLine
+				}
+			};
+		}
+		if (isJsonObject(value.start) && isJsonObject(value.end) && "baseLine" in value.start) {
+			const endpoint = (row) => isNumberValue(row.headLine) ? {
+				side: "head",
+				line: row.headLine
+			} : {
+				side: "base",
+				line: row.baseLine
+			};
+			return {
+				file: value.file,
+				start: endpoint(value.start),
+				end: endpoint(value.end)
+			};
+		}
+	}
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, migrateNode(child, [
+		"source",
+		"peek",
+		"sources",
+		"contextSources",
+		"callSite"
+	].includes(key))]));
+}
+//#endregion
+//#region src/stored-document-migration.ts
+/** Upgrade a saved or shared Review document to the current block schema at the
+* read/import boundary. New edits use the strict schema and never accept these
+* retired forms. */
+function migrateStoredDocument(input) {
+	return anchorStrings(dropSectionStatus(migrateDiffSelections(input)));
+}
+/** Lenses saved before ranges were anchor strings. */
+function migrateStoredLenses(input) {
+	return anchorStrings(migrateDiffSelections(input));
+}
+const ANCHOR_KEYS = [
+	"source",
+	"sources",
+	"callSite",
+	"contextSources"
+];
+const selectionObjectSchema = z.object({
+	file: z.string(),
+	start: z.object({
+		side: z.enum(["base", "head"]),
+		line: z.number()
+	}),
+	end: z.object({
+		side: z.enum(["base", "head"]),
+		line: z.number()
+	}),
+	pins: z.json().optional()
+});
+/**
+* Anchors were once selection objects, each with its own pins. They are now
+* strings, and pins sit on whatever holds them (a code peek, step, frame,
+* attachment or operation) when they differ from the enclosing block's. No
+* stored element mixed pins across its anchors. Lens ranges read at the
+* review's pins and never carried others.
+*/
+function anchorStrings(value, blockPins) {
+	if (Array.isArray(value)) return value.map((child) => anchorStrings(child, blockPins));
+	if (!isJsonObject(value)) return value;
+	const inherited = value.pins ?? blockPins;
+	let pins;
+	const convert = (anchor) => {
+		const selection = selectionObjectSchema.safeParse(anchor);
+		if (!selection.success) return anchor;
+		const { pins: own, ...anchorAt } = selection.data;
+		if (own) pins = own;
+		return formatAnchor(anchorAt);
+	};
+	const migrated = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, ANCHOR_KEYS.includes(key) ? Array.isArray(child) ? child.map(convert) : convert(child) : anchorStrings(child, inherited)]));
+	if (pins !== void 0 && value.kind !== "ranges" && JSON.stringify(pins) !== JSON.stringify(blockPins)) migrated.pins = pins;
+	return migrated;
+}
+/** Sections once carried an optional `status` (pending, in_progress or
+* complete). The authoring lease is now the only signal of work in progress,
+* so versions saved before it was retired drop the field when read. */
+function dropSectionStatus(value) {
+	if (Array.isArray(value)) return value.map(dropSectionStatus);
+	if (!isJsonObject(value)) return value;
+	return Object.fromEntries(Object.entries(value).filter(([key]) => !(value.type === "section" && key === "status")).map(([key, child]) => [key, dropSectionStatus(child)]));
+}
+/** A saved `file_lens` block, from before lenses left the document. */
+const legacyFileLensSchema = z.object({
+	type: z.literal("file_lens"),
+	id: label$1,
+	title: label$1,
+	targets: lensTargetsSchema.optional(),
+	patterns: z.array(label$1).min(1).optional()
+});
+/** Versions saved before lenses moved out of the document hold them as
+* `file_lens` blocks, possibly inside sections. Lift them out of a migrated
+* document, in document order, keeping each id, title and scope (legacy
+* `patterns` become a files target). Viewed state is per file, so it needs
+* no rewrite. */
+function liftFileLenses(document) {
+	const lenses = [];
+	const visit = (value) => {
+		if (Array.isArray(value)) return value.flatMap((item) => {
+			if (!isJsonObject(item) || item.type !== "file_lens") return [visit(item)];
+			const legacy = legacyFileLensSchema.safeParse(item);
+			if (legacy.success && (legacy.data.targets ?? legacy.data.patterns)) lenses.push({
+				id: legacy.data.id,
+				title: legacy.data.title,
+				targets: legacy.data.targets ?? [{
+					kind: "files",
+					patterns: legacy.data.patterns
+				}]
+			});
+			return [];
+		});
+		if (!isJsonObject(value)) return value;
+		return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, visit(child)]));
+	};
+	return {
+		document: visit(document),
+		lenses
+	};
+}
+//#endregion
+export { unionIntervals as $, applyLensEdit as A, parseMarkdown as B, resourceReferences as C, summarizeEdit as D, sourceReferences as E, checkSourcePath as F, selectionKey as G, comparisonKey as H, fileLineRangeSchema as I, coverageSources as J, sourceAnchors as K, requireVisibleSource as L, lensSchema as M, lensSelections as N, checkReferences as O, SourceRangeError as P, subtractIntervals as Q, sliceSourceRange as R, resourceReference as S, selectionReferences as T, formatAnchor as U, anchorSelection as V, resolveDiffSelection as W, intersectIntervals as X, emptyCoverage as Y, scopedCoverage as Z, hasCodeReferences as _, defineSoftwareMap as a, pinsSchema as b, traceSchema as c, applyEdit as d, updateCoverage as et, assignFreshIds as f, explicitPins as g, elements as h, SoftwareModelValidationError as i, lensEditSchema as j, UNCATEGORIZED_LENS_ID as k, textIncludesQuote as l, editSchema as m, migrateStoredDocument as n, normalizedSoftwareElementSchema as o, documentSchema as p, coverageSchema as q, migrateStoredLenses as r, normalizedSoftwareRelationshipSchema as s, liftFileLenses as t, anchorPins as u, isUnit as v, reviewTargetSchema as w, publishedEditSchema as x, pathTargetSchema as y, markdownNodes as z };