@bgub/fig-server 0.0.1

package/dist/payload.js

@@ -0,0 +1,1700 @@
+import { i as withContextValue, n as createStaticDispatcher, r as deferred, t as cloneContextValues } from "./shared-CQn6Dje6.js";
+import { Fragment, Suspense, ViewTransition, clientReference, createElement, readPromise } from "@bgub/fig";
+import { FigElementSymbol, assetResourceDestination, assetResourceKey, clientReferenceAssets, createDataStore, describeInvalidChild, isActivity, isAssets, isClientReference, isContext, isErrorBoundary, isFigAssetResource, isPortal, isSuspense, isThenable, isValidElement, isViewTransition, normalizeDataResourceKey, readThenable, setCurrentDataStore, setCurrentDispatcher, trackThenable } from "@bgub/fig/internal";
+//#region src/payload.ts
+const PAYLOAD_BOUNDARY_HEADER = "x-fig-payload-boundary";
+var PayloadRequestCancelledError = class extends Error {
+	constructor() {
+		super("Payload request cancelled.");
+		this.name = "PayloadRequestCancelledError";
+	}
+};
+var PayloadFetchError = class extends Error {
+	response;
+	status;
+	constructor(response) {
+		super(`Payload request failed with status ${response.status}.`);
+		this.name = "PayloadFetchError";
+		this.response = response;
+		this.status = response.status;
+	}
+};
+const textEncoder = new TextEncoder();
+const PayloadBoundarySymbol = Symbol.for("fig.payload-boundary");
+const errorStacks = /* @__PURE__ */ new WeakMap();
+const childrenTreeProps = /* @__PURE__ */ new Set(["children"]);
+const emptyTreeProps = /* @__PURE__ */ new Set();
+const suspenseTreeProps = /* @__PURE__ */ new Set(["children", "fallback"]);
+function createPayloadGraphEncodeContext() {
+	return {
+		ids: /* @__PURE__ */ new WeakMap(),
+		nextId: 1,
+		objects: /* @__PURE__ */ new Map()
+	};
+}
+function createPayloadGraphDecodeContext() {
+	return { refs: /* @__PURE__ */ new Map() };
+}
+/**
+* Readable development-oriented codec: one JSON payload row per newline.
+*/
+const jsonPayloadCodec = {
+	id: "json",
+	contentType: "text/x-fig-payload; codec=json; charset=utf-8",
+	createDecoder(onRow) {
+		return createJsonPayloadDecoder(onRow);
+	},
+	encodeRow(row) {
+		return textEncoder.encode(`${JSON.stringify(row)}\n`);
+	}
+};
+function createJsonPayloadDecoder(onRow) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let searchStart = 0;
+	function processBufferedLines() {
+		let lineStart = 0;
+		let firstError;
+		for (;;) {
+			const newlineIndex = buffer.indexOf("\n", searchStart);
+			if (newlineIndex === -1) {
+				searchStart = buffer.length;
+				break;
+			}
+			try {
+				processPayloadLine(buffer.slice(lineStart, newlineIndex), onRow);
+			} catch (error) {
+				firstError ??= error;
+			}
+			lineStart = newlineIndex + 1;
+			searchStart = lineStart;
+		}
+		if (firstError !== void 0) {
+			buffer = "";
+			searchStart = 0;
+			throw firstError;
+		}
+		if (lineStart > 0) {
+			buffer = buffer.slice(lineStart);
+			searchStart -= lineStart;
+		}
+	}
+	return {
+		decode(chunk) {
+			buffer += decoder.decode(chunk, { stream: true });
+			processBufferedLines();
+		},
+		flush() {
+			buffer += decoder.decode();
+			if (buffer.length > 0) {
+				const line = buffer;
+				buffer = "";
+				searchStart = 0;
+				processPayloadLine(line, onRow);
+			}
+		}
+	};
+}
+function processPayloadLine(line, onRow) {
+	if (line.length > 0) onRow(JSON.parse(line));
+}
+function payloadCodecIdFromContentType(contentTypeHeader) {
+	const parts = contentTypeHeader.split(";").slice(1);
+	for (const part of parts) {
+		const [name, rawValue] = part.split("=");
+		if (name?.trim().toLowerCase() !== "codec") continue;
+		const value = rawValue?.trim();
+		if (value === void 0 || value.length === 0) return null;
+		return value.replace(/^"|"$/g, "");
+	}
+	return null;
+}
+const PayloadBoundary = Object.assign((props) => props.children, { $$typeof: PayloadBoundarySymbol });
+function renderToPayloadStream(node, options = {}) {
+	const request = createPayloadRequest(node, options);
+	return {
+		abort: (reason) => abortPayloadRequest(request, reason),
+		allReady: request.allReady.promise,
+		contentType: request.codec.contentType,
+		stream: request.stream
+	};
+}
+function createPayloadResponse(options = {}) {
+	return new PayloadResponseImpl(options);
+}
+async function processPayloadStream(response, stream, signal) {
+	await response.processStream(stream, signal);
+}
+function isPayloadRequestCancelled(error) {
+	return error instanceof PayloadRequestCancelledError || typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError";
+}
+async function fetchPayload(response, input, options = {}) {
+	const { fetch: fetchImpl = globalThis.fetch, headers, refreshBoundary, signal, ...init } = options;
+	if (fetchImpl === void 0) throw new Error("fetchPayload requires a fetch implementation.");
+	throwIfAborted(signal);
+	const result = await fetchImpl(input, {
+		...init,
+		headers: appendPayloadHeaders(response.codec, headers, refreshBoundary),
+		signal
+	});
+	throwIfAborted(signal);
+	if (!result.ok) {
+		await result.body?.cancel().catch(() => void 0);
+		throw new PayloadFetchError(result);
+	}
+	if (result.body === null) throw new Error("Payload response did not include a body.");
+	assertPayloadCodecMatches(response.codec, result.headers.get("content-type"));
+	if (refreshBoundary !== void 0) response.beginRefreshPayload();
+	await processPayloadStream(response, result.body, signal);
+	return result;
+}
+function createPayloadRequest(node, options) {
+	throwIfAborted(options.signal);
+	const pendingDataSnapshots = /* @__PURE__ */ new Map();
+	const request = {
+		abortListener: null,
+		abortSignal: null,
+		allReady: deferred(),
+		boundaryIds: null,
+		clientReferenceRows: /* @__PURE__ */ new Map(),
+		clientReferenceAssets: options.clientReferenceAssets,
+		codec: options.codec ?? jsonPayloadCodec,
+		controller: null,
+		dataStore: createDataStore({
+			getLane: () => null,
+			onEntryChange: (entry) => {
+				pendingDataSnapshots.set(entry.canonicalKey, entry);
+			},
+			partition: options.dataPartition,
+			schedule: () => void 0
+		}),
+		emittedAssetKeys: /* @__PURE__ */ new Set(),
+		emittedDataKeys: /* @__PURE__ */ new Set(),
+		graph: createPayloadGraphEncodeContext(),
+		nextRowId: 1,
+		nextUseId: 0,
+		onError: options.onError,
+		pendingDataSnapshots,
+		pendingTasks: 0,
+		pingedTasks: [],
+		queuedRows: [],
+		refreshBoundary: options.refreshBoundary ?? null,
+		status: "opening",
+		stream: null,
+		workScheduled: false
+	};
+	request.allReady.promise.catch(() => void 0);
+	request.stream = new ReadableStream({
+		start(controller) {
+			request.controller = controller;
+			flushRows(request);
+		},
+		cancel(reason) {
+			abortPayloadRequest(request, reason);
+		}
+	});
+	if (options.signal !== void 0) {
+		const abortListener = () => abortPayloadRequest(request, options.signal?.reason);
+		request.abortListener = abortListener;
+		request.abortSignal = options.signal;
+		options.signal.addEventListener("abort", abortListener, { once: true });
+	}
+	request.pingedTasks.push(createTask(request, 0, "node", node, /* @__PURE__ */ new Map(), null));
+	request.workScheduled = true;
+	queueMicrotask(() => {
+		request.workScheduled = false;
+		performWork(request);
+	});
+	return request;
+}
+var PayloadResponseImpl = class {
+	options;
+	assetResources = /* @__PURE__ */ new Map();
+	boundaries = /* @__PURE__ */ new Map();
+	decodedBoundaries = /* @__PURE__ */ new Map();
+	initialBoundaries = /* @__PURE__ */ new Map();
+	clientReferences = /* @__PURE__ */ new Map();
+	chunks = /* @__PURE__ */ new Map();
+	clientReferenceEntries = /* @__PURE__ */ new Map();
+	resolvedClientReferenceComponents = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	resolveRootReady = () => void 0;
+	rootReady = new Promise((resolve) => {
+		this.resolveRootReady = resolve;
+	});
+	maxRowId = 0;
+	maxObjectId = 0;
+	objectIdBase = 0;
+	objectRefs = /* @__PURE__ */ new Map();
+	pendingData = [];
+	rootData = null;
+	rowIdBase = 0;
+	currentDecodeRevision = 0;
+	stringDecoder;
+	nextModelRevision = 1;
+	maxObjectIdScanDirty = false;
+	codec;
+	constructor(options) {
+		this.options = options;
+		this.codec = options.codec ?? jsonPayloadCodec;
+		this.stringDecoder = this.createDecoder(this.rowIdBase, this.objectIdBase);
+	}
+	beginRefreshPayload() {
+		this.ensureMaxObjectIdScanned();
+		this.rowIdBase = this.maxRowId;
+		this.objectIdBase = this.maxObjectId;
+		this.stringDecoder = this.createDecoder(this.rowIdBase, this.objectIdBase);
+	}
+	resetPayloadDecoder() {
+		this.rowIdBase = 0;
+		this.objectIdBase = 0;
+		this.stringDecoder = this.createDecoder(this.rowIdBase, this.objectIdBase);
+	}
+	getAssetResources() {
+		return [...this.assetResources.values()];
+	}
+	getClientReferences() {
+		return [...this.clientReferences.values()];
+	}
+	recordAssetResources(assets) {
+		if (assets === void 0) return;
+		for (const resource of assets) {
+			if (!isFigAssetResource(resource) || assetResourceDestination(resource) !== "stream") continue;
+			const key = assetResourceKey(resource);
+			if (!this.assetResources.has(key)) this.assetResources.set(key, resource);
+		}
+	}
+	recordClientReference(value) {
+		if (this.clientReferences.has(value.id)) return;
+		const reference = { id: value.id };
+		const assets = value.assets?.filter(isFigAssetResource);
+		if (assets !== void 0) reference.assets = assets;
+		if (value.exportName !== void 0) reference.exportName = value.exportName;
+		if (value.ssr === true) reference.ssr = true;
+		this.clientReferences.set(value.id, reference);
+		const load = this.options.loadClientReference;
+		if (load !== void 0) {
+			const metadata = clientRowMetadata(value);
+			if (this.options.resolveClientReference?.(metadata) === void 0) this.clientReferenceEntry(metadata, load);
+		}
+	}
+	bindRoot(root) {
+		this.rootData = root.data ?? null;
+		this.hydratePendingData();
+		const render = () => root.render(this.getRoot());
+		const unsubscribe = this.subscribe(render);
+		render();
+		return unsubscribe;
+	}
+	getRoot() {
+		return createElement(PayloadResponseRoot, { response: this });
+	}
+	createDecoder(rowIdBase, objectIdBase) {
+		return this.codec.createDecoder((row) => this.processRow(row, rowIdBase, objectIdBase));
+	}
+	processRow(row, rowIdBase, objectIdBase) {
+		if (rowIdBase > 0 || objectIdBase > 0) shiftRowIds(row, rowIdBase, objectIdBase);
+		this.markMaxObjectIdScanDirty(row);
+		if (row.tag === "data") {
+			this.pendingData.push(...decodePayloadDataEntries(row.value));
+			this.hydratePendingData();
+			return;
+		}
+		if (row.tag === "assets") {
+			this.recordAssetResources(row.value);
+			this.notify();
+			return;
+		}
+		if (row.tag === "refresh") {
+			const revision = this.claimModelRevision();
+			this.boundaries.set(row.boundary, {
+				model: row.value,
+				revision
+			});
+			this.invalidateDecodeCachesForBoundary(row.boundary);
+			this.decodedBoundaries.set(row.boundary, this.decodeModelAtRevision(row.value, revision));
+			const activeBoundaries = this.refreshRetainedChunks();
+			this.pruneObjectRefs(activeBoundaries);
+			this.notify();
+			return;
+		}
+		if (row.tag === "refresh-error") {
+			this.notify();
+			throw errorFromPayload(row.value);
+		}
+		const revision = row.tag === "model" ? this.claimModelRevision() : 0;
+		resolveDecodedRow(this, row, revision);
+		if (row.id === 0) {
+			if (row.tag === "model") {
+				const activeBoundaries = this.refreshRetainedChunks();
+				this.pruneObjectRefs(activeBoundaries);
+			}
+			this.resolveRootReady();
+			this.notify();
+		}
+	}
+	async processStream(stream, signal) {
+		const decoder = this.createDecoder(this.rowIdBase, this.objectIdBase);
+		try {
+			await readByteStream(stream, (chunk) => decoder.decode(chunk), signal);
+			decoder.flush();
+		} finally {
+			this.resetPayloadDecoder();
+		}
+	}
+	processBytesChunk(chunk) {
+		this.stringDecoder.decode(chunk);
+	}
+	processStringChunk(chunk) {
+		this.processBytesChunk(textEncoder.encode(chunk));
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	invalidateDecodeCachesForBoundary(id) {
+		for (const boundaryId of this.decodedBoundaries.keys()) {
+			const entry = this.currentBoundaryEntry(boundaryId);
+			if (boundaryId === id || entry !== void 0 && this.modelCanReachBoundary(entry.model, id)) this.decodedBoundaries.delete(boundaryId);
+		}
+		for (const chunk of this.chunks.values()) if (chunk.model !== null && this.modelCanReachBoundary(chunk.model, id)) {
+			chunk.decoded = void 0;
+			chunk.hasDecoded = false;
+		}
+	}
+	defineObjectRef(id, create, fill) {
+		const existing = this.objectRefs.get(id);
+		if (existing !== void 0) return existing.value;
+		const value = create();
+		this.objectRefs.set(id, { value });
+		if (id > this.maxObjectId) this.maxObjectId = id;
+		try {
+			fill(value);
+			return value;
+		} catch (error) {
+			this.objectRefs.delete(id);
+			throw error;
+		}
+	}
+	readObjectRef(id) {
+		const ref = this.objectRefs.get(id);
+		if (ref === void 0) throw new Error(`Payload referenced unknown object id ${id}.`);
+		return ref.value;
+	}
+	noteObjectId(id) {
+		if (id > this.maxObjectId) this.maxObjectId = id;
+	}
+	prepareBoundaryInitial(id, initial) {
+		const revision = this.currentDecodeRevision;
+		const previous = this.initialBoundaries.get(id);
+		this.initialBoundaries.set(id, {
+			model: initial,
+			revision
+		});
+		if (this.currentBoundaryEntry(id)?.model !== initial) return;
+		if (previous?.model === initial && previous.revision === revision && this.decodedBoundaries.has(id)) return;
+		const decoded = this.decodeModelAtRevision(initial, revision);
+		this.decodedBoundaries.set(id, decoded);
+	}
+	pruneObjectRefs(activeBoundaries = this.activeBoundaryEntries()) {
+		if ([...this.chunks.entries()].some(([id, chunk]) => id !== 0 && chunk.status === "pending")) return;
+		const retained = /* @__PURE__ */ new Set();
+		for (const chunk of this.chunks.values()) if (chunk.model !== null) collectObjectIds(chunk.model, retained);
+		for (const entry of activeBoundaries) collectObjectIds(entry.model, retained);
+		for (const id of this.objectRefs.keys()) if (!retained.has(id)) this.objectRefs.delete(id);
+	}
+	readBoundary(id, initial) {
+		let decoded = this.decodedBoundaries.get(id);
+		if (decoded === void 0) {
+			const entry = this.currentBoundaryEntry(id);
+			const model = entry?.model ?? initial;
+			const revision = entry?.revision ?? this.currentDecodeRevision;
+			decoded = this.decodeModelAtRevision(model, revision);
+			this.decodedBoundaries.set(id, decoded);
+		}
+		return decoded;
+	}
+	readChunk(id) {
+		const chunk = this.getChunk(id);
+		if (chunk.status === "rejected") throw chunk.value;
+		if (chunk.status === "pending") readPromise(chunk.promise);
+		if (chunk.model === null) return chunk.value;
+		if (!chunk.hasDecoded) {
+			chunk.decoded = this.decodeModelAtRevision(chunk.model, chunk.revision);
+			chunk.hasDecoded = true;
+		}
+		return chunk.decoded;
+	}
+	decodeClientReference(metadata) {
+		const resolvedCached = this.resolvedClientReferenceComponents.get(metadata.id);
+		if (resolvedCached !== void 0) return resolvedCached;
+		const cached = this.clientReferenceEntries.get(metadata.id)?.component;
+		if (cached !== void 0) return cached;
+		const resolved = this.options.resolveClientReference?.(metadata);
+		if (resolved !== void 0) {
+			const component = function PayloadResolvedClientComponent(props) {
+				return createElement(resolved, props);
+			};
+			this.resolvedClientReferenceComponents.set(metadata.id, component);
+			return component;
+		}
+		const load = this.options.loadClientReference;
+		if (load !== void 0) {
+			const entry = this.clientReferenceEntry(metadata, load);
+			let type = null;
+			entry.component = function PayloadClientComponent(props) {
+				if (type === null) type = resolveClientReferenceExport(readPromise(entry.load), metadata);
+				return createElement(type, props);
+			};
+			return entry.component;
+		}
+		if (this.options.resolveClientReference !== void 0) return clientReference({
+			id: metadata.id,
+			load: () => Promise.resolve({})
+		});
+		return function PayloadUnresolvedClientComponent() {
+			throw new Error(`Cannot render client reference "${metadata.id}" because createPayloadResponse was not configured with loadClientReference or a matching resolveClientReference.`);
+		};
+	}
+	preloadClientReferences() {
+		const loads = [...this.clientReferenceEntries.values()].map((entry) => entry.load);
+		return Promise.allSettled(loads).then(() => void 0);
+	}
+	clientReferenceEntry(metadata, load) {
+		let entry = this.clientReferenceEntries.get(metadata.id);
+		if (entry === void 0) {
+			entry = { load: load(metadata) };
+			this.clientReferenceEntries.set(metadata.id, entry);
+			trackThenable(entry.load);
+		}
+		return entry;
+	}
+	refreshRetainedChunks() {
+		const rootModel = this.chunks.get(0)?.model;
+		if (rootModel === void 0 || rootModel === null) return [];
+		const nextRetained = referencedChunkClosure(rootModel, this.chunks);
+		const activeBoundaries = this.activeBoundaryEntries();
+		for (const entry of activeBoundaries) addChunkRefs(nextRetained, referencedChunkClosure(entry.model, this.chunks));
+		if (![...this.chunks.entries()].some(([id, chunk]) => id !== 0 && chunk.status === "pending")) {
+			for (const id of this.chunks.keys()) if (id !== 0 && !nextRetained.has(id)) this.chunks.delete(id);
+		}
+		const activeSources = new Map(activeBoundaries.map((entry) => [entry.id, entry.source]));
+		for (const id of this.boundaries.keys()) if (activeSources.get(id) !== "refresh") this.boundaries.delete(id);
+		for (const id of this.initialBoundaries.keys()) if (activeSources.get(id) !== "initial") this.initialBoundaries.delete(id);
+		for (const id of this.decodedBoundaries.keys()) if (!activeSources.has(id)) this.decodedBoundaries.delete(id);
+		return activeBoundaries;
+	}
+	markMaxObjectIdScanDirty(row) {
+		if (row.tag === "model" || row.tag === "refresh") this.maxObjectIdScanDirty = true;
+	}
+	ensureMaxObjectIdScanned() {
+		if (!this.maxObjectIdScanDirty) return;
+		this.maxObjectIdScanDirty = false;
+		for (const chunk of this.chunks.values()) if (chunk.model !== null) noteMaxObjectIds(this, chunk.model);
+		for (const entry of this.boundaries.values()) noteMaxObjectIds(this, entry.model);
+		for (const entry of this.initialBoundaries.values()) noteMaxObjectIds(this, entry.model);
+	}
+	modelCanReachBoundary(model, id) {
+		const models = [model];
+		const visitedBoundaries = /* @__PURE__ */ new Set();
+		const visitedChunks = /* @__PURE__ */ new Set();
+		for (let index = 0; index < models.length; index += 1) {
+			const current = models[index];
+			if (current === void 0) continue;
+			const boundaryIds = /* @__PURE__ */ new Set();
+			collectBoundaryIds(current, boundaryIds);
+			if (boundaryIds.has(id)) return true;
+			for (const boundaryId of boundaryIds) {
+				if (visitedBoundaries.has(boundaryId)) continue;
+				visitedBoundaries.add(boundaryId);
+				const entry = this.currentBoundaryEntry(boundaryId);
+				if (entry !== void 0) models.push(entry.model);
+			}
+			const chunkIds = /* @__PURE__ */ new Set();
+			collectReferencedChunkIds(current, chunkIds);
+			for (const chunkId of chunkIds) {
+				if (visitedChunks.has(chunkId)) continue;
+				visitedChunks.add(chunkId);
+				const chunk = this.chunks.get(chunkId);
+				if (chunk?.model !== null && chunk?.model !== void 0) models.push(chunk.model);
+			}
+		}
+		return false;
+	}
+	activeBoundaryEntries() {
+		const rootModel = this.chunks.get(0)?.model;
+		if (rootModel === void 0 || rootModel === null) return [];
+		const active = /* @__PURE__ */ new Set();
+		const visitedChunks = /* @__PURE__ */ new Set();
+		const models = [rootModel];
+		const entries = [];
+		for (let index = 0; index < models.length; index += 1) {
+			const chunkIds = /* @__PURE__ */ new Set();
+			collectReferencedChunkIds(models[index], chunkIds);
+			for (const id of chunkIds) {
+				if (visitedChunks.has(id)) continue;
+				visitedChunks.add(id);
+				const chunk = this.chunks.get(id);
+				if (chunk?.model !== null && chunk?.model !== void 0) models.push(chunk.model);
+			}
+			const ids = /* @__PURE__ */ new Set();
+			collectBoundaryIds(models[index], ids);
+			for (const id of ids) {
+				if (active.has(id)) continue;
+				active.add(id);
+				const entry = this.currentBoundaryEntry(id);
+				if (entry === void 0) continue;
+				entries.push({
+					...entry,
+					id
+				});
+				models.push(entry.model);
+			}
+		}
+		return entries;
+	}
+	currentBoundaryEntry(id) {
+		const refreshed = this.boundaries.get(id);
+		const initial = this.initialBoundaries.get(id);
+		if (refreshed === void 0) return initial === void 0 ? void 0 : {
+			...initial,
+			source: "initial"
+		};
+		if (initial === void 0) return {
+			...refreshed,
+			source: "refresh"
+		};
+		return initial.revision > refreshed.revision ? {
+			...initial,
+			source: "initial"
+		} : {
+			...refreshed,
+			source: "refresh"
+		};
+	}
+	claimModelRevision() {
+		const revision = this.nextModelRevision;
+		this.nextModelRevision += 1;
+		return revision;
+	}
+	decodeModelAtRevision(model, revision) {
+		const previous = this.currentDecodeRevision;
+		this.currentDecodeRevision = revision;
+		try {
+			return decodeModel(this, model);
+		} finally {
+			this.currentDecodeRevision = previous;
+		}
+	}
+	getChunk(id) {
+		if (id > this.maxRowId) this.maxRowId = id;
+		return getOrCreateChunk(this.chunks, id);
+	}
+	notify() {
+		for (const listener of this.listeners) listener();
+	}
+	hydratePendingData() {
+		if (this.rootData === null || this.pendingData.length === 0) return;
+		const entries = this.pendingData;
+		this.pendingData = [];
+		this.rootData.hydrate(entries);
+	}
+};
+function createTask(request, id, kind, value, contextValues, stack) {
+	request.pendingTasks += 1;
+	return {
+		contextValues,
+		id,
+		kind,
+		stack,
+		value
+	};
+}
+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);
+	flushRows(request);
+}
+function retryTask(request, task) {
+	const frame = createRenderFrame(request, cloneContextValues(task.contextValues), task.stack);
+	try {
+		const value = task.kind === "node" ? serializeNode(task.value, frame) : serializeValue(readThenable(task.value), frame);
+		emitDataRows(request);
+		if (request.refreshBoundary !== null && task.id === 0) emitRow(request, {
+			boundary: request.refreshBoundary,
+			tag: "refresh",
+			value
+		});
+		else emitRow(request, {
+			id: task.id,
+			tag: "model",
+			value
+		});
+		finishTask(request);
+	} catch (error) {
+		if (isThenable(error)) {
+			error.then(() => pingTask(request, task), () => pingTask(request, task));
+			return;
+		}
+		if (request.refreshBoundary !== null && task.id === 0) emitRow(request, {
+			boundary: request.refreshBoundary,
+			tag: "refresh-error",
+			value: errorRowPayload(request, error, task.stack)
+		});
+		else emitRow(request, {
+			id: task.id,
+			tag: "error",
+			value: errorRowPayload(request, error, task.stack)
+		});
+		finishTask(request);
+	}
+}
+function finishTask(request) {
+	request.pendingTasks -= 1;
+	if (request.pendingTasks === 0) request.allReady.resolve(void 0);
+}
+function emitDataRows(request) {
+	const entries = [];
+	for (const snapshot of request.pendingDataSnapshots.values()) {
+		if (!snapshot.hasValue || snapshot.status === "refreshing") continue;
+		const key = normalizeDataResourceKey(snapshot.key);
+		if (request.emittedDataKeys.has(key)) {
+			request.pendingDataSnapshots.delete(snapshot.canonicalKey);
+			continue;
+		}
+		request.emittedDataKeys.add(key);
+		request.pendingDataSnapshots.delete(snapshot.canonicalKey);
+		entries.push({
+			key: snapshot.key,
+			value: snapshot.value
+		});
+	}
+	if (entries.length > 0) emitRow(request, {
+		tag: "data",
+		value: encodePayloadDataEntries(entries)
+	});
+}
+function createRenderFrame(request, contextValues, stack) {
+	return {
+		contextValues,
+		dispatcher: null,
+		request,
+		stack
+	};
+}
+function createPayloadDispatcher(frame) {
+	return createStaticDispatcher({
+		contextValues: frame.contextValues,
+		externalStoreError: "useSyncExternalStore requires getServerSnapshot during payload render.",
+		readPromise: readThenable,
+		readData(resource, args) {
+			return frame.request.dataStore.readData(resource, args, frame);
+		},
+		preloadData(resource, args) {
+			frame.request.dataStore.preloadData(resource, ...args);
+		},
+		useId() {
+			const id = `fig-pl-${frame.request.nextUseId.toString(32)}`;
+			frame.request.nextUseId += 1;
+			return id;
+		},
+		updateError: "State updates are not allowed during payload render."
+	});
+}
+function serializeNode(node, frame) {
+	if (Array.isArray(node)) return flattenChildArrays(node).map((child) => serializeNodeOrLazy(child, frame));
+	if (node === null || node === void 0 || typeof node === "boolean") return node === void 0 ? { $fig: "undefined" } : node;
+	if (typeof node === "string" || typeof node === "number") return node;
+	if (isPortal(node)) return null;
+	if (!isValidElement(node)) throw invalidChildError$1(node);
+	return serializeElement(node, frame, false);
+}
+function serializeNodeOrLazy(node, frame, preserveElementIdentity = false) {
+	const graphCheckpoint = checkpointGraph(frame.request.graph);
+	try {
+		if (!isValidElement(node)) return serializeNode(node, frame);
+		return serializeElement(node, frame, preserveElementIdentity);
+	} catch (error) {
+		rollbackGraph(frame.request.graph, graphCheckpoint);
+		if (isThenable(error)) return outlineTask(frame, "node", node, "lazy", error);
+		return outlineError(frame, error, "lazy");
+	}
+}
+function serializeElement(element, frame, preserveIdentity) {
+	const type = element.type;
+	if (typeof type === "string") return serializeElementModel(element, type, frame, preserveIdentity, childrenTreeProps);
+	if (type === Fragment) return serializeElementModel(element, { $fig: "fragment" }, frame, preserveIdentity, childrenTreeProps);
+	if (isClientReference(type)) return serializeElementModel(element, {
+		$fig: "client",
+		id: emitClientReference(frame.request, type)
+	}, frame, preserveIdentity);
+	if (isPayloadBoundary(type)) {
+		const id = element.props.id;
+		if (typeof id !== "string" || id.length === 0) throw new Error("Payload boundaries require a non-empty string id.");
+		if (frame.request.refreshBoundary === id) throw new Error(`Refresh payload for boundary "${id}" must render that boundary's replacement content, not a nested PayloadBoundary with the same id.`);
+		if (frame.request.boundaryIds !== null) {
+			if (frame.request.boundaryIds.has(id)) throw new Error(`Duplicate payload boundary id "${id}".`);
+			frame.request.boundaryIds.add(id);
+		}
+		return {
+			$fig: "boundary",
+			child: serializeTreeProp(element.props.children, frame),
+			id
+		};
+	}
+	if (isContext(type)) return serializeContextProvider(type, element.props, frame);
+	if (isAssets(type)) return serializeAssets(element.props, frame);
+	if (isSuspense(type)) return serializeElementModel(element, { $fig: "suspense" }, frame, preserveIdentity, suspenseTreeProps);
+	if (isErrorBoundary(type)) return serializeNode(element.props.children, frame);
+	if (isActivity(type)) return serializeNode(element.props.children, frame);
+	if (isViewTransition(type)) return serializeElementModel(element, { $fig: "view-transition" }, frame, preserveIdentity, childrenTreeProps);
+	if (typeof type === "function") return serializeFunctionComponent(type, element.props, frame);
+	throw new Error("Unsupported Fig element type during payload render.");
+}
+function serializeElementModel(element, type, frame, preserveIdentity, treeProps = emptyTreeProps) {
+	const id = preserveIdentity ? defineGraphElement(frame.request.graph, element) : void 0;
+	if (typeof id === "object") return id;
+	return {
+		$fig: "element",
+		...id === void 0 ? null : { id },
+		key: element.key,
+		props: serializeProps(element.props, frame, treeProps),
+		type
+	};
+}
+function serializeFunctionComponent(type, props, frame) {
+	frame.dispatcher ??= createPayloadDispatcher(frame);
+	const previousDispatcher = setCurrentDispatcher(frame.dispatcher);
+	const previousDataStore = setCurrentDataStore(frame.request.dataStore);
+	const previousStack = frame.stack;
+	frame.stack = {
+		name: type.name || "Anonymous",
+		parent: previousStack
+	};
+	try {
+		const result = type(props);
+		return serializeNode(isThenable(result) ? readThenable(result) : result, frame);
+	} catch (error) {
+		recordErrorStack(error, frame.stack);
+		throw error;
+	} finally {
+		frame.stack = previousStack;
+		setCurrentDataStore(previousDataStore);
+		setCurrentDispatcher(previousDispatcher);
+	}
+}
+function serializeContextProvider(context, props, frame) {
+	return withContextValue(frame.contextValues, context, props.value, () => serializeNode(props.children, frame));
+}
+function serializeAssets(props, frame) {
+	const serialized = serializeAssetResources(frame.request, props.assets);
+	if (serialized.length > 0) emitRow(frame.request, {
+		tag: "assets",
+		value: serialized
+	});
+	return serializeNode(props.children, frame);
+}
+function serializeProps(props, frame, treeProps) {
+	const value = {};
+	for (const [name, child] of Object.entries(props)) value[name] = treeProps.has(name) ? serializeTreeProp(child, frame) : serializeValue(child, frame);
+	return {
+		$fig: "object",
+		value
+	};
+}
+function serializeTreeProp(value, frame) {
+	if (Array.isArray(value)) return flattenChildArrays(value).map((child) => serializeNodeOrLazy(child, frame));
+	return serializeNodeOrLazy(value, frame);
+}
+function serializeValue(value, frame) {
+	if (isPlainPayloadValue(value)) return encodePayloadValue(value);
+	if (typeof value === "function") {
+		if (isClientReference(value)) return {
+			$fig: "client",
+			id: emitClientReference(frame.request, value)
+		};
+		throw new Error("Functions cannot be passed to client references.");
+	}
+	if (isThenable(value)) return outlineTask(frame, "promise", value, "promise", value);
+	if (isValidElement(value)) return serializeNodeOrLazy(value, frame, true);
+	if (isPortal(value)) return null;
+	if (typeof value === "object" && value !== null) {
+		if (value instanceof Date) return encodePayloadValueInternal(value, frame.request.graph);
+		if (value instanceof Map) return serializeMap(value, frame.request.graph, ([key, item]) => [serializeValue(key, frame), serializeValue(item, frame)]);
+		if (value instanceof Set) return serializeSet(value, frame.request.graph, (item) => serializeValue(item, frame));
+		if (Array.isArray(value)) return serializeArray(value, frame.request.graph, () => value, (item) => serializeValue(item, frame));
+		return serializePlainObject(value, frame.request.graph, (child) => serializeValue(child, frame));
+	}
+	throw new Error(`Cannot serialize ${typeof value} into the payload.`);
+}
+function isPlainPayloadValue(value) {
+	return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol";
+}
+/**
+* Encode ordinary data values into PayloadModel. Server component references
+* such as Fig elements, promises, and client references are handled by the
+* payload renderer before ordinary values reach this helper.
+*/
+function encodePayloadValue(value) {
+	return encodePayloadValueInternal(value, createPayloadGraphEncodeContext());
+}
+function encodePayloadValueInternal(value, graph) {
+	if (value === null) return null;
+	if (value === void 0) return { $fig: "undefined" };
+	if (typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") return encodePayloadNumber(value);
+	if (typeof value === "bigint") return {
+		$fig: "bigint",
+		value: value.toString()
+	};
+	if (typeof value === "symbol") {
+		const key = Symbol.keyFor(value);
+		if (key === void 0) throw new Error("Only global Symbol.for symbols can be serialized.");
+		return {
+			$fig: "symbol",
+			key
+		};
+	}
+	if (typeof value === "function") throw new Error("Functions cannot be serialized into the payload.");
+	if (Array.isArray(value)) return serializeArray(value, graph, () => value, (item) => encodePayloadValueInternal(item, graph));
+	if (value instanceof Date) {
+		const json = value.toJSON();
+		if (json === null) throw new Error("Invalid Date values cannot be serialized.");
+		return {
+			$fig: "date",
+			value: json
+		};
+	}
+	if (value instanceof Map) return serializeMap(value, graph, ([key, item]) => [encodePayloadValueInternal(key, graph), encodePayloadValueInternal(item, graph)]);
+	if (value instanceof Set) return serializeSet(value, graph, (item) => encodePayloadValueInternal(item, graph));
+	if (typeof value === "object" && value !== null) return serializePlainObject(value, graph, (child) => encodePayloadValueInternal(child, graph));
+	throw new Error(`Cannot serialize ${typeof value} into the payload.`);
+}
+function serializeMap(value, graph, encodeEntry) {
+	const existing = graphReference(graph, value);
+	if (existing !== null) return existing;
+	return {
+		$fig: "map",
+		id: defineGraphObject(graph, value),
+		entries: [...value.entries()].map(encodeEntry)
+	};
+}
+function serializeSet(value, graph, encodeItem) {
+	const existing = graphReference(graph, value);
+	if (existing !== null) return existing;
+	return {
+		$fig: "set",
+		id: defineGraphObject(graph, value),
+		values: [...value.values()].map(encodeItem)
+	};
+}
+function graphReference(graph, value) {
+	const id = graph.ids.get(value);
+	return id === void 0 ? null : {
+		$fig: "ref",
+		id
+	};
+}
+function defineGraphObject(graph, value) {
+	const id = graph.nextId;
+	graph.nextId += 1;
+	graph.ids.set(value, id);
+	graph.objects.set(id, value);
+	return id;
+}
+function checkpointGraph(graph) {
+	return graph.nextId;
+}
+function rollbackGraph(graph, checkpoint) {
+	for (let id = graph.nextId - 1; id >= checkpoint; id -= 1) {
+		const value = graph.objects.get(id);
+		if (value !== void 0) graph.ids.delete(value);
+		graph.objects.delete(id);
+	}
+	graph.nextId = checkpoint;
+}
+function defineGraphElement(graph, value) {
+	const existing = graphReference(graph, value);
+	if (existing !== null) return existing;
+	return defineGraphObject(graph, value);
+}
+function serializeArray(value, graph, entries, encodeChild) {
+	const existing = graphReference(graph, value);
+	if (existing !== null) return existing;
+	return {
+		$fig: "array",
+		id: defineGraphObject(graph, value),
+		value: entries().map(encodeChild)
+	};
+}
+function serializePlainObject(value, graph, encodeChild) {
+	const existing = graphReference(graph, value);
+	if (existing !== null) return existing;
+	return {
+		$fig: "object",
+		id: defineGraphObject(graph, value),
+		value: encodePayloadRecord(plainPayloadObject(value), encodeChild)
+	};
+}
+function plainPayloadObject(value) {
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new Error(`Cannot serialize ${prototype?.constructor?.name ?? "object"} into the payload.`);
+	return value;
+}
+function encodePayloadRecord(record, encodeChild) {
+	const encoded = {};
+	for (const [name, child] of Object.entries(record)) encoded[name] = encodeChild(child);
+	return encoded;
+}
+function encodePayloadNumber(value) {
+	if (Number.isNaN(value)) return {
+		$fig: "number",
+		value: "NaN"
+	};
+	if (value === Infinity) return {
+		$fig: "number",
+		value: "Infinity"
+	};
+	if (value === -Infinity) return {
+		$fig: "number",
+		value: "-Infinity"
+	};
+	if (Object.is(value, -0)) return {
+		$fig: "number",
+		value: "-0"
+	};
+	return value;
+}
+/** Decode values produced by encodePayloadValue. */
+function decodePayloadValue(model) {
+	return decodeModelValue(model, createPayloadGraphDecodeContext());
+}
+function decodeModelValue(model, graph) {
+	if (model === null) return null;
+	if (Array.isArray(model)) return model.map((item) => decodeModelValue(item, graph));
+	if (typeof model !== "object") return model;
+	if (isPayloadValueSpecialModel(model)) return decodePayloadSpecialValue(model, graph);
+	return decodePayloadRecord(model, (child) => decodeModelValue(child, graph));
+}
+function isPayloadValueSpecialModel(model) {
+	if (!("$fig" in model)) return false;
+	const tag = model.$fig;
+	return tag === "bigint" || tag === "array" || tag === "date" || tag === "map" || tag === "number" || tag === "object" || tag === "ref" || tag === "set" || tag === "symbol" || tag === "undefined";
+}
+function decodePayloadSpecialValue(model, graph) {
+	switch (model.$fig) {
+		case "array": {
+			const value = [];
+			graph.refs.set(model.id, value);
+			value.push(...model.value.map((item) => decodeModelValue(item, graph)));
+			return value;
+		}
+		case "bigint": return BigInt(model.value);
+		case "date": return new Date(model.value);
+		case "map": {
+			const value = /* @__PURE__ */ new Map();
+			graph.refs.set(model.id, value);
+			for (const [key, item] of model.entries) value.set(decodeModelValue(key, graph), decodeModelValue(item, graph));
+			return value;
+		}
+		case "number": return decodePayloadNumber(model.value);
+		case "object": return decodePayloadPlainObject(model, graph);
+		case "ref": return readGraphRef(graph, model.id);
+		case "set": {
+			const value = /* @__PURE__ */ new Set();
+			graph.refs.set(model.id, value);
+			for (const item of model.values) value.add(decodeModelValue(item, graph));
+			return value;
+		}
+		case "symbol": return Symbol.for(model.key);
+		case "undefined": return;
+	}
+}
+function decodePayloadPlainObject(model, graph) {
+	const decoded = {};
+	if (model.id !== void 0) graph.refs.set(model.id, decoded);
+	for (const [name, value] of Object.entries(model.value)) definePayloadProperty(decoded, name, decodeModelValue(value, graph));
+	return decoded;
+}
+function decodePayloadRecord(value, decodeChild) {
+	const decoded = {};
+	for (const [name, child] of Object.entries(value)) definePayloadProperty(decoded, name, decodeChild(child));
+	return decoded;
+}
+function definePayloadProperty(target, name, value) {
+	Object.defineProperty(target, name, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+}
+function readGraphRef(graph, id) {
+	if (!graph.refs.has(id)) throw new Error(`Payload referenced unknown object id ${id}.`);
+	return graph.refs.get(id);
+}
+function decodePayloadNumber(value) {
+	switch (value) {
+		case "Infinity": return Infinity;
+		case "-Infinity": return -Infinity;
+		case "-0": return -0;
+		case "NaN": return NaN;
+	}
+}
+function encodePayloadDataEntries(entries) {
+	const graph = createPayloadGraphEncodeContext();
+	return entries.map((entry) => encodePayloadDataEntryWithGraph(entry, graph));
+}
+function decodePayloadDataEntries(entries) {
+	const graph = createPayloadGraphDecodeContext();
+	return entries.map((entry) => decodePayloadDataEntryWithGraph(entry, graph));
+}
+function encodePayloadDataEntryWithGraph(entry, graph) {
+	return {
+		...entry,
+		value: encodePayloadValueInternal(entry.value, graph)
+	};
+}
+function decodePayloadDataEntryWithGraph(entry, graph) {
+	return {
+		...entry,
+		value: decodeModelValue(entry.value, graph)
+	};
+}
+function outlineTask(frame, kind, value, referenceKind, wakeable) {
+	const request = frame.request;
+	const id = request.nextRowId++;
+	const task = createTask(request, id, kind, value, cloneContextValues(frame.contextValues), stackForError(wakeable, frame.stack));
+	wakeable.then(() => pingTask(request, task), () => pingTask(request, task));
+	return {
+		$fig: referenceKind,
+		id
+	};
+}
+function outlineError(frame, error, referenceKind) {
+	const request = frame.request;
+	const id = request.nextRowId++;
+	emitRow(request, {
+		id,
+		tag: "error",
+		value: errorRowPayload(request, error, frame.stack)
+	});
+	return {
+		$fig: referenceKind,
+		id
+	};
+}
+function errorRowPayload(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" || error === null) return;
+	if (!errorStacks.has(error)) errorStacks.set(error, stack);
+}
+function stackForError(error, fallback) {
+	if (typeof error !== "object" || error === null) return fallback;
+	return errorStacks.get(error) ?? fallback;
+}
+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 clientRowMetadata(value) {
+	const metadata = { id: value.id };
+	if (value.exportName !== void 0) metadata.exportName = value.exportName;
+	if (value.ssr === true) metadata.ssr = true;
+	return metadata;
+}
+function clientReferenceExportName(id) {
+	const hashIndex = id.lastIndexOf("#");
+	if (hashIndex === -1) return void 0;
+	const exportName = id.slice(hashIndex + 1);
+	return exportName === "" ? void 0 : exportName;
+}
+function emitClientReference(request, reference) {
+	const existing = request.clientReferenceRows.get(reference.id);
+	if (existing !== void 0) return existing;
+	const assets = serializeClientReferenceAssets(request, reference);
+	const value = { id: reference.id };
+	if (assets.length > 0) value.assets = assets;
+	const exportName = clientReferenceExportName(reference.id);
+	if (exportName !== void 0) value.exportName = exportName;
+	if (reference.ssr !== void 0) value.ssr = true;
+	const id = request.nextRowId++;
+	request.clientReferenceRows.set(reference.id, id);
+	emitRow(request, {
+		id,
+		tag: "client",
+		value
+	});
+	return id;
+}
+function serializeClientReferenceAssets(request, reference) {
+	return serializeAssetResources(request, collectClientReferenceAssets(request, reference));
+}
+function serializeAssetResources(request, value) {
+	const input = isFigAssetResource(value) ? [value] : Array.isArray(value) ? value : [];
+	const resources = [];
+	for (const resource of input) {
+		if (!isFigAssetResource(resource)) continue;
+		if (assetResourceDestination(resource) !== "stream") continue;
+		const key = assetResourceKey(resource);
+		if (request.emittedAssetKeys.has(key)) continue;
+		request.emittedAssetKeys.add(key);
+		resources.push(serializeAssetResource(resource));
+	}
+	return resources;
+}
+function collectClientReferenceAssets(request, reference) {
+	const resources = [...clientReferenceAssets(reference)];
+	const resolved = request.clientReferenceAssets?.({ id: reference.id });
+	if (resolved === void 0) return resources;
+	if (isFigAssetResource(resolved)) return [...resources, resolved];
+	return Array.isArray(resolved) ? [...resources, ...resolved] : resources;
+}
+function serializeAssetResource(resource) {
+	switch (resource.kind) {
+		case "stylesheet": return {
+			...resource.crossOrigin === void 0 ? {} : { crossOrigin: resource.crossOrigin },
+			href: resource.href,
+			kind: resource.kind,
+			...resource.media === void 0 ? {} : { media: resource.media },
+			...resource.precedence === void 0 ? {} : { precedence: resource.precedence }
+		};
+		case "preload": return {
+			as: resource.as,
+			...resource.crossOrigin === void 0 ? {} : { crossOrigin: resource.crossOrigin },
+			...resource.fetchPriority === void 0 ? {} : { fetchPriority: resource.fetchPriority },
+			href: resource.href,
+			kind: resource.kind,
+			...resource.type === void 0 ? {} : { type: resource.type }
+		};
+		case "modulepreload": return {
+			...resource.crossOrigin === void 0 ? {} : { crossOrigin: resource.crossOrigin },
+			...resource.fetchPriority === void 0 ? {} : { fetchPriority: resource.fetchPriority },
+			href: resource.href,
+			kind: resource.kind
+		};
+		case "script": return {
+			...resource.async === void 0 ? {} : { async: resource.async },
+			...resource.crossOrigin === void 0 ? {} : { crossOrigin: resource.crossOrigin },
+			...resource.defer === void 0 ? {} : { defer: resource.defer },
+			kind: resource.kind,
+			...resource.module === void 0 ? {} : { module: resource.module },
+			src: resource.src
+		};
+		case "font": return {
+			...resource.crossOrigin === void 0 ? {} : { crossOrigin: resource.crossOrigin },
+			...resource.fetchPriority === void 0 ? {} : { fetchPriority: resource.fetchPriority },
+			href: resource.href,
+			kind: resource.kind,
+			type: resource.type
+		};
+		case "preconnect": return {
+			...resource.crossOrigin === void 0 ? {} : { crossOrigin: resource.crossOrigin },
+			href: resource.href,
+			kind: resource.kind
+		};
+		case "title":
+		case "meta": throw new Error("Head-only resources cannot be serialized into the payload.");
+	}
+	return unsupportedSerializedAssetResource(resource);
+}
+function unsupportedSerializedAssetResource(resource) {
+	throw new Error(`Unsupported asset resource kind: ${resource.kind}`);
+}
+function emitRow(request, row) {
+	request.queuedRows.push(request.codec.encodeRow(row));
+	flushRows(request);
+}
+function pingTask(request, task) {
+	if (request.status === "closed") return;
+	request.pingedTasks.push(task);
+	if (request.workScheduled) return;
+	request.workScheduled = true;
+	queueMicrotask(() => {
+		request.workScheduled = false;
+		performWork(request);
+	});
+}
+function flushRows(request) {
+	if (request.controller === null || request.status === "closed") return;
+	if (request.status === "opening") return;
+	if (request.queuedRows.length > 0) {
+		for (const row of request.queuedRows) request.controller.enqueue(row);
+		request.queuedRows = [];
+	}
+	if (request.pendingTasks === 0) {
+		request.status = "closed";
+		cleanupPayloadAbortListener(request);
+		request.dataStore.dispose();
+		request.controller.close();
+	}
+}
+function closeWithError(request, error) {
+	if (request.status === "closed") return;
+	cleanupPayloadAbortListener(request);
+	request.status = "closed";
+	request.dataStore.dispose();
+	request.allReady.reject(error);
+	request.controller?.error(error);
+}
+function abortPayloadRequest(request, reason) {
+	closeWithError(request, reason ?? new PayloadRequestCancelledError());
+}
+function cleanupPayloadAbortListener(request) {
+	if (request.abortListener === null) return;
+	request.abortSignal?.removeEventListener("abort", request.abortListener);
+	request.abortListener = null;
+	request.abortSignal = null;
+}
+function flattenChildArrays(children) {
+	const collected = [];
+	for (const child of children) if (Array.isArray(child)) collected.push(...flattenChildArrays(child));
+	else collected.push(child);
+	return collected;
+}
+function invalidChildError$1(value) {
+	return /* @__PURE__ */ new Error(`Invalid Fig child in payload render: ${describeInvalidChild(value)}.`);
+}
+async function readByteStream(stream, onChunk, signal) {
+	const reader = stream.getReader();
+	const abort = () => {
+		reader.cancel(signal?.reason).catch(() => void 0);
+	};
+	try {
+		signal?.addEventListener("abort", abort, { once: true });
+		while (true) {
+			throwIfAborted(signal);
+			const { done, value } = await reader.read();
+			throwIfAborted(signal);
+			if (done) return;
+			onChunk(value);
+		}
+	} catch (error) {
+		if (!signal?.aborted) await reader.cancel(error).catch(() => void 0);
+		throw error;
+	} finally {
+		signal?.removeEventListener("abort", abort);
+		reader.releaseLock();
+		throwIfAborted(signal);
+	}
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new PayloadRequestCancelledError();
+}
+function resolveDecodedRow(response, row, revision) {
+	const chunk = response.getChunk(row.id);
+	if (row.tag === "error") {
+		const error = errorFromPayload(row.value);
+		chunk.model = null;
+		chunk.status = "rejected";
+		chunk.value = error;
+		chunk.reject(error);
+		chunk.promise.catch(() => void 0);
+		return;
+	}
+	let value;
+	if (row.tag === "client") {
+		response.recordClientReference(row.value);
+		response.recordAssetResources(row.value.assets);
+		value = response.decodeClientReference(clientRowMetadata(row.value));
+	} else value = response.decodeModelAtRevision(row.value, revision);
+	chunk.model = row.tag === "model" ? row.value : null;
+	chunk.revision = revision;
+	if (row.tag === "model") {
+		chunk.decoded = value;
+		chunk.hasDecoded = true;
+	}
+	chunk.status = "fulfilled";
+	chunk.value = value;
+	chunk.resolve(value);
+}
+function errorFromPayload(value) {
+	const error = new Error(value.message ?? "The server render failed.");
+	if (value.digest !== void 0) error.digest = value.digest;
+	return error;
+}
+function shiftRowIds(row, rowOffset, objectOffset) {
+	if (row.tag === "client" || row.tag === "error" || row.tag === "model") row.id += rowOffset;
+	if (row.tag === "model" || row.tag === "refresh") shiftModelIds(row.value, rowOffset, objectOffset);
+	if (row.tag === "data") for (const entry of row.value) shiftModelIds(entry.value, rowOffset, objectOffset);
+}
+function shiftModelIds(model, rowOffset, objectOffset) {
+	if (model === null || typeof model !== "object") return;
+	if (Array.isArray(model)) {
+		for (const item of model) shiftModelIds(item, rowOffset, objectOffset);
+		return;
+	}
+	if (isPayloadSpecialModel(model)) {
+		const special = model;
+		switch (special.$fig) {
+			case "array":
+				special.id += objectOffset;
+				for (const value of special.value) shiftModelIds(value, rowOffset, objectOffset);
+				return;
+			case "client":
+			case "lazy":
+			case "promise":
+				special.id += rowOffset;
+				return;
+			case "element":
+				if (special.id !== void 0) special.id += objectOffset;
+				shiftModelIds(special.type, rowOffset, objectOffset);
+				shiftModelIds(special.props, rowOffset, objectOffset);
+				return;
+			case "object":
+				if (special.id !== void 0) special.id += objectOffset;
+				for (const value of Object.values(special.value)) shiftModelIds(value, rowOffset, objectOffset);
+				return;
+			case "boundary":
+				shiftModelIds(special.child, rowOffset, objectOffset);
+				return;
+			case "map":
+				special.id += objectOffset;
+				for (const [key, value] of special.entries) {
+					shiftModelIds(key, rowOffset, objectOffset);
+					shiftModelIds(value, rowOffset, objectOffset);
+				}
+				return;
+			case "ref":
+				special.id += objectOffset;
+				return;
+			case "set":
+				special.id += objectOffset;
+				for (const value of special.values) shiftModelIds(value, rowOffset, objectOffset);
+				return;
+			default: return;
+		}
+	}
+	for (const value of Object.values(model)) shiftModelIds(value, rowOffset, objectOffset);
+}
+function noteMaxObjectIds(response, model) {
+	if (model === null || typeof model !== "object") return;
+	if (Array.isArray(model)) {
+		for (const item of model) noteMaxObjectIds(response, item);
+		return;
+	}
+	if (isPayloadSpecialModel(model)) switch (model.$fig) {
+		case "array":
+			response.noteObjectId(model.id);
+			for (const value of model.value) noteMaxObjectIds(response, value);
+			return;
+		case "element":
+			if (model.id !== void 0) response.noteObjectId(model.id);
+			noteMaxObjectIds(response, model.type);
+			noteMaxObjectIds(response, model.props);
+			return;
+		case "map":
+			response.noteObjectId(model.id);
+			for (const [key, value] of model.entries) {
+				noteMaxObjectIds(response, key);
+				noteMaxObjectIds(response, value);
+			}
+			return;
+		case "object":
+			if (model.id !== void 0) response.noteObjectId(model.id);
+			for (const value of Object.values(model.value)) noteMaxObjectIds(response, value);
+			return;
+		case "ref":
+		case "set":
+			response.noteObjectId(model.id);
+			if (model.$fig === "set") for (const value of model.values) noteMaxObjectIds(response, value);
+			return;
+		case "boundary":
+			noteMaxObjectIds(response, model.child);
+			return;
+		default: return;
+	}
+	for (const value of Object.values(model)) noteMaxObjectIds(response, value);
+}
+function collectObjectIds(model, ids) {
+	if (model === null || typeof model !== "object") return;
+	if (Array.isArray(model)) {
+		for (const item of model) collectObjectIds(item, ids);
+		return;
+	}
+	if (isPayloadSpecialModel(model)) switch (model.$fig) {
+		case "array":
+			ids.add(model.id);
+			for (const value of model.value) collectObjectIds(value, ids);
+			return;
+		case "element":
+			if (model.id !== void 0) ids.add(model.id);
+			collectObjectIds(model.type, ids);
+			collectObjectIds(model.props, ids);
+			return;
+		case "map":
+			ids.add(model.id);
+			for (const [key, value] of model.entries) {
+				collectObjectIds(key, ids);
+				collectObjectIds(value, ids);
+			}
+			return;
+		case "object":
+			if (model.id !== void 0) ids.add(model.id);
+			for (const value of Object.values(model.value)) collectObjectIds(value, ids);
+			return;
+		case "ref":
+			ids.add(model.id);
+			return;
+		case "set":
+			ids.add(model.id);
+			for (const value of model.values) collectObjectIds(value, ids);
+			return;
+		case "boundary": return;
+		default: return;
+	}
+	for (const value of Object.values(model)) collectObjectIds(value, ids);
+}
+function collectBoundaryIds(model, ids) {
+	if (model === null || typeof model !== "object") return;
+	if (Array.isArray(model)) {
+		for (const item of model) collectBoundaryIds(item, ids);
+		return;
+	}
+	if (isPayloadSpecialModel(model)) switch (model.$fig) {
+		case "array":
+			for (const value of model.value) collectBoundaryIds(value, ids);
+			return;
+		case "element":
+			collectBoundaryIds(model.type, ids);
+			collectBoundaryIds(model.props, ids);
+			return;
+		case "object":
+			for (const value of Object.values(model.value)) collectBoundaryIds(value, ids);
+			return;
+		case "boundary":
+			ids.add(model.id);
+			return;
+		case "map":
+			for (const [key, value] of model.entries) {
+				collectBoundaryIds(key, ids);
+				collectBoundaryIds(value, ids);
+			}
+			return;
+		case "set":
+			for (const value of model.values) collectBoundaryIds(value, ids);
+			return;
+		default: return;
+	}
+	for (const value of Object.values(model)) collectBoundaryIds(value, ids);
+}
+function referencedChunkClosure(model, chunks) {
+	const ids = /* @__PURE__ */ new Set();
+	const pending = [model];
+	for (let index = 0; index < pending.length; index += 1) {
+		const next = /* @__PURE__ */ new Set();
+		collectReferencedChunkIds(pending[index], next);
+		for (const id of next) {
+			if (ids.has(id)) continue;
+			ids.add(id);
+			const chunk = chunks.get(id);
+			if (chunk?.model !== null && chunk?.model !== void 0) pending.push(chunk.model);
+		}
+	}
+	return ids;
+}
+function collectReferencedChunkIds(model, ids) {
+	if (model === null || typeof model !== "object") return;
+	if (Array.isArray(model)) {
+		for (const item of model) collectReferencedChunkIds(item, ids);
+		return;
+	}
+	if (isPayloadSpecialModel(model)) switch (model.$fig) {
+		case "array":
+			for (const value of model.value) collectReferencedChunkIds(value, ids);
+			return;
+		case "client":
+		case "lazy":
+		case "promise":
+			ids.add(model.id);
+			return;
+		case "element":
+			collectReferencedChunkIds(model.type, ids);
+			collectReferencedChunkIds(model.props, ids);
+			return;
+		case "object":
+			for (const value of Object.values(model.value)) collectReferencedChunkIds(value, ids);
+			return;
+		case "ref": return;
+		case "boundary": return;
+		case "map":
+			for (const [key, value] of model.entries) {
+				collectReferencedChunkIds(key, ids);
+				collectReferencedChunkIds(value, ids);
+			}
+			return;
+		case "set":
+			for (const value of model.values) collectReferencedChunkIds(value, ids);
+			return;
+		default: return;
+	}
+	for (const value of Object.values(model)) collectReferencedChunkIds(value, ids);
+}
+function addChunkRefs(target, ids) {
+	for (const id of ids) target.add(id);
+}
+function isPayloadSpecialModel(model) {
+	if (!("$fig" in model)) return false;
+	switch (model.$fig) {
+		case "array":
+		case "bigint":
+		case "boundary":
+		case "client":
+		case "date":
+		case "element":
+		case "fragment":
+		case "lazy":
+		case "map":
+		case "number":
+		case "object":
+		case "promise":
+		case "ref":
+		case "set":
+		case "suspense":
+		case "symbol":
+		case "undefined":
+		case "view-transition": return true;
+		default: return false;
+	}
+}
+function decodeModel(response, model) {
+	if (model === null) return null;
+	if (Array.isArray(model)) return model.map((item) => decodeModel(response, item));
+	if (typeof model !== "object") return model;
+	if (isPayloadSpecialModel(model)) return decodeSpecialModel(response, model);
+	const decoded = {};
+	for (const [name, value] of Object.entries(model)) definePayloadProperty(decoded, name, decodeModel(response, value));
+	return decoded;
+}
+function decodeSpecialModel(response, model) {
+	switch (model.$fig) {
+		case "array": return response.defineObjectRef(model.id, () => [], (value) => {
+			value.push(...model.value.map((item) => decodeModel(response, item)));
+		});
+		case "bigint": return BigInt(model.value);
+		case "date": return new Date(model.value);
+		case "map": return response.defineObjectRef(model.id, () => /* @__PURE__ */ new Map(), (value) => {
+			for (const [key, item] of model.entries) value.set(decodeModel(response, key), decodeModel(response, item));
+		});
+		case "number": return decodePayloadNumber(model.value);
+		case "object":
+			if (model.id === void 0) {
+				const value = {};
+				for (const [name, child] of Object.entries(model.value)) definePayloadProperty(value, name, decodeModel(response, child));
+				return value;
+			}
+			return response.defineObjectRef(model.id, () => ({}), (value) => {
+				for (const [name, child] of Object.entries(model.value)) definePayloadProperty(value, name, decodeModel(response, child));
+			});
+		case "ref": return response.readObjectRef(model.id);
+		case "set": return response.defineObjectRef(model.id, () => /* @__PURE__ */ new Set(), (value) => {
+			for (const item of model.values) value.add(decodeModel(response, item));
+		});
+		case "symbol": return Symbol.for(model.key);
+		case "undefined": return;
+		case "boundary":
+			response.prepareBoundaryInitial(model.id, model.child);
+			return createElement(PayloadBoundarySlot, {
+				id: model.id,
+				initial: model.child,
+				response
+			});
+		case "element": {
+			if (model.id !== void 0) return response.defineObjectRef(model.id, () => ({
+				$$typeof: FigElementSymbol,
+				key: model.key,
+				props: {},
+				type: Fragment
+			}), (element) => {
+				element.type = decodeElementType(response, model.type);
+				element.props = decodeModel(response, model.props);
+			});
+			const type = decodeElementType(response, model.type);
+			const props = decodeModel(response, model.props);
+			if (model.key !== null) props.key = model.key;
+			return createElement(type, props);
+		}
+		case "client": return response.readChunk(model.id);
+		case "fragment": return Fragment;
+		case "lazy": return createElement(PayloadLazyNode, {
+			id: model.id,
+			response
+		});
+		case "promise": return response.getChunk(model.id).promise;
+		case "suspense": return Suspense;
+		case "view-transition": return ViewTransition;
+	}
+}
+function decodeElementType(response, type) {
+	if (typeof type === "string") return type;
+	return decodeSpecialModel(response, type);
+}
+function PayloadResponseRoot(props) {
+	return props.response.readChunk(0);
+}
+function PayloadBoundarySlot(props) {
+	return props.response.readBoundary(props.id, props.initial);
+}
+function PayloadLazyNode(props) {
+	return props.response.readChunk(props.id);
+}
+function resolveClientReferenceExport(moduleValue, metadata) {
+	if (typeof moduleValue === "function") return moduleValue;
+	if (typeof moduleValue === "object" && moduleValue !== null && metadata.exportName !== void 0) {
+		const candidate = moduleValue[metadata.exportName];
+		if (typeof candidate === "function") return candidate;
+	}
+	throw new Error(`Client reference "${metadata.id}" did not load a component.`);
+}
+function appendPayloadHeaders(codec, headers, boundary) {
+	const next = new Headers(headers);
+	if (!next.has("accept")) next.set("accept", codec.contentType);
+	if (boundary !== void 0) next.set(PAYLOAD_BOUNDARY_HEADER, boundary);
+	return next;
+}
+function assertPayloadCodecMatches(codec, contentTypeHeader) {
+	if (contentTypeHeader === null) return;
+	const received = payloadCodecIdFromContentType(contentTypeHeader);
+	if (received === null || received === codec.id) return;
+	throw new Error(`Payload codec mismatch: response used "${received}" but this client expects "${codec.id}".`);
+}
+function getOrCreateChunk(chunks, id) {
+	const existing = chunks.get(id);
+	if (existing !== void 0) return existing;
+	const settled = deferred();
+	const chunk = {
+		decoded: void 0,
+		hasDecoded: false,
+		model: null,
+		promise: settled.promise,
+		reject: settled.reject,
+		resolve: settled.resolve,
+		revision: 0,
+		status: "pending",
+		value: void 0
+	};
+	chunks.set(id, chunk);
+	return chunk;
+}
+function isPayloadBoundary(value) {
+	return typeof value === "function" && value.$$typeof === PayloadBoundarySymbol;
+}
+//#endregion
+export { PAYLOAD_BOUNDARY_HEADER, PayloadBoundary, PayloadFetchError, createPayloadResponse, decodePayloadDataEntries, decodePayloadValue, encodePayloadDataEntries, encodePayloadValue, fetchPayload, isPayloadRequestCancelled, jsonPayloadCodec, renderToPayloadStream };
+
+//# sourceMappingURL=payload.js.map