@tanstack/react-start-rsc 0.0.0

package/dist/esm/plugin/vite.js

@@ -0,0 +1,172 @@
+import { fileURLToPath } from "node:url";
+import path from "pathe";
+import { resolveViteId } from "@tanstack/start-plugin-core/utils";
+//#region src/plugin/vite.ts
+var isClientEnvironment = (env) => env.config.consumer === "client";
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createVirtualModule(opts) {
+	const resolvedId = resolveViteId(opts.moduleId);
+	const idFilter = { id: new RegExp(escapeRegExp(opts.moduleId)) };
+	return {
+		name: opts.name,
+		apply: opts.apply,
+		applyToEnvironment: opts.applyToEnvironment,
+		resolveId: {
+			filter: idFilter,
+			handler() {
+				return resolvedId;
+			}
+		},
+		load: {
+			filter: idFilter,
+			handler: opts.load
+		}
+	};
+}
+var RSC_HMR_VIRTUAL_ID = "virtual:tanstack-rsc-hmr";
+var RSC_RUNTIME_VIRTUAL_ID = "virtual:tanstack-rsc-runtime";
+var RSC_BROWSER_DECODE_VIRTUAL_ID = "virtual:tanstack-rsc-browser-decode";
+var RSC_SSR_DECODE_VIRTUAL_ID = "virtual:tanstack-rsc-ssr-decode";
+var RSC_ENV_NAME = "rsc";
+var currentDir = path.dirname(fileURLToPath(import.meta.url));
+var entryDir = path.resolve(currentDir, "..", "..", "plugin", "entry");
+var rscEntryPath = path.resolve(entryDir, "rsc.tsx");
+function configureRsc() {
+	return {
+		envName: RSC_ENV_NAME,
+		providerEnvironmentName: RSC_ENV_NAME,
+		ssrResolverStrategy: {
+			type: "vite-rsc-forward",
+			sourceEnvironmentName: RSC_ENV_NAME,
+			sourceEntry: "index",
+			exportName: "getServerFnById"
+		},
+		serializationAdapters: [{
+			client: {
+				module: "@tanstack/react-start/rsc/serialization/client",
+				export: "rscSerializationAdapter",
+				isFactory: true
+			},
+			server: {
+				module: "@tanstack/react-start/rsc/serialization/server",
+				export: "rscSerializationAdapter",
+				isFactory: true
+			}
+		}]
+	};
+}
+function reactStartRscVitePlugin() {
+	return [
+		{
+			name: "tanstack-react-start:rsc-ssr-config",
+			config() {
+				return { ssr: { noExternal: true } };
+			}
+		},
+		{
+			name: "tanstack-react-start:rsc-env-config",
+			config() {
+				return {
+					rsc: {
+						serverHandler: false,
+						cssLinkPrecedence: false
+					},
+					environments: { [RSC_ENV_NAME]: {
+						consumer: "server",
+						resolve: { noExternal: [
+							"@tanstack/start**",
+							"@tanstack/react-start",
+							"@tanstack/react-start-rsc",
+							"@tanstack/react-router"
+						] },
+						build: { rollupOptions: { input: { index: rscEntryPath } } }
+					} }
+				};
+			}
+		},
+		createVirtualModule({
+			name: "tanstack-react-start:rsc-runtime-virtual",
+			moduleId: RSC_RUNTIME_VIRTUAL_ID,
+			load() {
+				if (this.environment.name === RSC_ENV_NAME) return `export { renderToReadableStream, createFromReadableStream, createTemporaryReferenceSet, decodeReply, loadServerAction, decodeAction, decodeFormState } from '@vitejs/plugin-rsc/rsc'`;
+				return `
+export function renderToReadableStream() { throw new Error('renderToReadableStream can only be used in RSC environment'); }
+export function createFromReadableStream() { throw new Error('createFromReadableStream can only be used in RSC environment'); }
+export function createTemporaryReferenceSet() { throw new Error('createTemporaryReferenceSet can only be used in RSC environment'); }
+export function decodeReply() { throw new Error('decodeReply can only be used in RSC environment'); }
+export function loadServerAction() { throw new Error('loadServerAction can only be used in RSC environment'); }
+export function decodeAction() { throw new Error('decodeAction can only be used in RSC environment'); }
+export function decodeFormState() { throw new Error('decodeFormState can only be used in RSC environment'); }
+`;
+			}
+		}),
+		createVirtualModule({
+			name: "tanstack-react-start:rsc-browser-decode-virtual",
+			moduleId: RSC_BROWSER_DECODE_VIRTUAL_ID,
+			load() {
+				return `export { createFromReadableStream, createFromFetch } from '@vitejs/plugin-rsc/browser'`;
+			}
+		}),
+		createVirtualModule({
+			name: "tanstack-react-start:rsc-ssr-decode-virtual",
+			moduleId: RSC_SSR_DECODE_VIRTUAL_ID,
+			load() {
+				return `export { setOnClientReference, createFromReadableStream } from '@vitejs/plugin-rsc/ssr'`;
+			}
+		}),
+		createVirtualModule({
+			name: "tanstack-react-start:rsc-hmr-virtual:dev",
+			moduleId: RSC_HMR_VIRTUAL_ID,
+			apply: "serve",
+			applyToEnvironment: isClientEnvironment,
+			load() {
+				return `
+export function setupRscHmr() {
+if (!import.meta.hot) {
+  return
+}
+
+  let __invalidateQueued = false
+
+  function __queueInvalidate() {
+    if (__invalidateQueued) return
+    __invalidateQueued = true
+    queueMicrotask(async () => {
+        __invalidateQueued = false
+        try {
+        const router = window.__TSR_ROUTER__
+        if (!router) {
+            console.warn('[rsc:hmr] No router found on window.__TSR_ROUTER__')
+            return
+        }
+        await router.invalidate()
+        } catch (e) {
+        console.warn('[rsc:hmr] Failed to invalidate router:', e)
+        }
+    })
+  }
+
+  import.meta.hot.on('rsc:update', () => {
+    __queueInvalidate()
+  })
+}
+`;
+			}
+		}),
+		createVirtualModule({
+			name: "tanstack-react-start:rsc-hmr-virtual:prod",
+			moduleId: RSC_HMR_VIRTUAL_ID,
+			applyToEnvironment: isClientEnvironment,
+			apply: "build",
+			load() {
+				return "export function setupRscHmr() {} ";
+			}
+		})
+	];
+}
+//#endregion
+export { configureRsc, reactStartRscVitePlugin };
+
+//# sourceMappingURL=vite.js.map

package/dist/esm/plugin/vite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.js","names":[],"sources":["../../../src/plugin/vite.ts"],"sourcesContent":["import { fileURLToPath } from 'node:url'\nimport path from 'pathe'\nimport { resolveViteId } from '@tanstack/start-plugin-core/utils'\nimport type {\n  TanStackStartVitePluginCoreOptions,\n  ViteRscForwardSsrResolverStrategy,\n} from '@tanstack/start-plugin-core/vite/types'\nimport type { Plugin, PluginOption, UserConfig } from 'vite'\n\ntype VirtualModuleLoadHandler = (this: {\n  environment: { name: string }\n}) => string\nconst isClientEnvironment = (env: { config: { consumer: string } }) =>\n  env.config.consumer === 'client'\n\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\nfunction createVirtualModule(opts: {\n  name: string\n  moduleId: string\n  load: VirtualModuleLoadHandler\n  apply?: Plugin['apply']\n  applyToEnvironment?: Plugin['applyToEnvironment']\n}): Plugin {\n  const resolvedId = resolveViteId(opts.moduleId)\n  const idFilter = { id: new RegExp(escapeRegExp(opts.moduleId)) }\n\n  return {\n    name: opts.name,\n    apply: opts.apply,\n    applyToEnvironment: opts.applyToEnvironment,\n    resolveId: {\n      filter: idFilter,\n      handler() {\n        return resolvedId\n      },\n    },\n    load: {\n      filter: idFilter,\n      handler: opts.load,\n    },\n  }\n}\n\n// Virtual module ids used by the React Start RSC runtime.\nconst RSC_HMR_VIRTUAL_ID = 'virtual:tanstack-rsc-hmr'\nconst RSC_RUNTIME_VIRTUAL_ID = 'virtual:tanstack-rsc-runtime'\nconst RSC_BROWSER_DECODE_VIRTUAL_ID = 'virtual:tanstack-rsc-browser-decode'\nconst RSC_SSR_DECODE_VIRTUAL_ID = 'virtual:tanstack-rsc-ssr-decode'\nconst RSC_ENV_NAME = 'rsc'\n\nconst currentDir = path.dirname(fileURLToPath(import.meta.url))\nconst entryDir = path.resolve(currentDir, '..', '..', 'plugin', 'entry')\nconst rscEntryPath = path.resolve(entryDir, 'rsc.tsx')\n\nexport function configureRsc(): {\n  envName: string\n  providerEnvironmentName: TanStackStartVitePluginCoreOptions['providerEnvironmentName']\n  ssrResolverStrategy: TanStackStartVitePluginCoreOptions['ssrResolverStrategy']\n  serializationAdapters: TanStackStartVitePluginCoreOptions['serializationAdapters']\n} {\n  const serializationAdapters: TanStackStartVitePluginCoreOptions['serializationAdapters'] =\n    [\n      // IMPORTANT: plugin-adapters-plugin only calls the top-level factory once.\n      // That factory must return a flat array of adapters (not nested arrays),\n      // otherwise router-core ends up with non-adapter entries and Seroval crashes.\n      {\n        client: {\n          module: '@tanstack/react-start/rsc/serialization/client',\n          export: 'rscSerializationAdapter',\n          isFactory: true,\n        },\n        server: {\n          module: '@tanstack/react-start/rsc/serialization/server',\n          export: 'rscSerializationAdapter',\n          isFactory: true,\n        },\n      },\n    ]\n  const ssrResolverStrategy = {\n    type: 'vite-rsc-forward',\n    sourceEnvironmentName: RSC_ENV_NAME,\n    sourceEntry: 'index',\n    exportName: 'getServerFnById',\n  } satisfies ViteRscForwardSsrResolverStrategy\n  return {\n    envName: RSC_ENV_NAME,\n    providerEnvironmentName: RSC_ENV_NAME,\n    ssrResolverStrategy,\n    serializationAdapters,\n  }\n}\nexport function reactStartRscVitePlugin(): PluginOption {\n  return [\n    // When RSC is enabled, SSR needs noExternal: true to ensure single React instance.\n    // The RSC decoder's dynamic imports for client components can cause module duplication\n    // without this, leading to \"Invalid hook call\" errors.\n    // We use the top-level `ssr` config option as `environments.ssr.resolve.noExternal`\n    // doesn't have the same effect.\n    {\n      name: 'tanstack-react-start:rsc-ssr-config',\n      config() {\n        return {\n          ssr: {\n            noExternal: true,\n          },\n        }\n      },\n    },\n    {\n      name: 'tanstack-react-start:rsc-env-config',\n      config() {\n        return {\n          rsc: {\n            // Disable @vitejs/plugin-rsc's built-in server handler middleware.\n            // TanStack Start has its own request handling via the SSR environment.\n            serverHandler: false,\n            // Disable CSS link precedence to prevent React 19 SSR suspension\n            // TanStack Start handles CSS preloading via manifest injection instead\n            cssLinkPrecedence: false,\n          },\n          environments: {\n            [RSC_ENV_NAME]: {\n              consumer: 'server',\n              // Force @tanstack packages to be processed by Vite as source code\n              // rather than treated as external modules. This ensures:\n              // 1. createIsomorphicFn transforms are applied\n              // 2. Imports are resolved within the RSC environment context\n              //    with proper react-server conditions and pre-bundled deps\n              resolve: {\n                noExternal: [\n                  '@tanstack/start**',\n                  '@tanstack/react-start',\n                  '@tanstack/react-start-rsc',\n                  '@tanstack/react-router',\n                ],\n              },\n              build: {\n                rollupOptions: {\n                  input: {\n                    index: rscEntryPath,\n                  },\n                },\n              },\n            },\n          },\n        } satisfies UserConfig & {\n          rsc: {\n            serverHandler: false\n            cssLinkPrecedence?: boolean\n          }\n        }\n      },\n    },\n\n    // Runtime bridge into the Vite RSC environment.\n    createVirtualModule({\n      name: 'tanstack-react-start:rsc-runtime-virtual',\n      moduleId: RSC_RUNTIME_VIRTUAL_ID,\n      load() {\n        const envName = this.environment.name\n        if (envName === RSC_ENV_NAME) {\n          return `export { renderToReadableStream, createFromReadableStream, createTemporaryReferenceSet, decodeReply, loadServerAction, decodeAction, decodeFormState } from '@vitejs/plugin-rsc/rsc'`\n        }\n        return `\nexport function renderToReadableStream() { throw new Error('renderToReadableStream can only be used in RSC environment'); }\nexport function createFromReadableStream() { throw new Error('createFromReadableStream can only be used in RSC environment'); }\nexport function createTemporaryReferenceSet() { throw new Error('createTemporaryReferenceSet can only be used in RSC environment'); }\nexport function decodeReply() { throw new Error('decodeReply can only be used in RSC environment'); }\nexport function loadServerAction() { throw new Error('loadServerAction can only be used in RSC environment'); }\nexport function decodeAction() { throw new Error('decodeAction can only be used in RSC environment'); }\nexport function decodeFormState() { throw new Error('decodeFormState can only be used in RSC environment'); }\n`\n      },\n    }),\n    createVirtualModule({\n      name: 'tanstack-react-start:rsc-browser-decode-virtual',\n      moduleId: RSC_BROWSER_DECODE_VIRTUAL_ID,\n      load() {\n        return `export { createFromReadableStream, createFromFetch } from '@vitejs/plugin-rsc/browser'`\n      },\n    }),\n    createVirtualModule({\n      name: 'tanstack-react-start:rsc-ssr-decode-virtual',\n      moduleId: RSC_SSR_DECODE_VIRTUAL_ID,\n      load() {\n        return `export { setOnClientReference, createFromReadableStream } from '@vitejs/plugin-rsc/ssr'`\n      },\n    }),\n    createVirtualModule({\n      name: 'tanstack-react-start:rsc-hmr-virtual:dev',\n      moduleId: RSC_HMR_VIRTUAL_ID,\n      apply: 'serve',\n      applyToEnvironment: isClientEnvironment,\n      load() {\n        return `\nexport function setupRscHmr() {\nif (!import.meta.hot) {\n  return\n}\n\n  let __invalidateQueued = false\n\n  function __queueInvalidate() {\n    if (__invalidateQueued) return\n    __invalidateQueued = true\n    queueMicrotask(async () => {\n        __invalidateQueued = false\n        try {\n        const router = window.__TSR_ROUTER__\n        if (!router) {\n            console.warn('[rsc:hmr] No router found on window.__TSR_ROUTER__')\n            return\n        }\n        await router.invalidate()\n        } catch (e) {\n        console.warn('[rsc:hmr] Failed to invalidate router:', e)\n        }\n    })\n  }\n\n  import.meta.hot.on('rsc:update', () => {\n    __queueInvalidate()\n  })\n}\n`\n      },\n    }),\n    createVirtualModule({\n      name: 'tanstack-react-start:rsc-hmr-virtual:prod',\n      moduleId: RSC_HMR_VIRTUAL_ID,\n      applyToEnvironment: isClientEnvironment,\n      apply: 'build',\n      load() {\n        return 'export function setupRscHmr() {} '\n      },\n    }),\n  ]\n}\n"],"mappings":";;;;AAYA,IAAM,uBAAuB,QAC3B,IAAI,OAAO,aAAa;AAE1B,SAAS,aAAa,OAAuB;AAC3C,QAAO,MAAM,QAAQ,uBAAuB,OAAO;;AAGrD,SAAS,oBAAoB,MAMlB;CACT,MAAM,aAAa,cAAc,KAAK,SAAS;CAC/C,MAAM,WAAW,EAAE,IAAI,IAAI,OAAO,aAAa,KAAK,SAAS,CAAC,EAAE;AAEhE,QAAO;EACL,MAAM,KAAK;EACX,OAAO,KAAK;EACZ,oBAAoB,KAAK;EACzB,WAAW;GACT,QAAQ;GACR,UAAU;AACR,WAAO;;GAEV;EACD,MAAM;GACJ,QAAQ;GACR,SAAS,KAAK;GACf;EACF;;AAIH,IAAM,qBAAqB;AAC3B,IAAM,yBAAyB;AAC/B,IAAM,gCAAgC;AACtC,IAAM,4BAA4B;AAClC,IAAM,eAAe;AAErB,IAAM,aAAa,KAAK,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAC;AAC/D,IAAM,WAAW,KAAK,QAAQ,YAAY,MAAM,MAAM,UAAU,QAAQ;AACxE,IAAM,eAAe,KAAK,QAAQ,UAAU,UAAU;AAEtD,SAAgB,eAKd;AAyBA,QAAO;EACL,SAAS;EACT,yBAAyB;EACzB,qBAT0B;GAC1B,MAAM;GACN,uBAAuB;GACvB,aAAa;GACb,YAAY;GACb;EAKC,uBA3BA,CAIE;GACE,QAAQ;IACN,QAAQ;IACR,QAAQ;IACR,WAAW;IACZ;GACD,QAAQ;IACN,QAAQ;IACR,QAAQ;IACR,WAAW;IACZ;GACF,CACF;EAYF;;AAEH,SAAgB,0BAAwC;AACtD,QAAO;EAML;GACE,MAAM;GACN,SAAS;AACP,WAAO,EACL,KAAK,EACH,YAAY,MACb,EACF;;GAEJ;EACD;GACE,MAAM;GACN,SAAS;AACP,WAAO;KACL,KAAK;MAGH,eAAe;MAGf,mBAAmB;MACpB;KACD,cAAc,GACX,eAAe;MACd,UAAU;MAMV,SAAS,EACP,YAAY;OACV;OACA;OACA;OACA;OACD,EACF;MACD,OAAO,EACL,eAAe,EACb,OAAO,EACL,OAAO,cACR,EACF,EACF;MACF,EACF;KACF;;GAOJ;EAGD,oBAAoB;GAClB,MAAM;GACN,UAAU;GACV,OAAO;AAEL,QADgB,KAAK,YAAY,SACjB,aACd,QAAO;AAET,WAAO;;;;;;;;;;GAUV,CAAC;EACF,oBAAoB;GAClB,MAAM;GACN,UAAU;GACV,OAAO;AACL,WAAO;;GAEV,CAAC;EACF,oBAAoB;GAClB,MAAM;GACN,UAAU;GACV,OAAO;AACL,WAAO;;GAEV,CAAC;EACF,oBAAoB;GAClB,MAAM;GACN,UAAU;GACV,OAAO;GACP,oBAAoB;GACpB,OAAO;AACL,WAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCV,CAAC;EACF,oBAAoB;GAClB,MAAM;GACN,UAAU;GACV,oBAAoB;GACpB,OAAO;GACP,OAAO;AACL,WAAO;;GAEV,CAAC;EACH"}

package/dist/esm/reactSymbols.js

@@ -0,0 +1,8 @@
+//#region src/reactSymbols.ts
+var ReactElement = Symbol.for("react.transitional.element");
+var ReactLazy = Symbol.for("react.lazy");
+var ReactSuspense = Symbol.for("react.suspense");
+//#endregion
+export { ReactElement, ReactLazy, ReactSuspense };
+
+//# sourceMappingURL=reactSymbols.js.map

package/dist/esm/reactSymbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactSymbols.js","names":[],"sources":["../../src/reactSymbols.ts"],"sourcesContent":["// Inline React 19 internal $$typeof symbols to avoid depending on `react-is`.\n// `react-is` is CJS-only, causing module resolution failures in strict pnpm\n// setups where it can't be resolved from the consumer's node_modules.\nexport const ReactElement = Symbol.for('react.transitional.element')\nexport const ReactLazy = Symbol.for('react.lazy')\nexport const ReactSuspense = Symbol.for('react.suspense')\n"],"mappings":";AAGA,IAAa,eAAe,OAAO,IAAI,6BAA6B;AACpE,IAAa,YAAY,OAAO,IAAI,aAAa;AACjD,IAAa,gBAAgB,OAAO,IAAI,iBAAiB"}

package/dist/esm/renderServerComponent.js

@@ -0,0 +1,58 @@
+import { RENDERABLE_RSC, SERVER_COMPONENT_STREAM } from "./ServerComponentTypes.js";
+import { ReplayableStream } from "./ReplayableStream.js";
+import { renderToReadableStream } from "virtual:tanstack-rsc-runtime";
+import { getRequest } from "@tanstack/start-server-core";
+import { getStartContext } from "@tanstack/start-storage-context";
+//#region src/renderServerComponent.ts
+/**
+* Renders a React element to an RSC Flight stream.
+*
+* Returns a "renderable proxy" that can be:
+* - Rendered directly as `{data}` in JSX
+* - Accessed for nested selections: `{data.foo.bar.Hello}`
+*
+* No slot support - for slots use `createCompositeComponent`.
+*
+* @example
+* ```tsx
+* // In a loader or server function
+* const data = await renderServerComponent(<MyServerComponent foo="bar" />)
+*
+* // In the route component
+* return (
+*   <div>
+*     {data}
+*     {data.sidebar.Menu}
+*   </div>
+* )
+* ```
+*/
+async function renderServerComponent(node) {
+	const flightStream = renderToReadableStream(node);
+	const isRouterRequest = getStartContext({ throwIfNotFound: false })?.handlerType === "router";
+	const ssrHandler = globalThis.__RSC_SSR__;
+	if (isRouterRequest && ssrHandler) {
+		const signal = getRequest().signal;
+		const stream = new ReplayableStream(flightStream, { signal });
+		const decoded = await ssrHandler.decode(stream);
+		return ssrHandler.createRenderableProxy(stream, decoded);
+	}
+	return createRenderableHandle(flightStream);
+}
+/**
+* Creates a renderable handle for server function responses.
+* Tagged with RENDERABLE_RSC for the serialization adapter.
+*/
+function createRenderableHandle(flightStream) {
+	const streamWrapper = { createReplayStream: () => flightStream };
+	const stub = function RenderableRscStub() {
+		throw new Error("Renderable RSC from server function cannot be rendered on server. It should be serialized and sent to the client.");
+	};
+	stub[SERVER_COMPONENT_STREAM] = streamWrapper;
+	stub[RENDERABLE_RSC] = true;
+	return stub;
+}
+//#endregion
+export { renderServerComponent };
+
+//# sourceMappingURL=renderServerComponent.js.map

package/dist/esm/renderServerComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderServerComponent.js","names":[],"sources":["../../src/renderServerComponent.ts"],"sourcesContent":["import { renderToReadableStream } from 'virtual:tanstack-rsc-runtime'\nimport { getRequest } from '@tanstack/start-server-core'\nimport { getStartContext } from '@tanstack/start-storage-context'\n\nimport { ReplayableStream } from './ReplayableStream'\nimport { RENDERABLE_RSC, SERVER_COMPONENT_STREAM } from './ServerComponentTypes'\nimport type {\n  AnyRenderableServerComponent,\n  RenderableServerComponentBuilder,\n  ServerComponentStream,\n  ValidateRenderableServerComponent,\n} from './ServerComponentTypes'\n\nimport './rscSsrHandler'\n// Import for global declaration side effect\nexport type { RscSsrHandler, RscDecodeResult } from './rscSsrHandler'\n\n/**\n * Renderable RSC handle type - used for serialization detection.\n */\n\n/**\n * Type guard for renderable RSC handle.\n */\nexport function isRenderableRscHandle(\n  value: unknown,\n): value is AnyRenderableServerComponent {\n  return (\n    typeof value === 'function' &&\n    SERVER_COMPONENT_STREAM in value &&\n    RENDERABLE_RSC in value &&\n    (value as any)[RENDERABLE_RSC] === true\n  )\n}\n\n/**\n * Renders a React element to an RSC Flight stream.\n *\n * Returns a \"renderable proxy\" that can be:\n * - Rendered directly as `{data}` in JSX\n * - Accessed for nested selections: `{data.foo.bar.Hello}`\n *\n * No slot support - for slots use `createCompositeComponent`.\n *\n * @example\n * ```tsx\n * // In a loader or server function\n * const data = await renderServerComponent(<MyServerComponent foo=\"bar\" />)\n *\n * // In the route component\n * return (\n *   <div>\n *     {data}\n *     {data.sidebar.Menu}\n *   </div>\n * )\n * ```\n */\nexport async function renderServerComponent<TNode>(\n  node: ValidateRenderableServerComponent<TNode>,\n): Promise<RenderableServerComponentBuilder<TNode>> {\n  // Render the element directly to a Flight stream\n  const flightStream = renderToReadableStream(node)\n\n  // Check if this is an SSR request (router) or a direct server function call\n  const ctx = getStartContext({ throwIfNotFound: false })\n  const isRouterRequest = ctx?.handlerType === 'router'\n  const ssrHandler = globalThis.__RSC_SSR__\n\n  // SSR path: buffer stream for replay, pre-decode for synchronous rendering\n  if (isRouterRequest && ssrHandler) {\n    const signal = getRequest().signal\n    const stream = new ReplayableStream(flightStream, { signal })\n\n    // Pre-decode during loader phase for synchronous SSR rendering\n    const decoded = await ssrHandler.decode(stream)\n    return ssrHandler.createRenderableProxy(\n      stream,\n      decoded,\n    ) as RenderableServerComponentBuilder<TNode>\n  }\n\n  // Server function call path: return a handle for serialization\n  return createRenderableHandle(\n    flightStream,\n  ) as unknown as RenderableServerComponentBuilder<TNode>\n}\n\n/**\n * Creates a renderable handle for server function responses.\n * Tagged with RENDERABLE_RSC for the serialization adapter.\n */\nfunction createRenderableHandle(\n  flightStream: ReadableStream<Uint8Array>,\n): AnyRenderableServerComponent {\n  const streamWrapper: ServerComponentStream = {\n    createReplayStream: () => flightStream,\n  }\n\n  const stub = function RenderableRscStub(): never {\n    throw new Error(\n      'Renderable RSC from server function cannot be rendered on server. ' +\n        'It should be serialized and sent to the client.',\n    )\n  }\n\n  ;(stub as any)[SERVER_COMPONENT_STREAM] = streamWrapper\n  ;(stub as any)[RENDERABLE_RSC] = true\n  return stub as unknown as AnyRenderableServerComponent\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,eAAsB,sBACpB,MACkD;CAElD,MAAM,eAAe,uBAAuB,KAAK;CAIjD,MAAM,kBADM,gBAAgB,EAAE,iBAAiB,OAAO,CAAC,EAC1B,gBAAgB;CAC7C,MAAM,aAAa,WAAW;AAG9B,KAAI,mBAAmB,YAAY;EACjC,MAAM,SAAS,YAAY,CAAC;EAC5B,MAAM,SAAS,IAAI,iBAAiB,cAAc,EAAE,QAAQ,CAAC;EAG7D,MAAM,UAAU,MAAM,WAAW,OAAO,OAAO;AAC/C,SAAO,WAAW,sBAChB,QACA,QACD;;AAIH,QAAO,uBACL,aACD;;;;;;AAOH,SAAS,uBACP,cAC8B;CAC9B,MAAM,gBAAuC,EAC3C,0BAA0B,cAC3B;CAED,MAAM,OAAO,SAAS,oBAA2B;AAC/C,QAAM,IAAI,MACR,oHAED;;AAGD,MAAa,2BAA2B;AACxC,MAAa,kBAAkB;AACjC,QAAO"}

package/dist/esm/renderServerComponent.stub.js

@@ -0,0 +1,16 @@
+//#region src/renderServerComponent.stub.ts
+/**
+* Client stub for renderServerComponent.
+*
+* This function should never be called at runtime on the client.
+* It exists only to satisfy bundler imports in client bundles.
+* The real implementation only runs inside server functions.
+*/
+function renderServerComponent(_node) {
+	if (process.env.NODE_ENV === "test") return Promise.resolve(null);
+	throw new Error("renderServerComponent cannot be called on the client. This function should only be called inside a server function or route loader.");
+}
+//#endregion
+export { renderServerComponent };
+
+//# sourceMappingURL=renderServerComponent.stub.js.map

package/dist/esm/renderServerComponent.stub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderServerComponent.stub.js","names":[],"sources":["../../src/renderServerComponent.stub.ts"],"sourcesContent":["import type {\n  RenderableServerComponentBuilder,\n  ValidateRenderableServerComponent,\n} from './ServerComponentTypes'\n\n/**\n * Client stub for renderServerComponent.\n *\n * This function should never be called at runtime on the client.\n * It exists only to satisfy bundler imports in client bundles.\n * The real implementation only runs inside server functions.\n */\nexport function renderServerComponent<TNode>(\n  _node: ValidateRenderableServerComponent<TNode>,\n): Promise<RenderableServerComponentBuilder<TNode>> {\n  // Unit/type tests import this stub directly and call it.\n  // Avoid throwing in that environment while keeping a hard runtime guard elsewhere.\n  if (process.env.NODE_ENV === 'test') {\n    return Promise.resolve(null as any)\n  }\n\n  throw new Error(\n    'renderServerComponent cannot be called on the client. ' +\n      'This function should only be called inside a server function or route loader.',\n  )\n}\n"],"mappings":";;;;;;;;AAYA,SAAgB,sBACd,OACkD;AAGlD,KAAA,QAAA,IAAA,aAA6B,OAC3B,QAAO,QAAQ,QAAQ,KAAY;AAGrC,OAAM,IAAI,MACR,sIAED"}

package/dist/esm/serialization.client.js

@@ -0,0 +1,21 @@
+import { createCompositeFromStream, createRenderableFromStream } from "./createServerComponentFromStream.js";
+import { createSerializationAdapter } from "@tanstack/react-router";
+import { setupRscHmr } from "virtual:tanstack-rsc-hmr";
+//#region src/serialization.client.ts
+if (process.env.NODE_ENV === "development") setupRscHmr();
+var adapter = createSerializationAdapter({
+	key: "$RSC",
+	test: (_value) => false,
+	toSerializable: () => {
+		throw new Error("RSC cannot be serialized on client");
+	},
+	fromSerializable: (value) => {
+		if (value.kind === "renderable") return createRenderableFromStream(value.stream);
+		return createCompositeFromStream(value.stream, { slotUsagesStream: value.slotUsagesStream });
+	}
+});
+var rscSerializationAdapter = () => [adapter];
+//#endregion
+export { rscSerializationAdapter };
+
+//# sourceMappingURL=serialization.client.js.map

package/dist/esm/serialization.client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.client.js","names":[],"sources":["../../src/serialization.client.ts"],"sourcesContent":["import { createSerializationAdapter } from '@tanstack/react-router'\n// RSC HMR setup (dev-only, provided by the active Start bundler adapter).\nimport { setupRscHmr } from 'virtual:tanstack-rsc-hmr'\nimport {\n  createCompositeFromStream,\n  createRenderableFromStream,\n} from './createServerComponentFromStream'\nimport type {\n  AnyCompositeComponent,\n  RscSlotUsageEvent,\n} from './ServerComponentTypes'\n\nif (process.env.NODE_ENV === 'development') {\n  setupRscHmr()\n}\n\n/**\n * Client-side serialization adapter for RSC (renderable + composite).\n */\ntype SerializedRsc = {\n  kind: 'renderable' | 'composite'\n  stream: ReadableStream<Uint8Array>\n  slotUsagesStream?: ReadableStream<RscSlotUsageEvent>\n}\n\nconst adapter = createSerializationAdapter({\n  key: '$RSC',\n  test: (_value: unknown): _value is never => false,\n  toSerializable: (): never => {\n    throw new Error('RSC cannot be serialized on client')\n  },\n  fromSerializable: (value: SerializedRsc): AnyCompositeComponent => {\n    if (value.kind === 'renderable') {\n      return createRenderableFromStream(value.stream)\n    }\n\n    return createCompositeFromStream(value.stream, {\n      slotUsagesStream: value.slotUsagesStream,\n    })\n  },\n})\n\nexport const rscSerializationAdapter = () => [adapter]\n"],"mappings":";;;;AAYA,IAAA,QAAA,IAAA,aAA6B,cAC3B,cAAa;AAYf,IAAM,UAAU,2BAA2B;CACzC,KAAK;CACL,OAAO,WAAqC;CAC5C,sBAA6B;AAC3B,QAAM,IAAI,MAAM,qCAAqC;;CAEvD,mBAAmB,UAAgD;AACjE,MAAI,MAAM,SAAS,aACjB,QAAO,2BAA2B,MAAM,OAAO;AAGjD,SAAO,0BAA0B,MAAM,QAAQ,EAC7C,kBAAkB,MAAM,kBACzB,CAAC;;CAEL,CAAC;AAEF,IAAa,gCAAgC,CAAC,QAAQ"}

package/dist/esm/serialization.server.js

@@ -0,0 +1,121 @@
+import { RENDERABLE_RSC, RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isServerComponent } from "./ServerComponentTypes.js";
+import { awaitLazyElements } from "./awaitLazyElements.js";
+import { createRscProxy } from "./createRscProxy.js";
+import { getStartContext } from "@tanstack/start-storage-context";
+import { createSerializationAdapter } from "@tanstack/react-router";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { RawStream } from "@tanstack/router-core";
+import { createFromReadableStream, setOnClientReference } from "virtual:tanstack-rsc-ssr-decode";
+//#region src/serialization.server.ts
+var decodeCollectorStorage = new AsyncLocalStorage();
+var jsCollectorStorage = new AsyncLocalStorage();
+setOnClientReference(({ deps, runtime }) => {
+	const ctx = getStartContext({ throwIfNotFound: false });
+	const cssCollector = decodeCollectorStorage.getStore();
+	if (cssCollector) for (const href of deps.css) cssCollector.add(href);
+	const jsCollector = jsCollectorStorage.getStore();
+	if (jsCollector) for (const href of deps.js) jsCollector.add(href);
+	if (!ctx || runtime === "rsbuild") return;
+	if (!ctx.requestAssets) ctx.requestAssets = [];
+	const seenHrefs = new Set(ctx.requestAssets.filter((a) => a.tag === "link" && a.attrs?.href).map((a) => a.attrs.href));
+	for (const href of deps.js) {
+		if (seenHrefs.has(href)) continue;
+		seenHrefs.add(href);
+		ctx.requestAssets.push({
+			tag: "link",
+			attrs: {
+				rel: "modulepreload",
+				href
+			}
+		});
+	}
+	for (const href of deps.css) {
+		if (seenHrefs.has(href)) continue;
+		seenHrefs.add(href);
+		ctx.requestAssets.push({
+			tag: "link",
+			attrs: {
+				rel: "preload",
+				href,
+				as: "style"
+			}
+		});
+	}
+});
+var ssrHandler = {
+	async decode(stream) {
+		const readableStream = stream.createReplayStream();
+		const cssCollector = /* @__PURE__ */ new Set();
+		const jsCollector = /* @__PURE__ */ new Set();
+		return decodeCollectorStorage.run(cssCollector, async () => {
+			return jsCollectorStorage.run(jsCollector, async () => {
+				const tree = await createFromReadableStream(readableStream);
+				await awaitLazyElements(tree, (href) => {
+					cssCollector.add(href);
+				});
+				return {
+					tree,
+					cssHrefs: cssCollector.size > 0 ? cssCollector : void 0,
+					jsPreloads: jsCollector.size > 0 ? jsCollector : void 0
+				};
+			});
+		});
+	},
+	createRenderableProxy(stream, decoded) {
+		return createRscProxy(() => decoded.tree, {
+			stream,
+			cssHrefs: decoded.cssHrefs,
+			jsPreloads: decoded.jsPreloads,
+			renderable: true
+		});
+	},
+	createCompositeProxy(stream, decoded, slotUsagesStream) {
+		return createRscProxy(() => decoded.tree, {
+			stream,
+			cssHrefs: decoded.cssHrefs,
+			jsPreloads: decoded.jsPreloads,
+			renderable: false,
+			slotUsagesStream
+		});
+	}
+};
+globalThis.__RSC_SSR__ = ssrHandler;
+/**
+* Helper to check if a value is a renderable RSC (from renderServerComponent).
+* The value can be either an object (proxy target) or a function (stub for server functions).
+*/
+function isRenderableRsc(value) {
+	if (value === null || value === void 0) return false;
+	if (typeof value !== "object" && typeof value !== "function") return false;
+	return RENDERABLE_RSC in value && value[RENDERABLE_RSC] === true;
+}
+/**
+* Server-side serialization adapter for RSC (renderable + composite).
+*/
+var adapter = createSerializationAdapter({
+	key: "$RSC",
+	test: (value) => {
+		return isServerComponent(value);
+	},
+	toSerializable: (component) => {
+		const stream = component[SERVER_COMPONENT_STREAM].createReplayStream();
+		const kind = isRenderableRsc(component) ? "renderable" : "composite";
+		const slotUsagesStream = kind === "composite" && process.env.NODE_ENV === "development" && RSC_SLOT_USAGES_STREAM in component ? component[RSC_SLOT_USAGES_STREAM] : void 0;
+		return {
+			kind,
+			stream: new RawStream(stream, { hint: "text" }),
+			slotUsagesStream
+		};
+	},
+	fromSerializable: () => {
+		throw new Error("Server should never deserialize RSC data");
+	}
+});
+/**
+* Factory function for server-side RSC serialization adapter.
+*/
+var rscSerializationAdapter = () => [adapter];
+//#endregion
+export { rscSerializationAdapter };
+
+//# sourceMappingURL=serialization.server.js.map

package/dist/esm/serialization.server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.server.js","names":[],"sources":["../../src/serialization.server.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport { createSerializationAdapter } from '@tanstack/react-router'\nimport { RawStream } from '@tanstack/router-core'\nimport { getStartContext } from '@tanstack/start-storage-context'\nimport {\n  setOnClientReference,\n  createFromReadableStream as ssrDecode,\n} from 'virtual:tanstack-rsc-ssr-decode'\nimport {\n  RENDERABLE_RSC,\n  RSC_SLOT_USAGES_STREAM,\n  SERVER_COMPONENT_STREAM,\n  isServerComponent,\n} from './ServerComponentTypes'\nimport { createRscProxy } from './createRscProxy'\nimport { awaitLazyElements } from './awaitLazyElements'\nimport type {\n  AnyCompositeComponent,\n  ServerComponentStream,\n} from './ServerComponentTypes'\nimport type { RscDecodeResult, RscSsrHandler } from './rscSsrHandler'\n\n// ===== SSR Handler Registration =====\n// This handler is registered on globalThis for the RSC environment to access.\n// The RSC env calls these functions during loader execution to pre-decode streams\n// and create renderable proxies.\n//\n// This MUST happen in a module without 'use client' directive.\n// Modules with 'use client' may be transformed to client references in the\n// SSR environment when RSC is enabled, preventing the side effect from running.\n\n// AsyncLocalStorage for decode-scoped CSS collector.\n// Each decode() runs in its own async context with its own collector.\n// The onClientReference callback reads from this to write CSS hrefs.\nconst decodeCollectorStorage = new AsyncLocalStorage<Set<string>>()\nconst jsCollectorStorage = new AsyncLocalStorage<Set<string>>()\n\nsetOnClientReference(\n  ({\n    deps,\n    runtime,\n  }: {\n    deps: { js: Array<string>; css: Array<string> }\n    runtime?: 'rsbuild'\n  }) => {\n    const ctx = getStartContext({ throwIfNotFound: false })\n\n    const cssCollector = decodeCollectorStorage.getStore()\n    if (cssCollector) {\n      for (const href of deps.css) {\n        cssCollector.add(href)\n      }\n    }\n\n    const jsCollector = jsCollectorStorage.getStore()\n    if (jsCollector) {\n      for (const href of deps.js) {\n        jsCollector.add(href)\n      }\n    }\n\n    if (!ctx || runtime === 'rsbuild') return\n\n    if (!ctx.requestAssets) ctx.requestAssets = []\n    const seenHrefs = new Set(\n      ctx.requestAssets\n        .filter((a) => a.tag === 'link' && a.attrs?.href)\n        .map((a) => a.attrs!.href as string),\n    )\n\n    for (const href of deps.js) {\n      if (seenHrefs.has(href)) continue\n      seenHrefs.add(href)\n      ctx.requestAssets.push({\n        tag: 'link',\n        attrs: { rel: 'modulepreload', href },\n      })\n    }\n\n    for (const href of deps.css) {\n      if (seenHrefs.has(href)) continue\n      seenHrefs.add(href)\n      ctx.requestAssets.push({\n        tag: 'link',\n        attrs: { rel: 'preload', href, as: 'style' },\n      })\n    }\n  },\n)\n\nconst ssrHandler: RscSsrHandler = {\n  async decode(stream: ServerComponentStream): Promise<RscDecodeResult> {\n    const readableStream = stream.createReplayStream()\n\n    // Create a collector for this decode operation.\n    // Run the decode in an AsyncLocalStorage context so the onClientReference\n    // callback can write to this specific collector even with parallel decodes.\n    const cssCollector = new Set<string>()\n    const jsCollector = new Set<string>()\n\n    return decodeCollectorStorage.run(cssCollector, async () => {\n      return jsCollectorStorage.run(jsCollector, async () => {\n        const tree = await ssrDecode(readableStream)\n        await awaitLazyElements(tree, (href) => {\n          cssCollector.add(href)\n        })\n\n        return {\n          tree,\n          cssHrefs: cssCollector.size > 0 ? cssCollector : undefined,\n          jsPreloads: jsCollector.size > 0 ? jsCollector : undefined,\n        }\n      })\n    })\n  },\n\n  createRenderableProxy(stream, decoded): any {\n    return createRscProxy(() => decoded.tree, {\n      stream,\n      cssHrefs: decoded.cssHrefs,\n      jsPreloads: decoded.jsPreloads,\n      renderable: true,\n    })\n  },\n\n  createCompositeProxy(\n    stream,\n    decoded,\n    slotUsagesStream,\n  ): AnyCompositeComponent {\n    const proxy = createRscProxy(() => decoded.tree, {\n      stream,\n      cssHrefs: decoded.cssHrefs,\n      jsPreloads: decoded.jsPreloads,\n      renderable: false,\n      slotUsagesStream,\n    })\n    return proxy\n  },\n}\n\n// Register SSR handler on globalThis for RSC environment to access.\nglobalThis.__RSC_SSR__ = ssrHandler\n\n// ===== End SSR Handler Registration =====\n\n/**\n * Helper to check if a value is a renderable RSC (from renderServerComponent).\n * The value can be either an object (proxy target) or a function (stub for server functions).\n */\nfunction 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\n/**\n * Server-side serialization adapter for RSC (renderable + composite).\n */\nconst adapter = createSerializationAdapter({\n  key: '$RSC',\n  test: (value: unknown): value is AnyCompositeComponent => {\n    return isServerComponent(value)\n  },\n  toSerializable: (component: AnyCompositeComponent) => {\n    const stream = component[SERVER_COMPONENT_STREAM]!.createReplayStream()\n\n    const kind = isRenderableRsc(component) ? 'renderable' : 'composite'\n\n    const slotUsagesStream =\n      kind === 'composite' &&\n      process.env.NODE_ENV === 'development' &&\n      RSC_SLOT_USAGES_STREAM in component\n        ? ((component as any)[RSC_SLOT_USAGES_STREAM] as unknown as\n            | ReadableStream<any>\n            | undefined)\n        : undefined\n\n    return {\n      kind,\n      stream: new RawStream(stream, { hint: 'text' }),\n      slotUsagesStream,\n    }\n  },\n  fromSerializable: (): never => {\n    throw new Error('Server should never deserialize RSC data')\n  },\n})\n\n/**\n * Factory function for server-side RSC serialization adapter.\n */\nexport const rscSerializationAdapter = () => [adapter]\n"],"mappings":"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"}

package/dist/esm/slotUsageSanitizer.js

@@ -0,0 +1,33 @@
+import { isValidElement } from "react";
+//#region src/slotUsageSanitizer.ts
+var REACT_ELEMENT_TYPE = Symbol.for("react.element");
+var REACT_TRANSITIONAL_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+var REACT_PORTAL_TYPE = Symbol.for("react.portal");
+function isReactElementLike(value) {
+	if (!value || typeof value !== "object" && typeof value !== "function") return false;
+	if (isValidElement(value)) return true;
+	const t = value.$$typeof;
+	return t === REACT_ELEMENT_TYPE || t === REACT_TRANSITIONAL_ELEMENT_TYPE || t === REACT_PORTAL_TYPE;
+}
+var REACT_ELEMENT_PLACEHOLDER = "React element";
+function sanitizeSlotArg(value, seen, depth) {
+	if (isReactElementLike(value)) return REACT_ELEMENT_PLACEHOLDER;
+	if (value === null || value === void 0) return value;
+	if (typeof value !== "object" && typeof value !== "function") return value;
+	if (Array.isArray(value)) return value.map((d) => sanitizeSlotArg(d, seen, depth + 1));
+	const proto = Object.getPrototypeOf(value);
+	if (proto === Object.prototype || proto === null) {
+		const out = {};
+		for (const [k, v] of Object.entries(value)) out[k] = sanitizeSlotArg(v, seen, depth + 1);
+		return out;
+	}
+	return value;
+}
+function sanitizeSlotArgs(args) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return args.map((d) => sanitizeSlotArg(d, seen, 0));
+}
+//#endregion
+export { sanitizeSlotArgs };
+
+//# sourceMappingURL=slotUsageSanitizer.js.map

package/dist/esm/slotUsageSanitizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotUsageSanitizer.js","names":[],"sources":["../../src/slotUsageSanitizer.ts"],"sourcesContent":["import { isValidElement } from 'react'\n\nconst REACT_ELEMENT_TYPE = Symbol.for('react.element')\nconst REACT_TRANSITIONAL_ELEMENT_TYPE = Symbol.for('react.transitional.element')\nconst REACT_PORTAL_TYPE = Symbol.for('react.portal')\n\nfunction isReactElementLike(value: unknown): boolean {\n  if (!value || (typeof value !== 'object' && typeof value !== 'function')) {\n    return false\n  }\n\n  // Prefer React's own check when available.\n  if (isValidElement(value)) return true\n\n  // Fallback: direct $$typeof detection (covers React 19 transitional elements).\n  const t = (value as any).$$typeof\n  return (\n    t === REACT_ELEMENT_TYPE ||\n    t === REACT_TRANSITIONAL_ELEMENT_TYPE ||\n    t === REACT_PORTAL_TYPE\n  )\n}\n\nconst REACT_ELEMENT_PLACEHOLDER = 'React element'\n\nfunction sanitizeSlotArg(\n  value: unknown,\n  seen: WeakSet<object>,\n  depth: number,\n): unknown {\n  if (isReactElementLike(value)) {\n    return REACT_ELEMENT_PLACEHOLDER\n  }\n\n  if (value === null || value === undefined) {\n    return value\n  }\n\n  if (typeof value !== 'object' && typeof value !== 'function') {\n    return value\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((d) => sanitizeSlotArg(d, seen, depth + 1))\n  }\n\n  const proto = Object.getPrototypeOf(value)\n  if (proto === Object.prototype || proto === null) {\n    const out: Record<string, unknown> = {}\n    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {\n      out[k] = sanitizeSlotArg(v, seen, depth + 1)\n    }\n    return out\n  }\n\n  return value\n}\n\nexport function sanitizeSlotArgs(args: Array<any>): Array<any> {\n  const seen = new WeakSet<object>()\n  return args.map((d) => sanitizeSlotArg(d, seen, 0))\n}\n"],"mappings":";;AAEA,IAAM,qBAAqB,OAAO,IAAI,gBAAgB;AACtD,IAAM,kCAAkC,OAAO,IAAI,6BAA6B;AAChF,IAAM,oBAAoB,OAAO,IAAI,eAAe;AAEpD,SAAS,mBAAmB,OAAyB;AACnD,KAAI,CAAC,SAAU,OAAO,UAAU,YAAY,OAAO,UAAU,WAC3D,QAAO;AAIT,KAAI,eAAe,MAAM,CAAE,QAAO;CAGlC,MAAM,IAAK,MAAc;AACzB,QACE,MAAM,sBACN,MAAM,mCACN,MAAM;;AAIV,IAAM,4BAA4B;AAElC,SAAS,gBACP,OACA,MACA,OACS;AACT,KAAI,mBAAmB,MAAM,CAC3B,QAAO;AAGT,KAAI,UAAU,QAAQ,UAAU,KAAA,EAC9B,QAAO;AAGT,KAAI,OAAO,UAAU,YAAY,OAAO,UAAU,WAChD,QAAO;AAGT,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,KAAK,MAAM,gBAAgB,GAAG,MAAM,QAAQ,EAAE,CAAC;CAG9D,MAAM,QAAQ,OAAO,eAAe,MAAM;AAC1C,KAAI,UAAU,OAAO,aAAa,UAAU,MAAM;EAChD,MAAM,MAA+B,EAAE;AACvC,OAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,MAAiC,CACnE,KAAI,KAAK,gBAAgB,GAAG,MAAM,QAAQ,EAAE;AAE9C,SAAO;;AAGT,QAAO;;AAGT,SAAgB,iBAAiB,MAA8B;CAC7D,MAAM,uBAAO,IAAI,SAAiB;AAClC,QAAO,KAAK,KAAK,MAAM,gBAAgB,GAAG,MAAM,EAAE,CAAC"}

package/dist/esm/src/ClientSlot.d.ts

@@ -0,0 +1,5 @@
+export interface ClientSlotProps {
+    slot: string;
+    args: Array<unknown>;
+}
+export declare function ClientSlot({ slot, args }: ClientSlotProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/esm/src/CompositeComponent.d.ts

@@ -0,0 +1,28 @@
+import { AnyCompositeComponent } from './ServerComponentTypes.js';
+/**
+ * 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>
+ * )
+ * ```
+ */
+export declare function CompositeComponent<TComp extends AnyCompositeComponent>(props: CompositeComponentProps<TComp>): TComp['~types']['return'];
+export type CompositeComponentProps<TComp extends AnyCompositeComponent> = {
+    src: TComp;
+} & TComp['~types']['props'];

package/dist/esm/src/ReplayableStream.d.ts

@@ -0,0 +1,76 @@
+/**
+ * ReplayableStream is used for React Server Components (RSC) / Flight streams.
+ *
+ * In this package the same Flight payload may need to be:
+ * - decoded for SSR (render path), and/or
+ * - serialized for transport to the client for client-side decoding.
+ *
+ * Call sites:
+ * - `src/createServerComponent.ts`: wraps the produced Flight stream once.
+ * - `src/serialization.ts`: uses `createReplayStream()` to transport a fresh stream
+ *   to the client via `RawStream`.
+ *
+ * Constraints:
+ * - Consumption order isn't fixed: SSR decode might start first or transport might
+ *   start first depending on the request path.
+ * - Sometimes only one happens (e.g. when client calls server function directly).
+ *
+ * Why not just `ReadableStream.tee()`?
+ * - tee() must be called up-front before the stream is consumed/locked and only
+ *   creates two live branches (no late "replay from byte 0").
+ * - If one branch is slower or never consumed, the runtime may buffer internally
+ *   to keep branches consistent, which can retain large Flight payloads longer
+ *   than intended and makes cleanup less explicit.
+ *
+ * ReplayableStream reads once, buffers explicitly, can mint replay streams on
+ * demand, and centralizes cancellation so aborting can stop upstream work and
+ * free buffered data deterministically.
+ *
+ * Memory Management:
+ * - Memory is released when the abort signal fires (request cancelled)
+ * - Call `release()` to force immediate cleanup if no more replays are needed
+ * - No automatic release: replays can be created at unpredictable times (SSR decode
+ *   finishes before serialization starts), so we can't safely auto-release
+ */
+export interface ReplayableStreamOptions {
+    signal?: AbortSignal;
+}
+export declare const REPLAYABLE_STREAM_MARKER: unique symbol;
+export declare class ReplayableStream<T = Uint8Array> {
+    private source;
+    private options;
+    readonly [REPLAYABLE_STREAM_MARKER] = true;
+    private chunks;
+    private done;
+    private error;
+    private waiter;
+    private aborted;
+    private released;
+    private sourceReader;
+    private abortSignal;
+    private abortListener;
+    constructor(source: ReadableStream<T>, options?: ReplayableStreamOptions);
+    private start;
+    private detachAbortListener;
+    private cancelSource;
+    private handleAbort;
+    private notify;
+    private wait;
+    /**
+     * 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(): void;
+    /**
+     * Check if the stream data has been released
+     */
+    isReleased(): boolean;
+    /**
+     * 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(): ReadableStream<T>;
+}

package/dist/esm/src/RscNodeRenderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Renders a renderable RSC proxy without slot support.
+ * Used internally by the renderable proxy's $$typeof/type masquerade.
+ */
+export declare function RscNodeRenderer({ data }: {
+    data: any;
+}): React.ReactNode;