@kestack/kabuki 0.0.0 → 0.0.2

package/dist/start/platform/cloudflare/index.d.ts

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

package/dist/start/platform/cloudflare/index.d.ts.map

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

package/dist/start/platform/cloudflare/index.js

@@ -0,0 +1 @@
+export { cloudflare, serve } from './cloudflare.js';

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

@@ -0,0 +1,2 @@
+export type { Handler, Host, PageCache, Platform } from './platform.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/start/platform/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC"}

package/dist/start/platform/index.js

@@ -0,0 +1 @@
+export {};

package/dist/start/platform/platform.d.ts

@@ -0,0 +1,31 @@
+/** Where static pages are kept, by a key Start makes from the build id and the URL. */
+export interface PageCache {
+    readonly match: (key: Request) => Promise<Response | undefined>;
+    readonly put: (key: Request, response: Response) => Promise<void>;
+}
+/** What a platform hands Start with each request. */
+export interface Host {
+    /** Its bindings and secrets: what the Loaders' Layers are made from. */
+    readonly env: unknown;
+    /** Where static pages are kept; with none, every page is drawn. */
+    readonly cache?: PageCache;
+}
+/** What Start answers requests with, on any platform. */
+export interface Handler {
+    readonly fetch: (request: Request, host: Host) => Promise<Response>;
+}
+/** What the Vite plugin needs to know of a platform to build for it. */
+export interface Platform {
+    readonly name: string;
+    /** The conditions the server build resolves its dependencies with. */
+    readonly conditions: ReadonlyArray<string>;
+    /**
+     * The adapter function the server entry wraps Start's `Handler` in, by
+     * module and export: the entry default-exports `serve(handler)`.
+     */
+    readonly serve: {
+        readonly from: string;
+        readonly name: string;
+    };
+}
+//# sourceMappingURL=platform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../src/start/platform/platform.ts"],"names":[],"mappings":"AAaA,uFAAuF;AACvF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC;IAChE,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE;AAED,qDAAqD;AACrD,MAAM,WAAW,IAAI;IACnB,wEAAwE;IACxE,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,mEAAmE;IACnE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;CAC5B;AAED,yDAAyD;AACzD,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CACrE;AAED,wEAAwE;AACxE,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC3C;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAClE"}

package/dist/start/platform/platform.js

@@ -0,0 +1,13 @@
+/*
+ * Where Start runs: the port every platform's adapter fills, each in a
+ * folder of its own under this one, imported from its own subpath, so a
+ * build carries only the adapter it names.
+ *
+ * - At build time, the Vite plugin reads a `Platform`: how to resolve the
+ *   server's dependencies, and which adapter function turns Start's
+ *   `Handler` into what the platform runs.
+ * - At run time, that adapter function hands every request to the
+ *   `Handler` with a `Host`: the platform's env and, if it has one, a
+ *   `PageCache`.
+ */
+export {};

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

@@ -0,0 +1,4 @@
+import type { PageCache } from '../platform/index.ts';
+/** The page at `url` for this build: from the Cache if it is there, else drawn and, if it may be `shared`, put there. */
+export declare const kept: (cache: PageCache | undefined, shared: string, build: string, url: URL, draw: () => Promise<Response>) => Promise<Response>;
+//# sourceMappingURL=cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/start/server/cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAUtD,yHAAyH;AACzH,eAAO,MAAM,IAAI,UACR,SAAS,GAAG,SAAS,UACpB,MAAM,SACP,MAAM,OACR,GAAG,QACF,MAAM,OAAO,CAAC,QAAQ,CAAC,KAC5B,OAAO,CAAC,QAAQ,CAiBlB,CAAC"}

package/dist/start/server/cache.js

@@ -0,0 +1,26 @@
+/*
+ * Static pages kept in the platform's Cache, under a key with the build id,
+ * so each is drawn once per deploy per data center. The first drawing is
+ * kept before it is sent, so the next request finds it, and goes out with
+ * the same Cache-Control as when it was drawn. With no Cache, as in dev or
+ * in Node, every page is drawn.
+ */
+/** The page at `url` for this build: from the Cache if it is there, else drawn and, if it may be `shared`, put there. */
+export const kept = async (cache, shared, build, url, draw) => {
+    if (!cache)
+        return draw();
+    const key = new Request(`${url.origin}/_kabuki/cache/${encodeURIComponent(build)}${url.pathname}${url.search}`);
+    const hit = await cache.match(key);
+    // A zone's Browser Cache TTL raises the max-age of what comes out of the
+    // Cache: the browser must still ask again, so a deploy is seen at once.
+    if (hit) {
+        const response = new Response(hit.body, hit);
+        response.headers.set('cache-control', shared);
+        return response;
+    }
+    const response = await draw();
+    if (response.headers.get('cache-control') !== shared)
+        return response;
+    await cache.put(key, response.clone());
+    return response;
+};

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

@@ -0,0 +1,10 @@
+import type { Known } from '../../routing/page/index.ts';
+import type { Build, DocumentType, ServedApp } from '../common/index.ts';
+/** What one drawing starts from: the Route and what its server-drawn places start from, by dotted name. */
+export interface At {
+    readonly route: unknown;
+    readonly known?: Readonly<Record<string, Known>>;
+}
+/** Draws the app at a Route as a whole HTML page; throws if anything in it fails to draw. */
+export declare const drawer: (app: ServedApp, Document: DocumentType, build: Build) => (at: At) => Promise<string>;
+//# sourceMappingURL=draw.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"draw.d.ts","sourceRoot":"","sources":["../../../src/start/server/draw.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAGzD,OAAO,KAAK,EAEV,KAAK,EACL,YAAY,EAEZ,SAAS,EACV,MAAM,oBAAoB,CAAC;AAe5B,2GAA2G;AAC3G,MAAM,WAAW,EAAE;IACjB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;CAClD;AA+CD,6FAA6F;AAC7F,eAAO,MAAM,MAAM,QACZ,SAAS,YACJ,YAAY,SACf,KAAK,UAQM,EAAE,KAAG,OAAO,CAAC,MAAM,CA6CtC,CAAC"}

package/dist/start/server/draw.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderToReadableStream } from 'react-dom/server';
+import { Layer } from 'effect';
+import { History } from '../../core/index.js';
+import { toReact } from '../../react/index.js';
+import { tagsOf } from '../../routing/route/index.js';
+import { PageContext, serialize } from '../common/index.js';
+/** The data among what places start from, by dotted name: what the Metadata is worked out from. */
+const dataOf = (known = {}) => Object.fromEntries(Object.entries(known).flatMap(([name, each]) => each._tag === 'Ready' ? [[name, each.data]] : []));
+const attribute = (value) => value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
+/** The files of a lazy View, by its id: in dev, its module itself. */
+const filesOf = (build, id) => build.views === null
+    ? { script: `${build.base}${id}`, styles: [], preloads: [] }
+    : build.views[id];
+/** The tags that load the lazy Views a drawing drew, less what the entry loads already. */
+const lazyTags = (build, ids) => {
+    const seen = new Set([
+        build.entry.script,
+        ...build.entry.styles,
+        ...build.entry.preloads,
+    ]);
+    const once = (href) => !seen.has(href) && seen.add(href);
+    let tags = '';
+    for (const id of ids) {
+        const files = filesOf(build, id);
+        if (!files)
+            continue;
+        for (const href of files.styles.filter(once))
+            tags += `<link rel="stylesheet" href="${attribute(href)}">`;
+        for (const href of files.preloads.filter(once))
+            tags += `<link rel="modulepreload" href="${attribute(href)}">`;
+        seen.add(files.script);
+        tags += `<link rel="modulepreload" href="${attribute(files.script)}" data-kabuki-view="${attribute(id)}">`;
+    }
+    return tags;
+};
+/** The script that puts the page's scroll back before the app hydrates, where the Router restores it. */
+const scrollOf = (app, route) => {
+    const scroll = app.restoreScroll?.(route);
+    return scroll ? { scroll } : {};
+};
+/** Draws the app at a Route as a whole HTML page; throws if anything in it fails to draw. */
+export const drawer = (app, Document, build) => {
+    const App = toReact(app.actor, app.view, Layer.empty);
+    return async (at) => {
+        const history = History.make(app.actor, { input: at });
+        const saved = History.restored(app.actor, history.snapshotAt(null), 0).save();
+        const metadata = app.routes.metadata(at.route, dataOf(at.known));
+        const page = {
+            entry: build.entry,
+            head: build.head,
+            saved,
+            drawn: { at: Date.now(), build: build.id },
+            ...scrollOf(app, at.route),
+        };
+        const views = new Set();
+        const failures = [];
+        const stream = await renderToReadableStream(_jsx(PageContext, { value: {
+                ...serialize(page),
+                metadata: { title: metadata.title, tags: tagsOf(metadata) },
+            }, children: _jsx(Document, { children: _jsx(App, { saved: saved, onLazyView: (view) => {
+                        if (view.id !== undefined)
+                            views.add(view.id);
+                    } }) }) }), { onError: (error) => void failures.push(error) });
+        await stream.allReady;
+        const html = await new Response(stream).text();
+        if (failures.length > 0)
+            throw failures[0];
+        const head = html.indexOf('</head>');
+        const whole = head < 0
+            ? html
+            : `${html.slice(0, head)}${lazyTags(build, views)}${html.slice(head)}`;
+        return whole.startsWith('<!DOCTYPE') ? whole : `<!DOCTYPE html>${whole}`;
+    };
+};

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

@@ -0,0 +1,3 @@
+export { server } from './server.tsx';
+export { Start } from './layers.ts';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/start/server/index.js

@@ -0,0 +1,2 @@
+export { server } from './server.js';
+export { Start } from './layers.js';

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

@@ -0,0 +1,97 @@
+import { Context } from 'effect';
+import type { Effect, Layer } from 'effect';
+import type { LoadError, StaticOf } from '../../routing/route/index.ts';
+/** One place's Loader, as `Routes.loaders` types it. */
+export type AnyLoader = (params: never, request: Request) => Effect.Effect<unknown, LoadError, any>;
+type AnyLoaders = Readonly<Record<string, AnyLoader>>;
+declare const ResponseHeaders_base: Context.ServiceClass<ResponseHeaders, "@kestack/kabuki/start/ResponseHeaders", {
+    readonly append: (name: string, value: string) => Effect.Effect<void>;
+}>;
+/**
+ * Headers for the response to the request being answered, as a refreshed
+ * session's `set-cookie`: for the visitor Layer and the dynamic and client
+ * Loaders, never a static one, whose page is kept for everyone.
+ */
+export declare class ResponseHeaders extends ResponseHeaders_base {
+}
+/** The tiers as Start makes them: each a function of what it is made from. */
+export interface Tiers {
+    /** Made once, the first time it is needed, and kept: clients of bindings, config, caches. */
+    readonly instance?: (env: any) => Layer.Layer<any, unknown, never>;
+    /** Made for each request that loads, from the env alone: what must not outlive a request, like a database connection. */
+    readonly request?: (env: any) => Layer.Layer<any, unknown, never>;
+    /** Made for each request that loads a dynamic or client place, from the env and the request itself: who is signed in. */
+    readonly visitor?: (from: {
+        readonly env: any;
+        readonly request: Request;
+    }) => Layer.Layer<any, unknown, never>;
+}
+declare const LOADERS: unique symbol;
+/** The Loaders and what they Require: what `src/loaders.server` default-exports. */
+export interface StartLoaders<L = AnyLoaders> {
+    readonly [LOADERS]: true;
+    readonly loaders: L;
+    readonly tiers: Tiers;
+}
+/** What the Loaders of `L` named `K` Require. */
+type ServicesOf<L, K extends keyof L> = {
+    [P in K]-?: L[P] extends (...args: never) => Effect.Effect<any, any, infer R> ? R : never;
+}[K];
+type Names<L> = keyof L & string;
+/** What the static places' Loaders Require. */
+type StaticNeeds<L> = ServicesOf<L, StaticOf<L> & Names<L>>;
+/** What the dynamic and client places' Loaders Require. */
+type LaterNeeds<L> = ServicesOf<L, Exclude<Names<L>, StaticOf<L>>>;
+/** What is missing, named, if anything is. */
+type Missing<Need, Given, Says extends string> = [
+    Exclude<Need, Given>
+] extends [never] ? unknown : {
+    readonly [K in Says]: Exclude<Need, Given>;
+};
+/**
+ * The Loaders, checked against the tiers: each Requirement no tier they
+ * may use gives is a property they miss, named by what Requires it.
+ */
+type Covered<L, I, R, V> = Missing<StaticNeeds<L>, I | R, 'static Loaders Require what no instance or request Layer gives'> & Missing<LaterNeeds<L>, I | R | V | ResponseHeaders, 'dynamic and client Loaders Require what no Layer gives'>;
+/**
+ * The tiers given so far, with what each gives: `I`, `R` and `V`. Each
+ * tier is checked as it is given against those before it; the Loaders,
+ * last, against all of them.
+ */
+export interface LayersOf<Env, I, R, V> {
+    /** Made once, from the env, the first time it is needed, and kept for every request: it Requires nothing. */
+    readonly instance: <Given>(make: (env: Env) => Layer.Layer<Given, unknown, never>) => LayersOf<Env, Given, R, V>;
+    /** Made for each request that loads, from the env: it may Require what the instance tier gives. */
+    readonly request: <Given>(make: (env: Env) => Layer.Layer<Given, unknown, I>) => LayersOf<Env, I, Given, V>;
+    /**
+     * Made for each request that loads a dynamic or client place, from the
+     * env and the request: it may Require what the instance and request
+     * tiers give, and `ResponseHeaders`.
+     */
+    readonly visitor: <Given>(make: (from: {
+        readonly env: Env;
+        readonly request: Request;
+    }) => Layer.Layer<Given, unknown, I | R | ResponseHeaders>) => LayersOf<Env, I, R, Given>;
+    /** The Loaders, checked against every tier: what `src/loaders.server` default-exports. */
+    readonly loaders: <const L extends AnyLoaders>(loaders: L & Covered<L, I, R, V>) => StartLoaders<L>;
+}
+/**
+ * The Loaders' Layers, a tier at a time, the env typed as the platform
+ * gives it: `Start.layers<WorkerEnv>().instance(…).request(…).visitor(…)
+ * .loaders(loaders)`. Every tier is optional; `.loaders` ends it.
+ */
+export declare const layers: <Env = unknown>() => LayersOf<Env, never, never, never>;
+/** What `src/loaders.server` default-exports, if there is one: `Start.layers()…loaders(…)`, and nothing else, so it is checked. */
+export declare const loadersOf: (exported: unknown) => StartLoaders;
+/**
+ * Start, as `src/loaders.server` writes it: `Start.layers()`, the Loaders
+ * with what they Require on the server, in three tiers, a call each; and
+ * `Start.ResponseHeaders`, what a dynamic or client Loader adds headers to
+ * its response with.
+ */
+export declare const Start: {
+    layers: typeof layers;
+    ResponseHeaders: typeof ResponseHeaders;
+};
+export {};
+//# sourceMappingURL=layers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layers.d.ts","sourceRoot":"","sources":["../../../src/start/server/layers.ts"],"names":[],"mappings":"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"}

package/dist/start/server/layers.js

@@ -0,0 +1,37 @@
+import { Context } from 'effect';
+import { branded, refused } from '../common/index.js';
+/**
+ * Headers for the response to the request being answered, as a refreshed
+ * session's `set-cookie`: for the visitor Layer and the dynamic and client
+ * Loaders, never a static one, whose page is kept for everyone.
+ */
+export class ResponseHeaders extends Context.Service()('@kestack/kabuki/start/ResponseHeaders') {
+}
+const LOADERS = Symbol.for('@kestack/kabuki/start/loaders');
+const layersOf = (tiers) => ({
+    instance: (make) => layersOf({ ...tiers, instance: make }),
+    request: (make) => layersOf({ ...tiers, request: make }),
+    visitor: (make) => layersOf({ ...tiers, visitor: make }),
+    loaders: (loaders) => ({ [LOADERS]: true, loaders, tiers }),
+});
+/**
+ * The Loaders' Layers, a tier at a time, the env typed as the platform
+ * gives it: `Start.layers<WorkerEnv>().instance(…).request(…).visitor(…)
+ * .loaders(loaders)`. Every tier is optional; `.loaders` ends it.
+ */
+export const layers = () => layersOf({});
+/** What `src/loaders.server` default-exports, if there is one: `Start.layers()…loaders(…)`, and nothing else, so it is checked. */
+export const loadersOf = (exported) => {
+    if (exported === undefined)
+        return { [LOADERS]: true, loaders: {}, tiers: {} };
+    if (branded(exported, LOADERS))
+        return exported;
+    throw refused('src/loaders.server', 'Start.layers().loaders(Routes.loaders({ … }))');
+};
+/**
+ * Start, as `src/loaders.server` writes it: `Start.layers()`, the Loaders
+ * with what they Require on the server, in three tiers, a call each; and
+ * `Start.ResponseHeaders`, what a dynamic or client Loader adds headers to
+ * its response with.
+ */
+export const Start = { layers, ResponseHeaders };

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

@@ -0,0 +1,15 @@
+/** A page every server-drawn place of which is static: the same for everyone until the next deploy. */
+export declare const SHARED = "public, max-age=0, s-maxage=31536000, no-transform";
+/** A page drawn for this request alone. */
+export declare const PRIVATE = "private, no-store, no-transform";
+export declare const html: (body: string, status: number, cache: string) => Response;
+/** A URL that is not written as its Route is, a redirect in the Routes, or a Loader's permanent Redirect: for good. */
+export declare const permanent: (location: string) => Response;
+/** A Loader's Redirect: it depends on the request, so it is neither permanent nor kept. */
+export declare const found: (location: string) => Response;
+export declare const notAllowed: () => Response;
+/** What a page that could not be drawn answers: nothing about why, which is logged. */
+export declare const broken: () => Response;
+/** The answer to a `HEAD`: a `GET`'s, without its body. */
+export declare const headOf: (response: Response) => Response;
+//# sourceMappingURL=respond.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"respond.d.ts","sourceRoot":"","sources":["../../../src/start/server/respond.ts"],"names":[],"mappings":"AAWA,uGAAuG;AACvG,eAAO,MAAM,MAAM,uDAAuD,CAAC;AAC3E,2CAA2C;AAC3C,eAAO,MAAM,OAAO,oCAAoC,CAAC;AAEzD,eAAO,MAAM,IAAI,SAAU,MAAM,UAAU,MAAM,SAAS,MAAM,aAO5D,CAAC;AAEL,uHAAuH;AACvH,eAAO,MAAM,SAAS,aAAc,MAAM,aACkB,CAAC;AAE7D,2FAA2F;AAC3F,eAAO,MAAM,KAAK,aAAc,MAAM,aAIlC,CAAC;AAEL,eAAO,MAAM,UAAU,gBAC+C,CAAC;AAEvE,uFAAuF;AACvF,eAAO,MAAM,MAAM,gBAKhB,CAAC;AAEJ,2DAA2D;AAC3D,eAAO,MAAM,MAAM,aAAc,QAAQ,aAIrC,CAAC"}

package/dist/start/server/respond.js

@@ -0,0 +1,35 @@
+/*
+ * The responses Start sends besides a drawn page's own, and how long each
+ * may be kept.
+ */
+/*
+ * Every page is `no-transform`: the browser hydrates the whole Document, so
+ * it must get it as drawn. Edge rewriting, as Cloudflare's injected Web
+ * Analytics beacon, email obfuscation or Rocket Loader, would change it.
+ */
+/** A page every server-drawn place of which is static: the same for everyone until the next deploy. */
+export const SHARED = 'public, max-age=0, s-maxage=31536000, no-transform';
+/** A page drawn for this request alone. */
+export const PRIVATE = 'private, no-store, no-transform';
+export const html = (body, status, cache) => new Response(body, {
+    status,
+    headers: {
+        'content-type': 'text/html; charset=utf-8',
+        'cache-control': cache,
+    },
+});
+/** A URL that is not written as its Route is, a redirect in the Routes, or a Loader's permanent Redirect: for good. */
+export const permanent = (location) => new Response(null, { status: 308, headers: { location } });
+/** A Loader's Redirect: it depends on the request, so it is neither permanent nor kept. */
+export const found = (location) => new Response(null, {
+    status: 302,
+    headers: { location, 'cache-control': PRIVATE },
+});
+export const notAllowed = () => new Response(null, { status: 405, headers: { allow: 'GET, HEAD' } });
+/** What a page that could not be drawn answers: nothing about why, which is logged. */
+export const broken = () => html('<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><title>Something went wrong</title></head><body><h1>Something went wrong</h1><p>This page could not be drawn. Try again in a moment.</p></body></html>', 500, PRIVATE);
+/** The answer to a `HEAD`: a `GET`'s, without its body. */
+export const headOf = (response) => new Response(null, {
+    status: response.status,
+    headers: response.headers,
+});

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

@@ -0,0 +1,11 @@
+import { Stream } from 'effect';
+import type { Outcome } from '../../routing/route/index.ts';
+import type { RoutesOnWire, Wanted } from '../common/index.ts';
+/**
+ * The server's side: reads the places a request asks for, then streams a
+ * line per place as `each` answers it. `open` makes what the Loaders run
+ * with before the answer starts, so the headers it adds go out with it; the
+ * stream it hands back runs inside that. A malformed ask is a `400`.
+ */
+export declare const answer: (routes: RoutesOnWire, request: Request, open: (wanted: ReadonlyArray<Wanted>) => Promise<Stream.Stream<readonly [string, Outcome]>>) => Promise<Response>;
+//# sourceMappingURL=rpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../../src/start/server/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAE5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAoB/D;;;;;GAKG;AACH,eAAO,MAAM,MAAM,WACT,YAAY,WACX,OAAO,QACV,CACJ,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,KAC1B,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,KACtD,OAAO,CAAC,QAAQ,CAsClB,CAAC"}

package/dist/start/server/rpc.js

@@ -0,0 +1,51 @@
+import { Cause, Effect, Exit, Fiber, Stream } from 'effect';
+import { NDJSON, loadable, readAsk, writeLine } from '../common/index.js';
+/*
+ * The Loader RPC, answered: the places a request asks for read with their
+ * Schemas, their Loaders run at once, and each line written as its place is
+ * done. The protocol is `common/wire.ts`.
+ */
+const json = (body, status) => new Response(JSON.stringify(body), {
+    status,
+    headers: {
+        'content-type': 'application/json',
+        'cache-control': 'private, no-store',
+    },
+});
+const reason = (error) => error.cause instanceof Error ? error.cause.message : 'the ask is not JSON';
+/**
+ * The server's side: reads the places a request asks for, then streams a
+ * line per place as `each` answers it. `open` makes what the Loaders run
+ * with before the answer starts, so the headers it adds go out with it; the
+ * stream it hands back runs inside that. A malformed ask is a `400`.
+ */
+export const answer = async (routes, request, open) => {
+    const places = loadable(routes);
+    let wanted;
+    try {
+        wanted = readAsk(places, await request.json());
+    }
+    catch (error) {
+        return json({ error: reason({ cause: error }) }, 400);
+    }
+    const lines = await open(wanted);
+    const encoder = new TextEncoder();
+    let running;
+    const body = new ReadableStream({
+        start: (controller) => {
+            running = Effect.runFork(Stream.runForEach(lines, ([name, outcome]) => Effect.sync(() => controller.enqueue(encoder.encode(`${JSON.stringify(writeLine(routes, places, { name, outcome }))}\n`)))));
+            running.addObserver((exit) => {
+                if (Exit.isSuccess(exit))
+                    return controller.close();
+                const { cause } = exit;
+                if (!Cause.hasInterruptsOnly(cause))
+                    controller.error(Cause.squash(cause));
+            });
+        },
+        // The browser went away: the Loaders still running stop.
+        cancel: () => running ? Effect.runPromise(Fiber.interrupt(running)) : undefined,
+    });
+    return new Response(body, {
+        headers: { 'content-type': NDJSON, 'cache-control': 'private, no-store' },
+    });
+};

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

@@ -0,0 +1,13 @@
+import type { Build, StartApp } from '../common/index.ts';
+import type { Handler } from '../platform/index.ts';
+import type { StartLoaders } from './layers.ts';
+export interface ServerOptions {
+    /** What `src/app` default-exports: `Start.app(…)`. */
+    readonly app: StartApp;
+    /** What `src/loaders.server` default-exports: `Start.layers()…loaders(…)`; none if no place has an Input. */
+    readonly loaders?: StartLoaders;
+    /** What the Vite plugin knows of the build. */
+    readonly build: Build;
+}
+export declare const server: (options: ServerOptions) => Handler;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/start/server/server.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAU,MAAM,oBAAoB,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAQ,MAAM,sBAAsB,CAAC;AAK1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA0ChD,MAAM,WAAW,aAAa;IAC5B,sDAAsD;IACtD,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,6GAA6G;IAC7G,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;IAChC,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;CACvB;AAgBD,eAAO,MAAM,MAAM,YAAa,aAAa,KAAG,OAkM/C,CAAC"}