@ai-gui/core 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -126,7 +126,10 @@ function repair(str) {
 				break;
 		}
 	}
-	if (inString && !stringIsKey) return [closeContainers(str + "\"", stack)];
+	if (inString && !stringIsKey) {
+		const body = escaped ? str.slice(0, -1) : str;
+		return [closeContainers(body + "\"", stack)];
+	}
 	const fallback = lastGoodEnd === -1 ? [] : [closeContainers(str.slice(0, lastGoodEnd), stack)];
 	if (inLiteral) return [closeContainers(str, stack), ...fallback];
 	return fallback;
@@ -150,20 +153,68 @@ function closeContainers(body, stack) {
 */
 function repairMarkdown(buffer) {
 	let out = buffer;
-	const fenceCount = (out.match(/^```/gm) ?? []).length;
-	if (fenceCount % 2 === 1) {
+	const openFence = findOpenFence(out);
+	if (openFence) {
 		if (!out.endsWith("\n")) out += "\n";
-		out += "```";
+		out += openFence;
 		return out;
 	}
-	const tick = (out.match(/`/g) ?? []).length;
-	if (tick % 2 === 1) out += "`";
-	const bold = (out.match(/\*\*/g) ?? []).length;
-	if (bold % 2 === 1) out += "**";
-	const strike = (out.match(/~~/g) ?? []).length;
+	const inline = findOpenInlineCode(out);
+	const visible = inline ? out.slice(0, inline.index) : out;
+	const bold = countUnescaped(visible, "**");
+	const strike = countUnescaped(visible, "~~");
+	if (inline) out += inline.marker;
 	if (strike % 2 === 1) out += "~~";
+	if (bold % 2 === 1) out += "**";
 	return out;
 }
+function findOpenFence(buffer) {
+	let open;
+	for (const line of buffer.split(/\r\n|\r|\n/)) {
+		const match = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+		if (!match) continue;
+		const marker = match[1];
+		if (!open) open = {
+			char: marker[0],
+			length: marker.length,
+			marker
+		};
+		else if (marker[0] === open.char && marker.length >= open.length && match[2].trim() === "") open = void 0;
+	}
+	return open?.marker;
+}
+function findOpenInlineCode(buffer) {
+	let open;
+	for (let i = 0; i < buffer.length;) {
+		if (buffer[i] !== "`" || isEscaped(buffer, i)) {
+			i++;
+			continue;
+		}
+		let end = i + 1;
+		while (buffer[end] === "`") end++;
+		const marker = buffer.slice(i, end);
+		if (!open) open = {
+			index: i,
+			marker
+		};
+		else if (open.marker === marker) open = void 0;
+		i = end;
+	}
+	return open;
+}
+function countUnescaped(buffer, marker) {
+	let count = 0;
+	for (let i = 0; i <= buffer.length - marker.length; i++) if (buffer.startsWith(marker, i) && !isEscaped(buffer, i)) {
+		count++;
+		i += marker.length - 1;
+	}
+	return count;
+}
+function isEscaped(buffer, index) {
+	let slashes = 0;
+	for (let i = index - 1; i >= 0 && buffer[i] === "\\"; i--) slashes++;
+	return slashes % 2 === 1;
+}
 
 //#endregion
 //#region src/sanitizer.ts
@@ -179,11 +230,270 @@ function escapeHtml(html) {
 * fall back to escaping the HTML-significant characters. This never emits raw
 * markup and never throws.
 */
-function sanitizeHtml(html) {
-	if (typeof window === "undefined") return escapeHtml(html);
+function sanitizeHtml(html, options = {}) {
+	if (options.sanitizer) return options.sanitizer(html);
+	if (typeof window === "undefined") {
+		if (options.ssr === "throw") throw new Error("sanitizeHtml requires a DOM or an injected sanitizer");
+		return escapeHtml(html);
+	}
 	return dompurify.default.sanitize(html);
 }
 
+//#endregion
+//#region src/debug-events.ts
+const DEFAULT_MAX_STRING_LENGTH = 2048;
+const DEFAULT_MAX_DEPTH = 8;
+const DEFAULT_MAX_NODES = 1e3;
+const SENSITIVE_KEY_PARTS = [
+	"authorization",
+	"auth",
+	"accesstoken",
+	"refreshtoken",
+	"clientsecret",
+	"credentials",
+	"cookie",
+	"setcookie",
+	"proxyauthorization",
+	"password",
+	"passwd",
+	"apikey",
+	"secret",
+	"token"
+];
+var DebugEmitter = class {
+	enabled;
+	source;
+	limits;
+	listeners = new Set();
+	sequence = 0;
+	constructor(source, options = {}) {
+		this.source = source;
+		this.enabled = options.debug === true;
+		this.limits = {
+			maxStringLength: positiveInteger(options.maxStringLength, DEFAULT_MAX_STRING_LENGTH, "maxStringLength"),
+			maxDepth: positiveInteger(options.maxDepth, DEFAULT_MAX_DEPTH, "maxDepth"),
+			maxNodes: positiveInteger(options.maxNodes, DEFAULT_MAX_NODES, "maxNodes"),
+			redact: options.redact
+		};
+		if (this.enabled && options.onDebugEvent) this.listeners.add(options.onDebugEvent);
+	}
+	get active() {
+		return this.enabled && this.listeners.size > 0;
+	}
+	get available() {
+		return this.enabled;
+	}
+	subscribe(listener) {
+		if (!this.enabled) return () => {};
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	emit(type, data = {}) {
+		if (!this.active) return;
+		const event = Object.freeze({
+			type,
+			source: this.source,
+			timestamp: Date.now(),
+			sequence: ++this.sequence,
+			data: safeDebugValue(data, this.limits)
+		});
+		for (const listener of this.listeners) try {
+			listener(event);
+		} catch {}
+	}
+};
+function safeDebugValue(value, options = {}) {
+	const maxStringLength = positiveInteger(options.maxStringLength, DEFAULT_MAX_STRING_LENGTH, "maxStringLength");
+	const maxDepth = positiveInteger(options.maxDepth, DEFAULT_MAX_DEPTH, "maxDepth");
+	const maxNodes = positiveInteger(options.maxNodes, DEFAULT_MAX_NODES, "maxNodes");
+	const seen = new WeakSet();
+	let nodes = 0;
+	const visit = (input, key = "", path = [], depth = 0) => {
+		if (++nodes > maxNodes) return "[MAX_NODES]";
+		if (isSensitiveKey(key) || options.redact?.({
+			key,
+			path,
+			value: input
+		})) return "[REDACTED]";
+		if (typeof input === "string") return limitString(redactText(input), maxStringLength);
+		if (input === null || typeof input === "boolean") return input;
+		if (typeof input === "number") return Number.isFinite(input) ? input : String(input);
+		if (typeof input === "bigint" || typeof input === "symbol" || typeof input === "function" || typeof input === "undefined") return String(input);
+		if (input instanceof Error) return {
+			name: limitString(input.name || "Error", maxStringLength),
+			message: limitString(redactText(input.message), maxStringLength)
+		};
+		if (depth >= maxDepth) return "[MAX_DEPTH]";
+		if (seen.has(input)) return "[CIRCULAR]";
+		seen.add(input);
+		try {
+			if (Array.isArray(input)) return input.map((item, index) => visit(item, "", [...path, index], depth + 1));
+			const output = {};
+			for (const [childKey, child] of Object.entries(input)) output[childKey] = visit(child, childKey, [...path, childKey], depth + 1);
+			return output;
+		} finally {
+			seen.delete(input);
+		}
+	};
+	return visit(value);
+}
+function isSensitiveKey(key) {
+	const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+	return normalized !== "" && SENSITIVE_KEY_PARTS.some((part) => normalized.includes(part));
+}
+function redactText(value) {
+	return value.replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [REDACTED]").replace(/([?&](?:access[_-]?token|refresh[_-]?token|client[_-]?secret|api[_-]?key|password|passwd|token|secret)=)[^&#\s]*/gi, "$1[REDACTED]").replace(/\b((?:access[_-]?token|refresh[_-]?token|client[_-]?secret|api[_-]?key|password|passwd|token|secret)\s*[:=]\s*)[^\s,;]+/gi, "$1[REDACTED]");
+}
+function limitString(value, maxLength) {
+	if (value.includes("[REDACTED]") && maxLength < 20) return `[REDACTED][TRUNCATED length=${value.length}]`;
+	return value.length > maxLength ? `${value.slice(0, maxLength)}[TRUNCATED length=${value.length}]` : value;
+}
+function positiveInteger(value, fallback, name) {
+	if (value === void 0) return fallback;
+	if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${name} must be a positive integer`);
+	return value;
+}
+
+//#endregion
+//#region src/json-schema.ts
+/** Small, dependency-free validator for the JSON Schema subset used by AIGUI definitions. */
+function validateJSONSchema(schema, value) {
+	const issues = [];
+	validate(schema, value, "$", issues);
+	return {
+		valid: issues.length === 0,
+		issues
+	};
+}
+function validate(schema, value, path, issues) {
+	if (Object.hasOwn(schema, "const") && !jsonEqual(value, schema.const)) {
+		issues.push(`${path} must equal ${describeJSONValue(schema.const)}`);
+		return;
+	}
+	if (schema.enum && !schema.enum.some((candidate) => jsonEqual(candidate, value))) {
+		issues.push(`${path} must be one of the allowed values`);
+		return;
+	}
+	if (schema.type === "object") {
+		if (!isJSONObject(value)) {
+			issues.push(`${path} must be an object`);
+			return;
+		}
+		for (const required of schema.required ?? []) if (!Object.hasOwn(value, required)) issues.push(`${path}.${required} is required`);
+		for (const [key, childSchema] of Object.entries(schema.properties ?? {})) if (Object.hasOwn(value, key)) validate(childSchema, value[key], `${path}.${key}`, issues);
+		if (schema.additionalProperties === false) {
+			const allowed = new Set(Object.keys(schema.properties ?? {}));
+			for (const key of Object.keys(value)) if (!allowed.has(key)) issues.push(`${path}.${key} is not allowed`);
+		} else if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null) {
+			const allowed = new Set(Object.keys(schema.properties ?? {}));
+			for (const key of Object.keys(value)) if (!allowed.has(key)) validate(schema.additionalProperties, value[key], `${path}.${key}`, issues);
+		}
+		return;
+	}
+	if (schema.type === "array") {
+		if (!Array.isArray(value)) {
+			issues.push(`${path} must be an array`);
+			return;
+		}
+		if (schema.minItems !== void 0 && value.length < schema.minItems) issues.push(`${path} must contain at least ${schema.minItems} items`);
+		if (schema.maxItems !== void 0 && value.length > schema.maxItems) issues.push(`${path} must contain at most ${schema.maxItems} items`);
+		if (schema.items) value.forEach((item, index) => validate(schema.items, item, `${path}[${index}]`, issues));
+		return;
+	}
+	if (schema.type === "string") {
+		if (typeof value !== "string") {
+			issues.push(`${path} must be a string`);
+			return;
+		}
+		if (schema.minLength !== void 0 && value.length < schema.minLength) issues.push(`${path} must contain at least ${schema.minLength} characters`);
+		if (schema.maxLength !== void 0 && value.length > schema.maxLength) issues.push(`${path} must contain at most ${schema.maxLength} characters`);
+		if (schema.pattern !== void 0) try {
+			if (!new RegExp(schema.pattern).test(value)) issues.push(`${path} must match ${schema.pattern}`);
+		} catch {
+			issues.push(`${path} has an invalid schema pattern`);
+		}
+		return;
+	}
+	if (schema.type === "number" || schema.type === "integer") {
+		if (typeof value !== "number" || !Number.isFinite(value) || schema.type === "integer" && !Number.isInteger(value)) {
+			issues.push(`${path} must be ${schema.type === "integer" ? "an integer" : "a number"}`);
+			return;
+		}
+		if (schema.minimum !== void 0 && value < schema.minimum) issues.push(`${path} must be at least ${schema.minimum}`);
+		if (schema.maximum !== void 0 && value > schema.maximum) issues.push(`${path} must be at most ${schema.maximum}`);
+		return;
+	}
+	if (schema.type === "boolean" && typeof value !== "boolean") issues.push(`${path} must be a boolean`);
+	if (schema.type === "null" && value !== null) issues.push(`${path} must be null`);
+}
+function isJSONObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return false;
+	if (Object.getOwnPropertySymbols(value).length > 0) return false;
+	return Object.values(Object.getOwnPropertyDescriptors(value)).every((descriptor) => descriptor.enumerable && "value" in descriptor);
+}
+function jsonEqual(left, right) {
+	return compareJSON(left, right, new WeakSet(), new WeakSet());
+}
+function compareJSON(left, right, leftPath, rightPath) {
+	if (left === null || right === null) return left === right;
+	if (typeof left !== typeof right) return false;
+	if (typeof left === "string" || typeof left === "boolean") return left === right;
+	if (typeof left === "number") return Number.isFinite(left) && Number.isFinite(right) && left === right;
+	if (typeof left !== "object" || typeof right !== "object") return false;
+	if (leftPath.has(left) || rightPath.has(right)) return false;
+	const leftArray = Array.isArray(left);
+	if (leftArray !== Array.isArray(right)) return false;
+	if (leftArray) {
+		if (!isJSONArray(left) || !isJSONArray(right)) return false;
+	} else if (!isJSONObject(left) || !isJSONObject(right)) return false;
+	leftPath.add(left);
+	rightPath.add(right);
+	try {
+		if (leftArray) {
+			const rightArray = right;
+			if (left.length !== rightArray.length) return false;
+			for (let index = 0; index < left.length; index++) if (!compareJSON(left[index], rightArray[index], leftPath, rightPath)) return false;
+			return true;
+		}
+		const leftRecord = left;
+		const rightRecord = right;
+		const leftKeys = Object.keys(leftRecord);
+		const rightKeys = Object.keys(rightRecord);
+		if (leftKeys.length !== rightKeys.length) return false;
+		for (const key of leftKeys) {
+			if (!Object.hasOwn(rightRecord, key)) return false;
+			if (!compareJSON(leftRecord[key], rightRecord[key], leftPath, rightPath)) return false;
+		}
+		return true;
+	} finally {
+		leftPath.delete(left);
+		rightPath.delete(right);
+	}
+}
+function describeJSONValue(value) {
+	try {
+		const serialized = JSON.stringify(value);
+		return serialized === void 0 ? "a valid JSON value" : serialized;
+	} catch {
+		return "a valid JSON value";
+	}
+}
+function isJSONArray(value) {
+	if (Object.getOwnPropertySymbols(value).length > 0) return false;
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	for (const [key, descriptor] of Object.entries(descriptors)) {
+		if (key === "length") continue;
+		if (!isArrayIndex(key) || !descriptor.enumerable || !("value" in descriptor)) return false;
+	}
+	return Object.keys(value).length === value.length;
+}
+function isArrayIndex(key) {
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
+}
+
 //#endregion
 //#region src/card-registry.ts
 var CardRegistry = class {
@@ -205,19 +515,28 @@ var CardRegistry = class {
 			complete,
 			valid: false
 		};
-		const valid = complete && this.validate(def, data);
+		const valid = complete && this.validateDefinition(def, data);
 		return {
 			data,
 			complete,
 			valid
 		};
 	}
-	validate(def, data) {
-		if (def.validate) return def.validate(data);
-		if (def.schema) return validateSchema(def.schema, data);
-		return true;
+	validate(type, data) {
+		const def = this.cards.get(type);
+		return def ? this.validateDefinition(def, data) : false;
+	}
+	validateDefinition(def, data) {
+		try {
+			if (def.validate) return def.validate(data);
+			if (def.schema) return validateJSONSchema(def.schema, data).valid;
+			return true;
+		} catch {
+			return false;
+		}
 	}
 	toPromptSpec() {
+		if (this.cards.size === 0) return "";
 		const lines = ["You can output cards. Format: a ```card:<type> fenced block with JSON inside. Available cards:"];
 		for (const def of this.cards.values()) {
 			lines.push(`- \`card:${def.type}\`: ${def.description}`);
@@ -229,6 +548,9 @@ var CardRegistry = class {
 		}
 		return lines.join("\n");
 	}
+	get size() {
+		return this.cards.size;
+	}
 	toJSONSchema() {
 		const properties = {};
 		for (const def of this.cards.values()) if (def.schema) properties[def.type] = def.schema;
@@ -238,53 +560,949 @@ var CardRegistry = class {
 		};
 	}
 };
-/** Minimal JSON Schema validation: covers type / required / properties, enough for cards. */
-function validateSchema(schema, data) {
-	if (schema.type === "object") {
-		if (typeof data !== "object" || data === null || Array.isArray(data)) return false;
-		const obj = data;
-		for (const req of schema.required ?? []) if (!(req in obj)) return false;
-		for (const [key, sub] of Object.entries(schema.properties ?? {})) if (key in obj && !validateSchema(sub, obj[key])) return false;
+
+//#endregion
+//#region src/card-store.ts
+const CARD_ID_MAX_LENGTH = 256;
+const CARD_JSON_MAX_DEPTH = 32;
+const CARD_JSON_MAX_NODES = 1e4;
+const CARD_PATCH_BATCH_MAX_SIZE = 100;
+var CardStore = class {
+	debugSource = "card-store";
+	registry;
+	cards = new Map();
+	lastMutationEpoch = new Map();
+	mutationEpoch = 0;
+	listeners = new Map();
+	allListeners = new Set();
+	debug;
+	constructor(options = {}) {
+		this.registry = options.registry;
+		this.debug = new DebugEmitter(this.debugSource, options);
+	}
+	register(input) {
+		validateCardId(input.id);
+		validateCardType(input.type);
+		assertRecordId(input.id, input.data);
+		const existing = this.cards.get(input.id);
+		if (existing) {
+			if (existing.type !== input.type) throw new CardTypeConflictError(input.id, existing.type, input.type);
+			return existing;
+		}
+		const data = cloneJSON(input.data);
+		this.assertValid(input.type, data);
+		const record = makeRecord(input.id, input.type, data, 0, { status: "idle" });
+		this.cards.set(input.id, record);
+		this.lastMutationEpoch.set(input.id, this.nextMutationEpoch());
+		this.notify(input.id);
+		return record;
+	}
+	get(id) {
+		return this.cards.get(id);
+	}
+	list() {
+		return [...this.cards.values()];
+	}
+	subscribe(id, listener) {
+		let listeners = this.listeners.get(id);
+		if (!listeners) {
+			listeners = new Set();
+			this.listeners.set(id, listeners);
+		}
+		listeners.add(listener);
+		return () => {
+			listeners?.delete(listener);
+			if (listeners?.size === 0) this.listeners.delete(id);
+		};
+	}
+	subscribeAll(listener) {
+		this.allListeners.add(listener);
+		return () => this.allListeners.delete(listener);
+	}
+	subscribeDebug(listener) {
+		return this.debug.subscribe(listener);
+	}
+	apply(patch) {
+		const next = this.preparePatch(this.cards, patch);
+		this.cards.set(next.id, next);
+		this.lastMutationEpoch.set(next.id, this.nextMutationEpoch());
+		this.notify(next.id);
+		if (this.debug.active) this.debug.emit("card-store-patch", {
+			patch,
+			cards: this.list()
+		});
+		return next;
+	}
+	applyAll(patches) {
+		if (patches.length > CARD_PATCH_BATCH_MAX_SIZE) throw new CardLimitError(`Card patch batches cannot exceed ${CARD_PATCH_BATCH_MAX_SIZE} operations`);
+		const nextCards = new Map(this.cards);
+		const changed = new Map();
+		for (const patch of patches) {
+			const next = this.preparePatch(nextCards, patch);
+			nextCards.set(next.id, next);
+			changed.set(next.id, next);
+		}
+		this.cards = nextCards;
+		for (const id of changed.keys()) this.lastMutationEpoch.set(id, this.nextMutationEpoch());
+		for (const id of changed.keys()) this.notifyOne(id);
+		if (changed.size) this.notifyAll();
+		if (changed.size && this.debug.active) {
+			const cards = this.list();
+			this.debug.emit("card-store-change", {
+				cardIds: [...changed.keys()],
+				cards
+			});
+			this.debug.emit("card-store-patch", {
+				patch: {
+					op: "batch",
+					patches
+				},
+				cards
+			});
+		}
+		return [...changed.values()];
+	}
+	delete(id) {
+		if (!this.cards.delete(id)) return false;
+		this.lastMutationEpoch.delete(id);
+		this.nextMutationEpoch();
+		this.notify(id);
 		return true;
 	}
-	if (schema.type === "array") {
-		if (!Array.isArray(data)) return false;
-		return schema.items ? data.every((d) => validateSchema(schema.items, d)) : true;
+	clear() {
+		if (this.cards.size === 0) return;
+		const ids = [...this.cards.keys()];
+		this.cards.clear();
+		this.lastMutationEpoch.clear();
+		this.nextMutationEpoch();
+		for (const id of ids) this.notifyOne(id);
+		this.notifyAll();
+		if (this.debug.active) this.debug.emit("card-store-change", {
+			operation: "clear",
+			cardIds: ids,
+			cards: []
+		});
+	}
+	snapshot() {
+		return {
+			version: 1,
+			cards: this.list().map(({ id, type, data, revision }) => ({
+				id,
+				type,
+				data: cloneJSON(data),
+				revision
+			}))
+		};
+	}
+	restore(snapshot) {
+		if (!snapshot || snapshot.version !== 1 || !Array.isArray(snapshot.cards)) throw new CardSnapshotError("Unsupported card snapshot");
+		const restored = new Map();
+		for (const input of snapshot.cards) {
+			if (!input || typeof input !== "object") throw new CardSnapshotError("Invalid card snapshot record");
+			validateCardId(input.id);
+			validateCardType(input.type);
+			if (!Number.isSafeInteger(input.revision) || input.revision < 0) throw new CardSnapshotError(`Invalid revision for card "${input.id}"`);
+			if (restored.has(input.id)) throw new CardSnapshotError(`Duplicate card id "${input.id}" in snapshot`);
+			const data = cloneJSON(input.data);
+			try {
+				assertRecordId(input.id, data);
+			} catch (cause) {
+				throw new CardSnapshotError(`Card snapshot data id does not match record id "${input.id}"`, { cause });
+			}
+			this.assertValid(input.type, data);
+			restored.set(input.id, makeRecord(input.id, input.type, data, input.revision, { status: "idle" }));
+		}
+		const ids = new Set([...this.cards.keys(), ...restored.keys()]);
+		this.cards = restored;
+		this.lastMutationEpoch = new Map([...restored.keys()].map((id) => [id, this.nextMutationEpoch()]));
+		if (restored.size === 0 && ids.size > 0) this.nextMutationEpoch();
+		for (const id of ids) this.notifyOne(id);
+		if (ids.size) this.notifyAll();
+		if (ids.size && this.debug.active) this.debug.emit("card-store-change", {
+			operation: "restore",
+			cardIds: [...ids],
+			cards: this.list()
+		});
+	}
+	beginAction(id, actionId) {
+		return this.setAction(id, actionId, {
+			status: "loading",
+			actionId
+		}, true);
+	}
+	succeedAction(id, actionId) {
+		return this.setAction(id, actionId, {
+			status: "success",
+			actionId
+		});
+	}
+	failAction(id, actionId, error) {
+		return this.setAction(id, actionId, {
+			status: "error",
+			actionId,
+			error: normalizeCardActionError(error)
+		});
+	}
+	cancelAction(id, actionId) {
+		return this.setAction(id, actionId, { status: "idle" });
+	}
+	isActionCurrent(id, actionId) {
+		const action = this.cards.get(id)?.action;
+		return action?.status === "loading" && action.actionId === actionId;
+	}
+	revisions() {
+		return new Map([...this.cards].map(([id, card]) => [id, card.revision]));
+	}
+	captureMutationEpoch() {
+		return this.mutationEpoch;
+	}
+	applyActionResult(result, startedEpoch) {
+		const patches = result.op === "batch" ? result.patches : [result];
+		if (patches.length > CARD_PATCH_BATCH_MAX_SIZE) throw new CardLimitError(`Card patch batches cannot exceed ${CARD_PATCH_BATCH_MAX_SIZE} operations`);
+		for (const cardId of new Set(patches.map((patch) => patch.cardId))) {
+			const current = this.cards.get(cardId);
+			if (!current) throw new CardNotFoundError(cardId);
+			const lastMutationEpoch = this.lastMutationEpoch.get(cardId);
+			if (lastMutationEpoch === void 0 || lastMutationEpoch > startedEpoch) throw new CardRevisionConflictError(cardId, startedEpoch, lastMutationEpoch ?? this.mutationEpoch);
+		}
+		return result.op === "batch" ? this.applyAll(result.patches) : [this.apply(result)];
+	}
+	preparePatch(cards, patch) {
+		assertPatch(patch);
+		const current = cards.get(patch.cardId);
+		if (!current) throw new CardNotFoundError(patch.cardId);
+		if (patch.revision !== void 0 && patch.revision !== current.revision) throw new CardRevisionConflictError(patch.cardId, patch.revision, current.revision);
+		const patchData = cloneJSON(patch.data);
+		assertPatchId(current.id, patchData);
+		const data = patch.op === "replace" ? patchData : mergeJSON(current.data, patchData);
+		assertStableId(current.id, current.data, data);
+		this.assertValid(current.type, data);
+		return makeRecord(current.id, current.type, data, current.revision + 1, current.action);
+	}
+	assertValid(type, data) {
+		if (this.registry && !this.registry.validate(type, data)) throw new CardValidationError(type);
+	}
+	setAction(id, actionId, action, start = false) {
+		const current = this.cards.get(id);
+		if (!current) throw new CardNotFoundError(id);
+		if (!start && (current.action.status !== "loading" || current.action.actionId !== actionId)) return false;
+		this.cards.set(id, makeRecord(current.id, current.type, current.data, current.revision, action));
+		this.notify(id);
+		return true;
+	}
+	nextMutationEpoch() {
+		return ++this.mutationEpoch;
+	}
+	notify(id) {
+		this.notifyOne(id);
+		this.notifyAll();
+		if (this.debug.active) this.debug.emit("card-store-change", {
+			cardId: id,
+			cards: this.list()
+		});
+	}
+	notifyOne(id) {
+		const card = this.cards.get(id);
+		for (const listener of this.listeners.get(id) ?? []) safeCall(listener, card);
+	}
+	notifyAll() {
+		const cards = this.list();
+		for (const listener of this.allListeners) safeCall(listener, cards);
+	}
+};
+var CardStoreError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+	}
+};
+var CardNotFoundError = class extends CardStoreError {
+	constructor(id) {
+		super(`Card "${id}" was not found`);
+	}
+};
+var CardTypeConflictError = class extends CardStoreError {
+	constructor(id, currentType, nextType) {
+		super(`Card "${id}" is already registered as "${currentType}", not "${nextType}"`);
+	}
+};
+var CardValidationError = class extends CardStoreError {
+	constructor(type) {
+		super(`Card data is invalid for type "${type}"`);
+	}
+};
+var CardRevisionConflictError = class extends CardStoreError {
+	constructor(id, expected, actual) {
+		super(`Card "${id}" revision conflict: expected ${expected}, actual ${actual}`);
+	}
+};
+var CardJSONError = class extends CardStoreError {};
+var CardLimitError = class extends CardStoreError {};
+var CardSnapshotError = class extends CardStoreError {};
+function isCardPatchResult(value) {
+	if (!isPlainObject(value) || typeof value.op !== "string") return false;
+	if (value.op === "batch") return Array.isArray(value.patches) && value.patches.every(isCardPatch);
+	return isCardPatch(value);
+}
+function isCardPatch(value) {
+	return isPlainObject(value) && (value.op === "merge" || value.op === "replace") && typeof value.cardId === "string" && Object.hasOwn(value, "data") && (value.revision === void 0 || Number.isSafeInteger(value.revision));
+}
+function assertPatch(patch) {
+	if (!isCardPatch(patch)) throw new CardStoreError("Invalid card patch");
+	validateCardId(patch.cardId);
+	if (patch.revision !== void 0 && patch.revision < 0) throw new CardStoreError("Card patch revision must be non-negative");
+}
+function validateCardId(id) {
+	if (typeof id !== "string" || id.trim().length === 0 || id.length > CARD_ID_MAX_LENGTH) throw new CardStoreError(`Card id must be a non-empty string up to ${CARD_ID_MAX_LENGTH} characters`);
+}
+function validateCardType(type) {
+	if (typeof type !== "string" || type.trim().length === 0) throw new CardStoreError("Card type must be a non-empty string");
+}
+function cloneJSON(value) {
+	let nodes = 0;
+	const path = new WeakSet();
+	const clone = (input, depth) => {
+		nodes++;
+		if (nodes > CARD_JSON_MAX_NODES) throw new CardLimitError(`Card JSON cannot exceed ${CARD_JSON_MAX_NODES} nodes`);
+		if (depth > CARD_JSON_MAX_DEPTH) throw new CardLimitError(`Card JSON cannot exceed depth ${CARD_JSON_MAX_DEPTH}`);
+		if (input === null || typeof input === "string" || typeof input === "boolean") return input;
+		if (typeof input === "number" && Number.isFinite(input)) return input;
+		if (typeof input !== "object") throw new CardJSONError("Card data must contain only JSON values");
+		if (path.has(input)) throw new CardJSONError("Card data cannot contain cycles");
+		path.add(input);
+		try {
+			if (Array.isArray(input)) {
+				if (Object.keys(input).length !== input.length) throw new CardJSONError("Card arrays must not be sparse");
+				return Object.freeze(input.map((item) => clone(item, depth + 1)));
+			}
+			if (!isPlainObject(input)) throw new CardJSONError("Card objects must be plain JSON objects");
+			const output = {};
+			for (const key of Object.keys(input)) {
+				if (isDangerousKey(key)) throw new CardJSONError(`Card data contains dangerous key "${key}"`);
+				Object.defineProperty(output, key, {
+					value: clone(input[key], depth + 1),
+					enumerable: true,
+					writable: false,
+					configurable: false
+				});
+			}
+			return Object.freeze(output);
+		} finally {
+			path.delete(input);
+		}
+	};
+	return clone(value, 0);
+}
+function mergeJSON(current, patch) {
+	if (!isPlainObject(current) || !isPlainObject(patch)) return patch;
+	const output = {};
+	for (const key of Object.keys(current)) output[key] = current[key];
+	for (const key of Object.keys(patch)) output[key] = mergeJSON(current[key], patch[key]);
+	return cloneJSON(output);
+}
+function assertPatchId(cardId, data) {
+	if (isPlainObject(data) && Object.hasOwn(data, "id") && data.id !== cardId) throw new CardStoreError(`Card patch cannot change id from "${cardId}"`);
+}
+function assertRecordId(cardId, data) {
+	if (isPlainObject(data) && Object.hasOwn(data, "id") && data.id !== cardId) throw new CardStoreError(`Card data id must match record id "${cardId}"`);
+}
+function assertStableId(cardId, current, next) {
+	const currentHasId = isPlainObject(current) && Object.hasOwn(current, "id");
+	const nextHasId = isPlainObject(next) && Object.hasOwn(next, "id");
+	if (currentHasId !== nextHasId || nextHasId && next.id !== cardId) throw new CardStoreError(`Card patch cannot change id from "${cardId}"`);
+}
+function makeRecord(id, type, data, revision, action) {
+	return Object.freeze({
+		id,
+		type,
+		data,
+		revision,
+		action: Object.freeze(action)
+	});
+}
+function normalizeCardActionError(error) {
+	if (error instanceof Error) return Object.freeze({
+		name: error.name || "Error",
+		message: error.message
+	});
+	return Object.freeze({
+		name: "Error",
+		message: typeof error === "string" ? error : "Unknown error"
+	});
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return false;
+	if (Object.getOwnPropertySymbols(value).length) return false;
+	return Object.values(Object.getOwnPropertyDescriptors(value)).every((descriptor) => descriptor.enumerable && "value" in descriptor);
+}
+function isDangerousKey(key) {
+	return key === "__proto__" || key === "prototype" || key === "constructor";
+}
+function safeCall(listener, ...args) {
+	try {
+		listener(...args);
+	} catch {}
+}
+
+//#endregion
+//#region src/actions.ts
+let nextRuntimeId = 0;
+var ActionRegistry = class {
+	actions = new Map();
+	register(definition, options = {}) {
+		if (typeof definition?.type !== "string" || definition.type.trim() === "") throw new TypeError("Action type must be a non-empty string");
+		if (typeof definition.run !== "function") throw new TypeError(`Action "${definition.type}" run must be a function`);
+		if (this.actions.has(definition.type) && !options.override) throw new ActionAlreadyRegisteredError(definition.type);
+		this.actions.set(definition.type, definition);
+	}
+	has(type) {
+		return this.actions.has(type);
+	}
+	get(type) {
+		return this.actions.get(type);
+	}
+	list() {
+		return [...this.actions.values()];
+	}
+};
+var ActionRuntime = class {
+	debugSource = "action-runtime";
+	registry;
+	cardStore;
+	defaultTimeoutMs;
+	onActionStart;
+	onActionSuccess;
+	onActionError;
+	states = new Map();
+	pending = new Map();
+	listeners = new Set();
+	defaultOwner = {};
+	runtimeId = ++nextRuntimeId;
+	generation = 0;
+	nextActionId = 0;
+	destroyed = false;
+	debug;
+	constructor(options) {
+		this.debug = new DebugEmitter(this.debugSource, options);
+		this.registry = options.registry;
+		this.cardStore = options.cardStore;
+		this.defaultTimeoutMs = options.timeoutMs;
+		this.onActionStart = options.onActionStart;
+		this.onActionSuccess = options.onActionSuccess;
+		this.onActionError = options.onActionError;
+	}
+	dispatch(request, options = {}) {
+		if (this.destroyed) return Promise.reject(new ActionDestroyedError());
+		const key = getActionKey(request.type, request.cardType, request.cardId);
+		const owner = options.owner ?? this.defaultOwner;
+		const existing = this.pending.get(key)?.get(owner);
+		if (existing) return existing.promise;
+		const actionId = `r${this.runtimeId}:${request.type}:${++this.nextActionId}`;
+		const event = {
+			key,
+			type: request.type,
+			params: request.params,
+			actionId,
+			cardType: request.cardType,
+			cardId: request.cardId
+		};
+		if (this.debug.active) this.debug.emit("action-dispatched", { ...event });
+		const definition = this.registry.get(request.type);
+		if (!definition) return this.rejectPreflight(event, new ActionNotFoundError(request.type));
+		if (definition.schema !== void 0) try {
+			const validation = validateJSONSchema(definition.schema, request.params);
+			if (!validation.valid) return this.rejectPreflight(event, new ActionValidationError(request.type, validation.issues));
+		} catch (cause) {
+			return this.rejectPreflight(event, new ActionExecutionError(request.type, cause));
+		}
+		let startedMutationEpoch;
+		try {
+			startedMutationEpoch = this.cardStore?.captureMutationEpoch();
+		} catch (cause) {
+			return this.rejectPreflight(event, new ActionExecutionError(request.type, cause));
+		}
+		if (request.cardId && this.cardStore) try {
+			this.cardStore.beginAction(request.cardId, actionId);
+		} catch (cause) {
+			return this.rejectPreflight(event, new ActionExecutionError(request.type, cause));
+		}
+		const generation = this.generation;
+		const controller = new AbortController();
+		const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+		let timer;
+		let timedOut = false;
+		let settled = false;
+		let resolvePromise;
+		let rejectPromise;
+		const promise = new Promise((resolve, reject) => {
+			resolvePromise = resolve;
+			rejectPromise = reject;
+		});
+		const state = {
+			status: "pending",
+			key,
+			type: request.type,
+			cardType: request.cardType,
+			cardId: request.cardId,
+			actionId
+		};
+		const pending = {
+			controller,
+			promise
+		};
+		const runtime = this;
+		let cleanupExternalSignal = () => {};
+		let cleanupAbortSignal = () => {};
+		let owners = this.pending.get(key);
+		if (!owners) {
+			owners = new Map();
+			this.pending.set(key, owners);
+		}
+		owners.set(owner, pending);
+		const cleanup = () => {
+			if (timer !== void 0) clearTimeout(timer);
+			cleanupExternalSignal();
+			cleanupAbortSignal();
+			const currentOwners = this.pending.get(key);
+			if (currentOwners?.get(owner) === pending) {
+				currentOwners.delete(owner);
+				if (currentOwners.size === 0) this.pending.delete(key);
+			}
+		};
+		const finishSuccess = (result) => {
+			if (settled) return;
+			const wasPublic = this.isPublic(key, actionId, generation);
+			const canAffectCard = !request.cardId || !this.cardStore || this.cardStore.isActionCurrent(request.cardId, actionId);
+			const canApplyResult = request.cardId ? canAffectCard : wasPublic;
+			if (canApplyResult && this.cardStore && startedMutationEpoch !== void 0 && isCardPatchResult(result)) try {
+				this.cardStore.applyActionResult(result, startedMutationEpoch);
+			} catch (error) {
+				finishError(error);
+				return;
+			}
+			settled = true;
+			cleanup();
+			if (wasPublic) {
+				this.commit({
+					status: "success",
+					key,
+					type: request.type,
+					cardType: request.cardType,
+					cardId: request.cardId,
+					actionId,
+					result
+				});
+				callEventHandler(this.onActionSuccess, {
+					...event,
+					result
+				});
+				if (this.debug.active) this.debug.emit("action-success", {
+					...event,
+					result
+				});
+			}
+			if (request.cardId && this.cardStore && canAffectCard) settleCardAction(() => this.cardStore?.succeedAction(request.cardId, actionId));
+			resolvePromise(result);
+		};
+		function finishError(cause) {
+			if (settled) return;
+			settled = true;
+			const wasPublic = runtime.isPublic(key, actionId, generation);
+			cleanup();
+			const error = normalizeError(request.type, cause, controller.signal.aborted, timedOut, timeoutMs);
+			if (request.cardId && runtime.cardStore) settleCardAction(() => error instanceof ActionAbortedError ? runtime.cardStore?.cancelAction(request.cardId, actionId) : runtime.cardStore?.failAction(request.cardId, actionId, error));
+			if (wasPublic) {
+				const state$1 = error instanceof ActionAbortedError ? {
+					status: "cancelled",
+					key,
+					type: request.type,
+					cardType: request.cardType,
+					actionId,
+					error
+				} : {
+					status: "error",
+					key,
+					type: request.type,
+					cardType: request.cardType,
+					cardId: request.cardId,
+					actionId,
+					error
+				};
+				if (request.cardId) state$1.cardId = request.cardId;
+				runtime.commit(state$1);
+				callEventHandler(runtime.onActionError, {
+					...event,
+					error
+				});
+				if (runtime.debug.active) runtime.debug.emit("action-error", {
+					...event,
+					error
+				});
+			}
+			rejectPromise(error);
+		}
+		this.commit(state);
+		callEventHandler(this.onActionStart, event);
+		cleanupExternalSignal = forwardAbort(options.signal, controller);
+		cleanupAbortSignal = listenForAbort(controller.signal, (cause) => finishError(cause));
+		if (timeoutMs !== void 0 && timeoutMs > 0 && !settled) timer = setTimeout(() => {
+			timedOut = true;
+			controller.abort(new ActionTimeoutError(request.type, timeoutMs));
+		}, timeoutMs);
+		if (controller.signal.aborted || this.generation !== generation || this.destroyed) {
+			finishError(controller.signal.reason ?? new ActionAbortedError(request.type));
+			return promise;
+		}
+		try {
+			const result = definition.run(request.params, {
+				signal: controller.signal,
+				actionId,
+				cardType: request.cardType,
+				cardId: request.cardId
+			});
+			Promise.resolve(result).then(finishSuccess, finishError);
+		} catch (error) {
+			finishError(error);
+		}
+		return promise;
+	}
+	getState(key) {
+		return this.states.get(key) ?? getIdleActionState(key);
+	}
+	/** Check the runtime allowlist without exposing executable action definitions. */
+	hasAction(type) {
+		return !this.destroyed && this.registry.has(type);
+	}
+	subscribe(listener) {
+		if (this.destroyed) return () => {};
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	subscribeDebug(listener) {
+		return this.debug.subscribe(listener);
+	}
+	cancel(key) {
+		const actions = this.pending.get(key);
+		if (!actions?.size) return false;
+		const type = this.states.get(key)?.type ?? getIdleActionState(key).type;
+		for (const action of [...actions.values()]) action.controller.abort(new ActionAbortedError(type));
+		return true;
+	}
+	reset() {
+		const oldStates = [...this.states.values()];
+		this.generation++;
+		const actions = [...this.pending.values()].flatMap((owners) => [...owners.values()]);
+		for (const action of actions) action.controller.abort(new ActionAbortedError("Action"));
+		this.pending.clear();
+		this.states.clear();
+		for (const state of oldStates) this.notify(idleStateFrom(state));
+	}
+	destroy() {
+		if (this.destroyed) return;
+		this.reset();
+		this.destroyed = true;
+		this.listeners.clear();
+	}
+	rejectPreflight(event, error) {
+		const errorState = {
+			status: "error",
+			key: event.key,
+			type: event.type,
+			cardType: event.cardType,
+			cardId: event.cardId,
+			actionId: event.actionId,
+			error
+		};
+		this.commit(errorState);
+		callEventHandler(this.onActionError, {
+			...event,
+			error
+		});
+		if (this.debug.active) this.debug.emit("action-error", {
+			...event,
+			error
+		});
+		return Promise.reject(error);
+	}
+	isPublic(key, actionId, generation) {
+		return !this.destroyed && this.generation === generation && this.states.get(key)?.actionId === actionId;
+	}
+	commit(state) {
+		this.states.set(state.key, state);
+		if (this.debug.active) this.debug.emit("action-state", { ...state });
+		this.notify(state);
+	}
+	notify(state) {
+		for (const listener of this.listeners) try {
+			listener(state);
+		} catch {}
+	}
+};
+function createActionRuntime(options) {
+	return new ActionRuntime(options);
+}
+var ActionRuntimeError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+	}
+};
+var ActionAlreadyRegisteredError = class extends ActionRuntimeError {
+	constructor(type) {
+		super(`Action "${type}" is already registered`);
+	}
+};
+var ActionNotFoundError = class extends ActionRuntimeError {
+	constructor(type) {
+		super(`Action "${type}" is not registered`);
+	}
+};
+var ActionValidationError = class extends ActionRuntimeError {
+	constructor(actionType, issues) {
+		super(`Action "${actionType}" parameters are invalid: ${issues.join(", ")}`);
+		this.actionType = actionType;
+		this.issues = issues;
+	}
+};
+var ActionExecutionError = class extends ActionRuntimeError {
+	constructor(type, cause) {
+		super(`Action "${type}" failed`, { cause });
+	}
+};
+var ActionAbortedError = class extends ActionRuntimeError {
+	constructor(type) {
+		super(`Action "${type}" was cancelled`);
 	}
-	if (schema.type === "string") return typeof data === "string";
-	if (schema.type === "number") return typeof data === "number";
-	if (schema.type === "boolean") return typeof data === "boolean";
-	return true;
+};
+var ActionTimeoutError = class extends ActionRuntimeError {
+	constructor(type, timeoutMs) {
+		super(`Action "${type}" timed out after ${timeoutMs}ms`);
+		this.timeoutMs = timeoutMs;
+	}
+};
+var ActionDestroyedError = class extends ActionRuntimeError {
+	constructor() {
+		super("Action runtime has been destroyed");
+	}
+};
+function getActionKey(type, cardType, cardId) {
+	if (cardId !== void 0) return `::${JSON.stringify([
+		cardType ?? null,
+		type,
+		cardId
+	])}`;
+	if (!type.includes(":") && !cardType?.includes(":")) return cardType ? `${cardType}:${type}` : type;
+	return `::${JSON.stringify([cardType ?? null, type])}`;
+}
+function getIdleActionState(key) {
+	if (key.startsWith("::")) try {
+		const [cardType, type, cardId] = JSON.parse(key.slice(2));
+		if (cardId !== void 0) return cardType === null ? {
+			status: "idle",
+			key,
+			type,
+			cardId
+		} : {
+			status: "idle",
+			key,
+			cardType,
+			type,
+			cardId
+		};
+		return cardType === null ? {
+			status: "idle",
+			key,
+			type
+		} : {
+			status: "idle",
+			key,
+			cardType,
+			type
+		};
+	} catch {
+		return {
+			status: "idle",
+			key,
+			type: key
+		};
+	}
+	const separator = key.indexOf(":");
+	return separator === -1 ? {
+		status: "idle",
+		key,
+		type: key
+	} : {
+		status: "idle",
+		key,
+		cardType: key.slice(0, separator),
+		type: key.slice(separator + 1)
+	};
+}
+function idleStateFrom(state) {
+	return {
+		status: "idle",
+		key: state.key,
+		type: state.type,
+		...state.cardType === void 0 ? {} : { cardType: state.cardType },
+		...state.cardId === void 0 ? {} : { cardId: state.cardId }
+	};
+}
+function listenForAbort(signal, onAbort) {
+	const abort = () => onAbort(signal.reason);
+	if (signal.aborted) abort();
+	else signal.addEventListener("abort", abort, { once: true });
+	return () => signal.removeEventListener("abort", abort);
+}
+function forwardAbort(signal, controller) {
+	if (!signal) return () => {};
+	const abort = () => controller.abort(signal.reason);
+	if (signal.aborted) abort();
+	else signal.addEventListener("abort", abort, { once: true });
+	return () => signal.removeEventListener("abort", abort);
+}
+function normalizeError(type, cause, aborted, timedOut, timeoutMs) {
+	if (cause instanceof ActionRuntimeError) return cause;
+	if (timedOut) return new ActionTimeoutError(type, timeoutMs ?? 0);
+	if (aborted || isAbortError(cause)) return new ActionAbortedError(type);
+	return new ActionExecutionError(type, cause);
+}
+function isAbortError(error) {
+	return error instanceof DOMException && error.name === "AbortError";
+}
+function callEventHandler(handler, event) {
+	try {
+		handler?.(event);
+	} catch {}
+}
+function settleCardAction(settle) {
+	try {
+		settle();
+	} catch {}
 }
 
 //#endregion
 //#region src/plugins.ts
 /** Merge every plugin's `nodeRenderers` into a single map (later plugins win). */
-function collectNodeRenderers(plugins = []) {
+function collectNodeRenderers(plugins = [], debugOptions = {}) {
 	const map = {};
-	for (const p of plugins) for (const [k, v] of Object.entries(p.nodeRenderers ?? {})) map[k] = v;
+	const target = debugOptions.debugTarget;
+	const debug = target ? void 0 : debugOptions.debug === true ? new DebugEmitter("renderer", debugOptions) : void 0;
+	for (const p of plugins) for (const [k, render] of Object.entries(p.nodeRenderers ?? {})) {
+		if (!(target?.debugEnabled || debugOptions.debug === true)) {
+			map[k] = render;
+			continue;
+		}
+		map[k] = (node) => {
+			const emit = (type, data) => target?.emitDebug(type, data) ?? debug?.emit(type, data);
+			emit("plugin-render-started", {
+				plugin: p.name,
+				nodeType: node.type,
+				nodeKey: node.key
+			});
+			try {
+				const output = render(node);
+				if (isPromise(output)) return output.then((resolved) => {
+					emit("async-output-resolved", {
+						plugin: p.name,
+						nodeType: node.type,
+						nodeKey: node.key,
+						outputKind: resolved.kind
+					});
+					emit("plugin-render-completed", {
+						plugin: p.name,
+						nodeType: node.type,
+						nodeKey: node.key,
+						outputKind: resolved.kind
+					});
+					return resolved;
+				}, (error) => {
+					emit("async-output-rejected", {
+						plugin: p.name,
+						nodeType: node.type,
+						nodeKey: node.key,
+						error
+					});
+					emit("plugin-render-failed", {
+						plugin: p.name,
+						nodeType: node.type,
+						nodeKey: node.key,
+						error
+					});
+					throw error;
+				});
+				emit("plugin-render-completed", {
+					plugin: p.name,
+					nodeType: node.type,
+					nodeKey: node.key,
+					outputKind: output.kind
+				});
+				return output;
+			} catch (error) {
+				emit("plugin-render-failed", {
+					plugin: p.name,
+					nodeType: node.type,
+					nodeKey: node.key,
+					error
+				});
+				throw error;
+			}
+		};
+	}
 	return map;
 }
 /** The set of node types claimed by the given plugins. */
 function pluginNodeTypes(plugins = []) {
 	return new Set(Object.keys(collectNodeRenderers(plugins)));
 }
+function isPromise(value) {
+	return typeof value?.then === "function";
+}
 
 //#endregion
 //#region src/parser.ts
 /** Build a parser that turns markdown source into a flat list of ASTNodes. */
 function createParser(options = {}) {
+	const parse = createParserWithMetadata(options);
+	return (src, rawSrc = src) => parse(src, rawSrc).nodes;
+}
+/** Build a parser that also reports the source range for each top-level block. */
+function createParserWithMetadata(options = {}) {
 	const md = new markdown_it.default({
 		html: true,
 		linkify: true
 	});
 	options.configureMd?.(md);
 	for (const plugin of options.plugins ?? []) plugin.extendParser?.(md);
+	const hasParserExtensions = Boolean(options.configureMd || options.plugins?.some((plugin) => plugin.extendParser));
 	const pluginTypes = pluginNodeTypes(options.plugins);
-	return (src) => {
-		const tokens = md.parse(src, {});
+	const completeness = new Map();
+	for (const plugin of options.plugins ?? []) for (const type of Object.keys(plugin.nodeRenderers ?? {})) if (plugin.isBlockComplete) completeness.set(type, plugin.isBlockComplete);
+	return (src, rawSrc = src, sourceOffset = 0) => {
+		const env = {};
+		const tokens = md.parse(normalizeLineEndings(src), env);
 		const nodes = [];
-		let index = 0;
+		const blocks = [];
+		const lineOffsets = getLineOffsets(rawSrc);
+		const startSlots = new Map();
+		const addNode = (node, map) => {
+			const range = sourceRange(map, rawSrc.length, lineOffsets, sourceOffset);
+			const previous = blocks.at(-1);
+			const block = previous && previous.start === range.start && previous.end === range.end ? previous : void 0;
+			const slot = startSlots.get(range.start) ?? 0;
+			startSlots.set(range.start, slot + 1);
+			nodes.push({
+				key: `${range.start}:${slot}`,
+				...node
+			});
+			if (block) block.nodeEnd = nodes.length;
+			else blocks.push({
+				...range,
+				nodeStart: nodes.length - 1,
+				nodeEnd: nodes.length
+			});
+		};
 		for (let i = 0; i < tokens.length; i++) {
 			const t = tokens[i];
 			if (t.type === "fence") {
@@ -292,79 +1510,84 @@ function createParser(options = {}) {
 				if (info.startsWith("card:") && options.registry) {
 					const cardType = info.slice(5);
 					const res = options.registry.parse(cardType, t.content);
-					nodes.push({
-						key: `${index++}:card`,
+					const complete = res.complete && isClosedFence(rawSrc, t.map, t.markup);
+					const idResult = complete && res.valid ? getCardId(res.data) : void 0;
+					addNode({
 						type: "card",
 						card: {
 							type: cardType,
 							data: res.data,
-							complete: res.complete,
-							valid: res.valid
+							complete,
+							valid: complete && res.valid && idResult !== false,
+							...typeof idResult === "string" ? { id: idResult } : {}
 						}
-					});
-				} else if (pluginTypes.has(info)) nodes.push({
-					key: `${index++}:${info}`,
-					type: info,
-					content: t.content,
-					attrs: { info }
-				});
-				else nodes.push({
-					key: `${index++}:code`,
+					}, t.map);
+				} else if (pluginTypes.has(info)) {
+					const predicate = completeness.get(info);
+					const fenceComplete = isClosedFence(rawSrc, t.map, t.markup);
+					let complete = fenceComplete;
+					if (complete && predicate) try {
+						complete = predicate(info, t.content);
+					} catch {
+						complete = false;
+					}
+					addNode({
+						type: info,
+						content: t.content,
+						attrs: { info },
+						complete
+					}, t.map);
+				} else addNode({
 					type: "code",
 					tag: "code",
 					attrs: info ? { lang: info } : void 0,
 					content: t.content
-				});
+				}, t.map);
 				continue;
 			}
 			if (t.type === "hr") {
-				nodes.push({
-					key: `${index++}:hr`,
+				addNode({
 					type: "hr",
 					tag: "hr"
-				});
+				}, t.map);
 				continue;
 			}
 			if (t.type === "code_block") {
-				nodes.push({
-					key: `${index++}:code`,
+				addNode({
 					type: "code",
 					tag: "code",
 					content: t.content
-				});
+				}, t.map);
 				continue;
 			}
 			if (t.type === "html_block") {
-				nodes.push({
-					key: `${index++}:html`,
+				addNode({
 					type: "html",
 					content: t.content
-				});
+				}, t.map);
 				continue;
 			}
 			if (t.type === "heading_open") {
 				const inline = tokens[i + 1];
 				const raw = inline?.content ?? "";
-				nodes.push({
-					key: `${index++}:heading`,
+				addNode({
 					type: "heading",
 					tag: t.tag,
 					content: raw,
-					html: md.renderInline(raw)
-				});
+					html: md.renderer.renderInline(inline?.children ?? [], md.options, env)
+				}, t.map);
 				i += 2;
 				continue;
 			}
 			if (t.type === "paragraph_open") {
 				const inline = tokens[i + 1];
 				const raw = inline?.content ?? "";
-				nodes.push({
-					key: `${index++}:paragraph`,
+				addNode({
 					type: "paragraph",
 					tag: "p",
 					content: raw,
-					html: md.renderInline(raw)
-				});
+					html: md.renderer.renderInline(inline?.children ?? [], md.options, env)
+				}, t.map);
 				i += 2;
 				continue;
 			}
@@ -380,54 +1603,132 @@ function createParser(options = {}) {
 					}
 				}
 				const slice = tokens.slice(i, j + 1);
-				nodes.push({
-					key: `${index++}:${t.type}`,
+				addNode({
 					type: "html",
-					content: md.renderer.render(slice, md.options, {})
-				});
+					content: md.renderer.render(slice, md.options, env)
+				}, t.map);
 				i = j;
 				continue;
 			}
 			if (t.block && t.level === 0) {
-				nodes.push({
-					key: `${index++}:${t.type}`,
+				addNode({
 					type: "html",
-					content: md.renderer.render([t], md.options, {})
-				});
+					content: md.renderer.render([t], md.options, env)
+				}, t.map);
 				continue;
 			}
 		}
-		return nodes;
+		return {
+			nodes,
+			blocks,
+			incrementalSafe: !hasParserExtensions && !hasReferenceSyntax(rawSrc)
+		};
 	};
 }
+function getCardId(data) {
+	if (typeof data !== "object" || data === null || Array.isArray(data) || !Object.hasOwn(data, "id")) return void 0;
+	const id = data.id;
+	return typeof id === "string" && id.trim().length > 0 && id.length <= 256 ? id : false;
+}
+function getLineOffsets(src) {
+	const offsets = [0];
+	for (let i = 0; i < src.length; i++) if (src[i] === "\r") {
+		if (src[i + 1] === "\n") i++;
+		offsets.push(i + 1);
+	} else if (src[i] === "\n") offsets.push(i + 1);
+	offsets.push(src.length);
+	return offsets;
+}
+function sourceRange(map, sourceLength, lineOffsets, sourceOffset) {
+	if (!map) return {
+		start: sourceOffset,
+		end: sourceOffset + sourceLength
+	};
+	return {
+		start: sourceOffset + Math.min(lineOffsets[map[0]] ?? sourceLength, sourceLength),
+		end: sourceOffset + Math.min(lineOffsets[map[1]] ?? sourceLength, sourceLength)
+	};
+}
+function hasReferenceSyntax(src) {
+	return /^ {0,3}\[[^\]\n]+\]:/m.test(src) || /\[[^\]\n]+\]\s*\[[^\]\n]*\]/.test(src) || /(^|[^!])\[[^\]\n]+\](?![([])/m.test(src);
+}
+function isClosedFence(src, map, markup) {
+	if (!map) return false;
+	const line = src.split(/\r\n|\r|\n/)[map[1] - 1]?.trim() ?? "";
+	if (line.length < markup.length || line[0] !== markup[0]) return false;
+	return line.split("").every((char) => char === markup[0]);
+}
+function normalizeLineEndings(src) {
+	return src.replace(/\r\n|\r/g, "\n");
+}
 
 //#endregion
 //#region src/diff.ts
 /** Produce a minimal set of patches turning `prev` into `next`, keyed by node key. */
 function diffAst(prev, next) {
 	const patches = [];
-	const prevByKey = new Map(prev.map((n) => [n.key, n]));
 	const nextKeys = new Set(next.map((n) => n.key));
-	next.forEach((node, index) => {
-		const old = prevByKey.get(node.key);
-		if (!old) patches.push({
-			op: "insert",
-			index,
-			node
+	const working = [...prev];
+	for (let index = working.length - 1; index >= 0; index--) if (!nextKeys.has(working[index].key)) {
+		patches.push({
+			op: "remove",
+			key: working[index].key
 		});
-		else if (!nodeEqual(old, node)) patches.push({
-			op: "update",
-			key: node.key,
-			node
-		});
-	});
-	for (const node of prev) if (!nextKeys.has(node.key)) patches.push({
-		op: "remove",
-		key: node.key
-	});
+		working.splice(index, 1);
+	}
+	for (let index = 0; index < next.length; index++) {
+		const node = next[index];
+		const currentIndex = working.findIndex((candidate) => candidate.key === node.key);
+		if (currentIndex === -1) {
+			patches.push({
+				op: "insert",
+				index,
+				node
+			});
+			working.splice(index, 0, node);
+			continue;
+		}
+		if (currentIndex !== index) {
+			patches.push({
+				op: "move",
+				key: node.key,
+				index
+			});
+			const [moved] = working.splice(currentIndex, 1);
+			working.splice(index, 0, moved);
+		}
+		if (!nodeEqual(working[index], node)) {
+			patches.push({
+				op: "update",
+				key: node.key,
+				node
+			});
+			working[index] = node;
+		}
+	}
 	return patches;
 }
+/** Apply patches in order, primarily for framework adapters and verification. */
+function applyPatches(nodes, patches) {
+	const next = [...nodes];
+	for (const patch of patches) if (patch.op === "insert") next.splice(patch.index, 0, patch.node);
+	else if (patch.op === "remove") {
+		const index = next.findIndex((node) => node.key === patch.key);
+		if (index !== -1) next.splice(index, 1);
+	} else if (patch.op === "move") {
+		const index = next.findIndex((node) => node.key === patch.key);
+		if (index !== -1) {
+			const [node] = next.splice(index, 1);
+			next.splice(patch.index, 0, node);
+		}
+	} else {
+		const index = next.findIndex((node) => node.key === patch.key);
+		if (index !== -1) next[index] = patch.node;
+	}
+	return next;
+}
 function nodeEqual(a, b) {
+	if (a === b) return true;
 	return JSON.stringify(a) === JSON.stringify(b);
 }
 
@@ -439,166 +1740,434 @@ function nodeEqual(a, b) {
 * the resulting patches via `onPatch`.
 */
 var Renderer = class {
+	debugSource = "renderer";
 	buffer = "";
 	prevAst = [];
 	parse;
+	parsed;
 	options;
 	sanitize;
+	generation = 0;
+	activeFeed;
+	renderScheduled = false;
+	scheduleGeneration = 0;
+	debug;
 	constructor(options = {}) {
 		this.options = options;
-		this.sanitize = options.sanitize !== false;
+		this.debug = new DebugEmitter(this.debugSource, options);
+		this.sanitize = options.sanitize === false ? false : typeof options.sanitize === "object" ? options.sanitize : {};
 		if (options.registry) for (const plugin of options.plugins ?? []) for (const card of plugin.cards ?? []) options.registry.register(card);
-		this.parse = createParser({
+		this.parse = createParserWithMetadata({
 			registry: options.registry,
 			plugins: options.plugins
 		});
 	}
+	get debugEnabled() {
+		return this.debug.available;
+	}
+	emitDebug(type, data = {}) {
+		this.debug.emit(type, data);
+	}
 	push(chunk) {
 		this.buffer += chunk;
-		this.render();
+		if (this.debug.active) this.debug.emit("chunk-received", {
+			chunk,
+			length: chunk.length,
+			bufferLength: this.buffer.length
+		});
+		this.scheduleRender();
 	}
-	async feed(source) {
-		if (Symbol.asyncIterator in source) {
-			for await (const chunk of source) this.push(chunk);
-			return;
-		}
-		const reader = source.getReader();
-		for (;;) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			if (value != null) this.push(value);
+	subscribeDebug(listener) {
+		return this.debug.subscribe(listener);
+	}
+	async feed(source, options = {}) {
+		const generation = ++this.generation;
+		this.cancelActiveFeed(createAbortError("Superseded by a newer feed"));
+		if (this.debug.active) this.debug.emit("feed-started", { generation });
+		const decoder = new TextDecoder();
+		const signal = options.signal;
+		if (signal?.aborted) throw abortReason$1(signal);
+		let aborted = false;
+		let abortError;
+		const abort = () => {
+			aborted = true;
+			abortError = abortReason$1(signal);
+			if (this.activeFeed?.generation === generation) this.cancelActiveFeed(abortError);
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		const consume = (chunk) => {
+			if (generation !== this.generation || aborted) return;
+			const text = typeof chunk === "string" ? decoder.decode() + chunk : decoder.decode(chunk, { stream: true });
+			if (text) this.push(text);
+		};
+		try {
+			if (isReadableStream$2(source)) {
+				const reader = source.getReader();
+				let cancelled = false;
+				this.activeFeed = {
+					generation,
+					cancel: async (reason) => {
+						if (cancelled) return;
+						cancelled = true;
+						await reader.cancel(reason);
+					}
+				};
+				try {
+					for (;;) {
+						const { done, value } = await reader.read();
+						if (done || generation !== this.generation || aborted) break;
+						if (value != null) consume(value);
+					}
+				} finally {
+					reader.releaseLock();
+				}
+			} else {
+				const iterator = source[Symbol.asyncIterator]();
+				let returned = false;
+				this.activeFeed = {
+					generation,
+					cancel: async () => {
+						if (returned) return;
+						returned = true;
+						await iterator.return?.();
+					}
+				};
+				try {
+					for (;;) {
+						const { done, value } = await iterator.next();
+						if (done || generation !== this.generation || aborted) break;
+						consume(value);
+					}
+				} finally {
+					if ((generation !== this.generation || aborted) && !returned) {
+						returned = true;
+						await iterator.return?.();
+					}
+				}
+			}
+			if (generation === this.generation && !aborted) {
+				const tail = decoder.decode();
+				if (tail) this.push(tail);
+				this.flush();
+			}
+			if (aborted) {
+				if (this.debug.active) this.debug.emit("feed-cancelled", {
+					generation,
+					error: abortError
+				});
+				throw abortError;
+			}
+			if (generation === this.generation && this.debug.active) this.debug.emit("feed-completed", {
+				generation,
+				bufferLength: this.buffer.length
+			});
+		} finally {
+			if (!aborted && generation !== this.generation && this.debug.active) this.debug.emit("feed-cancelled", {
+				generation,
+				reason: "superseded-or-reset"
+			});
+			signal?.removeEventListener("abort", abort);
+			if (this.activeFeed?.generation === generation) this.activeFeed = void 0;
 		}
 	}
 	reset() {
+		this.generation++;
+		this.cancelActiveFeed(createAbortError("Renderer reset"));
+		this.activeFeed = void 0;
 		this.buffer = "";
+		this.renderScheduled = false;
+		this.scheduleGeneration++;
+		const patches = diffAst(this.prevAst, []);
 		this.prevAst = [];
+		this.parsed = void 0;
+		this.options.onPatch?.(patches, []);
+		if (this.debug.active) this.debug.emit("renderer-reset", { patches });
+	}
+	/** Immediately render pending buffered input, bypassing the scheduler. */
+	flush() {
+		if (!this.renderScheduled) return;
+		this.renderScheduled = false;
+		this.scheduleGeneration++;
+		this.render();
+	}
+	scheduleRender() {
+		if (!this.options.scheduler) {
+			this.render();
+			return;
+		}
+		if (this.renderScheduled) return;
+		this.renderScheduled = true;
+		const scheduledGeneration = ++this.scheduleGeneration;
+		this.options.scheduler(() => {
+			if (!this.renderScheduled || scheduledGeneration !== this.scheduleGeneration) return;
+			this.renderScheduled = false;
+			this.render();
+		});
+	}
+	cancelActiveFeed(reason) {
+		const active = this.activeFeed;
+		if (!active) return;
+		Promise.resolve(active.cancel(reason)).catch(() => {});
 	}
 	render() {
-		const repaired = repairMarkdown(this.buffer);
-		const nextAst = this.parse(repaired);
-		if (this.sanitize) sanitizeNodes(nextAst);
+		const debug = this.debug.active;
+		const renderStarted = debug ? now() : 0;
+		const previous = this.parsed;
+		let next;
+		let mode = "full";
+		if (previous?.incrementalSafe && previous.blocks.length > 1) {
+			const mutable = previous.blocks.at(-1);
+			const stableBlocks = previous.blocks.slice(0, -1);
+			const stableNodeEnd = mutable.nodeStart;
+			const rawTail = this.buffer.slice(mutable.start);
+			const repaired = repairMarkdown(rawTail);
+			if (debug) this.debug.emit("markdown-repaired", {
+				mode: "mutable-tail",
+				raw: rawTail,
+				rawLength: rawTail.length,
+				repaired,
+				repairedLength: repaired.length,
+				sourceOffset: mutable.start
+			});
+			const parseStarted = debug ? now() : 0;
+			const tail = this.parse(repaired, rawTail, mutable.start);
+			if (debug) this.debug.emit("mutable-tail-reparsed", {
+				sourceOffset: mutable.start,
+				durationMs: now() - parseStarted
+			});
+			if (tail.incrementalSafe) {
+				mode = "mutable-tail";
+				if (this.sanitize !== false) this.sanitizeNodesWithDebug(tail.nodes);
+				next = {
+					nodes: [...previous.nodes.slice(0, stableNodeEnd), ...tail.nodes],
+					blocks: [...stableBlocks, ...tail.blocks.map((block) => ({
+						...block,
+						nodeStart: block.nodeStart + stableNodeEnd,
+						nodeEnd: block.nodeEnd + stableNodeEnd
+					}))],
+					incrementalSafe: true
+				};
+				if (debug) this.debug.emit("stable-prefix-committed", {
+					blocks: stableBlocks.length,
+					nodes: stableNodeEnd
+				});
+			} else {
+				const fullRepaired = repairMarkdown(this.buffer);
+				if (debug) this.debug.emit("markdown-repaired", {
+					mode: "full",
+					raw: this.buffer,
+					rawLength: this.buffer.length,
+					repaired: fullRepaired,
+					repairedLength: fullRepaired.length
+				});
+				const fullParseStarted = debug ? now() : 0;
+				next = this.parse(fullRepaired, this.buffer);
+				if (debug) this.debug.emit("parse-completed", {
+					mode: "full",
+					durationMs: now() - fullParseStarted
+				});
+				if (this.sanitize !== false) this.sanitizeNodesWithDebug(next.nodes);
+			}
+		} else {
+			const repaired = repairMarkdown(this.buffer);
+			if (debug) this.debug.emit("markdown-repaired", {
+				mode: "full",
+				raw: this.buffer,
+				rawLength: this.buffer.length,
+				repaired,
+				repairedLength: repaired.length
+			});
+			const parseStarted = debug ? now() : 0;
+			next = this.parse(repaired, this.buffer);
+			if (debug) this.debug.emit("parse-completed", {
+				mode: "full",
+				durationMs: now() - parseStarted
+			});
+			if (this.sanitize !== false) this.sanitizeNodesWithDebug(next.nodes);
+		}
+		const nextAst = next.nodes;
+		const diffStarted = debug ? now() : 0;
 		const patches = diffAst(this.prevAst, nextAst);
+		const diffDurationMs = debug ? now() - diffStarted : 0;
+		this.parsed = next;
 		this.prevAst = nextAst;
+		const patchDispatchStarted = debug ? now() : 0;
 		if (patches.length > 0) this.options.onPatch?.(patches, nextAst);
+		const patchDispatchDurationMs = debug ? now() - patchDispatchStarted : 0;
+		if (debug) {
+			this.debug.emit("ast-snapshot", {
+				mode,
+				nodes: nextAst
+			});
+			this.debug.emit("ast-patches", {
+				patches,
+				durationMs: diffDurationMs
+			});
+			this.debug.emit("patch-dispatched", {
+				patches: patches.length,
+				durationMs: patchDispatchDurationMs,
+				renderDurationMs: now() - renderStarted
+			});
+		}
+	}
+	sanitizeNodesWithDebug(nodes) {
+		if (this.sanitize === false) return;
+		if (!this.debug.active) {
+			sanitizeNodes(nodes, this.sanitize);
+			return;
+		}
+		const inputSize = nodeMarkupSize(nodes);
+		const started = now();
+		sanitizeNodes(nodes, this.sanitize);
+		this.debug.emit("sanitizer-completed", {
+			inputSize,
+			outputSize: nodeMarkupSize(nodes),
+			durationMs: now() - started
+		});
 	}
 };
 /**
 * Recursively sanitize node markup in place: the content of `html` nodes and
 * the rendered inline `html` field carried by any node.
 */
-function sanitizeNodes(nodes) {
+function sanitizeNodes(nodes, options) {
 	for (const node of nodes) {
-		if (node.type === "html" && typeof node.content === "string") node.content = sanitizeHtml(node.content);
-		if (node.html) node.html = sanitizeHtml(node.html);
-		if (node.children) sanitizeNodes(node.children);
+		if (node.type === "html" && typeof node.content === "string") node.content = sanitizeHtml(node.content, options);
+		if (node.html) node.html = sanitizeHtml(node.html, options);
+		if (node.children) sanitizeNodes(node.children, options);
 	}
 }
+function isReadableStream$2(source) {
+	return "getReader" in source && typeof source.getReader === "function";
+}
+function abortReason$1(signal) {
+	return signal?.reason ?? createAbortError("The operation was aborted");
+}
+function createAbortError(message) {
+	const error = new Error(message);
+	error.name = "AbortError";
+	return error;
+}
+function now() {
+	return typeof performance === "undefined" ? Date.now() : performance.now();
+}
+function nodeMarkupSize(nodes) {
+	let size = 0;
+	for (const node of nodes) {
+		size += node.content?.length ?? 0;
+		size += node.html?.length ?? 0;
+		if (node.children) size += nodeMarkupSize(node.children);
+	}
+	return size;
+}
 
 //#endregion
 //#region src/stream-router.ts
 const DEFAULT_CHANNEL = "content";
-/**
-* Demultiplexes one incoming stream into multiple named channels so different
-* UI regions can update independently (e.g. `progress` + `content` from a single
-* SSE). Framing is auto-detected per line and supports:
-*
-*  1. JSON envelope: `{"ch":"<channel>","delta":"text"}` (a text delta) or
-*     `{"ch":"<channel>","data":<any>}` (a structured value). May appear bare or
-*     after a `data: ` prefix.
-*  2. SSE `event: <name>` sets the channel for the following `data:` line(s).
-*  3. A plain `data: <text>` line with no `ch` and no preceding `event:` is a
-*     text delta on the default `content` channel.
-*/
+/** Demultiplex JSON-lines and standards-compliant SSE into named channels. */
 var StreamRouter = class {
 	sinks = new Map();
 	handlers = new Map();
-	/** Bind a text-stream sink to a channel: text deltas call `sink.push(delta)`. */
+	/** Most recently received SSE `id` field. */
+	lastEventId = "";
+	/** Most recently received valid non-negative SSE reconnection delay. */
+	retry;
 	channel(name, sink) {
 		this.sinks.set(name, sink);
 		return this;
 	}
-	/** Bind a handler to a channel: data values (and deltas as strings) call it. */
 	on(name, handler) {
 		this.handlers.set(name, handler);
 		return this;
 	}
-	/**
-	* Consume a stream to completion, dispatching each parsed line to its channel.
-	* Accepts an async iterable of strings, or a `ReadableStream` of either strings
-	* or `Uint8Array` bytes (decoded as UTF-8).
-	*/
 	async feed(source) {
 		let buffer = "";
-		let currentEvent;
+		let eventName = "";
+		let dataLines = [];
+		const decoder = new TextDecoder();
+		const dispatchEvent = () => {
+			if (dataLines.length === 0) {
+				eventName = "";
+				return;
+			}
+			const payload = dataLines.join("\n");
+			const channel = eventName || DEFAULT_CHANNEL;
+			dataLines = [];
+			eventName = "";
+			this.dispatchPayload(channel, payload, channel === DEFAULT_CHANNEL);
+		};
+		const processLine = (rawLine) => {
+			const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+			if (line === "") {
+				dispatchEvent();
+				return;
+			}
+			if (line.startsWith(":")) return;
+			const bareJson = tryParseJson(line);
+			if (isEnvelope(bareJson)) {
+				this.dispatchEnvelope(bareJson);
+				return;
+			}
+			const colon = line.indexOf(":");
+			const field = colon === -1 ? line : line.slice(0, colon);
+			let value = colon === -1 ? "" : line.slice(colon + 1);
+			if (value.startsWith(" ")) value = value.slice(1);
+			if (field === "event") eventName = value;
+			else if (field === "data") {
+				const envelope = tryParseJson(value);
+				if (!eventName && isEnvelope(envelope)) this.dispatchEnvelope(envelope);
+				else dataLines.push(value);
+			} else if (field === "id") {
+				if (!value.includes("\0")) this.lastEventId = value;
+			} else if (field === "retry") {
+				if (/^\d+$/.test(value)) this.retry = Number(value);
+			} else if (colon === -1) dataLines.push(line);
+		};
 		const consume = (chunk) => {
-			buffer += chunk;
-			let index;
-			while ((index = buffer.indexOf("\n")) !== -1) {
-				const line = buffer.slice(0, index);
-				buffer = buffer.slice(index + 1);
-				currentEvent = this.processLine(line, currentEvent);
+			const text = typeof chunk === "string" ? decoder.decode() + chunk : decoder.decode(chunk, { stream: true });
+			buffer += text;
+			let newline;
+			while ((newline = buffer.indexOf("\n")) !== -1) {
+				processLine(buffer.slice(0, newline));
+				buffer = buffer.slice(newline + 1);
 			}
 		};
-		if ("getReader" in source && typeof source.getReader === "function") {
+		if (isReadableStream$1(source)) {
 			const reader = source.getReader();
-			const decoder = new TextDecoder();
-			for (;;) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				if (value == null) continue;
-				consume(typeof value === "string" ? value : decoder.decode(value, { stream: true }));
+			try {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					if (value != null) consume(value);
+				}
+			} finally {
+				reader.releaseLock();
 			}
-			const tail = decoder.decode();
-			if (tail) consume(tail);
 		} else for await (const chunk of source) consume(chunk);
-		if (buffer.length > 0) this.processLine(buffer, currentEvent);
-	}
-	/** Process a single raw line; returns the (possibly updated) current event. */
-	processLine(rawLine, currentEvent) {
-		const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-		if (line.trim() === "") return void 0;
-		if (line.startsWith("event:")) return line.slice(6).trim();
-		let payload = line;
-		if (payload.startsWith("data:")) {
-			payload = payload.slice(5);
-			if (payload.startsWith(" ")) payload = payload.slice(1);
-		}
-		if (payload.startsWith("{")) {
-			const parsed = tryParseJson(payload);
-			if (parsed !== void 0 && isRecord(parsed) && typeof parsed.ch === "string") {
-				if ("delta" in parsed) this.routeDelta(parsed.ch, String(parsed.delta));
-				else this.routeData(parsed.ch, parsed.data);
-				return currentEvent;
-			}
-			if (parsed !== void 0) {
-				this.routeData(currentEvent ?? DEFAULT_CHANNEL, parsed);
-				return currentEvent;
-			}
-		}
-		if (currentEvent !== void 0) {
-			const parsed = tryParseJson(payload);
-			this.routeData(currentEvent, parsed !== void 0 ? parsed : payload);
-			return currentEvent;
-		}
-		this.routeDelta(DEFAULT_CHANNEL, payload);
-		return currentEvent;
+		const tail = decoder.decode();
+		if (tail) consume(tail);
+		if (buffer.length > 0) processLine(buffer);
+		dispatchEvent();
+	}
+	dispatchPayload(channel, payload, defaultIsDelta) {
+		const parsed = tryParseJson(payload);
+		if (isEnvelope(parsed)) this.dispatchEnvelope(parsed);
+		else if (defaultIsDelta) this.routeDelta(channel, payload);
+		else this.routeData(channel, parsed !== void 0 ? parsed : payload);
+	}
+	dispatchEnvelope(envelope) {
+		const channel = envelope.ch;
+		if ("delta" in envelope) this.routeDelta(channel, String(envelope.delta));
+		else this.routeData(channel, envelope.data);
 	}
-	/** Route a text delta: to a bound sink and/or an on() handler (either/both). */
 	routeDelta(channel, text) {
-		const sink = this.sinks.get(channel);
-		const handler = this.handlers.get(channel);
-		if (sink) sink.push(text);
-		if (handler) handler(text);
+		this.sinks.get(channel)?.push(text);
+		this.handlers.get(channel)?.(text);
 	}
-	/** Route a structured value: to the handler, or a string value to a lone sink. */
 	routeData(channel, value) {
 		const handler = this.handlers.get(channel);
-		if (handler) {
-			handler(value);
-			return;
-		}
-		const sink = this.sinks.get(channel);
-		if (sink && typeof value === "string") sink.push(value);
+		if (handler) handler(value);
+		else if (typeof value === "string") this.sinks.get(channel)?.push(value);
 	}
 };
 function tryParseJson(text) {
@@ -608,8 +2177,11 @@ function tryParseJson(text) {
 		return void 0;
 	}
 }
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
+function isEnvelope(value) {
+	return typeof value === "object" && value !== null && typeof value.ch === "string";
+}
+function isReadableStream$1(source) {
+	return "getReader" in source && typeof source.getReader === "function";
 }
 
 //#endregion
@@ -623,23 +2195,343 @@ function buildSystemPrompt(options = {}) {
 	const parts = [];
 	if (options.base) parts.push(options.base);
 	const cardSpec = options.registry?.toPromptSpec();
-	if (options.registry && hasCards(options.registry) && cardSpec) parts.push(cardSpec);
+	if (cardSpec) parts.push(cardSpec);
 	for (const p of options.plugins ?? []) if (p.promptSpec) parts.push(p.promptSpec);
 	return parts.join("\n\n");
 }
-function hasCards(registry) {
-	return registry.toPromptSpec().includes("card:");
+
+//#endregion
+//#region src/model-stream.ts
+async function* parseSSE(source, options = {}) {
+	let buffer = "";
+	let eventName;
+	let id;
+	let retry;
+	let data = [];
+	const doneData = options.doneData === void 0 ? "[DONE]" : options.doneData;
+	const dispatch = () => {
+		if (data.length === 0) {
+			eventName = void 0;
+			retry = void 0;
+			return void 0;
+		}
+		const raw = data.join("\n");
+		data = [];
+		const result = { data: raw };
+		if (eventName !== void 0) result.event = eventName;
+		if (id !== void 0) result.id = id;
+		if (retry !== void 0) result.retry = retry;
+		eventName = void 0;
+		retry = void 0;
+		if (doneData !== false && raw === doneData) return "done";
+		if (options.parseJSON) try {
+			result.data = JSON.parse(raw);
+		} catch (cause) {
+			const error = malformedError("Invalid SSE JSON", raw, cause);
+			if (options.onMalformed?.(error, raw) === "skip") return void 0;
+			throw error;
+		}
+		return result;
+	};
+	const processLine = (line) => {
+		if (line === "") return dispatch();
+		if (line.startsWith(":")) return void 0;
+		const colon = line.indexOf(":");
+		const field = colon < 0 ? line : line.slice(0, colon);
+		let value = colon < 0 ? "" : line.slice(colon + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		if (field === "data") data.push(value);
+		else if (field === "event") eventName = value;
+		else if (field === "id" && !value.includes("\0")) id = value;
+		else if (field === "retry" && /^\d+$/.test(value)) retry = Number(value);
+		return void 0;
+	};
+	const drainLines = function* (eof = false) {
+		for (;;) {
+			const cr = buffer.indexOf("\r");
+			const lf = buffer.indexOf("\n");
+			let newline = cr < 0 ? lf : lf < 0 ? cr : Math.min(cr, lf);
+			if (newline < 0) break;
+			if (!eof && buffer[newline] === "\r" && newline === buffer.length - 1) break;
+			const width = buffer[newline] === "\r" && buffer[newline + 1] === "\n" ? 2 : 1;
+			const line = buffer.slice(0, newline);
+			buffer = buffer.slice(newline + width);
+			const event$1 = processLine(line);
+			if (event$1) yield event$1;
+		}
+	};
+	for await (const chunk of decodedChunks(source, options.signal)) {
+		buffer += chunk;
+		for (const event$1 of drainLines()) {
+			if (event$1 === "done") return;
+			yield event$1;
+		}
+	}
+	for (const event$1 of drainLines(true)) {
+		if (event$1 === "done") return;
+		yield event$1;
+	}
+	if (buffer) processLine(buffer);
+	const event = dispatch();
+	if (event && event !== "done") yield event;
+}
+async function* jsonLines(source, options = {}) {
+	let buffer = "";
+	for await (const chunk of decodedChunks(source, options.signal)) {
+		buffer += chunk;
+		for (;;) {
+			const newline = buffer.indexOf("\n");
+			if (newline < 0) break;
+			const line = buffer.slice(0, newline).replace(/\r$/, "");
+			buffer = buffer.slice(newline + 1);
+			const value$1 = parseJSONLine(line, options);
+			if (value$1 !== SKIP) yield value$1;
+		}
+	}
+	const value = parseJSONLine(buffer.replace(/\r$/, ""), options);
+	if (value !== SKIP) yield value;
+}
+const ndjson = jsonLines;
+async function* textLines(source, options = {}) {
+	let buffer = "";
+	for await (const chunk of decodedChunks(source, options.signal)) {
+		buffer += chunk;
+		for (;;) {
+			const newline = buffer.indexOf("\n");
+			if (newline < 0) break;
+			yield buffer.slice(0, newline).replace(/\r$/, "");
+			buffer = buffer.slice(newline + 1);
+		}
+	}
+	if (buffer) yield buffer.replace(/\r$/, "");
+}
+async function* contentDeltas(events) {
+	for await (const event of events) if (event.type === "content") yield event.delta;
+}
+async function* mockModelStream(events, options = {}) {
+	for await (const event of events) {
+		throwIfAborted(options.signal);
+		if (options.delayMs && options.delayMs > 0) await delay(options.delayMs, options.signal);
+		yield event;
+	}
+}
+function readableBytes(chunks) {
+	const iterator = toAsyncIterator(chunks);
+	const encoder = new TextEncoder();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await iterator.next();
+				if (result.done) controller.close();
+				else controller.enqueue(typeof result.value === "string" ? encoder.encode(result.value) : result.value);
+			} catch (error) {
+				controller.error(error);
+			}
+		},
+		async cancel(reason) {
+			await iterator.return?.(reason);
+		}
+	});
+}
+async function* decodedChunks(source, signal) {
+	throwIfAborted(signal);
+	const decoder = new TextDecoder();
+	const body = isResponse(source) ? source.body : source;
+	if (!body) throw new TypeError("Response body is null");
+	if (isReadableStream(body)) {
+		const reader = body.getReader();
+		let done$1 = false;
+		let primaryError$1;
+		let cancelPromise;
+		const cancel = (reason) => {
+			if (done$1) return Promise.resolve();
+			cancelPromise ??= Promise.resolve().then(() => reader.cancel(reason));
+			return cancelPromise;
+		};
+		const abort = () => {
+			cancel(abortReason(signal)).catch(() => {});
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		try {
+			for (;;) {
+				throwIfAborted(signal);
+				const result = await reader.read();
+				throwIfAborted(signal);
+				if (result.done) {
+					done$1 = true;
+					break;
+				}
+				const text = decoder.decode(result.value, { stream: true });
+				if (text) yield text;
+			}
+			throwIfAborted(signal);
+			const tail = decoder.decode();
+			if (tail) yield tail;
+		} catch (error) {
+			primaryError$1 = error;
+			throw error;
+		} finally {
+			signal?.removeEventListener("abort", abort);
+			try {
+				if (!done$1) await cancel(abortReason(signal, "Stream iteration stopped"));
+			} catch (error) {
+				if (primaryError$1 === void 0) throw error;
+			} finally {
+				reader.releaseLock();
+			}
+		}
+		return;
+	}
+	const iterator = body[Symbol.asyncIterator]();
+	let done = false;
+	let primaryError;
+	try {
+		for (;;) {
+			throwIfAborted(signal);
+			const result = await nextWithAbort(iterator, signal);
+			throwIfAborted(signal);
+			if (result.done) {
+				done = true;
+				break;
+			}
+			const text = typeof result.value === "string" ? decoder.decode() + result.value : decoder.decode(result.value, { stream: true });
+			if (text) yield text;
+		}
+		const tail = decoder.decode();
+		if (tail) yield tail;
+	} catch (error) {
+		primaryError = error;
+		throw error;
+	} finally {
+		if (!done) try {
+			await iterator.return?.();
+		} catch (error) {
+			if (primaryError === void 0) throw error;
+		}
+	}
+}
+async function nextWithAbort(iterator, signal) {
+	if (!signal) return iterator.next();
+	throwIfAborted(signal);
+	const next = Promise.resolve(iterator.next());
+	let abort;
+	const aborted = new Promise((_resolve, reject) => {
+		abort = () => reject(abortReason(signal));
+		signal.addEventListener("abort", abort, { once: true });
+	});
+	try {
+		return await Promise.race([next, aborted]);
+	} finally {
+		signal.removeEventListener("abort", abort);
+	}
+}
+const SKIP = Symbol("skip");
+function parseJSONLine(line, options) {
+	if (!line.trim()) return SKIP;
+	try {
+		return JSON.parse(line);
+	} catch (cause) {
+		const error = malformedError("Invalid JSON line", line, cause);
+		if (options.onMalformed?.(error, line) === "skip") return SKIP;
+		throw error;
+	}
+}
+function malformedError(message, input, cause) {
+	const error = new SyntaxError(`${message}: ${input}`);
+	error.cause = cause;
+	return error;
+}
+function isResponse(value) {
+	return typeof Response !== "undefined" && value instanceof Response;
+}
+function isReadableStream(value) {
+	return typeof value === "object" && value !== null && "getReader" in value && typeof value.getReader === "function";
+}
+function toAsyncIterator(source) {
+	if (Symbol.asyncIterator in source) return source[Symbol.asyncIterator]();
+	const iterator = source[Symbol.iterator]();
+	return {
+		next: async () => iterator.next(),
+		return: iterator.return ? async (value) => iterator.return(value) : void 0
+	};
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw abortReason(signal);
+}
+function abortReason(signal, fallback = "The operation was aborted") {
+	if (signal?.reason !== void 0) return signal.reason;
+	const error = new Error(fallback);
+	error.name = "AbortError";
+	return error;
+}
+function delay(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(abortReason(signal));
+			return;
+		}
+		const finish = () => {
+			signal?.removeEventListener("abort", abort);
+			resolve();
+		};
+		const timer = setTimeout(finish, ms);
+		const abort = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
+			reject(abortReason(signal));
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+	});
 }
 
 //#endregion
+exports.ActionAbortedError = ActionAbortedError
+exports.ActionAlreadyRegisteredError = ActionAlreadyRegisteredError
+exports.ActionDestroyedError = ActionDestroyedError
+exports.ActionExecutionError = ActionExecutionError
+exports.ActionNotFoundError = ActionNotFoundError
+exports.ActionRegistry = ActionRegistry
+exports.ActionRuntime = ActionRuntime
+exports.ActionRuntimeError = ActionRuntimeError
+exports.ActionTimeoutError = ActionTimeoutError
+exports.ActionValidationError = ActionValidationError
+exports.CARD_ID_MAX_LENGTH = CARD_ID_MAX_LENGTH
+exports.CARD_JSON_MAX_DEPTH = CARD_JSON_MAX_DEPTH
+exports.CARD_JSON_MAX_NODES = CARD_JSON_MAX_NODES
+exports.CARD_PATCH_BATCH_MAX_SIZE = CARD_PATCH_BATCH_MAX_SIZE
+exports.CardJSONError = CardJSONError
+exports.CardLimitError = CardLimitError
+exports.CardNotFoundError = CardNotFoundError
 exports.CardRegistry = CardRegistry
+exports.CardRevisionConflictError = CardRevisionConflictError
+exports.CardSnapshotError = CardSnapshotError
+exports.CardStore = CardStore
+exports.CardStoreError = CardStoreError
+exports.CardTypeConflictError = CardTypeConflictError
+exports.CardValidationError = CardValidationError
+exports.DebugEmitter = DebugEmitter
 exports.Renderer = Renderer
 exports.StreamRouter = StreamRouter
+exports.applyPatches = applyPatches
 exports.buildSystemPrompt = buildSystemPrompt
 exports.collectNodeRenderers = collectNodeRenderers
+exports.contentDeltas = contentDeltas
+exports.createActionRuntime = createActionRuntime
 exports.createParser = createParser
+exports.createParserWithMetadata = createParserWithMetadata
 exports.diffAst = diffAst
+exports.getActionKey = getActionKey
+exports.getIdleActionState = getIdleActionState
+exports.isCardPatchResult = isCardPatchResult
+exports.jsonLines = jsonLines
+exports.mockModelStream = mockModelStream
+exports.ndjson = ndjson
 exports.parsePartialJSON = parsePartialJSON
+exports.parseSSE = parseSSE
 exports.pluginNodeTypes = pluginNodeTypes
+exports.readableBytes = readableBytes
 exports.repairMarkdown = repairMarkdown
-exports.sanitizeHtml = sanitizeHtml
+exports.safeDebugValue = safeDebugValue
+exports.sanitizeHtml = sanitizeHtml
+exports.textLines = textLines
+exports.validateJSONSchema = validateJSONSchema