@kestack/kabuki 0.0.0 → 0.0.2

package/dist/start/server/server.js

@@ -0,0 +1,138 @@
+import { Context, Effect, Exit, Layer, Scope, Stream } from 'effect';
+import { Loading, Router } from '../../routing/index.js';
+import { knownOf } from '../../routing/page/index.js';
+import { Document, PATH, appOf } from '../common/index.js';
+import { kept } from './cache.js';
+import { drawer } from './draw.js';
+import { loadersOf } from './layers.js';
+import { answer } from './rpc.js';
+import { tiers } from './tiers.js';
+import { PRIVATE, SHARED, broken, found, headOf, html, notAllowed, permanent, } from './respond.js';
+/** The places drawn on the server: every place above the first client one. */
+const drawnHere = (places) => {
+    const client = places.findIndex((place) => place.render === 'client');
+    return client < 0 ? places : places.slice(0, client);
+};
+/** The path of a URL, without its query. */
+const pathOf = (url, base) => new URL(url, base).pathname;
+export const server = (options) => {
+    const { build } = options;
+    const { app, document = Document } = appOf(options.app);
+    const { loaders, tiers: given } = loadersOf(options.loaders);
+    const draw = drawer(app, document, build);
+    const layerFor = tiers(given);
+    const modes = new Map(app.routes.every.map((place) => [place.name, place.render]));
+    // 4. Load
+    /** What the Loaders of `wanted` run with: the memory Loading, handed this request, and their tiers. */
+    const loadingFor = (request, env, headers, wanted) => Router.memory(app.routes, loaders, {
+        request: () => request,
+    }).pipe(Layer.provide(layerFor({
+        env,
+        request,
+        headers,
+        visitor: wanted.some(({ name }) => modes.get(name) !== 'static'),
+    })));
+    /** Runs the Loaders of `wanted` at once, as the memory Loading does, handed this request. */
+    const load = (request, env, headers) => (wanted) => wanted.length === 0
+        ? Effect.succeed({})
+        : Effect.gen(function* () {
+            const loading = yield* Loading;
+            return yield* loading.load(wanted);
+        }).pipe(Effect.provide(loadingFor(request, env, headers, wanted)));
+    /**
+     * The Loaders of `wanted`, each answered as it is done, for the Loader
+     * RPC. What they run with is made first, so the headers it adds are there
+     * before the answer starts; it is let go once the last place is answered.
+     */
+    const each = (request, env, headers) => async (wanted) => {
+        const scope = await Effect.runPromise(Scope.make());
+        const close = Scope.close(scope, Exit.void);
+        const context = await Effect.runPromise(Layer.buildWithScope(loadingFor(request, env, headers, wanted), scope).pipe(Effect.onError(() => close)));
+        const loading = Context.get(context, Loading);
+        return (loading.each
+            ? loading.each(wanted)
+            : Stream.unwrap(Effect.map(loading.load(wanted), (answers) => Stream.fromIterable(Object.entries(answers))))).pipe(Stream.ensuring(close));
+    };
+    /** What each place with data drawn here came to; a Redirect, the outermost first, instead. */
+    const loaded = async (run, places) => {
+        const wanted = places.filter((place) => place.input);
+        const outcomes = await Effect.runPromise(run(wanted.map(({ name, params }) => ({ name, params }))));
+        const known = {};
+        let status = 200;
+        for (const { name } of wanted) {
+            const outcome = outcomes[name] ?? {
+                _tag: 'Broken',
+                reason: `no answer for ${name}`,
+            };
+            if (outcome._tag === 'Redirect')
+                return outcome;
+            if (outcome._tag === 'NotFound')
+                status = Math.max(status, 404);
+            if (outcome._tag === 'Broken') {
+                console.error(`[@kestack/kabuki/start] the Loader of ${name} broke:`, outcome.reason);
+                status = 500;
+            }
+            known[name] = knownOf(outcome, Date.now(), 'server');
+        }
+        return { _tag: 'Loaded', known, status };
+    };
+    // 5. Draw
+    const drawn = async (at, status, cache) => html(await draw(at), status, cache);
+    const page = async (request, host, headers) => {
+        // 2. Read
+        const url = new URL(request.url);
+        const at = app.startAt(`${url.pathname}${url.search}`);
+        if (!at)
+            return new Response(null, { status: 404 });
+        const route = at.route;
+        const written = app.href(route);
+        if (route._tag !== 'NotFound' && pathOf(written, url) !== url.pathname)
+            return permanent(written.includes('?') ? written : `${written}${url.search}`);
+        // 3. Split
+        const here = drawnHere(app.routes.places(route));
+        const shared = build.id !== undefined &&
+            here.every((place) => place.render === 'static');
+        const cache = shared ? SHARED : PRIVATE;
+        const drawPage = async () => {
+            const answer = await loaded(load(request, host.env, headers), here);
+            if (answer._tag === 'Redirect') {
+                const to = answer.href ?? app.href(answer.route);
+                return answer.permanent ? permanent(to) : found(to);
+            }
+            const status = route._tag === 'NotFound' ? 404 : answer.status;
+            return drawn({ route, known: answer.known }, status, status === 200 ? cache : PRIVATE);
+        };
+        // 6. Keep
+        return shared
+            ? kept(host.cache, SHARED, build.id, url, drawPage)
+            : drawPage();
+    };
+    /** The response, with the headers the Loaders added. */
+    const sent = (response, headers) => {
+        for (const [name, value] of headers)
+            response.headers.append(name, value);
+        return response;
+    };
+    return {
+        fetch: async (request, host) => {
+            try {
+                const headers = new Headers();
+                // 1. Route
+                const { pathname } = new URL(request.url);
+                if (pathname === PATH)
+                    return request.method === 'POST'
+                        ? sent(await answer(app.routes, request, each(request, host.env, headers)), headers)
+                        : new Response(null, { status: 405, headers: { allow: 'POST' } });
+                if (request.method === 'HEAD')
+                    return headOf(sent(await page(new Request(request, { method: 'GET' }), host, headers), headers));
+                if (request.method !== 'GET')
+                    return notAllowed();
+                return sent(await page(request, host, headers), headers);
+            }
+            catch (error) {
+                console.error('[@kestack/kabuki/start] a request failed:', error);
+                return broken();
+            }
+        },
+    };
+};

package/dist/start/server/tiers.d.ts

@@ -0,0 +1,14 @@
+import { Layer } from 'effect';
+import type { Tiers } from './layers.ts';
+/** What one request's Loaders run with. */
+export interface Asked {
+    readonly env: unknown;
+    readonly request: Request;
+    /** The headers its response is sent with. */
+    readonly headers: Headers;
+    /** Whether it loads a dynamic or client place, which may use the visitor tier. */
+    readonly visitor: boolean;
+}
+/** The Layer each request's Loaders run with, the instance tier made once for all of them. */
+export declare const tiers: (layers: Tiers) => (asked: Asked) => Layer.Layer<any, never, never>;
+//# sourceMappingURL=tiers.d.ts.map

package/dist/start/server/tiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiers.d.ts","sourceRoot":"","sources":["../../../src/start/server/tiers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,EAAS,MAAM,QAAQ,CAAC;AAG9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAyBzC,2CAA2C;AAC3C,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,kFAAkF;IAClF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,8FAA8F;AAC9F,eAAO,MAAM,KAAK,WAAY,KAAK,aAelB,KAAK,KAAG,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,CAuBrD,CAAC"}

package/dist/start/server/tiers.js

@@ -0,0 +1,31 @@
+import { Effect, Layer, Scope } from 'effect';
+import { ResponseHeaders } from './layers.js';
+const made = (tier, env) => (tier === undefined ? Layer.empty : tier(env));
+/** The Layer each request's Loaders run with, the instance tier made once for all of them. */
+export const tiers = (layers) => {
+    let instance;
+    const kept = (env) => {
+        if (!instance) {
+            const making = Effect.runPromise(Layer.buildWithScope(made(layers.instance, env), Scope.makeUnsafe()));
+            instance = making;
+            making.catch(() => {
+                if (instance === making)
+                    instance = undefined;
+            });
+        }
+        return instance;
+    };
+    return (asked) => Layer.unwrap(Effect.promise(() => kept(asked.env)).pipe(Effect.map((context) => {
+        const shared = made(layers.request, asked.env).pipe(Layer.provideMerge(Layer.succeedContext(context)));
+        if (!asked.visitor)
+            return shared;
+        const above = Layer.merge(shared, Layer.succeed(ResponseHeaders, {
+            append: (name, value) => Effect.sync(() => asked.headers.append(name, value)),
+        }));
+        return layers.visitor
+            ? layers
+                .visitor({ env: asked.env, request: asked.request })
+                .pipe(Layer.provideMerge(above))
+            : above;
+    }))).pipe(Layer.orDie);
+};

package/dist/start/vite/dev.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Handler } from '../platform/index.ts';
+/** A Connect middleware that answers every request it is handed with the Worker. */
+export declare const serveHandler: (load: () => Promise<Handler>, onError: (error: Error) => void) => (incoming: IncomingMessage, outgoing: ServerResponse, next: (error?: unknown) => void) => Promise<void>;
+//# sourceMappingURL=dev.d.ts.map

package/dist/start/vite/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../src/start/vite/dev.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AA4CpD,oFAAoF;AACpF,eAAO,MAAM,YAAY,SAChB,MAAM,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,gBAElD,eAAe,YACf,cAAc,QAClB,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,kBAYhC,CAAC"}

package/dist/start/vite/dev.js

@@ -0,0 +1,56 @@
+import { Readable } from 'node:stream';
+/*
+ * `vite dev` with nothing else to run the server: Start's handler, which
+ * knows no platform, run in Vite's own server environment, in Node, each
+ * request handed to it with an empty env and no Cache, and its response
+ * written back. Where a platform's own plugin runs the server, as the
+ * Cloudflare plugin under `alchemy dev` runs workerd, this stands aside.
+ */
+const toRequest = (incoming) => {
+    const host = incoming.headers.host ?? 'localhost';
+    const url = new URL(incoming.url ?? '/', `http://${host}`);
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(incoming.headers)) {
+        if (value === undefined || name.startsWith(':'))
+            continue;
+        for (const each of Array.isArray(value) ? value : [value])
+            headers.append(name, each);
+    }
+    const hasBody = incoming.method !== 'GET' && incoming.method !== 'HEAD';
+    return new Request(url, {
+        method: incoming.method ?? 'GET',
+        headers,
+        ...(hasBody
+            ? {
+                body: Readable.toWeb(incoming),
+                duplex: 'half',
+            }
+            : {}),
+    });
+};
+const send = async (response, outgoing) => {
+    outgoing.statusCode = response.status;
+    for (const [name, value] of response.headers)
+        if (name !== 'set-cookie')
+            outgoing.setHeader(name, value);
+    const cookies = response.headers.getSetCookie();
+    if (cookies.length > 0)
+        outgoing.setHeader('set-cookie', cookies);
+    if (!response.body)
+        return void outgoing.end();
+    for await (const chunk of response.body)
+        outgoing.write(chunk);
+    outgoing.end();
+};
+/** A Connect middleware that answers every request it is handed with the Worker. */
+export const serveHandler = (load, onError) => async (incoming, outgoing, next) => {
+    try {
+        const handler = await load();
+        await send(await handler.fetch(toRequest(incoming), { env: {} }), outgoing);
+    }
+    catch (error) {
+        if (error instanceof Error)
+            onError(error);
+        next(error);
+    }
+};

package/dist/start/vite/entries.d.ts

@@ -0,0 +1,27 @@
+import type { Build, Script } from '../common/index.ts';
+import type { Platform } from '../platform/index.ts';
+import type { Files } from './files.ts';
+export declare const HANDLER = "virtual:kabuki-start/handler";
+export declare const WORKER = "virtual:kabuki-start/worker";
+export declare const CLIENT = "virtual:kabuki-start/client";
+export declare const BUILD = "virtual:kabuki-start/build";
+/** The name the client entry's chunk is given, to find it in the manifest. */
+export declare const ENTRY = "kabuki-start";
+/** Start's handler, made from the app's two files: what every platform serves. */
+export declare const handlerModule: (files: Files) => string;
+/** The server's entry: the handler in the platform's adapter, its only export. */
+export declare const workerEntry: (platform: Platform) => string;
+/**
+ * The browser's entry: hydrates the page the Worker drew. In dev it takes
+ * itself back whenever the app changes, and draws the page again with it,
+ * so an edit anywhere in the app is a hot reload, not a full one. React
+ * Refresh cannot swap the app, which is a value, not a component; the app
+ * carries on from its History, replayed with the new code. In dev it also
+ * turns off the styles the server linked in the head, which the app's own
+ * scripts have added again by then.
+ */
+export declare const clientEntry: (files: Files, devStyles?: string) => string;
+export declare const buildModule: (build: Build) => string;
+/** The scripts Vite writes in an HTML page's head in dev: its client, and React Refresh's preamble. */
+export declare const devScripts: (html: string) => ReadonlyArray<Script>;
+//# sourceMappingURL=entries.d.ts.map

package/dist/start/vite/entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../../src/start/vite/entries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AASxC,eAAO,MAAM,OAAO,iCAAiC,CAAC;AACtD,eAAO,MAAM,MAAM,gCAAgC,CAAC;AACpD,eAAO,MAAM,MAAM,gCAAgC,CAAC;AACpD,eAAO,MAAM,KAAK,+BAA+B,CAAC;AAElD,8EAA8E;AAC9E,eAAO,MAAM,KAAK,iBAAiB,CAAC;AAIpC,kFAAkF;AAClF,eAAO,MAAM,aAAa,UAAW,KAAK,WAS5B,CAAC;AAEf,kFAAkF;AAClF,eAAO,MAAM,WAAW,aAAc,QAAQ,WAKhC,CAAC;AAEf;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,UAAW,KAAK,cAAc,MAAM,WAmB9C,CAAC;AAEf,eAAO,MAAM,WAAW,UAAW,KAAK,WACI,CAAC;AAE7C,uGAAuG;AACvG,eAAO,MAAM,UAAU,SAAU,MAAM,KAAG,aAAa,CAAC,MAAM,CAS7D,CAAC"}

package/dist/start/vite/entries.js

@@ -0,0 +1,66 @@
+/*
+ * The modules the plugin writes, so the app writes no entry: Start's
+ * handler, which knows no platform; the server's entry, which hands it to
+ * the platform's adapter; the browser's; and what the server knows of the
+ * build.
+ */
+export const HANDLER = 'virtual:kabuki-start/handler';
+export const WORKER = 'virtual:kabuki-start/worker';
+export const CLIENT = 'virtual:kabuki-start/client';
+export const BUILD = 'virtual:kabuki-start/build';
+/** The name the client entry's chunk is given, to find it in the manifest. */
+export const ENTRY = 'kabuki-start';
+const from = (file) => JSON.stringify(file.replace(/\\/g, '/'));
+/** Start's handler, made from the app's two files: what every platform serves. */
+export const handlerModule = (files) => [
+    `import { server } from '@kestack/kabuki/start/server';`,
+    `import app from ${from(files.app)};`,
+    files.loaders
+        ? `import loaders from ${from(files.loaders)};`
+        : `const loaders = undefined;`,
+    `import build from '${BUILD}';`,
+    `export default server({ app, loaders, build });`,
+].join('\n');
+/** The server's entry: the handler in the platform's adapter, its only export. */
+export const workerEntry = (platform) => [
+    `import { ${platform.serve.name} as serve } from ${JSON.stringify(platform.serve.from)};`,
+    `import handler from '${HANDLER}';`,
+    `export default serve(handler);`,
+].join('\n');
+/**
+ * The browser's entry: hydrates the page the Worker drew. In dev it takes
+ * itself back whenever the app changes, and draws the page again with it,
+ * so an edit anywhere in the app is a hot reload, not a full one. React
+ * Refresh cannot swap the app, which is a value, not a component; the app
+ * carries on from its History, replayed with the new code. In dev it also
+ * turns off the styles the server linked in the head, which the app's own
+ * scripts have added again by then.
+ */
+export const clientEntry = (files, devStyles) => [
+    `import { client } from '@kestack/kabuki/start/client';`,
+    `import app from ${from(files.app)};`,
+    // The app's scripts have added its styles: the server's copy goes off.
+    ...(devStyles
+        ? [
+            `for (const link of window.document.querySelectorAll('link[rel="stylesheet"][href=${JSON.stringify(devStyles)}]'))`,
+            `  if (link.sheet) link.sheet.disabled = true;`,
+        ]
+        : []),
+    `const drawn = import.meta.hot?.data.hydrated;`,
+    `const hydrated = drawn`,
+    `  ? drawn.then((page) => (page.redraw(app), page))`,
+    `  : client(app);`,
+    `if (import.meta.hot) {`,
+    `  import.meta.hot.data.hydrated = hydrated;`,
+    `  import.meta.hot.accept();`,
+    `}`,
+].join('\n');
+export const buildModule = (build) => `export default ${JSON.stringify(build)};`;
+/** The scripts Vite writes in an HTML page's head in dev: its client, and React Refresh's preamble. */
+export const devScripts = (html) => {
+    const head = /<head>([\s\S]*?)<\/head>/.exec(html)?.[1] ?? '';
+    return Array.from(head.matchAll(/<script([^>]*)>([\s\S]*?)<\/script>/g), ([, attributes = '', code = '']) => {
+        const src = /\bsrc="([^"]*)"/.exec(attributes)?.[1];
+        return src !== undefined ? { src } : { code };
+    });
+};

package/dist/start/vite/files.d.ts

@@ -0,0 +1,22 @@
+/** Where Start finds each of the app's files, from the Vite root. */
+export interface FileOptions {
+    /**
+     * Default-exports the app, with its Document and what it needs in the
+     * browser: `Start.app(router, AppView, { … })`, from
+     * `@kestack/kabuki/start`. By default `src/app`.
+     */
+    readonly app?: string;
+    /**
+     * Default-exports the Loaders, with what they need on the server:
+     * `Start.layers()…loaders(Routes.loaders({ … }))`, from
+     * `@kestack/kabuki/start/server`; optional. By default
+     * `src/loaders.server`.
+     */
+    readonly loaders?: string;
+}
+export interface Files {
+    readonly app: string;
+    readonly loaders: string | undefined;
+}
+export declare const findFiles: (root: string, options: FileOptions) => Files;
+//# sourceMappingURL=files.d.ts.map

package/dist/start/vite/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../src/start/vite/files.ts"],"names":[],"mappings":"AAUA,qEAAqE;AACrE,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAsBD,eAAO,MAAM,SAAS,SAAU,MAAM,WAAW,WAAW,KAAG,KAM7D,CAAC"}

package/dist/start/vite/files.js

@@ -0,0 +1,23 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+const EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js', '.mts', '.mjs'];
+/** The file at `name`, as written or with the first extension that exists. */
+const find = (root, name) => {
+    const at = path.resolve(root, name);
+    if (path.extname(at) && existsSync(at))
+        return at;
+    return EXTENSIONS.map((extension) => `${at}${extension}`).find((file) => existsSync(file));
+};
+const required = (root, name, what) => {
+    const found = find(root, name);
+    if (!found)
+        throw new Error(`[@kestack/kabuki/start] no ${what} at ${path.join(root, name)}: write it, or name where it is in start({ … })`);
+    return found;
+};
+export const findFiles = (root, options) => ({
+    app: required(root, options.app ?? 'src/app', 'app'),
+    // Left out, it may be missing; named in the options, it must be there.
+    loaders: options.loaders
+        ? required(root, options.loaders, 'Loaders')
+        : find(root, 'src/loaders.server'),
+});

package/dist/start/vite/index.d.ts

@@ -0,0 +1,2 @@
+export { start } from './vite.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/start/vite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/start/vite/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC"}

package/dist/start/vite/index.js

@@ -0,0 +1 @@
+export { start } from './vite.js';

package/dist/start/vite/lazy.d.ts

@@ -0,0 +1,4 @@
+export declare const mentionsLazy: (code: string) => boolean;
+/** The code with an id on every lazy View that has none; `undefined` if there is none. */
+export declare const withIds: (code: string, root: string, resolve: (specifier: string) => Promise<string | undefined>) => Promise<string | undefined>;
+//# sourceMappingURL=lazy.d.ts.map

package/dist/start/vite/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../../src/start/vite/lazy.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,YAAY,SAAU,MAAM,YAA+B,CAAC;AAEzE,0FAA0F;AAC1F,eAAO,MAAM,OAAO,SACZ,MAAM,QACN,MAAM,WACH,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,KAC1D,OAAO,CAAC,MAAM,GAAG,SAAS,CAiB5B,CAAC"}

package/dist/start/vite/lazy.js

@@ -0,0 +1,30 @@
+import path from 'node:path';
+/*
+ * Every `View.lazy(Actor, () => import('./x'))` given the id of the module it
+ * loads: its path from the Vite root, which is its key in the client
+ * manifest. The server and the browser both see the same id, so a page
+ * names the lazy Views it drew and the browser preloads them.
+ */
+const LAZY = /View\.lazy\(\s*[\w$.]+\s*,\s*\(\)\s*=>\s*import\(\s*(['"`])([^'"`]+)\1\s*\)\s*\)/g;
+export const mentionsLazy = (code) => code.includes('View.lazy');
+/** The code with an id on every lazy View that has none; `undefined` if there is none. */
+export const withIds = async (code, root, resolve) => {
+    const found = [...code.matchAll(LAZY)];
+    if (found.length === 0)
+        return undefined;
+    let out = '';
+    let at = 0;
+    for (const match of found) {
+        const resolved = await resolve(match[2]);
+        if (!resolved)
+            continue;
+        const id = path
+            .relative(root, resolved.split('?')[0])
+            .split(path.sep)
+            .join('/');
+        const end = match.index + match[0].length - 1;
+        out += `${code.slice(at, end)}, { id: ${JSON.stringify(id)} })`;
+        at = end + 1;
+    }
+    return at === 0 ? undefined : out + code.slice(at);
+};

package/dist/start/vite/manifest.d.ts

@@ -0,0 +1,18 @@
+import type { Assets } from '../common/index.ts';
+interface Chunk {
+    readonly file: string;
+    readonly name?: string;
+    readonly isEntry?: boolean;
+    readonly isDynamicEntry?: boolean;
+    readonly imports?: ReadonlyArray<string>;
+    readonly css?: ReadonlyArray<string>;
+}
+export type Manifest = Readonly<Record<string, Chunk>>;
+export declare const filesOf: (manifest: Manifest, base: string) => {
+    entry: Assets;
+    views: {
+        [k: string]: Assets;
+    };
+};
+export {};
+//# sourceMappingURL=manifest.d.ts.map

package/dist/start/vite/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/start/vite/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AASjD,UAAU,KAAK;IACb,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC,QAAQ,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACtC;AAED,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;AA2BvD,eAAO,MAAM,OAAO,aAAc,QAAQ,QAAQ,MAAM;IAUpD,KAAK;IACL,KAAK;;;CAMR,CAAC"}

package/dist/start/vite/manifest.js

@@ -0,0 +1,42 @@
+import { ENTRY } from './entries.js';
+/** A chunk's script, its styles and those of every chunk it imports, and those chunks. */
+const assetsOf = (manifest, key, base) => {
+    const styles = new Set();
+    const preloads = new Set();
+    const seen = new Set();
+    const walk = (at) => {
+        if (seen.has(at))
+            return;
+        seen.add(at);
+        const chunk = manifest[at];
+        if (!chunk)
+            return;
+        for (const css of chunk.css ?? [])
+            styles.add(`${base}${css}`);
+        for (const imported of chunk.imports ?? []) {
+            const file = manifest[imported]?.file;
+            if (file)
+                preloads.add(`${base}${file}`);
+            walk(imported);
+        }
+    };
+    walk(key);
+    return {
+        script: `${base}${manifest[key].file}`,
+        styles: [...styles],
+        preloads: [...preloads],
+    };
+};
+export const filesOf = (manifest, base) => {
+    const entries = Object.entries(manifest);
+    const entry = entries.find(([, chunk]) => chunk.isEntry && chunk.name === ENTRY) ??
+        entries.find(([, chunk]) => chunk.isEntry);
+    if (!entry)
+        throw new Error('[@kestack/kabuki/start] the client build has no entry: is another plugin building the client?');
+    return {
+        entry: assetsOf(manifest, entry[0], base),
+        views: Object.fromEntries(entries
+            .filter(([, chunk]) => chunk.isDynamicEntry)
+            .map(([key]) => [key, assetsOf(manifest, key, base)])),
+    };
+};

package/dist/start/vite/styles.d.ts

@@ -0,0 +1,7 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { ViteDevServer } from 'vite';
+/** Where the stylesheet is served, after Vite's `base`. */
+export declare const DEV_STYLES = "@kabuki-start/styles.css";
+/** The stylesheet the head links in dev: an `@import` of each of the app's, from the server's drawing, else the browser's. */
+export declare const serveStyles: (server: ViteDevServer, files: () => ReadonlyArray<string>) => (incoming: IncomingMessage, outgoing: ServerResponse, next: () => void) => void;
+//# sourceMappingURL=styles.d.ts.map

package/dist/start/vite/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../src/start/vite/styles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAyB,aAAa,EAAE,MAAM,MAAM,CAAC;AAYjE,2DAA2D;AAC3D,eAAO,MAAM,UAAU,6BAA6B,CAAC;AA+BrD,8HAA8H;AAC9H,eAAO,MAAM,WAAW,WACb,aAAa,SAAS,MAAM,aAAa,CAAC,MAAM,CAAC,gBAC/C,eAAe,YAAY,cAAc,QAAQ,MAAM,IAAI,SAwBrE,CAAC"}

package/dist/start/vite/styles.js

@@ -0,0 +1,58 @@
+/*
+ * The app's styles in dev, before its scripts. Vite serves a stylesheet as
+ * a module that adds it to the page when it runs, so a page the server drew
+ * is painted bare until the browser has loaded the app's scripts. The head
+ * links one stylesheet, which imports every stylesheet the app imported
+ * while the server drew it, as plain CSS; the browser waits for them before
+ * the first paint. Once the app's scripts have added their own, the client
+ * entry turns it off, so an edit is drawn by Vite's styles alone.
+ */
+/** Where the stylesheet is served, after Vite's `base`. */
+export const DEV_STYLES = '@kabuki-start/styles.css';
+const CSS = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const NOT_A_STYLESHEET = /[?&](?:inline|url|raw|worker|sharedworker)\b/;
+/** Every stylesheet imported, at any depth, by the modules of `files`, in the order they are imported. */
+const stylesOf = (graph, files) => {
+    const styles = [];
+    const seen = new Set();
+    const walk = (module) => {
+        if (seen.has(module))
+            return;
+        seen.add(module);
+        if (CSS.test(module.url)) {
+            // A stylesheet's own imports are already in it, once Vite has served it.
+            if (!NOT_A_STYLESHEET.test(module.url))
+                styles.push(module.url);
+            return;
+        }
+        for (const imported of module.importedModules)
+            walk(imported);
+    };
+    for (const file of files)
+        for (const module of graph.getModulesByFile(file) ?? [])
+            walk(module);
+    return styles;
+};
+/** The stylesheet the head links in dev: an `@import` of each of the app's, from the server's drawing, else the browser's. */
+export const serveStyles = (server, files) => (incoming, outgoing, next) => {
+    const base = server.config.base;
+    if (incoming.url?.split('?')[0] !== `${base}${DEV_STYLES}`)
+        return next();
+    const environments = Object.values(server.environments);
+    const drawn = environments
+        .filter((environment) => environment.name !== 'client')
+        .flatMap((environment) => stylesOf(environment.moduleGraph, files()));
+    const styles = [
+        ...new Set(drawn.length > 0
+            ? drawn
+            : stylesOf(server.environments.client.moduleGraph, files())),
+    ];
+    outgoing.setHeader('content-type', 'text/css');
+    outgoing.setHeader('cache-control', 'no-store');
+    outgoing.end(styles
+        .map((url) => {
+        const href = `${base}${url.replace(/^\//, '')}${url.includes('?') ? '&' : '?'}direct`;
+        return `@import url(${JSON.stringify(href)});`;
+    })
+        .join('\n'));
+};

package/dist/start/vite/vite.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+import type { Platform } from '../platform/index.ts';
+import type { FileOptions } from './files.ts';
+/** Where the server runs, and where Start finds the app's files, from the Vite root. */
+export interface StartOptions extends FileOptions {
+    /** Where the server runs, as its adapter says: `cloudflare()` from `@kestack/kabuki/start/platform/cloudflare`. */
+    readonly platform: Platform;
+}
+/** Start's Vite plugin. Put it beside the React plugin: `plugins: [react(), start({ platform: cloudflare() })]`. */
+export declare const start: (options: StartOptions) => Plugin;
+//# sourceMappingURL=vite.d.ts.map

package/dist/start/vite/vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../../src/start/vite/vite.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAElD,OAAO,KAAK,EAAW,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAe9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AA6B9C,wFAAwF;AACxF,MAAM,WAAW,YAAa,SAAQ,WAAW;IAC/C,mHAAmH;IACnH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAcD,oHAAoH;AACpH,eAAO,MAAM,KAAK,YAAa,YAAY,KAAG,MA2O7C,CAAC"}