@solidjs/vite-plugin 3.0.0-next.39 → 3.0.0-next.41

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

@@ -237,4 +237,12 @@ export type ViteManifest = Record<string, {
     imports?: string[];
 }> & {
     _base?: string;
+    /**
+     * Manifest key of the client entry the document boots (the plugin's
+     * injected start-mode entry, or the single configured input). Absent when
+     * the plugin cannot tell the application entry apart from other configured
+     * inputs; its record is also serialized first so first-`isEntry` scans
+     * agree with it.
+     */
+    _entry?: string;
 };

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 —
@@ -213,4 +250,12 @@ export declare function startServe(options: StartOptions, internal?: {
      * declines HMR for that module's client compile (solidjs/solid#3151).
      */
     onDocumentResolved?: (documentPath: string | null) => void;
+    /**
+     * Reports the client entry this plugin adds to the client build's input
+     * (the virtual generated entry id, or the authored entry's absolute
+     * path) back to the main plugin, which stamps it as `_entry` on
+     * `virtual:solid-manifest` so the built handler and the runtime never
+     * have to guess the entry among other configured inputs (#353).
+     */
+    onClientEntryResolved?: (entryId: string) => void;
 }): Plugin[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/vite-plugin",
-  "version": "3.0.0-next.39",
+  "version": "3.0.0-next.41",
   "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