toolroll 0.9.103 → 0.9.105

package/dist/subagents.d.ts

@@ -1,146 +0,0 @@
-import { type CommandRunner } from "./claude-print.js";
-import type { ContractResult } from "./contracts/contract.js";
-import { type TurnAnswer } from "./contracts/subagent-turn.js";
-import { type Overrun } from "./text-limits.js";
-export declare const SOUL_CHARS = 12000;
-export type Soul = {
-    name: string;
-    role: string;
-    sections: {
-        title: string;
-        body: string;
-    }[];
-};
-/** A handle from a name: "Maya" → "maya". */
-export declare const handleOf: (name: string) => string;
-/** A soul file read: its name and role (front matter) and its sections. */
-export declare function parseSoul(text: string): {
-    ok: true;
-    soul: Soul;
-} | {
-    ok: false;
-    problem: string;
-};
-/** A soul file with one section replaced (by title, any case), or added at the end when it has no such section. */
-export declare function withSection(soul: string, title: string, text: string): string;
-/** Starters to copy and make your own. Every rule is plain words the subagent reads each turn. */
-export declare const SUBAGENT_TEMPLATES: readonly {
-    id: string;
-    label: string;
-    about: string;
-    soul: string;
-}[];
-export type { TurnAction, TurnAnswer } from "./contracts/subagent-turn.js";
-/** Each field's limit, in characters: stated in the prompt before it answers (turnPrompt), and an answer over one is
- * asked once to shorten (subagentTurn); one still over is kept whole, never cut. "text" is what the next zones read;
- * "note" is a decision or send-back note. Not in the turn's schema (src/contracts/subagent-turn.ts): the CLI would
- * refuse an answer a few characters over one whole. */
-export declare const TURN_LIMITS: {
-    readonly answer: 60;
-    readonly text: 12000;
-    readonly note: 4000;
-    readonly question: 600;
-    readonly reason: 400;
-    readonly remember: 300;
-};
-/** The fields of an answer over their limits. */
-export declare function turnOverruns(answer: TurnAnswer): Overrun[];
-/** Everything one turn is told: the zone, the card as data, and what its people said. */
-export type TurnContext = {
-    soul: string;
-    name: string;
-    role: string;
-    flow: string;
-    zone: string;
-    /** decide: a "Person decides" zone; handle: a "Subagent handles it" zone. */
-    kind: "decide" | "handle";
-    instructions: string | null;
-    /** decide: the draft being decided on (null: none), whether it can be sent back, and to whom hard ones go. */
-    draft: string | null;
-    canSendBack: boolean;
-    person: string;
-    /** handle: the answers it can pick (each leads to a zone). */
-    answers: string[];
-    card: {
-        title: string;
-        description: string | null;
-        source: string | null;
-        earlier: {
-            zone: string;
-            text: string;
-        }[];
-        discussion: {
-            by: string;
-            text: string;
-        }[];
-        history: string[];
-    };
-    /** Earlier questions on this card, with the answers. */
-    asked: {
-        question: string;
-        answer: string;
-    }[];
-    /** What its people told it lately. */
-    notes: {
-        by: string;
-        text: string;
-    }[];
-    /** v94: the tool actions it may use now (none: it decides with what it has), and what its calls on this visit did. */
-    tools?: {
-        name: string;
-        about: string;
-        input: string;
-        rule: string;
-    }[];
-    calls?: {
-        name: string;
-        input: string;
-        outcome: string;
-        said: string | null;
-    }[];
-    /** v94: it used its tools as much as one visit allows; it decides now. */
-    toolsSpent?: boolean;
-    /** v95: what it kept from earlier cards that fits this one. */
-    memory?: string[];
-    /** The shorten turn: its last answer, over a limit, and what to shorten. */
-    shorten?: {
-        answer: string;
-        ask: string;
-    };
-};
-export declare function turnPrompt(context: TurnContext): string;
-/**
- * A turn's answer, read through its contract (src/contracts/subagent-turn.ts) and then checked against what this zone
- * allows, each refusal naming its path (`action: "route" isn't one this zone allows`). Text is trimmed and kept whole
- * (a field over its limit is asked to shorten, turnOverruns); blank options are dropped, and an ask offers at most 4,
- * each cut to an answer's length, and a tool name is cut to 140, as they always were.
- */
-export declare function readTurn(value: unknown, context: Pick<TurnContext, "kind" | "canSendBack" | "answers" | "tools">): ContractResult<TurnAnswer>;
-export type TurnRequest = {
-    model: string;
-    prompt: string;
-    timeoutMs: number;
-};
-/** v97: what the turn cost, as the CLI estimates it (a Claude plan covers it; the figure is at API prices), and its tokens. */
-export type TurnCost = {
-    costUsd?: number;
-    tokensIn?: number;
-    tokensOut?: number;
-};
-export type TurnReply = ({
-    ok: true;
-    value: unknown;
-    ms: number;
-} & TurnCost) | ({
-    ok: false;
-    said: string;
-} & TurnCost);
-/** Runs one turn; injectable so tests never spend a subscription turn. */
-export type TurnRunner = (request: TurnRequest) => Promise<TurnReply>;
-export declare const TURN_TIMEOUT_MS = 180000;
-/** The production runner: Claude through this computer's sign-in, answering in the turn schema (TURN_MODEL_SCHEMA), with no tools, no MCP servers and no repository. */
-export declare function claudeTurnRunner(runner?: CommandRunner): TurnRunner;
-/** How a subagent is named to people: "Maya · Support". */
-export declare const subagentLabel: (soul: Pick<Soul, "name" | "role">) => string;
-/** How its acts read in a card's history: "Maya (AI)". */
-export declare const subagentActor: (soul: Pick<Soul, "name">) => string;

package/dist/subscription-chat.d.ts

@@ -1,54 +0,0 @@
-import { type LeadHistoryMessage, type LeadProviderAnswer, type LeadToolSchema } from "./converse.js";
-import { type CommandRunner } from "./claude-print.js";
-import type { SubscriptionChatProviderId } from "./store.js";
-import { type ProviderReport } from "./reported-usage.js";
-export type SubscriptionLeadRequest = {
-    provider: SubscriptionChatProviderId;
-    /** `default` lets the authenticated harness choose its current default. */
-    model: string;
-    system: string;
-    dataDocument: string;
-    history: readonly LeadHistoryMessage[];
-    tools: readonly LeadToolSchema[];
-    /** A structured answer of another shape (the memory pass's verdict): this JSON Schema is the harness's
-     * `--json-schema` (Codex's `--output-schema`) in place of the lead envelope, and its JSON text comes back as the
-     * answer's text, unread, for the caller's own schema to parse. */
-    outputSchema?: Record<string, unknown>;
-    timeoutMs: number;
-    /** The turn's own deadline: aborting it ends the harness's whole process group. */
-    signal?: AbortSignal;
-    /** The reply as it is written, cumulative, when the harness can stream it
-     * (Claude). Display only: the finished answer is still parsed whole. */
-    onText?: (text: string) => void;
-};
-export type SubscriptionLeadRunner = (request: SubscriptionLeadRequest) => Promise<{
-    ok: true;
-    answer: LeadProviderAnswer;
-} | {
-    ok: false;
-    problem: string;
-    quiet?: boolean;
-}>;
-/** The model-visible request. Tool results are already redacted by leadView. */
-export declare function composeSubscriptionLeadPrompt(request: Omit<SubscriptionLeadRequest, "provider" | "model" | "timeoutMs" | "signal">): string;
-/** Strictly turn the harness's structured output into the provider-neutral answer. */
-export declare function parseSubscriptionLeadAnswer(text: string, usage?: {
-    tokensIn?: unknown;
-    tokensOut?: unknown;
-    report?: ProviderReport | null;
-}): {
-    ok: true;
-    answer: LeadProviderAnswer;
-} | {
-    ok: false;
-    problem: string;
-};
-/** Production runner; injectable so tests never consume a subscription turn. */
-export declare function performSubscriptionLeadRequest(request: SubscriptionLeadRequest, runner?: CommandRunner): Promise<{
-    ok: true;
-    answer: LeadProviderAnswer;
-} | {
-    ok: false;
-    problem: string;
-    quiet?: boolean;
-}>;

package/dist/summary.d.ts

@@ -1,33 +0,0 @@
-/**
- * A window of runs, tallied — one arithmetic, shared by the CLI brief and
- * the web console so the two can never disagree about what a stretch of
- * unattended work cost.
- *
- * Economics are measured, never asserted: every provider spawn stamps its
- * run before spending, so `invoked` is the complete population; `measured`
- * is the subset whose envelopes actually reported cost, and the gap between
- * them is named by callers instead of summed as zero.
- */
-import type { Run } from "./store.js";
-export type RunTally<T extends Run> = {
-    built: T[];
-    failed: T[];
-    refused: T[];
-    /** Runs that never finished — the process died with them. Also an answer. */
-    cutDown: T[];
-    invoked: T[];
-    measured: T[];
-    spend: number;
-    tokens: number;
-};
-export declare function tally<T extends Run>(runs: T[]): RunTally<T>;
-/**
- * Provider harnesses do not all mean the same thing when they report a
- * dollar figure. Claude Code includes `total_cost_usd` in its result even
- * when it authenticated with a paid membership. In that case the number is
- * useful as an API-price equivalent for comparing work, but it is not API
- * key spend and must never be presented as a separate charge.
- */
-export declare function runCostWords(run: Pick<Run, "authMode" | "costUsd" | "tokensIn" | "tokensOut">, live?: boolean): string;
-/** The spend line, one wording everywhere. */
-export declare function spendLine(summary: RunTally<Run>): string;

package/dist/surface.d.ts

@@ -1,49 +0,0 @@
-/**
- * The declared command guide (arc 5): the agent-facing surface as data,
- * dumped by `contract --commands`. This is DOCUMENTATION with a stable
- * shape, not authority — legacy verbs do not execute from it,
- * and the runtime envelope remains the truth. Its honest limits ride the
- * envelope itself as SURFACE_NOTES, because a source comment is invisible
- * to consumers (arc-5 review, finding 1).
- *
- * What the tests DO hold to the code: every root here is a routed verb
- * and every routed verb appears here; every declared flag lives in the
- * parser's global vocabulary with the declared arity; the subcommand
- * inventories for task/publish/config/approver match the
- * exported action lists their dispatchers consult; keyed mutations
- * declare --key; notableReasons come from DOCUMENTED_REASONS. What they
- * CANNOT prove — that a given flag is read by a given handler — is why
- * SURFACE_NOTES.flags says "intended".
- */
-import { type CommandFlag, type CommandRow, type RemotePolicy } from './contracts/cli.js';
-import type { LocalOwnerAct } from './local-owner.js';
-/** A guide row and its flags are derived from their schemas in src/contracts/cli.ts. */
-export type { CommandFlag, CommandRow, RemotePolicy };
-/** The guide's limits, stated machine-readably in every dump. */
-export declare const SURFACE_NOTES: {
-    readonly authority: "documentation is not permission; legacy entries remain advisory";
-    readonly flags: "flags are intended per command and may use a global parser vocabulary";
-    readonly reasons: "curated, not exhaustive — the runtime `reason` field is the truth; ignore tokens you do not recognize";
-    readonly database: "local database commands wait up to 15 seconds for another writer; an exhausted wait returns database-busy and names the selected file";
-};
-export declare const SURFACE_SCHEMA_VERSION = 1;
-/** Every row's remote policy, by invocation. Exported for the contract test, which holds it to the guide exactly. */
-export declare const REMOTE_POLICY: ReadonlyMap<string, RemotePolicy>;
-/** How many times each invocation was classified — the contract test refuses a row stated twice. */
-export declare const REMOTE_POLICY_COUNT: number;
-/** Every guide row's local-owner mark, by invocation: `allow` with its act, else `deny`. Exported for the inventory test. */
-export declare const LOCAL_POLICY: ReadonlyMap<string, {
-    local: "allow";
-    act: LocalOwnerAct;
-} | {
-    local: "deny";
-}>;
-/** The invocations LOCAL_ALLOW names, for the inventory test (one naming no row is stale). */
-export declare const LOCAL_ALLOWED_INVOCATIONS: readonly string[];
-/** Every declared command, in guide order, paired with the schema of its `--json` answer (src/contracts/cli.ts).
- * An unclassified row is "no": nothing runs remotely by omission. */
-export declare const COMMAND_ENTRIES: readonly import("./contracts/cli.js").CommandEntry[];
-/** The invocations the guide states, for the contract test (a classification naming none of them is stale). */
-export declare const GUIDE_INVOCATIONS: readonly string[];
-/** The guide `contract --commands` dumps: each declared command's row, projected from COMMAND_ENTRIES. */
-export declare const COMMAND_GUIDE: readonly CommandRow[];

package/dist/sweep-gate.d.ts

@@ -1,10 +0,0 @@
-/** Assignment sweeps re-project every owned root on each pass. A pass is
- * skipped when nothing has moved since the last full cycle began: the store's
- * wake sequence is unchanged and that cycle started under a minute ago. The
- * minute covers changes that don't bump wake (time-based lease expiry, some
- * ledger-only writes). A cycle in progress (its cursor past 0) always goes on,
- * and a restarted process sweeps at once. */
-import type { Store } from "./store.js";
-export declare const SWEEP_FALLBACK_MS = 60000;
-/** Runs `sweep` unless the cycle under `cursorKey` would see what its last start saw. Returns whether it ran. */
-export declare function sweepIfMoved(store: Store, cursorKey: string, now: Date, sweep: () => void): boolean;

package/dist/sweep-quarantine.d.ts

@@ -1,29 +0,0 @@
-export declare const QUARANTINE_NOTE = ".toolroll-sweep.json";
-type Journal<T> = {
-    version: 1;
-    name: string;
-    data: T;
-    deleting: boolean;
-    pid: number;
-    host: string;
-    bootId: string | null;
-    machineId?: string | null;
-};
-export type Quarantine<T> = {
-    path: string;
-    original: string;
-    journal: Journal<T>;
-};
-export declare function quarantineEntries<T>(root: string): Quarantine<T>[];
-/** A small marker closes discovery before the atomic rename. It is never published half-written. */
-export declare function quarantine<T>(original: string, data: T): Quarantine<T> | null;
-/** Returns null if another sweep owns it (or won recovery). */
-export declare function claimQuarantine<T>(entry: Quarantine<T>): Quarantine<T> | null;
-export declare function releaseQuarantine<T>(entry: Quarantine<T>): void;
-/** A partially deleted tree must never become discoverable again. */
-export declare function restoreQuarantine<T>(entry: Quarantine<T>): boolean;
-/** Keep the journal until all potentially large removals succeeded. Recovery never guesses at a half-deleted tree. */
-export declare function deleteQuarantine<T>(entry: Quarantine<T>, remove: (path: string) => void | Promise<void>): Promise<void>;
-/** Staged pruning is also called synchronously by update/deploy. */
-export declare function deleteQuarantineSync<T>(entry: Quarantine<T>, remove: (path: string) => void): void;
-export {};

package/dist/sync.d.ts

@@ -1,94 +0,0 @@
-/**
- * External dispatch's sync pass (v20; five review rounds are the spec).
- *
- * What this does: pulls a tracker's nominated work into the overlay as
- * ORDINARY local tasks (mirrors), refreshes every known mirror's remote
- * state, verifies the plane marker, and delivers pending write-back
- * intents — all at daemon cadence, zero tokens.
- *
- * What this never does: touch claims or runs (the latch is a write to the
- * mirror row; admission and completion enforce it), import issue BODIES
- * (titles only, through the canonical proposal validator — a tracker
- * anyone can write to is a prompt-injection surface), or treat absence
- * from a capped listing as closure (every known mirror is fetched
- * INDIVIDUALLY; only a COMPLETE pass advances freshness).
- *
- * The plane marker is detection, never a distributed lease: a fixed-name
- * repository label carries this plane's id in its description. A 404 is
- * semantic "missing" only AFTER an authenticated access proof on the
- * repository itself — GitHub 404s private resources the caller cannot
- * see, and that must read as an OPERATIONAL block, fail closed.
- */
-import type { Runner } from "./backend.js";
-import type { BackendGrant } from "./grant.js";
-import type { Store } from "./store.js";
-export declare const SYNC_TIMEOUT_MS = 20000;
-export declare const MARKER_LABEL = "standing-orders-plane";
-/** Bounded forward scan: pages of 100, at most this many pages per pass. */
-export declare const MAX_FORWARD_PAGES = 10;
-export type RemoteIssue = {
-    number: number;
-    title: string;
-    state: "open" | "closed";
-};
-type Operational = {
-    ok: false;
-    kind: "operational";
-    message: string;
-};
-/** The gh surface the pass needs, injectable for tests. */
-export type DispatchAdapter = {
-    /** Authenticated access proof: 200 + push permission, or operational. */
-    repoAccess(remoteRepo: string): Promise<{
-        ok: true;
-        push: boolean;
-    } | Operational>;
-    /** Complete forward listing — complete=false when the page cap cut it. */
-    listAllOpen(remoteRepo: string): Promise<{
-        ok: true;
-        issues: RemoteIssue[];
-        complete: boolean;
-    } | Operational>;
-    /** One issue, individually — the reverse sweep's only evidence. */
-    getIssue(remoteRepo: string, number: string): Promise<{
-        ok: true;
-        found: RemoteIssue | null;
-    } | Operational>;
-    readMarker(remoteRepo: string): Promise<{
-        ok: true;
-        plane: string | null;
-        malformed: boolean;
-    } | Operational>;
-    writeMarker(remoteRepo: string, planeId: string): Promise<{
-        ok: true;
-    } | Operational>;
-    deleteMarker(remoteRepo: string): Promise<{
-        ok: true;
-    } | Operational>;
-    comment(remoteRepo: string, number: string, body: string): Promise<{
-        ok: true;
-    } | Operational>;
-    close(remoteRepo: string, number: string): Promise<{
-        ok: true;
-    } | Operational>;
-};
-export declare function ghDispatchAdapter(runner?: Runner, timeoutMs?: number): DispatchAdapter;
-/** ghi-<owner>-<name>-<n>-<hash8>: collision-resistant across long slugs. */
-export declare function mirrorTaskId(remoteRepo: string, remoteId: string): string;
-export type SyncReport = {
-    remoteRepo: string;
-    outcome: "complete" | "capped" | "failed" | "blocked";
-    detail: string | null;
-    candidates: number;
-    mirrored: number;
-    latched: number;
-    delivered: number;
-};
-/**
- * One pass over one dispatch grant. Order is the spec's: access proof →
- * marker verdict → forward scan → reverse sweep (every known mirror,
- * individually) → intent delivery → ledger close. Only a pass in which
- * EVERY step succeeded closes `complete` and advances freshness.
- */
-export declare function syncPass(store: Store, grant: BackendGrant, adapter: DispatchAdapter, now: () => Date): Promise<SyncReport>;
-export {};

package/dist/tailnet.d.ts

@@ -1,11 +0,0 @@
-type Runner = (file: string, args: readonly string[], options: {
-    timeoutMs: number;
-}) => Promise<{
-    code: number | null;
-    stdout: string;
-    notFound?: boolean;
-}>;
-/** The full MagicDNS name first (machine.tailnet.ts.net), then its short form (machine). Empty when Tailscale isn't running. */
-export declare function tailnetNamesOf(statusJson: string): string[];
-export declare function readTailnetNames(runner?: Runner, platform?: NodeJS.Platform): Promise<string[]>;
-export {};

package/dist/tamper-scan.d.ts

@@ -1,4 +0,0 @@
-/** Every expression in `text` that could reach the runner, with its arguments, spaces collapsed. */
-export declare function runnerExpressions(path: string, text: string): string[];
-/** What the candidate has that the base doesn't, as a multiset: an edited argument is a new expression, a moved one isn't. */
-export declare function tamperFindings(path: string, base: string | null, candidate: string): string[];

package/dist/task-activity.d.ts

@@ -1,27 +0,0 @@
-/**
- * What a running agent did last, recorded and read (live tasks).
- *
- * The recorder sits beside the live log on the agent's stream and keeps one
- * row per run: a fixed kind from live.ts's vocabulary and when. No text, no
- * tool names, no arguments are ever kept, so nothing here can leak a secret.
- * The reader picks the newer of that row and the run's latest progress
- * checkpoint, and asks the runner's heartbeat whether the worker still
- * answers. Neither side reads or stats a live-log file.
- */
-import { type RunActivity } from "./activity-line.js";
-import type { Store } from "./store.js";
-type Observer = {
-    observe(event: Record<string, unknown>): void;
-    close(): void;
-};
-/** Watch a run's stream for what the agent does, alongside its live log (which may be null). Fail-soft: a write
- * that fails never touches the run. */
-export declare function withRunActivity(liveLog: Observer | null, store: Pick<Store, "recordRunActivity">, run: number, clock: () => Date): Observer;
-/** A live run's last activity: the newer of its recorded kind and its latest progress checkpoint, else when it
- * started; and "offline" only when its registered worker's heartbeat has lapsed. */
-export declare function runActivityOf(store: Store, run: {
-    id: number;
-    runner: string;
-    startedAt: string;
-}, now: Date): RunActivity;
-export {};

package/dist/task-aliases.d.ts

@@ -1,5 +0,0 @@
-/** People's names for task commands (docs/plans/plain-toolroll.md P1.3): each is exactly the command it names, read
- * before anything else looks at the command, so a remote, local-owner or contract rule sees only the original. */
-export declare const TASK_ALIASES: Readonly<Record<string, string>>;
-/** `task <alias> …` as the command it names; anything else unchanged. */
-export declare function withTaskAlias(argv: readonly string[]): readonly string[];

package/dist/task-archive.d.ts

@@ -1,13 +0,0 @@
-/** Put-away checks (v145, docs/plans/task-tidy.md), in a leaf module so every door can ask without loading the store. */
-import type { Store } from "./store.js";
-/** Whether this task version is put away. Every door that dispatches, claims or approves asks this (fail closed: a
- * row means no). */
-export declare function refArchived(store: Store, taskRef: number): boolean;
-/** Whether the built-in task with this id is put away. */
-export declare function taskArchived(store: Store, taskId: string): boolean;
-/** Whether a flow card's work is put away: its current task or its first build task (a later stage keeps the first
- * and may clear the current one). Read from the card's own row now, so a put away that committed first holds it. */
-export declare function cardTaskArchived(store: Store, cardId: number): boolean;
-/** Whether the built-in task with this id is cancelled. Every door that approves, seals or carries a release asks
- * this beside the put-away check: a cancelled task takes no new yes (fail closed), by any road. */
-export declare function taskCancelled(store: Store, taskId: string): boolean;

package/dist/task-base.d.ts

@@ -1,39 +0,0 @@
-/**
- * Where a task's work starts, against current main (fresh base): one view for
- * the task page and `task show`. The base is saved run lineage — a builder
- * branch's pinned origin, or the newest plan's base — and the behind count is
- * read from Git now. Reads only.
- */
-import type { Store } from "./store.js";
-export type TaskBaseView = {
-    /** The base commit, in full. */
-    base: string;
-    branch: string;
-    /** The project's main: its checked-out branch, as a dispatch pass resolves it. Null when Git could not say. */
-    main: string | null;
-    /** Commits on main the base does not have; null when Git could not say. */
-    behind: number | null;
-    /** One short line: `Base 9d087efe · Behind main by 2 commits`. */
-    words: string;
-};
-/** A synchronous, read-only Git call in `cwd`: its trimmed output, or null on any failure. */
-export type GitRead = (cwd: string, args: readonly string[]) => string | null;
-export declare const readGit: GitRead;
-/** The base line on its own, for surfaces that label it already: `9d087efe · Behind main by 2 commits`. */
-export declare function baseStandingWords(view: Pick<TaskBaseView, "base" | "main" | "behind">): string;
-/**
- * The lease's fresh-base request for one attempt on `branch`, or nothing when the task's start is pinned elsewhere: a
- * revision keeps the head of the attempt it revises, and a prepared candidate or coding review keeps the base its
- * candidate was proved against.
- */
-export declare function freshBaseFor(store: Store, taskId: string, branch: string, main: string): {
-    freshBase: {
-        main: string;
-        recordedBase: string | null;
-    };
-} | Record<string, never>;
-export declare function taskBaseOf(store: Store, taskId: string, git?: GitRead): TaskBaseView | null;
-/** `git`'s answers kept for `ttlMs` (at most `entries` of them), for a page that shows the base line on every refresh:
- * each read still goes through the same frozen view when it runs; only its answer is reused for a moment. Display only —
- * never for a decision. */
-export declare function recentGitReads(git?: GitRead, ttlMs?: number, entries?: number, now?: () => number): GitRead;

package/dist/task-composer.d.ts

@@ -1,14 +0,0 @@
-/** UI choices translate into the same digest-bound schedules as the CLI. */
-import { type Schedule } from "./flow-schedule.js";
-import { type Html } from "./html.js";
-export declare function composerSchedule(fields: URLSearchParams): {
-    ok: true;
-    schedule: string | null;
-} | {
-    ok: false;
-    message: string;
-};
-export declare function scheduleFields(schedule: Schedule): Record<string, string>;
-/** A normal form works without JavaScript; enhancement only folds unused fields. */
-export declare function scheduleEditorHtml(raw: string | null, submitted?: URLSearchParams): Html;
-export declare function scheduleEditorScript(): string;