@kestack/kabuki 0.0.1 → 0.0.2

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

@@ -0,0 +1,14 @@
+import { Layer } from 'effect';
+import { Loading } from '../../routing/index.ts';
+import type { RoutesOnWire } from '../common/index.ts';
+/**
+ * The browser's side: a `Loading` that asks the server, in one request per
+ * ask, and hands on each place's answer as it comes. A request that does
+ * not get an answer breaks every place it asked for, so each page shows it
+ * failed and can retry.
+ */
+export declare const loading: (routes: RoutesOnWire, options?: {
+    readonly fetch?: typeof fetch;
+    readonly url?: string;
+}) => Layer.Layer<Loading>;
+//# sourceMappingURL=rpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../../src/start/client/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,EAAU,MAAM,QAAQ,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAGjD,OAAO,KAAK,EAAQ,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAQ7D;;;;;GAKG;AACH,eAAO,MAAM,OAAO,WACV,YAAY,YACX;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,KAChE,KAAK,CAAC,KAAK,CAAC,OAAO,CAkFrB,CAAC"}

package/dist/start/client/rpc.js

@@ -0,0 +1,70 @@
+import { Cause, Effect, Layer, Stream } from 'effect';
+import { Loading } from '../../routing/index.js';
+import { PATH, loadable, readLine, writeAsk } from '../common/index.js';
+/*
+ * The Loader RPC, asked: the `Loading` behind the browser's Data cache, one
+ * request for every place asked for at once, each answered as its line
+ * comes. The protocol is `common/wire.ts`.
+ */
+/**
+ * The browser's side: a `Loading` that asks the server, in one request per
+ * ask, and hands on each place's answer as it comes. A request that does
+ * not get an answer breaks every place it asked for, so each page shows it
+ * failed and can retry.
+ */
+export const loading = (routes, options = {}) => {
+    const places = loadable(routes);
+    const send = options.fetch ?? ((input, init) => fetch(input, init));
+    const each = (wanted) => {
+        const answered = new Set();
+        let broken;
+        return Stream.unwrap(Effect.gen(function* () {
+            const response = yield* Effect.tryPromise({
+                try: (signal) => send(options.url ?? PATH, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify(writeAsk(places, wanted)),
+                    signal,
+                }),
+                catch: (cause) => cause,
+            });
+            if (!response.ok || !response.body)
+                return yield* Effect.fail(new Error(`the Loader RPC answered ${response.status}`));
+            return Stream.fromReadableStream({
+                evaluate: () => response.body,
+                onError: (cause) => cause,
+            }).pipe(Stream.decodeText(), Stream.splitLines, Stream.filter((line) => line.trim() !== ''), Stream.map((line) => {
+                try {
+                    const read = readLine(routes, places, JSON.parse(line));
+                    answered.add(read.name);
+                    return [read.name, read.outcome];
+                }
+                catch (error) {
+                    broken = error instanceof Error ? error.message : String(error);
+                    return null;
+                }
+            }), Stream.filter((entry) => entry !== null));
+        })).pipe(Stream.catchCause((cause) => {
+            const error = Cause.squash(cause);
+            broken =
+                error instanceof Error
+                    ? error.message
+                    : 'the Loader RPC did not answer';
+            return Stream.empty;
+        }), 
+        // Every place the answer did not reach is broken, with why if it broke.
+        Stream.concat(Stream.suspend(() => Stream.fromIterable(wanted
+            .filter(({ name }) => !answered.has(name))
+            .map(({ name }) => [
+            name,
+            {
+                _tag: 'Broken',
+                reason: broken ?? `no answer for ${name}`,
+            },
+        ])))));
+    };
+    return Layer.succeed(Loading, {
+        each,
+        load: (wanted) => Stream.runCollect(each(wanted)).pipe(Effect.map((answers) => Object.fromEntries(answers))),
+    });
+};

package/dist/start/common/app.d.ts

@@ -0,0 +1,66 @@
+import type { ComponentType, ReactNode } from 'react';
+import type { Layer } from 'effect';
+import type { AnyActor, Needs } from '../../core/index.ts';
+import type { ViewOf } from '../../react/index.ts';
+import type { Navigation, PageBuild, PageDefinition } from '../../routing/index.ts';
+import type { Codec, Metadata, Place, PlaceData, PlaceSchema } from '../../routing/route/index.ts';
+/** What Start needs of the app the Router serves: what `Router.app(router, AppView)` gives. */
+export interface ServedApp {
+    readonly actor: AnyActor;
+    readonly view: ViewOf<any>;
+    /** The Router's Input at a URL, with what its places start from, by dotted name. */
+    readonly startAt: (url?: string, known?: Readonly<Record<string, any>>) => {
+        readonly route: any;
+        readonly known?: object;
+    } | undefined;
+    readonly href: (route: any) => string;
+    /** The script that puts a page's scroll back before the app hydrates, or `null` where the Router restores none. */
+    readonly restoreScroll?: (route: any) => string | null;
+    readonly routes: {
+        readonly route: Codec<any>;
+        readonly path: (route: any) => string;
+        readonly metadata: (of: any, data?: PlaceData) => Metadata;
+        readonly places: (of: any) => ReadonlyArray<Place>;
+        readonly every: ReadonlyArray<PlaceSchema>;
+    };
+}
+export type DocumentType = ComponentType<{
+    readonly children: ReactNode;
+}>;
+declare const APP: unique symbol;
+/** The app and what it needs in the browser: what `src/app` default-exports. */
+export interface StartApp<A extends ServedApp = ServedApp> {
+    readonly [APP]: true;
+    readonly app: A;
+    /** The HTML around the app; the plainest one if none. */
+    readonly document?: DocumentType;
+    /** What the app's Actors Require in the browser, besides the address and the Loaders. */
+    readonly layer?: Layer.Layer<any, never, never>;
+}
+/** What the root page's build still needs from above, besides what the Router Provides. */
+type NeedsOf<A> = Exclude<Needs<A>, Navigation>;
+/** The app's Layer, which must cover every Capability the tree still needs. */
+type AppOptions<A> = {
+    readonly document?: DocumentType;
+} & ([NeedsOf<A>] extends [never] ? {
+    readonly layer?: Layer.Layer<never, never, never>;
+} : {
+    readonly layer: Layer.Layer<NeedsOf<A>, never, never>;
+});
+/**
+ * The app, its Document, and what its Actors Require in the browser:
+ * `export default Start.app(router, AppView, { document, layer })`, where
+ * `AppView` draws the build of the router's root page. Leaving out a
+ * Capability the app Requires is a type error.
+ */
+export declare const app: <G extends PageDefinition, A extends PageBuild<G>>(router: {
+    readonly root: G;
+}, view: ViewOf<A>, ...[options]: [NeedsOf<A>] extends [never] ? [options?: AppOptions<A>] : [options: AppOptions<A>]) => StartApp;
+/** Why a file's default export is refused: only Start's own values are checked by type. */
+export declare const refused: (file: string, what: string) => Error;
+/** Whether `value` is one of Start's own, by its brand. */
+export declare const branded: (value: unknown, brand: symbol) => boolean;
+/** What `src/app` default-exports: `Start.app(…)`, and nothing else, so its Layer is checked. */
+export declare const appOf: (exported: unknown) => StartApp;
+export {};
+//# sourceMappingURL=app.d.ts.map

package/dist/start/common/app.d.ts.map

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

package/dist/start/common/app.js

@@ -0,0 +1,23 @@
+import { Router } from '../../routing/index.js';
+const APP = Symbol.for('@kestack/kabuki/start/app');
+/**
+ * The app, its Document, and what its Actors Require in the browser:
+ * `export default Start.app(router, AppView, { document, layer })`, where
+ * `AppView` draws the build of the router's root page. Leaving out a
+ * Capability the app Requires is a type error.
+ */
+export const app = (router, view, ...[options]) => ({
+    [APP]: true,
+    app: Router.app(router, view),
+    ...options,
+});
+/** Why a file's default export is refused: only Start's own values are checked by type. */
+export const refused = (file, what) => new Error(`[@kestack/kabuki/start] ${file} must default-export ${what}, so it is checked by type`);
+/** Whether `value` is one of Start's own, by its brand. */
+export const branded = (value, brand) => typeof value === 'object' && value !== null && brand in value;
+/** What `src/app` default-exports: `Start.app(…)`, and nothing else, so its Layer is checked. */
+export const appOf = (exported) => {
+    if (branded(exported, APP))
+        return exported;
+    throw refused('src/app', 'Start.app(router, AppView, { … })');
+};

package/dist/start/common/common.d.ts

@@ -0,0 +1,26 @@
+import { app } from './app.ts';
+import { Document, Head, Scripts, useDrawn, useRuntime } from './document.tsx';
+import type { DocumentProps as Props, Drawn as DrawnBy } from './document.tsx';
+/**
+ * What an app writes for Start on both sides: `Start.app(…)`, the app with
+ * its Document and what it needs in the browser. The parts of the Document
+ * Start fills: `<Start.Head />` in its `<head>`, `<Start.Scripts />` at the
+ * end of its `<body>`; `Start.Document`, the plainest one;
+ * `Start.useDrawn()`, when and by which build the server drew the page; and
+ * `Start.useRuntime()`, the running app, for devtools in the Document.
+ */
+export declare const Start: {
+    app: typeof app;
+    Document: typeof Document;
+    Head: typeof Head;
+    Scripts: typeof Scripts;
+    useDrawn: typeof useDrawn;
+    useRuntime: typeof useRuntime;
+};
+export declare namespace Start {
+    /** What the Document is drawn with: the app, as its children, to put in `<body>`. */
+    type DocumentProps = Props;
+    /** What `Start.useDrawn()` gives. */
+    type Drawn = DrawnBy;
+}
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/start/common/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,IAAI,KAAK,EAAE,KAAK,IAAI,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAW/E;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;;;;;;;CAAyD,CAAC;AAE5E,MAAM,CAAC,OAAO,WAAW,KAAK,CAAC;IAC7B,qFAAqF;IACrF,KAAY,aAAa,GAAG,KAAK,CAAC;IAClC,qCAAqC;IACrC,KAAY,KAAK,GAAG,OAAO,CAAC;CAC7B"}

package/dist/start/common/common.js

@@ -0,0 +1,19 @@
+import { app } from './app.js';
+import { Document, Head, Scripts, useDrawn, useRuntime } from './document.js';
+/*
+ * Start, as `src/app` writes it, on both sides: what `@kestack/kabuki/start`
+ * gives. The server's own, `Start.layers()` for `src/loaders.server`, is
+ * `@kestack/kabuki/start/server`'s.
+ *
+ *   src/app.tsx           Start.app(router, AppView, { document, layer })
+ *   src/document.tsx      <Start.Head /> in its head, <Start.Scripts /> at the end of its body
+ */
+/**
+ * What an app writes for Start on both sides: `Start.app(…)`, the app with
+ * its Document and what it needs in the browser. The parts of the Document
+ * Start fills: `<Start.Head />` in its `<head>`, `<Start.Scripts />` at the
+ * end of its `<body>`; `Start.Document`, the plainest one;
+ * `Start.useDrawn()`, when and by which build the server drew the page; and
+ * `Start.useRuntime()`, the running app, for devtools in the Document.
+ */
+export const Start = { app, Document, Head, Scripts, useDrawn, useRuntime };

package/dist/start/common/document.d.ts

@@ -0,0 +1,44 @@
+import type { ReactNode } from 'react';
+import type { AppRuntime } from '../../react/index.ts';
+/**
+ * The Metadata, the styles and the preloads, in the order the browser wants
+ * them: the charset and viewport first, then the title and every Metadata
+ * tag, then the entry's styles and the chunks it imports. The Metadata is
+ * drawn on the server only: in the browser the Router writes it after every
+ * move, so React leaves the tags the server drew alone.
+ */
+declare function Head(): import("react").JSX.Element;
+/** The Page as JSON, which the browser starts from, and the client entry that does it. */
+declare function Scripts(): import("react").JSX.Element;
+/**
+ * When the server drew this page, and by which build; and whether the
+ * component that asks was in that drawing, `hydrated`, or was drawn later
+ * by the browser, after a move. `null` outside a page Start served, as in a
+ * test or a story. A component keeps its answer for as long as it is
+ * mounted.
+ */
+declare function useDrawn(): Drawn | null;
+/**
+ * The running app, for devtools drawn in the Document around it: its
+ * History, the Step shown, and how to show another. `null` on the server,
+ * which draws each request from a History of its own and runs none, and
+ * outside a page Start served.
+ */
+declare function useRuntime(): AppRuntime | null;
+/** The plainest Document, for an app that gives none: Start's parts in an English page. */
+declare function Document({ children }: DocumentProps): import("react").JSX.Element;
+/** What the Document is drawn with: the app, as its children, to put in `<body>`. */
+export interface DocumentProps {
+    readonly children: ReactNode;
+}
+/** What `useDrawn()` gives: when and by which build the server drew the page, and whether the component asking was in it. */
+export interface Drawn {
+    /** When the server drew the page, in milliseconds since the epoch, after its Loaders answered. */
+    readonly at: number;
+    /** The build that drew it; none in dev. */
+    readonly build: string | undefined;
+    /** Whether the component asking was drawn by the server and hydrated, rather than by the browser after. */
+    readonly hydrated: boolean;
+}
+export { Document, Head, Scripts, useDrawn, useRuntime };
+//# sourceMappingURL=document.d.ts.map

package/dist/start/common/document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../src/start/common/document.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAWvD;;;;;;GAMG;AACH,iBAAS,IAAI,gCA6BZ;AAED,0FAA0F;AAC1F,iBAAS,OAAO,gCAgBf;AAID;;;;;;GAMG;AACH,iBAAS,QAAQ,IAAI,KAAK,GAAG,IAAI,CAWhC;AAED;;;;;GAKG;AACH,iBAAS,UAAU,IAAI,UAAU,GAAG,IAAI,CAGvC;AAED,2FAA2F;AAC3F,iBAAS,QAAQ,CAAC,EAAE,QAAQ,EAAE,EAAE,aAAa,+BAY5C;AAED,qFAAqF;AACrF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAC9B;AAED,6HAA6H;AAC7H,MAAM,WAAW,KAAK;IACpB,kGAAkG;IAClG,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,2GAA2G;IAC3G,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC"}

package/dist/start/common/document.js

@@ -0,0 +1,58 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { use, useState, useSyncExternalStore } from 'react';
+import { ID, PageContext, RuntimeContext, usePage } from './page.js';
+/*
+ * The Document's two parts Start fills: `<Start.Head />` in its `<head>`,
+ * `<Start.Scripts />` at the end of its `<body>`. Each draws the Page of the
+ * request, which the server works out and the browser reads back, so the
+ * Document hydrates as it was drawn. Lazy Views' files are added to the head
+ * by the server once the page is drawn, after these.
+ */
+/**
+ * The Metadata, the styles and the preloads, in the order the browser wants
+ * them: the charset and viewport first, then the title and every Metadata
+ * tag, then the entry's styles and the chunks it imports. The Metadata is
+ * drawn on the server only: in the browser the Router writes it after every
+ * move, so React leaves the tags the server drew alone.
+ */
+function Head() {
+    const { page, metadata } = usePage('<Start.Head />');
+    return (_jsxs(_Fragment, { children: [_jsx("meta", { charSet: "utf-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }), metadata?.title !== undefined && _jsx("title", { children: metadata.title }), metadata?.tags.map(({ tag: Tag, attributes }, at) => (_jsx(Tag, { ...attributes }, at))), page.head.map((script, at) => script.src !== undefined ? (_jsx("script", { type: "module", src: script.src }, `h${at}`)) : (_jsx("script", { type: "module", dangerouslySetInnerHTML: { __html: script.code ?? '' } }, `h${at}`))), page.entry.styles.map((href) => (_jsx("link", { rel: "stylesheet", href: href }, href))), page.entry.preloads.map((href) => (_jsx("link", { rel: "modulepreload", href: href }, href)))] }));
+}
+/** The Page as JSON, which the browser starts from, and the client entry that does it. */
+function Scripts() {
+    const { page, json } = usePage('<Start.Scripts />');
+    return (_jsxs(_Fragment, { children: [page.scroll && (_jsx("script", { dangerouslySetInnerHTML: { __html: page.scroll } })), _jsx("script", { type: "application/json", id: ID, dangerouslySetInnerHTML: { __html: json } }), _jsx("script", { type: "module", src: page.entry.script })] }));
+}
+const never = () => () => { };
+/**
+ * When the server drew this page, and by which build; and whether the
+ * component that asks was in that drawing, `hydrated`, or was drawn later
+ * by the browser, after a move. `null` outside a page Start served, as in a
+ * test or a story. A component keeps its answer for as long as it is
+ * mounted.
+ */
+function useDrawn() {
+    const drawn = use(PageContext);
+    // A server's snapshot is read on the server and while hydrating what it drew.
+    const hydrating = useSyncExternalStore(never, () => false, () => true);
+    const [hydrated] = useState(hydrating);
+    if (!drawn)
+        return null;
+    return { ...drawn.page.drawn, hydrated };
+}
+/**
+ * The running app, for devtools drawn in the Document around it: its
+ * History, the Step shown, and how to show another. `null` on the server,
+ * which draws each request from a History of its own and runs none, and
+ * outside a page Start served.
+ */
+function useRuntime() {
+    const read = use(RuntimeContext);
+    return read ? read() : null;
+}
+/** The plainest Document, for an app that gives none: Start's parts in an English page. */
+function Document({ children }) {
+    return (_jsxs("html", { lang: "en", children: [_jsx("head", { children: _jsx(Head, {}) }), _jsxs("body", { children: [children, _jsx(Scripts, {})] })] }));
+}
+export { Document, Head, Scripts, useDrawn, useRuntime };

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

@@ -0,0 +1,9 @@
+export { Start } from './common.ts';
+export { appOf, branded, refused } from './app.ts';
+export type { DocumentType, ServedApp, StartApp } from './app.ts';
+export { Document } from './document.tsx';
+export { ID, PageContext, RuntimeContext, readPage, serialize, usePage, } from './page.ts';
+export type { Assets, Build, Drawing, Drawn, Page, Script } from './page.ts';
+export { NDJSON, PATH, loadable, readAsk, readLine, writeAsk, writeLine, } from './wire.ts';
+export type { Line, RoutesOnWire, Wanted } from './wire.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/start/common/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnD,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EACL,EAAE,EACF,WAAW,EACX,cAAc,EACd,QAAQ,EACR,SAAS,EACT,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAC7E,OAAO,EACL,MAAM,EACN,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,SAAS,GACV,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC"}

package/dist/start/common/index.js

@@ -0,0 +1,5 @@
+export { Start } from './common.js';
+export { appOf, branded, refused } from './app.js';
+export { Document } from './document.js';
+export { ID, PageContext, RuntimeContext, readPage, serialize, usePage, } from './page.js';
+export { NDJSON, PATH, loadable, readAsk, readLine, writeAsk, writeLine, } from './wire.js';

package/dist/start/common/page.d.ts

@@ -0,0 +1,67 @@
+import type { SavedHistory } from '../../core/index.ts';
+import type { AppRuntime } from '../../react/index.ts';
+import type { Tag } from '../../routing/route/index.ts';
+/** A script Start writes in the head: Vite's client and React Refresh in dev. */
+export interface Script {
+    readonly src?: string;
+    readonly code?: string;
+}
+/** The files one entry, or one lazy View, needs: its script, its styles and the chunks it imports. */
+export interface Assets {
+    readonly script: string;
+    readonly styles: ReadonlyArray<string>;
+    readonly preloads: ReadonlyArray<string>;
+}
+/** What the Vite plugin gives the Worker about the build. */
+export interface Build {
+    /** Changes on every build: the key the cache keeps static pages under. None in dev, where nothing is cached. */
+    readonly id: string | undefined;
+    /** Vite's `base`: where every file is served from. */
+    readonly base: string;
+    /** The client entry's files. */
+    readonly entry: Assets;
+    /** Each lazy View's files, by its id; `null` in dev, where a View's module is served at `base` and its id. */
+    readonly views: Readonly<Record<string, Assets>> | null;
+    /** Scripts the head needs before anything else: Vite's client and React Refresh in dev. */
+    readonly head: ReadonlyArray<Script>;
+}
+/** When the server drew a page, and which build drew it. */
+export interface Drawing {
+    /** When it was drawn, in milliseconds since the epoch: after its Loaders answered. */
+    readonly at: number;
+    /** The build that drew it; none in dev. */
+    readonly build: string | undefined;
+}
+/** What the browser needs to draw the Document as the server did: its files, the History the app is drawn from, and when it was drawn. */
+export interface Page {
+    readonly entry: Assets;
+    readonly head: ReadonlyArray<Script>;
+    readonly saved: SavedHistory;
+    readonly drawn: Drawing;
+    /** The script that puts the page's scroll back before the app hydrates, if the Router restores it here. */
+    readonly scroll?: string;
+}
+/**
+ * A Page and the JSON it is written as, the same text on the server and in
+ * the browser; on the server, the Metadata too. The browser leaves the
+ * Metadata the server drew to the Router, which writes it after every move.
+ */
+export interface Drawn {
+    readonly page: Page;
+    readonly json: string;
+    readonly metadata?: {
+        readonly title: string | undefined;
+        readonly tags: ReadonlyArray<Tag>;
+    };
+}
+/** The id of the script that holds the Page as JSON. */
+export declare const ID = "kabuki-start";
+export declare const PageContext: import("react").Context<Drawn | undefined>;
+/** How the Document reads the running app: the browser's App's `useRuntime`. A server has none. */
+export declare const RuntimeContext: import("react").Context<(() => AppRuntime) | undefined>;
+export declare const usePage: (what: string) => Drawn;
+/** JSON safe inside a `<script>`: no `</script>`, no `<!--`, no line separators JavaScript reads as line ends. */
+export declare const serialize: (page: Page) => Omit<Drawn, 'metadata'>;
+/** The Page a server wrote in this document, read back as it was written. */
+export declare const readPage: (document: Document) => Drawn;
+//# sourceMappingURL=page.d.ts.map

package/dist/start/common/page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../src/start/common/page.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAUxD,iFAAiF;AACjF,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,sGAAsG;AACtG,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC1C;AAED,6DAA6D;AAC7D,MAAM,WAAW,KAAK;IACpB,gHAAgH;IAChH,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8GAA8G;IAC9G,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC;IACxD,2FAA2F;IAC3F,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACtC;AAED,4DAA4D;AAC5D,MAAM,WAAW,OAAO;IACtB,sFAAsF;IACtF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,0IAA0I;AAC1I,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,2GAA2G;IAC3G,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;QACnC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;KACnC,CAAC;CACH;AAED,wDAAwD;AACxD,eAAO,MAAM,EAAE,iBAAiB,CAAC;AAEjC,eAAO,MAAM,WAAW,4CAA8C,CAAC;AAEvE,mGAAmG;AACnG,eAAO,MAAM,cAAc,iCAAwB,UAAU,cAE5D,CAAC;AAEF,eAAO,MAAM,OAAO,SAAU,MAAM,KAAG,KAOtC,CAAC;AAEF,kHAAkH;AAClH,eAAO,MAAM,SAAS,SAAU,IAAI,KAAG,IAAI,CAAC,KAAK,EAAE,UAAU,CAQ3D,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,QAAQ,aAAc,QAAQ,KAAG,KAO7C,CAAC"}

package/dist/start/common/page.js

@@ -0,0 +1,29 @@
+import { createContext, use } from 'react';
+/** The id of the script that holds the Page as JSON. */
+export const ID = 'kabuki-start';
+export const PageContext = createContext(undefined);
+/** How the Document reads the running app: the browser's App's `useRuntime`. A server has none. */
+export const RuntimeContext = createContext(undefined);
+export const usePage = (what) => {
+    const drawn = use(PageContext);
+    if (!drawn)
+        throw new Error(`[@kestack/kabuki/start] ${what} is drawn outside Start: only the Document Start serves can draw it`);
+    return drawn;
+};
+/** JSON safe inside a `<script>`: no `</script>`, no `<!--`, no line separators JavaScript reads as line ends. */
+export const serialize = (page) => ({
+    page,
+    json: JSON.stringify(page)
+        .replace(/</g, '\\u003c')
+        .replace(/>/g, '\\u003e')
+        .replace(/&/g, '\\u0026')
+        .replace(/\u2028/g, '\\u2028')
+        .replace(/\u2029/g, '\\u2029'),
+});
+/** The Page a server wrote in this document, read back as it was written. */
+export const readPage = (document) => {
+    const json = document.getElementById(ID)?.textContent;
+    if (!json)
+        throw new Error(`[@kestack/kabuki/start] this page holds no #${ID} script: was it drawn by Start, with <Start.Scripts /> in its Document?`);
+    return { page: JSON.parse(json), json };
+};

package/dist/start/common/wire.d.ts

@@ -0,0 +1,37 @@
+import type { Codec, Outcome, PlaceSchema } from '../../routing/route/index.ts';
+/** Where the server answers it. */
+export declare const PATH = "/_kabuki/load";
+/** What the wire needs of a Routes tree: every place, and the Schema of every Route. */
+export interface RoutesOnWire {
+    readonly every: ReadonlyArray<PlaceSchema>;
+    readonly route: Codec<unknown>;
+}
+/** One line of the answer: what loading one place came to. */
+export interface Line {
+    readonly name: string;
+    readonly outcome: Outcome;
+}
+/** The answer's media type: one JSON value per line. */
+export declare const NDJSON = "application/x-ndjson";
+/** A place to load, decoded: its dotted name and its params. */
+export interface Wanted {
+    readonly name: string;
+    readonly params: Readonly<Record<string, unknown>>;
+}
+/** Every place with data, by dotted name: only those can be asked for. */
+export declare const loadable: (routes: RoutesOnWire) => Map<string, PlaceSchema<string>>;
+type Places = ReturnType<typeof loadable>;
+export declare const writeAsk: (places: Places, wanted: ReadonlyArray<Wanted>) => {
+    places: {
+        name: string;
+        params: unknown;
+    }[];
+};
+/** The places a request asks for, or why it cannot be read. Throws on a malformed ask. */
+export declare const readAsk: (places: Places, body: unknown) => ReadonlyArray<Wanted>;
+/** One place's outcome as a line, its data and Redirect written with their Schemas. */
+export declare const writeLine: (routes: RoutesOnWire, places: Places, line: Line) => Line;
+/** A line read back with its Schemas. */
+export declare const readLine: (routes: RoutesOnWire, places: Places, line: Line) => Line;
+export {};
+//# sourceMappingURL=wire.d.ts.map

package/dist/start/common/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../../../src/start/common/wire.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAchF,mCAAmC;AACnC,eAAO,MAAM,IAAI,kBAAkB,CAAC;AAkBpC,wFAAwF;AACxF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CAChC;AAED,8DAA8D;AAC9D,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,wDAAwD;AACxD,eAAO,MAAM,MAAM,yBAAyB,CAAC;AAE7C,gEAAgE;AAChE,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACpD;AAQD,0EAA0E;AAC1E,eAAO,MAAM,QAAQ,WAAY,YAAY,qCAK1C,CAAC;AAEJ,KAAK,MAAM,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;AAc1C,eAAO,MAAM,QAAQ,WAAY,MAAM,UAAU,aAAa,CAAC,MAAM,CAAC;IACpE,MAAM;;;;CAON,CAAC;AAEH,0FAA0F;AAC1F,eAAO,MAAM,OAAO,WAAY,MAAM,QAAQ,OAAO,KAAG,aAAa,CAAC,MAAM,CAUvE,CAAC;AAiDN,uFAAuF;AACvF,eAAO,MAAM,SAAS,WA9CX,YAAY,UAAU,MAAM,QAAQ,IAAI,KAAG,IA8CR,CAAC;AAC/C,yCAAyC;AACzC,eAAO,MAAM,QAAQ,WAhDV,YAAY,UAAU,MAAM,QAAQ,IAAI,KAAG,IAgDT,CAAC"}

package/dist/start/common/wire.js

@@ -0,0 +1,73 @@
+import { Exit, Schema } from 'effect';
+/*
+ * The Loader RPC: how the browser asks the server for the data of the
+ * places a move needs, all in one request. Made from the Routes, so it
+ * cannot disagree with them: a place with data is one call, what its Loader
+ * is handed the payload, and its outcome the answer.
+ *
+ * It is a fixed JSON protocol over the Routes' Schemas rather than an
+ * `effect/rpc` group: a move asks for all its places at once, which one
+ * request with one answer says directly, a Loader is handed the very request
+ * that asked, cookies and all, and the browser ships no RPC client.
+ */
+/** Where the server answers it. */
+export const PATH = '/_kabuki/load';
+/** The answer's media type: one JSON value per line. */
+export const NDJSON = 'application/x-ndjson';
+const Ask = Schema.Struct({
+    places: Schema.Array(Schema.Struct({ name: Schema.String, params: Schema.Unknown })),
+});
+/** Every place with data, by dotted name: only those can be asked for. */
+export const loadable = (routes) => new Map(routes.every.flatMap((place) => place.input ? [[place.name, place]] : []));
+const placeOf = (places, name) => {
+    const place = places.get(name);
+    if (!place)
+        throw new Error(`[@kestack/kabuki/start] ${name} is not a place with data`);
+    return place;
+};
+const sync = (exit, what) => {
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    throw new Error(`[@kestack/kabuki/start] ${what}`, { cause: exit.cause });
+};
+export const writeAsk = (places, wanted) => ({
+    places: wanted.map(({ name, params }) => ({
+        name,
+        params: sync(Schema.encodeUnknownExit(placeOf(places, name).params)(params), `the params of ${name} do not match its Schema`),
+    })),
+});
+/** The places a request asks for, or why it cannot be read. Throws on a malformed ask. */
+export const readAsk = (places, body) => sync(Schema.decodeUnknownExit(Ask)(body), 'the ask is not { places: [{ name, params }] }').places.map(({ name, params }) => ({
+    name,
+    params: sync(Schema.decodeUnknownExit(placeOf(places, name).params)(params), `the params of ${name} do not match its Schema`),
+}));
+const outcomeWith = (direction) => (routes, places, line) => {
+    const { name } = line;
+    // Only the outcome goes on the wire: what a Loading adds besides, as
+    // how long it took, the browser works out for itself.
+    const { took: _took, at: _at, cached: _cached, stale: _stale, ...outcome } = line.outcome;
+    const code = (schema) => (value) => direction === 'encode'
+        ? Schema.encodeUnknownExit(schema)(value)
+        : Schema.decodeUnknownExit(schema)(value);
+    if (outcome._tag === 'Loaded')
+        return {
+            name,
+            outcome: {
+                _tag: 'Loaded',
+                data: sync(code(placeOf(places, name).input)(outcome.data), `the data of ${name} does not match its Schema`),
+            },
+        };
+    if (outcome._tag === 'Redirect' && outcome.href === undefined)
+        return {
+            name,
+            outcome: {
+                ...outcome,
+                route: sync(code(routes.route)(outcome.route), 'a Redirect names no Route'),
+            },
+        };
+    return { name, outcome: outcome };
+};
+/** One place's outcome as a line, its data and Redirect written with their Schemas. */
+export const writeLine = outcomeWith('encode');
+/** A line read back with its Schemas. */
+export const readLine = outcomeWith('decode');

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

@@ -0,0 +1,8 @@
+import type { Handler, Platform } from '../index.ts';
+/** Cloudflare Workers, for `start({ platform: cloudflare() })`. */
+export declare const cloudflare: () => Platform;
+/** Start's handler as a Worker's: what the Worker's main default-exports. */
+export declare const serve: (handler: Handler) => {
+    fetch: (request: Request, env: unknown) => Promise<Response>;
+};
+//# sourceMappingURL=cloudflare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../../../src/start/platform/cloudflare/cloudflare.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,QAAQ,EAAE,MAAM,aAAa,CAAC;AAUhE,mEAAmE;AACnE,eAAO,MAAM,UAAU,QAAO,QAY5B,CAAC;AAOH,6EAA6E;AAC7E,eAAO,MAAM,KAAK,YAAa,OAAO;IACpC,KAAK,YAAY,OAAO,OAAO,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC;CAI1D,CAAC"}

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

@@ -0,0 +1,31 @@
+/*
+ * Start on Cloudflare Workers. `cloudflare()` is what the Vite plugin
+ * builds for: one module, its dependencies in their edge form, which
+ * Alchemy's `Cloudflare.Website.Vite` deploys in front of the client's
+ * assets. `serve(handler)` is the Worker: each request handed to Start with
+ * the Worker's env and the Cloudflare Cache.
+ */
+/** Cloudflare Workers, for `start({ platform: cloudflare() })`. */
+export const cloudflare = () => ({
+    name: 'cloudflare',
+    conditions: [
+        'workerd',
+        'worker',
+        'edge-light',
+        'module',
+        'browser',
+        'import',
+        'default',
+    ],
+    serve: { from: '@kestack/kabuki/start/platform/cloudflare', name: 'serve' },
+});
+/** The Cloudflare Cache of this data center; none outside workerd, as in Node. */
+const theCache = () => globalThis.caches
+    ?.default;
+/** Start's handler as a Worker's: what the Worker's main default-exports. */
+export const serve = (handler) => ({
+    fetch: (request, env) => {
+        const cache = theCache();
+        return handler.fetch(request, cache ? { env, cache } : { env });
+    },
+});