@happyvertical/smrt-planner 0.0.0-stage → 0.0.2

package/dist/inference/openai.d.ts

@@ -0,0 +1,59 @@
+import type { ChatModel } from '../assistant/transport.ts';
+/** How hard to ask the endpoint for JSON, strictest first. */
+export type JsonMode = 'json_schema' | 'json_object' | 'none';
+export interface OpenAIChatOptions {
+    /** e.g. `http://localhost:11434/v1`. */
+    baseUrl: string;
+    model: string;
+    /** Sent as `Authorization: Bearer`; omit for a local server. */
+    apiKey?: string;
+    /** Strictest JSON mode to try first; it steps down when the endpoint refuses it. */
+    jsonMode?: JsonMode;
+    fetch?: typeof fetch;
+    /** Called with the mode that worked, so a caller can remember it. */
+    onJsonMode?: (mode: JsonMode) => void;
+}
+/** `http(s)` base without a trailing slash, or null. */
+export declare function normalizeBaseUrl(value: string): string | null;
+/** Hosts that are this computer: a key may travel to them over plain http. */
+export declare function isLoopbackHost(hostname: string): boolean;
+/** Can a key be sent to this address? `https`, or `http` to this computer only. */
+export declare function keyMaySendTo(baseUrl: string): boolean;
+/** The origin a key was entered for: scheme, host and port of the address. */
+export declare function originOf(baseUrl: string): string | null;
+/** A failure that says what happened and never carries the key. */
+export declare class EndpointError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+export interface CompleteOptions {
+    maxTokens?: number;
+    signal?: AbortSignal;
+    /** Ask for JSON-mode output (default true). */
+    json?: boolean;
+    temperature?: number;
+    schema?: Record<string, unknown> | string;
+}
+export interface OpenAIChat extends ChatModel {
+    complete(messages: {
+        role: string;
+        content: string;
+    }[], extra?: CompleteOptions): Promise<string>;
+}
+/**
+ * A `ChatModel` over `${baseUrl}/chat/completions`. JSON-mode output is asked
+ * for with the planner's schema; an endpoint that answers 400/422 to it (many
+ * local servers know only `json_object`, some nothing) is retried one step
+ * down, and the step that worked is kept for the rest of the session.
+ */
+export declare function createOpenAIChat(options: OpenAIChatOptions): OpenAIChat;
+export interface ConnectionResult {
+    ok: boolean;
+    /** One sentence for the visitor. */
+    message: string;
+}
+/**
+ * Test connection: one tiny completion, so the address, the model and the key
+ * are all exercised. Never throws and never echoes the key.
+ */
+export declare function testConnection(options: OpenAIChatOptions): Promise<ConnectionResult>;

package/dist/inference/openai.js

@@ -0,0 +1,207 @@
+const JSON_MODES = ['json_schema', 'json_object', 'none'];
+const REQUEST_TIMEOUT_MS = 120_000;
+/** `http(s)` base without a trailing slash, or null. */
+export function normalizeBaseUrl(value) {
+    try {
+        const url = new URL(value.trim());
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return null;
+        // Credentials in a URL would travel in the clear as part of it.
+        if (url.username || url.password)
+            return null;
+        for (const name of url.searchParams.keys()) {
+            if (/^(?:api[-_]?key|key|token|authorization|secret|password)$/i.test(name)) {
+                return null;
+            }
+        }
+        return `${url.origin}${url.pathname.replace(/\/+$/, '')}`;
+    }
+    catch {
+        return null;
+    }
+}
+/** Hosts that are this computer: a key may travel to them over plain http. */
+export function isLoopbackHost(hostname) {
+    const host = hostname.toLowerCase().replace(/^\[|\]$/g, '');
+    return (host === 'localhost' ||
+        host.endsWith('.localhost') ||
+        host === '::1' ||
+        /^127(\.\d{1,3}){3}$/.test(host));
+}
+/** Can a key be sent to this address? `https`, or `http` to this computer only. */
+export function keyMaySendTo(baseUrl) {
+    try {
+        const url = new URL(baseUrl.trim());
+        return (url.protocol === 'https:' ||
+            (url.protocol === 'http:' && isLoopbackHost(url.hostname)));
+    }
+    catch {
+        return false;
+    }
+}
+/** The origin a key was entered for: scheme, host and port of the address. */
+export function originOf(baseUrl) {
+    try {
+        return new URL(baseUrl.trim()).origin;
+    }
+    catch {
+        return null;
+    }
+}
+/** A failure that says what happened and never carries the key. */
+export class EndpointError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'EndpointError';
+    }
+}
+function describeStatus(status) {
+    if (status === 401 || status === 403) {
+        return `the endpoint refused the key (${status})`;
+    }
+    if (status === 404) {
+        return 'the endpoint or model was not found (404), check the address and model name';
+    }
+    if (status === 429)
+        return 'the endpoint is rate limiting you (429)';
+    return `the endpoint answered ${status}`;
+}
+/** The text of the first choice, or a reason there is none. */
+function textOf(payload) {
+    const choice = payload?.choices?.[0];
+    const content = choice?.message?.content;
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => part && typeof part === 'object' && 'text' in part
+            ? String(part.text)
+            : '')
+            .join('');
+    }
+    throw new EndpointError('the endpoint sent no reply text');
+}
+function responseFormat(mode, schema) {
+    if (mode === 'none')
+        return undefined;
+    if (mode === 'json_schema' && schema && typeof schema === 'object') {
+        return {
+            type: 'json_schema',
+            json_schema: { name: 'planner_turn', strict: false, schema },
+        };
+    }
+    return { type: 'json_object' };
+}
+/**
+ * A `ChatModel` over `${baseUrl}/chat/completions`. JSON-mode output is asked
+ * for with the planner's schema; an endpoint that answers 400/422 to it (many
+ * local servers know only `json_object`, some nothing) is retried one step
+ * down, and the step that worked is kept for the rest of the session.
+ */
+export function createOpenAIChat(options) {
+    const base = normalizeBaseUrl(options.baseUrl);
+    if (!base)
+        throw new EndpointError('the address is not a valid http(s) URL');
+    if (options.apiKey && !keyMaySendTo(base)) {
+        throw new EndpointError('a key is only sent over https, or to this computer; use an https address');
+    }
+    const url = `${base}/chat/completions`;
+    const doFetch = options.fetch ?? fetch;
+    let level = Math.max(0, JSON_MODES.indexOf(options.jsonMode ?? 'json_schema'));
+    async function post(body, signal) {
+        const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+        try {
+            return await doFetch(url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...(options.apiKey
+                        ? { authorization: `Bearer ${options.apiKey}` }
+                        : {}),
+                },
+                body: JSON.stringify(body),
+                // No cookies for a third-party endpoint.
+                credentials: 'omit',
+                signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+            });
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            // A blocked cross-origin call and an unreachable server look the same
+            // to a page: a TypeError with no detail.
+            throw new EndpointError('could not reach the endpoint. Is it running, and does it allow this page (CORS)?');
+        }
+    }
+    async function complete(messages, extra = {}) {
+        const wantJson = extra.json !== false;
+        for (;;) {
+            const mode = wantJson ? (JSON_MODES[level] ?? 'none') : 'none';
+            const format = responseFormat(mode, extra.schema);
+            const response = await post({
+                model: options.model,
+                messages,
+                stream: false,
+                temperature: extra.temperature ?? 0,
+                ...(extra.maxTokens ? { max_tokens: extra.maxTokens } : {}),
+                ...(format ? { response_format: format } : {}),
+            }, extra.signal);
+            if (response.ok) {
+                if (wantJson)
+                    options.onJsonMode?.(mode);
+                return textOf(await response.json().catch(() => null));
+            }
+            // The endpoint refused the JSON mode: step down and ask again.
+            if (wantJson &&
+                (response.status === 400 || response.status === 422) &&
+                level < JSON_MODES.length - 1) {
+                level += 1;
+                continue;
+            }
+            throw new EndpointError(describeStatus(response.status), response.status);
+        }
+    }
+    return {
+        complete,
+        message(text, callOptions) {
+            return complete([
+                ...(callOptions?.history ?? []).map(({ role, content }) => ({
+                    role,
+                    content,
+                })),
+                { role: 'user', content: text },
+            ], {
+                maxTokens: callOptions?.maxTokens,
+                signal: callOptions?.signal,
+                temperature: callOptions?.temperature,
+                schema: callOptions?.responseSchema,
+            });
+        },
+    };
+}
+/**
+ * Test connection: one tiny completion, so the address, the model and the key
+ * are all exercised. Never throws and never echoes the key.
+ */
+export async function testConnection(options) {
+    try {
+        const chat = createOpenAIChat({ ...options, jsonMode: 'none' });
+        const reply = await chat.complete([{ role: 'user', content: 'Reply with the single word OK.' }], { maxTokens: 8, json: false });
+        return {
+            ok: true,
+            message: reply.trim()
+                ? `Connected to ${options.model}.`
+                : `Connected to ${options.model}, but it sent an empty reply.`,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: error instanceof EndpointError
+                ? `Could not connect: ${error.message}.`
+                : 'Could not connect.',
+        };
+    }
+}

package/dist/inference/presets.d.ts

@@ -0,0 +1,5 @@
+import type { ByoPresetDefinition } from './config.ts';
+/** The first-party presets; a config's `byo.presets` picks from or adds to these. */
+export declare const BUILT_IN_PRESETS: readonly ByoPresetDefinition[];
+/** Presets a config offers, in its order; unknown ids are dropped. Default: all built-ins. */
+export declare function resolvePresets(requested?: readonly (string | ByoPresetDefinition)[]): ByoPresetDefinition[];

package/dist/inference/presets.js

@@ -0,0 +1,46 @@
+/** The first-party presets; a config's `byo.presets` picks from or adds to these. */
+export const BUILT_IN_PRESETS = [
+    {
+        id: 'ollama',
+        label: 'Ollama (on this computer)',
+        baseUrl: 'http://localhost:11434/v1',
+        model: 'llama3.2',
+        keyless: true,
+        cors: 'Ollama only answers pages it trusts. Start it with OLLAMA_ORIGINS set to this site, for example OLLAMA_ORIGINS=https://your-site.example ollama serve (on macOS: launchctl setenv OLLAMA_ORIGINS https://your-site.example, then restart Ollama). A page served from http://localhost needs no change.',
+    },
+    {
+        id: 'openrouter',
+        label: 'OpenRouter',
+        baseUrl: 'https://openrouter.ai/api/v1',
+        model: 'openai/gpt-4o-mini',
+        cors: 'OpenRouter accepts calls from any web page, so no setup is needed. Use a key with a spending limit.',
+    },
+    {
+        id: 'openai',
+        label: 'OpenAI',
+        baseUrl: 'https://api.openai.com/v1',
+        model: 'gpt-4o-mini',
+        cors: 'OpenAI accepts calls from web pages when the request carries a key. Use a restricted key with a low spending limit: anyone with access to this browser profile can read it.',
+    },
+    {
+        id: 'custom',
+        label: 'Custom OpenAI-compatible endpoint',
+        baseUrl: '',
+        customUrl: true,
+        cors: 'The server must answer the browser\'s CORS preflight: allow this site\'s origin, the "authorization" and "content-type" headers, and the POST and OPTIONS methods.',
+    },
+];
+/** Presets a config offers, in its order; unknown ids are dropped. Default: all built-ins. */
+export function resolvePresets(requested) {
+    if (!requested?.length)
+        return [...BUILT_IN_PRESETS];
+    const out = [];
+    for (const entry of requested) {
+        const preset = typeof entry === 'string'
+            ? BUILT_IN_PRESETS.find((p) => p.id === entry)
+            : entry;
+        if (preset && !out.some((p) => p.id === preset.id))
+            out.push(preset);
+    }
+    return out.length ? out : [...BUILT_IN_PRESETS];
+}

package/dist/kitchen/client.d.ts

@@ -0,0 +1,39 @@
+import type { Cookbook } from '../cookbook/types.ts';
+/** Where to send, from the config. Absent from the config means no kitchen. */
+export interface KitchenEndpoint {
+    endpoint: string;
+    /**
+     * True when the file still carried a `token`: an older `smrt` CLI that serves
+     * it where any local process can read it. The value is never kept, and
+     * sending is off until the CLI is updated.
+     */
+    tokenInConfig?: true;
+}
+/** Where and how to send: the config's endpoint and the address's token. */
+export interface KitchenConfig extends KitchenEndpoint {
+    token: string;
+}
+/** The header the CLI checks the one-time token in. */
+export declare const KITCHEN_TOKEN_HEADER = "x-kitchen-token";
+/** What the kitchen reports after writing the project. */
+export interface KitchenResult {
+    dir: string;
+    mode: 'new' | 'update';
+    installed: boolean;
+    added: string[];
+    nextSteps: string[];
+}
+export type KitchenOutcome = {
+    ok: true;
+    result: KitchenResult;
+} | {
+    ok: false;
+    errors: string[];
+};
+/**
+ * Validate the config's `kitchen` block. Anything unusable means no kitchen.
+ * Only the endpoint is read: a `token` here is ignored, never used.
+ */
+export declare function parseKitchenConfig(value: unknown): KitchenEndpoint | undefined;
+/** POST the cookbook to the kitchen. Never throws; a failure is an outcome. */
+export declare function sendToKitchen(config: KitchenConfig, cookbook: Cookbook, fetcher?: typeof fetch): Promise<KitchenOutcome>;

package/dist/kitchen/client.js

@@ -0,0 +1,115 @@
+/**
+ * Send to kitchen: the hand-off to `smrt kitchen`, the CLI that serves this
+ * app on localhost and turns the cookbook into a project. The CLI announces
+ * itself in `planner.config.json` with where to send, and in the address it
+ * opens with the one-time token, as a fragment (`fragment.ts`):
+ *
+ *   planner.config.json  { "kitchen": { "endpoint": "/api/kitchen/cookbook" } }
+ *   address              http://127.0.0.1:<port>/#kitchen=<token>
+ *
+ * The config never carries a token (any local process sending the right Host
+ * header could read it); a `token` in the file is ignored (and reported, see
+ * `tokenInConfig`). The page POSTs the
+ * cookbook to the endpoint with the token in `x-kitchen-token`. Wire contract,
+ * version 1:
+ *
+ * - `200 { ok: true, dir, mode, installed, added, nextSteps }`: the project
+ *   was written (`mode` is `new` or `update`).
+ * - `4xx/5xx { ok: false, errors: string[] }`: the cookbook was not applied;
+ *   the server keeps listening, so the visitor can fix it and send again.
+ */
+import { serializeCookbook } from "../cookbook/file.js";
+/** The header the CLI checks the one-time token in. */
+export const KITCHEN_TOKEN_HEADER = 'x-kitchen-token';
+const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+/** An http(s) URL, or a path on the page's own origin. */
+function usableEndpoint(value) {
+    if (typeof value !== 'string')
+        return false;
+    const text = value.trim();
+    try {
+        const relative = text.startsWith('/') && !text.startsWith('//');
+        const url = new URL(text, relative ? 'https://planner.invalid' : undefined);
+        if (!relative && url.protocol !== 'http:' && url.protocol !== 'https:') {
+            return false;
+        }
+        if (url.username || url.password)
+            return false;
+        if (url.hash)
+            return false;
+        return ![...url.searchParams.keys()].some((name) => /^(?:api[-_]?key|key|token|authorization|secret|password)$/i.test(name));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate the config's `kitchen` block. Anything unusable means no kitchen.
+ * Only the endpoint is read: a `token` here is ignored, never used.
+ */
+export function parseKitchenConfig(value) {
+    if (!isObject(value))
+        return undefined;
+    const { endpoint } = value;
+    if (!usableEndpoint(endpoint))
+        return undefined;
+    return {
+        endpoint: endpoint.trim(),
+        ...(Object.hasOwn(value, 'token') ? { tokenInConfig: true } : {}),
+    };
+}
+const strings = (value) => Array.isArray(value)
+    ? value.filter((x) => typeof x === 'string')
+    : [];
+/** POST the cookbook to the kitchen. Never throws; a failure is an outcome. */
+export async function sendToKitchen(config, cookbook, fetcher = fetch) {
+    let response;
+    try {
+        response = await fetcher(config.endpoint, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                accept: 'application/json',
+                [KITCHEN_TOKEN_HEADER]: config.token,
+            },
+            body: serializeCookbook(cookbook),
+        });
+    }
+    catch {
+        return {
+            ok: false,
+            errors: [
+                'The kitchen could not be reached. Is `smrt kitchen` still running?',
+            ],
+        };
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        body = undefined;
+    }
+    if (response.ok && isObject(body) && body.ok === true) {
+        return {
+            ok: true,
+            result: {
+                dir: typeof body.dir === 'string' ? body.dir : '',
+                mode: body.mode === 'update' ? 'update' : 'new',
+                installed: body.installed === true,
+                added: strings(body.added),
+                nextSteps: strings(body.nextSteps),
+            },
+        };
+    }
+    const errors = isObject(body) ? strings(body.errors) : [];
+    if (isObject(body) && typeof body.error === 'string') {
+        errors.push(body.error);
+    }
+    return {
+        ok: false,
+        errors: errors.length
+            ? errors
+            : [`The kitchen answered ${response.status}.`],
+    };
+}

package/dist/kitchen/fragment.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The kitchen token arrives in the address, never in a file the server serves.
+ * `smrt kitchen` opens `http://127.0.0.1:<port>/#kitchen=<token>`: a fragment is
+ * never sent to a server, so no endpoint (and no other local process sending
+ * the right `Host`) can read it from `planner.config.json`. The page reads the
+ * fragment once at startup, keeps the token in memory only, and removes the
+ * `kitchen` parameter from the address (`replaceState`) so it is not left in
+ * the history entry either.
+ */
+/** The fragment key the token is under. */
+export declare const KITCHEN_FRAGMENT_KEY = "kitchen";
+export interface KitchenFragment {
+    /** The token, when the fragment carried a usable one. */
+    token?: string;
+    /** True when the fragment had a `kitchen` parameter (usable or not) to strip. */
+    present: boolean;
+    /**
+     * The fragment without the `kitchen` parameter, as it belongs in the address:
+     * `''` or `#other=1`. Other parameters are kept.
+     */
+    hash: string;
+}
+/**
+ * Read `location.hash` (with or without the `#`). Never throws. Only the
+ * `kitchen` parameter is touched: every other part of the fragment is returned
+ * exactly as it was (no re-encoding), so an in-page anchor survives. The token
+ * is read raw (it must already be URL-safe), so a percent-encoded or `+`-spaced
+ * value is not a token; the parameter is removed all the same.
+ */
+export declare function readKitchenFragment(hash: string): KitchenFragment;

package/dist/kitchen/fragment.js

@@ -0,0 +1,49 @@
+/**
+ * The kitchen token arrives in the address, never in a file the server serves.
+ * `smrt kitchen` opens `http://127.0.0.1:<port>/#kitchen=<token>`: a fragment is
+ * never sent to a server, so no endpoint (and no other local process sending
+ * the right `Host`) can read it from `planner.config.json`. The page reads the
+ * fragment once at startup, keeps the token in memory only, and removes the
+ * `kitchen` parameter from the address (`replaceState`) so it is not left in
+ * the history entry either.
+ */
+/** The fragment key the token is under. */
+export const KITCHEN_FRAGMENT_KEY = 'kitchen';
+/** URL-safe characters only (RFC 3986 unreserved): what `base64url` and hex produce. */
+const TOKEN = /^[A-Za-z0-9._~-]{1,256}$/;
+/**
+ * Read `location.hash` (with or without the `#`). Never throws. Only the
+ * `kitchen` parameter is touched: every other part of the fragment is returned
+ * exactly as it was (no re-encoding), so an in-page anchor survives. The token
+ * is read raw (it must already be URL-safe), so a percent-encoded or `+`-spaced
+ * value is not a token; the parameter is removed all the same.
+ */
+export function readKitchenFragment(hash) {
+    const text = hash.startsWith('#') ? hash.slice(1) : hash;
+    if (!text)
+        return { present: false, hash: '' };
+    let token;
+    let present = false;
+    const kept = [];
+    for (const part of text.split('&')) {
+        const equals = part.indexOf('=');
+        const key = equals < 0 ? part : part.slice(0, equals);
+        if (key !== KITCHEN_FRAGMENT_KEY) {
+            kept.push(part);
+            continue;
+        }
+        // The first `kitchen` wins; all of them are removed.
+        if (!present && equals >= 0) {
+            const value = part.slice(equals + 1);
+            if (TOKEN.test(value))
+                token = value;
+        }
+        present = true;
+    }
+    const rest = kept.filter((part) => part !== '').join('&');
+    return {
+        ...(token ? { token } : {}),
+        present,
+        hash: rest ? `#${rest}` : '',
+    };
+}

package/dist/kitchen/state.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { Cookbook } from '../cookbook/types.ts';
+import { type KitchenConfig, type KitchenEndpoint, type KitchenOutcome } from './client.ts';
+export type KitchenStatus = 'idle' | 'sending' | 'sent' | 'failed';
+/** Whether a kitchen is listening, and the state of the current send. */
+export declare class KitchenState {
+    /** Where the kitchen listens, from `planner.config.json`. */
+    endpoint: string | undefined;
+    /** An older CLI still puts its token in the config: never used, and sending is off. */
+    tokenInConfig: boolean;
+    /** The one-time token, from the address's fragment. Memory only. */
+    private token;
+    status: KitchenStatus;
+    outcome: KitchenOutcome | undefined;
+    /** A kitchen is listening and this page holds its token: sending is possible. */
+    get config(): KitchenConfig | undefined;
+    /**
+     * A kitchen is listening but this page was opened without its token (the
+     * address had no `#kitchen=` fragment, or the page was reloaded after the
+     * fragment was removed): the person needs the address `smrt kitchen` printed.
+     */
+    get needsLink(): boolean;
+    configure(config: KitchenEndpoint | undefined, token?: string): void;
+    send(cookbook: Cookbook, fetcher?: typeof fetch): Promise<void>;
+}
+/** The app's one kitchen state, set from `planner.config.json`. */
+export declare const kitchenState: KitchenState;

package/dist/kitchen/state.svelte.js

@@ -0,0 +1,45 @@
+import { sendToKitchen, } from "./client.js";
+/** Whether a kitchen is listening, and the state of the current send. */
+export class KitchenState {
+    /** Where the kitchen listens, from `planner.config.json`. */
+    endpoint = $state(undefined);
+    /** An older CLI still puts its token in the config: never used, and sending is off. */
+    tokenInConfig = $state(false);
+    /** The one-time token, from the address's fragment. Memory only. */
+    token = $state(undefined);
+    status = $state('idle');
+    outcome = $state(undefined);
+    /** A kitchen is listening and this page holds its token: sending is possible. */
+    get config() {
+        return this.endpoint && this.token && !this.tokenInConfig
+            ? { endpoint: this.endpoint, token: this.token }
+            : undefined;
+    }
+    /**
+     * A kitchen is listening but this page was opened without its token (the
+     * address had no `#kitchen=` fragment, or the page was reloaded after the
+     * fragment was removed): the person needs the address `smrt kitchen` printed.
+     */
+    get needsLink() {
+        return !!this.endpoint && !this.token && !this.tokenInConfig;
+    }
+    configure(config, token) {
+        this.endpoint = config?.endpoint;
+        this.tokenInConfig = config?.tokenInConfig === true;
+        this.token = config ? token : undefined;
+        this.status = 'idle';
+        this.outcome = undefined;
+    }
+    async send(cookbook, fetcher) {
+        const config = this.config;
+        if (!config || this.status === 'sending')
+            return;
+        this.status = 'sending';
+        this.outcome = undefined;
+        const outcome = await sendToKitchen(config, cookbook, fetcher);
+        this.outcome = outcome;
+        this.status = outcome.ok ? 'sent' : 'failed';
+    }
+}
+/** The app's one kitchen state, set from `planner.config.json`. */
+export const kitchenState = new KitchenState();

package/dist/library/apply.d.ts

@@ -0,0 +1,17 @@
+import type { CookbookStore } from '../cookbook/store.svelte.ts';
+import type { Cookbook, CookbookResult } from '../cookbook/types.ts';
+import type { AppSettings } from '../settings/app-settings.ts';
+import type { LibraryCookbook } from './types.ts';
+export { isCookbookEmpty } from './document.ts';
+/** Applying replaces the current recipes and menu, so it asks first unless empty. */
+export declare function needsConfirm(store: Pick<CookbookStore, 'snapshot'>): boolean;
+/**
+ * Replace the cookbook with the cookbook's: recipes, features, options,
+ * exposure and layout. Goes through the same strict check an import does, and
+ * applies nothing on failure. Also switches the sample-data pack to the
+ * cookbook's; rows already generated are regenerated by the caller resetting
+ * the data source (records are not part of a cookbook).
+ */
+export declare function applyLibraryCookbook(cookbook: LibraryCookbook, store: Pick<CookbookStore, 'replace'> & Partial<Pick<CookbookStore, 'theme'>>, settings?: AppSettings): CookbookResult;
+/** Does the current cookbook still hold everything the cookbook added? */
+export declare function holdsCookbook(cookbook: LibraryCookbook, current: Pick<Cookbook, 'recipes' | 'features'>): boolean;