@vitejs/plugin-rsc 0.5.32 → 0.5.34

package/README.md

@@ -26,12 +26,15 @@ npm create vite@latest -- --template rsc
 **Integration examples:**
 
 - [`./examples/basic`](./examples/basic) - Comprehensive showcase of standard RSC features and the primary E2E test fixture.
-- [`./examples/use-cache`](./examples/use-cache) - Minimal cache feature inspired by Next.js's `"use cache"`, built with generic transform and RSC runtime APIs.
+- [`./examples/use-cache`](./examples/use-cache) - Local cached functions and components demonstrating argument keys, Flight replay, dynamic children, captured values, and invalidation.
+- [`./examples/use-cache-callable`](./examples/use-cache-callable) - Cached server references demonstrating inline and file directives, client invocation, argument admission, and encrypted closure captures.
+- [`./examples/use-cache-persistent`](./examples/use-cache-persistent) - Persistent callable cache entries demonstrating Flight value replay and dependency-aware development invalidation.
 - [`./examples/custom-server-function`](./examples/custom-server-function) - Third-party Server Function directive integration using server reference claims.
 - [`./examples/ssg`](./examples/ssg) - Static site generation with MDX and client components for interactivity.
 - [`./examples/ppr`](./examples/ppr) - Partial prerendering with a reusable static HTML shell and request-time RSC content.
 - [`./examples/no-ssr`](./examples/no-ssr) - RSC application without an SSR environment.
 - [`./examples/client-first`](./examples/client-first) - Experimental client-owned page that consumes RSC function results.
+- [`./examples/action-reachability`](./examples/action-reachability) - Route-aware dispatch for a retained server action.
 - [`./examples/browser-mode`](./examples/browser-mode) - Advanced setup that runs both RSC and React client environments in the browser with custom module loading.
 - [`./examples/performance-track`](./examples/performance-track) - Minimal React Server Components performance track probe.
 - [`./examples/react-router`](./examples/react-router) - React Router RSC integration
@@ -47,7 +50,7 @@ This is the diagram to show the basic flow of RSC rendering process. See also ht
 graph TD
 
     subgraph "<strong>rsc environment</strong>"
-        A["React virtual dom tree"] --> |"[@vitejs/plugin-rsc/rsc]<br /><code>renderToReadableStream</code>"| B1["RSC Stream"];
+        A["React virtual dom tree"] --> |"[@vitejs/plugin-rsc/rsc/server]<br /><code>renderToReadableStream</code>"| B1["RSC Stream"];
     end
 
     B1 --> B2
@@ -137,7 +140,7 @@ export default defineConfig({
 - [`entry.rsc.tsx`](./examples/starter/src/framework/entry.rsc.tsx)
 
 ```tsx
-import { renderToReadableStream } from '@vitejs/plugin-rsc/rsc'
+import { renderToReadableStream } from '@vitejs/plugin-rsc/rsc/server'
 
 // the plugin assumes `rsc` entry having default export of request handler
 export default async function handler(request: Request): Promise<Response> {
@@ -184,20 +187,19 @@ if (import.meta.hot) {
 - [`entry.ssr.tsx`](./examples/starter/src/framework/entry.ssr.tsx)
 
 ```tsx
-import { createFromReadableStream } from '@vitejs/plugin-rsc/ssr'
+import {
+  createFromReadableStream,
+  getClientEntryUrl,
+} from '@vitejs/plugin-rsc/ssr'
 import { renderToReadableStream } from 'react-dom/server.edge'
 
 export async function handleSsr(rscStream: ReadableStream) {
   // deserialize RSC stream back to React VDOM
   const root = await createFromReadableStream(rscStream)
 
-  // helper API to allow referencing browser entry content from SSR environment
-  const bootstrapScriptContent =
-    await import.meta.viteRsc.loadBootstrapScriptContent('index')
-
   // render html (traditional SSR)
   const htmlStream = renderToReadableStream(root, {
-    bootstrapScriptContent,
+    bootstrapModules: [getClientEntryUrl()],
   })
 
   return htmlStream
@@ -332,20 +334,21 @@ export function UserApp() {
 
 ### Available on `ssr` environment
 
-#### `import.meta.viteRsc.loadBootstrapScriptContent("index")`
+#### `getClientEntryUrl()`
 
-This provides a raw js code to execute a browser entry file specified by `environments.client.build.rollupOptions.input.index`. This is intended to be used with React DOM SSR API, such as [`renderToReadableStream`](https://react.dev/reference/react-dom/server/renderToReadableStream)
+This returns the URL used to load the client entry specified by `environments.client.build.rollupOptions.input.index`. This can be used with React DOM SSR APIs such as [`renderToReadableStream`](https://react.dev/reference/react-dom/server/renderToReadableStream).
 
 ```js
+import { getClientEntryUrl } from '@vitejs/plugin-rsc/ssr'
 import { renderToReadableStream } from 'react-dom/server.edge'
 
-const bootstrapScriptContent =
-  await import.meta.viteRsc.loadBootstrapScriptContent('index')
 const htmlStream = await renderToReadableStream(reactNode, {
-  bootstrapScriptContent,
+  bootstrapModules: [getClientEntryUrl()],
 })
 ```
 
+`getClientEntryUrl()` cannot be used when the `customClientEntry` plugin option is enabled.
+
 ### Available on `client` environment
 
 #### `rsc:update` event
@@ -486,6 +489,8 @@ Together, these APIs allow a React VDOM to be serialized, saved as an RSC stream
 This module re-exports `@vitejs/plugin-rsc/rsc/server` and
 `@vitejs/plugin-rsc/rsc/client`.
 
+Prefer the explicit `/rsc/server` and `/rsc/client` entry points when only one protocol side is needed. Besides making API ownership explicit, this allows Vite to avoid loading and bundling the unused `react-server-dom` runtime. Use `/rsc` when both sides are intentionally needed.
+
 #### Vite-specific extension: `renderToReadableStream` (experimental)
 
 > [!NOTE]
@@ -534,11 +539,7 @@ This module provides Vite-integrated RSC runtime APIs based on
 
 The runtime APIs are exposed through two layers:
 
-- `@vitejs/plugin-rsc/rsc`, `@vitejs/plugin-rsc/ssr`, and
-  `@vitejs/plugin-rsc/browser` are the recommended entry points for application
-  and framework runtime code. They initialize the plugin's built-in module
-  loading using the manifests generated by Vite and re-export the corresponding
-  React runtime APIs described above.
+- `@vitejs/plugin-rsc/rsc/server`, `@vitejs/plugin-rsc/rsc/client`, `@vitejs/plugin-rsc/rsc/static`, `@vitejs/plugin-rsc/ssr`, and `@vitejs/plugin-rsc/browser` are the recommended entry points for application and framework runtime code. They initialize the plugin's built-in module loading using the manifests generated by Vite and re-export the corresponding React runtime APIs described above.
 - `@vitejs/plugin-rsc/react/rsc`, `@vitejs/plugin-rsc/react/ssr`, and
   `@vitejs/plugin-rsc/react/browser` are low-level runtime adapters. They are
   used by code generated for `"use client"` and `"use server"`, and by custom

package/dist/{cjs-Cxg_7upE.js → cjs-AWVWfddx.js}

@@ -1,5 +1,5 @@
 import { t as createDebug } from "./dist-uqdtSkzK.js";
-import { t as buildScopeTree } from "./scope-Do08R7C2.js";
+import { t as buildScopeTree } from "./scope-Bdx33sQv.js";
 import { n as parseIdQuery } from "./shared-B6H2TbnP.js";
 import fs from "node:fs";
 import path from "node:path";
@@ -14,7 +14,8 @@ function __cjs_interop__(m) {
 	return m.__cjs_module_runner_transform || "default" in m && Object.keys(m).every((k) => k === "default" || m[k] === m.default[k]) ? m.default : m;
 }
 const CJS_INTEROP_HELPER = __cjs_interop__.toString().replace(/\n\s*/g, "");
-function transformCjsToEsm(code, ast, options) {
+function transformCjsToEsm(code, viteAst, options) {
+	const ast = viteAst;
 	const output = new MagicString(code);
 	const scopeTree = buildScopeTree(ast);
 	const parentNodes = [];

package/dist/{client-reference-Dy7j0iU8.d.ts → client-reference-DEZtXTv1.d.ts}

@@ -1,5 +1,5 @@
 import { t as ClientReferenceMetadata } from "./rsc-C3UdJLOW.js";
-import { i as ResolvedAssetDeps } from "./plugin-DqLpibhH.js";
+import { i as ResolvedAssetDeps } from "./plugin-CKqXjp8D.js";
 //#region src/rsc/client-reference.d.ts
 type OnClientReference = (metadata: ClientReferenceMetadata & {
   deps: ResolvedAssetDeps;

package/dist/{index-COzKOTR1.d.ts → index-XXYjyFr6.d.ts}

@@ -1,4 +1,5 @@
 import MagicString from "magic-string";
+import { ESTree } from "vite";
 //#region ../../node_modules/.pnpm/@types+estree@1.0.9/node_modules/@types/estree/index.d.ts
 // This definition file follows a somewhat unusual format. ESTree allows
 // runtime type checks based on the `type` parameter. In order to explain this
@@ -526,6 +527,31 @@ interface AwaitExpression extends BaseExpression {
 }
 //#endregion
 //#region src/transforms/hoist.d.ts
+type TransformHoistInlineDirectiveOptions = {
+  runtime: (value: string, name: string, meta: TransformHoistInlineDirectiveMeta) => string;
+  directive: string | RegExp;
+  rejectNonAsyncFunction?: boolean;
+  encode?: (value: string) => string;
+  decode?: (value: string) => string;
+  /** Keep generated hoisted declarations module-local instead of exporting them. */
+  noExport?: boolean;
+  /**
+   * Evaluate the runtime expression once during module initialization.
+   * The expression can reference imports and the hoisted implementation, but
+   * must not depend on other module-local initialization.
+   */
+  hoistRuntime?: boolean;
+};
+type TransformHoistInlineDirectiveMeta = {
+  /** Match result for the source function directive. */
+  directiveMatch: RegExpMatchArray;
+  /** Original source function before closure captures are added as parameters. */
+  valueNode: ArrowFunctionExpression | FunctionDeclaration | FunctionExpression;
+};
+type TransformHoistInlineDirectiveResult = {
+  output: MagicString;
+  names: string[];
+};
 /**
  * Turns an inline directive function into a module-level registered function.
  * Conceptually:
@@ -578,25 +604,40 @@ interface AwaitExpression extends BaseExpression {
  *
  * In this second sketch, `__ENCODE__(...)` and `__DECODE__(...)` likewise
  * represent the expressions returned by those code-generation callbacks.
+ *
+ * With `hoistRuntime`, the runtime result becomes the module-level binding and
+ * the moved function becomes its private implementation:
+ *
+ * ```js
+ * function Component() {
+ *   const x = 1
+ *   const action = $$hoist_0_action.bind(null, x)
+ * }
+ * export const $$hoist_0_action = __RUNTIME__($$hoist_0_action$$impl)
+ * async function $$hoist_0_action$$impl(x, y) {
+ *   "use server"
+ *   return x + y
+ * }
+ * ```
+ *
+ * `noExport` independently keeps `$$hoist_0_action` module-local when an
+ * integration needs module-scope runtime initialization without an export.
  */
-declare function transformHoistInlineDirective(input: string, ast: Program, { runtime, rejectNonAsyncFunction, ...options }: {
-  runtime: (value: string, name: string, meta: {
-    directiveMatch: RegExpMatchArray;
-  }) => string;
-  directive: string | RegExp;
-  rejectNonAsyncFunction?: boolean;
-  encode?: (value: string) => string;
-  decode?: (value: string) => string;
-  /** Keep generated hoisted declarations module-local instead of exporting them. */
-  noExport?: boolean;
-}): {
-  output: MagicString;
-  names: string[];
-};
-declare function findDirectives(ast: Program, directive: string): Literal[];
+declare function transformHoistInlineDirective(input: string, viteAst: ESTree.Program, { runtime, rejectNonAsyncFunction, ...options }: TransformHoistInlineDirectiveOptions): TransformHoistInlineDirectiveResult;
+declare function findDirectives(viteAst: ESTree.Program, directive: string): Literal[];
 //#endregion
-//#region src/transforms/wrap-export.d.ts
-type ExportMeta = {
+//#region src/transforms/module-export-scan.d.ts
+type ModuleExportMeta = {
+  /**
+   * The source node that evaluates to the exported value when directly
+   * available.
+   *
+   * - The declaration for a function or class export.
+   * - The initializer for a variable export.
+   * - The declaration expression for a default export.
+   * - `undefined` for export specifiers and re-exports.
+   */
+  valueNode?: Node | ExportDefaultDeclaration["declaration"];
   /**
    * The local declaration name when statically available.
    *
@@ -617,8 +658,6 @@ type ExportMeta = {
   isFunction?: boolean;
   /**
    * The local identifier referenced by a default export.
-   * The RSC CSS transform uses this to detect a component by its capitalized
-   * local name and preserve that name on the generated wrapper.
    *
    * - `"Page"` for `const Page = () => {}; export default Page`
    * - `undefined` for `export default function Page() {}`
@@ -626,59 +665,273 @@ type ExportMeta = {
    */
   defaultExportIdentifierName?: string;
 };
-type TransformWrapExportFilter = (name: string, meta: ExportMeta) => boolean;
+type ModuleExportEntry = {
+  localName: string;
+  exportName: string;
+  meta: ModuleExportMeta;
+};
+type ModuleExportSpecifier = {
+  node: ExportSpecifier;
+  localName: string;
+  exportName: string;
+  meta: ModuleExportMeta;
+};
+type ModuleExportDefaultKind = "named-declaration" | "identifier" | "other";
+type ModuleExportGroup = {
+  /**
+   * export function foo() {}
+   * export class Foo {}
+   */
+  type: "declaration";
+  node: ExportNamedDeclaration;
+  declaration: FunctionDeclaration | ClassDeclaration;
+  export: ModuleExportEntry;
+} | {
+  /**
+   * export const foo = 1, bar = 2
+   */
+  type: "variable-declaration";
+  node: ExportNamedDeclaration;
+  declaration: VariableDeclaration;
+  declarators: {
+    node: VariableDeclarator;
+    exports: ModuleExportEntry[];
+  }[];
+} | {
+  /**
+   * export { foo as bar }
+   * export { foo as bar } from './dep'
+   */
+  type: "specifiers";
+  node: ExportNamedDeclaration;
+  exports: ModuleExportSpecifier[];
+} | {
+  /**
+   * export * from './dep'
+   * export * as ns from './dep'
+   */
+  type: "export-all";
+  node: ExportAllDeclaration;
+} | {
+  /**
+   * `named-declaration`: export default function foo() {}
+   * `identifier`: export default value
+   * `other`: export default function () {}
+   * `other`: export default () => {}
+   */
+  type: "default";
+  kind: ModuleExportDefaultKind;
+  node: ExportDefaultDeclaration;
+  localName?: string;
+  meta: ModuleExportMeta;
+};
+declare function scanModuleExports(viteAst: ESTree.Program): ModuleExportGroup[];
+//#endregion
+//#region src/transforms/module-export-effect.d.ts
+type TransformModuleExportEffectFilter = (name: string, meta: ModuleExportMeta) => boolean;
+type TransformModuleExportEffectContext = {
+  binding: string;
+  exportName: string;
+  meta: ModuleExportMeta;
+};
+type TransformModuleExportEffectOptions = {
+  generate: (context: TransformModuleExportEffectContext) => string;
+  filter?: TransformModuleExportEffectFilter;
+  rejectNonAsyncFunction?: boolean;
+  exportAll?: "error" | "preserve";
+};
+type TransformModuleExportEffectResult = {
+  output: MagicString;
+  references: TransformModuleExportEffectContext[];
+  referenceNames: string[];
+};
+/**
+ * Preserves source bindings and emits registration effects at module end.
+ *
+ * Conceptually:
+ *
+ * ```js
+ * export async function action() {}
+ * export default async () => {}
+ * ```
+ *
+ * becomes:
+ *
+ * ```js
+ * async function action() {}
+ * const $$effect_default = async () => {}
+ *
+ * __GENERATE__(action, 'action')
+ * export { action }
+ * __GENERATE__($$effect_default, 'default')
+ * export default $$effect_default
+ * ```
+ *
+ * Here, `__GENERATE__(...)` represents the expression returned by the
+ * `generate` callback for each `{ binding, exportName, meta }` context.
+ * `references` returns those contexts in generation order, while
+ * `referenceNames` returns only their export names.
+ *
+ * Effects emitted through declaration and default-export rewrites remain mapped
+ * to their original export sites. Export-specifier effects are appended without
+ * explicit mappings and rely on adjacent-source fallback. React captures the
+ * `registerServerReference` caller as the reference source location.
+ *
+ * Generated bindings such as `$$effect_default` and `$$effect_import_*` are not
+ * deconflicted from user bindings, consistent with the other transform helpers.
+ */
+declare function transformModuleExportEffect(input: string, viteAst: ESTree.Program, options: TransformModuleExportEffectOptions): TransformModuleExportEffectResult;
+//#endregion
+//#region src/transforms/wrap-export.d.ts
+type TransformWrapExportFilter = (name: string, meta: ModuleExportMeta) => boolean;
 type TransformWrapExportOptions = {
-  runtime: (value: string, name: string, meta: ExportMeta) => string;
+  runtime: (value: string, name: string, meta: ModuleExportMeta) => string;
   ignoreExportAllDeclaration?: boolean;
   rejectNonAsyncFunction?: boolean;
   filter?: TransformWrapExportFilter;
 };
-declare function transformWrapExport(input: string, ast: Program, options: TransformWrapExportOptions): {
+type TransformWrapExportResult = {
   exportNames: string[];
   output: MagicString;
 };
+/**
+ * Replaces selected module-local export bindings with runtime wrappers.
+ *
+ * Conceptually:
+ *
+ * ```js
+ * export async function action() {}
+ * export const loader = async () => {}
+ * export default function Page() {}
+ * ```
+ *
+ * becomes:
+ *
+ * ```js
+ * async function action() {}
+ * let loader = async () => {}
+ * function Page() {}
+ *
+ * action = __WRAP__(action, 'action')
+ * export { action }
+ * loader = __WRAP__(loader, 'loader')
+ * export { loader }
+ * const $$wrap_Page = __WRAP__(Page, 'default')
+ * export { $$wrap_Page as default }
+ * ```
+ *
+ * Here, `__WRAP__(...)` represents the expression returned by `runtime`.
+ * Unlike `transformModuleExportWrap`, direct local references observe the
+ * wrapped value because the original binding itself is reassigned.
+ *
+ * Declaration rewrites are moved to the end of the module so each generated
+ * runtime call retains the original export token's source mapping. Wrappers for
+ * export specifiers and default exports are appended without explicit mappings.
+ *
+ * Generated `$$wrap_*` and `$$import_*` names are not deconflicted from user
+ * bindings, consistent with the other transform helpers.
+ */
+declare function transformWrapExport(input: string, viteAst: ESTree.Program, options: TransformWrapExportOptions): TransformWrapExportResult;
 //#endregion
 //#region src/transforms/proxy-export.d.ts
+/** Selects which statically discovered exports become proxies. */
+type TransformProxyExportFilter = (name: string, meta: ModuleExportMeta) => boolean;
 type TransformProxyExportOptions = {
-  /** Required for source map and `keep` options */
+  /**
+   * Original module source used to preserve source mappings and initializer
+   * text. Required by `keep`.
+   */
   code?: string;
+  /**
+   * Returns the proxy expression for an export name. In `keep` mode, `value`
+   * contains the original initializer for a single identifier declaration.
+   */
   runtime: (name: string, meta?: {
     value: string;
   }) => string;
+  /**
+   * Removes a bare `export *` instead of rejecting it. With `keep`, the
+   * declaration is retained.
+   * @default false
+   */
   ignoreExportAllDeclaration?: boolean;
+  /** Rejects statically known values that are not async functions. */
   rejectNonAsyncFunction?: boolean;
   /**
-   * escape hatch for Waku's `allowServer`
+   * Selects exports before validation and proxy generation. Filtered exports
+   * are omitted from both the generated module and `exportNames`.
+   *
+   * Cannot be combined with `keep`.
+   * @default () => true
+   */
+  filter?: TransformProxyExportFilter;
+  /**
+   * Retains non-export implementation code and passes a single identifier
+   * declaration's initializer to `runtime`. This is an escape hatch for Waku's
+   * `allowServer` transform.
+   *
+   * Requires `code` and cannot be combined with `filter`.
    * @default false
    */
   keep?: boolean;
 };
-declare function transformDirectiveProxyExport(ast: Program, options: {
-  directive: string;
-} & TransformProxyExportOptions): {
-  exportNames: string[];
-  output: MagicString;
-} | undefined;
-declare function transformProxyExport(ast: Program, options: TransformProxyExportOptions): {
+type TransformProxyExportResult = {
   exportNames: string[];
   output: MagicString;
 };
+declare function transformDirectiveProxyExport(ast: ESTree.Program, options: {
+  directive: string;
+} & TransformProxyExportOptions): TransformProxyExportResult | undefined;
+/**
+ * Replaces selected exports with proxies created by `runtime` and removes the
+ * original module implementation.
+ *
+ * Conceptually, with a filter that excludes `objectValue`:
+ *
+ * ```js
+ * import { dependency } from './dep'
+ * export async function action() {}
+ * export const objectValue = {}
+ * export { dependency as renamed }
+ * export default async () => {}
+ * ```
+ *
+ * becomes:
+ *
+ * ```js
+ * export const action = __PROXY__('action')
+ * export const renamed = __PROXY__('renamed')
+ * export default __PROXY__('default')
+ * ```
+ *
+ * Unlike `transformWrapExport`, this transform does not evaluate the original
+ * exports. Unknown values are represented only by their export names, so the
+ * caller must filter solely from the available static `ModuleExportMeta`.
+ * `keep` is a specialized mode that retains non-export implementation code and
+ * passes a single variable initializer to `runtime`.
+ */
+declare function transformProxyExport(viteAst: ESTree.Program, options: TransformProxyExportOptions): TransformProxyExportResult;
 //#endregion
 //#region src/transforms/utils.d.ts
-declare function hasDirective(body: Program["body"], directive: string): boolean;
+declare function isDirective(node: Node): node is Directive;
+declare function hasDirective(viteBody: ESTree.Program["body"], directive: string): boolean;
 declare function extractNames(param: Pattern): string[];
 declare function extractIdentifiers(param: Pattern, nodes?: Identifier[]): Identifier[];
 declare function validateNonAsyncFunction(opts: {
   rejectNonAsyncFunction?: boolean;
 }, node: Node | ExportDefaultDeclaration["declaration"]): void;
+declare function rejectNonAsyncFunction$1(opts: {
+  rejectNonAsyncFunction?: boolean;
+}, pos: number): void;
 //#endregion
 //#region src/transforms/server-action.d.ts
-declare function transformServerActionServer(input: string, ast: Program, options: {
+type TransformServerActionServerOptions = {
   runtime: (value: string, name: string) => string;
   rejectNonAsyncFunction?: boolean;
   encode?: (value: string) => string;
   decode?: (value: string) => string;
-}): {
+};
+type TransformServerActionServerResult = {
   exportNames: string[];
   output: MagicString;
   referenceNames: string[];
@@ -687,19 +940,20 @@ declare function transformServerActionServer(input: string, ast: Program, option
   names: string[];
   referenceNames: string[];
 };
+declare function transformServerActionServer(input: string, ast: ESTree.Program, options: TransformServerActionServerOptions): TransformServerActionServerResult;
 //#endregion
 //#region src/transforms/expand-export-all.d.ts
 interface TransformExpandExportAllContext {
   resolve: (source: string, importer: string) => Promise<string | undefined>;
-  load: (id: string) => Promise<Program>;
+  load: (id: string) => Promise<ESTree.Program>;
 }
 interface TransformExpandExportAllOptions extends TransformExpandExportAllContext {
   code: string;
-  ast: Program;
+  ast: ESTree.Program;
   importer: string;
 }
 declare function transformExpandExportAll(options: TransformExpandExportAllOptions): Promise<{
   code: string;
 } | undefined>;
 //#endregion
-export { extractIdentifiers as a, validateNonAsyncFunction as c, transformProxyExport as d, TransformWrapExportFilter as f, transformHoistInlineDirective as g, findDirectives as h, transformServerActionServer as i, TransformProxyExportOptions as l, transformWrapExport as m, TransformExpandExportAllOptions as n, extractNames as o, TransformWrapExportOptions as p, transformExpandExportAll as r, hasDirective as s, TransformExpandExportAllContext as t, transformDirectiveProxyExport as u };
+export { ModuleExportSpecifier as A, TransformModuleExportEffectFilter as C, ModuleExportEntry as D, transformModuleExportEffect as E, findDirectives as F, transformHoistInlineDirective as I, TransformHoistInlineDirectiveMeta as M, TransformHoistInlineDirectiveOptions as N, ModuleExportGroup as O, TransformHoistInlineDirectiveResult as P, TransformModuleExportEffectContext as S, TransformModuleExportEffectResult as T, transformProxyExport as _, TransformServerActionServerResult as a, TransformWrapExportResult as b, extractNames as c, rejectNonAsyncFunction$1 as d, validateNonAsyncFunction as f, transformDirectiveProxyExport as g, TransformProxyExportResult as h, TransformServerActionServerOptions as i, scanModuleExports as j, ModuleExportMeta as k, hasDirective as l, TransformProxyExportOptions as m, TransformExpandExportAllOptions as n, transformServerActionServer as o, TransformProxyExportFilter as p, transformExpandExportAll as r, extractIdentifiers as s, TransformExpandExportAllContext as t, isDirective as u, TransformWrapExportFilter as v, TransformModuleExportEffectOptions as w, transformWrapExport as x, TransformWrapExportOptions as y };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { c as getPluginApi, o as RscPluginManager, r as PluginApi, s as RscPluginOptions, u as vitePluginRsc } from "./plugin-DqLpibhH.js";
+import { c as getPluginApi, o as RscPluginManager, r as PluginApi, s as RscPluginOptions, u as vitePluginRsc } from "./plugin-CKqXjp8D.js";
 export { type PluginApi, type RscPluginManager, type RscPluginOptions, vitePluginRsc as default, getPluginApi };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { r as vitePluginRsc, t as getPluginApi } from "./plugin-C27mwbgw.js";
+import { r as vitePluginRsc, t as getPluginApi } from "./plugin-Cbs9j6lP.js";
 export { vitePluginRsc as default, getPluginApi };

package/dist/{picocolors-CKiBgsDn.js → picocolors-391UXIDd.js}

@@ -1,4 +1,4 @@
-import { a as __commonJSMin } from "./plugin-C27mwbgw.js";
+import { a as __commonJSMin } from "./plugin-Cbs9j6lP.js";
 //#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
 var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	let p = process || {};

package/dist/{plugin-DqLpibhH.d.ts → plugin-CKqXjp8D.d.ts}

@@ -1,4 +1,4 @@
-import { f as TransformWrapExportFilter } from "./index-COzKOTR1.js";
+import { v as TransformWrapExportFilter } from "./index-XXYjyFr6.js";
 import MagicString from "magic-string";
 import { Plugin, ResolvedConfig, Rollup, ViteDevServer, parseAstAsync } from "vite";
 //#region src/plugins/import-environment.d.ts
@@ -160,7 +160,8 @@ type RscPluginOptions = {
    * - Require an entry chunk named "index"
    * - Automatically include client entry deps in each client reference's dependencies
    *
-   * Note: `import.meta.viteRsc.loadBootstrapScriptContent` cannot be used with this option.
+   * Note: `getClientEntryUrl` and `import.meta.viteRsc.loadBootstrapScriptContent`
+   * cannot be used with this option.
    *
    * Use this when you manually handle client entry setup and preloading.
    *
@@ -185,7 +186,7 @@ declare class RuntimeAsset {
   constructor(value: string);
 }
 type AssetsManifest = {
-  bootstrapScriptContent: string | RuntimeAsset;
+  clientEntryUrl?: string | RuntimeAsset;
   clientEntryDeps?: AssetDeps;
   clientReferenceDeps: Record<string, AssetDeps>;
   serverResources?: Record<string, Pick<AssetDeps, "css">>;
@@ -196,7 +197,7 @@ type AssetDeps = {
   css: (string | RuntimeAsset)[];
 };
 type ResolvedAssetsManifest = {
-  bootstrapScriptContent: string;
+  clientEntryUrl?: string;
   clientEntryDeps?: ResolvedAssetDeps;
   clientReferenceDeps: Record<string, ResolvedAssetDeps>;
   serverResources?: Record<string, Pick<ResolvedAssetDeps, "css">>;