vite-plugin-react-server 1.2.0-alpha.0 → 1.2.0

package/dist/plugin/types.d.ts

@@ -6,15 +6,16 @@ import type { PassThrough, Transform } from "stream";
 import type { AliasOptions, BuildOptions, Connect, Logger, Manifest, Plugin, ResolveOptions, UserConfig, ViteDevServer } from "vite";
 import type { serializeResolvedConfig, serializeResolvedUserConfig } from "./helpers/serializeUserOptions.js";
 import type { AllowedDirectives, Program } from "./loader/directives/types.js";
-import type { RenderMetrics, StreamMetrics } from "./metrics/types.js";
+import type { LoaderConfig, TransformOptions } from "./loader/types.js";
+import type { RenderMetrics, StreamMetrics, WorkerStartupMetrics, ModuleResolutionMetrics } from "./metrics/types.js";
 import type { HtmlWorkerOutputMessage } from "./worker/html/types.js";
 import type { RscChunkOutputMessage } from "./worker/rsc/types.js";
-import type { ReactServerDomEsmOptions } from "./worker/types.js";
-import type { LoaderConfig, TransformOptions } from "./loader/types.js";
-export type ReactStreamPluginFn<R extends Record<string, unknown> = {
-    meta: ReactStreamPluginMeta;
-}> = <Opt extends StreamPluginOptions = StreamPluginOptions>(options: Opt) => Plugin<R>;
-export type OnEvent = (event: PluginEvent) => void;
+import type { WorkerMessage } from "./worker/types.js";
+import type { Strategy } from "./orchestrator/createPluginOrchestrator.js";
+import type { RenderToPipeableStreamOptions as ClientRenderToPipeableStreamOptions } from "react-dom/server";
+import type { RenderToPipeableStreamOptions as ServerRenderToPipeableStreamOptions } from "react-server-dom-esm/server.node";
+export type OnEvent<Interface extends ViteReactServerComponentsPlugin = ViteReactServerComponentsPlugin> = (event: PluginEvent<Interface>) => void;
+export type OnMetrics = (metrics: RenderMetrics<"rsc-full" | "rsc-headless" | "html"> | WorkerStartupMetrics | ModuleResolutionMetrics) => void;
 export type MessageHandler<T extends HtmlWorkerOutputMessage | RscChunkOutputMessage = HtmlWorkerOutputMessage | RscChunkOutputMessage> = (message: T) => void | Promise<unknown>;
 export type CreateInputNormalizerProps = {
     root: string;
@@ -34,27 +35,71 @@ export type HmrState = {
 };
 export type RenderPageResult = {
     type: "skip";
+    reason?: unknown;
+    html: {
+        abort: (reason?: unknown) => void;
+        pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+    };
+    rsc: {
+        abort: (reason?: unknown) => void;
+        pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+    };
+    metrics: {
+        rscFull: RenderMetrics & {
+            type: "rsc-full";
+        };
+        rscHeadless: RenderMetrics & {
+            type: "rsc-headless";
+        };
+        html: RenderMetrics & {
+            type: "html";
+        };
+    };
 } | {
     type: "error";
-    error: Error;
+    error: unknown;
+    metrics: {
+        rscFull: RenderMetrics & {
+            type: "rsc-full";
+        };
+        rscHeadless: RenderMetrics & {
+            type: "rsc-headless";
+        };
+        html: RenderMetrics & {
+            type: "html";
+        };
+    };
 } | {
     type: "success";
-    html: PassThrough;
-    rsc: PassThrough;
+    html: {
+        abort: (reason?: unknown) => void;
+        pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+    };
+    rsc: {
+        abort: (reason?: unknown) => void;
+        pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+    };
     metrics: {
-        rscFull: StreamMetrics;
-        rscHeadless: StreamMetrics;
+        rscFull: RenderMetrics & {
+            type: "rsc-full";
+        };
+        rscHeadless: RenderMetrics & {
+            type: "rsc-headless";
+        };
+        html: RenderMetrics & {
+            type: "html";
+        };
     };
 };
 export type AutoDiscoveredFiles = ResolvedBuildPages & {
     workerPaths: Record<string, string>;
     serverEntry: Record<string, string> | null;
     clientEntry: Record<string, string>;
-    inputs: Record<string, string>;
-    staticManifest: Manifest;
+    clientInputs: Record<string, string>;
+    staticInputs: Record<string, string>;
+    serverInputs: Record<string, string>;
     serverActions: Record<string, string>;
 };
-export type FileWriterOptions = Pick<CreateHandlerOptions, "onEvent" | "route" | "build">;
 export type NormalizerInput = unknown;
 export type InputNormalizer = (input: NormalizerInput) => [string, string];
 export type HtmlContent = {
@@ -97,15 +142,20 @@ export type StreamPluginOptionsClient = {
     cssFiles?: AliasOptions;
 };
 export type StringKeys = "moduleBase" | "moduleBasePath" | "moduleBaseURL" | "moduleRootPath" | "projectRoot" | "pageExportName" | "propsExportName" | "htmlWorkerPath" | "rscWorkerPath" | "loaderPath" | "reactLoaderPath" | "cssLoaderPath" | "envLoaderPath" | "clientEntry" | "serverEntry" | "publicOrigin";
-export type NumberKeys = "rscTimeout" | "htmlWorkerStartupTimeout" | "rscWorkerStartupTimeout";
+export type NumberKeys = "rscTimeout" | "htmlTimeout" | "htmlWorkerStartupTimeout" | "rscWorkerStartupTimeout" | "fileWriteTimeout" | "workerShutdownTimeout";
 export type BooleanKeys = "verbose";
-export type NestedConfigKeys = "build" | "autoDiscover" | "loader" | "css" | "pipeableStreamOptions";
+export type NestedConfigKeys = "build" | "autoDiscover" | "loader" | "css" | "pipeableStreamOptions" | "serverPipeableStreamOptions" | "clientPipeableStreamOptions";
 export type EventKeys = "onMetrics" | "onEvent";
 export type NormalizerKeys = "normalizer" | "moduleID";
 export type ComponentKeys = "Html" | "Root";
 export type SourceURLKeys = "Page" | "props";
 export type OptKey = StringKeys | NumberKeys | BooleanKeys | EventKeys | NormalizerKeys | ComponentKeys | SourceURLKeys;
 export type AutoDiscoverConfig = {
+    clientEntry: string;
+    serverEntry: string;
+    cssEntry: string;
+    jsonEntry: string;
+    htmlEntry: string;
     modulePattern: RegExp;
     serverPattern: RegExp;
     clientPattern: RegExp;
@@ -131,9 +181,11 @@ export type BuildModuleLoader<Opt extends Pick<ResolvedUserOptions, "pageExportN
 } : Extra extends string ? Special extends "#" ? {
     [k in Extra]: unknown;
 } : Record<string, unknown> : Record<string, unknown> : Record<string, unknown>>;
+export type InterfaceAwareBuildModuleLoader<Interface extends ViteReactServerComponentsPlugin = DefaultInterface, Opt extends Pick<ResolvedUserOptions, "pageExportName" | "propsExportName"> = Pick<ResolvedUserOptions, "pageExportName" | "propsExportName">> = BuildModuleLoader<Opt, Interface["PageProps"]>;
 export type StreamError = {
     code?: string;
 } & Error;
+export type PanicThreshold = "none" | "critical_errors" | "all_errors";
 export type ResolvedUserOptions = {
     projectRoot: string;
     moduleBase: string;
@@ -153,10 +205,15 @@ export type ResolvedUserOptions = {
     envLoaderPath?: string;
     verbose: boolean;
     rscTimeout: number;
+    htmlTimeout: number;
     htmlWorkerStartupTimeout: number;
     rscWorkerStartupTimeout: number;
-    panicThreshold: "none" | "critical_errors" | "all_errors";
-    onEvent?: (event: PluginEvent) => void;
+    fileWriteTimeout: number;
+    workerShutdownTimeout: number;
+    panicThreshold: PanicThreshold;
+    availableEnvironments?: string[];
+    strategy?: Strategy;
+    onEvent?: OnEvent<ViteReactServerComponentsPlugin> | undefined;
     props?: StreamPluginOptions["props"];
     clientEntry?: string;
     serverEntry?: string;
@@ -164,19 +221,23 @@ export type ResolvedUserOptions = {
     Html: StreamPluginOptions["Html"];
     Root: StreamPluginOptions["Root"];
     normalizer: InputNormalizer;
-    moduleID: ((id: string) => string) | undefined;
-    onMetrics: (metrics: RenderMetrics) => void;
-    pipeableStreamOptions: ReactServerDomEsmOptions;
+    moduleID: ((id: string, sourceContent?: string) => string) | undefined;
+    onMetrics: OnMetrics | undefined;
+    pipeableStreamOptions: any;
+    serverPipeableStreamOptions?: any;
+    clientPipeableStreamOptions?: any;
     autoDiscover: Required<AutoDiscoverConfig>;
-    loader: Required<LoaderConfig>;
+    loader?: Required<LoaderConfig> | undefined;
     build: Required<BuildConfig>;
+    dev: Required<DevConfig>;
     css: RootOptions<boolean>;
     components?: StreamPluginOptions["components"];
 };
 export type DirectiveOptions = Pick<TransformOptions, "verbose" | "panicThreshold" | "loader"> & {
-    loader: Pick<Required<NonNullable<TransformOptions["loader"]>>, "isServerFunctionCode" | "isClientComponentCode" | "getDirectiveType"> & {
+    loader: Pick<Required<NonNullable<TransformOptions["loader"]>>, "isServerFunctionCode" | "isClientComponentCode" | "getDirectiveType" | "parse"> & {
         allowedDirectives: AllowedDirectives;
     };
+    logger?: Logger;
 };
 export type RootOptions<InlineCSS extends InlineCssOpt = InlineCssOpt> = {
     inlineCss?: InlineCSS;
@@ -188,19 +249,9 @@ export type CssContent<InlineCSS extends InlineCssOpt = InlineCssOpt> = InlineCS
 /**
  * Boxed component type for the Root
  */
-export type RootComponentType<As extends AsOpt = AsOpt, InlineCSS extends InlineCssOpt = InlineCssOpt, PageProps extends PagePropOpt = PagePropOpt, ReactType = any> = (props: RootProps<PageProps, InlineCSS, As>) => ReactType;
-export type RootProps<PageProps extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt, As extends AsOpt = AsOpt> = {
-    as: As;
-    cssFiles?: Map<string, CssContent<InlineCSS>>;
-    pageProps?: PageProps;
-    Page: PageComponentType<PageProps>;
-    id?: string;
-};
-export type RootComponent = (props: RootProps) => React.ReactNode;
-/**
- * Boxed component type for the Html component
- */
-export type HtmlComponentType<T extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt, As extends AsOpt = AsOpt, ReactType = any> = ((props: HtmlProps<T, InlineCSS, As>) => ReactType) | any;
+export type CssComponentType<InlineCSS extends InlineCssOpt = InlineCssOpt, R = any> = (props: {
+    cssFiles: Map<string, CssContent<InlineCSS>> | CssContent[];
+}) => R;
 export type FileWriteEvent = {
     type: "file.write";
     data: {
@@ -217,28 +268,51 @@ export type FileWriteDoneEvent = {
         route: string;
         fileType: "html" | "rsc";
         content: string;
+        chunks: number;
+        path: string;
+        fileName: string;
+        baseDir: string;
+        routePath: string;
     };
 };
-export type RouteProcessEvent = {
-    type: "route.process";
+export type RouteErrorEvent = {
+    type: "route.error";
     data: {
         route: string;
-        pagePath: string;
-        propsPath?: string | undefined;
+        error?: unknown | null;
+        errorInfo?: {
+            componentStack?: string | null;
+            digest?: string | null;
+        };
+        reason?: unknown;
+        isPanic?: boolean;
+        panicThreshold?: PanicThreshold;
     };
 };
-export type RouteErrorEvent = {
-    type: "route.error";
+export type RouteShellErrorEvent = {
+    type: "route.shellError";
     data: {
         route: string;
-        error?: Error | null;
+        error: unknown;
     };
 };
 export type RoutePostponeEvent = {
     type: "route.postpone";
     data: {
         route: string;
-        reason?: string | null;
+        reason?: unknown;
+    };
+};
+export type RouteShellReadyEvent = {
+    type: "route.shellReady";
+    data: {
+        route: string;
+    };
+};
+export type RouteAllReadyEvent = {
+    type: "route.allReady";
+    data: {
+        route: string;
     };
 };
 export type PropsLoadEvent = {
@@ -249,9 +323,9 @@ export type PropsLoadEvent = {
         props: unknown;
     };
 };
-export type CssProcessEvent = {
+export type CssProcessEvent<Interface extends ViteReactServerComponentsPlugin = DefaultInterface> = {
     type: "css.process";
-    data: CssContent;
+    data: InterfaceAwareCssContent<Interface>;
 };
 export type BuildStartEvent = {
     type: "build.start";
@@ -276,26 +350,34 @@ export type BuildWriteBundleEventClient = {
         bundle: OutputBundle;
     };
 };
-export type BuildWriteBundleEventStaticClient = {
-    type: "build.writeBundle.static-client";
+export type BuildWriteBundleEventStatic = {
+    type: "build.writeBundle.static";
     data: {
         pages: string[];
         options: NormalizedOutputOptions;
         bundle: OutputBundle;
     };
 };
-export type BuildWriteBundleEventStaticServer = {
-    type: "build.writeBundle.static-server";
+export type BuildEventStaticSiteGenerationStart = {
+    type: "build.ssg.start";
     data: {
         pages: string[];
         options: NormalizedOutputOptions;
         bundle: OutputBundle;
     };
 };
-export type BuildWriteBundleEvent = BuildWriteBundleEventServer | BuildWriteBundleEventClient | BuildWriteBundleEventStaticClient | BuildWriteBundleEventStaticServer;
-export type PluginEvent = FileWriteEvent | FileWriteDoneEvent | RouteProcessEvent | RouteErrorEvent | RoutePostponeEvent | PropsLoadEvent | CssProcessEvent | BuildStartEvent | BuildWriteBundleEvent;
+export type BuildEventStaticSiteGenerationEnd = {
+    type: "build.ssg.end";
+    data: {
+        pages: string[];
+        options: NormalizedOutputOptions;
+        bundle: OutputBundle;
+    };
+};
+export type BuildWriteBundleEvent = BuildWriteBundleEventServer | BuildWriteBundleEventClient | BuildEventStaticSiteGenerationStart | BuildEventStaticSiteGenerationEnd | BuildWriteBundleEventStatic;
+export type PluginEvent<Interface extends ViteReactServerComponentsPlugin = ViteReactServerComponentsPlugin> = FileWriteEvent | FileWriteDoneEvent | RouteErrorEvent | RouteShellErrorEvent | RoutePostponeEvent | PropsLoadEvent | CssProcessEvent<Interface> | BuildStartEvent | BuildWriteBundleEvent | RouteShellReadyEvent | RouteAllReadyEvent;
 export type PluginEventType = PluginEvent["type"];
-export type StreamPluginOptions<T extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt, As extends AsOpt = AsOpt, N1 extends string = PageName, N2 extends string = PropsName, N3 extends string = HtmlName, N4 extends string = RootName> = {
+export interface StreamPluginOptions<Interface extends ViteReactServerComponentsPlugin = DefaultInterface> {
     projectRoot?: string;
     moduleBase: string;
     moduleBasePath?: string;
@@ -314,6 +396,9 @@ export type StreamPluginOptions<T extends PagePropOpt = PagePropOpt, InlineCSS e
         directivePattern?: RegExpOpt;
         isServerFunctionCode?: (code: string, moduleId?: string) => boolean;
         isClientComponentCode?: (code: string, moduleId?: string) => boolean;
+        isClientComponentByCode?: (code: string) => boolean;
+        isClientComponentByName?: (moduleId: string) => boolean;
+        moduleID?: (moduleId: string) => string;
         allowedDirectives?: string[] | AllowedDirectives;
         mode?: "development" | "production" | "test";
         getDirectiveType?: (directive: string, moduleId?: string) => "client" | "server" | undefined;
@@ -329,6 +414,11 @@ export type StreamPluginOptions<T extends PagePropOpt = PagePropOpt, InlineCSS e
         }>;
     };
     autoDiscover?: {
+        clientEntry: string;
+        serverEntry: string;
+        cssEntry: string;
+        jsonEntry: string;
+        htmlEntry: string;
         /**
          * Pattern to match CSS files. If not provided, uses default pattern.
          * Provide either a string pattern or RegExp.
@@ -490,51 +580,79 @@ export type StreamPluginOptions<T extends PagePropOpt = PagePropOpt, InlineCSS e
     reactLoaderPath?: string;
     cssLoaderPath?: string;
     envLoaderPath?: string;
-    pageExportName?: N1;
-    propsExportName?: N2;
-    htmlExportName?: N3;
-    rootExportName?: N4;
+    pageExportName?: Interface["PageExportName"];
+    propsExportName?: Interface["PropsExportName"];
+    htmlExportName?: Interface["HtmlExportName"];
+    rootExportName?: Interface["RootExportName"];
     Html?: UrlOpt;
     Root?: UrlOpt;
     components?: {
-        Html?: React.FC<HtmlProps<T, InlineCSS, As>> | typeof React.Fragment;
-        Root?: RootComponentType;
+        Html?: HtmlComponentType<Interface["PageProps"], Interface["As"], Interface["InlineCSS"], Interface["ReactType"]>;
+        Root?: RootComponentType<Interface["PageProps"], Interface["As"], Interface["InlineCSS"], Interface["ReactType"]>;
+        Page?: PageComponentType<Interface["PageProps"], Interface["ReactType"]>;
     };
     build?: BuildConfig;
-    css?: RootOptions<InlineCSS>;
-    pipeableStreamOptions?: ReactServerDomEsmOptions;
-    onMetrics?: (metrics: RenderMetrics) => void;
-    onEvent?: (event: PluginEvent) => void;
+    dev?: DevConfig;
+    css?: RootOptions<Interface["InlineCSS"]>;
+    pipeableStreamOptions?: any;
+    serverPipeableStreamOptions?: any;
+    clientPipeableStreamOptions?: any;
+    onMetrics?: OnMetrics;
+    onEvent?: OnEvent<Interface>;
     normalizer?: InputNormalizer;
-    moduleID?: (id: string) => string;
+    moduleID?: (id: string, sourceContent?: string) => string;
     verbose?: boolean;
     rscTimeout?: number;
+    htmlTimeout?: number;
     htmlWorkerStartupTimeout?: number;
     rscWorkerStartupTimeout?: number;
-    panicThreshold?: "none" | "critical_errors" | "all_errors";
-};
+    fileWriteTimeout?: number;
+    workerShutdownTimeout?: number;
+    panicThreshold?: PanicThreshold;
+}
 export type MultiPageHandlerOptions<Opt extends ResolvedUserOptions = ResolvedUserOptions> = Omit<CreateHandlerOptions<Opt>, "pagePath" | "route" | "cssFiles" | "propsPath" | "rootPath" | "htmlPath" | "pageProps" | "PageComponent" | "RootComponent" | "HtmlComponent">;
-export type CreateHandlerOptions<Opt extends ResolvedUserOptions = ResolvedUserOptions> = Pick<Opt, "autoDiscover" | "css" | "pageExportName" | "propsExportName" | "rootExportName" | "htmlExportName" | "moduleBase" | "moduleRootPath" | "moduleBasePath" | "moduleBaseURL" | "publicOrigin" | "onEvent" | "onMetrics" | "projectRoot" | "normalizer" | "moduleID" | "verbose" | "components"> & {
+export type CreateHandlerOptions<Opt extends Record<string, unknown> = ResolvedUserOptions, Interface extends ViteReactServerComponentsPlugin = DefaultInterface, R = Interface["ReactType"]> = Pick<Opt, "autoDiscover" | "css" | "pageExportName" | "propsExportName" | "rootExportName" | "htmlExportName" | "moduleBase" | "moduleRootPath" | "moduleBasePath" | "moduleBaseURL" | "publicOrigin" | "onEvent" | "onMetrics" | "projectRoot" | "normalizer" | "moduleID" | "verbose" | "components" | "panicThreshold" | "projectRoot" | "rscTimeout" | "htmlTimeout" | "fileWriteTimeout" | "workerShutdownTimeout" | "rscWorkerPath" | "htmlWorkerPath"> & {
+    id?: string;
+    /** ID of headless stream to reuse for efficiency */
+    reuseHeadlessStreamId?: string;
+    /** Storage for headless stream reuse Map<id, { PageComponent: any, errored: boolean }> */
+    headlessStreamElements?: Map<string, {
+        PageComponent: any;
+        errored: boolean;
+    }>;
+    signal?: AbortSignal;
     logger: Logger;
     loader: BuildModuleLoader | GenericModuleLoader;
     pagePath: string;
     propsPath?: string;
     rootPath?: string;
     htmlPath?: string;
-    pageProps?: PagePropOpt;
-    PageComponent?: PageComponentType<PagePropOpt>;
-    RootComponent?: RootComponentType;
-    HtmlComponent?: HtmlComponentType<PagePropOpt>;
+    pageProps?: Interface["PageProps"];
+    PageComponent?: PageComponentType<Interface["PageProps"], R> | typeof React.Fragment;
+    RootComponent?: RootComponentType<Interface["PageProps"], Interface["As"], Interface["InlineCSS"], R> | typeof React.Fragment;
+    HtmlComponent?: HtmlComponentType<Interface["PageProps"], Interface["As"], Interface["InlineCSS"], R> | typeof React.Fragment;
     route: string;
-    as?: AsOpt;
+    url?: string;
+    as?: Interface["As"];
     manifest: Manifest;
+    staticManifest?: Manifest;
+    serverManifest?: Manifest;
+    clientManifest?: Manifest;
     worker?: Worker;
+    rscWorker?: Worker;
+    htmlWorker?: Worker;
     server?: ViteDevServer;
     importedCss?: Set<string>;
-    cssFiles: Map<string, CssContent<InlineCssOpt>>;
-    globalCss: Map<string, CssContent<InlineCssOpt>>;
-    pipeableStreamOptions: ReactServerDomEsmOptions;
-    build: Pick<ResolvedUserOptions["build"], "outDir" | "pages" | "server" | "static" | "client" | "rscOutputPath" | "htmlOutputPath">;
+    cssFiles: Map<string, InterfaceAwareCssContent<Interface>>;
+    globalCss: Map<string, InterfaceAwareCssContent<Interface>>;
+    serverPipeableStreamOptions?: ServerRenderToPipeableStreamOptions;
+    clientPipeableStreamOptions?: ClientRenderToPipeableStreamOptions;
+    rscStream?: import("node:stream").Readable;
+    htmlStream?: import("node:stream").Readable;
+    metrics?: import("./metrics/types.js").StreamMetrics;
+    build: Pick<ResolvedUserOptions["build"], "outDir" | "pages" | "server" | "static" | "client" | "rscOutputPath" | "htmlOutputPath" | "assetsDir" | "preserveModulesRoot">;
+    dev: Pick<ResolvedUserOptions["dev"], "useHtmlWorker" | "useRscWorker">;
+    children?: React.ReactNode;
 };
 export type ResolvePageOptions = {
     pagePath: string;
@@ -546,13 +664,6 @@ export type ResolvePropsOptions = {
     propsExportName: string;
     url: string;
 };
-export type BaseProps = {
-    manifest: Manifest;
-    children?: React.ReactNode;
-    assets?: {
-        css?: string[];
-    };
-};
 export type StreamResult = {
     type: "success";
     stream: PassThrough;
@@ -582,20 +693,27 @@ export type BuildOutput = {
     ext?: string;
 };
 export type BuildConfig = {
-    pages: string[] | (() => Promise<string[]> | string[]) | Promise<string[]>;
+    useRscWorker?: boolean;
+    useHtmlWorker?: boolean;
+    pages?: string[] | (() => Promise<string[]> | string[]) | Promise<string[]>;
     assetsDir?: string;
     client?: string;
     server?: string;
     static?: string;
     api?: string;
     outDir?: string;
-    hash?: string;
-    preserveDirectives?: boolean;
+    hash?: string | {
+        format?: "vite" | "hex" | "custom";
+        length?: number;
+        characters?: string;
+        prefix?: string;
+        suffix?: string;
+    };
     preserveModulesRoot?: boolean;
     rscOutputPath?: string;
     htmlOutputPath?: string;
-    entryFile?: (n: PreRenderedChunk, ssr: boolean) => string;
-    chunkFile?: (n: PreRenderedChunk, ssr: boolean) => string;
+    entryFile?: (n: PreRenderedChunk, ssr: boolean, sourceContent?: string) => string;
+    chunkFile?: (n: PreRenderedChunk, ssr: boolean, sourceContent?: string) => string;
     assetFile?: (n: PreRenderedAsset, ssr: boolean) => string;
     extensionMap?: Record<string, string>;
     moduleExtension?: string;
@@ -607,6 +725,10 @@ export type BuildConfig = {
     cssModuleExtension?: string;
     nodeExtension?: string;
 };
+export type DevConfig = {
+    useHtmlWorker?: boolean | undefined;
+    useRscWorker?: boolean | undefined;
+};
 export type RequestHandler = Connect.NextHandleFunction;
 export type RscServerModule = {
     /**
@@ -673,7 +795,7 @@ export type ResolvedBuildPages = {
         root?: string;
         html?: string;
     }>;
-    errors: Error[];
+    errors: unknown[];
 };
 export type ModuleId = string & {
     readonly __brand: unique symbol;
@@ -681,8 +803,6 @@ export type ModuleId = string & {
 export type PagePath = string & {
     readonly __brand: unique symbol;
 };
-export type InlineCssOpt = undefined | boolean;
-export type PagePropOpt = Record<string, unknown>;
 export interface DeserializedRegExp {
     source: string;
     flags: string;
@@ -694,11 +814,9 @@ export type PageName = "Page";
 export type PropsName = "props";
 export type HtmlName = "Html";
 export type RootName = "Root";
-export type AsOpt = React.ExoticComponent<React.FragmentProps> | Exclude<keyof React.JSX.IntrinsicElements, "symbol" | "object">;
-export type PageComponentType<PageProps extends PagePropOpt = PagePropOpt, ReactType = any> = (props: PageProps) => ReactType;
-export type HtmlProps<PageProps extends PagePropOpt = PagePropOpt, InlineCSS extends InlineCssOpt = InlineCssOpt, As extends AsOpt = AsOpt> = {
+export type HtmlProps<PageProps extends ViteReactServerComponentsPlugin["PageProps"] = DefaultInterface["PageProps"], InlineCSS extends ViteReactServerComponentsPlugin["InlineCSS"] = DefaultInterface["InlineCSS"], As extends ViteReactServerComponentsPlugin["As"] = DefaultInterface["As"], R = DefaultInterface["ReactType"]> = {
     pageProps?: PageProps;
-    Page: PageComponentType<PageProps>;
+    Page: PageComponentType<PageProps, R>;
     route: string;
     url: string;
     projectRoot: string;
@@ -708,7 +826,7 @@ export type HtmlProps<PageProps extends PagePropOpt = PagePropOpt, InlineCSS ext
     moduleRootPath: string;
     cssFiles: Map<string, CssContent<InlineCSS>>;
     manifest: Manifest;
-    Root: RootComponentType<As, InlineCSS, PageProps>;
+    Root: RootComponentType<PageProps, As, InlineCSS, R> | typeof React.Fragment;
     globalCss: Map<string, CssContent<InlineCSS>>;
     as?: As;
 };
@@ -748,40 +866,16 @@ export type HtmlRenderState = {
     progressStream: PassThrough;
     errorTransform: Transform;
     htmlChunks: string[];
-    pipeableStreamOptions: Omit<ReactServerDomEsmOptions, "onError" | "onPostpone">;
+    pipeableStreamOptions: any;
     streamState: StreamMetrics;
 };
 export type RenderPagesResult = {
-    type: "error";
-    error: Error;
-    failedRoutes: Set<string>;
+    type: "error" | "success" | "skip";
+    error?: unknown;
+    route?: string;
     completedRoutes: Set<string>;
-    htmlSizes: Map<string, number>;
-    rscSizes: Map<string, number>;
-    streamMetrics: StreamMetrics;
-    results: Map<string, {
-        html: PassThrough;
-        rsc: PassThrough;
-        metrics: {
-            rscFull: StreamMetrics;
-            rscHeadless: StreamMetrics;
-        };
-    }>;
-} | {
-    type: "success";
-    completedRoutes: Set<string>;
-    failedRoutes?: never;
-    htmlSizes: Map<string, number>;
-    rscSizes: Map<string, number>;
-    streamMetrics: StreamMetrics;
-    results: Map<string, {
-        html: PassThrough;
-        rsc: PassThrough;
-        metrics: {
-            rscFull: StreamMetrics;
-            rscHeadless: StreamMetrics;
-        };
-    }>;
+    failedRoutes: Map<string, unknown>;
+    results: Map<string, RenderPageResult>;
 };
 export type HandlerAssets<InlineCSS extends InlineCssOpt = InlineCssOpt> = {
     css: CssContent<InlineCSS>[];
@@ -801,20 +895,10 @@ export type CreateHandlerResult<InlineCSS extends InlineCssOpt = InlineCssOpt> =
     metrics: StreamMetrics;
 } | {
     type: "error";
-    error: Error;
+    error: unknown;
 } | {
     type: "skip";
 };
-export type ReactStaticEvent = FileWriteEvent | {
-    type: "build.start";
-    data: {
-        pages: string[];
-        files: Array<[string, {
-            page: string;
-            props?: string;
-        }]>;
-    };
-};
 export type LoaderContext = {
     format?: string;
     importAttributes?: Record<string, string>;
@@ -885,9 +969,150 @@ export type FlightConfig = {
     rsc: RSCInteropConfig;
     vendor: VendorInteropConfig;
 };
-export { createFlightBindings, defaultFlightBindings, } from "./config/flightBindings.js";
-export type ReactStreamOptionsFn<ReturnType = void> = <PageProp extends PagePropOpt = PagePropOpt, As extends AsOpt = AsOpt, N1 extends string = PageName, N2 extends string = PropsName, Input extends StreamPluginOptions<PageProp, InlineCssOpt, As, N1, N2> = StreamPluginOptions<PageProp, InlineCssOpt, As, N1, N2>, Output extends ReturnType = ReturnType>(options: Input) => Output;
-export type ReactStreamHandlerFn<ReturnType> = <Opt extends CreateHandlerOptions = CreateHandlerOptions>(options: Opt) => ReturnType;
-export type ReactStreamResolvedOptionsFn<ReturnType = void> = (options: ResolvedUserOptions) => ReturnType;
-export type { RenderMetrics, StreamMetrics };
+export type VitePluginMainFn = <Opt extends StreamPluginOptions<any> = StreamPluginOptions<any>>(options: Opt, strategy?: Strategy) => Plugin<Opt>[];
+export type VitePluginMainAsyncFn = <Opt extends StreamPluginOptions<any> = StreamPluginOptions<any>>(options: Opt) => Promise<Plugin<Opt>[]>;
+export type VitePluginFn = <Opt extends StreamPluginOptions = StreamPluginOptions>(options: Opt) => Plugin;
+export type ComponentResolutionStrategy = "serializable-path" | "direct-import" | "worker-internal" | "external-reference";
+export type SerializableComponentPath = string & {
+    readonly __brand: "SerializableComponentPath";
+};
+export type ComponentResolutionConfig = {
+    strategy: ComponentResolutionStrategy;
+    path?: SerializableComponentPath;
+    moduleId?: string;
+    exportName?: string;
+};
+export type ClientEnvironmentOptions = {
+    PageComponent?: never;
+    RootComponent?: never;
+    HtmlComponent?: never;
+    pageComponentConfig?: ComponentResolutionConfig;
+    rootComponentConfig?: ComponentResolutionConfig;
+    htmlComponentConfig?: ComponentResolutionConfig;
+    pagePath?: string;
+    rootPath?: string;
+    htmlPath?: string;
+};
+export type ServerEnvironmentOptions = {
+    PageComponent?: CreateHandlerOptions["PageComponent"];
+    RootComponent?: CreateHandlerOptions["RootComponent"];
+    HtmlComponent?: CreateHandlerOptions["HtmlComponent"];
+    pageComponentConfig?: ComponentResolutionConfig;
+    rootComponentConfig?: ComponentResolutionConfig;
+    htmlComponentConfig?: ComponentResolutionConfig;
+    pagePath?: string;
+    rootPath?: string;
+    htmlPath?: string;
+};
+export type ReactStreamCommonOptions<Env extends "client" | "server" = "client" | "server", Handles extends keyof CreateHandlerOptions = never> = Omit<CreateHandlerOptions, Handles | "PageComponent" | "RootComponent" | "HtmlComponent" | "pagePath" | "rootPath" | "htmlPath"> & Partial<Pick<CreateHandlerOptions, Handles>> & (Env extends "client" ? ClientEnvironmentOptions : ServerEnvironmentOptions);
+export type ReactStreamHandlerFn<Env extends "client" | "server", Handles extends keyof CreateHandlerOptions, ReturnType> = (options: ReactStreamCommonOptions<Env, Handles>) => ReturnType;
+export type RscWorkerMessage = {
+    pageComponentConfig?: ComponentResolutionConfig;
+    rootComponentConfig?: ComponentResolutionConfig;
+    htmlComponentConfig?: ComponentResolutionConfig;
+    pagePath?: string;
+    rootPath?: string;
+    htmlPath?: string;
+    route: string;
+    url: string;
+    pageProps?: Record<string, unknown>;
+    cssFiles: Array<[string, unknown]>;
+    manifest: Record<string, unknown>;
+    PageComponent?: never;
+    RootComponent?: never;
+    HtmlComponent?: never;
+};
+export type RscRenderOpt = WorkerMessage & {
+    type: "INIT";
+} & {
+    dataPort: MessagePort;
+    controlPort: MessagePort;
+    options: Omit<CreateHandlerOptions<ResolvedUserOptions>, "onEvent" | "onMetrics" | "loader" | "build" | "autoDiscover" | "normalizer" | "moduleID" | "PageComponent" | "RootComponent" | "HtmlComponent" | "url" | "logger" | "cssFiles"> & {
+        url?: string;
+        pageComponentConfig?: ComponentResolutionConfig;
+        rootComponentConfig?: ComponentResolutionConfig;
+        htmlComponentConfig?: ComponentResolutionConfig;
+        cssFiles: Array<[string, unknown]>;
+        build: Omit<CreateHandlerOptions<ResolvedUserOptions>["build"], "entryFileNames" | "chunkFileNames" | "assetFileNames" | "pages"> & {
+            pages: string[];
+        };
+    };
+};
+export type PluginComponentReference = {
+    type: "plugin-component";
+    componentName: "Html" | "Root" | "Css";
+    modulePath: string;
+    exportName: string;
+};
+export type ResolvedComponent<T = unknown> = {
+    type: "success";
+    component: T;
+    source: "direct" | "resolved" | "plugin" | "worker-internal";
+} | {
+    type: "error";
+    error: Error;
+    source: "direct" | "resolved" | "plugin" | "worker-internal";
+};
+export type WorkerComponentLoader = {
+    loadComponent: (config: ComponentResolutionConfig) => Promise<ResolvedComponent>;
+    loadPluginComponent: (reference: PluginComponentReference) => Promise<ResolvedComponent>;
+    hasInternalComponent: (componentName: string) => boolean;
+};
+export type { RenderMetrics, StreamMetrics, WorkerStartupMetrics, ModuleResolutionMetrics, };
+export type InferReactType<R = React.ReactNode> = R;
+export type CustomInterface<R = React.ReactNode> = {
+    ReactType: R;
+    PageProps: any;
+    As: any;
+    PropsExportName: string;
+    PageExportName: string;
+    RootExportName: string;
+    HtmlExportName: string;
+    InlineCSS: undefined | boolean;
+};
+declare global {
+    interface ViteReactServerComponentsPlugin {
+        PageProps: any;
+        As: any;
+        InlineCSS: undefined | boolean;
+        ReactType: InferReactType;
+        PropsExportName: string;
+        PageExportName: string;
+        RootExportName: string;
+        HtmlExportName: string;
+    }
+}
+export interface DefaultInterface<T extends React.ComponentProps<any> = React.ComponentProps<any>, As extends React.JSXElementConstructor<any> | keyof React.JSX.IntrinsicElements = React.JSXElementConstructor<any> | keyof React.JSX.IntrinsicElements> extends ViteReactServerComponentsPlugin {
+    ReactType: InferReactType;
+    PageProps: T;
+    As: As;
+    PropsExportName: PropsName;
+    PageExportName: PageName;
+    RootExportName: RootName;
+    HtmlExportName: HtmlName;
+}
+export type PagePropOpt = DefaultInterface["PageProps"];
+export type AsOpt = DefaultInterface["As"];
+export type InlineCssOpt = DefaultInterface["InlineCSS"];
+export type PageComponentType<PageProps extends ViteReactServerComponentsPlugin["PageProps"] = DefaultInterface["PageProps"], R = DefaultInterface["ReactType"]> = (props: PageProps) => R;
+export type RootComponentType<PageProps extends ViteReactServerComponentsPlugin["PageProps"] = DefaultInterface["PageProps"], As extends ViteReactServerComponentsPlugin["As"] = DefaultInterface["As"], InlineCSS extends ViteReactServerComponentsPlugin["InlineCSS"] = DefaultInterface["InlineCSS"], R = DefaultInterface["ReactType"]> = (props: RootProps<PageProps, InlineCSS, As, R>) => R;
+export type RootProps<PageProps extends ViteReactServerComponentsPlugin["PageProps"] = DefaultInterface["PageProps"], InlineCSS extends ViteReactServerComponentsPlugin["InlineCSS"] = DefaultInterface["InlineCSS"], As extends ViteReactServerComponentsPlugin["As"] = DefaultInterface["As"], R = DefaultInterface["ReactType"]> = {
+    as: As;
+    cssFiles?: Map<string, CssContent<InlineCSS>>;
+    pageProps?: Omit<PageProps, "children">;
+    Page: PageComponentType<Omit<PageProps, "children">, R>;
+    id?: string;
+};
+/**
+ * Boxed component type for the Html component
+ */
+export type HtmlComponentType<T extends ViteReactServerComponentsPlugin["PageProps"] = DefaultInterface["PageProps"], As extends ViteReactServerComponentsPlugin["As"] = DefaultInterface["As"], InlineCSS extends ViteReactServerComponentsPlugin["InlineCSS"] = DefaultInterface["InlineCSS"], R = DefaultInterface["ReactType"]> = (props: HtmlProps<T, InlineCSS, As, R>) => R;
+export type InterfaceAwareCssContent<Interface extends ViteReactServerComponentsPlugin> = CssContent<Interface["InlineCSS"]>;
+export type InterfaceAwareRootOptions<Interface extends ViteReactServerComponentsPlugin> = RootOptions<Interface["InlineCSS"]>;
+export type InterfaceAwareCssComponentType<Interface extends ViteReactServerComponentsPlugin, R = Interface["ReactType"]> = CssComponentType<Interface["InlineCSS"], R>;
+export type InterfaceAwareCssProps<Interface extends ViteReactServerComponentsPlugin> = CssProps<Interface["InlineCSS"]>;
+export type InterfaceAwareHandlerAssets<Interface extends ViteReactServerComponentsPlugin> = HandlerAssets<Interface["InlineCSS"]>;
+export type InterfaceAwareCreateHandlerResult<Interface extends ViteReactServerComponentsPlugin> = CreateHandlerResult<Interface["InlineCSS"]>;
+export type VitePluginReactClientFn = <Opt extends StreamPluginOptions = StreamPluginOptions>(options: Opt) => Plugin[];
+export type VitePluginReactServerFn = <Opt extends StreamPluginOptions = StreamPluginOptions>(options: Opt) => Plugin[];
 //# sourceMappingURL=types.d.ts.map