@fluixi/start 0.1.0-alpha.63 → 0.1.0-alpha.65

package/dist/adapter.d.ts

@@ -2,31 +2,101 @@ import type { FluixiConfig, ResolvedConfig } from './config.js';
 import { type FetchHandler } from './handler.js';
 /**
  * Build the production SSR fetch handler from a `fluixi build` output (dist/server +
- * dist/client/index.html). It's runtime-neutral — the SAME handler runs on Node, Bun,
- * Deno, and edge/worker runtimes. Adapters decide how to serve it + assets.
+ * dist/client/index.html), reading both off disk. Runtime-neutral once assembled, but
+ * the assembly is not: a worker has no filesystem, so a deploy adapter generates an
+ * entry that imports the same pieces statically and calls `createHandlerFrom`.
  */
 export declare function createProdHandler(config?: FluixiConfig): Promise<FetchHandler>;
+/**
+ * The shell the server renders into.
+ *
+ * `dist/client/index.html` is it, until the app prerenders `/` — then that path holds a
+ * rendered page and the build stashes the shell in `dist/server/template.html` first.
+ * Rendering into the page instead puts the home page's markup and head around every
+ * SSR response, and leaves hydration two mount elements to choose between.
+ */
+export declare function readTemplate(clientDir: string, serverDir: string): Promise<string>;
 export interface AdapterContext {
     handler: FetchHandler;
     cfg: ResolvedConfig;
     /** Built client assets dir (dist/client). */
     clientDir: string;
 }
+/** What an adapter is given after `fluixi build` has produced its output. */
+export interface AdapterBuildContext {
+    cfg: ResolvedConfig;
+    /** App root. */
+    root: string;
+    /** Client assets and prerendered HTML (dist/client). */
+    clientDir: string;
+    /** The built server entry and middleware (dist/server). */
+    serverDir: string;
+    /** False for a fully static SPA, which ships no server entry to wrap. */
+    hasServer: boolean;
+    /**
+     * Bundle a generated entry into one self-contained file. Adapters emit a small
+     * platform entry — the worker's `fetch` export, the function's handler — and this
+     * pulls the server bundle and the template into it, because none of these
+     * platforms can resolve a module or read a file at runtime.
+     */
+    bundleEntry(source: string, outFile: string): Promise<void>;
+}
 /**
- * A deploy target. The runtime-neutral fetch handler is the portable core; an adapter
- * packages it for a platform: filesystem runtimes (node) listen on a port and serve
- * static files from disk; edge/serverless runtimes return a `{ fetch }` export the
- * platform invokes (assets served by the platform/CDN). Build-time artifact emission
- * (worker bundle, function manifest) is a later increment.
+ * A deploy target.
+ *
+ * The runtime-neutral fetch handler is the portable core; an adapter packages it for a
+ * platform — how the server is bundled (`bundle`), how it is served in development or
+ * on a long-running host (`serve`), and what a deploy actually needs on disk
+ * (`build`): a worker entry, a function manifest, a routing config.
  */
 export interface Adapter {
     name: string;
+    /**
+     * How `fluixi build` bundles the framework into the server output. The choice is a
+     * property of the deploy target, not of the app:
+     *
+     * - `'external'` — `@fluixi/*` stays as bare imports, resolved from `node_modules` at
+     *   runtime. Smaller output, faster build; requires the dependencies to be installed
+     *   next to it. Right for a long-running Node/Bun/Deno process.
+     * - `'inline'` — everything is bundled into one self-contained file that resolves
+     *   nothing at runtime. Right for edge/serverless, where there is no `node_modules`.
+     *
+     * Unset leaves Vite's own heuristic alone (installed deps external, linked ones bundled).
+     */
+    bundle?: 'external' | 'inline';
     serve(ctx: AdapterContext): Promise<void> | {
         fetch: FetchHandler;
     };
+    /**
+     * Emit the platform's output layout. Runs after the client and server builds and
+     * after prerendering, so everything it copies or wraps already exists.
+     */
+    build?(ctx: AdapterBuildContext): Promise<void> | void;
 }
 /** Reference filesystem adapter — Node `http` + static files from dist/client. */
 export declare const nodeAdapter: Adapter;
+export { cloudflareAdapter, netlifyAdapter, vercelAdapter } from './adapters/platforms.js';
 /** Reference edge/web adapter — export `{ fetch }`; the platform serves assets. */
 export declare const webAdapter: Adapter;
+/**
+ * The Vite `ssr` options for a build, given the configured adapter's `bundle` mode.
+ * Shared by the server and middleware builds so the two cannot disagree.
+ *
+ * `'external'` lists the app's own `@fluixi/*` dependencies rather than externalizing
+ * everything: under a strict `node_modules` layout (pnpm) only what the app itself
+ * declares is resolvable from its root, so externalizing a merely transitive package
+ * would produce a bundle that imports something Node cannot find.
+ *
+ * Each package is listed with every subpath its `exports` map publishes, because Vite
+ * only honours an *exact* id in `ssr.external`. A bare package name falls through to a
+ * resolvability probe that does not externalize deep imports here, and the result is the
+ * worst of both worlds: `@fluixi/core` an import, `@fluixi/core/router-next` copied into
+ * the bundle — two routers, two sets of module state, in one server.
+ *
+ * `ssrNoExternal` always wins — it is the app saying "this one must be bundled".
+ */
+export declare function ssrBuildOptions(cfg: ResolvedConfig): {
+    noExternal?: string[] | true;
+    external?: string[];
+};
 //# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGhE,OAAO,EAKL,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAGtB;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,GAAE,YAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAkDxF;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,YAAY,CAAC;IACtB,GAAG,EAAE,cAAc,CAAC;IACpB,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG;QAAE,KAAK,EAAE,YAAY,CAAA;KAAE,CAAC;CACrE;AAED,kFAAkF;AAClF,eAAO,MAAM,WAAW,EAAE,OAQzB,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,UAAU,EAAE,OAKxB,CAAC"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAA8B,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAI7E;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,GAAE,YAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAiBxF;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGxF;AAoBD,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,YAAY,CAAC;IACtB,GAAG,EAAE,cAAc,CAAC;IACpB,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,cAAc,CAAC;IACpB,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,SAAS,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC/B,KAAK,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG;QAAE,KAAK,EAAE,YAAY,CAAA;KAAE,CAAC;IACpE;;;OAGG;IACH,KAAK,CAAC,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACxD;AAED,kFAAkF;AAClF,eAAO,MAAM,WAAW,EAAE,OAWzB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE3F,mFAAmF;AACnF,eAAO,MAAM,UAAU,EAAE,OAQxB,CAAC;AAUF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,cAAc,GAAG;IACpD,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB,CAoBA"}

package/dist/adapter.js

@@ -1,67 +1,70 @@
 import { readFile } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { resolve, join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
 import { resolveConfig } from './config.js';
-import { injectAppAndHead, splitTemplate, guardHandler } from './internal.js';
-import { createRequestHandler, serveNode, streamDocument, withStaticFiles, } from './handler.js';
-import { composeMiddleware, normalizeMiddleware } from './middleware.js';
+import { serveNode, withStaticFiles } from './handler.js';
+import { createHandlerFrom } from './handler-core.js';
+import { createPreloader } from './preload.js';
 /**
  * Build the production SSR fetch handler from a `fluixi build` output (dist/server +
- * dist/client/index.html). It's runtime-neutral — the SAME handler runs on Node, Bun,
- * Deno, and edge/worker runtimes. Adapters decide how to serve it + assets.
+ * dist/client/index.html), reading both off disk. Runtime-neutral once assembled, but
+ * the assembly is not: a worker has no filesystem, so a deploy adapter generates an
+ * entry that imports the same pieces statically and calls `createHandlerFrom`.
  */
 export async function createProdHandler(config = {}) {
     const cfg = resolveConfig(config);
     const clientDir = resolve(cfg.root, 'dist/client');
-    const template = await readFile(join(clientDir, 'index.html'), 'utf-8');
+    const template = await readTemplate(clientDir, resolve(cfg.root, 'dist/server'));
     const serverEntry = resolve(cfg.root, 'dist/server', 'entry-server.js');
     // SPA apps may ship no server entry (or one only for server functions) — import if present.
     const mod = existsSync(serverEntry)
         ? await import(/* @vite-ignore */ pathToFileURL(serverEntry).href)
         : {};
-    // Streaming when the entry exports `renderStream` (a body stream): flush the split
-    // template head first, pipe the body, then the tail. Else inject the string render.
-    let core;
-    if (!cfg.ssr) {
-        // SPA: the page is the static shell; the client entry renders it. Server functions +
-        // middleware still run through this handler — there's just no SSR render pass.
-        core = createRequestHandler(async () => template);
-    }
-    else if (typeof mod.renderStream === 'function') {
-        const { head, tail } = splitTemplate(template, cfg.mountId);
-        core = async (request) => {
-            const url = new URL(request.url);
-            const body = await mod.renderStream(url.pathname + url.search, request);
-            return streamDocument(head, body, tail);
-        };
-    }
-    else {
-        const render = mod.render ?? mod.default;
-        core = createRequestHandler(async (url, request) => injectAppAndHead(template, await render(url, request), cfg.mountId));
-    }
-    // Server-function RPC dispatch. The entry-server module re-exports the dispatcher, so
-    // it shares the registry that the app's "use server" modules populated (a separate
-    // node-imported copy would have an empty registry).
-    if (typeof mod.handleServerFn === 'function' && typeof mod.isServerFnRequest === 'function') {
-        const render = core;
-        core = (request) => (mod.isServerFnRequest(request) ? mod.handleServerFn(request) : render(request));
-    }
-    // File-based API routes — the entry-server re-exports them from virtual:fluixi-api.
-    if (typeof mod.handleApiRequest === 'function' && typeof mod.isApiRequest === 'function') {
-        const next = core;
-        core = (request) => (mod.isApiRequest(request) ? mod.handleApiRequest(request) : next(request));
-    }
     // Optional request middleware (src/middleware.ts → dist/server/middleware.js).
     const mwFile = resolve(cfg.root, 'dist/server', 'middleware.js');
-    if (!existsSync(mwFile))
-        return guardHandler(core);
-    const mwMod = await import(/* @vite-ignore */ pathToFileURL(mwFile).href);
-    return guardHandler(composeMiddleware(normalizeMiddleware(mwMod), core));
+    const middleware = existsSync(mwFile)
+        ? await import(/* @vite-ignore */ pathToFileURL(mwFile).href)
+        : undefined;
+    return createHandlerFrom({ template, mod, cfg, middleware, preload: await loadPreloader(cfg) });
+}
+/**
+ * The shell the server renders into.
+ *
+ * `dist/client/index.html` is it, until the app prerenders `/` — then that path holds a
+ * rendered page and the build stashes the shell in `dist/server/template.html` first.
+ * Rendering into the page instead puts the home page's markup and head around every
+ * SSR response, and leaves hydration two mount elements to choose between.
+ */
+export async function readTemplate(clientDir, serverDir) {
+    const stashed = join(serverDir, 'template.html');
+    return readFile(existsSync(stashed) ? stashed : join(clientDir, 'index.html'), 'utf-8');
+}
+/**
+ * The preloader for a filesystem host, from the route→files map `fluixi build` leaves
+ * in `dist/server`. Absent or unreadable means no hints and an unchanged page, never a
+ * failed request. A deploy adapter inlines the same map, because a worker cannot read
+ * it at runtime.
+ */
+async function loadPreloader(cfg) {
+    const file = resolve(cfg.root, 'dist/server', 'route-assets.json');
+    if (!existsSync(file))
+        return undefined;
+    try {
+        return createPreloader(JSON.parse(await readFile(file, 'utf-8')));
+    }
+    catch {
+        // A map that cannot be read is a reason to skip preloading, not to refuse to serve.
+        return undefined;
+    }
 }
 /** Reference filesystem adapter — Node `http` + static files from dist/client. */
 export const nodeAdapter = {
     name: 'node',
+    // A Node server runs from the app directory, so node_modules is right there: keep the
+    // framework as imports instead of copying it into the bundle.
+    bundle: 'external',
     async serve({ handler, cfg, clientDir }) {
         serveNode(withStaticFiles(handler, clientDir), {
             port: cfg.port,
@@ -69,10 +72,113 @@ export const nodeAdapter = {
         });
     },
 };
+export { cloudflareAdapter, netlifyAdapter, vercelAdapter } from './adapters/platforms.js';
 /** Reference edge/web adapter — export `{ fetch }`; the platform serves assets. */
 export const webAdapter = {
     name: 'web',
+    // An edge/serverless runtime uploads a file, not an install: nothing may be left to
+    // resolve at runtime, so everything goes in the bundle.
+    bundle: 'inline',
     serve({ handler }) {
         return { fetch: handler };
     },
 };
+/**
+ * Subpaths that only look like package entries: a Vite plugin replaces them with the
+ * app's generated route/server-fn/API tables, and the real file in the package is a stub
+ * that throws. Externalizing one would ship the stub. The plugins run with
+ * `enforce: 'pre'` so they win anyway — this list is the second lock on that door.
+ */
+const GENERATED_SUBPATHS = new Set(['./routes', './server-fns', './api-routes']);
+/**
+ * The Vite `ssr` options for a build, given the configured adapter's `bundle` mode.
+ * Shared by the server and middleware builds so the two cannot disagree.
+ *
+ * `'external'` lists the app's own `@fluixi/*` dependencies rather than externalizing
+ * everything: under a strict `node_modules` layout (pnpm) only what the app itself
+ * declares is resolvable from its root, so externalizing a merely transitive package
+ * would produce a bundle that imports something Node cannot find.
+ *
+ * Each package is listed with every subpath its `exports` map publishes, because Vite
+ * only honours an *exact* id in `ssr.external`. A bare package name falls through to a
+ * resolvability probe that does not externalize deep imports here, and the result is the
+ * worst of both worlds: `@fluixi/core` an import, `@fluixi/core/router-next` copied into
+ * the bundle — two routers, two sets of module state, in one server.
+ *
+ * `ssrNoExternal` always wins — it is the app saying "this one must be bundled".
+ */
+export function ssrBuildOptions(cfg) {
+    const noExternal = cfg.ssrNoExternal.length ? cfg.ssrNoExternal : undefined;
+    const mode = cfg.adapter?.bundle;
+    if (mode === 'inline')
+        return { noExternal: true };
+    if (mode !== 'external')
+        return { noExternal };
+    const external = frameworkDeps(cfg.root)
+        .filter((name) => !cfg.ssrNoExternal.includes(name))
+        .flatMap((name) => withSubpaths(cfg.root, name));
+    if (!external.length) {
+        // Silently building an inlined bundle here would look identical to a working one
+        // until someone measures it, so say why nothing was externalized.
+        console.warn(`  fluixi: adapter "${cfg.adapter?.name}" builds an externalized server, but no ` +
+            `@fluixi/* dependency was found in ${join(cfg.root, 'package.json')} — bundling everything.`);
+    }
+    return { noExternal, external: external.length ? external : undefined };
+}
+/** The app's own `@fluixi/*` dependencies, read from its package.json. */
+function frameworkDeps(root) {
+    const pkg = readPackage(join(root, 'package.json'));
+    if (!pkg)
+        return [];
+    const declared = { ...pkg.dependencies, ...pkg.peerDependencies, ...pkg.optionalDependencies };
+    return Object.keys(declared).filter((id) => id.startsWith('@fluixi/'));
+}
+/**
+ * `['@fluixi/core', '@fluixi/core/rx', …]` — the package plus every static subpath it
+ * exports. Wildcard entries (`./lib/*`) cannot be enumerated and are left to Vite; an
+ * app importing through one gets it bundled, which is the safe direction.
+ */
+function withSubpaths(root, name) {
+    const exports = resolvePackage(root, name)?.exports;
+    if (!exports || typeof exports !== 'object')
+        return [name];
+    const ids = [name];
+    for (const key of Object.keys(exports)) {
+        if (!key.startsWith('./') || key.includes('*'))
+            continue;
+        if (key === './package.json' || GENERATED_SUBPATHS.has(key))
+            continue;
+        ids.push(`${name}/${key.slice(2)}`);
+    }
+    return ids;
+}
+/**
+ * A dependency's package.json, read from where the app would resolve it. `require.resolve`
+ * covers the normal case; packages that do not export `./package.json` (a package may
+ * legitimately keep it private) need the node_modules walk, which also handles hoisting.
+ */
+function resolvePackage(root, name) {
+    try {
+        return readPackage(createRequire(join(root, 'index.js')).resolve(`${name}/package.json`));
+    }
+    catch {
+        /* not exported — fall through */
+    }
+    for (let dir = root;; dir = dirname(dir)) {
+        const pkg = readPackage(join(dir, 'node_modules', name, 'package.json'));
+        if (pkg)
+            return pkg;
+        if (dirname(dir) === dir)
+            return undefined;
+    }
+}
+function readPackage(file) {
+    if (!existsSync(file))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/adapters/entry.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The source of the entry a deploy adapter bundles.
+ *
+ * Every one of these platforms runs the same handler; they differ only in what they
+ * expect the module to export and how static assets reach the request. So the entry
+ * is generated rather than shipped: it imports the built server and the template,
+ * hands both to `createHandlerFrom`, and wraps the result in whatever shape the
+ * platform invokes.
+ *
+ * The template is inlined as a string. Reading `index.html` at runtime is what
+ * `createProdHandler` does on Node and what none of these can do.
+ */
+export interface EntrySource {
+    /** Path to the built server entry, relative to the generated file. */
+    serverEntry: string;
+    /** Path to the built middleware, or null when the app has none. */
+    middleware: string | null;
+    /** `dist/client/index.html`, inlined. */
+    template: string;
+    ssr: boolean;
+    mountId: string;
+    /** Paths that exist as prerendered HTML, so the platform can answer them itself. */
+    prerendered: string[];
+    /** URL pattern → built files, inlined: a worker cannot read the map off disk. */
+    routeAssets: Record<string, string[]>;
+}
+/**
+ * Cloudflare Pages, advanced mode: a `_worker.js` at the root of the published
+ * directory takes every request. Pages stops serving static files itself in that
+ * mode, so assets go through the ASSETS binding, and `_routes.json` keeps the worker
+ * out of the hot path for anything under a hashed asset directory.
+ */
+export declare function cloudflareEntry(source: EntrySource): string;
+/**
+ * Netlify Functions v2: a default-exported fetch handler. `config.path` claims every
+ * route; Netlify still serves a matching static file first, so the function only sees
+ * what the CDN could not answer.
+ */
+export declare function netlifyEntry(source: EntrySource): string;
+/**
+ * Vercel Build Output API v3, Node runtime.
+ *
+ * The `Nodejs` launcher invokes the default export as `(req, res)`, so the entry
+ * bridges the two itself. Exporting `(request) => Response` hangs instead of failing:
+ * the launcher passes an `IncomingMessage`, nothing writes to `res`, and the request
+ * sits until the platform times it out. Node rather than edge, so a server function
+ * can use Node APIs.
+ */
+export declare function vercelEntry(source: EntrySource): string;
+//# sourceMappingURL=entry.d.ts.map

package/dist/adapters/entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../src/adapters/entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,oFAAoF;IACpF,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACvC;AA0BD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAoB3D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAOxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAuCvD"}

package/dist/adapters/entry.js

@@ -0,0 +1,124 @@
+/**
+ * The source of the entry a deploy adapter bundles.
+ *
+ * Every one of these platforms runs the same handler; they differ only in what they
+ * expect the module to export and how static assets reach the request. So the entry
+ * is generated rather than shipped: it imports the built server and the template,
+ * hands both to `createHandlerFrom`, and wraps the result in whatever shape the
+ * platform invokes.
+ *
+ * The template is inlined as a string. Reading `index.html` at runtime is what
+ * `createProdHandler` does on Node and what none of these can do.
+ */
+/** Imports and the handler, shared by every platform entry. */
+function preamble({ serverEntry, middleware, template, ssr, mountId, routeAssets }) {
+    return [
+        `import { createHandlerFrom } from '@fluixi/start/handler-core';`,
+        `import { createPreloader } from '@fluixi/start/preload';`,
+        `import * as server from ${JSON.stringify(serverEntry)};`,
+        middleware ? `import * as middleware from ${JSON.stringify(middleware)};` : '',
+        ``,
+        `const template = ${JSON.stringify(template)};`,
+        // Inlined for the same reason as the template: this runs as an uploaded file, with
+        // no dist/server beside it to read.
+        `const routeAssets = ${JSON.stringify(routeAssets)};`,
+        `const handler = createHandlerFrom({`,
+        `  template,`,
+        `  mod: server,`,
+        `  cfg: { ssr: ${ssr}, mountId: ${JSON.stringify(mountId)} },`,
+        `  preload: createPreloader(routeAssets),`,
+        middleware ? `  middleware,` : '',
+        `});`,
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+/**
+ * Cloudflare Pages, advanced mode: a `_worker.js` at the root of the published
+ * directory takes every request. Pages stops serving static files itself in that
+ * mode, so assets go through the ASSETS binding, and `_routes.json` keeps the worker
+ * out of the hot path for anything under a hashed asset directory.
+ */
+export function cloudflareEntry(source) {
+    return `${preamble(source)}
+
+const prerendered = new Set(${JSON.stringify(source.prerendered)});
+
+export default {
+  async fetch(request, env, ctx) {
+    // Static first, but only for what is static. ASSETS answers "/" with index.html
+    // whether that is a prerendered page or the shell, so asking about every path
+    // costs an SSR app its home page. Extension means a file, prerendered means a
+    // page, the rest is the handler's — the rule \`withStaticFiles\` already uses.
+    const { pathname } = new URL(request.url);
+    if (env && env.ASSETS && (prerendered.has(pathname) || /\\.[^/]+$/.test(pathname))) {
+      const asset = await env.ASSETS.fetch(request.clone());
+      if (asset.status !== 404) return asset;
+    }
+    return handler(request, { env, ctx });
+  },
+};
+`;
+}
+/**
+ * Netlify Functions v2: a default-exported fetch handler. `config.path` claims every
+ * route; Netlify still serves a matching static file first, so the function only sees
+ * what the CDN could not answer.
+ */
+export function netlifyEntry(source) {
+    return `${preamble(source)}
+
+export default async (request, context) => handler(request, { context });
+
+export const config = { path: '/*', preferStatic: true };
+`;
+}
+/**
+ * Vercel Build Output API v3, Node runtime.
+ *
+ * The `Nodejs` launcher invokes the default export as `(req, res)`, so the entry
+ * bridges the two itself. Exporting `(request) => Response` hangs instead of failing:
+ * the launcher passes an `IncomingMessage`, nothing writes to `res`, and the request
+ * sits until the platform times it out. Node rather than edge, so a server function
+ * can use Node APIs.
+ */
+export function vercelEntry(source) {
+    return `${preamble(source)}
+
+export default async (req, res) => {
+  const proto = req.headers['x-forwarded-proto'] || 'https';
+  const host = req.headers['x-forwarded-host'] || req.headers.host;
+
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) for (const one of value) headers.append(name, one);
+    else if (value !== undefined) headers.set(name, value);
+  }
+
+  // A body has to be read off the stream before it can be handed to Request; only
+  // GET and HEAD are guaranteed not to have one.
+  let body;
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    if (chunks.length) body = new Blob(chunks);
+  }
+
+  const response = await handler(
+    new Request(new URL(req.url, \`\${proto}://\${host}\`), { method: req.method, headers, body }),
+  );
+
+  res.statusCode = response.status;
+  // set-cookie is the one header that legitimately repeats; folding it into one line
+  // breaks the cookies.
+  for (const [name, value] of response.headers) {
+    if (name.toLowerCase() !== 'set-cookie') res.setHeader(name, value);
+  }
+  const cookies = response.headers.getSetCookie?.() ?? [];
+  if (cookies.length) res.setHeader('set-cookie', cookies);
+
+  if (response.body) for await (const chunk of response.body) res.write(chunk);
+  res.end();
+};
+`;
+}

package/dist/adapters/platforms.d.ts

@@ -0,0 +1,30 @@
+import { type Adapter } from '../adapter.js';
+/**
+ * Cloudflare Pages. `_worker.js` at the root of the published directory takes every
+ * request; `_routes.json` is what decides whether a request costs an invocation.
+ *
+ * In advanced mode the worker sees everything not excluded — so a prerendered page
+ * would wake it just to proxy the file back through the ASSETS binding. On a plan
+ * metered by request that is the whole page view budget spent on static files, so
+ * every prerendered path is excluded by name.
+ *
+ * Publish `dist/client`.
+ */
+export declare const cloudflareAdapter: Adapter;
+/**
+ * Netlify. The function is a v2 fetch handler under `.netlify/functions-internal/`,
+ * which is where a framework — as opposed to the user — puts one, so it cannot
+ * collide with the app's own `netlify/functions`.
+ *
+ * Publish `dist/client`.
+ */
+export declare const netlifyAdapter: Adapter;
+/**
+ * Vercel, through the Build Output API v3: `.vercel/output/` is read directly, with
+ * no framework detection and no `vercel.json` to keep in sync.
+ *
+ * `config.json` routes the filesystem first so a prerendered page is served as a
+ * file, then sends the rest to the function.
+ */
+export declare const vercelAdapter: Adapter;
+//# sourceMappingURL=platforms.d.ts.map

package/dist/adapters/platforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platforms.d.ts","sourceRoot":"","sources":["../../src/adapters/platforms.ts"],"names":[],"mappings":"AAaA,OAAO,EAAgB,KAAK,OAAO,EAA4B,MAAM,eAAe,CAAC;AAwGrF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,EAAE,OAgC/B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,OA+B5B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,OAgE3B,CAAC"}