vike-react-rsc-rudder 1.0.0

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const PKG_NAME = "vike-react-rsc-rudder";

package/dist/getGlobalObject-CzWO6NfD.js

@@ -0,0 +1,10 @@
+//#region src/utils/getGlobalObject.ts
+function getGlobalObject(key, defaultValue) {
+	const globalObjectsAll = globalThis[projectKey] = globalThis[projectKey] || {};
+	const globalObject = globalObjectsAll[key] = globalObjectsAll[key] || defaultValue;
+	return globalObject;
+}
+const projectKey = "_vike_react_rsc";
+
+//#endregion
+export { getGlobalObject };

package/dist/hooks/pageContext/pageContext-client.d.ts

@@ -0,0 +1,11 @@
+export { usePageContext };
+export { getPageContext };
+export { PageContextProvider };
+import React from "react";
+import type { PageContext } from "vike/types";
+declare function PageContextProvider({ pageContext, children }: {
+	pageContext: PageContext
+	children: React.ReactNode
+}): React.ReactElement;
+declare function usePageContext(): PageContext;
+declare function getPageContext(): PageContext;

package/dist/hooks/pageContext/pageContext-client.js

@@ -0,0 +1,4 @@
+import "../../getGlobalObject-CzWO6NfD.js";
+import { PageContextProvider, getPageContext, usePageContext } from "../../pageContext-client-CmvZ4bmk.js";
+
+export { PageContextProvider, getPageContext, usePageContext };

package/dist/hooks/pageContext/pageContext-server.d.ts

@@ -0,0 +1,7 @@
+export { usePageContext };
+export { getPageContext };
+export { providePageContext };
+import type { PageContext } from "vike/types";
+declare function providePageContext<T>(pageContext: PageContext, callback: () => T): T;
+declare function getPageContext(): PageContext;
+declare function usePageContext(): PageContext;

package/dist/hooks/pageContext/pageContext-server.js

@@ -0,0 +1,4 @@
+import "../../getGlobalObject-CzWO6NfD.js";
+import { getPageContext$1 as getPageContext, providePageContext, usePageContext$1 as usePageContext } from "../../pageContext-server-B1QwrAws.js";
+
+export { getPageContext, providePageContext, usePageContext };

package/dist/integration/client.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/integration/client.js

@@ -0,0 +1,16 @@
+import { tinyassert } from "@hiogawa/utils";
+import * as ReactClient from "@vitejs/plugin-rsc/react/browser";
+
+//#region src/integration/client.ts
+async function importClientRefrence(id) {
+	if (import.meta.env.DEV) return self.__raw_import(id);
+	else {
+		const clientReferences = await import("virtual:client-references");
+		const dynImport = clientReferences.default[id];
+		tinyassert(dynImport, `client reference not found '${id}'`);
+		return dynImport();
+	}
+}
+ReactClient.setRequireModule({ load: importClientRefrence });
+
+//#endregion

package/dist/integration/getPageElement/getPageElement-server.d.ts

@@ -0,0 +1,14 @@
+export { getPageElementRsc };
+import React from "react";
+import type { PageContext } from "vike/types";
+type EnsureArray<T> = NonNullable<T> extends Array<any> ? NonNullable<T> : NonNullable<T>[];
+type ConfigMap = { [K in keyof PageContext["config"]] : EnsureArray<PageContext["config"][K]> };
+declare global {
+	var __VIKE_RSC_PAGES_MANIFEST__: {
+		[pageId: string]: {
+			importPage: () => Promise<PageContext["Page"]>
+			getConfig: () => Promise<ConfigMap>
+		}
+	};
+}
+declare function getPageElementRsc(pageContext: PageContext): Promise<React.ReactElement>;

package/dist/integration/onBeforeRender.d.ts

@@ -0,0 +1,2 @@
+import type { OnBeforeRenderAsync } from "vike/types";
+export declare const onBeforeRender: OnBeforeRenderAsync;

package/dist/integration/onBeforeRender.js

@@ -0,0 +1,17 @@
+import envName from "virtual:enviroment-name";
+
+//#region src/integration/onBeforeRender.tsx
+const onBeforeRender = envName === "ssr" && async function(pageContext) {
+	console.log("[Vike Hook] +onBeforeRender called.");
+	if (pageContext.handleServerAction) {
+		pageContext.handleServerAction(pageContext);
+		return;
+	}
+	if (pageContext.handleNavigation) {
+		pageContext.handleNavigation(pageContext);
+		return;
+	}
+};
+
+//#endregion
+export { onBeforeRender };

package/dist/integration/onPageTransitionStart.d.ts

@@ -0,0 +1,2 @@
+import type { OnPageTransitionStartSync } from "vike/types";
+export declare const onPageTransitionStart: OnPageTransitionStartSync;

package/dist/integration/onPageTransitionStart.js

@@ -0,0 +1,11 @@
+import "../getGlobalObject-CzWO6NfD.js";
+import "../cache-BCYpxG4P.js";
+import { onNavigate } from "../client-BpZo3JRu.js";
+
+//#region src/integration/onPageTransitionStart.tsx
+const onPageTransitionStart = (pageContext) => {
+	onNavigate(pageContext);
+};
+
+//#endregion
+export { onPageTransitionStart };

package/dist/integration/onRenderClient.d.ts

@@ -0,0 +1,2 @@
+import type { OnRenderClientAsync } from "vike/types";
+export declare const onRenderClient: OnRenderClientAsync;

package/dist/integration/onRenderClient.js

@@ -0,0 +1,63 @@
+import "../getGlobalObject-CzWO6NfD.js";
+import { PageContextProvider } from "../pageContext-client-CmvZ4bmk.js";
+import { getGlobalClientState } from "../cache-BCYpxG4P.js";
+import { parseRscStream } from "../client-BpZo3JRu.js";
+import { useEffect, useState } from "react";
+import envName from "virtual:enviroment-name";
+import { tinyassert } from "@hiogawa/utils";
+import { jsx } from "react/jsx-runtime";
+import ReactDOMClient from "react-dom/client";
+
+//#region src/integration/onRenderClient.tsx
+tinyassert(envName === "client", "Invalid environment");
+const globalState = getGlobalClientState();
+function Root({ initialPayload, initialPageContext }) {
+	const [payload, setPayload] = useState({
+		payload: initialPayload,
+		pageContext: initialPageContext
+	});
+	useEffect(() => {
+		globalState.setPayload = setPayload;
+	}, []);
+	return /* @__PURE__ */ jsx(PageContextProvider, {
+		pageContext: payload.pageContext,
+		children: payload.payload.root
+	});
+}
+const onRenderClient = async function(pageContext) {
+	globalState.pageContext = pageContext;
+	console.log("[Vike Hook] +onRenderClient called");
+	if (pageContext.isHydration) try {
+		console.log("[Client] Hydrating root");
+		const container = document.getElementById("root");
+		if (!container) {
+			console.error("[Client] Container #root not found!");
+			return;
+		}
+		const rscPayloadStream = window.__rsc_payload_stream;
+		const initialPayload = await parseRscStream(rscPayloadStream);
+		ReactDOMClient.hydrateRoot(container, /* @__PURE__ */ jsx(Root, {
+			initialPayload,
+			initialPageContext: pageContext
+		}), { formState: initialPayload.formState });
+		console.log("[Client] Hydration complete");
+	} catch (err) {
+		console.error("[Client] Hydration failed:", err);
+	}
+	else if (pageContext.isClientSideNavigation) try {
+		console.log("[Client] Client-side navigation", globalState.navigationPromise);
+		if (globalState.navigationPromise) {
+			const payload = await globalState.navigationPromise;
+			globalState.setPayload?.({
+				pageContext,
+				payload
+			});
+		} else console.error("[Client] No navigation promise found");
+		console.log("[Client] Navigation complete");
+	} catch (error) {
+		console.error("[Client] Failed to navigate:", error);
+	}
+};
+
+//#endregion
+export { onRenderClient };

package/dist/integration/onRenderHtml.d.ts

@@ -0,0 +1,2 @@
+import type { OnRenderHtmlAsync } from "vike/types";
+export declare const onRenderHtml: OnRenderHtmlAsync;

package/dist/integration/onRenderHtml.js

@@ -0,0 +1,10 @@
+import envName from "virtual:enviroment-name";
+import runtimeSsr from "virtual:runtime/ssr";
+
+//#region src/integration/onRenderHtml.tsx
+const onRenderHtml = envName === "ssr" && async function(pageContext) {
+	return runtimeSsr.onRenderHtmlSsr(pageContext);
+};
+
+//#endregion
+export { onRenderHtml };

package/dist/integration/rscMiddleware.d.ts

@@ -0,0 +1,3 @@
+import { type UniversalMiddleware } from "@universal-middleware/core";
+declare const serverActionMiddleware: UniversalMiddleware;
+export default serverActionMiddleware;

package/dist/integration/rscMiddleware.js

@@ -0,0 +1,35 @@
+import envName from "virtual:enviroment-name";
+import { tinyassert } from "@hiogawa/utils";
+import { enhance } from "@universal-middleware/core";
+import { renderPage } from "vike/server";
+
+//#region src/integration/rscMiddleware.ts
+tinyassert(envName === "ssr", "Invalid environment");
+const serverActionMiddleware = envName === "ssr" && enhance(async (request) => {
+	const runtimeRsc = await import("virtual:runtime/server").then((m) => m.default);
+	const req = request;
+	const actionId = req.headers.get("x-rsc-action");
+	const urlOriginal = req.headers.get("x-vike-urloriginal");
+	if (!urlOriginal) return new Response("Missing x-vike-urloriginal header", { status: 400 });
+	const contentType = req.headers.get("content-type");
+	const body = contentType?.startsWith("multipart/form-data") ? await req.formData() : await req.text();
+	const { promise, resolve } = Promise.withResolvers();
+	renderPage({
+		urlOriginal,
+		handleServerAction: actionId ? (pageContext) => resolve(runtimeRsc.handleServerAction({
+			actionId,
+			pageContext,
+			body
+		})) : null,
+		handleNavigation: !actionId ? (pageContext) => resolve(runtimeRsc.renderPageRsc(pageContext)) : null
+	});
+	return new Response(await promise, { headers: { "content-type": "text/x-component;charset=utf-8" } });
+}, {
+	name: "rsc-handler",
+	method: ["GET", "POST"],
+	path: "/_rsc"
+});
+var rscMiddleware_default = serverActionMiddleware;
+
+//#endregion
+export { rscMiddleware_default as default };

package/dist/pageContext-client-CmvZ4bmk.js

@@ -0,0 +1,27 @@
+import { getGlobalObject } from "./getGlobalObject-CzWO6NfD.js";
+import React, { useContext } from "react";
+import envName from "virtual:enviroment-name";
+import { tinyassert } from "@hiogawa/utils";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/hooks/pageContext/pageContext-client.tsx
+tinyassert(envName === "client" || envName === "ssr", "Invalid environment");
+const globalObject = getGlobalObject("PageContextProvider.ts", { reactContext: React.createContext(void 0) });
+function PageContextProvider({ pageContext, children }) {
+	const { reactContext } = globalObject;
+	return /* @__PURE__ */ jsx(reactContext.Provider, {
+		value: pageContext,
+		children
+	});
+}
+function usePageContext() {
+	const { reactContext } = globalObject;
+	const pageContext = useContext(reactContext);
+	return pageContext;
+}
+function getPageContext() {
+	throw new Error("Cannot use getPageContext in a client component. Import usePageContext instead.");
+}
+
+//#endregion
+export { PageContextProvider, getPageContext, usePageContext };

package/dist/pageContext-server-B1QwrAws.js

@@ -0,0 +1,22 @@
+import { getGlobalObject } from "./getGlobalObject-CzWO6NfD.js";
+import envName from "virtual:enviroment-name";
+import { tinyassert } from "@hiogawa/utils";
+import { AsyncLocalStorage } from "async_hooks";
+
+//#region src/hooks/pageContext/pageContext-server.tsx
+tinyassert(envName === "rsc", "Invalid environment");
+const globalObject = getGlobalObject("PageContextProviderRsc.ts", { reactContextRsc: new AsyncLocalStorage() });
+function providePageContext(pageContext, callback) {
+	const { reactContextRsc } = globalObject;
+	return reactContextRsc.run(pageContext, callback);
+}
+function getPageContext() {
+	const { reactContextRsc } = globalObject;
+	return reactContextRsc.getStore();
+}
+function usePageContext() {
+	throw new Error("Cannot use usePageContext in a server component or action. Import getPageContext instead.");
+}
+
+//#endregion
+export { getPageContext as getPageContext$1, providePageContext, usePageContext as usePageContext$1 };

package/dist/plugin/index.d.ts

@@ -0,0 +1,20 @@
+import { type PluginOption, type ViteDevServer } from "vite";
+type GlobalState = {
+	clientReferences: Record<string, string>
+	serverReferences: Record<string, string>
+	devServer?: ViteDevServer
+	disableUseClientPlugin?: boolean
+	getCssDependencies(id: string): Promise<{
+		cssIds: string[]
+		jsIds: string[]
+	}>
+	pruneCssRegistry(id: string): void
+	isClientDependency(id: string): boolean
+	excludedModuleMap: {
+		[moduleId: string]: string[]
+	}
+};
+declare global {
+	var vikeReactRscGlobalState: GlobalState;
+}
+export default function vikeRscPlugin(): PluginOption[];

package/dist/plugin/plugins/clientDepTrackerPlugin.d.ts

@@ -0,0 +1,7 @@
+export { clientDepTrackerPlugin };
+import type { Plugin } from "vite";
+/**
+* Creates a client dependency tracker for handling client component dependencies
+* Works in both development and build modes with on-demand dependency tracking
+*/
+declare function clientDepTrackerPlugin(): Plugin;

package/dist/plugin/plugins/config.d.ts

@@ -0,0 +1,8 @@
+import { type Plugin } from "vite";
+import { type VitePluginServerEntryOptions } from "@brillout/vite-plugin-server-entry/plugin";
+declare module "vite" {
+	interface UserConfig {
+		vitePluginServerEntry?: VitePluginServerEntryOptions;
+	}
+}
+export declare const configs: Plugin[];

package/dist/plugin/plugins/cssTrackerPlugin.d.ts

@@ -0,0 +1,6 @@
+export { cssTrackerPlugin };
+import type { Plugin } from "vite";
+/**
+* Creates a CSS dependency tracker for proxying CSS imports from rsc to client
+*/
+declare function cssTrackerPlugin(): Plugin;

package/dist/plugin/plugins/dev.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "vite";
+export declare const exposeDevServer: Plugin;

package/dist/plugin/plugins/hmrPlugin.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from "vite";
+export declare const hmrPlugin: () => Plugin;

package/dist/plugin/plugins/injectManifestBuild.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "vite";
+/**
+* Vite plugin that generates a manifest for React Server Components during build.
+* Creates a mapping of page IDs to their corresponding config loaders.
+*/
+export declare function vikeRscManifestPluginBuild(): Plugin;

package/dist/plugin/plugins/serverComponentExclusionPlugin.d.ts

@@ -0,0 +1,6 @@
+import { type Plugin } from "vite";
+/**
+* Plugin to exclude server components from client and SSR bundles
+* while preserving CSS imports for proper styling.
+*/
+export declare const serverComponentExclusionPlugin: () => Plugin[];

package/dist/plugin/plugins/useClientPlugin.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from "vite";
+export declare const useClientPlugin: () => Plugin[];

package/dist/plugin/plugins/useServerPlugin.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from "vite";
+export declare const useServerPlugin: () => Plugin[];

package/dist/plugin/plugins/virtuals.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "vite";
+export declare const virtuals: Plugin[];

package/dist/plugin/utils.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin, ResolvedConfig, ViteDevServer } from "vite";
+export { normalizeReferenceId, virtualNormalizeReferenceIdPlugin, createVirtualPlugin, hashString };
+declare function hashString(value: string): string;
+declare function normalizeReferenceId(id: string, name: "client" | "rsc", server: ViteDevServer, config: ResolvedConfig): Promise<string>;
+declare function createVirtualPlugin(name: string, load: Plugin["load"]): Plugin;
+declare function virtualNormalizeReferenceIdPlugin(): Plugin;

package/dist/register/browser.d.ts

@@ -0,0 +1 @@
+export { createServerReference, callServer } from "@vitejs/plugin-rsc/react/browser";

package/dist/register/browser.js

@@ -0,0 +1,3 @@
+import { callServer, createServerReference } from "@vitejs/plugin-rsc/react/browser";
+
+export { callServer, createServerReference };

package/dist/register/server.d.ts

@@ -0,0 +1 @@
+export { registerClientReference, registerServerReference } from "@vitejs/plugin-rsc/react/rsc";

package/dist/register/server.js

@@ -0,0 +1,3 @@
+import { registerClientReference, registerServerReference } from "@vitejs/plugin-rsc/react/rsc";
+
+export { registerClientReference, registerServerReference };

package/dist/register/ssr.d.ts

@@ -0,0 +1 @@
+export { createServerReference, callServer } from "@vitejs/plugin-rsc/react/ssr";

package/dist/register/ssr.js

@@ -0,0 +1,3 @@
+import { callServer, createServerReference } from "@vitejs/plugin-rsc/react/ssr";
+
+export { callServer, createServerReference };

package/dist/runtime/cache.d.ts

@@ -0,0 +1,50 @@
+import type { PageContext } from "vike/types";
+import type { RscPayload } from "../types.js";
+export type { CacheEntry } from "./client/globalState.js";
+/**
+* Get the cache key for a page context
+*/
+export declare function getCacheKey(pageContext: PageContext): string;
+/**
+* Get stale time from page context
+*/
+export declare function getStaleTime(pageContext: PageContext): number;
+/**
+* Get a cached entry if it exists and is not stale
+*/
+export declare function getCachedPayload(pageContext: PageContext): RscPayload | null;
+/**
+* Store a payload in the cache
+*/
+export declare function cachePayload(pageContext: PageContext, payload: RscPayload): void;
+/**
+* Invalidate the cache entry for a specific page
+*/
+export declare function invalidateCache(pageContext: PageContext): void;
+/**
+* Mark all server component cache entries as stale
+* This is useful when a server action changes data that server components depend on
+*/
+export declare function invalidateServerComponentCache(): void;
+/**
+* Clear all pending server component requests
+* This is useful when navigating between pages or when invalidating the cache
+*/
+export declare function clearPendingServerComponentRequests(): void;
+/**
+* Get a cached server component if it exists
+* Returns the component even if it's stale (stale-while-revalidate pattern)
+* The caller should check the isStale flag and trigger a revalidation if needed
+*/
+export declare function getCachedServerComponent<T>(key: string, pageContext: PageContext): {
+	component: T | null
+	isStale: boolean
+};
+/**
+* Mark a server component as being revalidated
+*/
+export declare function markServerComponentRevalidating(key: string): void;
+/**
+* Store a server component in the cache
+*/
+export declare function cacheServerComponent<T>(key: string, component: T, pageContext: PageContext): void;

package/dist/runtime/client/globalState.d.ts

@@ -0,0 +1,22 @@
+import type { PageContextClient } from "vike/types";
+import type { RscPayload } from "../../types.js";
+export interface GlobalClientState {
+	rscCache: Map<string, CacheEntry>;
+	serverComponentCache: Map<string, CacheEntry>;
+	pendingRequests: Map<string, Promise<any>>;
+	pageContext?: PageContextClient;
+	navigationPromise?: Promise<RscPayload>;
+	isRscCall: boolean;
+	setPayload?: React.Dispatch<React.SetStateAction<{
+		payload: RscPayload
+		pageContext: PageContextClient
+	}>>;
+	vikeRscCallServer?: Function;
+}
+export interface CacheEntry {
+	payload: RscPayload;
+	timestamp: number;
+	isStale?: boolean;
+	revalidating?: boolean;
+}
+export declare function getGlobalClientState(): GlobalClientState;

package/dist/runtime/client.d.ts

@@ -0,0 +1,5 @@
+import type { PageContextClient } from "vike/types";
+import type { RscPayload } from "../types.js";
+export declare function callServer(id: string, args: unknown[]): Promise<RscPayload>;
+export declare function onNavigate(pageContext: PageContextClient): Promise<RscPayload>;
+export declare function parseRscStream(stream: ReadableStream<Uint8Array>): Promise<RscPayload>;

package/dist/runtime/rscBridge.d.ts

@@ -0,0 +1,7 @@
+import React, { type ComponentType } from "react";
+export declare function rsc<
+	P,
+	T extends React.ReactElement<any>
+>(c: (props: P) => Promise<T>): ComponentType<P & {
+	fallback?: React.ReactNode
+}>;

package/dist/runtime/server.d.ts

@@ -0,0 +1,7 @@
+import type { PageContext } from "vike/types";
+export declare function renderPageRsc(pageContext: PageContext): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+export declare function handleServerAction({ actionId, pageContext, body }: {
+	actionId: string
+	pageContext: PageContext
+	body: string | FormData
+}): Promise<ReadableStream<Uint8Array>>;

package/dist/runtime/server.js

@@ -0,0 +1,110 @@
+import "../getGlobalObject-CzWO6NfD.js";
+import { provideServerActionContext } from "../serverActionContext-7Jnbh0-W.js";
+import { providePageContext } from "../pageContext-server-B1QwrAws.js";
+import React, { Suspense } from "react";
+import envName from "virtual:enviroment-name";
+import { tinyassert } from "@hiogawa/utils";
+import { Fragment, jsx } from "react/jsx-runtime";
+import * as ReactServer from "@vitejs/plugin-rsc/react/rsc";
+
+//#region src/integration/getPageElement/getPageElement-server.tsx
+tinyassert(envName === "rsc", "Invalid environment");
+/**
+* Gets page configuration from either dev or production environment
+*/
+async function getPageConfig(pageContext) {
+	if (!import.meta.env.DEV) return __VIKE_RSC_PAGES_MANIFEST__[pageContext.pageId].getConfig();
+	let result = {};
+	const entries = pageContext.configEntries || {};
+	for (const [key, configEntries] of Object.entries(entries).filter(([key$1]) => [
+		"Page",
+		"Layout",
+		"Wrapper",
+		"Loading"
+	].includes(key$1))) {
+		if (!configEntries?.length) continue;
+		const components = (await Promise.all(configEntries.map(async ({ configDefinedAt }) => {
+			const filePath = configDefinedAt.split(" at ").pop() || "";
+			if (!/[tj]sx?$/.test(filePath) || !(key in pageContext.config)) return null;
+			const module = await import(
+				/* @vite-ignore */
+				filePath
+);
+			return module[key] || module.default;
+		}))).filter(Boolean);
+		result[key] = components;
+	}
+	return result;
+}
+async function getPageElementRsc(pageContext) {
+	let Page = () => /* @__PURE__ */ jsx(Fragment, {});
+	let Layout = [];
+	let Wrapper = [];
+	let Loading = {};
+	if (!pageContext.pageId && !import.meta.env.DEV) throw new Error("Missing pageId in production environment");
+	const config = await getPageConfig(pageContext);
+	Page = config.Page?.[0] ?? Page;
+	Layout = config.Layout ?? Layout;
+	Wrapper = config.Wrapper ?? Wrapper;
+	Loading = config.Loading?.[0] ?? Loading;
+	let page = Page ? /* @__PURE__ */ jsx(Page, {}) : null;
+	const addSuspense = (el) => {
+		if (!Loading?.layout) return el;
+		return /* @__PURE__ */ jsx(Suspense, {
+			fallback: /* @__PURE__ */ jsx(Loading.layout, {}),
+			children: page
+		});
+	};
+	page = addSuspense(page);
+	[...Layout || [], ...Wrapper || []].forEach((Wrap) => {
+		page = /* @__PURE__ */ jsx(Wrap, { children: page });
+		page = addSuspense(page);
+	});
+	return page;
+}
+
+//#endregion
+//#region src/runtime/server.tsx
+tinyassert(envName === "rsc", "Invalid environment");
+async function importServerReference(id) {
+	if (import.meta.env.DEV) return import(
+		/* @vite-ignore */
+		id
+);
+	else {
+		const references = await import("virtual:server-references");
+		const dynImport = references.default[id];
+		tinyassert(dynImport, `server reference not found '${id}'`);
+		return dynImport();
+	}
+}
+ReactServer.setRequireModule({ load: importServerReference });
+async function renderPageRsc(pageContext) {
+	console.log("[Renderer] Rendering page to RSC stream");
+	const root = await getPageElementRsc(pageContext);
+	return providePageContext(pageContext, () => ReactServer.renderToReadableStream(
+		// TODO: add form when initial request is POST
+		{ root }
+));
+}
+async function handleServerAction({ actionId, pageContext, body }) {
+	const isServerComponentCall = pageContext.headers?.["x-rsc-component-call"] === "true";
+	console.log("[Server] Handling server action:", actionId, isServerComponentCall ? "(from server component)" : "");
+	const context = { shouldRerender: false };
+	const [args, action] = await Promise.all([ReactServer.decodeReply(body), ReactServer.loadServerAction(actionId)]);
+	const returnValue = await provideServerActionContext(context, () => providePageContext(pageContext, () => action.apply(null, args)));
+	if (context.shouldRerender) {
+		console.log("[Server] Re-rendering page after server action");
+		const root = await getPageElementRsc(pageContext);
+		return providePageContext(pageContext, () => ReactServer.renderToReadableStream({
+			returnValue,
+			root
+		}));
+	} else {
+		console.log("[Server] Returning server action result without re-rendering");
+		return providePageContext(pageContext, () => ReactServer.renderToReadableStream({ returnValue }));
+	}
+}
+
+//#endregion
+export { handleServerAction, renderPageRsc };