@temelj/mdx 0.14.0 → 0.15.0

package/dist/stream-session.mjs

@@ -0,0 +1,904 @@
+import { createDiagnostic } from "./diagnostics.mjs";
+import { LimitError, ParseError } from "./errors.mjs";
+import { FootnoteNumbering } from "./footnote-numbering.mjs";
+import { mdxChildren } from "./model.mjs";
+import { rangesIntersect, shiftRange } from "./ranges.mjs";
+import { SourceBuffer, sourceText } from "./source.mjs";
+import { createHtmlLoweringCache, lowerFootnoteSection, lowerNodes } from "./html-lower.mjs";
+import { createMaterializeCache } from "./parser/materialize-cache.mjs";
+import { materializeDocument } from "./parser/materialize.mjs";
+import { ParserSession } from "./parser/session.mjs";
+import { FenceText, OpenParagraph, lowerOpenLeaf, trimOpenTail } from "./stream-tail.mjs";
+import { rewriteMdx } from "./traversal.mjs";
+//#region src/stream-session.ts
+const EMPTY_DEFINITIONS = {
+	links: /* @__PURE__ */ new Map(),
+	footnotes: /* @__PURE__ */ new Map()
+};
+const NO_OCCURRENCES = Object.freeze([]);
+const NO_DEPENDENCIES = Object.freeze({
+	definitions: Object.freeze([]),
+	footnotes: Object.freeze([])
+});
+/**
+* Owns the parser and the rendered blocks of one stream. A top-level block
+* settles once later input cannot change it, and then materializes and lowers
+* once. Each append renders only the open tail; a settled block renders again
+* only when a definition or footnote number it uses changes.
+*/
+var StreamSession = class {
+	#limits;
+	#maximumPendingBlockLength;
+	#parser;
+	/** The stream owns its source; each version is an immutable file. */
+	#source;
+	#file;
+	/** Settled parser output that has not been rendered yet. */
+	#queue = [];
+	#settled = [];
+	/** The settled blocks' renderings, kept beside the entries so a snapshot copies one array. */
+	#blocks = [];
+	#tail = [];
+	#definitions = EMPTY_DEFINITIONS;
+	#dependents = /* @__PURE__ */ new Map();
+	#nodes = 0;
+	#diagnostics = [];
+	#limited;
+	#referenceLimits = /* @__PURE__ */ new Map();
+	#numbering = new FootnoteNumbering();
+	#occurrences = /* @__PURE__ */ new WeakMap();
+	#tailDefinitions = EMPTY_DEFINITIONS;
+	#tailNumbering = new FootnoteNumbering();
+	#tailOccurrences = /* @__PURE__ */ new WeakMap();
+	#definitionsVersion = 0;
+	#footnotes;
+	#footnotesKey = [];
+	#materializeCache = createMaterializeCache();
+	#loweringCache = createHtmlLoweringCache();
+	#fence = new FenceText();
+	#paragraph = new OpenParagraph();
+	#phrasing = /* @__PURE__ */ new WeakMap();
+	#nextId = 0;
+	#current;
+	#lastValid;
+	/** The settled numbering must restart, because settled blocks were dropped. */
+	#renumber = false;
+	#limitedPreview = false;
+	constructor(options) {
+		this.#limits = options.limits;
+		this.#maximumPendingBlockLength = options.maximumPendingBlockLength;
+		this.#source = new SourceBuffer({
+			name: options.name,
+			text: options.source
+		});
+		this.#file = this.#source.file;
+		this.#parser = new ParserSession({
+			source: this.#file,
+			syntax: options.syntax,
+			onSettled: (syntax, index) => this.#queue.push({
+				syntax,
+				index
+			})
+		});
+		this.#current = this.update(0);
+	}
+	/** The latest change, whose snapshot is the current preview. */
+	get current() {
+		return this.#current;
+	}
+	append(text) {
+		const start = this.#settled.length;
+		this.#file = this.#source.append(text);
+		this.#parser.append(text, sourceText(this.#file));
+		this.#current = this.update(start);
+		return this.#current;
+	}
+	edit(edit) {
+		const retired = this.retiredIds(edit);
+		this.#file = this.#source.replace(edit.start, edit.end, edit.text);
+		this.#parser.edit(edit);
+		this.#current = this.update(this.#settled.length, retired);
+		return this.#current;
+	}
+	/**
+	* Finishes the tail strictly and assembles the document from the settled
+	* blocks' nodes, so only the tail materializes again.
+	*/
+	complete() {
+		const limited = this.limitState();
+		if (limited !== void 0 && limited.limit !== "maximumPendingBlockLength") throw this.limitError(limited);
+		const tail = this.#parser.tailDraft().blocks;
+		const settled = this.#settled;
+		const diagnostics = [];
+		const errors = [];
+		const parts = [];
+		let nodes = 1 + this.#nodes;
+		for (const entry of settled) if (entry.materialized.kind === "invalid") errors.push(...entry.materialized.diagnostics);
+		else if (entry.materialized.kind === "ok") {
+			diagnostics.push(...entry.materialized.diagnostics);
+			parts.push({
+				id: entry.id,
+				origin: entry.origin,
+				node: entry.materialized.node
+			});
+		}
+		const tailIds = new Map(this.#tail.map((entry) => [entry.origin.start, entry.id]));
+		for (const syntax of tail) {
+			const origin = blockOrigin(sourceText(this.#file), syntax);
+			const materialized = materializeDocument(this.#file, [syntax], this.#parser.syntax, {
+				...this.#limits,
+				maximumNodes: Math.max(1, this.#limits.maximumNodes - nodes + 1)
+			}, {
+				keepReferences: true,
+				cache: this.#materializeCache,
+				definitionLookup: this.effectiveDefinitions().links
+			});
+			if (materialized.kind === "limitExceeded") throw this.limitError({
+				limit: materialized.limit,
+				offset: origin.end
+			});
+			if (materialized.kind === "invalid") {
+				errors.push(...materialized.diagnostics);
+				continue;
+			}
+			diagnostics.push(...materialized.diagnostics);
+			for (const block of materialized.blocks) {
+				nodes += block.nodeCount;
+				parts.push({
+					id: tailIds.get(origin.start) ?? this.newId(),
+					origin,
+					node: block.node
+				});
+			}
+		}
+		const [firstError, ...otherErrors] = errors;
+		if (firstError !== void 0) throw ParseError.invalidSyntax(this.#file, [firstError, ...otherErrors]);
+		if (nodes > this.#limits.maximumNodes) throw this.limitError({
+			limit: "maximumNodes",
+			offset: this.#file.length
+		});
+		const definitions = collectDefinitions(parts.map((part) => part.node));
+		const document = {
+			kind: "document",
+			children: parts.map((part) => resolveReferences(part.node, definitions, this.#file)),
+			origin: {
+				start: 0,
+				end: this.#file.length
+			}
+		};
+		return Object.freeze({
+			kind: "complete",
+			file: this.#file,
+			document,
+			blocks: Object.freeze(parts.map((part) => Object.freeze({
+				id: part.id,
+				origin: part.origin
+			}))),
+			diagnostics: Object.freeze(diagnostics)
+		});
+	}
+	/**
+	* Settles queued blocks, renders the blocks whose definitions or footnote
+	* numbers changed, renders the open tail, and assembles the snapshot.
+	*/
+	update(previousSettled, retired) {
+		if (this.#file.length > this.#limits.maximumSourceLength) return this.limitChange({
+			limit: "maximumSourceLength",
+			offset: this.#file.length
+		});
+		const before = this.effectiveDefinitions();
+		const previousTail = this.#tail;
+		const start = Math.min(previousSettled, this.dropChangedSettled());
+		const firstAdded = this.#settled.length;
+		const adopted = this.settleQueued(previousTail, retired);
+		const draft = this.#parser.tailDraft();
+		const parts = draft.blocks.map((syntax) => this.materializeTail(syntax, draft.pending));
+		this.#tailDefinitions = collectDefinitions(parts.flatMap(materializedNodes));
+		const after = this.effectiveDefinitions();
+		const changed = changedDefinitions(before, after);
+		const refreshed = this.refreshSettled(changed, after, firstAdded, adopted, start);
+		const settledDefinitions = this.effectiveDefinitions();
+		const resolvedParts = parts.map((part) => {
+			if (part.materialized.kind !== "ok" || !part.materialized.references.some((id) => changed.links.has(id))) return part;
+			return {
+				...part,
+				materialized: this.materialize(part.syntax, this.#limits.maximumNodes - 1 - this.#nodes, part.pending !== void 0 && containsRange(part.syntax.range, part.pending.range) ? part.pending.range : void 0, settledDefinitions.links)
+			};
+		});
+		this.#tailDefinitions = collectDefinitions(resolvedParts.flatMap(materializedNodes));
+		const resolvedDefinitions = this.effectiveDefinitions();
+		this.renderTail(resolvedParts, previousTail, retired, resolvedDefinitions, changed.links);
+		const footnotes = this.footnoteSection(resolvedDefinitions);
+		const limited = this.limitState(draft.pending);
+		if (limited !== void 0) return this.limitChange(limited);
+		const snapshot = Object.freeze({
+			kind: "preview",
+			file: this.#file,
+			blocks: Object.freeze([...this.#blocks, ...this.#tail.map((entry) => entry.block)]),
+			footnotes,
+			diagnostics: Object.freeze([...this.#diagnostics, ...this.#tail.flatMap((entry) => entry.block.diagnostics)]),
+			limit: void 0
+		});
+		const continuous = !this.#limitedPreview;
+		this.#limitedPreview = false;
+		const previous = this.#lastValid;
+		this.#lastValid = snapshot;
+		return Object.freeze({
+			snapshot,
+			start: previous !== void 0 && continuous ? start : 0,
+			refreshed: Object.freeze(continuous ? refreshed : []),
+			footnotesChanged: footnotes !== previous?.footnotes
+		});
+	}
+	/**
+	* Drops settled blocks that an edit replaced, which settle again from the
+	* queue, and returns how many settled blocks remain.
+	*/
+	dropChangedSettled() {
+		const keep = Math.min(this.#settled.length, this.#parser.settledCount, this.#queue[0]?.index ?? Infinity);
+		if (keep < this.#settled.length) this.truncate(keep);
+		return this.#settled.length;
+	}
+	/** Settles queued parser output and returns the indexes of blocks adopted from the tail. */
+	settleQueued(previousTail, retired) {
+		const adopted = /* @__PURE__ */ new Set();
+		for (const settlement of this.#queue) {
+			if (settlement.index !== this.#settled.length) continue;
+			const entry = this.settle(settlement.syntax, previousTail, retired);
+			if (entry.block !== void 0) adopted.add(this.#settled.length);
+			this.addSettled(entry);
+		}
+		this.#queue = [];
+		return adopted;
+	}
+	/**
+	* Renders newly settled blocks, and settled blocks whose definitions or
+	* footnote numbers changed. Returns the re-rendered blocks before `start`.
+	*/
+	refreshSettled(changed, definitions, firstAdded, adopted, start) {
+		const dirty = /* @__PURE__ */ new Set();
+		if (changed.links.size > 0) {
+			this.#loweringCache = createHtmlLoweringCache();
+			this.#materializeCache = createMaterializeCache();
+			this.#definitionsVersion++;
+			for (const identifier of changed.links) for (const index of this.#dependents.get(identifier) ?? []) dirty.add(index);
+		}
+		for (let index = firstAdded; index < this.#settled.length; index++) if (!adopted.has(index)) dirty.add(index);
+		let rematerializedFootnotes = false;
+		for (const index of this.#referenceLimits.keys()) dirty.add(index);
+		for (const index of dirty) {
+			const entry = this.#settled[index];
+			if (entry.materialized.kind === "ok" && (entry.materialized.references.some((id) => changed.links.has(id)) || this.#referenceLimits.has(index))) {
+				const old = entry.materialized;
+				const oldCount = old.nodeCount;
+				const materialized = this.materialize(entry.syntax, this.#limits.maximumNodes - 1 - this.#nodes + oldCount, void 0, definitions.links);
+				if (materialized.kind === "limitExceeded") {
+					this.#referenceLimits.set(index, {
+						limit: materialized.limit,
+						offset: entry.origin.end
+					});
+					continue;
+				}
+				this.#referenceLimits.delete(index);
+				if (materialized.kind === "ok") this.#definitions = {
+					links: replaceDefinitions(this.#definitions.links, old.contents.definitions, materialized.contents.definitions),
+					footnotes: replaceDefinitions(this.#definitions.footnotes, old.contents.footnotes, materialized.contents.footnotes)
+				};
+				this.#nodes += (materialized.kind === "ok" ? materialized.nodeCount : 0) - oldCount;
+				for (const identifier of old.contents.definitionReferences) this.#dependents.get(identifier)?.delete(index);
+				if (materialized.kind === "ok") for (const identifier of materialized.contents.definitionReferences) {
+					const dependents = this.#dependents.get(identifier) ?? /* @__PURE__ */ new Set();
+					dependents.add(index);
+					this.#dependents.set(identifier, dependents);
+				}
+				this.#settled[index] = {
+					...entry,
+					materialized
+				};
+				rematerializedFootnotes ||= old.contents.footnoteReferences.length > 0;
+			}
+		}
+		definitions = this.effectiveDefinitions();
+		const renumberAll = changed.footnotes || this.#renumber || rematerializedFootnotes;
+		this.#renumber = false;
+		for (const index of this.renumber(renumberAll ? 0 : firstAdded)) dirty.add(index);
+		const refreshed = [];
+		for (const index of dirty) {
+			this.#settled[index] = this.render(this.#settled[index], definitions, this.#occurrences, true);
+			this.#blocks[index] = renderedBlock(this.#settled[index]);
+			if (index < start) refreshed.push(renderedBlock(this.#settled[index]));
+		}
+		for (const index of adopted) {
+			const entry = this.#settled[index];
+			const block = renderedBlock(entry);
+			if (!dirty.has(index) && !block.settled) {
+				this.#settled[index] = {
+					...entry,
+					block: Object.freeze({
+						...block,
+						settled: true
+					})
+				};
+				this.#blocks[index] = renderedBlock(this.#settled[index]);
+			}
+		}
+		return refreshed;
+	}
+	/** Adopts the tail's rendering for a block that settled unchanged, or queues it to render. */
+	settle(syntax, previousTail, retired) {
+		const adopted = previousTail.find((entry) => entry.syntax === syntax && entry.pending === void 0);
+		if (adopted !== void 0) return adopted;
+		const origin = blockOrigin(sourceText(this.#file), syntax);
+		return {
+			syntax,
+			id: this.blockId(origin, previousTail, retired),
+			origin,
+			materialized: this.materialize(syntax, this.#limits.maximumNodes - 1 - this.#nodes),
+			pending: void 0,
+			pendingNodes: 0,
+			occurrences: NO_OCCURRENCES,
+			block: void 0
+		};
+	}
+	materializeTail(syntax, pending) {
+		const open = pending !== void 0 && containsRange(syntax.range, pending.range) ? pending : void 0;
+		return {
+			syntax,
+			origin: blockOrigin(sourceText(this.#file), syntax),
+			materialized: this.materialize(syntax, this.#limits.maximumNodes - 1 - this.#nodes, open?.range),
+			pending: open
+		};
+	}
+	materialize(syntax, budget, open, definitions = this.effectiveDefinitions().links) {
+		if (budget < 1) return {
+			kind: "limitExceeded",
+			limit: "maximumNodes"
+		};
+		const result = materializeDocument(this.#file, [syntax], this.#parser.syntax, {
+			...this.#limits,
+			maximumNodes: budget + 1
+		}, {
+			keepReferences: true,
+			allowIncomplete: true,
+			cache: this.#materializeCache,
+			open,
+			definitionLookup: definitions
+		});
+		if (result.kind === "limitExceeded") return {
+			kind: "limitExceeded",
+			limit: result.limit
+		};
+		if (result.kind === "invalid") return {
+			kind: "invalid",
+			diagnostics: result.diagnostics
+		};
+		const [block] = result.blocks;
+		if (block === void 0) throw new Error("A stream block materialized to no node");
+		const contents = blockContents(block.node);
+		return {
+			kind: "ok",
+			node: block.node,
+			nodeCount: block.nodeCount,
+			references: block.references,
+			diagnostics: result.diagnostics,
+			contents: {
+				...contents,
+				definitionReferences: [.../* @__PURE__ */ new Set([...contents.definitionReferences, ...block.references])]
+			}
+		};
+	}
+	/** Adds one settled block to the running totals. Its rendering may still be pending. */
+	addSettled(entry) {
+		const index = this.#settled.length;
+		this.#settled.push(entry);
+		this.#blocks.push(entry.block ?? unrendered);
+		const { materialized } = entry;
+		if (materialized.kind === "limitExceeded") {
+			this.#limited ??= {
+				limit: materialized.limit,
+				offset: entry.origin.end
+			};
+			return;
+		}
+		this.#diagnostics.push(...materialized.diagnostics);
+		if (materialized.kind === "invalid") return;
+		const { contents } = materialized;
+		this.#nodes += materialized.nodeCount;
+		if (contents.definitions.length > 0 || contents.footnotes.length > 0) {
+			const links = new Map(this.#definitions.links);
+			const footnotes = new Map(this.#definitions.footnotes);
+			addFirst(links, contents.definitions);
+			addFirst(footnotes, contents.footnotes);
+			this.#definitions = {
+				links,
+				footnotes
+			};
+		}
+		for (const identifier of contents.definitionReferences) {
+			let dependents = this.#dependents.get(identifier);
+			if (dependents === void 0) {
+				dependents = /* @__PURE__ */ new Set();
+				this.#dependents.set(identifier, dependents);
+			}
+			dependents.add(index);
+		}
+	}
+	/** Drops the settled blocks from `length` on, after an edit before them. */
+	truncate(length) {
+		const kept = this.#settled.slice(0, length);
+		this.#settled = [];
+		this.#blocks = [];
+		this.#definitions = EMPTY_DEFINITIONS;
+		this.#dependents = /* @__PURE__ */ new Map();
+		this.#nodes = 0;
+		this.#diagnostics = [];
+		this.#limited = void 0;
+		for (const index of this.#referenceLimits.keys()) if (index >= length) this.#referenceLimits.delete(index);
+		for (const entry of kept) this.addSettled(entry);
+		this.#renumber = true;
+	}
+	/**
+	* Numbers footnote references in settled blocks from `from` on, continuing
+	* the numbering before them, and returns the blocks whose numbers changed.
+	*/
+	renumber(from) {
+		if (from === 0) {
+			this.#numbering = new FootnoteNumbering();
+			this.#occurrences = /* @__PURE__ */ new WeakMap();
+		}
+		const changed = [];
+		for (let index = from; index < this.#settled.length; index++) {
+			const entry = this.#settled[index];
+			const occurrences = numberReferences(entry.materialized, this.#numbering, this.#occurrences, (identifier) => this.isFootnoteDefined(identifier));
+			if (!sameOccurrences(entry.occurrences, occurrences)) {
+				changed.push(index);
+				this.#settled[index] = {
+					...entry,
+					occurrences
+				};
+			}
+		}
+		return changed;
+	}
+	renderTail(parts, previousTail, retired, definitions, changedLinks) {
+		this.#tailNumbering = this.#numbering.fork();
+		this.#tailOccurrences = /* @__PURE__ */ new WeakMap();
+		this.#tail = parts.map((part) => {
+			const occurrences = numberReferences(part.materialized, this.#tailNumbering, this.#tailOccurrences, (identifier) => this.isFootnoteDefined(identifier));
+			const reusable = previousTail.find((entry) => entry.syntax === part.syntax && entry.pending === void 0 && part.pending === void 0 && sameOccurrences(entry.occurrences, occurrences) && !dependsOn(entry, changedLinks));
+			if (reusable !== void 0) return reusable;
+			return this.render({
+				...part,
+				id: this.blockId(part.origin, previousTail, retired),
+				pendingNodes: 0,
+				occurrences,
+				block: void 0
+			}, definitions, this.#tailOccurrences, false);
+		});
+		const last = this.#tail.at(-1);
+		if (last !== void 0) {
+			const nodes = trimOpenTail(last.block.nodes);
+			if (nodes !== last.block.nodes) this.#tail[this.#tail.length - 1] = {
+				...last,
+				block: Object.freeze({
+					...last.block,
+					nodes: Object.freeze(nodes)
+				})
+			};
+		}
+	}
+	/** Lowers one block in the stream's scope. */
+	render(entry, definitions, occurrences, settled) {
+		const { materialized, pending } = entry;
+		if (materialized.kind !== "ok") {
+			const invalid = materialized.kind === "invalid";
+			return {
+				...entry,
+				block: Object.freeze({
+					id: entry.id,
+					origin: entry.origin,
+					nodes: Object.freeze(invalid ? inertSource(this.#file, entry.origin) : []),
+					status: invalid ? "invalid" : "valid",
+					settled,
+					diagnostics: invalid ? materialized.diagnostics : Object.freeze([]),
+					dependencies: NO_DEPENDENCIES
+				})
+			};
+		}
+		let pendingNodes = 0;
+		const references = new Set(materialized.references);
+		const scope = {
+			definition: (identifier) => definitions.links.get(identifier),
+			footnote: (identifier) => definitions.footnotes.get(identifier),
+			occurrence: (node) => occurrences.get(node),
+			options: { source: this.#file },
+			provisional: true,
+			cache: this.#loweringCache
+		};
+		const nodes = lowerNodes([materialized.node], pending === void 0 ? scope : {
+			...scope,
+			replace: (node) => {
+				const open = lowerOpenLeaf(node, pending, {
+					file: this.#file,
+					definitions: definitions.links,
+					references,
+					syntax: this.#parser.syntax,
+					limits: this.#limits,
+					fence: this.#fence,
+					paragraph: this.#paragraph,
+					phrasing: this.#phrasing,
+					lowering: this.#loweringCache
+				}, (children, previous) => lowerNodes(children, scope, previous));
+				pendingNodes += open?.nodeCount ?? 0;
+				return open?.nodes;
+			}
+		});
+		const contents = {
+			...materialized.contents,
+			definitionReferences: [.../* @__PURE__ */ new Set([...materialized.contents.definitionReferences, ...references])]
+		};
+		return {
+			...entry,
+			materialized: {
+				...materialized,
+				contents,
+				references: [...references]
+			},
+			pendingNodes,
+			block: Object.freeze({
+				id: entry.id,
+				origin: entry.origin,
+				nodes: Object.freeze(nodes),
+				status: "valid",
+				settled,
+				diagnostics: materialized.diagnostics,
+				dependencies: dependenciesOf(contents)
+			})
+		};
+	}
+	isFootnoteDefined(identifier) {
+		return this.#definitions.footnotes.has(identifier) || this.#tailDefinitions.footnotes.has(identifier);
+	}
+	effectiveDefinitions() {
+		const tail = this.#tailDefinitions;
+		if (tail.links.size === 0 && tail.footnotes.size === 0) return this.#definitions;
+		const links = new Map(this.#definitions.links);
+		const footnotes = new Map(this.#definitions.footnotes);
+		addFirst(links, [...tail.links.values()]);
+		addFirst(footnotes, [...tail.footnotes.values()]);
+		return {
+			links,
+			footnotes
+		};
+	}
+	/** The footnote section, rebuilt only when its numbering or definitions change. */
+	footnoteSection(definitions) {
+		const numbering = this.#tailNumbering;
+		const key = [this.#definitionsVersion, ...numbering.order.flatMap((identifier) => [
+			identifier,
+			numbering.count(identifier),
+			definitions.footnotes.get(identifier)
+		])];
+		if (key.length === this.#footnotesKey.length && key.every((value, index) => value === this.#footnotesKey[index])) return this.#footnotes;
+		this.#footnotesKey = key;
+		this.#footnotes = lowerFootnoteSection(numbering, {
+			definition: (identifier) => definitions.links.get(identifier),
+			footnote: (identifier) => definitions.footnotes.get(identifier),
+			occurrence: (node) => this.#occurrences.get(node) ?? this.#tailOccurrences.get(node),
+			options: { source: this.#file },
+			provisional: true
+		});
+		return this.#footnotes;
+	}
+	/** The first limit the stream exceeds, if any. */
+	limitState(pending) {
+		if (this.#file.length > this.#limits.maximumSourceLength) return {
+			limit: "maximumSourceLength",
+			offset: this.#file.length
+		};
+		if (this.#limited !== void 0) return this.#limited;
+		const referenceLimit = this.#referenceLimits.values().next().value;
+		if (referenceLimit !== void 0) return referenceLimit;
+		let nodes = 1 + this.#nodes;
+		for (const entry of this.#tail) {
+			if (entry.materialized.kind === "limitExceeded") return {
+				limit: entry.materialized.limit,
+				offset: entry.origin.end
+			};
+			nodes += (entry.materialized.kind === "ok" ? entry.materialized.nodeCount : 0) + entry.pendingNodes;
+		}
+		if (nodes > this.#limits.maximumNodes) return {
+			limit: "maximumNodes",
+			offset: this.#tail.at(-1)?.origin.end ?? 0
+		};
+		const owner = pending === void 0 ? void 0 : this.#tail.find((entry) => entry.pending !== void 0);
+		if (owner !== void 0 && owner.syntax.range.end - owner.syntax.range.start > this.#maximumPendingBlockLength) return {
+			limit: "maximumPendingBlockLength",
+			offset: owner.syntax.range.end
+		};
+	}
+	/** Keeps the last preview within limits, with its block identities. */
+	limitChange(state) {
+		this.#limitedPreview = true;
+		const snapshot = Object.freeze({
+			kind: "preview",
+			file: this.#file,
+			blocks: this.#lastValid?.blocks ?? Object.freeze([]),
+			footnotes: this.#lastValid?.footnotes,
+			diagnostics: Object.freeze([limitDiagnostic(this.#file, state)]),
+			limit: state.limit
+		});
+		return Object.freeze({
+			snapshot,
+			start: snapshot.blocks.length,
+			refreshed: Object.freeze([]),
+			footnotesChanged: false
+		});
+	}
+	limitError(state) {
+		const maximum = state.limit === "maximumPendingBlockLength" ? this.#maximumPendingBlockLength : this.#limits[state.limit];
+		return LimitError.exceeded(this.#file, state.limit, maximum, {
+			start: state.offset,
+			end: state.offset
+		}, state.limit === "maximumSourceLength" ? this.#file.length : void 0);
+	}
+	/** A block keeps its identity across appends, and across edits that do not touch it. */
+	blockId(origin, previousTail, retired) {
+		if (retired !== void 0) return retired.get(rangeKey(origin)) ?? this.newId();
+		return previousTail.find((entry) => entry.origin.start === origin.start)?.id ?? this.newId();
+	}
+	/** Identities of blocks an edit does not touch, keyed by their range after the edit. */
+	retiredIds(edit) {
+		const retired = /* @__PURE__ */ new Map();
+		const delta = edit.text.length - (edit.end - edit.start);
+		for (const entry of [...this.#settled, ...this.#tail]) if (!rangesIntersect(entry.origin, edit)) retired.set(rangeKey(entry.origin.start >= edit.end ? shiftRange(entry.origin, delta) : entry.origin), entry.id);
+		return retired;
+	}
+	newId() {
+		const value = `block-${this.#nextId++}`;
+		if (!isBlockId(value)) throw new Error("Internal block identity invariant failed");
+		return value;
+	}
+};
+/** Stands in for a settled block until it renders later in the same update. */
+const unrendered = Object.freeze({
+	id: placeholderId(),
+	origin: Object.freeze({
+		start: 0,
+		end: 0
+	}),
+	nodes: Object.freeze([]),
+	status: "valid",
+	settled: true,
+	diagnostics: Object.freeze([]),
+	dependencies: NO_DEPENDENCIES
+});
+/** Every settled entry renders before an update publishes its snapshot. */
+function renderedBlock(entry) {
+	if (entry.block === void 0) throw new Error("A settled stream block was not rendered");
+	return entry.block;
+}
+function materializedNodes(part) {
+	return part.materialized.kind === "ok" ? [part.materialized.node] : [];
+}
+const emptyContents = Object.freeze({
+	definitionReferences: Object.freeze([]),
+	footnoteReferences: Object.freeze([]),
+	definitions: Object.freeze([]),
+	footnotes: Object.freeze([])
+});
+/** Contents by node identity. Trees are immutable, so a reused subtree is walked once. */
+const contentsCache = /* @__PURE__ */ new WeakMap();
+/** The references a node makes and the definitions it contains, in document order. */
+function blockContents(node) {
+	const hit = contentsCache.get(node);
+	if (hit !== void 0) return hit;
+	if (node.kind === "list") return listContents(node);
+	const parts = mdxChildren(node).map(blockContents);
+	switch (node.kind) {
+		case "linkReference":
+		case "imageReference":
+			parts.unshift({
+				...emptyContents,
+				definitionReferences: [node.identifier]
+			});
+			break;
+		case "footnoteReference":
+			parts.unshift({
+				...emptyContents,
+				footnoteReferences: [node]
+			});
+			break;
+		case "definition":
+			parts.unshift({
+				...emptyContents,
+				definitions: [node]
+			});
+			break;
+		case "footnoteDefinition": parts.unshift({
+			...emptyContents,
+			footnotes: [node]
+		});
+	}
+	const filled = parts.filter((part) => part !== emptyContents);
+	const contents = filled.length === 0 ? emptyContents : filled.length === 1 ? filled[0] : {
+		definitionReferences: [...new Set(filled.flatMap((part) => part.definitionReferences))],
+		footnoteReferences: filled.flatMap((part) => part.footnoteReferences),
+		definitions: filled.flatMap((part) => part.definitions),
+		footnotes: filled.flatMap((part) => part.footnotes)
+	};
+	contentsCache.set(node, contents);
+	return contents;
+}
+/** A list's contents after each of its last items, by item. */
+const listContentsCache = /* @__PURE__ */ new WeakMap();
+/** A growing list combines the contents of its unchanged leading items once. */
+function listContents(node) {
+	const items = node.children;
+	let start = 0;
+	let contents = emptyContents;
+	for (let index = items.length - 1; index >= Math.max(0, items.length - 8); index--) {
+		const prefix = listContentsCache.get(items[index]);
+		if (prefix?.index === index) {
+			start = index + 1;
+			contents = prefix.contents;
+			break;
+		}
+	}
+	for (let index = start; index < items.length; index++) {
+		contents = mergeContents(contents, blockContents(items[index]));
+		if (index >= items.length - 8) listContentsCache.set(items[index], {
+			index,
+			contents
+		});
+	}
+	contentsCache.set(node, contents);
+	return contents;
+}
+function mergeContents(left, right) {
+	if (right === emptyContents) return left;
+	if (left === emptyContents) return right;
+	return {
+		definitionReferences: [.../* @__PURE__ */ new Set([...left.definitionReferences, ...right.definitionReferences])],
+		footnoteReferences: [...left.footnoteReferences, ...right.footnoteReferences],
+		definitions: [...left.definitions, ...right.definitions],
+		footnotes: [...left.footnotes, ...right.footnotes]
+	};
+}
+function collectDefinitions(nodes) {
+	const links = /* @__PURE__ */ new Map();
+	const footnotes = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const contents = blockContents(node);
+		addFirst(links, contents.definitions);
+		addFirst(footnotes, contents.footnotes);
+	}
+	return {
+		links,
+		footnotes
+	};
+}
+/** Replaces re-materialized definitions only when their old node was the winning definition. */
+function replaceDefinitions(current, previous, next) {
+	if (previous.length === 0) return current;
+	const old = new Set(previous);
+	const updated = new Map(current);
+	for (const node of next) {
+		const winner = updated.get(node.identifier);
+		if (winner !== void 0 && old.has(winner)) updated.set(node.identifier, node);
+	}
+	return updated;
+}
+function addFirst(target, nodes) {
+	for (const node of nodes) if (!target.has(node.identifier)) target.set(node.identifier, node);
+}
+function changedDefinitions(before, after) {
+	const links = /* @__PURE__ */ new Set();
+	if (before.links !== after.links) for (const identifier of /* @__PURE__ */ new Set([...before.links.keys(), ...after.links.keys()])) {
+		const previous = before.links.get(identifier);
+		const next = after.links.get(identifier);
+		if (previous?.url !== next?.url || previous?.title !== next?.title) links.add(identifier);
+	}
+	let footnotes = before.footnotes.size !== after.footnotes.size;
+	for (const identifier of after.footnotes.keys()) footnotes ||= !before.footnotes.has(identifier);
+	return {
+		links,
+		footnotes
+	};
+}
+function numberReferences(materialized, numbering, occurrences, defined) {
+	if (materialized.kind !== "ok" || materialized.contents.footnoteReferences.length === 0) return NO_OCCURRENCES;
+	return materialized.contents.footnoteReferences.map((node) => {
+		if (!defined(node.identifier)) return;
+		const occurrence = numbering.reference(node.identifier);
+		occurrences.set(node, occurrence);
+		return occurrence;
+	});
+}
+function sameOccurrences(left, right) {
+	return left === right || left.length === right.length && left.every((occurrence, index) => occurrence?.ordinal === right[index]?.ordinal && occurrence?.occurrence === right[index]?.occurrence);
+}
+function dependsOn(entry, identifiers) {
+	return identifiers.size > 0 && entry.materialized.kind === "ok" && entry.materialized.contents.definitionReferences.some((identifier) => identifiers.has(identifier));
+}
+function dependenciesOf(contents) {
+	if (contents.definitionReferences.length === 0 && contents.footnoteReferences.length === 0) return NO_DEPENDENCIES;
+	return Object.freeze({
+		definitions: Object.freeze([...contents.definitionReferences]),
+		footnotes: Object.freeze([...new Set(contents.footnoteReferences.map((node) => node.identifier))])
+	});
+}
+/** Turns references without definitions into their authored text, like batch parsing. */
+function resolveReferences(node, definitions, file) {
+	const contents = blockContents(node);
+	if (!(contents.definitionReferences.some((identifier) => !definitions.links.has(identifier)) || contents.footnoteReferences.some((reference) => !definitions.footnotes.has(reference.identifier)))) return node;
+	const authored = (reference) => reference.origin === void 0 ? void 0 : {
+		kind: "text",
+		value: file.slice(reference.origin),
+		origin: reference.origin
+	};
+	const [result] = rewriteMdx({
+		kind: "document",
+		children: [node]
+	}, {
+		linkReference: ({ node: reference }) => definitions.links.has(reference.identifier) ? void 0 : authored(reference),
+		imageReference: ({ node: reference }) => definitions.links.has(reference.identifier) ? void 0 : authored(reference),
+		footnoteReference: ({ node: reference }) => definitions.footnotes.has(reference.identifier) ? void 0 : authored(reference)
+	}).children;
+	if (result === void 0) throw new Error("Reference resolution removed a stream block");
+	return result;
+}
+/** Invalid authored source renders as inert text. */
+function inertSource(file, origin) {
+	return [{
+		kind: "element",
+		tagName: "p",
+		attributes: {},
+		children: [{
+			kind: "text",
+			value: file.semanticSlice(origin).trimEnd(),
+			origin
+		}],
+		origin
+	}];
+}
+function limitDiagnostic(file, state) {
+	return createDiagnostic({
+		code: "mdx-limit-exceeded",
+		severity: "error",
+		message: `${state.limit} was exceeded at source offset ${state.offset}`,
+		span: {
+			file,
+			start: state.offset,
+			end: state.offset
+		}
+	});
+}
+/** A block starts at the start of its first physical line. */
+function blockOrigin(text, syntax) {
+	let start = syntax.range.start;
+	while (start > 0 && text.char(start - 1) !== "\n" && text.char(start - 1) !== "\r") start--;
+	return {
+		start,
+		end: syntax.range.end
+	};
+}
+function containsRange(outer, inner) {
+	return outer.start <= inner.start && inner.end <= outer.end;
+}
+function rangeKey(range) {
+	return `${range.start}:${range.end}`;
+}
+/** The placeholder never reaches a snapshot, so its identity never meets a real block. */
+function placeholderId() {
+	const value = "block-0";
+	if (!isBlockId(value)) throw new Error("Internal block identity invariant failed");
+	return value;
+}
+function isBlockId(value) {
+	return /^block-\d+$/u.test(value);
+}
+//#endregion
+export { StreamSession };
+
+//# sourceMappingURL=stream-session.mjs.map