@bgub/fig-server 0.0.1 → 0.1.0-alpha.1

package/dist/payload.js

@@ -1,166 +1,36 @@
-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";
+import { a as deferred, c as streamHighWaterMark, i as createStaticDispatcher, l as withContextValue, n as cloneContextValues, r as componentStack, s as streamFlowBlocked } from "./shared-Bna74_aZ.js";
+import { Fragment, isValidElement } from "@bgub/fig";
+import { assetResourceDestination, assetResourceKey, checkpointPayloadGraph, clientOnlyHostBehavior, clientReferenceAssets, createPayloadGraphEncodeContext, createRendererDataStore, definePayloadGraphElement, describeInvalidChild, encodePayloadDataEntries, encodePayloadValueWithGraph, isActivity, isAssets, isClientReference, isContext, isErrorBoundary, isFigAssetResource, isPlainPayloadValue, isPortal, isSuspense, isThenable, isViewTransition, jsonPayloadCodec, readThenable, rollbackPayloadGraph, serializePayloadArray, serializePayloadMap, serializePayloadPlainObject, serializePayloadSet, setCurrentDataStore, setCurrentDispatcher } 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);
+	const { request, stream } = createPayloadRequest(node, options);
 	return {
-		abort: (reason) => abortPayloadRequest(request, reason),
 		allReady: request.allReady.promise,
-		contentType: request.codec.contentType,
-		stream: request.stream
+		contentType: jsonPayloadCodec.contentType,
+		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,
+		cleanupAbortListener: () => void 0,
 		clientReferenceRows: /* @__PURE__ */ new Map(),
 		clientReferenceAssets: options.clientReferenceAssets,
-		codec: options.codec ?? jsonPayloadCodec,
+		componentAssets: options.componentAssets,
 		controller: null,
-		dataStore: createDataStore({
+		dataStore: createRendererDataStore({
 			getLane: () => null,
 			onEntryChange: (entry) => {
 				pendingDataSnapshots.set(entry.canonicalKey, entry);
@@ -178,459 +48,82 @@ function createPayloadRequest(node, options) {
 		pendingTasks: 0,
 		pingedTasks: [],
 		queuedRows: [],
-		refreshBoundary: options.refreshBoundary ?? null,
-		status: "opening",
-		stream: null,
+		flushingRows: false,
+		status: "open",
 		workScheduled: false
 	};
 	request.allReady.promise.catch(() => void 0);
-	request.stream = new ReadableStream({
+	request.pingedTasks.push(createTask(request, 0, {
+		kind: "node",
+		value: node
+	}, /* @__PURE__ */ new Map(), null));
+	const stream = new ReadableStream({
 		start(controller) {
 			request.controller = controller;
 			flushRows(request);
 		},
+		pull() {
+			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"
+	}, new ByteLengthQueuingStrategy({ highWaterMark: streamHighWaterMark(options.highWaterMark) }));
+	const signal = options.signal;
+	if (signal !== void 0) {
+		const abortListener = () => abortPayloadRequest(request, signal.reason);
+		signal.addEventListener("abort", abortListener, { once: true });
+		request.cleanupAbortListener = () => {
+			signal.removeEventListener("abort", abortListener);
+			request.cleanupAbortListener = () => void 0;
 		};
-		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) {
+	scheduleWork(request);
+	return {
+		request,
+		stream
+	};
+}
+function createTask(request, id, value, contextValues, stack) {
 	request.pendingTasks += 1;
 	return {
 		contextValues,
 		id,
-		kind,
 		stack,
-		value
+		...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);
+	const frame = {
+		contextValues: cloneContextValues(task.contextValues),
+		dispatcher: null,
+		pendingAssets: [],
+		request,
+		stack: task.stack
+	};
 	try {
-		const value = task.kind === "node" ? serializeNode(task.value, frame) : serializeValue(readThenable(task.value), frame);
+		let value;
+		switch (task.kind) {
+			case "node":
+				value = serializeNode(task.value, frame);
+				break;
+			case "node-promise":
+				value = serializeNode(readThenable(task.value), frame);
+				break;
+			case "promise":
+				value = serializeValue(readThenable(task.value), frame);
+				break;
+		}
+		flushFrameAssets(frame, task.id);
 		emitDataRows(request);
-		if (request.refreshBoundary !== null && task.id === 0) emitRow(request, {
-			boundary: request.refreshBoundary,
-			tag: "refresh",
-			value
-		});
-		else emitRow(request, {
+		emitRow(request, {
 			id: task.id,
 			tag: "model",
 			value
@@ -638,15 +131,12 @@ function retryTask(request, task) {
 		finishTask(request);
 	} catch (error) {
 		if (isThenable(error)) {
+			flushFrameAssets(frame, task.id);
 			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, {
+		flushFrameAssets(frame, task.id);
+		emitRow(request, {
 			id: task.id,
 			tag: "error",
 			value: errorRowPayload(request, error, task.stack)
@@ -662,7 +152,7 @@ function emitDataRows(request) {
 	const entries = [];
 	for (const snapshot of request.pendingDataSnapshots.values()) {
 		if (!snapshot.hasValue || snapshot.status === "refreshing") continue;
-		const key = normalizeDataResourceKey(snapshot.key);
+		const key = snapshot.canonicalKey;
 		if (request.emittedDataKeys.has(key)) {
 			request.pendingDataSnapshots.delete(snapshot.canonicalKey);
 			continue;
@@ -679,13 +169,14 @@ function emitDataRows(request) {
 		value: encodePayloadDataEntries(entries)
 	});
 }
-function createRenderFrame(request, contextValues, stack) {
-	return {
-		contextValues,
-		dispatcher: null,
-		request,
-		stack
-	};
+function flushFrameAssets(frame, rowId) {
+	if (frame.pendingAssets.length === 0) return;
+	const value = frame.pendingAssets.splice(0);
+	emitRow(frame.request, {
+		for: rowId,
+		tag: "assets",
+		value
+	});
 }
 function createPayloadDispatcher(frame) {
 	return createStaticDispatcher({
@@ -711,18 +202,27 @@ function serializeNode(node, 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);
+	if (isValidElement(node)) return serializeElement(node, frame, false);
+	if (isThenable(node)) return outlineTask(frame, {
+		kind: "node-promise",
+		value: node
+	}, "promise", node);
+	throw invalidChildError$1(node);
 }
 function serializeNodeOrLazy(node, frame, preserveElementIdentity = false) {
-	const graphCheckpoint = checkpointGraph(frame.request.graph);
+	const graphCheckpoint = checkpointPayloadGraph(frame.request.graph);
+	const assetCheckpoint = frame.pendingAssets.length;
 	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");
+		rollbackPayloadGraph(frame.request.graph, graphCheckpoint);
+		const scopedAssets = frame.pendingAssets.splice(assetCheckpoint);
+		if (isThenable(error)) return outlineTask(frame, {
+			kind: "node",
+			value: node
+		}, "lazy", error, scopedAssets);
+		return outlineError(frame, error, "lazy", scopedAssets);
 	}
 }
 function serializeElement(element, frame, preserveIdentity) {
@@ -733,20 +233,6 @@ function serializeElement(element, frame, preserveIdentity) {
 		$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);
@@ -757,17 +243,20 @@ function serializeElement(element, frame, preserveIdentity) {
 	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;
+	const id = preserveIdentity ? definePayloadGraphElement(frame.request.graph, element) : void 0;
 	if (typeof id === "object") return id;
-	return {
+	const model = {
 		$fig: "element",
-		...id === void 0 ? null : { id },
 		key: element.key,
-		props: serializeProps(element.props, frame, treeProps),
+		props: serializeProps(element.props, frame, treeProps, typeof type === "string"),
 		type
 	};
+	if (id !== void 0) model.id = id;
+	return model;
 }
 function serializeFunctionComponent(type, props, frame) {
+	const assetCheckpoint = frame.pendingAssets.length;
+	frame.pendingAssets.push(...serializeAssetResources(frame.request, frame.request.componentAssets?.(type)));
 	frame.dispatcher ??= createPayloadDispatcher(frame);
 	const previousDispatcher = setCurrentDispatcher(frame.dispatcher);
 	const previousDataStore = setCurrentDataStore(frame.request.dataStore);
@@ -778,7 +267,14 @@ function serializeFunctionComponent(type, props, frame) {
 	};
 	try {
 		const result = type(props);
-		return serializeNode(isThenable(result) ? readThenable(result) : result, frame);
+		if (isThenable(result)) {
+			const scopedAssets = frame.pendingAssets.splice(assetCheckpoint);
+			return outlineTask(frame, {
+				kind: "node-promise",
+				value: result
+			}, "promise", result, scopedAssets);
+		}
+		return serializeNode(result, frame);
 	} catch (error) {
 		recordErrorStack(error, frame.stack);
 		throw error;
@@ -792,16 +288,18 @@ 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
-	});
+	frame.pendingAssets.push(...serializeAssetResources(frame.request, props.assets));
 	return serializeNode(props.children, frame);
 }
-function serializeProps(props, frame, treeProps) {
+function serializeProps(props, frame, treeProps, hostElement = false) {
+	const clientOnlyBehavior = hostElement ? clientOnlyHostBehavior(props) : void 0;
+	if (clientOnlyBehavior !== void 0) throw new Error(`Client-only host behavior from ${clientOnlyBehavior} cannot be serialized in a payload; move it into a client reference.`);
 	const value = {};
-	for (const [name, child] of Object.entries(props)) value[name] = treeProps.has(name) ? serializeTreeProp(child, frame) : serializeValue(child, frame);
+	for (const name of Object.keys(props)) {
+		if (hostElement && name === "mix") continue;
+		const child = props[name];
+		value[name] = treeProps.has(name) ? serializeTreeProp(child, frame) : serializeValue(child, frame);
+	}
 	return {
 		$fig: "object",
 		value
@@ -812,273 +310,50 @@ function serializeTreeProp(value, 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 (isPlainPayloadValue(value)) return encodePayloadValueWithGraph(value, frame.request.graph);
+	if (isClientReference(value)) return {
+		$fig: "client",
+		id: emitClientReference(frame.request, value)
+	};
 	if (isValidElement(value)) return serializeNodeOrLazy(value, frame, true);
 	if (isPortal(value)) return null;
+	if (isThenable(value)) return outlineTask(frame, {
+		kind: "promise",
+		value
+	}, "promise", value);
+	if (typeof value === "function") throw new Error("Functions cannot be passed to client references.");
 	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));
+		if (value instanceof Date) return encodePayloadValueWithGraph(value, frame.request.graph);
+		if (value instanceof Map) return serializePayloadMap(value, frame.request.graph, ([key, item]) => [serializeValue(key, frame), serializeValue(item, frame)]);
+		if (value instanceof Set) return serializePayloadSet(value, frame.request.graph, (item) => serializeValue(item, frame));
+		if (Array.isArray(value)) return serializePayloadArray(value, frame.request.graph, () => value, (item) => serializeValue(item, frame));
+		return serializePayloadPlainObject(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) {
+function outlineTask(frame, value, referenceKind, wakeable, scopedAssets = []) {
 	const request = frame.request;
 	const id = request.nextRowId++;
-	const task = createTask(request, id, kind, value, cloneContextValues(frame.contextValues), stackForError(wakeable, frame.stack));
+	if (scopedAssets.length > 0) emitRow(request, {
+		for: id,
+		tag: "assets",
+		value: scopedAssets
+	});
+	const task = createTask(request, id, 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) {
+function outlineError(frame, error, referenceKind, scopedAssets) {
 	const request = frame.request;
 	const id = request.nextRowId++;
+	if (scopedAssets.length > 0) emitRow(request, {
+		for: id,
+		tag: "assets",
+		value: scopedAssets
+	});
 	emitRow(request, {
 		id,
 		tag: "error",
@@ -1107,27 +382,15 @@ 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;
+	return id.slice(hashIndex + 1) || void 0;
 }
 function emitClientReference(request, reference) {
 	const existing = request.clientReferenceRows.get(reference.id);
 	if (existing !== void 0) return existing;
-	const assets = serializeClientReferenceAssets(request, reference);
+	const assets = serializeAssetResources(request, collectClientReferenceAssets(request, reference));
 	const value = { id: reference.id };
 	if (assets.length > 0) value.assets = assets;
 	const exportName = clientReferenceExportName(reference.id);
@@ -1142,18 +405,16 @@ function emitClientReference(request, reference) {
 	});
 	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);
+		if (assetResourceDestination(resource) === "stream") {
+			const key = assetResourceKey(resource);
+			if (request.emittedAssetKeys.has(key)) continue;
+			request.emittedAssetKeys.add(key);
+		}
 		resources.push(serializeAssetResource(resource));
 	}
 	return resources;
@@ -1167,62 +428,91 @@ function collectClientReferenceAssets(request, reference) {
 }
 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,
+		case "stylesheet": {
+			const model = {
+				href: resource.href,
+				kind: resource.kind
+			};
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			if (resource.media !== void 0) model.media = resource.media;
+			if (resource.precedence !== void 0) model.precedence = resource.precedence;
+			return model;
+		}
+		case "preload": {
+			const model = {
+				as: resource.as,
+				href: resource.href,
+				kind: resource.kind
+			};
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			if (resource.fetchpriority !== void 0) model.fetchpriority = resource.fetchpriority;
+			if (resource.type !== void 0) model.type = resource.type;
+			return model;
+		}
+		case "modulepreload": {
+			const model = {
+				href: resource.href,
+				kind: resource.kind
+			};
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			if (resource.fetchpriority !== void 0) model.fetchpriority = resource.fetchpriority;
+			return model;
+		}
+		case "script": {
+			const model = {
+				kind: resource.kind,
+				src: resource.src
+			};
+			if (resource.async !== void 0) model.async = resource.async;
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			if (resource.defer !== void 0) model.defer = resource.defer;
+			if (resource.module !== void 0) model.module = resource.module;
+			return model;
+		}
+		case "font": {
+			const model = {
+				href: resource.href,
+				kind: resource.kind,
+				type: resource.type
+			};
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			if (resource.fetchpriority !== void 0) model.fetchpriority = resource.fetchpriority;
+			return model;
+		}
+		case "preconnect": {
+			const model = {
+				href: resource.href,
+				kind: resource.kind
+			};
+			if (resource.crossorigin !== void 0) model.crossorigin = resource.crossorigin;
+			return model;
+		}
+		case "title": return {
 			kind: resource.kind,
-			type: resource.type
+			value: resource.value
 		};
-		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.");
+		case "meta": {
+			const model = { kind: resource.kind };
+			if (resource.charset !== void 0) model.charset = resource.charset;
+			if (resource.content !== void 0) model.content = resource.content;
+			if (resource["http-equiv"] !== void 0) model["http-equiv"] = resource["http-equiv"];
+			if (resource.key !== void 0) model.key = resource.key;
+			if (resource.name !== void 0) model.name = resource.name;
+			if (resource.property !== void 0) model.property = resource.property;
+			return model;
+		}
 	}
-	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));
+	request.queuedRows.push(jsonPayloadCodec.encodeRow(row));
 	flushRows(request);
 }
 function pingTask(request, task) {
 	if (request.status === "closed") return;
 	request.pingedTasks.push(task);
+	scheduleWork(request);
+}
+function scheduleWork(request) {
 	if (request.workScheduled) return;
 	request.workScheduled = true;
 	queueMicrotask(() => {
@@ -1232,21 +522,29 @@ function pingTask(request, task) {
 }
 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.flushingRows) return;
+	request.flushingRows = true;
+	try {
+		let flushed = 0;
+		while (flushed < request.queuedRows.length && !streamFlowBlocked(request.controller)) {
+			request.controller.enqueue(request.queuedRows[flushed]);
+			flushed += 1;
+		}
+		if (flushed === request.queuedRows.length) request.queuedRows.length = 0;
+		else if (flushed > 0) request.queuedRows = request.queuedRows.slice(flushed);
+	} finally {
+		request.flushingRows = false;
 	}
-	if (request.pendingTasks === 0) {
+	if (request.pendingTasks === 0 && request.queuedRows.length === 0) {
 		request.status = "closed";
-		cleanupPayloadAbortListener(request);
+		request.cleanupAbortListener();
 		request.dataStore.dispose();
 		request.controller.close();
 	}
 }
 function closeWithError(request, error) {
 	if (request.status === "closed") return;
-	cleanupPayloadAbortListener(request);
+	request.cleanupAbortListener();
 	request.status = "closed";
 	request.dataStore.dispose();
 	request.allReady.reject(error);
@@ -1255,446 +553,20 @@ function closeWithError(request, 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) {
+	if (!children.some(Array.isArray)) return children;
 	const collected = [];
-	for (const child of children) if (Array.isArray(child)) collected.push(...flattenChildArrays(child));
+	for (const child of children) if (Array.isArray(child)) for (const nested of flattenChildArrays(child)) collected.push(nested);
 	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 };
+export { renderToPayloadStream };
 
 //# sourceMappingURL=payload.js.map