@stringsync/splates 0.0.60 → 1.13.3

package/vendor/@stringsync/splates-server/server/interrupt.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Ps } from "../../../core/system/index.js";
+import { type Timer } from "../../../core/time/index.js";
+/** Stops the server command on Ctrl-C, even when a child ignores its stop signal. */
+export declare class ServerInterrupt {
+    private readonly ps;
+    private readonly opts;
+    private readonly stopping;
+    private readonly forced;
+    private deadline;
+    private forcing;
+    constructor(ps: Ps, opts: ServerInterruptOptions);
+    get signal(): AbortSignal;
+    interrupt(): void;
+    /** A child that ignores SIGTERM must not hold the command open forever. */
+    wait<T>(running: Promise<T>): Promise<T>;
+    dispose(): void;
+    private force;
+}
+interface ServerInterruptOptions {
+    timer: Timer;
+    log: Logger | null;
+}
+export {};

package/vendor/@stringsync/splates-server/server/loop-watch.d.ts

@@ -0,0 +1,12 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import { type Clock, type Timer } from "../../../core/time/index.js";
+/** Leaves evidence of a delayed event loop beside the worker's missed heartbeats. */
+export declare class LoopWatch implements Resource {
+    private readonly interval;
+    constructor(log: Logger, { clock, timer, }?: {
+        clock?: Clock;
+        timer?: Timer;
+    });
+    dispose(): void;
+}

package/vendor/@stringsync/splates-server/server/migrations.d.ts

@@ -0,0 +1,46 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { Projects } from "../projects";
+/** What `Migrations` works with. */
+export interface MigrationsHome {
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    projects: Projects;
+    /** Opens the project at `root` again, as its next request would. */
+    reopen(root: string): Promise<unknown>;
+}
+/**
+ * What `splates server` does about each project's records being older than it
+ * reads: moves them all forward before it listens, and, for one whose
+ * migration failed, says why to the page, tries again when asked, and
+ * names the root its terminal opens in. A failure is never tried again on
+ * its own, so the server comes up once and stays up, however often it is
+ * started.
+ */
+export declare class Migrations {
+    private readonly home;
+    constructor(home: MigrationsHome);
+    /**
+     * Moves every registered project's records forward, all at once, each
+     * within the limit `Migration` keeps: a failure is kept for its page and
+     * never stops the others, or the server.
+     */
+    startAll(): Promise<void>;
+    /**
+     * The project `request` names with `?project=`, or the focused one, read
+     * from the registry alone, so it is found with records that do not open.
+     */
+    rootFor(request: Request): Promise<string>;
+    /**
+     * The failure kept for the project `request` names, with what the page's
+     * Fix with an agent types into its terminal and the branch it opens on;
+     * `failure` null for none.
+     */
+    readonly read: (request: Request) => Promise<Response>;
+    /** Forgets the failure kept for the project `request` names, and opens it again. */
+    readonly retry: (request: Request) => Promise<Response>;
+    private of;
+    /** The command that starts an agent told what failed and how to try again. */
+    private fix;
+}

package/vendor/@stringsync/splates-server/server/options.d.ts

@@ -0,0 +1,143 @@
+import type { Pusher, VapidKeys } from "../../../core/push/index.js";
+import type { PortProvider } from "../../../core/system/index.js";
+import type { Duration } from "../../../core/time/index.js";
+import type { Config } from "../config";
+import type { Conversations } from "../conversations";
+import type { Creds } from "../creds";
+import type { TranscriberFor } from "../dictate";
+import type { Git } from "../git";
+import type { Slot } from "../ports";
+import type { Journal } from "../records";
+import type { Storage } from "../storage";
+import type { WorktreeService } from "../tasks";
+import type { AccessConfig, TunnelConfig } from "../tunnel";
+import type { CoordinatorState, DevWorkers, MachineSensors, WorkerMachine } from "../workers";
+import type { GeneralOptions } from "./general";
+import type { Project } from "./project";
+import type { ServerChoice } from "./servers";
+/** What `dev` lets a caller choose. */
+export interface DevOptions {
+    /**
+     * Where the local worker dials in, a Unix socket path; without it, workers
+     * reach this server only through `/api/workers`.
+     */
+    workerSocket?: string | null;
+    /** Where workers are taken in; one of its own by default. */
+    workers?: DevWorkers | null;
+    /**
+     * What this server keeps across its restarts: the roots of the
+     * projects whose agents the last run let go of, served before the worker
+     * joins so they are taken back, and written again at the next restart;
+     * null keeps nothing, and a restart ends every agent.
+     */
+    coordinator?: CoordinatorState | null;
+    /**
+     * The worker agents and terminals run on, whose process table a restart
+     * reads; this machine, read directly, by default.
+     */
+    worker?: WorkerMachine | null;
+    /**
+     * The wildcard base host task ports are served under, as
+     * `<task>-<port>.<base>`, behind `access`; null serves them only on
+     * loopback ports here. Refused without `access`.
+     */
+    portsHost?: string | null;
+    /** Where to listen; the port `--port` asked for, and the span above it. */
+    ports?: PortProvider;
+    /**
+     * Host names besides this machine's own that the page may be reached by,
+     * like the hostname of a tunnel. Anything else is refused, which is what
+     * stops another site from reading the repo through a browser pointed at
+     * localhost. Who may use those names is the Access policy's business, not
+     * splates's.
+     */
+    hosts?: string[];
+    /**
+     * The Cloudflare Access application in front of `hosts`, or null for none.
+     * Given one, a request to those hosts must carry a token it signed, and
+     * then may use conversations and terminals too. Anything that exposes the
+     * page beyond this machine refuses to without it.
+     */
+    access?: AccessConfig | null;
+    /**
+     * The Cloudflare tunnel to run once listening, whose host `hosts` also
+     * lets in. Refused without `access`.
+     */
+    tunnel?: TunnelConfig | null;
+    /**
+     * Makes the conversations a project's page may hold with agents, its
+     * records in `storage`, its commands watched through `git`, its limits
+     * from `config`, its agents placed on a remote worker in its tasks'
+     * clones that `service` records; without it no page has any to show, and the routes
+     * say they are off.
+     */
+    conversations?: ((project: {
+        dir: string;
+        storage: Storage;
+        git: Git;
+        config: Config;
+        creds: Creds;
+        /** Its tasks, for where its agents start on a remote worker. */
+        service: WorktreeService;
+        /** Where what its agents do is logged. */
+        journal: Journal;
+    }) => Conversations) | null;
+    /** The machine's projectless conversations; none when omitted. */
+    general?: GeneralOptions | null;
+    /**
+     * The shell a page's terminal runs, as argv, in the main tree or a task's
+     * worktree; without it, the page has no terminal and the route says so.
+     */
+    shell?: string[] | null;
+    /**
+     * What a project's dictations transcribe with, by default OpenAI on the
+     * key its creds keep; a test hands in a fake.
+     */
+    transcriber?: TranscriberFor;
+    /** Opens a registered project by its root; `openRepository` by default. */
+    open?: (root: string) => Promise<Project>;
+    /**
+     * The latest splates on npm, or null when it cannot say, asked as the server
+     * starts and hourly after; the page hints at a restart once it is past
+     * `running`. Without it, nothing is checked.
+     */
+    newest?: () => Promise<string | null>;
+    /** The version serving; the one installed by default. */
+    running?: string;
+    /** How often `newest` is asked after the first time: hourly by default. */
+    checkEvery?: Duration;
+    /**
+     * The last commit to splates's own source, or null when it does not run
+     * from a checkout. Asked as the server starts, then every `sourceEvery`;
+     * once it moves on, the page hints at a restart. A server started from a
+     * checkout asks this in place of `newest`, since a restart runs the
+     * checkout again. Without it, nothing is checked.
+     */
+    source?: () => Promise<string | null>;
+    /** How often `source` is asked after the first time. */
+    sourceEvery?: Duration;
+    /**
+     * Whether building the page failed before this start, so what it serves
+     * is the page built before; the page says so.
+     */
+    unbuilt?: boolean;
+    /** The slot `splates server --slot` serves under, which the page shows; null for none. */
+    slot?: Slot | null;
+    /**
+     * Every `splates server` on this machine, the machine's own and each slot's,
+     * which the page's switcher lists beside the projects; none by default.
+     */
+    servers?: () => Promise<ServerChoice[]>;
+    /**
+     * Ends the process with `RESTART` or `UPDATE` once the server has
+     * stopped, for its supervisor to start another; without it, the page
+     * cannot restart `splates server`.
+     */
+    exit?: ((code: number) => void) | null;
+    /** How long a restart or shutdown waits on checkpoints and on stopping before going on without them; five minutes for none. */
+    deadlineMs?: number;
+    /** Where the page's machine stats come from; this machine's OS for none. */
+    sensors?: MachineSensors | null;
+    /** What pushes notices to the devices that subscribed; the Web Push services by default. */
+    pusher?: (keys: VapidKeys) => Pusher;
+}

package/vendor/@stringsync/splates-server/server/pages.d.ts

@@ -0,0 +1,35 @@
+import type { Assets } from "./assets";
+/**
+ * The page the server hands to browsers: the files built as this run
+ * started. It changes only with a restart, which builds it again before the
+ * server comes back, so the page always matches the server it talks to.
+ */
+export declare class Pages {
+    readonly assets: Assets;
+    /** The shell, naming the script and styles by what they hold. */
+    readonly page: string;
+    /**
+     * Each file by its path: the small ones made as the server starts, the
+     * chunks and their maps only on the first ask for one.
+     */
+    private readonly files;
+    constructor(assets: Assets);
+    /** The server's routes for the page's own files, spread into its `routes`. */
+    routes(): Record<string, (request: Request) => Promise<Response>>;
+    /** What each body gzips to, made on first ask and kept for the run. */
+    private readonly gzipped;
+    /**
+     * What each body compresses to under brotli, which takes seconds at its
+     * best setting: started on the first ask and kept once done, while that
+     * ask and any before it is done are answered with gzip.
+     */
+    private readonly brotlied;
+    /**
+     * `file`, or a 304 for a request that holds this very build. A request for
+     * the stamped `?v=` name of a body it holds may keep it for good, since a
+     * new build is a new name.
+     */
+    private respond;
+    /** `file` under brotli once that is made, else null, starting to make it. */
+    private brotli;
+}

package/vendor/@stringsync/splates-server/server/ports.d.ts

@@ -0,0 +1,11 @@
+import { type PortProvider } from "../../../core/system/index.js";
+/** Preferred, not required: `dev` moves up from here when it is taken. */
+export declare const DEFAULT_PORT = 4269;
+/** How far above the port asked for `dev` will look before giving up. */
+export declare const PORT_SPAN = 20;
+/**
+ * Where `dev` will listen, given the port asked for. A flag is outside input,
+ * so a port that cannot exist is a refusal with an exit code rather than the
+ * assertion `OpenPortProvider` would raise for a bug in here.
+ */
+export declare function devPorts(from: number): PortProvider;

package/vendor/@stringsync/splates-server/server/premerge.d.ts

@@ -0,0 +1,61 @@
+import type { Logger } from "../../../core/log/index.js";
+import { type Fs, type Ps } from "../../../core/system/index.js";
+import { type PlacedAcquireOptions, type PlacedLock } from "./ticketed-lock";
+/** Set for what a merge's gate runs: a `bin/mono premerge` that sees it runs without waiting for the premerge lock, which the gate holds. */
+export declare const PREMERGE_HELD = "SPLATES_PREMERGE";
+/** The commit the `preLock` checks passed on, set for the gate's `bin/mono premerge`. */
+export declare const CHECKED_COMMIT = "SPLATES_CHECKED";
+/**
+ * The nice for anything an agent runs beside a merge gate that is not the
+ * gate, so the gate keeps the CPU: pass it to `nice -n` or `os.setPriority`.
+ */
+export declare const BESIDE_GATE_NICE = 10;
+/**
+ * Set for a merge's gate to the test files that failed recent gates, one
+ * path a line, which `bin/mono premerge` runs before the whole suite.
+ */
+export declare const RECENT_FAILED_FILES = "SPLATES_RECENT_FAILED_FILES";
+/**
+ * Set for a merge's gate to a file its command may append the phases it
+ * timed to, one `{"phase": "<name>", "ms": <n>}` line each, which the merge's
+ * log entry keeps as its `gate`.
+ */
+export declare const GATE_PHASES = "SPLATES_GATE_PHASES";
+/** How long a merge's gate may run before it is killed, on a machine whose cores it fits. */
+export declare const PREMERGE_TIMEOUT_MS: number;
+/** Set for a merge's gate to its deadline in milliseconds, which `bin/mono premerge` stops its tests by. */
+export declare const GATE_DEADLINE = "SPLATES_GATE_DEADLINE_MS";
+/** How long one holder may keep the premerge lock before it is let go of; a gate given a longer deadline renews it for that long. */
+export declare const PREMERGE_HOLD_MS: number;
+/**
+ * A lock that lets its holder go after `holdMs`. `renew` it before each
+ * bounded step of work, with the step's own bound when that is longer.
+ */
+export declare class TimedLock implements PlacedLock {
+    #private;
+    private readonly inner;
+    private readonly holdMs;
+    private readonly log;
+    constructor(inner: PlacedLock, holdMs: number, log: Logger);
+    acquire(onPlace?: (place: number) => void | Promise<void>, signal?: AbortSignal, opts?: PlacedAcquireOptions): Promise<void>;
+    renew(holdMs?: number): void;
+    release(): Promise<void>;
+    releaseIfOurs(): Promise<void>;
+}
+/**
+ * A project's one premerge: every task's merge gate in that project, and a
+ * `bin/mono premerge` run by hand there, holds it while the whole suite
+ * runs, so a project's full suite runs one at a time. Projects take theirs
+ * apart, since they cannot stomp on each other's checkouts. Waiters take it
+ * in the order they asked, told their place in line meanwhile, and a holder
+ * keeps it at most `PREMERGE_HOLD_MS`. `root` is the project's main tree.
+ */
+export declare function premergeLockOfProject({ fs, ps, log, root, holdMs, }: {
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    root: string;
+    holdMs?: number;
+}): PlacedLock;
+/** The main tree of the project `cwd` is in, whichever worktree that is. */
+export declare function projectRootOf(ps: Ps, cwd: string): Promise<string>;

package/vendor/@stringsync/splates-server/server/project-watch.d.ts

@@ -0,0 +1,94 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import { Duration } from "../../../core/time/index.js";
+import { type Snapshot } from "../tasks";
+import { type StreamWatcher } from "./http";
+import type { DevContext, Project } from "./project";
+/** How long changes to a repo's files settle before it is read again. */
+export declare const SETTLE: Duration;
+/**
+ * What one project's pages hear of its repo: its records, read whole and kept
+ * until something in them moves, and a stream that says `changed` whenever
+ * what they show moved.
+ */
+export declare class ProjectWatch implements StreamWatcher {
+    private readonly project;
+    private readonly context;
+    /** The streams of the pages listening. */
+    private readonly open;
+    /** What else listens as a page does, such as the every-project feed. */
+    private readonly heard;
+    private last;
+    /** Bumped by every sign the repo moved, so a read from before it is stale. */
+    private moves;
+    /** The last read, kept while no move has come since it began. */
+    private kept;
+    /** The read under way, which every caller at its move count shares. */
+    private reading;
+    /** Whether the records are watched, without which nothing kept is trusted. */
+    private watching;
+    private disposed;
+    private watches;
+    private readonly trees;
+    private poll;
+    /**
+     * Reads each task, keeping what git said of it until a ref or a
+     * worktree's file moves, so a board write re-reads only the records.
+     */
+    private readonly details;
+    private readonly settle;
+    private readonly edits;
+    /** Watches `project`, read once now so the first page opens on it. */
+    static start(project: Project, context: DevContext): Promise<ProjectWatch>;
+    private constructor();
+    /**
+     * The whole repo, as a page shows it. A worktree's edits may lag by as
+     * long as they take to settle.
+     */
+    current(): Promise<Snapshot>;
+    /**
+     * Call it after a page's own write: the repo is read again behind the
+     * answer, and its pages told.
+     */
+    tick(): void;
+    /** Reads the repo again soon, telling its pages if anything moved. */
+    readonly changed: () => void;
+    /** As {@link changed}, for a move that git may say something new of. */
+    private readonly moved;
+    private readonly edited;
+    /** The stream a page listens to for `changed`. */
+    events(): Response;
+    /**
+     * Calls `changed` whenever what a page shows moved, listening as a page
+     * does, so worktrees' edits move it too, until disposed.
+     */
+    listen(changed: () => void): Resource;
+    opened(): void;
+    closed(): void;
+    /** How many pages, and whatever else, listen. */
+    private get listening();
+    dispose(): void;
+    /** The repo read whole, the server's own facts aside. */
+    private read;
+    /** `snapshot` with what the server says of itself now, which it may have learned since. */
+    private live;
+    /** A read begun at the current move count, kept once it lands. */
+    private fresh;
+    /** Tells the pages listening, if what they show moved since they last heard. */
+    private push;
+    /**
+     * Reads again behind what is kept, which still answers meanwhile, and
+     * tells the pages listening if it moved.
+     */
+    private revalidate;
+    private tell;
+    private watchRecords;
+    private arm;
+    private disarm;
+    /**
+     * Watches each worktree in `paths`, and no other: its SPLATES.md always,
+     * and while a page listens, its files as they are edited, which move its
+     * counts. A recursive watch costs a watch per directory
+     * on some systems, so none is kept for a page that is not open.
+     */
+    private follow;
+}

package/vendor/@stringsync/splates-server/server/project.d.ts

@@ -0,0 +1,239 @@
+import type { Deps } from "../../../core/cmd/index.js";
+import type { Transcriber } from "../../../core/dictate/index.js";
+import type { AsyncResource, Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { ElsewhereBoards, LaneRecord, TaskRecord } from "../board";
+import type { ConversationState, Conversations, ConversationsHeard } from "../conversations";
+import type { SecretStores } from "../creds";
+import type { TranscriberFor } from "../dictate";
+import { type Needing } from "../plans";
+import type { PortOwners, Slot } from "../ports";
+import type { Everywhere, Projects } from "../projects";
+import type { Format, Journal, Repository } from "../records";
+import { type ReplicaStatus } from "../replica";
+import { Shipping } from "../ship";
+import type { Details, Snapshot } from "../tasks";
+import type { Assets } from "./assets";
+import type { Behind, Release } from "./release";
+import type { Replicas } from "./replicas";
+/**
+ * Everything one project's page talks to: its records, its stream of
+ * changes and its conversations, kept from the first request for it until
+ * the server stops.
+ */
+export declare function serveProject(project: Project, context: DevContext): Promise<Served>;
+/** What `dev` serves a project with: its own records, read and written. */
+export type Project = Pick<Repository, "service" | "config" | "journal" | "tasks" | "format" | "dir" | "storage" | "git" | "creds" | "slots" | "trunk" | "branches" | "lock"> & {
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+};
+/**
+ * What `dev` runs with: the machine's, not any project's, since it serves
+ * every registered project wherever it was started.
+ */
+export type DevMachine = Deps & {
+    fs: Fs;
+    /** Where each project's creds are kept; the system's stores by default. */
+    secrets?: SecretStores;
+    /** How setup's checks reach the network; the global fetch by default. */
+    fetch?: typeof fetch;
+    /** The built page. */
+    assets: Assets;
+    /** Every splates project on this machine. */
+    projects: Projects;
+    /**
+     * Projects opened already, served as they are rather than opened again:
+     * a test's own, with its fakes.
+     */
+    opened?: Project[];
+};
+/** What the server as a whole tells each project it serves. */
+export interface DevContext {
+    /** Where the agents' own `splates` reaches this server, once it listens. */
+    readonly url: string | null;
+    /** A newer splates on npm, once a check has found one; every page says so. */
+    readonly release: Release | null;
+    /** Commits to splates's own source since this run started, once seen. */
+    readonly behind: Behind | null;
+    /** Whether building the page failed, so it serves the one built before. */
+    readonly unbuilt: boolean;
+    /** The slot `splates server --slot` serves under, or null. */
+    readonly slot: Slot | null;
+    /** The replicators of every project, which `serveProject` leaves to run on. */
+    readonly replicas: Replicas;
+    /** The conversations `project`'s page may hold, or null when they are off. */
+    conversationsFor(project: Project): Conversations | null;
+    /** Every served project's conversations, where a caller of one may be. */
+    readonly everywhere: Everywhere;
+    /**
+     * The other projects' boards, which its tasks may wait on; absent, as in
+     * a test of one project, none is read.
+     */
+    readonly boards?: ElsewhereBoards;
+    /** Calls `listener` whenever the workers' slots change, until the call it gives back. */
+    onWorkerRoom(listener: () => void): () => void;
+    /** Whether everything splates starts on its own waits, the person's own agents alone starting. */
+    paused(): boolean;
+    /** What `project`'s dictations transcribe with. */
+    readonly transcriberFor: TranscriberFor;
+}
+/** A route's work once its project is known. */
+export type Handler = (request: Request) => Promise<Response>;
+/** One project as the server holds it: what each of its routes does. */
+export interface Served extends AsyncResource {
+    root: string;
+    /** Its config's `afterBump`, for the bump tasks of a ship's cascade. */
+    afterBump: string | null;
+    /** Its journal, for the events the server logs on its behalf. */
+    journal: Journal;
+    format: Format;
+    conversations: Conversations | null;
+    /** Reads the repo again soon, telling its pages if anything moved. */
+    refresh: () => void;
+    snapshot: Handler;
+    /**
+     * Everything its page shows, cheap enough to read for every project at
+     * once: a read while nothing in the repo moved answers the last one.
+     */
+    current: () => Promise<Snapshot>;
+    /** How many of its agents wait on the person. */
+    waiting: () => Promise<number>;
+    /** What each of its agents needs, and the lanes that name an orchestrator. */
+    needing: () => Promise<{
+        rows: Needing[];
+        lanes: LaneRecord[];
+    }>;
+    /** Every lane there has been, to name an orchestrator after. */
+    lanes: () => Promise<LaneRecord[]>;
+    /** Its tasks' worktrees and agents, whose processes' ports are the tasks'. */
+    portOwners: () => Promise<PortOwners>;
+    events: Handler;
+    /**
+     * Tells `heard` of each move its pages would hear, listening as a page
+     * does, until disposed.
+     */
+    listen: (heard: ProjectHeard) => Resource;
+    file: Handler;
+    open: Handler;
+    paths: Handler;
+    diff: Handler;
+    finishedTasks: Handler;
+    mergeEstimates: Handler;
+    mergeOutput: Handler;
+    finishedTask: Handler;
+    retryTask: Handler;
+    removeTask: Handler;
+    addQueued: Handler;
+    updateQueued: Handler;
+    moveQueued: Handler;
+    linkQueued: Handler;
+    elsewhereTasks: Handler;
+    arrangeQueued: Handler;
+    assignQueued: Handler;
+    queueQueued: Handler;
+    answerDeferred: Handler;
+    doneOutside: Handler;
+    moveInQueue: Handler;
+    /** Tries a queued task's refused start again. */
+    retryQueued: Handler;
+    joinLane: Handler;
+    addLane: Handler;
+    updateLane: Handler;
+    dropLane: Handler;
+    removeQueued: Handler;
+    restoreQueued: Handler;
+    /** The project's latest ship. */
+    ship: Handler;
+    /** Runs the project's ship, as a cascade's step. */
+    shipping: Shipping;
+    /** The project's bump tasks in a cascade. */
+    /** What its latest ship printed, as it prints. */
+    shipOutput: Handler;
+    listCreds: Handler;
+    saveCred: Handler;
+    removeCred: Handler;
+    dismissCred: Handler;
+    /** Where its replica stands now, or as last recorded; null when none has run. */
+    replica: () => Promise<ReplicaStatus | null>;
+    /** Whether its creds, the project's then the device's, keep `name`. */
+    kept: (name: string) => Promise<boolean>;
+    listBudgets: Handler;
+    setBudget: Handler;
+    raiseBudget: Handler;
+    endRaise: Handler;
+    pauseBudget: Handler;
+    resumeBudget: Handler;
+    listAutomations: Handler;
+    addAutomation: Handler;
+    editAutomation: Handler;
+    removeAutomation: Handler;
+    pauseAutomation: Handler;
+    resumeAutomation: Handler;
+    runAutomation: Handler;
+    listConversations: Handler;
+    searchConversations: Handler;
+    showConversation: Handler;
+    refreshLimits: Handler;
+    chooseDefault: Handler;
+    startShipTask(task: string, ship: string): Promise<void>;
+    startConversation: Handler;
+    startAutoPick: Handler;
+    tryAutoPick: Handler;
+    listSessions: Handler;
+    bringSession: Handler;
+    /**
+     * Asks every live conversation here to bring its SPLATES.md up to date,
+     * answering with what settles as each answers; with `budget`, those
+     * `only` names, for a worker budget hard stop.
+     */
+    checkpoint: (only?: string[], budget?: string | null) => Promise<Promise<void>[]>;
+    moveConversation: Handler;
+    promptConversation: Handler;
+    approveSuite: Handler;
+    addArtifact: Handler;
+    removeArtifact: Handler;
+    deleteArtifactVersion: Handler;
+    conversationAttachment: Handler;
+    conversationArtifact: Handler;
+    answerConversation: Handler;
+    cancelConversation: Handler;
+    pauseConversation: Handler;
+    restartConversation: Handler;
+    handOffConversation: Handler;
+    stopBackground: Handler;
+    backgroundOutput: Handler;
+    unqueueConversation: Handler;
+    sendQueuedNow: Handler;
+    chooseSetting: Handler;
+    switchAutoPick: Handler;
+    renameConversation: Handler;
+    markUnread: Handler;
+    markRead: Handler;
+    pinConversation: Handler;
+    reparentConversation: Handler;
+    archiveConversation: Handler;
+    conversationEvents: Handler;
+    terminalTree: (request: Request) => Promise<string>;
+    /**
+     * What a dictation transcribes with, read afresh for each take; null,
+     * after asking for the key on the Creds page, without one.
+     */
+    transcriber: () => Promise<Transcriber | null>;
+}
+/** What a listener other than a page hears of one project. */
+export interface ProjectHeard extends ConversationsHeard {
+    /** Something its snapshot holds moved, such as a task. */
+    board(): void;
+}
+/**
+ * How many agents wait on the person, counted as the page's waiting line
+ * counts them: only conversations, and questions only while unanswered.
+ */
+export declare function waitingOn(tasks: Details[], conversations: ConversationState[], todos?: readonly TaskRecord[]): number;
+/**
+ * How many tasks wait on the person where no conversation is known, as for a
+ * project not opened, whose conversations are not loaded.
+ */
+export declare function waitingTasks(tasks: Details[]): number;