@tanstack/react-start-rsc 0.0.0

package/dist/esm/ClientSlot.js

@@ -0,0 +1,19 @@
+"use client";
+import { useSlotContext } from "./SlotContext.js";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#region src/ClientSlot.tsx
+function ClientSlot({ slot, args }) {
+	const ctx = useSlotContext();
+	if (!ctx) throw new Error("ClientSlot must be rendered within SlotProvider");
+	const impl = ctx.implementations[slot];
+	if (impl === void 0) {
+		if (ctx.strict) throw new Error(`Missing slot implementation for "${slot}"`);
+		return null;
+	}
+	if (typeof impl !== "function") return /* @__PURE__ */ jsx(Fragment, { children: impl });
+	return /* @__PURE__ */ jsx(Fragment, { children: impl(...args) });
+}
+//#endregion
+export { ClientSlot };
+
+//# sourceMappingURL=ClientSlot.js.map

package/dist/esm/ClientSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientSlot.js","names":[],"sources":["../../src/ClientSlot.tsx"],"sourcesContent":["'use client'\n\nimport { useSlotContext } from './SlotContext'\n\nexport interface ClientSlotProps {\n  slot: string\n  args: Array<unknown>\n}\n\nexport function ClientSlot({ slot, args }: ClientSlotProps) {\n  const ctx = useSlotContext()\n\n  if (!ctx) {\n    throw new Error('ClientSlot must be rendered within SlotProvider')\n  }\n\n  const impl = ctx.implementations[slot]\n\n  // No implementation provided\n  if (impl === undefined) {\n    if (ctx.strict) {\n      throw new Error(`Missing slot implementation for \"${slot}\"`)\n    }\n    return null\n  }\n\n  // For children slot or any non-function value, render directly\n  if (typeof impl !== 'function') {\n    return <>{impl}</>\n  }\n\n  // Render function with args\n  return <>{impl(...args)}</>\n}\n"],"mappings":";;;;AASA,SAAgB,WAAW,EAAE,MAAM,QAAyB;CAC1D,MAAM,MAAM,gBAAgB;AAE5B,KAAI,CAAC,IACH,OAAM,IAAI,MAAM,kDAAkD;CAGpE,MAAM,OAAO,IAAI,gBAAgB;AAGjC,KAAI,SAAS,KAAA,GAAW;AACtB,MAAI,IAAI,OACN,OAAM,IAAI,MAAM,oCAAoC,KAAK,GAAG;AAE9D,SAAO;;AAIT,KAAI,OAAO,SAAS,WAClB,QAAO,oBAAA,UAAA,EAAA,UAAG,MAAQ,CAAA;AAIpB,QAAO,oBAAA,UAAA,EAAA,UAAG,KAAK,GAAG,KAAK,EAAI,CAAA"}

package/dist/esm/CompositeComponent.js

@@ -0,0 +1,93 @@
+"use client";
+import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH, SERVER_COMPONENT_CSS_HREFS, SERVER_COMPONENT_JS_PRELOADS, SERVER_COMPONENT_STREAM } from "./ServerComponentTypes.js";
+import { SlotProvider } from "./SlotContext.js";
+import { Suspense } from "react";
+import ReactDOM from "react-dom";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#region src/CompositeComponent.tsx
+function splitSlotProps(props) {
+	const { children, strict, ...slotProps } = props ?? {};
+	return {
+		implementations: {
+			...slotProps,
+			children
+		},
+		strict: strict === true
+	};
+}
+function EmptyFallback() {
+	return null;
+}
+function CompositeRenderInner({ getTree, path, slotProps }) {
+	let tree = getTree();
+	for (const key of path) {
+		if (tree === null || tree === void 0) return null;
+		if (typeof tree !== "object") return null;
+		tree = tree[key];
+	}
+	if (tree === null || tree === void 0) return null;
+	const { implementations, strict } = splitSlotProps(slotProps);
+	return /* @__PURE__ */ jsx(SlotProvider, {
+		implementations,
+		strict,
+		children: tree
+	});
+}
+function CompositeRenderComponent({ getTree, path, slotProps, cssHrefs, jsPreloads }) {
+	for (const href of cssHrefs ?? []) ReactDOM.preinit(href, {
+		as: "style",
+		precedence: "high"
+	});
+	if (jsPreloads) for (const href of jsPreloads) ReactDOM.preloadModule(href);
+	return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(Suspense, {
+		fallback: /* @__PURE__ */ jsx(EmptyFallback, {}),
+		children: /* @__PURE__ */ jsx(CompositeRenderInner, {
+			getTree,
+			path,
+			slotProps
+		})
+	}) });
+}
+/**
+* Renders composite RSC data with slot support.
+*
+* Use this component to render data from `createCompositeComponent`.
+* Pass slot implementations as props to fill in ClientSlot placeholders.
+*
+* @example
+* ```tsx
+* const src = await createCompositeComponent((props) => (
+*   <div>
+*     <header>{props.header('Dashboard')}</header>
+*     <main>{props.children}</main>
+*   </div>
+* ))
+*
+* // In route component
+* return (
+*   <CompositeComponent src={src} header={(title) => <h1>{title}</h1>}>
+*     <p>Main content</p>
+*   </CompositeComponent>
+* )
+* ```
+*/
+function CompositeComponent(props) {
+	const { src, ...slotProps } = props;
+	if (!src[SERVER_COMPONENT_STREAM]) throw new Error("[tanstack/start] <CompositeComponent> missing RSC stream on src");
+	const cssHrefs = src[SERVER_COMPONENT_CSS_HREFS];
+	const jsPreloads = src[SERVER_COMPONENT_JS_PRELOADS];
+	const path = src[RSC_PROXY_PATH] ?? [];
+	const getTree = src[RSC_PROXY_GET_TREE];
+	if (!getTree) throw new Error("[tanstack/start] <CompositeComponent> missing getTree on RSC src. Make sure src comes from createCompositeComponent().");
+	return /* @__PURE__ */ jsx(CompositeRenderComponent, {
+		getTree,
+		path,
+		slotProps,
+		cssHrefs,
+		jsPreloads
+	});
+}
+//#endregion
+export { CompositeComponent };
+
+//# sourceMappingURL=CompositeComponent.js.map

package/dist/esm/CompositeComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositeComponent.js","names":[],"sources":["../../src/CompositeComponent.tsx"],"sourcesContent":["'use client'\n\nimport { Suspense } from 'react'\nimport ReactDOM from 'react-dom'\n\nimport { SlotProvider } from './SlotContext'\nimport {\n  RSC_PROXY_GET_TREE,\n  RSC_PROXY_PATH,\n  SERVER_COMPONENT_CSS_HREFS,\n  SERVER_COMPONENT_JS_PRELOADS,\n  SERVER_COMPONENT_STREAM,\n} from './ServerComponentTypes'\nimport type { AnyCompositeComponent } from './ServerComponentTypes'\nimport type { SlotImplementations } from './types'\n\nfunction splitSlotProps(props?: Record<string, unknown>): {\n  implementations: SlotImplementations\n  strict: boolean\n} {\n  const safeProps = props ?? {}\n  const { children, strict, ...slotProps } = safeProps as {\n    children?: unknown\n    strict?: unknown\n    [key: string]: unknown\n  }\n\n  return {\n    implementations: { ...slotProps, children },\n    strict: strict === true,\n  }\n}\n\nfunction EmptyFallback() {\n  return null\n}\n\nfunction CompositeRenderInner({\n  getTree,\n  path,\n  slotProps,\n}: {\n  getTree: () => unknown\n  path: Array<string>\n  slotProps?: Record<string, unknown>\n}): React.ReactNode {\n  let tree: unknown = getTree()\n\n  for (const key of path) {\n    if (tree === null || tree === undefined) return null\n    if (typeof tree !== 'object') return null\n    tree = (tree as Record<string, unknown>)[key]\n  }\n\n  if (tree === null || tree === undefined) return null\n\n  const { implementations, strict } = splitSlotProps(slotProps)\n\n  return (\n    <SlotProvider implementations={implementations} strict={strict}>\n      {tree as React.ReactNode}\n    </SlotProvider>\n  )\n}\n\nfunction CompositeRenderComponent({\n  getTree,\n  path,\n  slotProps,\n  cssHrefs,\n  jsPreloads,\n}: {\n  getTree: () => unknown\n  path: Array<string>\n  slotProps?: Record<string, unknown>\n  cssHrefs?: ReadonlySet<string>\n  jsPreloads?: ReadonlySet<string>\n}): React.ReactNode {\n  for (const href of cssHrefs ?? []) {\n    ReactDOM.preinit(href, { as: 'style', precedence: 'high' })\n  }\n\n  if (jsPreloads) {\n    for (const href of jsPreloads) {\n      ReactDOM.preloadModule(href)\n    }\n  }\n\n  return (\n    <>\n      <Suspense fallback={<EmptyFallback />}>\n        <CompositeRenderInner\n          getTree={getTree}\n          path={path}\n          slotProps={slotProps}\n        />\n      </Suspense>\n    </>\n  )\n}\n\n/**\n * Renders composite RSC data with slot support.\n *\n * Use this component to render data from `createCompositeComponent`.\n * Pass slot implementations as props to fill in ClientSlot placeholders.\n *\n * @example\n * ```tsx\n * const src = await createCompositeComponent((props) => (\n *   <div>\n *     <header>{props.header('Dashboard')}</header>\n *     <main>{props.children}</main>\n *   </div>\n * ))\n *\n * // In route component\n * return (\n *   <CompositeComponent src={src} header={(title) => <h1>{title}</h1>}>\n *     <p>Main content</p>\n *   </CompositeComponent>\n * )\n * ```\n */\nexport function CompositeComponent<TComp extends AnyCompositeComponent>(\n  props: CompositeComponentProps<TComp>,\n): TComp['~types']['return'] {\n  const { src, ...slotProps } = props\n\n  const stream = src[SERVER_COMPONENT_STREAM]\n\n  if (!stream) {\n    throw new Error(\n      '[tanstack/start] <CompositeComponent> missing RSC stream on src',\n    )\n  }\n\n  const cssHrefs = src[SERVER_COMPONENT_CSS_HREFS]\n  const jsPreloads = src[SERVER_COMPONENT_JS_PRELOADS]\n\n  const path = src[RSC_PROXY_PATH] ?? []\n\n  const getTree = src[RSC_PROXY_GET_TREE]\n\n  if (!getTree) {\n    throw new Error(\n      '[tanstack/start] <CompositeComponent> missing getTree on RSC src. ' +\n        'Make sure src comes from createCompositeComponent().',\n    )\n  }\n\n  return (\n    <CompositeRenderComponent\n      getTree={getTree}\n      path={path}\n      slotProps={slotProps}\n      cssHrefs={cssHrefs}\n      jsPreloads={jsPreloads}\n    />\n  )\n}\n\nexport type CompositeComponentProps<TComp extends AnyCompositeComponent> = {\n  src: TComp\n} & TComp['~types']['props']\n"],"mappings":";;;;;;;AAgBA,SAAS,eAAe,OAGtB;CAEA,MAAM,EAAE,UAAU,QAAQ,GAAG,cADX,SAAS,EAAE;AAO7B,QAAO;EACL,iBAAiB;GAAE,GAAG;GAAW;GAAU;EAC3C,QAAQ,WAAW;EACpB;;AAGH,SAAS,gBAAgB;AACvB,QAAO;;AAGT,SAAS,qBAAqB,EAC5B,SACA,MACA,aAKkB;CAClB,IAAI,OAAgB,SAAS;AAE7B,MAAK,MAAM,OAAO,MAAM;AACtB,MAAI,SAAS,QAAQ,SAAS,KAAA,EAAW,QAAO;AAChD,MAAI,OAAO,SAAS,SAAU,QAAO;AACrC,SAAQ,KAAiC;;AAG3C,KAAI,SAAS,QAAQ,SAAS,KAAA,EAAW,QAAO;CAEhD,MAAM,EAAE,iBAAiB,WAAW,eAAe,UAAU;AAE7D,QACE,oBAAC,cAAD;EAA+B;EAAyB;YACrD;EACY,CAAA;;AAInB,SAAS,yBAAyB,EAChC,SACA,MACA,WACA,UACA,cAOkB;AAClB,MAAK,MAAM,QAAQ,YAAY,EAAE,CAC/B,UAAS,QAAQ,MAAM;EAAE,IAAI;EAAS,YAAY;EAAQ,CAAC;AAG7D,KAAI,WACF,MAAK,MAAM,QAAQ,WACjB,UAAS,cAAc,KAAK;AAIhC,QACE,oBAAA,UAAA,EAAA,UACE,oBAAC,UAAD;EAAU,UAAU,oBAAC,eAAD,EAAiB,CAAA;YACnC,oBAAC,sBAAD;GACW;GACH;GACK;GACX,CAAA;EACO,CAAA,EACV,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;AA2BP,SAAgB,mBACd,OAC2B;CAC3B,MAAM,EAAE,KAAK,GAAG,cAAc;AAI9B,KAAI,CAFW,IAAI,yBAGjB,OAAM,IAAI,MACR,kEACD;CAGH,MAAM,WAAW,IAAI;CACrB,MAAM,aAAa,IAAI;CAEvB,MAAM,OAAO,IAAI,mBAAmB,EAAE;CAEtC,MAAM,UAAU,IAAI;AAEpB,KAAI,CAAC,QACH,OAAM,IAAI,MACR,yHAED;AAGH,QACE,oBAAC,0BAAD;EACW;EACH;EACK;EACD;EACE;EACZ,CAAA"}

package/dist/esm/ReplayableStream.js

@@ -0,0 +1,147 @@
+//#region src/ReplayableStream.ts
+var REPLAYABLE_STREAM_MARKER = Symbol.for("tanstack.rsc.ReplayableStream");
+var ReplayableStream = class {
+	constructor(source, options = {}) {
+		this.source = source;
+		this.options = options;
+		this[REPLAYABLE_STREAM_MARKER] = true;
+		this.chunks = [];
+		this.done = false;
+		this.error = null;
+		this.waiter = null;
+		this.aborted = false;
+		this.released = false;
+		this.sourceReader = null;
+		this.abortListener = null;
+		this.abortSignal = options.signal;
+		this.start();
+	}
+	start() {
+		const signal = this.abortSignal;
+		if (signal?.aborted) {
+			this.handleAbort();
+			return;
+		}
+		const onAbort = () => this.handleAbort();
+		this.abortListener = onAbort;
+		signal?.addEventListener("abort", onAbort, { once: true });
+		const reader = this.source.getReader();
+		this.sourceReader = reader;
+		const pump = async () => {
+			try {
+				while (!this.aborted && !this.released) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					if (this.aborted || this.released) break;
+					this.chunks.push(value);
+					this.notify();
+				}
+				this.done = true;
+			} catch (err) {
+				if (!this.aborted && !this.released) this.error = err;
+				this.done = true;
+			} finally {
+				this.detachAbortListener();
+				try {
+					reader.releaseLock();
+				} catch {}
+				if (this.sourceReader === reader) this.sourceReader = null;
+				this.notify();
+			}
+		};
+		pump();
+	}
+	detachAbortListener() {
+		const signal = this.abortSignal;
+		const listener = this.abortListener;
+		if (signal && listener) signal.removeEventListener("abort", listener);
+		this.abortListener = null;
+	}
+	cancelSource(reason) {
+		const reader = this.sourceReader;
+		this.sourceReader = null;
+		try {
+			reader?.cancel(reason).catch(() => {});
+		} catch {}
+	}
+	handleAbort() {
+		if (this.aborted) return;
+		this.aborted = true;
+		this.done = true;
+		const reason = this.abortSignal?.reason ?? /* @__PURE__ */ new Error("ReplayableStream aborted");
+		this.detachAbortListener();
+		this.abortSignal = void 0;
+		this.cancelSource(reason);
+		this.chunks = [];
+		this.released = true;
+		this.notify();
+	}
+	notify() {
+		if (this.waiter) {
+			this.waiter.resolve();
+			this.waiter = null;
+		}
+	}
+	wait() {
+		if (this.done || this.released) return Promise.resolve();
+		if (!this.waiter) this.waiter = Promise.withResolvers();
+		return this.waiter.promise;
+	}
+	/**
+	* Explicitly release buffered chunks.
+	* Call this when you know no more replay streams will be created.
+	* After calling release(), createReplayStream() will return empty streams.
+	*/
+	release() {
+		if (this.released) return;
+		this.released = true;
+		this.chunks = [];
+		this.detachAbortListener();
+		this.abortSignal = void 0;
+		this.cancelSource(/* @__PURE__ */ new Error("ReplayableStream released"));
+		this.notify();
+	}
+	/**
+	* Check if the stream data has been released
+	*/
+	isReleased() {
+		return this.released;
+	}
+	/**
+	* Create an independent replay stream. Each call returns a fresh reader
+	* that starts from the beginning of the buffered data.
+	*
+	* If the stream has been released, returns a stream that closes immediately.
+	*/
+	createReplayStream() {
+		if (this.released) return new ReadableStream({ start(controller) {
+			controller.close();
+		} });
+		let index = 0;
+		return new ReadableStream({
+			pull: async (controller) => {
+				while (true) {
+					if (this.released) {
+						controller.close();
+						return;
+					}
+					if (index < this.chunks.length) {
+						controller.enqueue(this.chunks[index++]);
+						return;
+					}
+					if (this.done) {
+						if (this.error && !this.aborted) controller.error(this.error);
+						else controller.close();
+						return;
+					}
+					await this.wait();
+				}
+			},
+			cancel: () => {}
+		});
+	}
+};
+//#endregion
+export { ReplayableStream };
+
+//# sourceMappingURL=ReplayableStream.js.map

package/dist/esm/ReplayableStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReplayableStream.js","names":[],"sources":["../../src/ReplayableStream.ts"],"sourcesContent":["/**\n * ReplayableStream is used for React Server Components (RSC) / Flight streams.\n *\n * In this package the same Flight payload may need to be:\n * - decoded for SSR (render path), and/or\n * - serialized for transport to the client for client-side decoding.\n *\n * Call sites:\n * - `src/createServerComponent.ts`: wraps the produced Flight stream once.\n * - `src/serialization.ts`: uses `createReplayStream()` to transport a fresh stream\n *   to the client via `RawStream`.\n *\n * Constraints:\n * - Consumption order isn't fixed: SSR decode might start first or transport might\n *   start first depending on the request path.\n * - Sometimes only one happens (e.g. when client calls server function directly).\n *\n * Why not just `ReadableStream.tee()`?\n * - tee() must be called up-front before the stream is consumed/locked and only\n *   creates two live branches (no late \"replay from byte 0\").\n * - If one branch is slower or never consumed, the runtime may buffer internally\n *   to keep branches consistent, which can retain large Flight payloads longer\n *   than intended and makes cleanup less explicit.\n *\n * ReplayableStream reads once, buffers explicitly, can mint replay streams on\n * demand, and centralizes cancellation so aborting can stop upstream work and\n * free buffered data deterministically.\n *\n * Memory Management:\n * - Memory is released when the abort signal fires (request cancelled)\n * - Call `release()` to force immediate cleanup if no more replays are needed\n * - No automatic release: replays can be created at unpredictable times (SSR decode\n *   finishes before serialization starts), so we can't safely auto-release\n */\n\nexport interface ReplayableStreamOptions {\n  signal?: AbortSignal\n}\n\n// Use Symbol.for to ensure the same symbol across different module instances\nexport const REPLAYABLE_STREAM_MARKER = Symbol.for(\n  'tanstack.rsc.ReplayableStream',\n)\n\nexport class ReplayableStream<T = Uint8Array> {\n  // Marker for cross-environment instance checking\n  readonly [REPLAYABLE_STREAM_MARKER] = true\n\n  private chunks: Array<T> = []\n  private done = false\n  private error: unknown = null\n  private waiter: PromiseWithResolvers<void> | null = null\n  private aborted = false\n  private released = false\n\n  private sourceReader: ReadableStreamDefaultReader<T> | null = null\n  private abortSignal: AbortSignal | undefined\n  private abortListener: (() => void) | null = null\n\n  constructor(\n    private source: ReadableStream<T>,\n    private options: ReplayableStreamOptions = {},\n  ) {\n    this.abortSignal = options.signal\n    this.start()\n  }\n\n  private start(): void {\n    const signal = this.abortSignal\n\n    if (signal?.aborted) {\n      this.handleAbort()\n      return\n    }\n\n    const onAbort = () => this.handleAbort()\n    this.abortListener = onAbort\n    signal?.addEventListener('abort', onAbort, { once: true })\n\n    const reader = this.source.getReader()\n    this.sourceReader = reader\n\n    const pump = async () => {\n      try {\n        // Keep reading until upstream ends or we are stopped.\n        while (!this.aborted && !this.released) {\n          const { done, value } = await reader.read()\n          if (done) break\n          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n          if (this.aborted || this.released) break\n          this.chunks.push(value)\n          this.notify()\n        }\n        this.done = true\n      } catch (err) {\n        if (!this.aborted && !this.released) {\n          this.error = err\n        }\n        this.done = true\n      } finally {\n        this.detachAbortListener()\n        try {\n          reader.releaseLock()\n        } catch {\n          // Ignore\n        }\n        if (this.sourceReader === reader) {\n          this.sourceReader = null\n        }\n        this.notify()\n      }\n    }\n\n    pump()\n  }\n\n  private detachAbortListener(): void {\n    const signal = this.abortSignal\n    const listener = this.abortListener\n    if (signal && listener) {\n      signal.removeEventListener('abort', listener)\n    }\n    this.abortListener = null\n  }\n\n  private cancelSource(reason: unknown): void {\n    const reader = this.sourceReader\n    this.sourceReader = null\n\n    try {\n      reader?.cancel(reason).catch(() => {})\n    } catch {\n      // Ignore\n    }\n  }\n\n  private handleAbort(): void {\n    if (this.aborted) return\n    this.aborted = true\n    this.done = true\n\n    // Try to stop upstream work immediately.\n    // Cancellation during an abort can throw synchronously in some runtimes\n    // (eg when the underlying cancel algorithm throws). Never let that escape\n    // an AbortSignal event handler.\n    const reason =\n      this.abortSignal?.reason ?? new Error('ReplayableStream aborted')\n\n    this.detachAbortListener()\n    this.abortSignal = undefined\n    this.cancelSource(reason)\n\n    this.chunks = [] // Free memory immediately on abort\n    this.released = true\n    this.notify()\n  }\n\n  private notify(): void {\n    if (this.waiter) {\n      this.waiter.resolve()\n      this.waiter = null\n    }\n  }\n\n  private wait(): Promise<void> {\n    if (this.done || this.released) return Promise.resolve()\n    if (!this.waiter) {\n      this.waiter = Promise.withResolvers<void>()\n    }\n    return this.waiter.promise\n  }\n\n  /**\n   * Explicitly release buffered chunks.\n   * Call this when you know no more replay streams will be created.\n   * After calling release(), createReplayStream() will return empty streams.\n   */\n  release(): void {\n    if (this.released) return\n\n    this.released = true\n    this.chunks = []\n\n    // Release should also stop upstream work and wake any waiters.\n    // This is important when a Flight payload is never consumed again\n    // (eg. cached loader data that evicts) to avoid retaining upstream resources.\n    this.detachAbortListener()\n    this.abortSignal = undefined\n    this.cancelSource(new Error('ReplayableStream released'))\n    this.notify()\n  }\n\n  /**\n   * Check if the stream data has been released\n   */\n  isReleased(): boolean {\n    return this.released\n  }\n\n  /**\n   * Create an independent replay stream. Each call returns a fresh reader\n   * that starts from the beginning of the buffered data.\n   *\n   * If the stream has been released, returns a stream that closes immediately.\n   */\n  createReplayStream(): ReadableStream<T> {\n    if (this.released) {\n      return new ReadableStream<T>({\n        start(controller) {\n          controller.close()\n        },\n      })\n    }\n\n    let index = 0\n\n    return new ReadableStream<T>({\n      pull: async (controller) => {\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n        while (true) {\n          if (this.released) {\n            controller.close()\n            return\n          }\n\n          if (index < this.chunks.length) {\n            controller.enqueue(this.chunks[index++] as T)\n            return\n          }\n\n          if (this.done) {\n            if (this.error && !this.aborted) {\n              controller.error(this.error)\n            } else {\n              controller.close()\n            }\n            return\n          }\n\n          await this.wait()\n        }\n      },\n      cancel: () => {\n        // No-op: consumers canceling a replay should not cancel upstream.\n        // Upstream cancellation is controlled by abort/release.\n      },\n    })\n  }\n}\n"],"mappings":"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"}

package/dist/esm/RscNodeRenderer.js

@@ -0,0 +1,46 @@
+"use client";
+import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH, SERVER_COMPONENT_CSS_HREFS, SERVER_COMPONENT_JS_PRELOADS } from "./ServerComponentTypes.js";
+import { Suspense } from "react";
+import ReactDOM from "react-dom";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#region src/RscNodeRenderer.tsx
+function EmptyFallback() {
+	return null;
+}
+function RscNodeRenderInner({ getTree, path }) {
+	let tree = getTree();
+	for (const key of path) {
+		if (tree === null || tree === void 0) return null;
+		if (typeof tree !== "object") return null;
+		tree = tree[key];
+	}
+	if (tree === null || tree === void 0) return null;
+	return tree;
+}
+/**
+* Renders a renderable RSC proxy without slot support.
+* Used internally by the renderable proxy's $$typeof/type masquerade.
+*/
+function RscNodeRenderer({ data }) {
+	const cssHrefs = data[SERVER_COMPONENT_CSS_HREFS];
+	const jsPreloads = data[SERVER_COMPONENT_JS_PRELOADS];
+	const path = data[RSC_PROXY_PATH] ?? [];
+	const getTree = data[RSC_PROXY_GET_TREE];
+	if (!getTree) throw new Error("[tanstack/start] RscNodeRenderer missing getTree on RSC data.");
+	for (const href of cssHrefs ?? []) ReactDOM.preinit(href, {
+		as: "style",
+		precedence: "high"
+	});
+	if (jsPreloads) for (const href of jsPreloads) ReactDOM.preloadModule(href);
+	return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(Suspense, {
+		fallback: /* @__PURE__ */ jsx(EmptyFallback, {}),
+		children: /* @__PURE__ */ jsx(RscNodeRenderInner, {
+			getTree,
+			path
+		})
+	}) });
+}
+//#endregion
+export { RscNodeRenderer };
+
+//# sourceMappingURL=RscNodeRenderer.js.map

package/dist/esm/RscNodeRenderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RscNodeRenderer.js","names":[],"sources":["../../src/RscNodeRenderer.tsx"],"sourcesContent":["'use client'\n\nimport { Suspense } from 'react'\nimport ReactDOM from 'react-dom'\n\nimport {\n  RSC_PROXY_GET_TREE,\n  RSC_PROXY_PATH,\n  SERVER_COMPONENT_CSS_HREFS,\n  SERVER_COMPONENT_JS_PRELOADS,\n} from './ServerComponentTypes'\n\nfunction EmptyFallback() {\n  return null\n}\n\nfunction RscNodeRenderInner({\n  getTree,\n  path,\n}: {\n  getTree: () => unknown\n  path: Array<string>\n}): React.ReactNode {\n  let tree: unknown = getTree()\n\n  for (const key of path) {\n    if (tree === null || tree === undefined) return null\n    if (typeof tree !== 'object') return null\n    tree = (tree as Record<string, unknown>)[key]\n  }\n\n  if (tree === null || tree === undefined) return null\n\n  // No SlotProvider - just return the tree directly\n  return tree as React.ReactNode\n}\n\n/**\n * Renders a renderable RSC proxy without slot support.\n * Used internally by the renderable proxy's $$typeof/type masquerade.\n */\nexport function RscNodeRenderer({ data }: { data: any }): React.ReactNode {\n  const cssHrefs = data[SERVER_COMPONENT_CSS_HREFS] as\n    | ReadonlySet<string>\n    | undefined\n  const jsPreloads = data[SERVER_COMPONENT_JS_PRELOADS] as\n    | ReadonlySet<string>\n    | undefined\n\n  const path = (data[RSC_PROXY_PATH] as Array<string> | undefined) ?? []\n\n  const getTree = data[RSC_PROXY_GET_TREE] as (() => unknown) | undefined\n  if (!getTree) {\n    throw new Error(\n      '[tanstack/start] RscNodeRenderer missing getTree on RSC data.',\n    )\n  }\n\n  for (const href of cssHrefs ?? []) {\n    ReactDOM.preinit(href, { as: 'style', precedence: 'high' })\n  }\n\n  if (jsPreloads) {\n    for (const href of jsPreloads) {\n      ReactDOM.preloadModule(href)\n    }\n  }\n\n  return (\n    <>\n      <Suspense fallback={<EmptyFallback />}>\n        <RscNodeRenderInner getTree={getTree} path={path} />\n      </Suspense>\n    </>\n  )\n}\n"],"mappings":";;;;;;AAYA,SAAS,gBAAgB;AACvB,QAAO;;AAGT,SAAS,mBAAmB,EAC1B,SACA,QAIkB;CAClB,IAAI,OAAgB,SAAS;AAE7B,MAAK,MAAM,OAAO,MAAM;AACtB,MAAI,SAAS,QAAQ,SAAS,KAAA,EAAW,QAAO;AAChD,MAAI,OAAO,SAAS,SAAU,QAAO;AACrC,SAAQ,KAAiC;;AAG3C,KAAI,SAAS,QAAQ,SAAS,KAAA,EAAW,QAAO;AAGhD,QAAO;;;;;;AAOT,SAAgB,gBAAgB,EAAE,QAAwC;CACxE,MAAM,WAAW,KAAK;CAGtB,MAAM,aAAa,KAAK;CAIxB,MAAM,OAAQ,KAAK,mBAAiD,EAAE;CAEtE,MAAM,UAAU,KAAK;AACrB,KAAI,CAAC,QACH,OAAM,IAAI,MACR,gEACD;AAGH,MAAK,MAAM,QAAQ,YAAY,EAAE,CAC/B,UAAS,QAAQ,MAAM;EAAE,IAAI;EAAS,YAAY;EAAQ,CAAC;AAG7D,KAAI,WACF,MAAK,MAAM,QAAQ,WACjB,UAAS,cAAc,KAAK;AAIhC,QACE,oBAAA,UAAA,EAAA,UACE,oBAAC,UAAD;EAAU,UAAU,oBAAC,eAAD,EAAiB,CAAA;YACnC,oBAAC,oBAAD;GAA6B;GAAe;GAAQ,CAAA;EAC3C,CAAA,EACV,CAAA"}

package/dist/esm/ServerComponentTypes.js

@@ -0,0 +1,22 @@
+//#region src/ServerComponentTypes.ts
+var SERVER_COMPONENT_STREAM = Symbol.for("tanstack.rsc.stream");
+var SERVER_COMPONENT_CSS_HREFS = Symbol.for("tanstack.rsc.cssHrefs");
+var SERVER_COMPONENT_JS_PRELOADS = Symbol.for("tanstack.rsc.jsPreloads");
+var RSC_PROXY_PATH = Symbol.for("tanstack.rsc.path");
+var RSC_PROXY_GET_TREE = Symbol.for("tanstack.rsc.getTree");
+var RENDERABLE_RSC = Symbol.for("tanstack.rsc.renderable");
+var RSC_SLOT_USAGES = Symbol.for("tanstack.rsc.slotUsages");
+var RSC_SLOT_USAGES_STREAM = Symbol.for("tanstack.rsc.slotUsages.stream");
+/**
+* Type guard to check if a value is a ServerComponent (Proxy with attached stream).
+* The value can be either an object (proxy target) or a function (stub for server functions).
+*/
+function isServerComponent(value) {
+	if (value === null || value === void 0) return false;
+	if (typeof value !== "object" && typeof value !== "function") return false;
+	return SERVER_COMPONENT_STREAM in value && value[SERVER_COMPONENT_STREAM] !== void 0;
+}
+//#endregion
+export { RENDERABLE_RSC, RSC_PROXY_GET_TREE, RSC_PROXY_PATH, RSC_SLOT_USAGES, RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_CSS_HREFS, SERVER_COMPONENT_JS_PRELOADS, SERVER_COMPONENT_STREAM, isServerComponent };
+
+//# sourceMappingURL=ServerComponentTypes.js.map

package/dist/esm/ServerComponentTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerComponentTypes.js","names":[],"sources":["../../src/ServerComponentTypes.ts"],"sourcesContent":["import type {\n  Constrain,\n  LooseAsyncReturnType,\n  LooseReturnType,\n  ValidateSerializable,\n} from '@tanstack/router-core'\nimport type { ComponentProps, ComponentType } from 'react'\n\nexport interface ServerComponentStream {\n  createReplayStream: () => ReadableStream<Uint8Array>\n}\n\n// Symbol to attach stream to component for serialization\nexport const SERVER_COMPONENT_STREAM = Symbol.for('tanstack.rsc.stream')\n\n// Symbol to attach collected CSS hrefs to component\nexport const SERVER_COMPONENT_CSS_HREFS = Symbol.for('tanstack.rsc.cssHrefs')\n\n// Symbol to attach collected JS modulepreload hrefs to component\nexport const SERVER_COMPONENT_JS_PRELOADS = Symbol.for(\n  'tanstack.rsc.jsPreloads',\n)\n\n// Symbol to attach a nested selection path to the RSC data proxy\nexport const RSC_PROXY_PATH = Symbol.for('tanstack.rsc.path')\n\n// Symbol to attach the root tree getter to every nested proxy\nexport const RSC_PROXY_GET_TREE = Symbol.for('tanstack.rsc.getTree')\n\n// Symbol to mark a proxy as \"renderable\" (for renderServerComponent output)\n// When true: from renderServerComponent (directly renderable)\n// When false/undefined: from createCompositeComponent (needs <CompositeComponent src={...} />)\nexport const RENDERABLE_RSC = Symbol.for('tanstack.rsc.renderable')\n\n// Dev-only: collected slot usage data for devtools (client-side cache)\nexport const RSC_SLOT_USAGES = Symbol.for('tanstack.rsc.slotUsages')\n\n// Dev-only: stream of slot usage preview events for devtools\nexport const RSC_SLOT_USAGES_STREAM = Symbol.for(\n  'tanstack.rsc.slotUsages.stream',\n)\n\nexport type RscSlotUsageEvent = {\n  slot: string\n  // Raw args passed to the slot call (must be serializable by the transport)\n  args?: Array<any>\n}\n\n/**\n * Type guard to check if a value is a ServerComponent (Proxy with attached stream).\n * The value can be either an object (proxy target) or a function (stub for server functions).\n */\nexport function isServerComponent(\n  value: unknown,\n): value is AnyCompositeComponent {\n  if (value === null || value === undefined) return false\n  if (typeof value !== 'object' && typeof value !== 'function') return false\n  return (\n    SERVER_COMPONENT_STREAM in value &&\n    (value as any)[SERVER_COMPONENT_STREAM] !== undefined\n  )\n}\n\n/**\n * Type guard to check if a value is a RenderableRsc (renderable proxy from renderServerComponent).\n * The value can be either an object (proxy target) or a function (stub for server functions).\n */\nexport function isRenderableRsc(value: unknown): boolean {\n  if (value === null || value === undefined) return false\n  if (typeof value !== 'object' && typeof value !== 'function') return false\n  return RENDERABLE_RSC in value && (value as any)[RENDERABLE_RSC] === true\n}\n\nexport type ValidateCompositeComponent<TComp> = Constrain<\n  TComp,\n  (\n    props: ValidateCompositeComponentProps<TComp>,\n  ) => ValidateCompositeComponentReturnType<TComp>\n>\n\nexport type ValidateCompositeComponentProps<TComp> = unknown extends TComp\n  ? TComp\n  : ValidateCompositeComponentPropsObject<CompositeComponentProps<TComp>>\n\nexport type ValidateCompositeComponentPropsObject<TProps> =\n  unknown extends TProps\n    ? TProps\n    : {\n        [TKey in keyof TProps]: ValidateCompositeComponentProp<TProps[TKey]>\n      }\n\nexport type CompositeComponentProps<TComp> = TComp extends (\n  props: infer TProps,\n) => any\n  ? TProps\n  : unknown\n\nexport type ValidateCompositeComponentProp<TProp> = TProp extends (\n  ...args: Array<any>\n) => any\n  ? (...args: ValidateReactSerializable<Parameters<TProp>>) => React.ReactNode\n  : TProp extends ComponentType<any>\n    ? ComponentType<ValidateReactSerializable<ComponentProps<TProp>>>\n    : TProp extends React.ReactNode\n      ? TProp\n      : React.ReactNode\n\nexport type ValidateReactSerializable<T> = ValidateSerializable<\n  T,\n  ReactSerializable\n>\n\nexport type ReactSerializable =\n  | number\n  | string\n  | bigint\n  | boolean\n  | null\n  | undefined\n  | React.ReactNode\n\nexport type ValidateCompositeComponentReturnType<TComp> = unknown extends TComp\n  ? React.ReactNode\n  : ValidateCompositeComponentResult<LooseReturnType<TComp>>\n\nexport type ValidateCompositeComponentResult<TNode> =\n  ValidateServerComponentResult<TNode>\n\nexport type ValidateServerComponentResult<TNode> =\n  TNode extends Promise<any>\n    ? ValidateCompositeComponentPromiseResult<TNode>\n    : TNode extends React.ReactNode\n      ? TNode\n      : TNode extends (...args: Array<any>) => any\n        ? React.ReactNode\n        : TNode extends object\n          ? ValidateCompositeComponentObjectResult<TNode>\n          : React.ReactNode\n\nexport type ValidateCompositeComponentPromiseResult<TPromise> =\n  TPromise extends Promise<infer T>\n    ? Promise<ValidateCompositeComponentResult<T>>\n    : never\n\nexport type ValidateCompositeComponentObjectResult<TObject> = {\n  [TKey in keyof TObject]: ValidateCompositeComponentResult<TObject[TKey]>\n}\n\nexport type CompositeComponentResult<TComp> = CompositeComponentBuilder<\n  TComp,\n  LooseAsyncReturnType<TComp>\n>\n\nexport type CompositeComponentBuilder<TComp, TReturn> =\n  TReturn extends React.ReactNode\n    ? CompositeComponent<TComp, TReturn>\n    : {\n        [TKey in keyof TReturn]: CompositeComponentBuilder<TComp, TReturn[TKey]>\n      }\n\nexport interface CompositeComponent<in out TComp, in out TReturn> {\n  '~types': {\n    props: CompositeComponentProps<TComp>\n    return: TReturn\n  }\n\n  [SERVER_COMPONENT_STREAM]?: ServerComponentStream\n\n  /**\n   * Root decoded tree getter.\n   */\n  [RSC_PROXY_GET_TREE]?: () => unknown\n  /**\n   * Nested selection path (eg ['content','Stats']).\n   * Used by <CompositeComponent/> to render a sub-tree.\n   */\n  [RSC_PROXY_PATH]?: Array<string>\n  /**\n   * CSS hrefs collected from the RSC stream.\n   * Can be used for preloading in <head> or emitting 103 Early Hints.\n   */\n  [SERVER_COMPONENT_CSS_HREFS]?: ReadonlySet<string>\n\n  /**\n   * JS hrefs collected from the RSC stream.\n   * Emitted as modulepreload links only if the decoded tree is rendered in SSR.\n   */\n  [SERVER_COMPONENT_JS_PRELOADS]?: ReadonlySet<string>\n\n  /**\n   * Dev-only: async stream of slot usage preview events.\n   * Used by devtools to show slot names and previewed call args without\n   * buffering/draining the Flight stream.\n   */\n  [RSC_SLOT_USAGES_STREAM]?: ReadableStream<RscSlotUsageEvent>\n}\n\nexport type ValidateRenderableServerComponent<TNode> =\n  ValidateServerComponentResult<TNode>\n\nexport type RenderableServerComponentBuilder<T> = T extends React.ReactNode\n  ? RenderableServerComponent<T>\n  : { [TKey in keyof T]: RenderableServerComponentBuilder<T[TKey]> }\n\nexport type RenderableServerComponent<TNode extends React.ReactNode> = TNode &\n  RenderableServerComponentAttributes<TNode>\n\nexport interface RenderableServerComponentAttributes<TNode> {\n  '~types': {\n    node: TNode\n  }\n  [SERVER_COMPONENT_STREAM]: ServerComponentStream\n  [RENDERABLE_RSC]: true\n}\n\ndeclare module '@tanstack/router-core' {\n  export interface SerializableExtensions {\n    CompositeComponent: AnyCompositeComponent\n    RenderableServerComponent: AnyRenderableServerComponent\n  }\n}\n\nexport type AnyCompositeComponent = CompositeComponent<any, any>\n\nexport type AnyRenderableServerComponent =\n  RenderableServerComponentAttributes<any>\n"],"mappings":";AAaA,IAAa,0BAA0B,OAAO,IAAI,sBAAsB;AAGxE,IAAa,6BAA6B,OAAO,IAAI,wBAAwB;AAG7E,IAAa,+BAA+B,OAAO,IACjD,0BACD;AAGD,IAAa,iBAAiB,OAAO,IAAI,oBAAoB;AAG7D,IAAa,qBAAqB,OAAO,IAAI,uBAAuB;AAKpE,IAAa,iBAAiB,OAAO,IAAI,0BAA0B;AAGnE,IAAa,kBAAkB,OAAO,IAAI,0BAA0B;AAGpE,IAAa,yBAAyB,OAAO,IAC3C,iCACD;;;;;AAYD,SAAgB,kBACd,OACgC;AAChC,KAAI,UAAU,QAAQ,UAAU,KAAA,EAAW,QAAO;AAClD,KAAI,OAAO,UAAU,YAAY,OAAO,UAAU,WAAY,QAAO;AACrE,QACE,2BAA2B,SAC1B,MAAc,6BAA6B,KAAA"}

package/dist/esm/SlotContext.js

@@ -0,0 +1,30 @@
+"use client";
+import { createContext, use } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/SlotContext.tsx
+var SlotContext = createContext(null);
+/**
+* Hook to access slot implementations from within ClientSlot.
+*/
+function useSlotContext() {
+	return use(SlotContext);
+}
+/**
+* SlotProvider - makes slot implementations available to ClientSlot components.
+*
+* Must wrap the decoded RSC content so that ClientSlot components can
+* access their slot implementations via React Context.
+*/
+function SlotProvider({ implementations, strict, children }) {
+	return /* @__PURE__ */ jsx(SlotContext, {
+		value: {
+			implementations,
+			strict: strict ?? false
+		},
+		children
+	});
+}
+//#endregion
+export { SlotProvider, useSlotContext };
+
+//# sourceMappingURL=SlotContext.js.map

package/dist/esm/SlotContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlotContext.js","names":[],"sources":["../../src/SlotContext.tsx"],"sourcesContent":["'use client'\n\nimport { createContext, use } from 'react'\nimport type { SlotImplementations } from './types'\n\nexport interface SlotContextValue {\n  implementations: SlotImplementations\n  strict: boolean\n}\n\nconst SlotContext = createContext<SlotContextValue | null>(null)\n\n/**\n * Hook to access slot implementations from within ClientSlot.\n */\nexport function useSlotContext(): SlotContextValue | null {\n  return use(SlotContext)\n}\n\nexport interface SlotProviderProps {\n  implementations: SlotImplementations\n  strict?: boolean\n  children?: React.ReactNode\n}\n\n/**\n * SlotProvider - makes slot implementations available to ClientSlot components.\n *\n * Must wrap the decoded RSC content so that ClientSlot components can\n * access their slot implementations via React Context.\n */\nexport function SlotProvider({\n  implementations,\n  strict,\n  children,\n}: SlotProviderProps) {\n  return (\n    <SlotContext value={{ implementations, strict: strict ?? false }}>\n      {children}\n    </SlotContext>\n  )\n}\n"],"mappings":";;;;AAUA,IAAM,cAAc,cAAuC,KAAK;;;;AAKhE,SAAgB,iBAA0C;AACxD,QAAO,IAAI,YAAY;;;;;;;;AAezB,SAAgB,aAAa,EAC3B,iBACA,QACA,YACoB;AACpB,QACE,oBAAC,aAAD;EAAa,OAAO;GAAE;GAAiB,QAAQ,UAAU;GAAO;EAC7D;EACW,CAAA"}

package/dist/esm/awaitLazyElements.js

@@ -0,0 +1,41 @@
+import { ReactElement, ReactLazy, ReactSuspense } from "./reactSymbols.js";
+//#region src/awaitLazyElements.ts
+/**
+* Yields pending lazy element payloads from a tree, stopping at Suspense boundaries.
+* Also collects CSS hrefs from <link rel="stylesheet" data-rsc-css-href> elements.
+*/
+function* findPendingLazyPayloads(obj, seen = /* @__PURE__ */ new Set(), cssCollector) {
+	if (!obj || typeof obj !== "object") return;
+	if (seen.has(obj)) return;
+	seen.add(obj);
+	const el = obj;
+	if (el.$$typeof === ReactElement && el.type === ReactSuspense) return;
+	if (el.$$typeof === ReactElement && el.type === "link" && el.props?.rel === "stylesheet") {
+		const cssHref = el.props["data-rsc-css-href"];
+		if (cssHref && cssCollector) cssCollector(cssHref);
+	}
+	if (el.$$typeof === ReactLazy) {
+		const payload = el._payload;
+		if (payload && typeof payload === "object" && (payload.status === "pending" || payload.status === "blocked") && typeof payload.then === "function") yield payload;
+	}
+	if (Array.isArray(obj)) for (const item of obj) yield* findPendingLazyPayloads(item, seen, cssCollector);
+	else for (const key of Object.keys(obj)) if (key !== "_owner" && key !== "_store") yield* findPendingLazyPayloads(el[key], seen, cssCollector);
+}
+/**
+* Wait for all lazy elements in a tree to be resolved.
+* This ensures client component chunks are fully loaded before rendering,
+* preventing Suspense boundaries from flashing during SWR navigation.
+*
+* Also collects CSS hrefs from <link rel="stylesheet" data-rsc-css-href>
+* elements for preloading in <head>.
+*
+* @param tree - The tree to process
+* @param cssCollector - Optional callback to collect CSS hrefs (server-only)
+*/
+async function awaitLazyElements(tree, cssCollector) {
+	for (const payload of findPendingLazyPayloads(tree, /* @__PURE__ */ new Set(), cssCollector)) await Promise.resolve(payload).catch(() => {});
+}
+//#endregion
+export { awaitLazyElements };
+
+//# sourceMappingURL=awaitLazyElements.js.map

package/dist/esm/awaitLazyElements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"awaitLazyElements.js","names":[],"sources":["../../src/awaitLazyElements.ts"],"sourcesContent":["import { ReactElement, ReactLazy, ReactSuspense } from './reactSymbols'\n\n/**\n * Optional callback for collecting CSS hrefs during tree traversal.\n * Only called server-side when processing <link rel=\"stylesheet\" data-rsc-css-href>\n */\nexport type CssHrefCollector = (href: string) => void\n\n/**\n * Yields pending lazy element payloads from a tree, stopping at Suspense boundaries.\n * Also collects CSS hrefs from <link rel=\"stylesheet\" data-rsc-css-href> elements.\n */\nfunction* findPendingLazyPayloads(\n  obj: unknown,\n  seen = new Set(),\n  cssCollector?: CssHrefCollector,\n): Generator<PromiseLike<unknown>> {\n  if (!obj || typeof obj !== 'object') return\n  if (seen.has(obj)) return\n  seen.add(obj)\n\n  const el = obj as any\n\n  // Stop at Suspense boundaries - lazy elements inside are intentionally deferred\n  if (el.$$typeof === ReactElement && el.type === ReactSuspense) {\n    return\n  }\n\n  // Collect CSS hrefs from <link rel=\"stylesheet\" data-rsc-css-href>\n  // The active RSC bundler adapter injects these for CSS module imports\n  if (\n    el.$$typeof === ReactElement &&\n    el.type === 'link' &&\n    el.props?.rel === 'stylesheet'\n  ) {\n    const cssHref = el.props['data-rsc-css-href'] as string | undefined\n    if (cssHref && cssCollector) {\n      cssCollector(cssHref)\n    }\n  }\n\n  // Yield pending lazy element payload\n  if (el.$$typeof === ReactLazy) {\n    const payload = el._payload\n    if (\n      payload &&\n      typeof payload === 'object' &&\n      (payload.status === 'pending' || payload.status === 'blocked') &&\n      typeof payload.then === 'function'\n    ) {\n      yield payload\n    }\n  }\n\n  // Recurse into children\n  if (Array.isArray(obj)) {\n    for (const item of obj) {\n      yield* findPendingLazyPayloads(item, seen, cssCollector)\n    }\n  } else {\n    for (const key of Object.keys(obj)) {\n      if (key !== '_owner' && key !== '_store') {\n        yield* findPendingLazyPayloads(el[key], seen, cssCollector)\n      }\n    }\n  }\n}\n\n/**\n * Wait for all lazy elements in a tree to be resolved.\n * This ensures client component chunks are fully loaded before rendering,\n * preventing Suspense boundaries from flashing during SWR navigation.\n *\n * Also collects CSS hrefs from <link rel=\"stylesheet\" data-rsc-css-href>\n * elements for preloading in <head>.\n *\n * @param tree - The tree to process\n * @param cssCollector - Optional callback to collect CSS hrefs (server-only)\n */\nexport async function awaitLazyElements(\n  tree: unknown,\n  cssCollector?: CssHrefCollector,\n): Promise<void> {\n  for (const payload of findPendingLazyPayloads(\n    tree,\n    new Set(),\n    cssCollector,\n  )) {\n    await Promise.resolve(payload).catch(() => {})\n  }\n}\n"],"mappings":";;;;;;AAYA,UAAU,wBACR,KACA,uBAAO,IAAI,KAAK,EAChB,cACiC;AACjC,KAAI,CAAC,OAAO,OAAO,QAAQ,SAAU;AACrC,KAAI,KAAK,IAAI,IAAI,CAAE;AACnB,MAAK,IAAI,IAAI;CAEb,MAAM,KAAK;AAGX,KAAI,GAAG,aAAa,gBAAgB,GAAG,SAAS,cAC9C;AAKF,KACE,GAAG,aAAa,gBAChB,GAAG,SAAS,UACZ,GAAG,OAAO,QAAQ,cAClB;EACA,MAAM,UAAU,GAAG,MAAM;AACzB,MAAI,WAAW,aACb,cAAa,QAAQ;;AAKzB,KAAI,GAAG,aAAa,WAAW;EAC7B,MAAM,UAAU,GAAG;AACnB,MACE,WACA,OAAO,YAAY,aAClB,QAAQ,WAAW,aAAa,QAAQ,WAAW,cACpD,OAAO,QAAQ,SAAS,WAExB,OAAM;;AAKV,KAAI,MAAM,QAAQ,IAAI,CACpB,MAAK,MAAM,QAAQ,IACjB,QAAO,wBAAwB,MAAM,MAAM,aAAa;KAG1D,MAAK,MAAM,OAAO,OAAO,KAAK,IAAI,CAChC,KAAI,QAAQ,YAAY,QAAQ,SAC9B,QAAO,wBAAwB,GAAG,MAAM,MAAM,aAAa;;;;;;;;;;;;;AAiBnE,eAAsB,kBACpB,MACA,cACe;AACf,MAAK,MAAM,WAAW,wBACpB,sBACA,IAAI,KAAK,EACT,aACD,CACC,OAAM,QAAQ,QAAQ,QAAQ,CAAC,YAAY,GAAG"}