@fictjs/ssr 0.25.0 → 0.27.0

package/dist/render-core-D0nOT_Pe.js

@@ -0,0 +1,1824 @@
+import { createStreamRuntimeCode } from "./stream-runtime.js";
+import { render } from "@fictjs/runtime";
+import { __fictCreateSSRSession, __fictDisableSSR, __fictEnableSSR, __fictGetCurrentSSRSession, __fictGetScopeRegistry, __fictRetainSSRSession, __fictRunWithSSRSession, __fictSerializeSSRState, __fictSerializeSSRStateForScopes, __fictSetSSRScopeIdentifierPrefix, __fictSetSSRStreamHooks, assertValidDOMAttributeName, assertValidDOMElementName } from "@fictjs/runtime/internal";
+import { parseHTML } from "linkedom";
+//#region src/node-require.ts
+/**
+* Resolve Node's module-local `require` without introducing a Node builtin
+* import into the edge-compatible ESM build.
+*
+* The CJS build replaces `__FICT_NODE_REQUIRE__` with its local `require`.
+* Source/ESM execution can still opt in through a host-provided global.
+*/
+function getNodeRequire() {
+	if (typeof __FICT_NODE_REQUIRE__ === "function") return __FICT_NODE_REQUIRE__;
+	const direct = globalThis.require;
+	if (typeof direct === "function") return direct;
+	try {
+		return Function("return typeof require === \"function\" ? require : null")();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/globals.ts
+function installGlobals(window, document) {
+	const win = window;
+	const required = {
+		window: win,
+		document,
+		self: win,
+		Node: win.Node,
+		Element: win.Element,
+		HTMLElement: win.HTMLElement,
+		SVGElement: win.SVGElement,
+		Document: win.Document,
+		DocumentFragment: win.DocumentFragment,
+		Text: win.Text,
+		Comment: win.Comment
+	};
+	const optional = {
+		Range: win.Range,
+		Event: win.Event,
+		CustomEvent: win.CustomEvent,
+		MutationObserver: win.MutationObserver,
+		DOMParser: win.DOMParser,
+		getComputedStyle: win.getComputedStyle?.bind(win)
+	};
+	const missing = Object.entries(required).filter(([, value]) => value === void 0).map(([key]) => key);
+	if (missing.length) throw new Error(`[fict/ssr] Missing DOM globals: ${missing.join(", ")}`);
+	const globals = {
+		...required,
+		...optional
+	};
+	const keys = Object.keys(globals);
+	const snapshot = captureGlobals(keys);
+	for (const key of keys) {
+		const value = globals[key];
+		if (value !== void 0) globalThis[key] = value;
+	}
+	return () => restoreGlobals(snapshot);
+}
+function installManifest(manifest) {
+	if (!manifest) return () => {};
+	let resolved;
+	if (typeof manifest === "string") {
+		const raw = readTextFileFromPath(manifest);
+		resolved = JSON.parse(raw);
+	} else resolved = manifest;
+	const session = __fictGetCurrentSSRSession();
+	if (session) {
+		const previous = session.manifest;
+		session.manifest = resolved;
+		return () => {
+			session.manifest = previous;
+		};
+	}
+	const key = "__FICT_MANIFEST__";
+	const snapshot = {
+		exists: Object.prototype.hasOwnProperty.call(globalThis, key),
+		value: globalThis[key]
+	};
+	globalThis[key] = resolved;
+	return () => {
+		if (snapshot.exists) globalThis[key] = snapshot.value;
+		else delete globalThis[key];
+	};
+}
+function captureGlobals(keys) {
+	const snapshot = [];
+	for (const key of keys) {
+		const exists = Object.prototype.hasOwnProperty.call(globalThis, key);
+		const value = globalThis[key];
+		snapshot.push({
+			key,
+			exists,
+			value
+		});
+	}
+	return snapshot;
+}
+function restoreGlobals(snapshot) {
+	for (const entry of snapshot) if (entry.exists) globalThis[entry.key] = entry.value;
+	else delete globalThis[entry.key];
+}
+function readTextFileFromPath(path) {
+	const deno = globalThis.Deno;
+	if (deno && typeof deno.readTextFileSync === "function") return deno.readTextFileSync(path);
+	const nodeRequire = getNodeRequire();
+	if (nodeRequire) return nodeRequire("node:fs").readFileSync(path, "utf8");
+	throw new Error("[fict/ssr] `manifest` as file path is only supported when Deno.readTextFileSync or CommonJS require is available. Pass a manifest object in Node ESM or edge runtimes.");
+}
+//#endregion
+//#region src/html-serializer.ts
+const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+const MATHML_TEXT_INTEGRATION_EXCEPTIONS = /* @__PURE__ */ new Set(["mglyph", "malignmark"]);
+const HTML_VOID_ELEMENTS = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"basefont",
+	"bgsound",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"keygen",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+const HTML_RAW_TEXT_ELEMENTS = /* @__PURE__ */ new Set([
+	"iframe",
+	"noembed",
+	"noframes",
+	"noscript",
+	"script",
+	"style",
+	"xmp"
+]);
+const HTML_RCDATA_ELEMENTS = /* @__PURE__ */ new Set(["textarea", "title"]);
+const HTML_TABLE_SECTION_ELEMENTS = /* @__PURE__ */ new Set([
+	"tbody",
+	"thead",
+	"tfoot"
+]);
+const HTML_TEXT_ONLY_ELEMENTS = /* @__PURE__ */ new Set([
+	...HTML_RAW_TEXT_ELEMENTS,
+	"plaintext",
+	"textarea",
+	"title"
+]);
+const HTML_DOCUMENT_STRUCTURE_ELEMENTS = /* @__PURE__ */ new Set([
+	"frameset",
+	"head",
+	"html"
+]);
+const HTML_UNSAFE_RESUMABLE_HOST_PARENTS = /* @__PURE__ */ new Set([
+	"colgroup",
+	"option",
+	"optgroup",
+	"select",
+	"table",
+	"tr",
+	...HTML_TABLE_SECTION_ELEMENTS,
+	...HTML_TEXT_ONLY_ELEMENTS,
+	...HTML_DOCUMENT_STRUCTURE_ELEMENTS
+]);
+const HTML_HOST_SENSITIVE_CONTEXT_CHILDREN = /* @__PURE__ */ new Map([
+	["details", /* @__PURE__ */ new Set(["summary"])],
+	["fieldset", /* @__PURE__ */ new Set(["legend"])],
+	["audio", /* @__PURE__ */ new Set(["source", "track"])],
+	["video", /* @__PURE__ */ new Set(["source", "track"])],
+	["ruby", /* @__PURE__ */ new Set(["rp", "rt"])],
+	["figure", /* @__PURE__ */ new Set(["figcaption"])],
+	["map", /* @__PURE__ */ new Set(["area"])]
+]);
+const HTML_LIST_ITEM_SCAN_BARRIERS = /* @__PURE__ */ new Set([
+	"applet",
+	"article",
+	"aside",
+	"blockquote",
+	"button",
+	"caption",
+	"center",
+	"colgroup",
+	"details",
+	"dl",
+	"fieldset",
+	"figure",
+	"footer",
+	"form",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hgroup",
+	"hr",
+	"main",
+	"marquee",
+	"menu",
+	"nav",
+	"object",
+	"ol",
+	"pre",
+	"search",
+	"section",
+	"select",
+	"table",
+	"tbody",
+	"td",
+	"tfoot",
+	"th",
+	"thead",
+	"tr",
+	"ul"
+]);
+const HTML_PARSER_SENSITIVE_HOST_CONTEXTS = /* @__PURE__ */ new Map([
+	["p", { descendants: /* @__PURE__ */ new Set([
+		"address",
+		"article",
+		"aside",
+		"blockquote",
+		"center",
+		"dd",
+		"details",
+		"dialog",
+		"dir",
+		"div",
+		"dl",
+		"dt",
+		"fieldset",
+		"figcaption",
+		"figure",
+		"footer",
+		"form",
+		"h1",
+		"h2",
+		"h3",
+		"h4",
+		"h5",
+		"h6",
+		"header",
+		"hgroup",
+		"hr",
+		"li",
+		"listing",
+		"main",
+		"menu",
+		"nav",
+		"ol",
+		"p",
+		"plaintext",
+		"pre",
+		"search",
+		"section",
+		"summary",
+		"table",
+		"ul",
+		"xmp"
+	]) }],
+	["a", { descendants: /* @__PURE__ */ new Set(["a"]) }],
+	["button", { descendants: /* @__PURE__ */ new Set(["button"]) }],
+	["li", {
+		descendants: /* @__PURE__ */ new Set(["li"]),
+		barriers: HTML_LIST_ITEM_SCAN_BARRIERS
+	}],
+	["dt", {
+		descendants: /* @__PURE__ */ new Set(["dt", "dd"]),
+		barriers: HTML_LIST_ITEM_SCAN_BARRIERS
+	}],
+	["dd", {
+		descendants: /* @__PURE__ */ new Set(["dt", "dd"]),
+		barriers: HTML_LIST_ITEM_SCAN_BARRIERS
+	}],
+	["nobr", { descendants: /* @__PURE__ */ new Set(["nobr"]) }],
+	["form", { descendants: /* @__PURE__ */ new Set(["form"]) }],
+	["caption", {
+		descendants: /* @__PURE__ */ new Set([
+			"caption",
+			"col",
+			"colgroup",
+			"tbody",
+			"td",
+			"tfoot",
+			"th",
+			"thead",
+			"tr"
+		]),
+		barriers: /* @__PURE__ */ new Set(["table"])
+	}],
+	["td", {
+		descendants: /* @__PURE__ */ new Set([
+			"caption",
+			"col",
+			"colgroup",
+			"tbody",
+			"td",
+			"tfoot",
+			"th",
+			"thead",
+			"tr"
+		]),
+		barriers: /* @__PURE__ */ new Set(["table"])
+	}],
+	["th", {
+		descendants: /* @__PURE__ */ new Set([
+			"caption",
+			"col",
+			"colgroup",
+			"tbody",
+			"td",
+			"tfoot",
+			"th",
+			"thead",
+			"tr"
+		]),
+		barriers: /* @__PURE__ */ new Set(["table"])
+	}]
+]);
+const STREAM_BOUNDARY_START_PREFIX = "fict:suspense-start:";
+const STREAM_BOUNDARY_END_PREFIX = "fict:suspense-end:";
+const SCRIPT_SUPPORTING_ELEMENTS = ["script", "template"];
+const HTML_STREAM_BOUNDARY_ALLOWED_CHILDREN = /* @__PURE__ */ new Map([
+	["table", /* @__PURE__ */ new Set([
+		"caption",
+		"colgroup",
+		"tbody",
+		"tfoot",
+		"thead",
+		...SCRIPT_SUPPORTING_ELEMENTS
+	])],
+	["tbody", /* @__PURE__ */ new Set(["tr", ...SCRIPT_SUPPORTING_ELEMENTS])],
+	["thead", /* @__PURE__ */ new Set(["tr", ...SCRIPT_SUPPORTING_ELEMENTS])],
+	["tfoot", /* @__PURE__ */ new Set(["tr", ...SCRIPT_SUPPORTING_ELEMENTS])],
+	["tr", /* @__PURE__ */ new Set([
+		"td",
+		"th",
+		...SCRIPT_SUPPORTING_ELEMENTS
+	])],
+	["colgroup", /* @__PURE__ */ new Set(["col", "template"])],
+	["select", /* @__PURE__ */ new Set([
+		"hr",
+		"optgroup",
+		"option",
+		...SCRIPT_SUPPORTING_ELEMENTS
+	])],
+	["optgroup", /* @__PURE__ */ new Set(["option", ...SCRIPT_SUPPORTING_ELEMENTS])],
+	["option", /* @__PURE__ */ new Set()]
+]);
+const HTML_STREAM_BOUNDARY_TEXT_CONTEXTS = /* @__PURE__ */ new Set([
+	"option",
+	"optgroup",
+	"select"
+]);
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const CDATA_SECTION_NODE = 4;
+const PROCESSING_INSTRUCTION_NODE = 7;
+const COMMENT_NODE = 8;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_TYPE_NODE = 10;
+const DOCUMENT_FRAGMENT_NODE = 11;
+/**
+* Serialize a DOM subtree as HTML without relying on the host DOM's
+* `innerHTML`/`outerHTML` implementation. Some lightweight server DOMs do not
+* escape ampersands in attributes or matching end tags in raw-text elements,
+* so their output can produce a different (and unsafe) tree when a browser
+* parses it again.
+*/
+function serializeHtmlNode(node, parentElement = null) {
+	switch (node.nodeType) {
+		case ELEMENT_NODE: return serializeElement(node, parentElement);
+		case TEXT_NODE:
+		case CDATA_SECTION_NODE: return serializeText(node.nodeValue ?? "", parentElement);
+		case COMMENT_NODE: return serializeComment(node.nodeValue ?? "");
+		case DOCUMENT_NODE:
+		case DOCUMENT_FRAGMENT_NODE: return serializeHtmlChildren(node);
+		case DOCUMENT_TYPE_NODE: return serializeDocumentType(node);
+		case PROCESSING_INSTRUCTION_NODE: return serializeComment(`?${node.nodeName} ${node.nodeValue ?? ""}?`);
+		default: return "";
+	}
+}
+function serializeHtmlChildren(parent) {
+	const parentElement = parent.nodeType === ELEMENT_NODE ? parent : null;
+	return serializeHtmlNodes(parent.childNodes, parentElement);
+}
+function serializeHtmlNodes(nodes, parentElement = null) {
+	if (parentElement && isHtmlElement(parentElement)) assertSafeStreamingBoundaryContext(parentElement, (parentElement.localName || parentElement.tagName).toLowerCase());
+	let html = "";
+	for (const node of nodes) html += serializeHtmlNode(node, parentElement);
+	const rawTextTagName = getRawTextTagName(parentElement);
+	return rawTextTagName ? escapeRawTextEndTag(html, rawTextTagName) : html;
+}
+function serializeElement(element, serializedParent) {
+	const localName = element.localName || element.tagName;
+	const tagName = element.prefix ? `${element.prefix}:${localName}` : localName;
+	const isHtml = isHtmlElement(element);
+	const normalizedTagName = tagName.toLowerCase();
+	assertSafeResumableHostContext(element, serializedParent);
+	if (isHtml && normalizedTagName === "plaintext") throw new Error("[fict/ssr] Cannot serialize HTML <plaintext>. The HTML syntax has no closing tag for this element, so a browser would consume every following tag, ancestor closing tag, and snapshot script as text. Use <pre> for preformatted HTML content or return a text/plain response instead.");
+	assertValidDOMElementName(tagName, !isHtml, isHtml ? void 0 : element.namespaceURI);
+	let html = `<${tagName}`;
+	for (const attribute of Array.from(element.attributes)) {
+		assertValidDOMAttributeName(attribute.name, attribute.namespaceURI != null, attribute.namespaceURI ?? void 0);
+		html += ` ${attribute.name}="${escapeAttributeValue(attribute.value)}"`;
+	}
+	if (isHtml && HTML_VOID_ELEMENTS.has(normalizedTagName)) {
+		assertEmptyHtmlVoidElement(element, normalizedTagName);
+		return `${html}>`;
+	}
+	html += ">";
+	const childSource = isHtml && normalizedTagName === "template" && "content" in element ? element.content ?? element : element;
+	if (childSource !== element) assertSafeTemplateContent(childSource);
+	html += serializeHtmlChildren(childSource);
+	if (isHtml && (HTML_RAW_TEXT_ELEMENTS.has(normalizedTagName) || HTML_RCDATA_ELEMENTS.has(normalizedTagName))) assertTextOnlyHtmlChildren(childSource, normalizedTagName);
+	html += `</${tagName}>`;
+	return html;
+}
+function assertTextOnlyHtmlChildren(element, tagName) {
+	for (const child of Array.from(element.childNodes)) {
+		if (child.nodeType === TEXT_NODE || child.nodeType === CDATA_SECTION_NODE) continue;
+		const childDescription = child.nodeType === ELEMENT_NODE ? `<${(child.localName || child.tagName).toLowerCase()}>` : child.nodeType === COMMENT_NODE ? "a comment" : `a ${child.nodeName || `nodeType ${child.nodeType}`} node`;
+		throw new Error(`[fict/ssr] Cannot serialize HTML <${tagName}> with ${childDescription} child. The HTML parser treats this element's contents as text, so non-text DOM nodes cannot round-trip and would silently disappear. Provide string/textContent content instead.`);
+	}
+}
+function assertEmptyHtmlVoidElement(element, tagName) {
+	const childCount = element.childNodes.length;
+	if (childCount === 0) return;
+	const discardedResumableState = describeDiscardedResumableFeature(findResumableFeature(element));
+	throw new Error(`[fict/ssr] Cannot serialize <${tagName}> with ${childCount} child node${childCount === 1 ? "" : "s"}. HTML void elements cannot contain children, and browsers omit every child when serializing or parsing <${tagName}>.${discardedResumableState} Remove all children from <${tagName}> and move the content outside the void element.`);
+}
+function assertSafeStreamingBoundaryContext(element, contextTag) {
+	if (HTML_TEXT_ONLY_ELEMENTS.has(contextTag)) {
+		const marker = findStreamingBoundaryMarker(element);
+		if (!marker) return;
+		throw new Error(`[fict/ssr] Cannot serialize a streaming Suspense boundary inside <${contextTag}>. The HTML parser treats its comment markers as text in this context, so the streamed patch can never find boundary ${JSON.stringify(marker.id)}. Move the streaming boundary outside <${contextTag}> and update this element through an outer component.`);
+	}
+	const allowedChildren = HTML_STREAM_BOUNDARY_ALLOWED_CHILDREN.get(contextTag);
+	if (!allowedChildren) return;
+	const children = Array.from(element.childNodes);
+	for (let index = 0; index < children.length; index++) {
+		const start = parseStreamingBoundaryMarker(children[index]);
+		if (start?.kind !== "start") continue;
+		let endIndex = index + 1;
+		while (endIndex < children.length) {
+			const end = parseStreamingBoundaryMarker(children[endIndex]);
+			if (end?.kind === "end" && end.id === start.id) break;
+			endIndex++;
+		}
+		if (endIndex === children.length) throw new Error(`[fict/ssr] Cannot serialize streaming Suspense boundary ${JSON.stringify(start.id)} inside <${contextTag}> because its sibling end marker is missing.`);
+		for (let contentIndex = index + 1; contentIndex < endIndex; contentIndex++) {
+			const invalidContent = describeInvalidBoundaryContent(children[contentIndex], allowedChildren, HTML_STREAM_BOUNDARY_TEXT_CONTEXTS.has(contextTag));
+			if (!invalidContent) continue;
+			throw new Error(`[fict/ssr] Cannot serialize a streaming Suspense boundary inside <${contextTag}> with direct ${invalidContent} content. The HTML parser reparents or discards that content, so the boundary markers no longer describe one patchable sibling range. ` + getStreamingBoundaryRewriteSuggestion(contextTag, invalidContent));
+		}
+	}
+}
+function describeInvalidBoundaryContent(node, allowedElements, allowText) {
+	if (node.nodeType === COMMENT_NODE) return null;
+	if (node.nodeType === TEXT_NODE || node.nodeType === CDATA_SECTION_NODE) return allowText || !(node.nodeValue ?? "").trim() ? null : "non-whitespace text";
+	if (node.nodeType !== ELEMENT_NODE) return `node type ${node.nodeType}`;
+	const element = node;
+	const tagName = (element.localName || element.tagName).toLowerCase();
+	return isHtmlElement(element) && allowedElements.has(tagName) ? null : `<${tagName}>`;
+}
+function getStreamingBoundaryRewriteSuggestion(contextTag, invalidContent) {
+	if (contextTag === "table" && invalidContent === "<tr>") return "Wrap the boundary and rows in an explicit <tbody>.";
+	if (contextTag === "table" && invalidContent === "<col>") return "Wrap the boundary and columns in an explicit <colgroup>.";
+	if (HTML_TABLE_SECTION_ELEMENTS.has(contextTag)) return `Wrap cells in a native <tr>, or move the boundary outside <${contextTag}>.`;
+	if (contextTag === "tr") return "Render only native <td> or <th> roots inside this boundary.";
+	if (contextTag === "colgroup") return "Render only native <col> roots inside this boundary.";
+	if (contextTag === "select" || contextTag === "optgroup" || contextTag === "option") return "Use only portable native option content, or move the boundary outside <select>.";
+	return `Move the boundary outside <${contextTag}> or wrap its content in a parser-stable native container.`;
+}
+function assertSafeResumableHostContext(element, serializedParent) {
+	if (!isResumableFictHost(element)) return;
+	const foreignNamespace = getResumableHostForeignNamespace(element, serializedParent);
+	if (foreignNamespace) {
+		const scopeId = element.getAttribute("data-fict-s") ?? "<unknown>";
+		const namespaceDescription = foreignNamespace.kind === "other" ? `foreign namespace ${JSON.stringify(foreignNamespace.uri)}` : `the ${foreignNamespace.kind} namespace`;
+		const semanticRisk = foreignNamespace.kind === "SVG" ? "A custom element wrapper is not structurally transparent in SVG and can suppress the graphics it contains after HTML parsing." : foreignNamespace.kind === "MathML" ? "A custom element wrapper is not structurally transparent in MathML and can replace the intended operands of fixed-arity layout elements after HTML parsing." : "A custom element wrapper is not guaranteed to be structurally transparent in foreign content after HTML parsing.";
+		throw new Error(`[fict/ssr] Cannot serialize resumable <fict-host> scope ${JSON.stringify(scopeId)} in ${namespaceDescription}. ${semanticRisk} Range-based scope anchors (range-v3) are required for resumable components in foreign content; move the component boundary outside the foreign-content subtree until that protocol is available.`);
+	}
+	const parent = serializedParent ?? element.parentElement;
+	if (!parent || !isHtmlElement(parent)) return;
+	const contextTag = (parent.localName || parent.tagName).toLowerCase();
+	if (HTML_UNSAFE_RESUMABLE_HOST_PARENTS.has(contextTag)) {
+		const scopeId = element.getAttribute("data-fict-s") ?? "<unknown>";
+		throw new Error(`[fict/ssr] Cannot serialize resumable <fict-host> scope ${JSON.stringify(scopeId)} inside <${contextTag}>. The HTML parser will not preserve that host at this location, so its scope would target different DOM after parsing. ` + getResumableHostRewriteSuggestion(contextTag));
+	}
+	assertSafeHostParserStateContext(element, parent);
+	assertSafeHostSensitiveHtmlContext(element, contextTag);
+}
+function isResumableFictHost(element) {
+	return (element.localName || element.tagName).toLowerCase() === "fict-host" && element.hasAttribute("data-fict-host") && !!element.getAttribute("data-fict-s");
+}
+function assertSafeHostParserStateContext(host, parent) {
+	let ancestor = parent;
+	while (ancestor) {
+		if (isHtmlElement(ancestor)) {
+			const contextTag = (ancestor.localName || ancestor.tagName).toLowerCase();
+			const rule = HTML_PARSER_SENSITIVE_HOST_CONTEXTS.get(contextTag);
+			if (rule) {
+				const sensitiveTag = findParserSensitiveDescendant(host, rule);
+				if (sensitiveTag) {
+					const scopeId = host.getAttribute("data-fict-s") ?? "<unknown>";
+					throw new Error(`[fict/ssr] Cannot serialize resumable <fict-host> scope ${JSON.stringify(scopeId)} inside <${contextTag}> with descendant <${sensitiveTag}>. The HTML parser applies <${sensitiveTag}> start-tag rules outside the custom-element boundary, so it will close or reparent the ancestor, eject content from the host, or discard the component root. Move the component boundary outside <${contextTag}>, or make the component own that element. Range-based scope anchors (range-v3) are required to preserve this boundary without an element wrapper.`);
+				}
+			}
+		}
+		ancestor = ancestor.parentElement;
+	}
+}
+function findParserSensitiveDescendant(host, rule) {
+	const pending = Array.from(host.children);
+	while (pending.length > 0) {
+		const element = pending.shift();
+		if (!isHtmlElement(element)) continue;
+		const tagName = (element.localName || element.tagName).toLowerCase();
+		if (rule.descendants.has(tagName)) return tagName;
+		if (tagName === "template" || tagName === "svg" || tagName === "math" || HTML_TEXT_ONLY_ELEMENTS.has(tagName) || rule.barriers?.has(tagName)) continue;
+		pending.unshift(...Array.from(element.children));
+	}
+	return null;
+}
+function assertSafeHostSensitiveHtmlContext(host, contextTag) {
+	let sensitiveDescription;
+	if (contextTag === "picture") sensitiveDescription = "the native <source> and <img> structure";
+	else {
+		const sensitiveTags = HTML_HOST_SENSITIVE_CONTEXT_CHILDREN.get(contextTag);
+		if (!sensitiveTags) return;
+		const sensitiveTag = findTransparentDirectChildTag(host, sensitiveTags);
+		if (!sensitiveTag) return;
+		sensitiveDescription = `a transparent direct <${sensitiveTag}> child`;
+	}
+	const scopeId = host.getAttribute("data-fict-s") ?? "<unknown>";
+	throw new Error(`[fict/ssr] Cannot serialize resumable <fict-host> scope ${JSON.stringify(scopeId)} as a component boundary inside <${contextTag}> around ${sensitiveDescription}. ${getHostSensitiveContextRisk(contextTag)} CSS display: contents removes only the host's box; it does not make the host transparent to these DOM rules. Move the component boundary outside <${contextTag}> and make the component own <${contextTag}>, so its sensitive content remains native direct children. Range-based scope anchors (range-v3) are required to keep a resumable boundary at this position without an element wrapper.`);
+}
+function findTransparentDirectChildTag(host, sensitiveTags) {
+	for (const child of Array.from(host.children)) {
+		if (!isHtmlElement(child)) continue;
+		if (isResumableFictHost(child)) {
+			const nestedTag = findTransparentDirectChildTag(child, sensitiveTags);
+			if (nestedTag) return nestedTag;
+			continue;
+		}
+		const childTag = (child.localName || child.tagName).toLowerCase();
+		if (sensitiveTags.has(childTag)) return childTag;
+	}
+	return null;
+}
+function getHostSensitiveContextRisk(contextTag) {
+	switch (contextTag) {
+		case "picture": return "Browsers select picture candidates from its direct <source>/<img> structure, so a wrapper can silently select the fallback image.";
+		case "details": return "Only a direct <summary> child provides the native disclosure control, so wrapping it prevents activation from toggling <details>.";
+		case "fieldset": return "A direct <legend> supplies the fieldset name and its first-legend disabled-state exemption, both of which a wrapper removes.";
+		case "audio":
+		case "video": return `Browsers discover <source> and <track> from direct <${contextTag}> children, so wrapped media resources and text tracks are ignored.`;
+		case "ruby": return "Ruby annotation layout depends on direct <rt>/<rp> structure, and wrappers cause annotations to render as ordinary inline content in some browsers.";
+		case "figure": return "A direct <figcaption> provides the accessible name of <figure>, which is lost through a wrapper.";
+		case "map": return "Browser image-map and areas-collection behavior diverges when <area> is hidden behind a wrapper.";
+		default: return "This HTML context assigns semantics through native direct-child relationships that an element wrapper changes.";
+	}
+}
+function getResumableHostForeignNamespace(element, serializedParent) {
+	const directNamespace = classifyForeignNamespace(element.namespaceURI);
+	if (directNamespace) return directNamespace;
+	let ancestor = serializedParent ?? element.parentElement;
+	let descendantLocalName = null;
+	while (ancestor) {
+		const localName = (ancestor.localName || ancestor.tagName).toLowerCase();
+		if (localName === "foreignobject" || localName === "title" || localName === "desc") return null;
+		if (localName === "mi" || localName === "mo" || localName === "mn" || localName === "ms" || localName === "mtext") {
+			if (MATHML_TEXT_INTEGRATION_EXCEPTIONS.has(descendantLocalName ?? "") || findTransparentDirectRootTag(element, MATHML_TEXT_INTEGRATION_EXCEPTIONS)) return { kind: "MathML" };
+			return null;
+		}
+		if (localName === "annotation-xml") {
+			const encoding = ancestor.getAttribute("encoding")?.toLowerCase();
+			if (encoding === "text/html" || encoding === "application/xhtml+xml") return null;
+		}
+		const ancestorNamespace = classifyForeignNamespace(ancestor.namespaceURI);
+		if (ancestorNamespace) return ancestorNamespace;
+		if (localName === "svg") return { kind: "SVG" };
+		if (localName === "math") return { kind: "MathML" };
+		descendantLocalName = localName;
+		ancestor = ancestor.parentElement;
+	}
+	return null;
+}
+function findTransparentDirectRootTag(host, tagNames) {
+	for (const child of Array.from(host.children)) {
+		if (isResumableFictHost(child)) {
+			const nestedTag = findTransparentDirectRootTag(child, tagNames);
+			if (nestedTag) return nestedTag;
+			continue;
+		}
+		const childTag = (child.localName || child.tagName).toLowerCase();
+		if (tagNames.has(childTag)) return childTag;
+	}
+	return null;
+}
+function classifyForeignNamespace(namespaceURI) {
+	if (namespaceURI === null || namespaceURI === HTML_NAMESPACE) return null;
+	if (namespaceURI === SVG_NAMESPACE) return { kind: "SVG" };
+	if (namespaceURI === MATHML_NAMESPACE) return { kind: "MathML" };
+	return {
+		kind: "other",
+		uri: namespaceURI
+	};
+}
+function getResumableHostRewriteSuggestion(contextTag) {
+	if (contextTag === "table") return "Move the component outside <table>, or make it own the complete table while keeping table sections as native elements.";
+	if (HTML_TABLE_SECTION_ELEMENTS.has(contextTag)) return "Move the component into a native <td> or <th> within the row, or move its resumable boundary outside the table.";
+	if (contextTag === "tr") return "Move the component inside a native <td> or <th>, rather than using a component as a direct row child.";
+	if (contextTag === "colgroup") return "Move the component outside <colgroup>, or make it own the complete table and render <col> elements natively.";
+	if (contextTag === "select" || contextTag === "optgroup" || contextTag === "option") return "Move the component outside <select>, or make it own the complete select while rendering option structure natively.";
+	if (HTML_TEXT_ONLY_ELEMENTS.has(contextTag)) return `Move the component outside <${contextTag}> and make it own that element; bind its value or text content instead of nesting a component inside it.`;
+	return "Move the component into <body> content, outside document-structure elements.";
+}
+function describeDiscardedResumableFeature(feature) {
+	if (!feature) return "";
+	if (feature.kind === "scope") return ` The discarded children contain a resumable scope (${feature.detail}), which would leave orphaned snapshot state.`;
+	if (feature.kind === "event") return ` The discarded children contain a resumable event (${feature.detail}), which would disappear from the parsed document.`;
+	return ` The discarded children contain a streaming Suspense boundary (${feature.detail}), which would leave an unpatchable stream.`;
+}
+function assertSafeTemplateContent(content) {
+	const feature = findResumableFeature(content);
+	if (!feature) return;
+	if (feature.kind === "boundary") throw new Error(`[fict/ssr] Cannot serialize <template> content containing a streaming Suspense boundary (${feature.detail}). Native template content can be cloned more than once, which duplicates the stream boundary id and makes patch targeting ambiguous. Move the streaming boundary outside <template>.`);
+	const label = feature.kind === "scope" ? "resumable scope" : "resumable event";
+	throw new Error(`[fict/ssr] Cannot serialize <template> content containing a ${label} (${feature.detail}). Native template content can be cloned more than once, but the current resumability protocol assigns only one runtime scope to each server scope id. Move the resumable component or event outside <template>.`);
+}
+function findResumableFeature(root) {
+	for (const child of Array.from(root.childNodes)) {
+		const boundary = parseStreamingBoundaryMarker(child);
+		if (boundary) return {
+			kind: "boundary",
+			detail: `${boundary.kind} id ${JSON.stringify(boundary.id)}`
+		};
+		if (child.nodeType !== ELEMENT_NODE) continue;
+		const element = child;
+		const scopeId = element.getAttribute("data-fict-s");
+		if (scopeId) return {
+			kind: "scope",
+			detail: `data-fict-s=${JSON.stringify(scopeId)}`
+		};
+		const resumeQrl = element.getAttribute("data-fict-h");
+		if (resumeQrl) return {
+			kind: "scope",
+			detail: `data-fict-h=${JSON.stringify(resumeQrl)}`
+		};
+		for (const attribute of Array.from(element.attributes)) if (attribute.value && attribute.name.startsWith("on:") && attribute.name.length > 3) return {
+			kind: "event",
+			detail: attribute.name
+		};
+		const nested = findResumableFeature(isHtmlElement(element) && (element.localName || element.tagName).toLowerCase() === "template" && "content" in element ? element.content ?? element : element);
+		if (nested) return nested;
+	}
+	return null;
+}
+function findStreamingBoundaryMarker(root) {
+	for (const child of Array.from(root.childNodes)) {
+		const marker = parseStreamingBoundaryMarker(child);
+		if (marker) return marker;
+		if (child.nodeType !== ELEMENT_NODE) continue;
+		const element = child;
+		const nested = findStreamingBoundaryMarker(isHtmlElement(element) && (element.localName || element.tagName).toLowerCase() === "template" && "content" in element ? element.content ?? element : element);
+		if (nested) return nested;
+	}
+	return null;
+}
+function parseStreamingBoundaryMarker(node) {
+	if (!node || node.nodeType !== COMMENT_NODE) return null;
+	const value = node.nodeValue ?? "";
+	if (value.startsWith(STREAM_BOUNDARY_START_PREFIX)) {
+		const id = value.slice(20);
+		return id ? {
+			kind: "start",
+			id
+		} : null;
+	}
+	if (value.startsWith(STREAM_BOUNDARY_END_PREFIX)) {
+		const id = value.slice(18);
+		return id ? {
+			kind: "end",
+			id
+		} : null;
+	}
+	return null;
+}
+function serializeText(value, parentElement) {
+	const rawTextTagName = getRawTextTagName(parentElement);
+	if (rawTextTagName) return escapeRawTextEndTag(value, rawTextTagName);
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeRawTextEndTag(value, tagName) {
+	const endTag = new RegExp(`</${tagName}(?=[\\t\\n\\f\\r />])`, "gi");
+	return value.replace(endTag, (match) => `<\\/${match.slice(2)}`);
+}
+function escapeAttributeValue(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializeComment(value) {
+	let safe = value.replace(/-(?=-)/g, "- ").replace(/-$/, "- ");
+	if (safe.startsWith(">") || safe.startsWith("->")) safe = ` ${safe}`;
+	return `<!--${safe}-->`;
+}
+function serializeDocumentType(doctype) {
+	const name = doctype.name || "html";
+	assertValidDOMElementName(name, true);
+	if (doctype.publicId) {
+		const system = doctype.systemId ? ` "${escapeAttributeValue(doctype.systemId)}"` : "";
+		return `<!DOCTYPE ${name} PUBLIC "${escapeAttributeValue(doctype.publicId)}"${system}>`;
+	}
+	if (doctype.systemId) return `<!DOCTYPE ${name} SYSTEM "${escapeAttributeValue(doctype.systemId)}">`;
+	return `<!DOCTYPE ${name}>`;
+}
+function isHtmlElement(element) {
+	return element.namespaceURI === null || element.namespaceURI === HTML_NAMESPACE;
+}
+function getRawTextTagName(element) {
+	if (!element || !isHtmlElement(element)) return null;
+	const tagName = (element.localName || element.tagName).toLowerCase();
+	return HTML_RAW_TEXT_ELEMENTS.has(tagName) ? tagName : null;
+}
+//#endregion
+//#region src/stream-bridge.ts
+function createQueuedTextStream(options = {}) {
+	const encoder = new TextEncoder();
+	const queue = [];
+	let controller = null;
+	let closed = false;
+	let aborted;
+	const readyResolvers = [];
+	const resolveReady = () => {
+		if (!controller || (controller.desiredSize ?? 1) <= 0) return;
+		while (readyResolvers.length > 0) readyResolvers.shift()?.();
+	};
+	const drainReady = () => {
+		while (readyResolvers.length > 0) readyResolvers.shift()?.();
+	};
+	const abortQueue = (reason, notifyController = true) => {
+		if (closed || aborted !== void 0) return;
+		aborted = reason ?? /* @__PURE__ */ new Error("Stream aborted");
+		queue.length = 0;
+		drainReady();
+		if (notifyController) controller?.error(aborted);
+	};
+	return {
+		stream: new ReadableStream({
+			start(ctrl) {
+				controller = ctrl;
+				for (const chunk of queue) ctrl.enqueue(chunk);
+				queue.length = 0;
+				if (aborted !== void 0) {
+					ctrl.error(aborted);
+					return;
+				}
+				if (closed) ctrl.close();
+			},
+			pull() {
+				resolveReady();
+			},
+			cancel(reason) {
+				abortQueue(reason, false);
+				options.onCancel?.(reason);
+			}
+		}),
+		writer: {
+			write(chunk) {
+				if (closed || aborted !== void 0) return;
+				const data = encoder.encode(chunk);
+				if (controller) {
+					controller.enqueue(data);
+					if ((controller.desiredSize ?? 1) <= 0) return new Promise((resolve) => {
+						readyResolvers.push(resolve);
+					});
+				} else queue.push(data);
+			},
+			close() {
+				if (closed || aborted !== void 0) return;
+				closed = true;
+				drainReady();
+				controller?.close();
+			},
+			abort(reason) {
+				abortQueue(reason);
+			}
+		}
+	};
+}
+function createPipeBridge() {
+	const nodeBridge = createNodePipeBridge();
+	if (nodeBridge) return nodeBridge;
+	const targets = /* @__PURE__ */ new Set();
+	const buffer = [];
+	let state = "open";
+	let abortReason = null;
+	let sinkErrorHandler;
+	const safeWrite = (target, chunk) => {
+		try {
+			if (target.write(chunk) === false) return new Promise((resolve) => {
+				const withOnce = target;
+				if (typeof withOnce.once === "function") withOnce.once("drain", resolve);
+				else resolve();
+			});
+		} catch (error) {
+			sinkErrorHandler?.(error);
+		}
+	};
+	const safeEnd = (target) => {
+		try {
+			target.end();
+		} catch {}
+	};
+	const safeDestroy = (target, reason) => {
+		const withDestroy = target;
+		if (typeof withDestroy.destroy === "function") {
+			try {
+				withDestroy.destroy(reason);
+			} catch {}
+			return;
+		}
+		safeEnd(target);
+	};
+	return {
+		pipe(writable, options) {
+			targets.add(writable);
+			if (options?.onError) {
+				sinkErrorHandler = options.onError;
+				if (typeof writable.on === "function") writable.on("error", options.onError);
+			}
+			if (buffer.length > 0) {
+				for (const chunk of buffer) safeWrite(writable, chunk);
+				buffer.length = 0;
+			}
+			if (state === "closed") safeEnd(writable);
+			else if (state === "aborted") safeDestroy(writable, abortReason ?? /* @__PURE__ */ new Error("Stream aborted"));
+		},
+		write(chunk) {
+			if (state !== "open") return;
+			if (targets.size === 0) {
+				buffer.push(chunk);
+				return;
+			}
+			const pending = [];
+			for (const target of targets) {
+				const result = safeWrite(target, chunk);
+				if (result) pending.push(result);
+			}
+			return pending.length > 0 ? Promise.all(pending).then(() => void 0) : void 0;
+		},
+		close() {
+			if (state !== "open") return;
+			state = "closed";
+			for (const target of targets) safeEnd(target);
+			if (targets.size > 0) buffer.length = 0;
+		},
+		abort(reason) {
+			if (state !== "open") return;
+			state = "aborted";
+			abortReason = reason instanceof Error ? reason : /* @__PURE__ */ new Error("Stream aborted");
+			for (const target of targets) safeDestroy(target, abortReason);
+			buffer.length = 0;
+		}
+	};
+}
+function createNodePipeBridge() {
+	const nodeRequire = getNodeRequire();
+	if (!nodeRequire) return null;
+	try {
+		const streamModule = nodeRequire("node:stream");
+		if (!streamModule.PassThrough) return null;
+		const passThrough = new streamModule.PassThrough();
+		passThrough.on?.("error", () => {});
+		const buffer = [];
+		let piped = false;
+		let state = "open";
+		let abortReason = null;
+		const pendingDrains = /* @__PURE__ */ new Set();
+		const flushDrains = () => {
+			for (const resolve of pendingDrains) resolve();
+			pendingDrains.clear();
+		};
+		const writeToPassThrough = (chunk) => {
+			if (passThrough.write(chunk) === false) return new Promise((resolve) => {
+				const settle = () => {
+					pendingDrains.delete(settle);
+					resolve();
+				};
+				pendingDrains.add(settle);
+				const withOnce = passThrough;
+				if (typeof withOnce.once === "function") withOnce.once("drain", settle);
+				else settle();
+			});
+		};
+		const flushBuffer = () => {
+			if (buffer.length === 0) return void 0;
+			const pending = [];
+			for (const chunk of buffer) {
+				const result = writeToPassThrough(chunk);
+				if (result) pending.push(result);
+			}
+			buffer.length = 0;
+			return pending.length > 0 ? Promise.all(pending).then(() => void 0) : void 0;
+		};
+		const destroyPassThrough = (error) => {
+			if (typeof passThrough.destroy === "function") passThrough.destroy(error);
+			else passThrough.end();
+		};
+		return {
+			pipe(writable, options) {
+				piped = true;
+				passThrough.pipe(writable);
+				const onError = options?.onError;
+				if (onError && typeof writable.on === "function") writable.on("error", (err) => {
+					flushDrains();
+					onError(err);
+				});
+				if (state === "aborted") {
+					destroyPassThrough(abortReason ?? /* @__PURE__ */ new Error("Stream aborted"));
+					return;
+				}
+				const flushed = flushBuffer();
+				if (state === "closed") if (flushed) flushed.then(() => passThrough.end());
+				else passThrough.end();
+			},
+			write(chunk) {
+				if (state !== "open") return;
+				if (!piped) {
+					buffer.push(chunk);
+					return;
+				}
+				return writeToPassThrough(chunk);
+			},
+			close() {
+				if (state !== "open") return;
+				state = "closed";
+				if (!piped) return;
+				passThrough.end();
+			},
+			abort(reason) {
+				if (state !== "open") return;
+				state = "aborted";
+				abortReason = reason instanceof Error ? reason : /* @__PURE__ */ new Error("Stream aborted");
+				buffer.length = 0;
+				flushDrains();
+				if (piped) destroyPassThrough(abortReason);
+			}
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/render-core.ts
+const DEFAULT_HTML = "<!doctype html><html><head></head><body></body></html>";
+const SVG_HTML_INTEGRATION_POINTS = /* @__PURE__ */ new Set([
+	"foreignobject",
+	"title",
+	"desc"
+]);
+const MATHML_TEXT_INTEGRATION_POINTS = /* @__PURE__ */ new Set([
+	"mi",
+	"mo",
+	"mn",
+	"ms",
+	"mtext"
+]);
+const IDENTIFIER_PREFIX_PATTERN = /^[A-Za-z0-9_.:-]+$/;
+let streamTailMarkerId = 0;
+let scopeIdentifierSequence = 0;
+let streamIdentifierSequence = 0;
+const ssrIdentifierSeed = createIdentifierSeed();
+function createSSRDocument(html = DEFAULT_HTML) {
+	const window = parseHTML(html);
+	const document = window.document;
+	if (!window || !document) throw new Error("[fict/ssr] Failed to create DOM. Missing window or document.");
+	return {
+		window,
+		document
+	};
+}
+function renderToDocument(view, options = {}) {
+	return __fictRunWithSSRSession(__fictCreateSSRSession(), () => renderToDocumentInSession(view, options));
+}
+function renderToDocumentInSession(view, options) {
+	validateScopeIdentifierPrefix(options.scopeIdentifierPrefix);
+	const scopeIdentifierPrefix = resolveScopeIdentifierPrefix(options.scopeIdentifierPrefix);
+	const includeSnapshot = options.includeSnapshot !== false;
+	__fictEnableSSR();
+	__fictSetSSRScopeIdentifierPrefix(scopeIdentifierPrefix);
+	let dom;
+	let restoreGlobals = () => {};
+	let restoreManifest = () => {};
+	let container;
+	let teardown = () => {};
+	try {
+		dom = resolveDom(options);
+		const { document, window } = dom;
+		restoreGlobals = options.exposeGlobals === true ? installGlobals(window, document) : () => {};
+		restoreManifest = installManifest(options.manifest);
+		container = resolveContainer(document, options);
+		teardown = render(view, container);
+		if (includeSnapshot) {
+			const state = __fictSerializeSSRState();
+			injectSnapshot(document, container, state, options);
+		}
+	} catch (error) {
+		__fictDisableSSR();
+		cleanupRenderResources(teardown, restoreGlobals, restoreManifest, true);
+		throw error;
+	}
+	__fictDisableSSR();
+	let html;
+	try {
+		html = serializeOutput(dom.document, container, options);
+	} catch (error) {
+		cleanupRenderResources(teardown, restoreGlobals, restoreManifest, true);
+		throw error;
+	}
+	const dispose = () => cleanupRenderResources(teardown, restoreGlobals, restoreManifest, false);
+	return {
+		html,
+		document: dom.document,
+		window: dom.window,
+		container,
+		dispose
+	};
+}
+function renderToString(view, options = {}) {
+	const result = renderToDocument(view, options);
+	const html = result.html;
+	result.dispose();
+	return html;
+}
+async function renderToStringAsync(view, options = {}) {
+	let html = "";
+	const renderResult = startStreamingRender(view, {
+		...options,
+		mode: "all",
+		fullDocument: options.fullDocument ?? false
+	}, {
+		write(chunk) {
+			html += chunk;
+		},
+		close() {},
+		abort() {}
+	});
+	await Promise.all([renderResult.shellReady, renderResult.allReady]);
+	return html;
+}
+function renderToStream(view, options = {}) {
+	validateScopeIdentifierPrefix(options.scopeIdentifierPrefix);
+	validateStreamIdentifierPrefix(options.streamIdentifierPrefix);
+	const encoder = new TextEncoder();
+	let controller = null;
+	let abortRender = null;
+	const readyResolvers = [];
+	const drainBackpressure = () => {
+		while (readyResolvers.length > 0) readyResolvers.shift()?.();
+	};
+	const resolveBackpressure = () => {
+		if (!controller || (controller.desiredSize ?? 1) <= 0) return;
+		drainBackpressure();
+	};
+	const closeController = () => {
+		abortRender = null;
+		drainBackpressure();
+		if (!controller) return;
+		try {
+			controller.close();
+		} finally {
+			controller = null;
+		}
+	};
+	const errorController = (reason) => {
+		abortRender = null;
+		drainBackpressure();
+		if (!controller) return;
+		try {
+			controller.error(reason);
+		} finally {
+			controller = null;
+		}
+	};
+	return new ReadableStream({
+		start(ctrl) {
+			controller = ctrl;
+			const started = startStreamingRender(view, options, {
+				write(chunk) {
+					if (!controller) return;
+					controller.enqueue(encoder.encode(chunk));
+					if ((controller.desiredSize ?? 1) <= 0) return new Promise((resolve) => {
+						readyResolvers.push(resolve);
+					});
+				},
+				close() {
+					closeController();
+				},
+				abort(reason) {
+					errorController(reason);
+				}
+			});
+			abortRender = started.abort;
+			started.shellReady.catch(() => void 0);
+			started.allReady.catch(() => void 0);
+		},
+		pull() {
+			resolveBackpressure();
+		},
+		cancel(reason) {
+			const abort = abortRender;
+			controller = null;
+			drainBackpressure();
+			abort?.(reason ?? /* @__PURE__ */ new Error("Stream canceled"));
+		}
+	});
+}
+function renderToPipeableStream(view, options = {}) {
+	const bridge = createPipeBridge();
+	const { shellReady, allReady, abort } = startStreamingRender(view, options, {
+		write(chunk) {
+			return bridge.write(chunk);
+		},
+		close() {
+			bridge.close();
+		},
+		abort(reason) {
+			bridge.abort(reason);
+		}
+	});
+	return {
+		pipe(writable) {
+			bridge.pipe(writable, { onError: abort });
+		},
+		abort,
+		shellReady,
+		allReady
+	};
+}
+/**
+* @experimental Preview API for v1.0; the return shape may change before this
+* becomes stable.
+*/
+function renderToPartial(view, options = {}) {
+	const partialOptions = {
+		...options,
+		mode: "shell",
+		fullDocument: options.fullDocument ?? true
+	};
+	let shell = "";
+	let shellPhase = true;
+	let abortPartial = null;
+	const queued = createQueuedTextStream({ onCancel(reason) {
+		abortPartial?.(reason ?? /* @__PURE__ */ new Error("Stream canceled"));
+	} });
+	const { shellReady, allReady, abort } = startStreamingRender(view, partialOptions, {
+		write(chunk) {
+			if (shellPhase) {
+				shell += chunk;
+				return;
+			}
+			return queued.writer.write(chunk);
+		},
+		close() {
+			queued.writer.close();
+		},
+		abort(reason) {
+			queued.writer.abort(reason);
+		}
+	}, {
+		includeTailInShell: true,
+		onShellFlushed() {
+			shellPhase = false;
+		}
+	});
+	abortPartial = abort;
+	return {
+		shell,
+		stream: queued.stream,
+		shellReady,
+		allReady,
+		abort
+	};
+}
+function resolveDom(options) {
+	if (options.dom) return options.dom;
+	if (options.document && options.window) return {
+		document: options.document,
+		window: options.window
+	};
+	if (options.document) {
+		const window = options.window ?? options.document.defaultView ?? options.document.defaultView ?? void 0;
+		if (!window) throw new Error("[fict/ssr] A window is required when providing a document without defaultView.");
+		return {
+			document: options.document,
+			window
+		};
+	}
+	if (options.window) return {
+		document: options.window.document,
+		window: options.window
+	};
+	return createSSRDocument(options.html);
+}
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function cleanupRenderResources(teardown, restoreGlobals, restoreManifest, suppressErrors) {
+	let failed = false;
+	let firstError;
+	for (const cleanup of [
+		teardown,
+		restoreGlobals,
+		restoreManifest
+	]) try {
+		cleanup();
+	} catch (error) {
+		if (!failed) {
+			failed = true;
+			firstError = error;
+		}
+	}
+	if (failed && !suppressErrors) throw firstError;
+}
+function startStreamingRender(view, options, writer, control = {}) {
+	const session = __fictCreateSSRSession();
+	const releaseSession = __fictRetainSSRSession();
+	try {
+		return __fictRunWithSSRSession(session, () => startStreamingRenderInSession(session, view, options, writer, releaseSession, control));
+	} catch (error) {
+		releaseSession();
+		throw error;
+	}
+}
+function startStreamingRenderInSession(session, view, options, writer, releaseSession, control = {}) {
+	const runInSession = (fn) => __fictRunWithSSRSession(session, fn);
+	const resolvedOptions = {
+		...options,
+		fullDocument: options.fullDocument ?? true
+	};
+	let resolveShell;
+	let rejectShell;
+	let resolveAll;
+	let rejectAll;
+	let shellSettled = false;
+	const shellReady = new Promise((res, rej) => {
+		resolveShell = () => {
+			if (shellSettled) return;
+			shellSettled = true;
+			res();
+		};
+		rejectShell = (err) => {
+			if (shellSettled) return;
+			shellSettled = true;
+			rej(err);
+		};
+	});
+	const allReady = new Promise((res, rej) => {
+		resolveAll = res;
+		rejectAll = rej;
+	});
+	let dom = null;
+	let restoreGlobals = () => {};
+	let restoreManifest = () => {};
+	let teardown = () => {};
+	let container = null;
+	let closed = false;
+	let tailHtml = "";
+	let wroteShell = false;
+	let shellCarriesTail = false;
+	let writeChain = null;
+	let writeFailed = false;
+	let failureReported = false;
+	let cleaned = false;
+	let removeAbortListener = () => {};
+	let canFinalize = false;
+	validateScopeIdentifierPrefix(options.scopeIdentifierPrefix);
+	validateStreamIdentifierPrefix(options.streamIdentifierPrefix);
+	const mode = options.mode ?? "shell";
+	const scopeIdentifierPrefix = resolveScopeIdentifierPrefix(options.scopeIdentifierPrefix);
+	const streamIdentifierPrefix = mode === "shell" ? resolveStreamIdentifierPrefix(options.streamIdentifierPrefix) : null;
+	const includeSnapshot = options.includeSnapshot !== false;
+	const sentScopeSnapshots = /* @__PURE__ */ new Map();
+	const boundaryMap = /* @__PURE__ */ new Map();
+	let boundaryId = 0;
+	let pendingCount = 0;
+	const handleWriteError = (error) => {
+		if (writeFailed) return;
+		reportErrorAndAbort(error);
+	};
+	const enqueueWrite = (chunk) => {
+		if (writeFailed) return;
+		const trackWrite = (promise) => {
+			const tracked = promise.then(() => {
+				if (writeChain === tracked) writeChain = null;
+			}, (error) => {
+				if (writeChain === tracked) writeChain = null;
+				handleWriteError(error);
+			});
+			writeChain = tracked;
+		};
+		const writeAsync = () => Promise.resolve(writer.write(chunk)).then(() => void 0);
+		if (writeChain) {
+			trackWrite(writeChain.then(writeAsync));
+			return;
+		}
+		try {
+			const result = writer.write(chunk);
+			if (isPromiseLike(result)) trackWrite(result.then(() => void 0, (error) => {
+				throw error;
+			}));
+		} catch (error) {
+			handleWriteError(error);
+		}
+	};
+	const afterWrites = (fn) => {
+		const pending = writeChain;
+		if (!pending) {
+			if (!writeFailed) fn();
+			return;
+		}
+		pending.then(() => {
+			if (!writeFailed) fn();
+		});
+	};
+	const markShellReady = () => {
+		afterWrites(() => {
+			try {
+				control.onShellFlushed?.();
+			} catch (error) {
+				reportErrorAndAbort(error);
+				return;
+			}
+			resolveShell();
+			callLifecycleCallback(options.onShellReady);
+		});
+	};
+	const writeSnapshotForScopes = (scopeIds) => {
+		runInSession(() => {
+			if (!includeSnapshot || scopeIds.length === 0) return;
+			const registry = __fictGetScopeRegistry();
+			const pending = Array.from(new Set(scopeIds)).filter((id) => registry.has(id));
+			if (pending.length === 0) return;
+			const snapshot = __fictSerializeSSRStateForScopes(pending);
+			const changedScopes = Object.create(null);
+			const changedSignatures = /* @__PURE__ */ new Map();
+			for (const [id, scope] of Object.entries(snapshot.scopes)) {
+				const signature = JSON.stringify(scope);
+				if (sentScopeSnapshots.get(id) === signature) continue;
+				changedScopes[id] = scope;
+				changedSignatures.set(id, signature);
+			}
+			const ids = Object.keys(changedScopes);
+			if (ids.length === 0) return;
+			const chunk = buildIncrementalSnapshotChunk({
+				...snapshot,
+				scopes: changedScopes
+			}, resolvedOptions);
+			if (chunk) enqueueWrite(chunk);
+			for (const id of ids) sentScopeSnapshots.set(id, changedSignatures.get(id));
+		});
+	};
+	const writeSnapshotForBoundary = (start, end) => {
+		runInSession(() => {
+			const scopes = collectPatchScopeIds(start, end);
+			writeSnapshotForScopes(scopes);
+		});
+	};
+	const writeRemainingSnapshots = () => {
+		runInSession(() => {
+			const scopes = Array.from(__fictGetScopeRegistry().keys());
+			writeSnapshotForScopes(scopes);
+		});
+	};
+	const cleanup = () => {
+		if (cleaned) return;
+		cleaned = true;
+		try {
+			removeAbortListener();
+		} catch {}
+		removeAbortListener = () => {};
+		try {
+			runInSession(() => {
+				__fictSetSSRStreamHooks(null);
+				__fictDisableSSR();
+			});
+		} catch {}
+		try {
+			cleanupRenderResources(teardown, restoreGlobals, restoreManifest, true);
+		} finally {
+			releaseSession();
+		}
+	};
+	const reportErrorAndAbort = (error) => {
+		if (failureReported) {
+			abort(error);
+			return;
+		}
+		failureReported = true;
+		let abortReason = error;
+		try {
+			options.onError?.(error);
+		} catch (onErrorFailure) {
+			abortReason = onErrorFailure;
+		}
+		abort(abortReason);
+	};
+	const callLifecycleCallback = (callback) => {
+		try {
+			callback?.();
+		} catch (error) {
+			reportErrorAndAbort(error);
+		}
+	};
+	const finalize = () => {
+		if (closed) return;
+		if (mode === "all" && dom && container && !wroteShell) {
+			let fullHtml;
+			try {
+				if (includeSnapshot) {
+					const snapshot = __fictSerializeSSRState();
+					injectSnapshot(dom.document, container, snapshot, resolvedOptions);
+				}
+				fullHtml = serializeOutput(dom.document, container, resolvedOptions);
+			} catch (error) {
+				reportErrorAndAbort(error);
+				return;
+			}
+			closed = true;
+			enqueueWrite(fullHtml);
+			afterWrites(() => {
+				try {
+					writer.close();
+				} catch (error) {
+					reportErrorAndAbort(error);
+					return;
+				}
+				cleanup();
+				resolveShell();
+				resolveAll();
+				callLifecycleCallback(options.onShellReady);
+				callLifecycleCallback(options.onAllReady);
+			});
+			return;
+		}
+		try {
+			writeRemainingSnapshots();
+		} catch (error) {
+			reportErrorAndAbort(error);
+			return;
+		}
+		if (writeFailed) return;
+		closed = true;
+		if (tailHtml) enqueueWrite(tailHtml);
+		afterWrites(() => {
+			try {
+				writer.close();
+			} catch (error) {
+				reportErrorAndAbort(error);
+				return;
+			}
+			cleanup();
+			resolveAll();
+			callLifecycleCallback(options.onAllReady);
+		});
+	};
+	const maybeFinalize = () => {
+		if (canFinalize && pendingCount === 0) finalize();
+	};
+	const registerStreamBoundary = (start, end) => {
+		const localId = `s${++boundaryId}`;
+		const id = streamIdentifierPrefix ? `${streamIdentifierPrefix}:${localId}` : localId;
+		boundaryMap.set(id, {
+			start,
+			end,
+			pending: false
+		});
+		return id;
+	};
+	const hooks = {
+		registerBoundary: registerStreamBoundary,
+		registerErrorBoundary: registerStreamBoundary,
+		boundaryPending(id) {
+			const entry = boundaryMap.get(id);
+			if (!entry || entry.pending) return;
+			entry.pending = true;
+			pendingCount++;
+		},
+		boundaryResolved(id) {
+			const entry = boundaryMap.get(id);
+			if (!entry) return;
+			if (entry.pending) {
+				entry.pending = false;
+				pendingCount = Math.max(0, pendingCount - 1);
+			}
+			if (mode === "shell" && wroteShell) try {
+				if (dom) {
+					writeSnapshotForBoundary(entry.start, entry.end);
+					const content = serializeBetween(entry.start, entry.end);
+					enqueueWrite(buildPatchChunk(id, content, resolvedOptions));
+				}
+			} catch (error) {
+				reportErrorAndAbort(error);
+				return;
+			}
+			maybeFinalize();
+		},
+		boundaryAbandoned(id) {
+			const entry = boundaryMap.get(id);
+			if (!entry) return;
+			boundaryMap.delete(id);
+			if (entry.pending) pendingCount = Math.max(0, pendingCount - 1);
+			maybeFinalize();
+		},
+		onError(err) {
+			reportErrorAndAbort(err);
+		}
+	};
+	const abort = (reason) => {
+		const abortReason = reason ?? /* @__PURE__ */ new Error("Stream aborted");
+		if (!cleaned) {
+			closed = true;
+			writeFailed = true;
+			cleanup();
+			try {
+				writer.abort(abortReason);
+			} catch {}
+		}
+		rejectShell(abortReason);
+		rejectAll(abortReason);
+	};
+	if (options.signal) if (options.signal.aborted) {
+		abort(options.signal.reason);
+		return {
+			shellReady,
+			allReady,
+			abort
+		};
+	} else {
+		const onAbort = () => abort(options.signal?.reason);
+		options.signal.addEventListener("abort", onAbort, { once: true });
+		removeAbortListener = () => options.signal?.removeEventListener("abort", onAbort);
+	}
+	try {
+		__fictEnableSSR();
+		__fictSetSSRScopeIdentifierPrefix(scopeIdentifierPrefix);
+		__fictSetSSRStreamHooks(hooks);
+		dom = resolveDom(resolvedOptions);
+		restoreGlobals = resolvedOptions.exposeGlobals === true ? installGlobals(dom.window, dom.document) : () => {};
+		restoreManifest = installManifest(resolvedOptions.manifest);
+		container = resolveContainer(dom.document, resolvedOptions);
+		teardown = render(view, container);
+		if (mode === "all") {
+			canFinalize = true;
+			maybeFinalize();
+			return {
+				shellReady,
+				allReady,
+				abort
+			};
+		}
+		const streamRuntime = boundaryMap.size > 0 ? buildStreamRuntimeScript(resolvedOptions) : "";
+		if (resolvedOptions.fullDocument) {
+			const split = serializeStreamingDocument(dom.document, container, resolvedOptions);
+			if (!split) throw new Error("[fict/ssr] Failed to locate the document body for streaming output.");
+			if (control.includeTailInShell) {
+				enqueueWrite(split.head + streamRuntime);
+				tailHtml = split.tail;
+				shellCarriesTail = true;
+			} else {
+				enqueueWrite(split.head + streamRuntime);
+				tailHtml = split.tail;
+			}
+		} else enqueueWrite(serializeOutput(dom.document, container, resolvedOptions) + streamRuntime);
+		if (writeFailed) return {
+			shellReady,
+			allReady,
+			abort
+		};
+		wroteShell = true;
+		writeSnapshotForScopes(Array.from(__fictGetScopeRegistry().keys()));
+		if (shellCarriesTail && tailHtml) {
+			enqueueWrite(tailHtml);
+			tailHtml = "";
+			shellCarriesTail = false;
+		}
+		markShellReady();
+		canFinalize = true;
+		maybeFinalize();
+	} catch (err) {
+		reportErrorAndAbort(err);
+	}
+	return {
+		shellReady,
+		allReady,
+		abort
+	};
+}
+function resolveContainer(document, options) {
+	if (options.container) {
+		if (options.container.ownerDocument && options.container.ownerDocument !== document) throw new Error("[fict/ssr] Provided container belongs to a different document.");
+		return options.container;
+	}
+	const tag = options.containerTag ?? "div";
+	assertValidDOMElementName(tag);
+	const container = document.createElement(tag);
+	if (options.containerId) container.setAttribute("id", options.containerId);
+	if (options.containerAttributes) for (const [name, value] of Object.entries(options.containerAttributes)) {
+		assertValidDOMAttributeName(name);
+		if (value === null || value === void 0 || value === false) continue;
+		container.setAttribute(name, value === true ? "" : String(value));
+	}
+	if (document.body) document.body.appendChild(container);
+	return container;
+}
+function buildStreamRuntimeScript(options) {
+	const nonce = renderNonceAttribute(options);
+	if (options.streamRuntime === "external") {
+		if (!options.streamRuntimeSrc) throw new Error("[fict/ssr] streamRuntimeSrc is required when streamRuntime is \"external\".");
+		return `<script${nonce} src="${escapeAttribute(options.streamRuntimeSrc)}" data-fict-stream-runtime data-fict-stream-observer><\/script>`;
+	}
+	return `<script${nonce}>${createStreamRuntimeCode({ observerMode: resolveStreamPatchMode(options) === "observer" })}<\/script>`;
+}
+function buildPatchChunk(id, content, options) {
+	const namespaceAttribute = content.namespace ? ` data-fict-patch-namespace="${content.namespace}"` : "";
+	const html = content.namespace === "svg" ? `<svg>${content.html}</svg>` : content.namespace === "mathml" ? `<math>${content.html}</math>` : content.html;
+	const template = `<template data-fict-suspense="${escapeAttribute(id)}"${namespaceAttribute}>${html}</template>`;
+	if (resolveStreamPatchMode(options) === "observer") return template;
+	return `${template}<script${renderNonceAttribute(options)}>__FICT_STREAM.apply("${escapeScriptString(id)}")<\/script>`;
+}
+function resolveStreamPatchMode(options) {
+	if (options.streamPatchMode) return options.streamPatchMode;
+	return options.streamRuntime === "external" ? "observer" : "inline";
+}
+function resolveStreamIdentifierPrefix(configured) {
+	if (configured !== void 0) return configured;
+	return `f${ssrIdentifierSeed}.${(++streamIdentifierSequence).toString(36)}`;
+}
+function validateStreamIdentifierPrefix(configured) {
+	validateIdentifierPrefix("streamIdentifierPrefix", configured);
+}
+function resolveScopeIdentifierPrefix(configured) {
+	if (configured !== void 0) return configured;
+	return `r${ssrIdentifierSeed}.${(++scopeIdentifierSequence).toString(36)}`;
+}
+function validateScopeIdentifierPrefix(configured) {
+	validateIdentifierPrefix("scopeIdentifierPrefix", configured);
+}
+function validateIdentifierPrefix(option, configured) {
+	if (configured === void 0) return;
+	if (typeof configured !== "string" || configured.length === 0 || configured.length > 128 || !IDENTIFIER_PREFIX_PATTERN.test(configured) || configured.includes("--")) throw new TypeError(`[fict/ssr] ${option} must contain 1-128 ASCII letters, digits, "_", ".", ":", or "-", and must not contain "--".`);
+}
+function createIdentifierSeed() {
+	try {
+		const normalized = (globalThis.crypto?.randomUUID?.())?.replace(/[^A-Za-z0-9]/g, "");
+		if (normalized) return normalized;
+	} catch {}
+	const random = Math.random().toString(36).slice(2) || "0";
+	return `${Date.now().toString(36)}${random}`;
+}
+function serializeBetween(start, end) {
+	const parentElement = start.parentElement ?? (start.parentNode?.nodeType === 1 ? start.parentNode : null);
+	const nodes = [];
+	let node = start.nextSibling;
+	while (node && node !== end) {
+		nodes.push(node);
+		node = node.nextSibling;
+	}
+	const namespace = resolveStreamPatchNamespace(parentElement);
+	return {
+		html: serializeHtmlNodes(nodes, parentElement),
+		namespace
+	};
+}
+function collectPatchScopeIds(start, end) {
+	const ids = /* @__PURE__ */ new Set();
+	const addScopeId = (element) => {
+		const id = element.getAttribute("data-fict-s");
+		if (id) ids.add(id);
+	};
+	const addVisibleSubtree = (element) => {
+		addScopeId(element);
+		for (const descendant of element.querySelectorAll("[data-fict-s]")) addScopeId(descendant);
+	};
+	let ancestor = start.parentElement ?? (start.parentNode?.nodeType === 1 ? start.parentNode : null);
+	while (ancestor) {
+		addScopeId(ancestor);
+		ancestor = ancestor.parentElement;
+	}
+	let node = start.nextSibling;
+	while (node && node !== end) {
+		if (node.nodeType === 1) addVisibleSubtree(node);
+		node = node.nextSibling;
+	}
+	return Array.from(ids);
+}
+function resolveStreamPatchNamespace(parentElement) {
+	if (!parentElement) return null;
+	let element = parentElement;
+	let descendantLocalName = null;
+	while (element) {
+		const localName = element.localName.toLowerCase();
+		if (SVG_HTML_INTEGRATION_POINTS.has(localName)) return null;
+		if (MATHML_TEXT_INTEGRATION_POINTS.has(localName)) {
+			if (descendantLocalName === "mglyph" || descendantLocalName === "malignmark") return "mathml";
+			return null;
+		}
+		if (isHtmlAnnotationIntegrationPoint(element)) return null;
+		if (localName === "svg") return "svg";
+		if (localName === "math") return "mathml";
+		descendantLocalName = localName;
+		element = element.parentElement;
+	}
+	return null;
+}
+function isHtmlAnnotationIntegrationPoint(element) {
+	if (element.localName.toLowerCase() !== "annotation-xml") return false;
+	const encoding = element.getAttribute("encoding")?.toLowerCase();
+	return encoding === "text/html" || encoding === "application/xhtml+xml";
+}
+function serializeStreamingDocument(document, container, options) {
+	const body = document.body;
+	if (!body) return null;
+	const marker = document.createComment("");
+	body.appendChild(marker);
+	let markerText = `fict:stream-tail:${++streamTailMarkerId}`;
+	try {
+		while (true) {
+			marker.data = markerText;
+			const html = serializeOutput(document, container, options);
+			const serializedMarker = `<!--${markerText}-->`;
+			const idx = html.indexOf(serializedMarker);
+			if (idx !== -1 && html.indexOf(serializedMarker, idx + serializedMarker.length) === -1) return {
+				head: html.slice(0, idx),
+				tail: html.slice(idx + serializedMarker.length)
+			};
+			markerText += markerText;
+		}
+	} finally {
+		marker.parentNode?.removeChild(marker);
+	}
+}
+function buildIncrementalSnapshotChunk(state, options) {
+	const json = serializeSnapshotForScript(state);
+	const nonce = renderNonceAttribute(options);
+	if (options.snapshotTarget === "head") {
+		const jsonLiteral = JSON.stringify(json);
+		return `<script${nonce}>(function(){var s=document.createElement('script');s.type='application/json';s.setAttribute('data-fict-snapshot','');${options.scriptNonce !== void 0 ? `s.setAttribute('nonce',${serializeScriptStringLiteral(options.scriptNonce)});` : ""}s.textContent=${jsonLiteral};(document.head||document.documentElement).appendChild(s);}())<\/script>`;
+	}
+	return `<script${nonce} type="application/json" data-fict-snapshot>${json}<\/script>`;
+}
+function serializeOutput(document, container, options) {
+	if (options.fullDocument) {
+		const doctype = serializeDoctype(document, options.doctype);
+		const html = document.documentElement ? serializeHtmlNode(document.documentElement) : serializeHtmlNode(container);
+		return doctype ? `${doctype}${html}` : html;
+	}
+	if (options.includeContainer) return serializeHtmlNode(container);
+	return serializeHtmlChildren(container);
+}
+function injectSnapshot(document, container, state, options) {
+	const script = document.createElement("script");
+	script.type = "application/json";
+	script.id = options.snapshotScriptId ?? "__FICT_SNAPSHOT__";
+	if (options.scriptNonce !== void 0) script.setAttribute("nonce", options.scriptNonce);
+	script.textContent = serializeSnapshotForScript(state);
+	if (options.fullDocument) {
+		if (options.snapshotTarget === "head" && document.head) {
+			document.head.appendChild(script);
+			return;
+		}
+		if (document.body) {
+			document.body.appendChild(script);
+			return;
+		}
+	}
+	const target = options.snapshotTarget ?? "container";
+	if (target === "body" && document.body) {
+		document.body.appendChild(script);
+		return;
+	}
+	if (target === "head" && document.head) {
+		document.head.appendChild(script);
+		return;
+	}
+	container.appendChild(script);
+}
+function serializeSnapshotForScript(state) {
+	return JSON.stringify(state).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function serializeScriptStringLiteral(value) {
+	return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function renderNonceAttribute(options) {
+	return options.scriptNonce === void 0 ? "" : ` nonce="${escapeAttribute(options.scriptNonce)}"`;
+}
+function escapeAttribute(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeScriptString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function serializeDoctype(document, override) {
+	if (override === null) return "";
+	if (override !== void 0) return override;
+	const doctype = document.doctype;
+	if (!doctype) return "";
+	return serializeHtmlNode(doctype);
+}
+//#endregion
+export { renderToStream as a, renderToPipeableStream as i, renderToDocument as n, renderToString as o, renderToPartial as r, renderToStringAsync as s, createSSRDocument as t };
+
+//# sourceMappingURL=render-core-D0nOT_Pe.js.map