@bgub/fig-server 0.0.1

package/dist/index.js

@@ -0,0 +1,1429 @@
+import { i as withContextValue, n as createStaticDispatcher, r as deferred, t as cloneContextValues } from "./shared-CQn6Dje6.js";
+import { Fragment, createElement } from "@bgub/fig";
+import { ACTIVITY_TEMPLATE_ATTRIBUTE, EARLY_EVENT_HANDLER_PROPERTY, EARLY_EVENT_QUEUE_PROPERTY, REPLAYABLE_EVENT_TYPES, SUSPENSE_CLIENT_MARKER, SUSPENSE_COMPLETED_MARKER, SUSPENSE_END_MARKER, SUSPENSE_MARKER_PREFIX, SUSPENSE_PENDING_PREFIX, VIEW_TRANSITION_CLASS_ATTRIBUTE, VIEW_TRANSITION_NAME_ATTRIBUTE, VIEW_TRANSITION_PENDING_PROPERTY, assetResourceDestination, assetResourceFromHostProps, assetResourceHostAttributes, assetResourceKey, collectChildren, createDataStore, invalidChildError, isActivity, isAssets, isClientReference, isContext, isErrorBoundary, isFigAssetResource, isPortal, isSuspense, isThenable, isValidElement, isViewTransition, readThenable, setCurrentDataStore, setCurrentDispatcher } from "@bgub/fig/internal";
+//#region src/html.ts
+const voidElements = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+function writeText(value, sink) {
+	sink.write(escapeText(value));
+}
+function writeElementStart(type, props, sink, inheritedProps = {}) {
+	validateTagName(type);
+	sink.write(`<${type}`);
+	writeAttributes(type, props, inheritedProps, sink);
+	sink.write(">");
+}
+function writeElementEnd(type, sink) {
+	sink.write(`</${type}>`);
+}
+function isVoidElement(type) {
+	return voidElements.has(type);
+}
+function hasRenderableChild(node) {
+	if (Array.isArray(node)) return node.some(hasRenderableChild);
+	if (isPortal(node)) return false;
+	return !emptyChild(node);
+}
+function formTextContent(type, props) {
+	if (type !== "textarea") return null;
+	return formString(props.value !== void 0 ? props.value : props.defaultValue);
+}
+function unsafeHTMLContent(props) {
+	const value = props.unsafeHTML;
+	if (emptyValue(value)) return null;
+	if (typeof value === "string") return value;
+	throw new Error("The unsafeHTML prop must be a string during server render.");
+}
+function writeAttributes(type, props, inheritedProps, sink) {
+	for (const [name, value] of Object.entries(props)) {
+		if (reservedProp(name)) continue;
+		if (name === "value" && props.defaultValue !== void 0) continue;
+		if (name === "checked" && props.defaultChecked !== void 0) continue;
+		if (name === "style") {
+			const style = serializeStyle(value);
+			if (style !== "") writeAttribute(sink, "style", style);
+			continue;
+		}
+		const attribute = formAttribute(type, name, value);
+		if (attribute === null) continue;
+		const [attributeNameValue, attributeValue] = attribute;
+		validateAttributeName(attributeNameValue);
+		if (attributeValue === true) {
+			sink.write(` ${attributeNameValue}`);
+			continue;
+		}
+		if (serializableAttributeValue(attributeValue)) {
+			writeAttribute(sink, attributeNameValue, String(attributeValue));
+			continue;
+		}
+		throw new Error(`Cannot serialize prop "${name}" to HTML.`);
+	}
+	if (type === "option" && props.selected === void 0 && optionSelected(optionValue(props), inheritedProps)) sink.write(" selected");
+}
+function formAttribute(type, name, value) {
+	if ((type === "textarea" || type === "select") && valueProp(name)) return null;
+	if (valueProp(name)) return valueAttribute(value);
+	if (name === "defaultChecked") return value === true ? ["checked", true] : null;
+	if (type === "option" && name === "selected") return value === true ? ["selected", true] : null;
+	return attributeValue(name, value);
+}
+function attributeValue(name, value) {
+	return emptyValue(value) ? null : [name, value];
+}
+function valueAttribute(value) {
+	if (emptyValue(value)) return null;
+	if (serializableAttributeValue(value)) return ["value", String(value)];
+	return ["value", value];
+}
+function optionSelected(value, selectProps) {
+	const selectValue = selectProps.value !== void 0 ? selectProps.value : selectProps.defaultValue;
+	if (emptyValue(selectValue)) return false;
+	const optionValue = formString(value);
+	if (optionValue === null) return false;
+	return selectedValueSet(selectValue).has(optionValue);
+}
+function optionValue(props) {
+	return props.value === void 0 ? optionTextValue(props.children) : formString(props.value);
+}
+function optionTextValue(node) {
+	if (typeof node === "string" || typeof node === "number") return String(node);
+	if (Array.isArray(node)) {
+		let text = "";
+		for (const child of node) {
+			const childText = optionTextValue(child);
+			if (childText === null) return null;
+			text += childText;
+		}
+		return text;
+	}
+	return null;
+}
+function formString(value) {
+	if (emptyValue(value)) return null;
+	if (serializableAttributeValue(value)) return String(value);
+	return null;
+}
+function selectedValueSet(value) {
+	return new Set(Array.isArray(value) ? value.map(String) : [String(value)]);
+}
+function serializableAttributeValue(value) {
+	return value === true || typeof value === "string" || typeof value === "number" || typeof value === "bigint";
+}
+function emptyValue(value) {
+	return value === null || value === void 0 || value === false;
+}
+function emptyChild(value) {
+	return value === null || value === void 0 || typeof value === "boolean";
+}
+function writeAttribute(sink, name, value) {
+	sink.write(` ${name}="${escapeAttribute(value)}"`);
+}
+function serializeStyle(value) {
+	if (emptyValue(value)) return "";
+	if (typeof value !== "object" || value === null) throw new Error("The style prop must be an object during server render.");
+	const declarations = [];
+	for (const [name, item] of Object.entries(value)) {
+		if (emptyValue(item)) continue;
+		if (typeof item !== "string" && typeof item !== "number" && typeof item !== "bigint") throw new Error(`Cannot serialize style property "${name}" to HTML.`);
+		declarations.push(`${styleName(name)}:${String(item)}`);
+	}
+	return declarations.join(";");
+}
+function reservedProp(name) {
+	return name === "children" || name === "key" || name === "events" || name === "bind" || name === "suppressHydrationWarning" || name === "unsafeHTML" || /^on[A-Z]/.test(name);
+}
+function valueProp(name) {
+	return name === "value" || name === "defaultValue";
+}
+function styleName(name) {
+	if (name.startsWith("--")) return name;
+	return name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+function validateTagName(name) {
+	if (!/^[A-Za-z][A-Za-z0-9:._-]*$/.test(name)) throw new Error(`Invalid HTML tag name "${name}".`);
+}
+function validateAttributeName(name) {
+	if (/[\s"'<>/=]/.test(name)) throw new Error(`Invalid HTML attribute name "${name}".`);
+}
+function escapeText(value) {
+	return value.replace(/[&<>]/g, (character) => {
+		if (character === "&") return "&amp;";
+		if (character === "<") return "&lt;";
+		return "&gt;";
+	});
+}
+function escapeAttribute(value) {
+	return value.replace(/[&"<>]/g, (character) => {
+		if (character === "&") return "&amp;";
+		if (character === "\"") return "&quot;";
+		if (character === "<") return "&lt;";
+		return "&gt;";
+	});
+}
+//#endregion
+//#region src/asset-registry.ts
+var AssetResourceRegistry = class {
+	identifierPrefix;
+	emittedResources = /* @__PURE__ */ new Set();
+	resources = /* @__PURE__ */ new Map();
+	stylesheetIds = /* @__PURE__ */ new Map();
+	nextStylesheetId = 0;
+	constructor(identifierPrefix) {
+		this.identifierPrefix = identifierPrefix;
+	}
+	register(resource) {
+		return this.canonical(resource).added;
+	}
+	write(resource, sink) {
+		const { key, resource: current } = this.canonical(resource);
+		const id = this.revealBlockerId(key, current);
+		if (assetResourceDestination(current) === "head") return id;
+		if (this.emittedResources.has(key)) return id;
+		this.emittedResources.add(key);
+		writeAssetTag(sink, current, id);
+		return id;
+	}
+	headHtml(nonce) {
+		let html = "";
+		const sink = {
+			nonce,
+			write(chunk) {
+				html += chunk;
+			}
+		};
+		for (const resource of this.resources.values()) if (assetResourceDestination(resource) === "head") writeAssetTag(sink, resource, null);
+		return html;
+	}
+	canonical(resource) {
+		const key = assetResourceKey(resource);
+		const current = this.resources.get(key);
+		if (current !== void 0) {
+			if (assetSignature(current) !== assetSignature(resource)) {
+				if (resource.kind === "title") {
+					this.resources.set(key, resource);
+					return {
+						added: false,
+						key,
+						resource
+					};
+				}
+				throw new AssetResourceConflictError(key, current, resource);
+			}
+			return {
+				added: false,
+				key,
+				resource: current
+			};
+		}
+		this.resources.set(key, resource);
+		return {
+			added: true,
+			key,
+			resource
+		};
+	}
+	revealBlockerId(key, resource) {
+		if (resource.kind !== "stylesheet") return null;
+		if (resource.blocking === "none") return null;
+		return this.stylesheetIdFor(key);
+	}
+	stylesheetIdFor(key) {
+		const current = this.stylesheetIds.get(key);
+		if (current !== void 0) return current;
+		const id = this.identifierPrefix === "" ? `r-${this.nextStylesheetId}` : `${this.identifierPrefix}-r-${this.nextStylesheetId}`;
+		this.nextStylesheetId += 1;
+		this.stylesheetIds.set(key, id);
+		return id;
+	}
+};
+var AssetResourceConflictError = class extends Error {
+	constructor(key, current, incoming) {
+		super(`Conflicting Fig resource for key "${key}". Existing: ${JSON.stringify(current)}. Incoming: ${JSON.stringify(incoming)}.`);
+	}
+};
+function writeAssetTag(sink, resource, id) {
+	switch (resource.kind) {
+		case "title":
+			writeElementStart("title", {}, sink);
+			writeText(resource.value, sink);
+			writeElementEnd("title", sink);
+			return;
+		case "meta":
+			writeElementStart("meta", {
+				charset: resource.charset,
+				name: resource.name,
+				property: resource.property,
+				"http-equiv": resource.httpEquiv,
+				content: resource.content,
+				"data-fig-resource-key": resource.key
+			}, sink);
+			return;
+		default: {
+			const props = Object.fromEntries(assetResourceHostAttributes(resource));
+			if (resource.kind === "stylesheet" && id !== null) props.id = id;
+			const tag = resource.kind === "script" ? "script" : "link";
+			writeElementStart(tag, withNonce(sink, props), sink);
+			if (tag === "script") writeElementEnd("script", sink);
+		}
+	}
+}
+function withNonce(sink, props) {
+	return sink.nonce === void 0 ? props : {
+		...props,
+		nonce: sink.nonce
+	};
+}
+function assetSignature(resource) {
+	switch (resource.kind) {
+		case "stylesheet": return signature(resource.kind, resource.href, resource.media ?? "", resource.precedence ?? "", resource.crossOrigin ?? "", resource.blocking ?? "reveal");
+		case "preload": return signature(resource.kind, resource.href, resource.as, resource.type ?? "", resource.crossOrigin ?? "", resource.fetchPriority ?? "");
+		case "modulepreload": return signature(resource.kind, resource.href, resource.crossOrigin ?? "", resource.fetchPriority ?? "");
+		case "font": return signature("preload", resource.href, "font", resource.type, resource.crossOrigin ?? "anonymous", resource.fetchPriority ?? "");
+		case "preconnect": return signature(resource.kind, resource.href, resource.crossOrigin ?? "");
+		case "script": return signature(resource.kind, resource.src, resource.module === true, resource.async !== false, resource.defer === true, resource.crossOrigin ?? "");
+		case "title": return signature(resource.kind, resource.value);
+		case "meta": return signature(resource.kind, resource.charset ?? "", resource.name ?? "", resource.property ?? "", resource.httpEquiv ?? "", resource.content ?? "");
+	}
+	return unsupportedAssetResource(resource);
+}
+function unsupportedAssetResource(resource) {
+	throw new Error(`Unsupported asset resource kind: ${resource.kind}`);
+}
+function signature(...values) {
+	return JSON.stringify(values);
+}
+//#endregion
+//#region src/protocol.ts
+function serverRuntimeCodeFor(runtimeName) {
+	return `globalThis[${jsString(runtimeName)}]??={r(a,f){let n=0,d=()=>{--n||f()};for(let i of a){let e=document.getElementById(i);if(e&&e.tagName==='LINK'&&e.rel==='stylesheet'&&!e.sheet){n++;e.addEventListener('load',d,{once:true});e.addEventListener('error',d,{once:true})}}n||f()},q(e,a){if(e&&e.nodeType===1){if(e.hasAttribute&&e.hasAttribute('${VIEW_TRANSITION_NAME_ATTRIBUTE}'))a.push([e,e.getAttribute('${VIEW_TRANSITION_NAME_ATTRIBUTE}'),e.getAttribute('${VIEW_TRANSITION_CLASS_ATTRIBUTE}')]);if(e.querySelectorAll)for(let x of e.querySelectorAll('[${VIEW_TRANSITION_NAME_ATTRIBUTE}]'))a.push([x,x.getAttribute('${VIEW_TRANSITION_NAME_ATTRIBUTE}'),x.getAttribute('${VIEW_TRANSITION_CLASS_ATTRIBUTE}')])}},g(r){let a=[];this.q(r,a);return a},h(b){let a=[],d=0;for(let e=b;e;){if(e.nodeType===8){if(e.data.indexOf('${SUSPENSE_MARKER_PREFIX}')===0)d++;else if(e.data==='${SUSPENSE_END_MARKER}'){if(d===0)break;d--}}else this.q(e,a);e=e.nextSibling}return a},a(l){for(let x of l){let e=x[0],s=e.style;x[3]=s.viewTransitionName;x[4]=s.viewTransitionClass;s.viewTransitionName=x[1];if(x[2])s.viewTransitionClass=x[2]}},u(l){for(let x of l){let e=x[0],s=e.style;s.viewTransitionName=x[3]||'';s.viewTransitionClass=x[4]||'';!(e.getAttribute&&e.getAttribute('style'))&&e.removeAttribute&&e.removeAttribute('style')}},z(l){for(let f of l)f()},j(t,r){let p=t&&(t.ready||t.finished);p&&p.then?p.then(r,()=>{let f=t&&t.finished;f&&f.then?f.then(r,r):r()}):r()},v(b,s,f){let o=this.h(b),n=this.g(s);if(!o.length&&!n.length){f();return}let d=document,w=d.startViewTransition;if(typeof w!='function'){f();return}let p=d.${VIEW_TRANSITION_PENDING_PROPERTY},pw=p&&(p.finished||p.ready);if(pw&&pw.then){let g=()=>this.v(b,s,f);pw.then(g,g);return}this.a(o);let m=0,l=[],r=()=>{this.u(o);this.u(n);this.z(l)};try{let t=w.call(d,()=>{m=1;f(l);this.a(n)});if(t){d.${VIEW_TRANSITION_PENDING_PROPERTY}=t;let c=()=>{d.${VIEW_TRANSITION_PENDING_PROPERTY}===t&&(d.${VIEW_TRANSITION_PENDING_PROPERTY}=null)},cw=t.finished||t.ready;cw&&cw.then?cw.then(c,c):c()}this.j(t,r)}catch(e){r();if(m)throw e;f()}},s(p,s){p=document.getElementById(p);s=document.getElementById(s);if(!p||!s)return;this.v(p,s,()=>{while(s.firstChild)p.parentNode.insertBefore(s.firstChild,p);p.remove();s.remove()})},f(r,i){if(!r)return null;if(r.id===i)return r;for(let e of r.querySelectorAll?r.querySelectorAll('[id]'):[])if(e.id===i)return e;return null},b(t,b){let e=document.getElementById(t),r=e&&(e.content||e);return this.f(r,b)||document.getElementById(b)},c(b,s){let x=document.getElementById(b),y=document.getElementById(s);this.v(x,y,r=>this.o(x,y,r))},o(b,s,l){if(!b||!s)return;let a=b.previousSibling||b,p=a.parentNode,c=s.content||s;if(!p)return;while(c.firstChild)p.insertBefore(c.firstChild,b);for(let e=b,d=0;e;){if(e.nodeType===8){if(e.data.indexOf('${SUSPENSE_MARKER_PREFIX}')===0)d++;else if(e.data==='${SUSPENSE_END_MARKER}'){if(d===0)break;d--}}let x=e.nextSibling;e.remove();e=x}s.remove();if(a.nodeType===8){a.data='${SUSPENSE_COMPLETED_MARKER}';let r=a.__figRetry;if(r){if(l)l.push(r);else r()}}},x(b,d,m){this.y(document.getElementById(b),d,m)},y(b,d,m){if(!b)return;let s=b.previousSibling;if(s&&s.nodeType===8){s.data='${SUSPENSE_CLIENT_MARKER}';if(d)b.dataset.dgst=d;if(m)b.dataset.msg=m;s.__figRetry&&s.__figRetry()}},ac(t,b,s){let x=this.b(t,b),y=document.getElementById(s);this.v(x,y,r=>this.o(x,y,r))},ax(t,b,d,m){this.y(this.b(t,b),d,m)}}`;
+}
+function writeRuntime$1(request, write) {
+	if (request.runtimeWritten) return;
+	request.runtimeWritten = true;
+	writeScript$1(request, serverRuntimeCodeFor(request.runtimeName), write);
+}
+function writeScript$1(request, code, write) {
+	write(`<script${request.nonce === void 0 ? "" : ` nonce="${escapeAttribute(request.nonce)}"`}>${code}<\/script>`);
+}
+function earlyEventCaptureCode() {
+	return `(d=>{if(d.${EARLY_EVENT_QUEUE_PROPERTY})return;let q=d.${EARLY_EVENT_QUEUE_PROPERTY}=[],h=d.${EARLY_EVENT_HANDLER_PROPERTY}=e=>{q.push(e)};for(let t of [${REPLAYABLE_EVENT_TYPES.map((type) => `'${type}'`).join(",")}])d.addEventListener(t,h,!0)})(document)`;
+}
+function earlyEventCaptureMarkup(request) {
+	let markup = "";
+	writeScript$1(request, earlyEventCaptureCode(), (chunk) => {
+		markup += chunk;
+	});
+	return markup;
+}
+function placeholderMarkup(request, id) {
+	return templateMarkup(placeholderId(request, id));
+}
+function boundaryPlaceholderMarkup(request, id) {
+	return templateMarkup(boundaryId(request, id));
+}
+function templateMarkup(id) {
+	return `<template id="${escapeAttribute(id)}"></template>`;
+}
+function segmentContainerStartMarkup(request, id) {
+	return `<div hidden id="${escapeAttribute(segmentId(request, id))}">`;
+}
+function activityId(request, id) {
+	return prefixedId(request, "a", id);
+}
+function placeholderId(request, id) {
+	return prefixedId(request, "p", id);
+}
+function segmentId(request, id) {
+	return prefixedId(request, "s", id);
+}
+function boundaryId(request, id) {
+	return prefixedId(request, "b", id);
+}
+function jsString(value) {
+	return JSON.stringify(value).replace(/</g, "\\u003C");
+}
+function prefixedId(request, kind, id) {
+	return request.identifierPrefix === "" ? `${kind}-${id}` : `${request.identifierPrefix}-${kind}-${id}`;
+}
+//#endregion
+//#region src/renderer.ts
+const errorStacks = /* @__PURE__ */ new WeakMap();
+const textEncoder = new TextEncoder();
+const documentHeadMarker = Symbol("fig.document-head");
+const RUNTIME_REF = "__figSSR";
+const TEXT_SEPARATOR = "<!--,-->";
+let nextRuntimeId = 0;
+function createServerRenderRequest(node, options = {}, mode = {}) {
+	throwIfAborted(options.signal);
+	const shellReady = deferred();
+	const headReady = deferred();
+	const allReady = deferred();
+	shellReady.promise.catch(() => void 0);
+	headReady.promise.catch(() => void 0);
+	allReady.promise.catch(() => void 0);
+	const rootSegment = createSegment(0, null);
+	const request = {
+		abortableTasks: /* @__PURE__ */ new Set(),
+		abortListener: null,
+		abortSignal: options.signal ?? null,
+		allReady,
+		completedBoundaries: /* @__PURE__ */ new Set(),
+		completedRootSegment: null,
+		controller: null,
+		dataStore: createDataStore({
+			getLane: () => null,
+			partition: options.dataPartition,
+			schedule: () => void 0
+		}),
+		fatalError: null,
+		identifierPrefix: options.identifierPrefix ?? "",
+		nextBoundaryId: 0,
+		nextSegmentId: 0,
+		nextActivityId: 0,
+		nextViewTransitionId: 0,
+		nonce: options.nonce,
+		onError: options.onError,
+		onAssetError: options.onAssetError,
+		pendingRootTasks: 0,
+		pendingTasks: 0,
+		pingedTasks: [],
+		assetSink: null,
+		rootSegment,
+		runtimeName: createRuntimeName(options.identifierPrefix),
+		runtimeWritten: false,
+		headReady,
+		headSnapshot: null,
+		shellReady,
+		status: "opening",
+		stream: null,
+		clientRenderedBoundaries: /* @__PURE__ */ new Set(),
+		clientReferenceFallback: options.clientReferenceFallback,
+		partialBoundaries: /* @__PURE__ */ new Set(),
+		prerender: mode.prerender === true,
+		componentAssets: options.assets,
+		document: mode.document === true ? { hasHead: false } : null,
+		assetRegistry: new AssetResourceRegistry(options.identifierPrefix ?? ""),
+		resolveAssetKey: options.resolveAssetKey,
+		workScheduled: false,
+		writeBuffer: []
+	};
+	request.assetSink = {
+		nonce: options.nonce,
+		write: (chunk) => write(request, chunk)
+	};
+	const stream = new ReadableStream({
+		start(streamController) {
+			request.controller = streamController;
+			flushCompletedQueues(request);
+		},
+		cancel(reason) {
+			abort(request, reason);
+		}
+	});
+	request.stream = stream;
+	rootSegment.parentFlushed = true;
+	const rootTask = createTask(request, node, rootSegment, {
+		abortSet: request.abortableTasks,
+		boundary: null,
+		contextValues: /* @__PURE__ */ new Map(),
+		hiddenActivityId: null,
+		hostAncestors: [],
+		idPath: "",
+		selectProps: null,
+		stack: null,
+		treeParent: options.renderTree?.tree ?? null,
+		viewTransition: null
+	});
+	request.pingedTasks.push(rootTask);
+	if (options.signal !== void 0) {
+		const abortListener = () => abort(request, options.signal?.reason);
+		request.abortListener = abortListener;
+		options.signal.addEventListener("abort", abortListener, { once: true });
+	}
+	request.workScheduled = true;
+	queueMicrotask(() => {
+		request.workScheduled = false;
+		performWork(request);
+	});
+	return {
+		abort: (reason) => abort(request, reason),
+		allReady: allReady.promise,
+		contentType: "text/html; charset=utf-8",
+		getData: () => request.dataStore.snapshot(),
+		getHead: () => request.headSnapshot ?? request.assetRegistry.headHtml(request.nonce),
+		headReady: headReady.promise,
+		shellReady: shellReady.promise,
+		stream
+	};
+}
+function createTask(request, node, segment, scope, childIndexBase = 0) {
+	request.pendingTasks += 1;
+	if (scope.boundary === null) request.pendingRootTasks += 1;
+	else scope.boundary.pendingTasks += 1;
+	const task = {
+		...scope,
+		childIndexBase,
+		node,
+		segment
+	};
+	request.abortableTasks.add(task);
+	scope.abortSet.add(task);
+	return task;
+}
+function forkScope(scope) {
+	return {
+		abortSet: scope.abortSet,
+		boundary: scope.boundary,
+		contextValues: cloneContextValues(scope.contextValues),
+		hiddenActivityId: scope.hiddenActivityId,
+		hostAncestors: scope.hostAncestors,
+		idPath: scope.idPath,
+		selectProps: scope.selectProps,
+		stack: scope.stack,
+		treeParent: scope.treeParent,
+		viewTransition: scope.viewTransition === null ? null : { ...scope.viewTransition }
+	};
+}
+function createSegment(index, boundary, textSeams = {
+	lastPushedText: false,
+	textEmbedded: false
+}) {
+	return {
+		boundary,
+		children: [],
+		chunks: [],
+		id: null,
+		index,
+		lastPushedText: textSeams.lastPushedText,
+		parentFlushed: false,
+		assetResources: [],
+		status: "pending",
+		textEmbedded: textSeams.textEmbedded,
+		write(chunk) {
+			this.lastPushedText = false;
+			this.chunks.push(chunk);
+		}
+	};
+}
+function createBoundary(fallbackAbortableTasks, contentSegment) {
+	return {
+		activityId: null,
+		completedSegments: [],
+		contentSegment,
+		error: null,
+		fallbackAbortableTasks,
+		id: null,
+		parentFlushed: false,
+		pendingTasks: 0,
+		status: "pending"
+	};
+}
+function performWork(request) {
+	if (request.status === "closed") return;
+	if (request.status === "opening") request.status = "open";
+	const tasks = request.pingedTasks;
+	request.pingedTasks = [];
+	for (const task of tasks) retryTask(request, task);
+	flushCompletedQueues(request);
+}
+function retryTask(request, task) {
+	if (task.segment.status !== "pending") return;
+	task.segment.status = "rendering";
+	const frame = createRenderFrame(request, task.segment, forkScope(task));
+	try {
+		renderChildSequence(collectChildren(task.node), frame, task.childIndexBase);
+		completeSegmentText(task.segment);
+		task.segment.status = "completed";
+		detachTask(request, task);
+		finishedTask(request, task, task.segment);
+	} catch (error) {
+		detachTask(request, task);
+		task.segment.status = "completed";
+		erroredTask(request, task, error);
+	}
+}
+function createRenderFrame(request, segment, scope) {
+	const frame = {
+		...scope,
+		dispatcher: null,
+		localIdCounter: 0,
+		pendingLeadingNewlineHost: null,
+		request,
+		segment
+	};
+	frame.dispatcher = createServerDispatcher(frame);
+	return frame;
+}
+function createServerDispatcher(frame) {
+	return createStaticDispatcher({
+		contextValues: frame.contextValues,
+		externalStoreError: "useSyncExternalStore requires getServerSnapshot during server render.",
+		readPromise(promise) {
+			throwIfAborting(frame.request);
+			return readThenable(promise);
+		},
+		readData(resource, args) {
+			throwIfAborting(frame.request);
+			return frame.request.dataStore.readData(resource, args, frame);
+		},
+		preloadData(resource, args) {
+			throwIfAborting(frame.request);
+			frame.request.dataStore.preloadData(resource, ...args);
+		},
+		useId() {
+			const id = `${frame.request.identifierPrefix}fig-${frame.idPath}-${frame.localIdCounter.toString(32)}`;
+			frame.localIdCounter += 1;
+			return id;
+		},
+		updateError: "State updates are not allowed during server render."
+	});
+}
+function renderNode(node, frame) {
+	if (Array.isArray(node)) {
+		renderChildren(node, frame);
+		return;
+	}
+	if (node === null || node === void 0 || typeof node === "boolean") return;
+	if (typeof node === "string" || typeof node === "number") {
+		const text = String(node);
+		if (frame.request.document !== null && !frame.request.document.hasHead) {
+			if (text.trim() !== "") throw invalidDocumentShellError();
+		}
+		if (text !== "") {
+			if (frame.treeParent !== null) frame.treeParent.children.push({
+				children: [],
+				key: null,
+				kind: "text",
+				name: "#text",
+				props: { nodeValue: text }
+			});
+			const output = consumePendingLeadingNewline(frame) ? preserveParserStrippedLeadingNewline(text) : text;
+			if (frame.segment.lastPushedText) frame.segment.write(TEXT_SEPARATOR);
+			writeText(output, frame.segment);
+			frame.segment.lastPushedText = true;
+		}
+		return;
+	}
+	if (isPortal(node)) return;
+	if (!isValidElement(node)) throw invalidChildError(node);
+	renderElement(node, frame);
+}
+function renderChildren(node, frame) {
+	renderChildSequence(collectChildren(node), frame);
+}
+function renderChildSequence(children, frame, indexBase = 0) {
+	for (let index = 0; index < children.length; index += 1) try {
+		withIdSegment(frame, indexBase + index, () => renderNode(children[index], frame));
+	} catch (error) {
+		if (isThenable(error)) {
+			spawnSuspendedTask(frame, children[index], error, indexBase + index);
+			continue;
+		}
+		throw error;
+	}
+}
+function completeSegmentText(segment) {
+	if (segment.textEmbedded && segment.lastPushedText) segment.write(TEXT_SEPARATOR);
+}
+function withIdSegment(frame, index, callback) {
+	const previousIdPath = frame.idPath;
+	const segment = index.toString(32);
+	frame.idPath = previousIdPath === "" ? segment : `${previousIdPath}-${segment}`;
+	try {
+		return callback();
+	} finally {
+		frame.idPath = previousIdPath;
+	}
+}
+function renderElement(element, frame) {
+	if (frame.treeParent === null) {
+		renderElementKind(element, frame);
+		return;
+	}
+	const treeNode = collectedTreeNode(element);
+	frame.treeParent.children.push(treeNode);
+	const previousTreeParent = frame.treeParent;
+	frame.treeParent = treeNode;
+	try {
+		renderElementKind(element, frame);
+	} finally {
+		frame.treeParent = previousTreeParent;
+	}
+}
+function collectedTreeNode(element) {
+	const { children: _children, ...ownProps } = element.props;
+	const [name, kind] = collectedNameAndKind(element.type);
+	return {
+		children: [],
+		key: element.key ?? null,
+		kind,
+		name,
+		props: ownProps
+	};
+}
+function collectedNameAndKind(type) {
+	if (typeof type === "string") return [type, "host"];
+	if (type === Fragment) return ["Fragment", "fragment"];
+	if (isContext(type)) {
+		const named = type;
+		return [`${typeof named.displayName === "string" && named.displayName !== "" ? named.displayName : "Context"}.Provider`, "context-provider"];
+	}
+	if (isAssets(type)) return ["Assets", "assets"];
+	if (isSuspense(type)) return ["Suspense", "suspense"];
+	if (isErrorBoundary(type)) return ["ErrorBoundary", "error-boundary"];
+	if (isActivity(type)) return ["Activity", "activity"];
+	if (isViewTransition(type)) return ["ViewTransition", "view-transition"];
+	if (isClientReference(type)) {
+		const id = type.id;
+		const exportName = id.slice(id.lastIndexOf("#") + 1);
+		return [exportName === "" ? "ClientReference" : exportName, "client-reference"];
+	}
+	if (typeof type === "function") return [type.name === "" ? "Anonymous" : type.name, "function"];
+	return ["Anonymous", "function"];
+}
+function renderElementKind(element, frame) {
+	const type = element.type;
+	if (typeof type === "string") {
+		renderHostElement(type, element.props, frame);
+		return;
+	}
+	if (type === Fragment) {
+		renderChildren(element.props.children, frame);
+		return;
+	}
+	if (isContext(type)) {
+		renderContextProvider(type, element.props, frame);
+		return;
+	}
+	if (isAssets(type)) {
+		renderAssets(element.props, frame);
+		return;
+	}
+	if (isSuspense(type)) {
+		renderSuspense(element.props, frame);
+		return;
+	}
+	if (isErrorBoundary(type)) {
+		renderChildren(element.props.children, frame);
+		return;
+	}
+	if (isClientReference(type)) {
+		renderClientReference(type, element.props, frame);
+		return;
+	}
+	if (isActivity(type)) {
+		renderActivity(element.props, frame);
+		return;
+	}
+	if (isViewTransition(type)) {
+		renderViewTransition(element.props, frame);
+		return;
+	}
+	if (typeof type === "function") {
+		renderFunctionComponent(type, element.props, frame);
+		return;
+	}
+	throw new Error(`Unsupported Fig element type: ${describeElementType(type)}.`);
+}
+function renderFunctionComponent(type, props, frame) {
+	const previousDispatcher = setCurrentDispatcher(frame.dispatcher);
+	const previousDataStore = setCurrentDataStore(frame.request.dataStore);
+	const previousStack = frame.stack;
+	const previousLocalIdCounter = frame.localIdCounter;
+	frame.stack = {
+		name: type.name || "Anonymous",
+		parent: previousStack
+	};
+	frame.localIdCounter = 0;
+	try {
+		renderComponentAssets(type, frame);
+		renderChildren(type(props), frame);
+	} catch (error) {
+		recordErrorStack(error, frame.stack);
+		throw error;
+	} finally {
+		frame.stack = previousStack;
+		frame.localIdCounter = previousLocalIdCounter;
+		setCurrentDataStore(previousDataStore);
+		setCurrentDispatcher(previousDispatcher);
+	}
+}
+function renderClientReference(type, props, frame) {
+	if (type.ssr !== void 0) {
+		renderComponentAssets(type, frame);
+		renderElement(createElement(type.ssr, props), frame);
+		return;
+	}
+	const fallback = frame.request.clientReferenceFallback;
+	if (fallback === void 0) {
+		renderFunctionComponent(type, props, frame);
+		return;
+	}
+	renderComponentAssets(type, frame);
+	renderChildren(fallback(type, props), frame);
+}
+function renderComponentAssets(type, frame) {
+	const key = isClientReference(type) ? type.id : frame.request.resolveAssetKey?.(type);
+	if (key !== void 0) renderAssetValue(frame.request.componentAssets?.[key], frame);
+}
+function renderContextProvider(context, props, frame) {
+	withContextValue(frame.contextValues, context, props.value, () => renderChildren(props.children, frame));
+}
+function renderAssets(props, frame) {
+	renderAssetValue(props.assets, frame);
+	renderChildren(props.children, frame);
+}
+function renderAssetValue(value, frame) {
+	if (value === void 0 || value === null || value === false) return;
+	for (const resource of Array.isArray(value) ? value : [value]) {
+		if (!isFigAssetResource(resource)) throw new Error("The assets prop must contain Fig asset resources.");
+		try {
+			if (frame.request.assetRegistry.register(resource)) reportLateHeadAsset(frame.request, resource, frame.stack);
+		} catch (error) {
+			recordErrorStack(error, frame.stack);
+			throw error;
+		}
+		frame.segment.assetResources.push(resource);
+	}
+}
+function reportLateHeadAsset(request, resource, stack) {
+	if (request.headSnapshot === null || assetResourceDestination(resource) !== "head") return;
+	const key = assetResourceKey(resource);
+	const error = /* @__PURE__ */ new Error(`Fig head resource "${key}" was discovered after headReady. Move required metadata outside pending Suspense boundaries, or wait for allReady before reading getHead().`);
+	try {
+		request.onAssetError?.(error, {
+			componentStack: componentStack(stack),
+			destination: "head",
+			key,
+			resource
+		});
+	} catch {}
+}
+function renderSuspense(props, frame) {
+	consumePendingLeadingNewline(frame);
+	const fallbackAbortableTasks = /* @__PURE__ */ new Set();
+	const contentSegment = createSegment(0, null);
+	const boundary = createBoundary(fallbackAbortableTasks, contentSegment);
+	boundary.activityId = frame.hiddenActivityId;
+	const parentSegment = frame.segment;
+	const boundarySegment = createSegment(parentSegment.chunks.length, boundary);
+	parentSegment.children.push(boundarySegment);
+	parentSegment.lastPushedText = false;
+	contentSegment.parentFlushed = true;
+	const contentFrame = createRenderFrame(frame.request, contentSegment, {
+		...forkScope(frame),
+		boundary
+	});
+	try {
+		renderChildren(props.children, contentFrame);
+		contentSegment.status = "completed";
+		boundary.completedSegments.push(contentSegment);
+		if (boundary.pendingTasks === 0) boundary.status = "completed";
+	} catch (error) {
+		contentSegment.status = "completed";
+		markBoundaryClientRendered(frame.request, boundary, error, frame.stack);
+	}
+	const advanceSurfaceWatermark = (branch) => {
+		if (frame.viewTransition !== null && branch.viewTransition !== null) frame.viewTransition.index = Math.max(frame.viewTransition.index, branch.viewTransition.index);
+	};
+	advanceSurfaceWatermark(contentFrame);
+	if (boundary.status === "completed") return;
+	const fallbackFrame = createRenderFrame(frame.request, boundarySegment, {
+		...forkScope(frame),
+		abortSet: fallbackAbortableTasks
+	});
+	try {
+		renderChildren(props.fallback, fallbackFrame);
+		boundarySegment.status = "completed";
+	} catch (error) {
+		if (boundary.pendingTasks > 0) for (const task of Array.from(boundary.fallbackAbortableTasks)) abortTask(frame.request, task);
+		throw error;
+	} finally {
+		advanceSurfaceWatermark(fallbackFrame);
+	}
+}
+function renderViewTransition(props, frame) {
+	const previousViewTransition = frame.viewTransition;
+	frame.viewTransition = createServerViewTransition(props, frame.request);
+	try {
+		renderChildren(props.children, frame);
+	} finally {
+		frame.viewTransition = previousViewTransition;
+	}
+}
+function createServerViewTransition(props, request) {
+	return {
+		className: serverViewTransitionClass(props),
+		index: 0,
+		name: props.name === void 0 || props.name === "auto" ? `fig-vt-${request.nextViewTransitionId++}` : props.name
+	};
+}
+function serverViewTransitionClass(props) {
+	const className = props.default;
+	if (className === void 0 || className === "auto" || className === "none") return null;
+	return className;
+}
+function renderActivity(props, frame) {
+	if (props.mode !== "hidden") {
+		renderChildren(props.children, frame);
+		return;
+	}
+	const id = activityId(frame.request, frame.request.nextActivityId++);
+	frame.segment.write(`<template ${ACTIVITY_TEMPLATE_ATTRIBUTE}="" id="${escapeAttribute(id)}">`);
+	const previousHiddenActivityId = frame.hiddenActivityId;
+	frame.hiddenActivityId = id;
+	try {
+		renderChildren(props.children, frame);
+	} finally {
+		frame.hiddenActivityId = previousHiddenActivityId;
+	}
+	frame.segment.write("</template>");
+}
+function renderHostElement(type, props, frame) {
+	if (renderHostAsset(type, props, frame)) return;
+	const document = frame.request.document;
+	if (document !== null && !document.hasHead) {
+		if (type !== "html" && type !== "head") throw invalidDocumentShellError();
+	}
+	if (document !== null && type === "html") frame.segment.write("<!doctype html>");
+	if (document !== null && type === "head") document.hasHead = true;
+	const isVoid = isVoidElement(type);
+	const unsafeHTML = unsafeHTMLContent(props);
+	if (isVoid && hasRenderableChild(props.children)) throw new Error(`Void element <${type}> cannot have children.`);
+	if (isVoid && unsafeHTML !== null) throw new Error(`Void element <${type}> cannot have unsafeHTML.`);
+	if (unsafeHTML !== null && hasRenderableChild(props.children)) throw new Error("Host elements cannot have both unsafeHTML and children.");
+	consumePendingLeadingNewline(frame);
+	const viewTransition = frame.viewTransition;
+	writeElementStart(type, viewTransition === null ? props : viewTransitionHostProps(props, viewTransition), frame.segment, frame.selectProps ?? {});
+	if (document !== null && type === "head") frame.segment.write(earlyEventCaptureMarkup(frame.request));
+	if (isVoid) return;
+	const previousPendingLeadingNewlineHost = frame.pendingLeadingNewlineHost;
+	frame.pendingLeadingNewlineHost = leadingNewlineStrippedHost(type) ? type : null;
+	if (unsafeHTML !== null) {
+		frame.segment.write(consumePendingLeadingNewline(frame) ? preserveParserStrippedLeadingNewline(unsafeHTML) : unsafeHTML);
+		frame.pendingLeadingNewlineHost = previousPendingLeadingNewlineHost;
+		writeElementEnd(type, frame.segment);
+		return;
+	}
+	const formText = formTextContent(type, props);
+	if (formText !== null) {
+		writeText(consumePendingLeadingNewline(frame) ? preserveParserStrippedLeadingNewline(formText) : formText, frame.segment);
+		frame.pendingLeadingNewlineHost = previousPendingLeadingNewlineHost;
+		writeElementEnd(type, frame.segment);
+		return;
+	}
+	const previousSelectProps = frame.selectProps;
+	if (type === "select") frame.selectProps = props;
+	const previousHostAncestors = frame.hostAncestors;
+	const previousViewTransition = frame.viewTransition;
+	if (viewTransition !== null) frame.viewTransition = null;
+	try {
+		renderChildren(props.children, frame);
+	} finally {
+		frame.selectProps = previousSelectProps;
+		frame.hostAncestors = previousHostAncestors;
+		frame.viewTransition = previousViewTransition;
+		frame.pendingLeadingNewlineHost = previousPendingLeadingNewlineHost;
+	}
+	if (document !== null && type === "head") writeDocumentHeadMarker(frame.segment);
+	writeElementEnd(type, frame.segment);
+}
+function renderHostAsset(type, props, frame) {
+	const resource = assetResourceFromHostProps(type, props);
+	if (resource === null) return false;
+	renderAssetValue(resource, frame);
+	return true;
+}
+function viewTransitionHostProps(props, viewTransition) {
+	const index = viewTransition.index++;
+	const name = index === 0 ? viewTransition.name : `${viewTransition.name}_${index}`;
+	const nextProps = {
+		...props,
+		[VIEW_TRANSITION_NAME_ATTRIBUTE]: name
+	};
+	if (viewTransition.className !== null) nextProps[VIEW_TRANSITION_CLASS_ATTRIBUTE] = viewTransition.className;
+	return nextProps;
+}
+function spawnSuspendedTask(frame, node, thenable, childIndexBase) {
+	const request = frame.request;
+	const segment = createSegment(frame.segment.chunks.length, null, {
+		lastPushedText: frame.segment.lastPushedText,
+		textEmbedded: true
+	});
+	frame.segment.lastPushedText = false;
+	frame.segment.children.push(segment);
+	const task = createTask(request, node, segment, forkScope(frame), childIndexBase);
+	thenable.then(() => pingTask(request, task), () => pingTask(request, task));
+}
+function pingTask(request, task) {
+	if (request.status === "closed" || request.status === "aborting") return;
+	request.pingedTasks.push(task);
+	if (request.workScheduled) return;
+	request.workScheduled = true;
+	queueMicrotask(() => {
+		request.workScheduled = false;
+		performWork(request);
+	});
+}
+function finishedTask(request, task, segment) {
+	request.pendingTasks -= 1;
+	const boundary = task.boundary;
+	if (boundary === null) {
+		request.pendingRootTasks -= 1;
+		if (segment === request.rootSegment || request.completedRootSegment === null) request.completedRootSegment = request.rootSegment;
+		if (request.pendingRootTasks === 0) finishRootShell(request);
+	} else {
+		boundary.pendingTasks -= 1;
+		if (segment.parentFlushed) enqueueUnique(boundary.completedSegments, segment);
+		if (!completeBoundaryIfReady(request, boundary) && boundary.parentFlushed) request.partialBoundaries.add(boundary);
+	}
+	if (request.pendingTasks === 0) request.allReady.resolve(void 0);
+}
+function erroredTask(request, task, error) {
+	request.pendingTasks -= 1;
+	const boundary = task.boundary;
+	if (boundary === null) {
+		request.pendingRootTasks -= 1;
+		fatalError(request, error);
+		return;
+	}
+	boundary.pendingTasks -= 1;
+	markBoundaryClientRendered(request, boundary, error, task.stack);
+	if (request.pendingTasks === 0) request.allReady.resolve(void 0);
+}
+function detachTask(request, task) {
+	task.abortSet.delete(task);
+	request.abortableTasks.delete(task);
+}
+function abortTask(request, task) {
+	if (!request.abortableTasks.delete(task)) return;
+	task.segment.status = "completed";
+	task.abortSet.delete(task);
+	request.pendingTasks -= 1;
+	const boundary = task.boundary;
+	if (boundary === null) {
+		request.pendingRootTasks -= 1;
+		if (request.pendingRootTasks === 0) finishRootShell(request);
+	} else {
+		boundary.pendingTasks -= 1;
+		completeBoundaryIfReady(request, boundary);
+	}
+	if (request.pendingTasks === 0) request.allReady.resolve(void 0);
+}
+function completeBoundaryIfReady(request, boundary) {
+	if (boundary.pendingTasks !== 0 || boundary.status !== "pending") return false;
+	boundary.status = "completed";
+	abortFallbackTasks(request, boundary);
+	if (boundary.parentFlushed) request.completedBoundaries.add(boundary);
+	return true;
+}
+function abortFallbackTasks(request, boundary) {
+	for (const fallbackTask of Array.from(boundary.fallbackAbortableTasks)) abortTask(request, fallbackTask);
+}
+function markBoundaryClientRendered(request, boundary, error, stack, payload) {
+	if (boundary.status !== "client-rendered") {
+		boundary.status = "client-rendered";
+		boundary.error = payload ?? reportBoundaryError(request, error, stack);
+	}
+	boundary.completedSegments = [];
+	request.completedBoundaries.delete(boundary);
+	request.partialBoundaries.delete(boundary);
+	for (const task of Array.from(request.abortableTasks)) if (task.boundary === boundary) abortTask(request, task);
+	for (const task of Array.from(boundary.fallbackAbortableTasks)) abortTask(request, task);
+	if (boundary.parentFlushed) request.clientRenderedBoundaries.add(boundary);
+}
+function abort(request, reason) {
+	if (request.status === "closed") return;
+	cleanupAbortListener(request);
+	request.status = "aborting";
+	request.dataStore.dispose();
+	const error = abortError(reason);
+	request.fatalError = error;
+	if (request.pendingRootTasks > 0) {
+		fatalError(request, error);
+		return;
+	}
+	for (const task of Array.from(request.abortableTasks)) {
+		const boundary = task.boundary;
+		if (boundary !== null) markBoundaryClientRendered(request, boundary, error, task.stack, {});
+	}
+	request.abortableTasks.clear();
+	request.pendingTasks = 0;
+	request.allReady.resolve(void 0);
+	flushCompletedQueues(request);
+}
+function fatalError(request, error) {
+	if (request.status === "closed") return;
+	cleanupAbortListener(request);
+	request.status = "closed";
+	request.dataStore.dispose();
+	request.fatalError = error;
+	request.headReady.reject(error);
+	request.shellReady.reject(error);
+	request.allReady.reject(error);
+	request.controller?.error(error);
+}
+function finishRootShell(request) {
+	if (request.document !== null && !request.document.hasHead) {
+		fatalError(request, invalidDocumentShellError());
+		return;
+	}
+	if (!request.prerender) sealHead(request);
+	request.shellReady.resolve(void 0);
+}
+function flushCompletedQueues(request) {
+	if (request.controller === null || request.status === "closed") return;
+	if (request.status === "opening") return;
+	if (request.pendingRootTasks > 0) return;
+	if (request.prerender && request.pendingTasks > 0) return;
+	sealHead(request);
+	if (request.completedRootSegment !== null) {
+		flushSegment(request, request.completedRootSegment);
+		request.completedRootSegment = null;
+		flushWriteBuffer(request);
+	}
+	drainBoundaryQueue(request, request.clientRenderedBoundaries, flushClientRenderedBoundary);
+	drainBoundaryQueue(request, request.completedBoundaries, flushCompletedBoundary);
+	drainBoundaryQueue(request, request.partialBoundaries, flushPartialBoundary);
+	flushWriteBuffer(request);
+	if (request.pendingTasks === 0 && request.completedBoundaries.size === 0 && request.clientRenderedBoundaries.size === 0 && request.partialBoundaries.size === 0) {
+		cleanupAbortListener(request);
+		request.status = "closed";
+		request.dataStore.dispose();
+		request.controller.close();
+	}
+}
+function flushSegment(request, segment) {
+	if (segment.boundary !== null) {
+		flushSuspenseBoundary(request, segment, segment.boundary);
+		return;
+	}
+	flushSubtree(request, segment);
+}
+function flushSubtree(request, segment) {
+	segment.parentFlushed = true;
+	if (segment.status === "pending" || segment.status === "rendering") {
+		write(request, placeholderMarkup(request, ensureSegmentId(request, segment)));
+		return;
+	}
+	if (segment.status === "flushed") return;
+	segment.status = "flushed";
+	if (request.document === null || segment !== request.rootSegment) flushSegmentAssets(request, segment);
+	let chunkIndex = 0;
+	for (const child of segment.children) {
+		for (; chunkIndex < child.index; chunkIndex += 1) writeChunk(request, segment.chunks[chunkIndex], segment);
+		flushSegment(request, child);
+	}
+	for (; chunkIndex < segment.chunks.length; chunkIndex += 1) writeChunk(request, segment.chunks[chunkIndex], segment);
+}
+function flushSuspenseBoundary(request, segment, boundary) {
+	segment.boundary = null;
+	boundary.parentFlushed = true;
+	if (boundary.status === "completed") {
+		write(request, `<!--${SUSPENSE_COMPLETED_MARKER}-->`);
+		flushBoundaryContent(request, boundary);
+		write(request, `<!--${SUSPENSE_END_MARKER}-->`);
+		return;
+	}
+	if (request.prerender && boundary.status === "client-rendered") {
+		write(request, `<!--${SUSPENSE_CLIENT_MARKER}-->`);
+		write(request, clientRenderedBoundaryPlaceholderMarkup(request, boundary));
+		flushSubtree(request, segment);
+		write(request, `<!--${SUSPENSE_END_MARKER}-->`);
+		return;
+	}
+	const boundaryIdValue = ensureBoundaryId(request, boundary);
+	flushSegmentAssets(request, boundary.contentSegment);
+	write(request, `<!--${SUSPENSE_PENDING_PREFIX}${boundaryIdValue}-->`);
+	write(request, boundaryPlaceholderMarkup(request, boundaryIdValue));
+	flushSubtree(request, segment);
+	write(request, `<!--${SUSPENSE_END_MARKER}-->`);
+	if (boundary.status === "client-rendered") request.clientRenderedBoundaries.add(boundary);
+	else if (boundary.completedSegments.length > 0) request.partialBoundaries.add(boundary);
+}
+function flushBoundaryContent(request, boundary) {
+	for (const segment of boundary.completedSegments) flushSegment(request, segment);
+	boundary.completedSegments = [];
+}
+function clientRenderedBoundaryPlaceholderMarkup(request, boundary) {
+	const id = escapeAttribute(boundaryId(request, ensureBoundaryId(request, boundary)));
+	const digest = boundary.error?.digest;
+	const message = boundary.error?.message;
+	return `<template id="${id}"${digest === void 0 || digest === "" ? "" : ` data-dgst="${escapeAttribute(digest)}"`}${message === void 0 || message === "" ? "" : ` data-msg="${escapeAttribute(message)}"`}></template>`;
+}
+function sealHead(request) {
+	if (request.headSnapshot !== null) return;
+	const head = request.assetRegistry.headHtml(request.nonce);
+	request.headSnapshot = head;
+	request.headReady.resolve(head);
+}
+function flushCompletedBoundary(request, boundary) {
+	flushPartialBoundary(request, boundary);
+	writeBoundaryRevealScript(request, boundary);
+}
+function flushPartialBoundary(request, boundary) {
+	for (const segment of boundary.completedSegments) flushBoundarySegment(request, boundary, segment);
+	boundary.completedSegments = [];
+}
+function flushBoundarySegment(request, boundary, segment) {
+	ensureBoundaryId(request, boundary);
+	ensureSegmentId(request, segment);
+	const blockingIds = flushSegmentContainer(request, segment);
+	if (segment !== boundary.contentSegment) writeSegmentRevealScript(request, segment, blockingIds);
+}
+function writeSegmentRevealScript(request, segment, blockingIds) {
+	const id = ensureSegmentId(request, segment);
+	writeRuntime(request);
+	writeScript(request, withAssetGate(request, blockingIds, `${RUNTIME_REF}.s(${jsString(placeholderId(request, id))},${jsString(segmentId(request, id))})`));
+}
+function writeBoundaryRevealScript(request, boundary) {
+	const blockingIds = flushSegmentAssets(request, boundary.contentSegment);
+	writeRuntime(request);
+	const boundaryRef = jsString(boundaryId(request, ensureBoundaryId(request, boundary)));
+	const contentRef = jsString(segmentId(request, ensureSegmentId(request, boundary.contentSegment)));
+	const runtime = RUNTIME_REF;
+	writeScript(request, withAssetGate(request, blockingIds, boundary.activityId === null ? `${runtime}.c(${boundaryRef},${contentRef})` : `${runtime}.ac(${jsString(boundary.activityId)},${boundaryRef},${contentRef})`));
+}
+function flushSegmentContainer(request, segment) {
+	if (segment.status === "flushed") return [];
+	const blockingIds = flushSegmentAssets(request, segment);
+	write(request, segmentContainerStartMarkup(request, ensureSegmentId(request, segment)));
+	flushSegment(request, segment);
+	write(request, "</div>");
+	return blockingIds;
+}
+function flushSegmentAssets(request, segment) {
+	const blockingIds = /* @__PURE__ */ new Set();
+	collectSegmentAssets(request, segment, request.assetSink, blockingIds);
+	return [...blockingIds];
+}
+function collectSegmentAssets(request, segment, sink, blockingIds) {
+	if (segment.status !== "pending" && segment.status !== "rendering") flushAssetList(request, segment.assetResources, sink, blockingIds);
+	for (const child of segment.children) collectSegmentAssets(request, child, sink, blockingIds);
+}
+function flushAssetList(request, resources, sink, blockingIds) {
+	for (const resource of resources) {
+		const id = request.assetRegistry.write(resource, sink);
+		if (id !== null) blockingIds.add(id);
+	}
+}
+function withAssetGate(request, blockingIds, call) {
+	if (blockingIds.length === 0) return call;
+	return `${RUNTIME_REF}.r([${blockingIds.map(jsString).join(",")}],()=>{${call}})`;
+}
+function flushClientRenderedBoundary(request, boundary) {
+	if (boundary.id === null) return;
+	writeRuntime(request);
+	const boundaryRef = jsString(boundaryId(request, boundary.id));
+	const digest = jsString(boundary.error?.digest ?? "");
+	const message = jsString(boundary.error?.message ?? "");
+	const runtime = RUNTIME_REF;
+	writeScript(request, boundary.activityId === null ? `${runtime}.x(${boundaryRef},${digest},${message})` : `${runtime}.ax(${jsString(boundary.activityId)},${boundaryRef},${digest},${message})`);
+}
+function drainBoundaryQueue(request, queue, flush) {
+	for (;;) {
+		const first = queue.values().next();
+		if (first.done === true) return;
+		flush(request, first.value);
+		queue.delete(first.value);
+		flushWriteBuffer(request);
+	}
+}
+function enqueueUnique(queue, item) {
+	if (!queue.includes(item)) queue.push(item);
+}
+function reportBoundaryError(request, error, stack) {
+	const info = { componentStack: componentStack(stackForError(error, stack)) };
+	if (request.onError === void 0) return {};
+	try {
+		return request.onError(error, info) ?? {};
+	} catch {
+		return {};
+	}
+}
+function recordErrorStack(error, stack) {
+	if (stack === null) return;
+	if (typeof error !== "object" && typeof error !== "function") return;
+	if (error === null || isThenable(error)) return;
+	if (!errorStacks.has(error)) errorStacks.set(error, stack);
+}
+function stackForError(error, fallback) {
+	if (typeof error !== "object" && typeof error !== "function" || error === null) return fallback;
+	return errorStacks.get(error) ?? fallback;
+}
+function writeRuntime(request) {
+	writeRuntime$1(request, (chunk) => write(request, chunk));
+}
+function writeScript(request, code) {
+	writeScript$1(request, `(__figSSR=>{${code}})(globalThis[${jsString(request.runtimeName)}])`, (chunk) => write(request, chunk));
+}
+function createRuntimeName(identifierPrefix) {
+	const id = nextRuntimeId.toString(36);
+	nextRuntimeId += 1;
+	const prefix = identifierPrefix?.replace(/[^A-Za-z0-9_$]/g, "_") ?? "";
+	return prefix === "" ? `__figSSR_${id}` : `__figSSR_${prefix}_${id}`;
+}
+function writeChunk(request, chunk, segment) {
+	if (chunk !== documentHeadMarker) {
+		write(request, chunk);
+		return;
+	}
+	if (request.document === null) return;
+	write(request, request.assetRegistry.headHtml(request.nonce));
+	flushAssetList(request, segment.assetResources, request.assetSink, /* @__PURE__ */ new Set());
+}
+function write(request, chunk) {
+	request.writeBuffer.push(chunk);
+}
+function writeDocumentHeadMarker(segment) {
+	segment.lastPushedText = false;
+	segment.chunks.push(documentHeadMarker);
+}
+function consumePendingLeadingNewline(frame) {
+	const pending = frame.pendingLeadingNewlineHost !== null;
+	frame.pendingLeadingNewlineHost = null;
+	return pending;
+}
+function leadingNewlineStrippedHost(type) {
+	return type === "pre" || type === "textarea";
+}
+function preserveParserStrippedLeadingNewline(text) {
+	return text.startsWith("\n") ? `\n${text}` : text;
+}
+function cleanupAbortListener(request) {
+	if (request.abortListener === null || request.abortSignal === null) return;
+	request.abortSignal.removeEventListener("abort", request.abortListener);
+	request.abortListener = null;
+	request.abortSignal = null;
+}
+function flushWriteBuffer(request) {
+	if (request.writeBuffer.length === 0 || request.controller === null) return;
+	request.controller.enqueue(textEncoder.encode(request.writeBuffer.join("")));
+	request.writeBuffer = [];
+}
+function invalidDocumentShellError() {
+	return /* @__PURE__ */ new Error("renderToDocumentStream requires the root to render an <html> document with a <head>.");
+}
+function ensureSegmentId(request, segment) {
+	segment.id ??= request.nextSegmentId++;
+	return segment.id;
+}
+function ensureBoundaryId(request, boundary) {
+	boundary.id ??= request.nextBoundaryId++;
+	return boundary.id;
+}
+function componentStack(stack) {
+	const frames = [];
+	for (let frame = stack; frame !== null; frame = frame.parent) frames.push(`    at ${frame.name}`);
+	return frames.length === 0 ? "" : `\n${frames.join("\n")}`;
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted === true) throw abortReason(signal.reason);
+}
+function throwIfAborting(request) {
+	if (request.status === "aborting") throw abortReason(request.fatalError);
+}
+function abortError(reason) {
+	if (reason instanceof Error) return reason;
+	return new Error(typeof reason === "string" ? reason : "Server render was aborted.");
+}
+function abortReason(reason) {
+	return reason ?? /* @__PURE__ */ new Error("Server render was aborted.");
+}
+function describeElementType(type) {
+	if (typeof type === "symbol") return String(type);
+	if (typeof type === "function") return type.name || "anonymous function";
+	return typeof type;
+}
+//#endregion
+//#region src/render-tree.ts
+function createRenderTreeCollector() {
+	return { tree: {
+		children: [],
+		key: null,
+		kind: "root",
+		name: "Root",
+		props: {}
+	} };
+}
+//#endregion
+//#region src/index.ts
+function renderToStream(node, options = {}) {
+	return createServerRenderRequest(node, options);
+}
+function renderToDocumentStream(node, options = {}) {
+	const request = createServerRenderRequest(node, options, { document: true });
+	return {
+		abort: (reason) => request.abort(reason),
+		allReady: request.allReady,
+		contentType: request.contentType,
+		getData: () => request.getData(),
+		shellReady: request.shellReady,
+		stream: request.stream
+	};
+}
+/**
+* The streamed output, buffered: awaits `allReady` and concatenates exactly
+* the bytes a streaming client would have received — including the inline
+* streaming runtime and boundary-reveal scripts when the tree suspends past
+* the shell. Right for caching responses and snapshotting wire output; it is
+* NOT React's `renderToString` (use `prerender` for settled, script-free
+* static markup).
+*/
+async function renderToHtml(node, options = {}) {
+	const result = renderToStream(node, options);
+	await result.allReady;
+	return readStreamToString(result.stream);
+}
+/** Document-mode {@link renderToHtml}: the streamed document, buffered. */
+async function renderToDocumentHtml(node, options = {}) {
+	const result = renderToDocumentStream(node, options);
+	await result.allReady;
+	return readStreamToString(result.stream);
+}
+/**
+* Settled static HTML: waits for all async work before flushing, so completed
+* Suspense content is emitted in logical position without streaming scripts.
+*/
+async function prerender(node, options = {}) {
+	const { document = false, ...renderOptions } = options;
+	const result = createServerRenderRequest(node, renderOptions, {
+		document,
+		prerender: true
+	});
+	await result.allReady;
+	const html = await readStreamToString(result.stream);
+	return {
+		data: result.getData(),
+		head: document ? "" : result.getHead(),
+		html
+	};
+}
+async function readStreamToString(stream) {
+	const reader = stream.getReader();
+	const textDecoder = new TextDecoder();
+	let output = "";
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) return output + textDecoder.decode();
+		output += textDecoder.decode(value, { stream: true });
+	}
+}
+//#endregion
+export { createRenderTreeCollector, escapeAttribute, escapeText, prerender, renderToDocumentHtml, renderToDocumentStream, renderToHtml, renderToStream };
+
+//# sourceMappingURL=index.js.map