@tanstack/react-start-rsc 0.0.0

package/dist/esm/createCompositeComponent.js

@@ -0,0 +1,205 @@
+import { RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM } from "./ServerComponentTypes.js";
+import { ReplayableStream } from "./ReplayableStream.js";
+import { sanitizeSlotArgs } from "./slotUsageSanitizer.js";
+import { ClientSlot } from "./ClientSlot.js";
+import { createElement } from "react";
+import { renderToReadableStream } from "virtual:tanstack-rsc-runtime";
+import { getRequest } from "@tanstack/start-server-core";
+import { getStartContext } from "@tanstack/start-storage-context";
+//#region src/createCompositeComponent.ts
+/**
+* Creates a composite server component with slot support.
+*
+* Supports returning:
+* - A ReactNode directly
+* - An object structure with ReactNodes: accessed as `src.Foo`
+* - Nested structures: accessed as `src.x.Bar`
+*
+* Props that are functions become slots - they render as ClientSlot placeholders
+* in the RSC output, filled in by the consumer with actual implementations.
+*
+* The returned value is NOT directly renderable. Use `<CompositeComponent src={...} />`.
+*
+* @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>
+* )
+* ```
+*/
+async function createCompositeComponent(component) {
+	const isDev = process.env.NODE_ENV === "development";
+	const slotUsagesEmitter = isDev ? createReadableStreamEmitter() : null;
+	const { proxy: proxyProps } = createSlotProxy({ onSlotCall: slotUsagesEmitter ? (name, args) => {
+		const sanitizedArgs = sanitizeSlotArgs(args);
+		slotUsagesEmitter.emit({
+			slot: name,
+			args: sanitizedArgs.length ? sanitizedArgs : void 0
+		});
+	} : void 0 });
+	async function ServerComponentWrapper() {
+		return component(proxyProps);
+	}
+	const flightStream = renderToReadableStream(createElement(ServerComponentWrapper));
+	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);
+		slotUsagesEmitter?.close();
+		return ssrHandler.createCompositeProxy(stream, decoded, slotUsagesEmitter?.stream);
+	}
+	return createCompositeHandle(isDev && slotUsagesEmitter ? wrapReadableStream(flightStream, {
+		onDone: () => {
+			slotUsagesEmitter.close();
+		},
+		onCancel: () => {
+			slotUsagesEmitter.close();
+		},
+		onError: () => {
+			slotUsagesEmitter.close();
+		}
+	}) : flightStream, { slotUsagesStream: slotUsagesEmitter?.stream });
+}
+/**
+* Creates a composite handle for server function responses.
+* No proxy needed - the client will decode and create its own proxy.
+*/
+function createCompositeHandle(flightStream, options) {
+	const streamWrapper = { createReplayStream: () => flightStream };
+	const stub = function CompositeComponentStub() {
+		throw new Error("CompositeComponent from server function cannot be rendered on server. It should be serialized and sent to the client.");
+	};
+	stub[SERVER_COMPONENT_STREAM] = streamWrapper;
+	if (options?.slotUsagesStream) stub[RSC_SLOT_USAGES_STREAM] = options.slotUsagesStream;
+	return stub;
+}
+/**
+* Proxy that turns property access into ClientSlot renders.
+* Also tracks accessed slot names for devtools.
+*/
+function createSlotProxy(options) {
+	const cache = /* @__PURE__ */ new Map();
+	return { proxy: new Proxy({}, { get(_target, prop) {
+		if (prop === "then" || typeof prop !== "string") return void 0;
+		if (prop === "children") {
+			options?.onSlotCall?.("children", []);
+			return createElement(ClientSlot, {
+				slot: "children",
+				args: []
+			});
+		}
+		let fn = cache.get(prop);
+		if (!fn) {
+			fn = (...args) => {
+				options?.onSlotCall?.(prop, args);
+				return createElement(ClientSlot, {
+					slot: prop,
+					args
+				});
+			};
+			cache.set(prop, fn);
+		}
+		return fn;
+	} }) };
+}
+function createReadableStreamEmitter() {
+	let closed = false;
+	const queue = [];
+	let controller = null;
+	const stream = new ReadableStream({
+		start(ctrl) {
+			controller = ctrl;
+			for (const value of queue) try {
+				ctrl.enqueue(value);
+			} catch {}
+			queue.length = 0;
+			if (closed) try {
+				ctrl.close();
+			} catch {}
+		},
+		cancel() {
+			closed = true;
+			controller = null;
+			queue.length = 0;
+		}
+	});
+	const emit = (value) => {
+		if (closed) return;
+		if (!controller) {
+			queue.push(value);
+			return;
+		}
+		try {
+			controller.enqueue(value);
+		} catch {}
+	};
+	const close = () => {
+		if (closed) return;
+		closed = true;
+		if (controller) {
+			try {
+				controller.close();
+			} catch {}
+			controller = null;
+		}
+	};
+	return {
+		stream,
+		emit,
+		close
+	};
+}
+function wrapReadableStream(source, handlers) {
+	const reader = source.getReader();
+	let finished = false;
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		handlers.onDone?.();
+		try {
+			reader.releaseLock();
+		} catch {}
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { value, done } = await reader.read();
+				if (done) {
+					controller.close();
+					finish();
+					return;
+				}
+				controller.enqueue(value);
+			} catch (err) {
+				try {
+					controller.error(err);
+				} catch {}
+				handlers.onError?.();
+				finish();
+			}
+		},
+		async cancel(reason) {
+			handlers.onCancel?.();
+			try {
+				await reader.cancel(reason);
+			} catch {}
+			finish();
+		}
+	});
+}
+//#endregion
+export { createCompositeComponent };
+
+//# sourceMappingURL=createCompositeComponent.js.map

package/dist/esm/createCompositeComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCompositeComponent.js","names":[],"sources":["../../src/createCompositeComponent.ts"],"sourcesContent":["import { createElement } from 'react'\nimport { renderToReadableStream } from 'virtual:tanstack-rsc-runtime'\nimport { getRequest } from '@tanstack/start-server-core'\nimport { getStartContext } from '@tanstack/start-storage-context'\nimport { sanitizeSlotArgs } from './slotUsageSanitizer'\n\nimport { ReplayableStream } from './ReplayableStream'\nimport { ClientSlot } from './ClientSlot'\nimport {\n  RSC_SLOT_USAGES_STREAM,\n  SERVER_COMPONENT_STREAM,\n} from './ServerComponentTypes'\nimport type {\n  AnyCompositeComponent,\n  CompositeComponentResult,\n  RscSlotUsageEvent,\n  ServerComponentStream,\n  ValidateCompositeComponent,\n} from './ServerComponentTypes'\n\nimport './rscSsrHandler' // Import for global declaration side effect\n\n/**\n * Creates a composite server component with slot support.\n *\n * Supports returning:\n * - A ReactNode directly\n * - An object structure with ReactNodes: accessed as `src.Foo`\n * - Nested structures: accessed as `src.x.Bar`\n *\n * Props that are functions become slots - they render as ClientSlot placeholders\n * in the RSC output, filled in by the consumer with actual implementations.\n *\n * The returned value is NOT directly renderable. Use `<CompositeComponent src={...} />`.\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 async function createCompositeComponent<TComp>(\n  component: ValidateCompositeComponent<TComp>,\n): Promise<CompositeComponentResult<TComp>> {\n  const isDev = process.env.NODE_ENV === 'development'\n\n  // Dev-only: stream slot usage events (slot + raw args)\n  const slotUsagesEmitter = isDev\n    ? createReadableStreamEmitter<RscSlotUsageEvent>()\n    : null\n\n  // Create a wrapper component that will be rendered inside React's Flight context.\n  // This ensures React.cache works properly since the component is called during\n  // renderToReadableStream's render phase, not before it.\n  const { proxy: proxyProps } = createSlotProxy<{}>({\n    onSlotCall: slotUsagesEmitter\n      ? (name, args) => {\n          const sanitizedArgs = sanitizeSlotArgs(args)\n          slotUsagesEmitter.emit({\n            slot: name,\n            args: sanitizedArgs.length ? sanitizedArgs : undefined,\n          })\n        }\n      : undefined,\n  })\n\n  // Wrapper that renders the user's component inside Flight render context\n  async function ServerComponentWrapper() {\n    return (component as React.FC)(proxyProps)\n  }\n\n  // Render using createElement so React calls our component during Flight rendering\n  // This is critical for React.cache to work - the component must be invoked\n  // during renderToReadableStream's execution, not before\n  const flightStream = renderToReadableStream(\n    createElement(ServerComponentWrapper),\n  )\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\n    // For SSR we know decode fully consumed the Flight stream.\n    slotUsagesEmitter?.close()\n\n    const proxy = ssrHandler.createCompositeProxy(\n      stream,\n      decoded,\n      slotUsagesEmitter?.stream,\n    )\n    return proxy as CompositeComponentResult<TComp>\n  }\n\n  // Server function call path:\n  // The serialization adapter will stream to the client.\n  const monitoredFlightStream =\n    isDev && slotUsagesEmitter\n      ? wrapReadableStream(flightStream, {\n          onDone: () => {\n            slotUsagesEmitter.close()\n          },\n          onCancel: () => {\n            slotUsagesEmitter.close()\n          },\n          onError: () => {\n            slotUsagesEmitter.close()\n          },\n        })\n      : flightStream\n\n  return createCompositeHandle(monitoredFlightStream, {\n    slotUsagesStream: slotUsagesEmitter?.stream,\n  }) as CompositeComponentResult<TComp>\n}\n\n/**\n * Creates a composite handle for server function responses.\n * No proxy needed - the client will decode and create its own proxy.\n */\nfunction createCompositeHandle(\n  flightStream: ReadableStream<Uint8Array>,\n  options?: {\n    slotUsagesStream?: ReadableStream<RscSlotUsageEvent>\n  },\n): AnyCompositeComponent {\n  // Simple single-use stream wrapper. For server function calls, the stream\n  // is consumed exactly once by the serialization adapter for transport.\n  const streamWrapper: ServerComponentStream = {\n    createReplayStream: () => flightStream,\n  }\n\n  // Create a stub function with the stream attached for serialization.\n  // This will never be rendered directly - it goes through serialization\n  // which extracts the stream and sends it to the client.\n  const stub = function CompositeComponentStub(): never {\n    throw new Error(\n      'CompositeComponent 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  // Note: RENDERABLE_RSC is not set (or implicitly false), indicating this is a composite component\n\n  if (options?.slotUsagesStream) {\n    ;(stub as any)[RSC_SLOT_USAGES_STREAM] = options.slotUsagesStream\n  }\n\n  return stub as unknown as AnyCompositeComponent\n}\n\n/**\n * Base slot props type - functions that become ClientSlot placeholders\n */\ninterface SlotPropsBase {\n  [key: string]:\n    | ((...args: Array<any>) => React.ReactNode)\n    | React.ReactNode\n    | undefined\n  children?: React.ReactNode\n}\n\ninterface SlotProxyResult<TSlotProps extends object> {\n  proxy: TSlotProps & SlotPropsBase\n}\n\n/**\n * Proxy that turns property access into ClientSlot renders.\n * Also tracks accessed slot names for devtools.\n */\nfunction createSlotProxy<TSlotProps extends object>(options?: {\n  onSlotCall?: (name: string, args: Array<any>) => void\n}): SlotProxyResult<TSlotProps> {\n  const cache = new Map<string, (...args: Array<any>) => React.ReactNode>()\n\n  const proxy = new Proxy({} as TSlotProps & SlotPropsBase, {\n    get(_target, prop) {\n      if (prop === 'then' || typeof prop !== 'string') return undefined\n\n      if (prop === 'children') {\n        options?.onSlotCall?.('children', [])\n        return createElement(ClientSlot, { slot: 'children', args: [] })\n      }\n\n      let fn = cache.get(prop)\n      if (!fn) {\n        fn = (...args: Array<any>) => {\n          options?.onSlotCall?.(prop, args)\n          return createElement(ClientSlot, { slot: prop, args })\n        }\n        cache.set(prop, fn)\n      }\n      return fn\n    },\n  })\n\n  return {\n    proxy,\n  }\n}\n\nfunction createReadableStreamEmitter<T>(): {\n  stream: ReadableStream<T>\n  emit: (value: T) => void\n  close: () => void\n} {\n  let closed = false\n  const queue: Array<T> = []\n  let controller: ReadableStreamDefaultController<T> | null = null\n\n  const stream = new ReadableStream<T>({\n    start(ctrl) {\n      controller = ctrl\n      for (const value of queue) {\n        try {\n          ctrl.enqueue(value)\n        } catch {\n          // Ignore\n        }\n      }\n      queue.length = 0\n      if (closed) {\n        try {\n          ctrl.close()\n        } catch {\n          // Ignore\n        }\n      }\n    },\n    cancel() {\n      closed = true\n      controller = null\n      queue.length = 0\n    },\n  })\n\n  const emit = (value: T) => {\n    if (closed) return\n    if (!controller) {\n      queue.push(value)\n      return\n    }\n    try {\n      controller.enqueue(value)\n    } catch {\n      // Ignore\n    }\n  }\n\n  const close = () => {\n    if (closed) return\n    closed = true\n    if (controller) {\n      try {\n        controller.close()\n      } catch {\n        // Ignore\n      }\n      controller = null\n    }\n  }\n\n  return { stream, emit, close }\n}\n\nfunction wrapReadableStream<T>(\n  source: ReadableStream<T>,\n  handlers: {\n    onDone?: () => void\n    onCancel?: () => void\n    onError?: () => void\n  },\n): ReadableStream<T> {\n  const reader = source.getReader()\n  let finished = false\n\n  const finish = () => {\n    if (finished) return\n    finished = true\n    handlers.onDone?.()\n    try {\n      reader.releaseLock()\n    } catch {\n      // Ignore\n    }\n  }\n\n  return new ReadableStream<T>({\n    async pull(controller) {\n      try {\n        const { value, done } = await reader.read()\n        if (done) {\n          controller.close()\n          finish()\n          return\n        }\n        controller.enqueue(value)\n      } catch (err) {\n        try {\n          controller.error(err)\n        } catch {\n          // Ignore\n        }\n        handlers.onError?.()\n        finish()\n      }\n    },\n    async cancel(reason) {\n      handlers.onCancel?.()\n      try {\n        await reader.cancel(reason)\n      } catch {\n        // Ignore\n      }\n      finish()\n    },\n  })\n}\n"],"mappings":"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"}

package/dist/esm/createCompositeComponent.stub.js

@@ -0,0 +1,15 @@
+//#region src/createCompositeComponent.stub.ts
+/**
+* Client stub for createCompositeComponent.
+*
+* 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 createCompositeComponent(_component) {
+	throw new Error("createCompositeComponent cannot be called on the client. This function should only be called inside a server function or route loader.");
+}
+//#endregion
+export { createCompositeComponent };
+
+//# sourceMappingURL=createCompositeComponent.stub.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createCompositeComponent.stub.js","names":[],"sources":["../../src/createCompositeComponent.stub.ts"],"sourcesContent":["import type {\n  CompositeComponentResult,\n  ValidateCompositeComponent,\n} from './ServerComponentTypes'\n\n/**\n * Client stub for createCompositeComponent.\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 createCompositeComponent<TComp>(\n  _component: ValidateCompositeComponent<TComp>,\n): Promise<CompositeComponentResult<TComp>> {\n  throw new Error(\n    'createCompositeComponent 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,yBACd,YAC0C;AAC1C,OAAM,IAAI,MACR,yIAED"}

package/dist/esm/createRscProxy.js

@@ -0,0 +1,138 @@
+"use client";
+import { 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 } from "./ServerComponentTypes.js";
+import { RscNodeRenderer } from "./RscNodeRenderer.js";
+import { createElement } from "react";
+//#region src/createRscProxy.tsx
+/**
+* Creates a recursive Proxy for RSC data.
+*
+* If `renderable: true`, returns a React element that can be rendered as `{data}`.
+* The element also has proxy-like behavior for nested access like `data.foo.bar`.
+*
+* If `renderable: false` (default), the proxy is NOT directly renderable and
+* must be used with `<CompositeComponent src={...} />`.
+*/
+function createRscProxy(getTree, options = {}) {
+	if (options.renderable) return createRenderableElement(getTree, [], options.stream, options.cssHrefs, options.jsPreloads);
+	let slotUsages = void 0;
+	if (process.env.NODE_ENV === "development" && typeof window !== "undefined" && options.slotUsagesStream) {
+		slotUsages = [];
+		consumeSlotUsages(options.slotUsagesStream, slotUsages);
+	}
+	return createRscProxyWithPath(getTree, [], options.stream, options.cssHrefs, options.jsPreloads, slotUsages, options.slotUsagesStream);
+}
+var UNHANDLED = Symbol("tanstack.rsc.proxy.unhandled");
+function handleProxyTrap(kind, prop, options) {
+	switch (prop) {
+		case "__SEROVAL_STREAM__":
+		case "__SEROVAL_SEQUENCE__": return kind === "get" ? void 0 : false;
+		case Symbol.iterator:
+		case Symbol.asyncIterator: return kind === "get" ? void 0 : false;
+		case SERVER_COMPONENT_STREAM: return kind === "get" ? options.stream : options.stream !== void 0;
+		case SERVER_COMPONENT_CSS_HREFS: return kind === "get" ? options.cssHrefs : options.cssHrefs !== void 0;
+		case SERVER_COMPONENT_JS_PRELOADS: return kind === "get" ? options.jsPreloads : options.jsPreloads !== void 0;
+		case RSC_PROXY_GET_TREE: return kind === "get" ? options.getTree : true;
+		case RSC_PROXY_PATH: return kind === "get" ? options.path : true;
+		case RENDERABLE_RSC: return kind === "get" ? options.renderable : true;
+		case RSC_SLOT_USAGES: return kind === "get" ? options.slotUsages : options.slotUsages !== void 0;
+		case RSC_SLOT_USAGES_STREAM: return kind === "get" ? options.slotUsagesStream : options.slotUsagesStream !== void 0;
+		case "then": return kind === "get" ? void 0 : UNHANDLED;
+		case "toString": return kind === "get" ? Object.prototype.toString : UNHANDLED;
+		case "valueOf": return kind === "get" ? Object.prototype.valueOf : UNHANDLED;
+		case "constructor": return kind === "get" ? Object : UNHANDLED;
+	}
+	if (typeof prop === "symbol") return kind === "get" ? void 0 : false;
+	return UNHANDLED;
+}
+function createRscProxyInternal(options) {
+	const childCache = /* @__PURE__ */ new Map();
+	const getChild = (key) => {
+		const cached = childCache.get(key);
+		if (cached) return cached;
+		const next = createRscProxyInternal({
+			...options,
+			path: [...options.path, key]
+		});
+		childCache.set(key, next);
+		return next;
+	};
+	const dataProxy = options.renderable ? createRscProxyInternal({
+		...options,
+		renderable: false
+	}) : void 0;
+	const proxyTarget = options.renderable ? createElement(RscNodeRenderer, { data: dataProxy }) : {};
+	return new Proxy(proxyTarget, {
+		get(target, prop) {
+			const handled = handleProxyTrap("get", prop, options);
+			if (handled !== UNHANDLED) return handled;
+			if (options.renderable) {
+				if (prop === "props") return target.props;
+				if (prop === "data") return dataProxy;
+				if (prop in target) return target[prop];
+			}
+			return getChild(String(prop));
+		},
+		has(target, prop) {
+			const handled = handleProxyTrap("has", prop, options);
+			if (handled !== UNHANDLED) return handled;
+			if (options.renderable) {
+				if (prop in target) return true;
+				if (typeof prop === "string") return true;
+				return false;
+			}
+			return true;
+		},
+		getPrototypeOf(target) {
+			return options.renderable ? Object.getPrototypeOf(target) : Object.prototype;
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			return options.renderable ? Object.getOwnPropertyDescriptor(target, prop) : void 0;
+		},
+		ownKeys(target) {
+			return options.renderable ? Reflect.ownKeys(target) : [];
+		}
+	});
+}
+/**
+* Creates a React element that's also a Proxy for nested access.
+* This is used by renderable RSCs so they work as both {data} and {data.foo.bar}.
+*/
+function createRenderableElement(getTree, path, stream, cssHrefs, jsPreloads) {
+	return createRscProxyInternal({
+		getTree,
+		path,
+		stream,
+		cssHrefs,
+		jsPreloads,
+		renderable: true,
+		slotUsages: void 0,
+		slotUsagesStream: void 0
+	});
+}
+function createRscProxyWithPath(getTree, path, stream, cssHrefs, jsPreloads, slotUsages, slotUsagesStream) {
+	return createRscProxyInternal({
+		getTree,
+		path,
+		stream,
+		cssHrefs,
+		jsPreloads,
+		renderable: false,
+		slotUsages,
+		slotUsagesStream
+	});
+}
+async function consumeSlotUsages(stream, slotUsages) {
+	try {
+		const reader = stream.getReader();
+		for (;;) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			if (!value.slot) continue;
+			slotUsages.push(value);
+		}
+	} catch {}
+}
+//#endregion
+export { createRscProxy };
+
+//# sourceMappingURL=createRscProxy.js.map

package/dist/esm/createRscProxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRscProxy.js","names":[],"sources":["../../src/createRscProxy.tsx"],"sourcesContent":["'use client'\n\nimport { createElement } from 'react'\nimport { RscNodeRenderer } from './RscNodeRenderer'\nimport {\n  RENDERABLE_RSC,\n  RSC_PROXY_GET_TREE,\n  RSC_PROXY_PATH,\n  RSC_SLOT_USAGES,\n  RSC_SLOT_USAGES_STREAM,\n  SERVER_COMPONENT_CSS_HREFS,\n  SERVER_COMPONENT_JS_PRELOADS,\n  SERVER_COMPONENT_STREAM,\n} from './ServerComponentTypes'\nimport type { RscSlotUsageEvent } from './ServerComponentTypes'\n\nexport interface RscProxyOptions {\n  stream?: unknown // The stream to attach for serialization\n  cssHrefs?: ReadonlySet<string> // CSS hrefs collected from the RSC stream\n  jsPreloads?: ReadonlySet<string> // JS hrefs collected from the RSC stream\n  renderable?: boolean // If true, proxy masquerades as React element\n  slotUsagesStream?: ReadableStream<RscSlotUsageEvent> // Dev only: slot usage event stream\n}\n\n/**\n * Creates a recursive Proxy for RSC data.\n *\n * If `renderable: true`, returns a React element that can be rendered as `{data}`.\n * The element also has proxy-like behavior for nested access like `data.foo.bar`.\n *\n * If `renderable: false` (default), the proxy is NOT directly renderable and\n * must be used with `<CompositeComponent src={...} />`.\n */\nexport function createRscProxy<T>(\n  getTree: () => T,\n  options: RscProxyOptions = {},\n): any {\n  if (options.renderable) {\n    // For renderable mode, create a real React element with proxy access\n    return createRenderableElement(\n      getTree,\n      [],\n      options.stream,\n      options.cssHrefs,\n      options.jsPreloads,\n    )\n  }\n  let slotUsages: Array<RscSlotUsageEvent> | undefined = undefined\n\n  if (\n    process.env.NODE_ENV === 'development' &&\n    typeof window !== 'undefined' &&\n    options.slotUsagesStream\n  ) {\n    slotUsages = []\n    void consumeSlotUsages(options.slotUsagesStream, slotUsages)\n  }\n\n  // Non-renderable mode: plain proxy\n  return createRscProxyWithPath(\n    getTree,\n    [],\n    options.stream,\n    options.cssHrefs,\n    options.jsPreloads,\n    slotUsages,\n    options.slotUsagesStream,\n  )\n}\n\n/**\n * Creates a React element that's also a Proxy for nested access.\n * This is used by renderable RSCs so they work as both {data} and {data.foo.bar}.\n */\ntype CreateProxyOptions = {\n  getTree: () => unknown\n  path: Array<string>\n  stream: unknown | undefined\n  cssHrefs: ReadonlySet<string> | undefined\n  jsPreloads: ReadonlySet<string> | undefined\n  renderable: boolean\n  slotUsages: Array<RscSlotUsageEvent> | undefined\n  slotUsagesStream: ReadableStream<RscSlotUsageEvent> | undefined\n}\n\nconst UNHANDLED = Symbol('tanstack.rsc.proxy.unhandled')\n\nfunction handleProxyTrap(\n  kind: 'get' | 'has',\n  prop: PropertyKey,\n  options: CreateProxyOptions,\n): unknown | boolean | typeof UNHANDLED {\n  switch (prop) {\n    // Seroval (>=1.5) uses string sentinels and `in` checks for internal types.\n    // These proxies must never look like streams/sequences.\n    case '__SEROVAL_STREAM__':\n    case '__SEROVAL_SEQUENCE__':\n      return kind === 'get' ? undefined : false\n\n    // Seroval >=1.5 also checks iterability via `Symbol.iterator in value`.\n    case Symbol.iterator:\n    case Symbol.asyncIterator:\n      return kind === 'get' ? undefined : false\n\n    // Our proxy branding/properties\n    case SERVER_COMPONENT_STREAM:\n      return kind === 'get' ? options.stream : options.stream !== undefined\n    case SERVER_COMPONENT_CSS_HREFS:\n      return kind === 'get' ? options.cssHrefs : options.cssHrefs !== undefined\n    case SERVER_COMPONENT_JS_PRELOADS:\n      return kind === 'get'\n        ? options.jsPreloads\n        : options.jsPreloads !== undefined\n    case RSC_PROXY_GET_TREE:\n      return kind === 'get' ? options.getTree : true\n    case RSC_PROXY_PATH:\n      return kind === 'get' ? options.path : true\n    case RENDERABLE_RSC:\n      return kind === 'get' ? options.renderable : true\n    case RSC_SLOT_USAGES:\n      return kind === 'get'\n        ? options.slotUsages\n        : options.slotUsages !== undefined\n\n    case RSC_SLOT_USAGES_STREAM:\n      return kind === 'get'\n        ? options.slotUsagesStream\n        : options.slotUsagesStream !== undefined\n\n    // Avoid promise-like checks\n    case 'then':\n      return kind === 'get' ? undefined : UNHANDLED\n\n    // Avoid breaking primitive coercion (eg String(proxy)).\n    // Without these, nested-selection proxies can shadow these keys and\n    // cause `Cannot convert object to primitive value` errors.\n    case 'toString':\n      return kind === 'get' ? Object.prototype.toString : UNHANDLED\n    case 'valueOf':\n      return kind === 'get' ? Object.prototype.valueOf : UNHANDLED\n    case 'constructor':\n      return kind === 'get' ? Object : UNHANDLED\n  }\n\n  // Non-renderable proxies claim all string keys exist for nested selection,\n  // but symbol presence checks should be accurate.\n  if (typeof prop === 'symbol') {\n    return kind === 'get' ? undefined : false\n  }\n\n  return UNHANDLED\n}\n\nfunction createRscProxyInternal(options: CreateProxyOptions): any {\n  // Per-proxy cache so repeated property access is referentially stable.\n  const childCache = new Map<string, any>()\n\n  const getChild = (key: string) => {\n    const cached = childCache.get(key)\n    if (cached) return cached\n\n    const next = createRscProxyInternal({\n      ...options,\n      path: [...options.path, key],\n    })\n    childCache.set(key, next)\n    return next\n  }\n\n  const dataProxy = options.renderable\n    ? createRscProxyInternal({ ...options, renderable: false })\n    : undefined\n\n  // Use a React element (renderable) or plain object (non-renderable) as Proxy target.\n  const proxyTarget = options.renderable\n    ? createElement(RscNodeRenderer, { data: dataProxy })\n    : ({} as any)\n\n  return new Proxy(proxyTarget, {\n    get(target, prop) {\n      const handled = handleProxyTrap('get', prop, options)\n      if (handled !== UNHANDLED) return handled\n\n      if (options.renderable) {\n        // Proxy invariants: if target has a non-configurable, read-only property,\n        // we must return the *exact* value for that property.\n        if (prop === 'props') {\n          return target.props\n        }\n\n        if (prop === 'data') {\n          return dataProxy\n        }\n\n        if (prop in target) {\n          return target[prop]\n        }\n      }\n\n      return getChild(String(prop))\n    },\n\n    has(target, prop) {\n      const handled = handleProxyTrap('has', prop, options)\n      if (handled !== UNHANDLED) return handled as boolean\n\n      if (options.renderable) {\n        if (prop in target) return true\n        if (typeof prop === 'string') return true\n        return false\n      }\n\n      // Allow any property access for nested selection.\n      return true\n    },\n\n    getPrototypeOf(target) {\n      return options.renderable\n        ? Object.getPrototypeOf(target)\n        : Object.prototype\n    },\n\n    getOwnPropertyDescriptor(target, prop) {\n      return options.renderable\n        ? Object.getOwnPropertyDescriptor(target, prop)\n        : undefined\n    },\n\n    ownKeys(target) {\n      return options.renderable ? Reflect.ownKeys(target) : []\n    },\n  })\n}\n\n/**\n * Creates a React element that's also a Proxy for nested access.\n * This is used by renderable RSCs so they work as both {data} and {data.foo.bar}.\n */\nfunction createRenderableElement(\n  getTree: () => unknown,\n  path: Array<string>,\n  stream: unknown | undefined,\n  cssHrefs: ReadonlySet<string> | undefined,\n  jsPreloads: ReadonlySet<string> | undefined,\n): any {\n  return createRscProxyInternal({\n    getTree,\n    path,\n    stream,\n    cssHrefs,\n    jsPreloads,\n    renderable: true,\n    slotUsages: undefined,\n    slotUsagesStream: undefined,\n  })\n}\n\nfunction createRscProxyWithPath(\n  getTree: () => unknown,\n  path: Array<string>,\n  stream: unknown | undefined,\n  cssHrefs: ReadonlySet<string> | undefined,\n  jsPreloads: ReadonlySet<string> | undefined,\n  slotUsages: Array<RscSlotUsageEvent> | undefined,\n  slotUsagesStream: ReadableStream<RscSlotUsageEvent> | undefined,\n): any {\n  return createRscProxyInternal({\n    getTree,\n    path,\n    stream,\n    cssHrefs,\n    jsPreloads,\n    renderable: false,\n    slotUsages,\n    slotUsagesStream,\n  })\n}\n\nasync function consumeSlotUsages(\n  stream: ReadableStream<RscSlotUsageEvent>,\n  slotUsages: Array<RscSlotUsageEvent>,\n): Promise<void> {\n  try {\n    const reader = stream.getReader()\n    for (;;) {\n      const { value, done } = await reader.read()\n      if (done) break\n      if (!value.slot) continue\n      slotUsages.push(value)\n    }\n  } catch {\n    // Ignore - dev-only best effort\n  }\n}\n"],"mappings":"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"}

package/dist/esm/createServerComponentFromStream.js

@@ -0,0 +1,74 @@
+"use client";
+import { awaitLazyElements } from "./awaitLazyElements.js";
+import { createRscProxy } from "./createRscProxy.js";
+import { use } from "react";
+import { trackPostProcessPromise } from "@tanstack/start-client-core";
+import { createFromReadableStream } from "virtual:tanstack-rsc-browser-decode";
+//#region src/createServerComponentFromStream.ts
+/**
+* Creates a renderable RSC proxy from a raw Flight stream.
+* Client-side only - used by the client serialization adapter for `renderServerComponent`.
+*
+* Returns a Proxy that:
+* - Can be rendered directly as `{data}` in JSX
+* - Supports nested access: `{data.foo.bar}`
+* - Masquerades as a React element
+*/
+function createRenderableFromStream(stream) {
+	const { getTree, streamWrapper, cssHrefs } = setupStreamDecode(stream);
+	return createRscProxy(getTree, {
+		stream: streamWrapper,
+		cssHrefs,
+		renderable: true
+	});
+}
+/**
+* Creates a composite RSC proxy from a raw Flight stream.
+* Client-side only - used by the client serialization adapter for `createCompositeComponent`.
+*
+* Returns a Proxy that:
+* - NOT directly renderable
+* - Supports nested access: `src.foo.bar`
+* - Must be rendered via `<CompositeComponent src={...} />`
+*/
+function createCompositeFromStream(stream, options) {
+	const { getTree, streamWrapper, cssHrefs } = setupStreamDecode(stream);
+	return createRscProxy(getTree, {
+		stream: streamWrapper,
+		cssHrefs,
+		renderable: false,
+		slotUsagesStream: options?.slotUsagesStream
+	});
+}
+/**
+* Shared stream decode setup for both renderable and composite.
+*/
+function setupStreamDecode(stream) {
+	const decodeThenable = createFromReadableStream(stream);
+	const cssHrefs = /* @__PURE__ */ new Set();
+	let cachedTree = void 0;
+	let cacheReady = false;
+	const transformedTreePromise = Promise.resolve(decodeThenable).then(async (result) => {
+		await awaitLazyElements(result, (href) => {
+			cssHrefs.add(href);
+		});
+		cachedTree = result;
+		cacheReady = true;
+		return result;
+	});
+	trackPostProcessPromise(transformedTreePromise);
+	const streamWrapper = { createReplayStream: () => stream };
+	const getTree = () => {
+		if (cacheReady) return cachedTree;
+		return use(transformedTreePromise);
+	};
+	return {
+		getTree,
+		streamWrapper,
+		cssHrefs
+	};
+}
+//#endregion
+export { createCompositeFromStream, createRenderableFromStream };
+
+//# sourceMappingURL=createServerComponentFromStream.js.map

package/dist/esm/createServerComponentFromStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createServerComponentFromStream.js","names":[],"sources":["../../src/createServerComponentFromStream.ts"],"sourcesContent":["'use client'\n\nimport { use } from 'react'\nimport { trackPostProcessPromise } from '@tanstack/start-client-core'\nimport { createFromReadableStream as browserDecode } from 'virtual:tanstack-rsc-browser-decode'\n\nimport { awaitLazyElements } from './awaitLazyElements'\nimport { createRscProxy } from './createRscProxy'\nimport type {\n  AnyCompositeComponent,\n  RscSlotUsageEvent,\n  ServerComponentStream,\n} from './ServerComponentTypes'\n\n/**\n * Creates a renderable RSC proxy from a raw Flight stream.\n * Client-side only - used by the client serialization adapter for `renderServerComponent`.\n *\n * Returns a Proxy that:\n * - Can be rendered directly as `{data}` in JSX\n * - Supports nested access: `{data.foo.bar}`\n * - Masquerades as a React element\n */\nexport function createRenderableFromStream(\n  stream: ReadableStream<Uint8Array>,\n): any {\n  const { getTree, streamWrapper, cssHrefs } = setupStreamDecode(stream)\n\n  return createRscProxy(getTree, {\n    stream: streamWrapper,\n    cssHrefs,\n    renderable: true,\n  })\n}\n\n/**\n * Creates a composite RSC proxy from a raw Flight stream.\n * Client-side only - used by the client serialization adapter for `createCompositeComponent`.\n *\n * Returns a Proxy that:\n * - NOT directly renderable\n * - Supports nested access: `src.foo.bar`\n * - Must be rendered via `<CompositeComponent src={...} />`\n */\nexport function createCompositeFromStream(\n  stream: ReadableStream<Uint8Array>,\n  options?: {\n    slotUsagesStream?: ReadableStream<RscSlotUsageEvent>\n  },\n): AnyCompositeComponent {\n  const { getTree, streamWrapper, cssHrefs } = setupStreamDecode(stream)\n\n  return createRscProxy(getTree, {\n    stream: streamWrapper,\n    cssHrefs,\n    renderable: false,\n    slotUsagesStream: options?.slotUsagesStream,\n  })\n}\n\n/**\n * Shared stream decode setup for both renderable and composite.\n */\nfunction setupStreamDecode(stream: ReadableStream<Uint8Array>): {\n  getTree: () => unknown\n  streamWrapper: ServerComponentStream\n  cssHrefs: Set<string> | undefined\n} {\n  // Start decoding eagerly during deserialization\n  const decodeThenable = browserDecode(stream)\n  const cssHrefs = new Set<string>()\n\n  // Synchronous cache for the decoded tree.\n  let cachedTree: unknown = undefined\n  let cacheReady = false\n\n  // Promise for the tree with lazy elements awaited.\n  const transformedTreePromise = Promise.resolve(decodeThenable).then(\n    async (result) => {\n      await awaitLazyElements(result, (href) => {\n        cssHrefs.add(href)\n      })\n      cachedTree = result\n      cacheReady = true\n      return result\n    },\n  )\n\n  // Track the lazy element loading - prevents flash\n  trackPostProcessPromise(transformedTreePromise)\n\n  const streamWrapper: ServerComponentStream = {\n    createReplayStream: () => stream,\n  }\n\n  const getTree = () => {\n    if (cacheReady) return cachedTree\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return use(transformedTreePromise)\n  }\n\n  return { getTree, streamWrapper, cssHrefs }\n}\n// Legacy export for backwards compatibility during migration\nexport const createServerComponentFromStream = createCompositeFromStream\n"],"mappings":";;;;;;;;;;;;;;;;AAuBA,SAAgB,2BACd,QACK;CACL,MAAM,EAAE,SAAS,eAAe,aAAa,kBAAkB,OAAO;AAEtE,QAAO,eAAe,SAAS;EAC7B,QAAQ;EACR;EACA,YAAY;EACb,CAAC;;;;;;;;;;;AAYJ,SAAgB,0BACd,QACA,SAGuB;CACvB,MAAM,EAAE,SAAS,eAAe,aAAa,kBAAkB,OAAO;AAEtE,QAAO,eAAe,SAAS;EAC7B,QAAQ;EACR;EACA,YAAY;EACZ,kBAAkB,SAAS;EAC5B,CAAC;;;;;AAMJ,SAAS,kBAAkB,QAIzB;CAEA,MAAM,iBAAiB,yBAAc,OAAO;CAC5C,MAAM,2BAAW,IAAI,KAAa;CAGlC,IAAI,aAAsB,KAAA;CAC1B,IAAI,aAAa;CAGjB,MAAM,yBAAyB,QAAQ,QAAQ,eAAe,CAAC,KAC7D,OAAO,WAAW;AAChB,QAAM,kBAAkB,SAAS,SAAS;AACxC,YAAS,IAAI,KAAK;IAClB;AACF,eAAa;AACb,eAAa;AACb,SAAO;GAEV;AAGD,yBAAwB,uBAAuB;CAE/C,MAAM,gBAAuC,EAC3C,0BAA0B,QAC3B;CAED,MAAM,gBAAgB;AACpB,MAAI,WAAY,QAAO;AAEvB,SAAO,IAAI,uBAAuB;;AAGpC,QAAO;EAAE;EAAS;EAAe;EAAU"}

package/dist/esm/entry/rsc.js

@@ -0,0 +1,21 @@
+import { renderToReadableStream } from "virtual:tanstack-rsc-runtime";
+import { getServerFnById } from "#tanstack-start-server-fn-resolver";
+//#region src/entry/rsc.tsx
+/**
+* Shared RSC (React Server Components) entry point.
+*
+* This file exports the functions needed for the active RSC environment:
+* - getServerFnById: Resolves server functions by their encoded ID
+* - render: Renders a React node to an RSC Flight stream
+*/
+/**
+* Renders a React node to an RSC Flight stream.
+* Used internally for streaming server component output.
+*/
+function render(node) {
+	return renderToReadableStream(node);
+}
+//#endregion
+export { getServerFnById, render };
+
+//# sourceMappingURL=rsc.js.map

package/dist/esm/entry/rsc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsc.js","names":[],"sources":["../../../src/entry/rsc.tsx"],"sourcesContent":["/**\n * Shared RSC (React Server Components) entry point.\n *\n * This file exports the functions needed for the active RSC environment:\n * - getServerFnById: Resolves server functions by their encoded ID\n * - render: Renders a React node to an RSC Flight stream\n */\n\nimport { renderToReadableStream } from 'virtual:tanstack-rsc-runtime'\nimport type React from 'react'\n\n// Re-export getServerFnById from the virtual module which handles both dev and production\n// In dev: dynamic import with base64url-decoded file path\n// In production: manifest-based lookup with bundled chunks\nexport { getServerFnById } from '#tanstack-start-server-fn-resolver'\n\n/**\n * Renders a React node to an RSC Flight stream.\n * Used internally for streaming server component output.\n */\nexport function render(node: React.ReactNode): ReadableStream<Uint8Array> {\n  return renderToReadableStream(node)\n}\n"],"mappings":";;;;;;;;;;;;;;AAoBA,SAAgB,OAAO,MAAmD;AACxE,QAAO,uBAAuB,KAAK"}

package/dist/esm/flight.js

@@ -0,0 +1,56 @@
+import { createClientOnlyFn, createIsomorphicFn } from "@tanstack/start-fn-stubs";
+//#region src/flight.ts
+/**
+* Low-level Flight stream APIs for decoding RSC streams.
+*
+* These functions provide direct access to RSC Flight stream decoding,
+* allowing advanced use cases like:
+* - Server functions returning raw Flight Response
+* - API routes streaming Flight payloads
+* - Custom Flight stream handling via RawStream
+*
+* `createFromReadableStream` works in both SSR and browser contexts.
+* `createFromFetch` is browser-only.
+*
+* NOTE: Dynamic imports keep decode initialisation runtime-specific. The
+* concrete implementation comes from bundler-owned virtual modules.
+*/
+/**
+* Decode a Flight stream into React elements.
+* Works in both SSR and browser contexts.
+*
+* @example
+* ```tsx
+* const rawStream = await getRscRawStream()
+* const tree = await createFromReadableStream(rawStream)
+* return <>{tree}</>
+* ```
+*/
+var createFromReadableStream = createIsomorphicFn().server(async (stream) => {
+	const { createFromReadableStream: decode } = await import("virtual:tanstack-rsc-ssr-decode");
+	return decode(stream);
+}).client(async (stream) => {
+	const { createFromReadableStream: decode } = await import("virtual:tanstack-rsc-browser-decode");
+	return decode(stream);
+});
+/**
+* Decode a Flight stream from a fetch Response.
+* Browser only - will throw if called on the server.
+*
+* @example
+* ```tsx
+* // From server function returning raw Response
+* const tree = await createFromFetch(getFlightResponse())
+*
+* // From API route
+* const tree = await createFromFetch(fetch('/api/rsc-flight'))
+* ```
+*/
+var createFromFetch = createClientOnlyFn(async (fetchPromise) => {
+	const { createFromFetch: decode } = await import("virtual:tanstack-rsc-browser-decode");
+	return decode(fetchPromise);
+});
+//#endregion
+export { createFromFetch, createFromReadableStream };
+
+//# sourceMappingURL=flight.js.map

package/dist/esm/flight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flight.js","names":[],"sources":["../../src/flight.ts"],"sourcesContent":["/**\n * Low-level Flight stream APIs for decoding RSC streams.\n *\n * These functions provide direct access to RSC Flight stream decoding,\n * allowing advanced use cases like:\n * - Server functions returning raw Flight Response\n * - API routes streaming Flight payloads\n * - Custom Flight stream handling via RawStream\n *\n * `createFromReadableStream` works in both SSR and browser contexts.\n * `createFromFetch` is browser-only.\n *\n * NOTE: Dynamic imports keep decode initialisation runtime-specific. The\n * concrete implementation comes from bundler-owned virtual modules.\n */\n\nimport {\n  createClientOnlyFn,\n  createIsomorphicFn,\n} from '@tanstack/start-fn-stubs'\n\n/**\n * Decode a Flight stream into React elements.\n * Works in both SSR and browser contexts.\n *\n * @example\n * ```tsx\n * const rawStream = await getRscRawStream()\n * const tree = await createFromReadableStream(rawStream)\n * return <>{tree}</>\n * ```\n */\nexport const createFromReadableStream = createIsomorphicFn()\n  .server(\n    async (stream: ReadableStream<Uint8Array>): Promise<React.ReactNode> => {\n      const { createFromReadableStream: decode } =\n        await import('virtual:tanstack-rsc-ssr-decode')\n      return decode(stream) as React.ReactNode\n    },\n  )\n  .client(\n    async (stream: ReadableStream<Uint8Array>): Promise<React.ReactNode> => {\n      const { createFromReadableStream: decode } =\n        await import('virtual:tanstack-rsc-browser-decode')\n      return decode(stream)\n    },\n  )\n\n/**\n * Decode a Flight stream from a fetch Response.\n * Browser only - will throw if called on the server.\n *\n * @example\n * ```tsx\n * // From server function returning raw Response\n * const tree = await createFromFetch(getFlightResponse())\n *\n * // From API route\n * const tree = await createFromFetch(fetch('/api/rsc-flight'))\n * ```\n */\nexport const createFromFetch = createClientOnlyFn(\n  async (fetchPromise: Promise<Response>): Promise<React.ReactNode> => {\n    const { createFromFetch: decode } =\n      await import('virtual:tanstack-rsc-browser-decode')\n    return decode(fetchPromise)\n  },\n)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAa,2BAA2B,oBAAoB,CACzD,OACC,OAAO,WAAiE;CACtE,MAAM,EAAE,0BAA0B,WAChC,MAAM,OAAO;AACf,QAAO,OAAO,OAAO;EAExB,CACA,OACC,OAAO,WAAiE;CACtE,MAAM,EAAE,0BAA0B,WAChC,MAAM,OAAO;AACf,QAAO,OAAO,OAAO;EAExB;;;;;;;;;;;;;;AAeH,IAAa,kBAAkB,mBAC7B,OAAO,iBAA8D;CACnE,MAAM,EAAE,iBAAiB,WACvB,MAAM,OAAO;AACf,QAAO,OAAO,aAAa;EAE9B"}

package/dist/esm/flight.rsc.js

@@ -0,0 +1,2 @@
+import { renderToReadableStream as renderToReadableStream$1 } from "virtual:tanstack-rsc-runtime";
+export { renderToReadableStream$1 as renderToReadableStream };

package/dist/esm/flight.stub.js

@@ -0,0 +1,15 @@
+//#region src/flight.stub.ts
+/**
+* Client stub for renderToReadableStream.
+*
+* This function should never be called at runtime on the client.
+* It exists only to provide types for bundler imports in client bundles.
+* The real implementation only runs inside RSC context (server functions).
+*/
+function renderToReadableStream(_node) {
+	throw new Error("renderToReadableStream cannot be called on the client. This function should only be called inside RSC context (server functions).");
+}
+//#endregion
+export { renderToReadableStream };
+
+//# sourceMappingURL=flight.stub.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flight.stub.js","names":[],"sources":["../../src/flight.stub.ts"],"sourcesContent":["/**\n * Client stub for renderToReadableStream.\n *\n * This function should never be called at runtime on the client.\n * It exists only to provide types for bundler imports in client bundles.\n * The real implementation only runs inside RSC context (server functions).\n */\nexport function renderToReadableStream(\n  _node: React.ReactNode,\n): ReadableStream<Uint8Array> {\n  throw new Error(\n    'renderToReadableStream cannot be called on the client. ' +\n      'This function should only be called inside RSC context (server functions).',\n  )\n}\n"],"mappings":";;;;;;;;AAOA,SAAgB,uBACd,OAC4B;AAC5B,OAAM,IAAI,MACR,oIAED"}

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { SERVER_COMPONENT_CSS_HREFS } from "./ServerComponentTypes.js";
+import { renderServerComponent } from "./renderServerComponent.stub.js";
+import { createCompositeComponent } from "./createCompositeComponent.stub.js";
+import { CompositeComponent } from "./CompositeComponent.js";
+import { createFromFetch, createFromReadableStream } from "./flight.js";
+import { renderToReadableStream } from "./flight.stub.js";
+export { CompositeComponent, SERVER_COMPONENT_CSS_HREFS, createCompositeComponent, createFromFetch, createFromReadableStream, renderServerComponent, renderToReadableStream };

package/dist/esm/index.rsc.js

@@ -0,0 +1,6 @@
+import { CompositeComponent } from "./CompositeComponent.js";
+import { createFromFetch, createFromReadableStream } from "./flight.js";
+import { renderServerComponent } from "./renderServerComponent.js";
+import { createCompositeComponent } from "./createCompositeComponent.js";
+import { renderToReadableStream } from "./flight.rsc.js";
+export { CompositeComponent, createCompositeComponent, createFromFetch, createFromReadableStream, renderServerComponent, renderToReadableStream };