@foldkit/vite-plugin 0.26.1-canary.085b787da0a5 → 0.26.1-canary.6bd9ee8e728c

package/README.md

@@ -65,53 +65,24 @@ With this set, the dev server converts HTML page requests to Web `Request` value
 
 Vite retains ownership of configured proxy routes before Foldkit handles application requests. Vite's `server.cors` option applies to Vite-owned source modules, assets, and HMR. It does not add headers to application responses or answer their preflights. Preflight ownership follows `Access-Control-Request-Method`, so a preflight for an application `POST` reaches `renderPage` even when its path looks like an asset. An `OPTIONS` request without both `Origin` and `Access-Control-Request-Method` is not a preflight and also reaches `renderPage`. Define application CORS in `renderPage`, where development and the deployed host share one policy. Vite's `allowedHosts` check runs before proxy and application handling, including `OPTIONS` and methods the Web `Request` API cannot represent.
 
-## Server-rendered documents
-
-With `ssr.build`, the client input is a script and the server entry produces the complete HTML document. Configure the script beside the server entry:
-
-```typescript
-foldkit({
-  ssr: {
-    clientEntry: '/src/entry.ts',
-    serverEntry: '/src/entry.server.ts',
-    build: true,
-  },
-})
-```
-
-Import CSS from the client script. Export `renderDocument` alongside `renderPage` in the server entry:
-
-```typescript
-export const renderDocument = Server.renderDocument
-```
-
-`Server.renderDocument(application, assets, options)` assembles the document with the application's title, language, direction, canonical URL, and Open Graph URL. `assets` contains the emitted `entryScript`, ordered `stylesheets`, and `modulePreloads`. The plugin collects static imports and their CSS, leaves lazy imports to Vite's runtime, and supplies the same assets to request-time rendering and prerendering. The default document includes UTF-8 and viewport metadata. Wrap the helper to set a default `lang` or add trusted author-owned `head` markup, such as a favicon. Never interpolate unescaped request data into `head`.
-
-The client build starts from a script rather than HTML. `index.html` appears in the client output only when prerendering generates `/`. The build refuses an existing root document copied from `publicDir`, emitted by another plugin, or left by an earlier build when `emptyOutDir` is disabled. Remove the source `index.html` when migrating an SSR build, move its stylesheet links into client imports, and move document tags into `renderDocument`. Build-time `transformIndexHtml` hooks do not run with a script input. In development, Vite transforms the rendered document for HMR and dev HTML hooks. `containerId` belongs only to a template-based custom host and cannot be combined with `clientEntry`.
-
-Use a root-relative `clientEntry`, such as `/src/entry.ts`, and an absolute-path or full-URL Vite `base`. Relative bases (`''` and `'./'`) are rejected because their asset URLs would resolve differently on nested routes. `modulePreload` configuration and absolute `experimental.renderBuiltUrl` results apply to the generated document; relative and runtime `renderBuiltUrl` results are rejected.
-
-The standalone build plugin takes `foldkitBuild(serverEntry, { clientEntry, ...options })`. Omitting `clientEntry` and `ssr.build` selects the template-based development host for a custom build pipeline. Hosts that own an HTML template can use the lower-level `injectIntoTemplate`, `toResponse`, and `handleRequest(request, { template, renderPage })` APIs.
-
 ## Foldkit package resolution
 
 Each module graph must load one Foldkit copy. The plugin configures Vite for that:
 
 - `resolve.dedupe` lists `foldkit`, `@foldkit/ui`, and `@foldkit/devtools`, each only when it resolves from the application root.
-- In server builds and in every server environment of the dev server, the plugin bundles those three packages, plus every installed package whose `dependencies` or `peerDependencies` include `foldkit` or an `@foldkit/*` package, such as `@foldkit/markdown`. The plugin lists them in `resolve.noExternal`, which Vite applies to every environment, and in `ssr.noExternal`. In a Node server environment of the dev server, these packages run through Vite's module runner instead of Node's own import. An explicit `ssr.external` or `resolve.external` entry still keeps a package external.
+- Server builds and the dev server's server render bundle those three packages, plus every installed package whose `dependencies` or `peerDependencies` include `foldkit` or an `@foldkit/*` package, such as `@foldkit/markdown`. In the dev server, these `ssr.noExternal` packages run through Vite's module runner instead of Node's own import. An explicit `ssr.external` entry still keeps a package external.
 - The plugin finds these packages by crawling from the application's `package.json`. It follows the application's `dependencies` and `devDependencies`, then the `dependencies` of each package it bundles, plus the `devDependencies` of a bundled package that is a private workspace package.
-- The plugin excludes `foldkit` from dependency pre-bundling in every environment, so the build id transform runs on it. It also pre-bundles the Effect entries Foldkit imports in every environment whose optimizer is enabled, for example a Cloudflare Worker environment, so Foldkit and the application share one Effect instance. Applications need no `optimizeDeps` settings for Foldkit.
 
-A package the crawl does not reach stays external. For example: a peer the application does not declare, or a package reached only through a package that does not depend on Foldkit. Such a package loads a second Foldkit copy from `node_modules` at runtime. Declare it in the application's `package.json`, or add it to `resolve.noExternal`, which Vite applies to every environment:
+A package the crawl does not reach stays external. For example: a peer the application does not declare, or a package reached only through a package that does not depend on Foldkit. Such a package loads a second Foldkit copy from `node_modules` at runtime. Declare it in the application's `package.json`, or add it to `ssr.noExternal`:
 
 ```typescript
 export default defineConfig({
   plugins: [foldkit()],
-  resolve: { noExternal: ['foldkit-component-library'] },
+  ssr: { noExternal: ['foldkit-component-library'] },
 })
 ```
 
-Vitest copies each environment's `resolve.noExternal` into `server.deps.inline`. A Vitest config that includes `foldkit()` therefore also inlines the crawled packages in tests.
+Vitest copies SSR `noExternal` into `server.deps.inline`. A Vitest config that includes `foldkit()` therefore also inlines the crawled packages in tests.
 
 ## Completed build metadata
 

package/dist/build.d.ts

@@ -15,15 +15,25 @@ export type FoldkitPrerenderOptions = Readonly<{
      * from `Request.url`, in which case it should match the published origin.
      */
     origin?: string;
+    /**
+     * The `id` of the placeholder element in `index.html` the rendered markup
+     * replaces. Defaults to `'root'`, and the aggregate plugin passes whatever
+     * `ssr.containerId` names, so a renamed container is renamed once.
+     */
+    containerId?: string;
 }>;
 /** How `vite build` builds a server entry and what it generates from it. */
 export type FoldkitBuildOptions = Readonly<{
-    /** Root-relative browser script entry resolved by Vite, such as `'/src/entry.ts'`. Import stylesheets from this module. */
-    clientEntry: string;
     /** Where the browser build is written. */
     clientOutDir?: string;
     /** Where the server build is written. */
     serverOutDir?: string;
+    /**
+     * The `id` of the empty container in `index.html` the fetch handler
+     * replaces. Defaults to `'root'`. The aggregate plugin copies
+     * `ssr.containerId` here.
+     */
+    containerId?: string;
     /**
      * Generate static HTML for a set of URLs after both builds. `true` takes the
      * paths from the entry's `prerenderPaths` export.
@@ -124,9 +134,8 @@ export declare const renderTargetFor: (clientDirectory: string, path: string, or
  *
  * Vite builds both environments, so a deployment target that runs `vite build`
  * gets the browser and server bundles. The `fetch` handler and generated pages
- * use the server entry's `renderDocument` export with the emitted browser assets.
- * The browser build has a script input and emits no HTML until prerendering.
- * The server bundle's default export is `{ fetch }`.
+ * use the HTML emitted by the browser build, but the unrendered template is not
+ * published with the assets. The server bundle's default export is `{ fetch }`.
  */
-export declare const foldkitBuild: (serverEntry: string, options: FoldkitBuildOptions) => Plugin<FoldkitBuildApi>;
+export declare const foldkitBuild: (serverEntry: string, options?: FoldkitBuildOptions) => Plugin<FoldkitBuildApi>;
 //# sourceMappingURL=build.d.ts.map

package/dist/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,MAAM,EAAE,MAAM,QAAQ,CAAA;AAS1C,OAAO,QAA8B,MAAM,WAAW,CAAA;AAEtD,OAAO,KAAK,EAGV,MAAM,EAGP,MAAM,MAAM,CAAA;AAEb,mEAAmE;AACnE,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C;;;OAGG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC7B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAC,CAAA;AAEF,4EAA4E;AAC5E,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,2HAA2H;IAC3H,WAAW,EAAE,MAAM,CAAA;IACnB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,yCAAyC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,uBAAuB,CAAA;CAC9C,CAAC,CAAA;AAEF,6EAA6E;AAC7E,eAAO,MAAM,uBAAuB,0BAA0B,CAAA;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;OAIG;;IAEH;;;;OAIG;;IAEH,+EAA+E;;IAE/E,2DAA2D;;IAE3D,6EAA6E;;EAE7E,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,iFAAiF;AACjF,eAAO,MAAM,oBAAoB;IAC/B,+CAA+C;;IAE/C,kDAAkD;;IAElD,iDAAiD;;IAEjD,kDAAkD;;IAElD,0DAA0D;;QAtC1D;;;;WAIG;;QAEH;;;;WAIG;;QAEH,+EAA+E;;QAE/E,2DAA2D;;QAE3D,6EAA6E;;;EAwB7E,CAAA;AAEF,sEAAsE;AACtE,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,2DAA2D;AAC3D,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAA;IACnB,uDAAuD;IACvD,aAAa,EAAE,OAAO,uBAAuB,CAAA;IAC7C;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;CAC7C,CAAC,CAAA;AAcF,eAAO,MAAM,YAAY,SACjB,MAAM,aACD,MAAM,YACR,OAAO,QAAQ,KACvB,MAQF,CAAA;AA6FD,eAAO,MAAM,eAAe,oBACT,MAAM,QACjB,MAAM,UACJ,MAAM,YACL,OAAO,QAAQ,KACvB,QAAQ,CAAC;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CA0CrC,CAAA;AAqLD;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,gBACV,MAAM,WACV,mBAAmB,KAC3B,MAAM,CAAC,eAAe,CAwSxB,CAAA"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAI/B,OAAO,QAA8B,MAAM,WAAW,CAAA;AAEtD,OAAO,KAAK,EAGV,MAAM,EAEP,MAAM,MAAM,CAAA;AAEb,mEAAmE;AACnE,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C;;;OAGG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC7B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAC,CAAA;AAEF,4EAA4E;AAC5E,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,0CAA0C;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,yCAAyC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,uBAAuB,CAAA;CAC9C,CAAC,CAAA;AAEF,6EAA6E;AAC7E,eAAO,MAAM,uBAAuB,0BAA0B,CAAA;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;OAIG;;IAEH;;;;OAIG;;IAEH,+EAA+E;;IAE/E,2DAA2D;;IAE3D,6EAA6E;;EAE7E,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,iFAAiF;AACjF,eAAO,MAAM,oBAAoB;IAC/B,+CAA+C;;IAE/C,kDAAkD;;IAElD,iDAAiD;;IAEjD,kDAAkD;;IAElD,0DAA0D;;QAtC1D;;;;WAIG;;QAEH;;;;WAIG;;QAEH,+EAA+E;;QAE/E,2DAA2D;;QAE3D,6EAA6E;;;EAwB7E,CAAA;AAEF,sEAAsE;AACtE,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE,2DAA2D;AAC3D,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAA;IACnB,uDAAuD;IACvD,aAAa,EAAE,OAAO,uBAAuB,CAAA;IAC7C;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;CAC7C,CAAC,CAAA;AAcF,eAAO,MAAM,YAAY,SACjB,MAAM,aACD,MAAM,YACR,OAAO,QAAQ,KACvB,MAQF,CAAA;AAyFD,eAAO,MAAM,eAAe,oBACT,MAAM,QACjB,MAAM,UACJ,MAAM,YACL,OAAO,QAAQ,KACvB,QAAQ,CAAC;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CA0CrC,CAAA;AAsFD;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,gBACV,MAAM,YACV,mBAAmB,KAC3B,MAAM,CAAC,eAAe,CAqPxB,CAAA"}

package/dist/build.js

@@ -1,7 +1,6 @@
-import { Predicate, Schema } from 'effect';
-import { createHash, randomUUID } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { Schema } from 'effect';
+import { randomUUID } from 'node:crypto';
+import { mkdir, writeFile } from 'node:fs/promises';
 import nodePath, { dirname, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 /** Vite module id of the fetch handler Foldkit emits as the server entry. */
@@ -65,15 +64,12 @@ export const manifestPath = (root, directory, pathApi = nodePath) => {
     return related.split(pathApi.sep).join('/');
 };
 const MANIFEST_FILE_NAME = 'foldkit.build.json';
+const TEMPLATE_FILE_NAME = 'index.html';
 const DEFAULT_CLIENT_OUT_DIR = 'dist/client';
 const DEFAULT_SERVER_OUT_DIR = 'dist/server';
 const DEFAULT_PRERENDER_ORIGIN = 'http://localhost';
 const FETCH_CHUNK_NAME = 'fetch';
 const RESOLVED_FETCH_MODULE_ID = `\0${FOLDKIT_FETCH_MODULE_ID}`;
-const CLIENT_MODULE_ID = 'virtual:foldkit/client';
-const RESOLVED_CLIENT_MODULE_ID = `\0${CLIENT_MODULE_ID}`;
-const CLIENT_CHUNK_NAME = 'app';
-const VITE_CONSOLIDATED_CSS_ORIGINAL_NAME = 'style.css';
 // The chunk built from the configured entry, by name rather than by position.
 //
 // An SSR environment can carry more than one input, and prerendering imports
@@ -172,104 +168,39 @@ const prerenderOptionsFrom = (prerender) => {
     }
     return prerender === true ? {} : prerender;
 };
-const documentHash = (document) => createHash('sha256').update(document).digest('hex');
-const collectDocumentAssets = (outputs, config) => {
-    const entryFile = serverEntryFile(outputs, CLIENT_CHUNK_NAME);
-    const chunks = new Map(outputs.flatMap(output => output.type === 'chunk' ? [[output.fileName, output]] : []));
-    const visited = new Set();
-    const stylesheets = new Set();
-    const modulePreloads = new Set();
-    const visit = (fileName) => {
-        if (visited.has(fileName)) {
-            return;
-        }
-        visited.add(fileName);
-        const chunk = chunks.get(fileName);
-        if (chunk === undefined) {
-            return;
-        }
-        for (const imported of chunk.imports) {
-            visit(imported);
-        }
-        for (const stylesheet of chunk.viteMetadata?.importedCss ?? []) {
-            stylesheets.add(stylesheet);
-        }
-        if (fileName !== entryFile) {
-            modulePreloads.add(fileName);
-        }
-    };
-    visit(entryFile);
-    if (!config.build.cssCodeSplit) {
-        for (const output of outputs) {
-            if (output.type === 'asset' &&
-                output.originalFileNames.includes(VITE_CONSOLIDATED_CSS_ORIGINAL_NAME)) {
-                stylesheets.add(output.fileName);
-            }
-        }
-    }
-    const { modulePreload } = config.build;
-    const preloadFiles = modulePreload === false
-        ? []
-        : (modulePreload.resolveDependencies?.(entryFile, [...modulePreloads], {
-            hostId: 'index.html',
-            hostType: 'html',
-        }) ?? [...modulePreloads]);
-    const assetUrl = (fileName) => {
-        if (/^([a-z]+:)?\/\//.test(fileName)) {
-            return fileName;
-        }
-        const builtUrl = config.experimental.renderBuiltUrl?.(fileName, {
-            hostId: 'index.html',
-            hostType: 'html',
-            type: 'asset',
-            ssr: false,
-        });
-        if (Predicate.isString(builtUrl)) {
-            if (!builtUrl.startsWith('/') && !/^https?:\/\//.test(builtUrl)) {
-                throw new Error('[foldkit] renderBuiltUrl must return an absolute URL or root-relative URL for document assets.');
-            }
-            return builtUrl;
-        }
-        if (builtUrl?.runtime !== undefined || builtUrl?.relative === true) {
-            throw new Error('[foldkit] document assets cannot use runtime or relative renderBuiltUrl results.');
-        }
-        return `${config.base}${encodeURI(fileName).replace(/[?#]/g, encodeURIComponent)}`;
-    };
-    return Object.freeze({
-        entryScript: assetUrl(entryFile),
-        stylesheets: Object.freeze([...stylesheets].map(assetUrl)),
-        modulePreloads: Object.freeze(preloadFiles.map(assetUrl)),
-    });
-};
-const fetchModuleSource = (serverEntry, assets) => {
+const fetchModuleSource = (serverEntry, template, containerId) => {
+    const containerLiteral = containerId === undefined ? 'undefined' : JSON.stringify(containerId);
     // NOTE: `export *` re-exports whatever the application entry actually names,
     // so a missing `prerenderPaths` is absent rather than a Vite undefined-import
     // warning.
     return `${[
         `import { handleRequest } from 'foldkit/experimental/server'`,
-        `import { renderDocument } from ${JSON.stringify(serverEntry)}`,
         `import * as server from ${JSON.stringify(serverEntry)}`,
         `export * from ${JSON.stringify(serverEntry)}`,
-        `const assets = ${JSON.stringify(assets)}`,
-        `Object.freeze(assets.stylesheets)`,
-        `Object.freeze(assets.modulePreloads)`,
-        `Object.freeze(assets)`,
+        `const template = ${JSON.stringify(template)}`,
+        `const containerId = ${containerLiteral}`,
         `export default {`,
         `  fetch(request) {`,
         `    return handleRequest(request, {`,
         `      renderPage: server.renderPage,`,
-        `      renderDocument: application => renderDocument(application, assets),`,
+        `      template,`,
+        `      containerId,`,
         `    })`,
         `  },`,
         `}`,
         ``,
     ].join('\n')}`;
 };
-const assetsForFetchModule = (assets) => {
-    if (assets === undefined) {
-        throw new Error('[foldkit] the browser build has not emitted its script entry. Build the "client" environment before "ssr" so the document can reference the emitted assets.');
+// The template is what the browser build emitted in this same `vite build`,
+// never a file on disk: `dist/client/index.html` could only be the previous
+// build's shell with its old asset hashes, and the source `index.html` still
+// names `/src/entry.ts`. Either would bundle into a handler that serves a
+// page which cannot hydrate, from a build that reported success.
+const templateForFetchModule = (capturedTemplate) => {
+    if (capturedTemplate === undefined) {
+        throw new Error(`[foldkit] the browser build has not emitted ${TEMPLATE_FILE_NAME}, so the fetch handler has no template to render into. Build the "client" environment before "ssr", and give the client an HTML entry.`);
     }
-    return assets;
+    return capturedTemplate;
 };
 /**
  * Builds a Web `fetch` handler alongside the browser build, and generates
@@ -277,21 +208,21 @@ const assetsForFetchModule = (assets) => {
  *
  * Vite builds both environments, so a deployment target that runs `vite build`
  * gets the browser and server bundles. The `fetch` handler and generated pages
- * use the server entry's `renderDocument` export with the emitted browser assets.
- * The browser build has a script input and emits no HTML until prerendering.
- * The server bundle's default export is `{ fetch }`.
+ * use the HTML emitted by the browser build, but the unrendered template is not
+ * published with the assets. The server bundle's default export is `{ fetch }`.
  */
-export const foldkitBuild = (serverEntry, options) => {
+export const foldkitBuild = (serverEntry, options = {}) => {
     const state = {};
     let metadata;
     const clientOutDir = options.clientOutDir ?? DEFAULT_CLIENT_OUT_DIR;
     const serverOutDir = options.serverOutDir ?? DEFAULT_SERVER_OUT_DIR;
     const prerender = prerenderOptionsFrom(options.prerender ?? false);
+    const containerId = prerender?.containerId ?? options.containerId;
     // Prerendering imports the server bundle and runs it in the build process,
     // with the build's own privileges. That module is the application's own code
     // and its dependencies, built from the configured entry, and is trusted on
     // exactly those terms. Nothing here is imported when prerendering is off.
-    const generatePages = async (builder, clientDirectory, serverDirectory, entryFileName) => {
+    const generatePages = async (builder, template, clientDirectory, serverDirectory, entryFileName) => {
         if (prerender === undefined) {
             return [];
         }
@@ -311,19 +242,15 @@ export const foldkitBuild = (serverEntry, options) => {
         if (paths === undefined) {
             throw new Error(`[foldkit] cannot generate pages: "${entry}" exports no prerenderPaths and the build configured no paths.`);
         }
-        if (!Predicate.isFunction(entry.renderDocument)) {
-            throw new Error(`[foldkit] "${entryFileName}" exports no renderDocument function.`);
-        }
-        const assets = assetsForFetchModule(state.assets);
+        const { injectIntoTemplate } = await import('foldkit/experimental/server');
         for (const path of paths) {
             const { url, file } = renderTargetFor(clientDirectory, path, origin);
             const result = await entry.renderPage(new Request(url));
-            const html = entry.renderDocument(renderedApplication(path, result), assets);
+            const html = injectIntoTemplate(template(), renderedApplication(path, result), prerender.containerId === undefined
+                ? undefined
+                : { containerId: prerender.containerId });
             await mkdir(dirname(file), { recursive: true });
             await writeFile(file, html);
-            if (path === '/') {
-                state.prerenderedRootHash = documentHash(html);
-            }
             builder.config.logger.info(`  generated ${path}`);
         }
         return paths;
@@ -337,16 +264,15 @@ export const foldkitBuild = (serverEntry, options) => {
         if (state.serverEntryFile === undefined) {
             throw new Error('[foldkit] the server environment produced no entry chunk, so there is nothing to deploy or generate from.');
         }
-        const rootDocumentPath = resolve(clientDirectory, 'index.html');
-        if (existsSync(rootDocumentPath) &&
-            documentHash(await readFile(rootDocumentPath, 'utf8')) !==
-                state.prerenderedRootHash) {
-            throw new Error('[foldkit] the browser output contains index.html before prerendering. Remove it from publicDir or the plugin that emits it, and clear stale output when emptyOutDir is disabled. Only prerendering may generate the root document in an ssr.build output.');
-        }
-        const prerendered = await generatePages(builder, clientDirectory, serverDirectory, state.serverEntryFile);
-        if (!prerendered.includes('/') && existsSync(rootDocumentPath)) {
-            throw new Error('[foldkit] index.html remains in the browser output, but this build did not prerender "/". Clear the previous root document before building without it.');
-        }
+        // Read only when a page is actually generated: a build that generates
+        // nothing has no use for an HTML entry and must not require one.
+        const template = () => {
+            if (state.template === undefined) {
+                throw new Error(`[foldkit] the browser build emitted no ${TEMPLATE_FILE_NAME} to generate pages from. Prerendering needs an HTML entry.`);
+            }
+            return state.template;
+        };
+        const prerendered = await generatePages(builder, template, clientDirectory, serverDirectory, state.serverEntryFile);
         const manifest = FoldkitBuildManifest.make({
             schemaVersion: MANIFEST_SCHEMA_VERSION,
             client: manifestPath(builder.config.root, clientDirectory),
@@ -385,17 +311,9 @@ export const foldkitBuild = (serverEntry, options) => {
             order: 'pre',
             handler() {
                 if (this.environment.name === 'client') {
-                    delete state.assets;
+                    delete state.template;
                     delete state.serverEntryFile;
                     metadata = undefined;
-                    const { input } = this.environment.config.build.rolldownOptions;
-                    const inputs = Predicate.isString(input)
-                        ? [input]
-                        : Object.values(input ?? {});
-                    if (!inputs.includes(CLIENT_MODULE_ID) ||
-                        inputs.some(entry => /\.html(?:[?#]|$)/.test(entry))) {
-                        throw new Error('[foldkit] ssr.build owns the browser script input. Configure ssr.clientEntry instead of an HTML input or a replacement client input.');
-                    }
                 }
                 else if (this.environment.name === 'ssr') {
                     delete state.serverEntryFile;
@@ -404,27 +322,20 @@ export const foldkitBuild = (serverEntry, options) => {
             },
         },
         resolveId(id) {
-            if (id === CLIENT_MODULE_ID) {
-                return RESOLVED_CLIENT_MODULE_ID;
-            }
             if (id === FOLDKIT_FETCH_MODULE_ID) {
                 return RESOLVED_FETCH_MODULE_ID;
             }
             return undefined;
         },
         load(id) {
-            if (id === RESOLVED_CLIENT_MODULE_ID) {
-                const { modulePreload } = this.environment.config.build;
-                const polyfill = modulePreload !== false && modulePreload.polyfill
-                    ? "import 'vite/modulepreload-polyfill'\n"
-                    : '';
-                return `${polyfill}import ${JSON.stringify(options.clientEntry)}\n`;
-            }
             if (id !== RESOLVED_FETCH_MODULE_ID) {
                 return;
             }
-            return fetchModuleSource(serverEntry, assetsForFetchModule(state.assets));
+            const template = templateForFetchModule(state.template);
+            return fetchModuleSource(serverEntry, template, containerId);
         },
+        // NOTE: `order: 'post'` because Vite's own HTML plugin emits `index.html`
+        // from a `generateBundle` of its own; post is guaranteed to run after it.
         generateBundle: {
             order: 'post',
             handler(_options, bundle) {
@@ -435,15 +346,17 @@ export const foldkitBuild = (serverEntry, options) => {
                 if (this.environment.name !== 'client') {
                     return;
                 }
-                state.assets = collectDocumentAssets(Object.values(bundle), this.environment.config);
+                const html = bundle[TEMPLATE_FILE_NAME];
+                if (html === undefined || html.type !== 'asset') {
+                    return;
+                }
+                state.template = String(html.source);
+                delete bundle[TEMPLATE_FILE_NAME];
             },
         },
         config: userConfig => {
             const client = {
-                build: {
-                    outDir: clientOutDir,
-                    rolldownOptions: { input: { [CLIENT_CHUNK_NAME]: CLIENT_MODULE_ID } },
-                },
+                build: { outDir: clientOutDir },
             };
             const ssr = {
                 build: {
@@ -474,16 +387,6 @@ export const foldkitBuild = (serverEntry, options) => {
                 }
                 : { environments: { client, ssr } };
         },
-        configResolved(config) {
-            if (config.base === '' || config.base === './') {
-                throw new Error('[foldkit] ssr.build requires an absolute URL or root-relative base, such as "/" or "/app/". A relative base cannot locate browser assets consistently across server-rendered routes.');
-            }
-            if (!options.clientEntry?.startsWith('/') ||
-                options.clientEntry.startsWith('//') ||
-                /\.html(?:[?#]|$)/.test(options.clientEntry)) {
-                throw new Error("[foldkit] ssr.build requires clientEntry to name a browser script. Move stylesheet imports into that script and document markup into the server entry's renderDocument export.");
-            }
-        },
         // The composable finalization point. `order: 'post'` runs this after the
         // config-level orchestrator — the host's, or the default above — no matter
         // where this plugin sits in the plugin list, which a wrapped

package/dist/foldkitPackages.d.ts

@@ -12,6 +12,6 @@ export declare const isFoldkitSingletonPackageSpecifier: (specifier: string) =>
  */
 export declare const crawlFoldkitPackages: (root: string, isBuild: boolean, viteUserConfig: UserConfig) => Promise<Readonly<{
     dedupe: Array<string>;
-    noExternal: Array<string>;
+    ssrNoExternal: Array<string>;
 }>>;
 //# sourceMappingURL=foldkitPackages.d.ts.map

package/dist/foldkitPackages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foldkitPackages.d.ts","sourceRoot":"","sources":["../src/foldkitPackages.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,UAAU,EAA0B,MAAM,MAAM,CAAA;AAS9D;;;;GAIG;AACH,eAAO,MAAM,kCAAkC,cAClC,MAAM,KAChB,OAKA,CAAA;AA8CH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,SACzB,MAAM,WACH,OAAO,kBACA,UAAU,KACzB,OAAO,CAAC,QAAQ,CAAC;IAAE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CAoCxE,CAAA"}
+{"version":3,"file":"foldkitPackages.d.ts","sourceRoot":"","sources":["../src/foldkitPackages.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,UAAU,EAA0B,MAAM,MAAM,CAAA;AAS9D;;;;GAIG;AACH,eAAO,MAAM,kCAAkC,cAClC,MAAM,KAChB,OAKA,CAAA;AA8CH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,SACzB,MAAM,WACH,OAAO,kBACA,UAAU,KACzB,OAAO,CACR,QAAQ,CAAC;IAAE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAAC,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CAqClE,CAAA"}

package/dist/foldkitPackages.js

@@ -58,11 +58,11 @@ export const crawlFoldkitPackages = async (root, isBuild, viteUserConfig) => {
         viteUserConfig,
         isSemiFrameworkPkgByJson: dependsOnFoldkit,
     });
-    const noExternal = Array.dedupe([
+    const ssrNoExternal = Array.dedupe([
         ...FOLDKIT_SINGLETON_PACKAGES,
         ...crawl.ssr.noExternal,
     ]);
     const maybeResolvableSingletons = await Promise.all(Array.map(FOLDKIT_SINGLETON_PACKAGES, async (packageName) => pipe(await findDepPkgJsonPath(packageName, crawlRoot), Option.fromUndefinedOr, Option.as(packageName))));
     const dedupe = Array.getSomes(maybeResolvableSingletons);
-    return { dedupe, noExternal };
+    return { dedupe, ssrNoExternal };
 };

package/dist/index.d.ts

@@ -25,10 +25,7 @@ export type FoldkitPluginOptions = Readonly<{
      * `ssr.serverEntry`. When `undefined` (the default), the dev server
      * serves the client entry only.
      */
-    ssr?: Omit<FoldkitSsrOptions, 'buildId' | 'quietStandDown' | 'clientEntry' | 'containerId'> & (Readonly<{
-        /** Root-relative browser script for the server entry's code-rendered document. */
-        clientEntry: string;
-        containerId?: never;
+    ssr?: Omit<FoldkitSsrOptions, 'buildId' | 'quietStandDown'> & Readonly<{
         /**
          * Build a Web `fetch` handler alongside the browser build, and generate
          * static HTML from the server entry, inside this project's own
@@ -38,13 +35,8 @@ export type FoldkitPluginOptions = Readonly<{
          *
          * When this is absent, `vite build` builds the browser bundle only.
          */
-        build?: boolean | Omit<FoldkitBuildOptions, 'clientEntry'>;
-    }> | Readonly<{
-        /** Use a custom template-based development and build pipeline. */
-        clientEntry?: never;
-        containerId?: string;
-        build?: false;
-    }>);
+        build?: boolean | FoldkitBuildOptions;
+    }>;
     /**
      * An explicit identity for the deployment this build belongs to. Foldkit
      * normally generates an opaque identity when one Vite app build coordinates

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA6CA,OAAO,KAAK,EAGV,MAAM,EAIP,MAAM,MAAM,CAAA;AAOb,OAAO,EAAE,KAAK,mBAAmB,EAAgB,MAAM,YAAY,CAAA;AAKnE,OAAO,EAAE,KAAK,iBAAiB,EAAc,MAAM,UAAU,CAAA;AAG7D,OAAO,EAAE,KAAK,eAAe,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACzE,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,YAAY,GACb,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,iBAAiB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EACL,KAAK,2BAA2B,EAChC,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,mBAAmB,CAAA;AAE1B,6CAA6C;AAC7C,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;IAChC;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,IAAI,CACR,iBAAiB,EACjB,SAAS,GAAG,gBAAgB,GAAG,aAAa,GAAG,aAAa,CAC7D,GACC,CACI,QAAQ,CAAC;QACP,kFAAkF;QAClF,WAAW,EAAE,MAAM,CAAA;QACnB,WAAW,CAAC,EAAE,KAAK,CAAA;QACnB;;;;;;;;WAQG;QACH,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC,mBAAmB,EAAE,aAAa,CAAC,CAAA;KAC3D,CAAC,GACF,QAAQ,CAAC;QACP,kEAAkE;QAClE,WAAW,CAAC,EAAE,KAAK,CAAA;QACnB,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,KAAK,CAAC,EAAE,KAAK,CAAA;KACd,CAAC,CACL,CAAA;IACH;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAC,CAAA;AAg6BF,eAAO,MAAM,OAAO,aAAa,oBAAoB,KAAQ,KAAK,CAAC,MAAM,CA+IxE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA6CA,OAAO,KAAK,EAEV,MAAM,EAIP,MAAM,MAAM,CAAA;AAOb,OAAO,EAAE,KAAK,mBAAmB,EAAgB,MAAM,YAAY,CAAA;AAKnE,OAAO,EAAE,KAAK,iBAAiB,EAAc,MAAM,UAAU,CAAA;AAG7D,OAAO,EAAE,KAAK,eAAe,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACzE,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,YAAY,GACb,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,iBAAiB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC7D,OAAO,EACL,KAAK,2BAA2B,EAChC,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,mBAAmB,CAAA;AAE1B,6CAA6C;AAC7C,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;IAChC;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,SAAS,GAAG,gBAAgB,CAAC,GACzD,QAAQ,CAAC;QACP;;;;;;;;WAQG;QACH,KAAK,CAAC,EAAE,OAAO,GAAG,mBAAmB,CAAA;KACtC,CAAC,CAAA;IACJ;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAC,CAAA;AAs6BF,eAAO,MAAM,OAAO,aAAa,oBAAoB,KAAQ,KAAK,CAAC,MAAM,CAyHxE,CAAA"}

package/dist/index.js

@@ -19,12 +19,12 @@ export { FOLDKIT_FETCH_MODULE_ID, FoldkitBuildManifest, FoldkitBuildMetadata, fo
 export { foldkitSsr } from './ssr.js';
 export { foldkitViewIdentity, transformViewIdentity, } from './viewIdentity.js';
 // NOTE: Vite does not scan imports through `foldkit` because the plugin
-// excludes the package from optimization in every environment. A consumer can
-// import only Effect subpaths while Foldkit's compiled distribution imports the
-// bare barrel, so include both the barrel and every top-level namespace Foldkit
-// imports. This keeps them in one optimized dependency graph. Over-inclusion is
-// harmless; under-inclusion is the bug. `scripts/check-effect-prebundle.ts`
-// keeps the entries in sync with Foldkit's source and runs in `pnpm check`.
+// excludes the package from optimization. A consumer can import only Effect
+// subpaths while Foldkit's compiled distribution imports the bare barrel, so
+// include both the barrel and every top-level namespace Foldkit imports. This
+// keeps them in one optimized dependency graph. Over-inclusion is harmless;
+// under-inclusion is the bug. `scripts/check-effect-prebundle.ts` keeps the
+// entries in sync with Foldkit's source and runs in `pnpm check`.
 const FORCE_INCLUDED_EFFECT_ENTRIES = [
     'effect',
     'effect/Array',
@@ -70,16 +70,6 @@ const FORCE_INCLUDED_EFFECT_ENTRIES = [
     'effect/SubscriptionRef',
     'effect/Types',
 ];
-// NOTE: Adding includes to an environment whose optimizer is otherwise disabled
-// turns on Vite's explicit optimizer, which would pre-bundle Effect in Vite's
-// default Node `ssr` environment.
-const shouldForceEffectEntries = (name, config) => {
-    const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
-    const isClientEnvironment = consumer === 'client';
-    const isDiscoveryEnabled = config.optimizeDeps?.noDiscovery === false;
-    const isExplicitOptimizationEnabled = Array.isArrayNonEmpty(config.optimizeDeps?.include ?? []);
-    return (isClientEnvironment || isDiscoveryEnabled || isExplicitOptimizationEnabled);
-};
 const Event = Data.taggedEnum();
 const makeState = Effect.gen(function* () {
     const preservedModels = yield* Ref.make(HashMap.empty());
@@ -484,6 +474,27 @@ const main = (server, events, options) => Effect.gen(function* () {
  * an array; Vite flattens nested plugin arrays, so `plugins: [foldkit()]`
  * keeps working.
  */
+// The container is named once, on `ssr`, and reaches both the dev host and the
+// build from there. A `build.prerender` that names its own wins, so a project
+// that needs them to differ still can.
+const withContainerId = (build, containerId) => {
+    const options = build === true ? {} : build;
+    if (containerId === undefined) {
+        return options;
+    }
+    const withContainer = { ...options, containerId };
+    if (options.prerender === undefined) {
+        return withContainer;
+    }
+    const prerender = options.prerender === true ? {} : options.prerender;
+    if (prerender === false) {
+        return withContainer;
+    }
+    return {
+        ...withContainer,
+        prerender: { containerId, ...prerender },
+    };
+};
 const relayRegistryLayer = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer, NodeCrypto.layer);
 export const foldkit = (options = {}) => {
     // NOTE: During a Vite restart, old and new servers overlap. Separate queues
@@ -502,15 +513,11 @@ export const foldkit = (options = {}) => {
     const reloadPlugin = {
         name: 'foldkit',
         apply: 'serve',
-        // NOTE: The `post` order runs this hook after every default-order
-        // `configEnvironment` hook, so the predicate sees discovery or includes
-        // that another plugin turns on there.
-        configEnvironment: {
-            order: 'post',
-            handler: (name, config) => shouldForceEffectEntries(name, config)
-                ? { optimizeDeps: { include: [...FORCE_INCLUDED_EFFECT_ENTRIES] } }
-                : undefined,
-        },
+        config: () => ({
+            optimizeDeps: {
+                include: [...FORCE_INCLUDED_EFFECT_ENTRIES],
+            },
+        }),
         configureServer: server => {
             const events = Effect.runSync(Queue.unbounded());
             // NOTE: The default ConfigProvider snapshots the environment. Create a
@@ -540,27 +547,24 @@ export const foldkit = (options = {}) => {
         config: async (userConfig, { command }) => {
             const foldkitPackages = await crawlFoldkitPackages(userConfig.root ?? process.cwd(), command === 'build', userConfig);
             return {
+                optimizeDeps: {
+                    exclude: ['foldkit'],
+                },
                 resolve: {
                     dedupe: foldkitPackages.dedupe,
-                    noExternal: foldkitPackages.noExternal,
                 },
                 ssr: {
-                    noExternal: foldkitPackages.noExternal,
+                    noExternal: foldkitPackages.ssrNoExternal,
                 },
                 environments: {
                     ssr: {
                         resolve: {
-                            noExternal: foldkitPackages.noExternal,
+                            noExternal: foldkitPackages.ssrNoExternal,
                         },
                     },
                 },
             };
         },
-        configEnvironment: () => ({
-            optimizeDeps: {
-                exclude: ['foldkit'],
-            },
-        }),
     };
     const shared = [
         resolutionPlugin,
@@ -573,9 +577,6 @@ export const foldkit = (options = {}) => {
         return shared;
     }
     const { build, ...ssr } = options.ssr;
-    if (ssr.clientEntry !== undefined && ssr.containerId !== undefined) {
-        throw new Error('[foldkit] containerId belongs to an HTML template. A clientEntry build takes its complete document from renderDocument instead.');
-    }
     const servePages = foldkitSsr({
         ...ssr,
         ...(options.buildId === undefined ? {} : { buildId: options.buildId }),
@@ -584,15 +585,9 @@ export const foldkit = (options = {}) => {
     if (build === undefined || build === false) {
         return [...shared, servePages];
     }
-    if (ssr.clientEntry === undefined) {
-        throw new Error('[foldkit] ssr.build requires ssr.clientEntry to name the browser script and the server entry to export renderDocument.');
-    }
     return [
         ...shared,
         servePages,
-        foldkitBuild(ssr.serverEntry, {
-            ...(build === true ? {} : build),
-            clientEntry: ssr.clientEntry,
-        }),
+        foldkitBuild(ssr.serverEntry, withContainerId(build, ssr.containerId)),
     ];
 };

package/dist/ssr.d.ts

@@ -8,12 +8,6 @@ export type FoldkitSsrOptions = Readonly<{
      * `Promise<EntryResult>`.
      */
     serverEntry: string;
-    /**
-     * Root-relative browser script entry for a code-rendered document. The server entry must
-     * also export `renderDocument(application, assets)`. When absent, the dev
-     * host uses `index.html` for a custom template-based build pipeline.
-     */
-    clientEntry?: string;
     /**
      * The `id` of the empty container element in `index.html` the rendered
      * markup replaces. Defaults to `'root'`.

package/dist/ssr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr.d.ts","sourceRoot":"","sources":["../src/ssr.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAGV,MAAM,EAGP,MAAM,MAAM,CAAA;AAIb,0EAA0E;AAC1E,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC,CAAA;AA6tBF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,YAAa,iBAAiB,KAAG,MAyGvD,CAAA"}
+{"version":3,"file":"ssr.d.ts","sourceRoot":"","sources":["../src/ssr.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAGV,MAAM,EAGP,MAAM,MAAM,CAAA;AAIb,0EAA0E;AAC1E,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB,CAAC,CAAA;AAosBF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,YAAa,iBAAiB,KAAG,MAgEvD,CAAA"}

package/dist/ssr.js

@@ -132,32 +132,19 @@ const renderDecision = (nodeRequest, requestUrl) => {
 const renderRequest = (server, options, nodeRequest, requestUrl) => Effect.gen(function* () {
     const { pathname, search } = new URL(requestUrl);
     const route = `${pathname}${search}`;
+    const rawTemplate = yield* Effect.promise(() => readFile(resolve(server.config.root, 'index.html'), 'utf-8'));
+    // NOTE: the first argument tells Vite where the HTML lives, and Vite
+    // resolves the template's relative URLs (such as a `./src/entry.ts`
+    // script) against it. The template always lives at the site root, so
+    // that argument must stay `/index.html` no matter which route is being
+    // rendered. The third argument, named `originalUrl` in Vite's signature,
+    // carries the route actually being requested.
+    const template = yield* Effect.promise(() => server.transformIndexHtml('/index.html', rawTemplate, route));
     const loadedModule = yield* Effect.promise(() => server.ssrLoadModule(options.serverEntry));
     if (!isEntryModule(loadedModule)) {
         return yield* Effect.die(new Error(`[foldkit] '${options.serverEntry}' does not export a renderPage function, so the dev server cannot render pages.`));
     }
     const result = yield* Effect.promise(() => loadedModule.renderPage(toWebRequest(requestUrl, nodeRequest)));
-    if (result._tag === 'Responded') {
-        return result.response;
-    }
-    if (options.clientEntry !== undefined) {
-        if (!('renderDocument' in loadedModule) ||
-            !Predicate.isFunction(loadedModule.renderDocument)) {
-            return yield* Effect.die(new Error(`[foldkit] '${options.serverEntry}' must export renderDocument(application, assets) when clientEntry is configured.`));
-        }
-        const assets = Server.DocumentAssets.make({
-            entryScript: options.clientEntry,
-            stylesheets: [],
-            modulePreloads: [],
-        });
-        const document = loadedModule.renderDocument(result.application, assets);
-        const transformed = yield* Effect.promise(() => server.transformIndexHtml(pathname, document, route));
-        return Server.toResponse(() => transformed, result);
-    }
-    const rawTemplate = yield* Effect.promise(() => readFile(resolve(server.config.root, 'index.html'), 'utf-8'));
-    // NOTE: Vite resolves template-relative URLs against the first argument;
-    // the template-based host's index lives at the root for nested page requests.
-    const template = yield* Effect.promise(() => server.transformIndexHtml('/index.html', rawTemplate, route));
     return Server.toResponse(template, result, options.containerId === undefined
         ? {}
         : { containerId: options.containerId });
@@ -474,32 +461,9 @@ const renderMiddleware = (server, options, requestUrls, stateByRequest) => (node
  * responses. Server entry edits take effect without a restart.
  */
 export const foldkitSsr = (options) => {
-    let isDevelopmentHost = false;
     return {
         name: 'foldkit-ssr',
-        configResolved(config) {
-            if (!isDevelopmentHost || options.clientEntry === undefined) {
-                return;
-            }
-            if (!options.clientEntry.startsWith('/') ||
-                options.clientEntry.startsWith('//') ||
-                /\.html(?:[?#]|$)/.test(options.clientEntry)) {
-                throw new Error('[foldkit] clientEntry must be a root-relative browser script URL, such as "/src/entry.ts".');
-            }
-            if (options.containerId !== undefined) {
-                throw new Error('[foldkit] containerId is only used by the template-based dev host. A code-rendered document owns its application placement.');
-            }
-            if (config.base === '' || config.base === './') {
-                throw new Error('[foldkit] code-rendered documents require an absolute URL or root-relative base so browser assets resolve consistently on nested routes.');
-            }
-        },
-        config: (config, { command, isPreview }) => {
-            isDevelopmentHost = command === 'serve' && isPreview !== true;
-            if (isDevelopmentHost &&
-                options.clientEntry !== undefined &&
-                (config.base === '' || config.base === './')) {
-                throw new Error('[foldkit] code-rendered documents require an absolute URL or root-relative base so browser assets resolve consistently on nested routes.');
-            }
+        config: (_config, { command, isPreview }) => {
             const buildId = buildIdForCommand(command, options.buildId);
             return {
                 // NOTE: `vite preview` also resolves with command 'serve', but it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/vite-plugin",
-  "version": "0.26.1-canary.085b787da0a5",
+  "version": "0.26.1-canary.6bd9ee8e728c",
   "description": "Vite plugin for Foldkit with state-preserving live reload",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,7 +17,7 @@
   ],
   "peerDependencies": {
     "effect": "4.0.0",
-    "foldkit": "0.166.0-canary.085b787da0a5",
+    "foldkit": "0.166.0-canary.6bd9ee8e728c",
     "vite": "^8.0.0"
   },
   "dependencies": {
@@ -38,7 +38,7 @@
     "vite": "^8.3.1",
     "vite-host": "npm:vite@8.2.1",
     "vitest": "^4.1.11",
-    "foldkit": "0.166.0-canary.085b787da0a5"
+    "foldkit": "0.166.0-canary.6bd9ee8e728c"
   },
   "keywords": [
     "vite",