@solidjs/vite-plugin 3.0.0-next.38 → 3.0.0-next.40

package/dist/types/src/index.d.ts

@@ -5,7 +5,7 @@ import { type StartOptions } from './ssr/index.js';
 export { devStylePatch } from './dev-manifest.js';
 export { serverFunctions };
 export type { ServerFunctionsOptions };
-export type { ServerFunctionsFilter } from './server-functions/index.js';
+export type { PersistedServerFunctionManifest, ServerFunctionsFilter, } from './server-functions/index.js';
 export type { StartOptions };
 import type { FilterPattern, Plugin } from 'vite';
 /** Possible options for the extensions property */

package/dist/types/src/server-functions/index.d.ts

@@ -135,6 +135,17 @@ export interface ServerFunctionsOptions {
      */
     components?: boolean | 'external';
 }
+/** The persisted manifest's on-disk shape (the array form is the pre-`functions` legacy). */
+export interface PersistedServerFunctionManifest {
+    /** Modules containing server functions, root-relative. */
+    modules: string[];
+    /** Every server function the client build emitted a reference to. */
+    functions: Array<{
+        id: string;
+        name: string;
+        module: string;
+    }>;
+}
 /**
  * The second parameter is internal wiring for the main plugin's
  * `serverFunctions` option: the built-in dev middleware is only installed

package/dist/types/src/ssr/index.d.ts

@@ -119,6 +119,43 @@ export interface StartOptions {
      * @default undefined
      */
     setup?: string;
+    /**
+     * How the generated handler turns a page render into a response body.
+     *
+     * - `'stream'` (default): the document shell flushes as soon as it is
+     *   ready, with `<Loading>` fallbacks in place; boundary content follows
+     *   in later chunks and is swapped in by inline scripts. Best TTFB, but
+     *   a client that never runs JavaScript (crawlers, `curl`, no-JS
+     *   browsers) is left looking at the fallbacks (solidjs/solid#3280).
+     * - `'async'`: the handler awaits the render until every boundary has
+     *   settled and sends one complete document. Nothing has flushed, so
+     *   each resolved boundary is spliced in place of its placeholder — no
+     *   fallback markup, no swap templates or scripts — while hydration data
+     *   still serializes, so JavaScript clients hydrate exactly as before.
+     *   The tradeoffs are inherent: time-to-first-byte waits for the slowest
+     *   boundary, and the whole page buffers in memory before it is sent.
+     *   `deferStream` is moot here (everything defers), and a `Location`
+     *   header written mid-render becomes a real 3xx instead of the
+     *   post-flush script fallback.
+     * - A module path (resolved relative to the Vite root, following the
+     *   `middleware`/`setup` convention — a Vite config cannot serialize a
+     *   closure into the generated handler): the module default-exports
+     *   `(event) => 'stream' | 'async' | Promise<'stream' | 'async'>`, called
+     *   per request inside the request scope after the middleware chain (so
+     *   `event.locals` decoration is visible) — e.g. `'async'` for crawler
+     *   user agents or a `?nojs` flag, `'stream'` for everyone else.
+     *
+     * Hosts driving the handler directly can override all of the above per
+     * call with `handleRequest(request, { renderMode })`; precedence is that
+     * runtime option, then the module function's result, then this static
+     * value. Applies to generated and authored entries alike (an authored
+     * `render()` returning a `renderToStream` result is awaited the same
+     * way). Server mode only — ignored in client mode, where the served
+     * shell has no boundaries to settle.
+     *
+     * @default 'stream'
+     */
+    renderMode?: 'stream' | 'async' | (string & {});
     /**
      * Typed, validated environment variables. A schema file — conventionally
      * `env.ts` (or `env.js`) at the project root, probed automatically —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/vite-plugin",
-  "version": "3.0.0-next.38",
+  "version": "3.0.0-next.40",
   "description": "solid-js integration plugin for Vite",
   "type": "module",
   "engines": {
@@ -83,9 +83,9 @@
   },
   "peerDependencies": {
     "@solidjs/start-devtools": "^1.0.0-next.2",
-    "@solidjs/web": "^2.0.0-rc.0",
+    "@solidjs/web": "^2.0.0-rc.7",
     "@testing-library/jest-dom": "^5.16.6 || ^5.17.0 || ^6.*",
-    "solid-js": "^2.0.0-rc.0",
+    "solid-js": "^2.0.0-rc.7",
     "vite": "^8.0.0 || ^9.0.0"
   },
   "peerDependenciesMeta": {

package/virtual-solid-manifest.d.ts

@@ -49,6 +49,16 @@ declare module "virtual:solid-ssr-handler" {
       context?: Record<string, unknown>;
       /** Status/headers for the HTML response. */
       responseInit?: ResponseInit;
+      /**
+       * Per-call render mode, overriding `start.renderMode` (static value or
+       * per-request module alike). `'stream'` flushes the document shell
+       * with `<Loading>` fallbacks and streams boundary content behind it;
+       * `'async'` awaits the render until every boundary settled and sends
+       * one complete document — no fallbacks, no swap scripts, hydration
+       * data intact — for clients that never run JavaScript. A mid-render
+       * `Location` becomes a real 3xx under `'async'`.
+       */
+      renderMode?: 'stream' | 'async';
       /**
        * Extra fields spread into the request event at creation — the public
        * wrapper→event extension seam. Conventionally `nativeEvent` carries