@stringsync/splates 0.0.0-stage → 0.0.45

package/todo-lanes.d.ts

@@ -0,0 +1,82 @@
+import type { Fs } from "webappwiz/system";
+import { type LaneRecord } from "./lanes.js";
+import type { TodoState } from "./todo.js";
+import type { Todos } from "./todos.js";
+/**
+ * The lanes of a `Todos`: their records in `lanes` beside the todos, and every
+ * change that moves todos between them, each made under the todos' lock.
+ */
+export declare class TodoLanes {
+    private readonly todos;
+    private readonly fs;
+    constructor(todos: Todos, fs: Fs);
+    /**
+     * Moves every todo in lane `from` to the bottom of lane `into`, in the
+     * order they had, and the lane `from` is gone.
+     */
+    joinLanes(from: number, into: number): Promise<void>;
+    /** Starts an empty lane called `name`, after the others. */
+    addLane(name: string): Promise<LaneRecord>;
+    /** Calls lane `id` by another name. */
+    renameLane(id: number, name: string): Promise<LaneRecord>;
+    /**
+     * Puts lane `id` at `position` among the lanes, 1 the first column, past
+     * the last meaning the last; the others close up around it.
+     */
+    moveLane(id: number, position: number): Promise<LaneRecord[]>;
+    /** Removes lane `id`, putting its todos back in none, untriaged. */
+    dropLane(id: number): Promise<void>;
+    /**
+     * @internal Removes each lane in `ids` that no todo is in any more: a lane
+     * whose last todo merged is done. One emptied by hand stays, to be filled.
+     */
+    endLanes(ids: number[]): Promise<void>;
+    /**
+     * Moves todos saved while splates kept tags into lanes, one lane a tag,
+     * and drops their tags, which splates refuses to read until then. A todo
+     * in no lane goes to the lane of its tag the most todos share, at the
+     * bottom, in list order, below anything in that lane blocking it; a lane
+     * already called that takes them. Gives back each lane it filled, with
+     * the todos it put there, in board order; none once no todo has tags.
+     */
+    moveTagsToLanes(): Promise<{
+        lane: LaneRecord;
+        todos: number[];
+    }[]>;
+    /**
+     * @internal The lane `lane` names: null for none, one there is, or for
+     * `"new"` one started for `todos`, called `name` or named after them. Call
+     * it under the lock.
+     */
+    laneId(lane: number | "new" | null, states: TodoState[], todos: TodoState[], name?: string): Promise<number | null>;
+    /**
+     * Starts a lane for `todos` after the others, called `name`, or aptly
+     * named without one. Call it under the lock.
+     */
+    private newLane;
+    /**
+     * A lane id never handed out before, so a lane's number never comes back
+     * meaning another. Call it under the lock.
+     */
+    private nextLaneId;
+    /**
+     * @internal The lanes as stored, and after them any lane a todo is in that
+     * has no record. A file that will not parse reads as none.
+     */
+    records(states: TodoState[]): Promise<LaneRecord[]>;
+    /**
+     * The name of every lane there has been: those on the board, and after
+     * them each that is gone as it was last called, so an orchestrator whose
+     * lanes are done still goes by their names.
+     */
+    names(states: TodoState[]): Promise<LaneRecord[]>;
+    /** The lane records in `file`, none when it is missing or will not parse. */
+    private read;
+    /**
+     * Writes the lanes, in board order, keeping the name of each lane they
+     * drop in `ended-lanes`. Call it under the lock.
+     */
+    private writeLanes;
+    /** Writes `records` to `file` whole, so a reader never sees half of it. */
+    private write;
+}

package/todo-list.d.ts

@@ -0,0 +1,26 @@
+import { type Logger } from "webappwiz/log";
+import type { Todos } from "./todos.js";
+export interface TodoListOptions {
+    /** Print the todos as JSON instead of a table. */
+    json?: boolean;
+    /** Only those no task has taken: the ones free to pick up. */
+    open?: boolean;
+    /**
+     * Only those free to start now: nobody has taken them, and nothing they
+     * is blocked by is still open.
+     */
+    ready?: boolean;
+}
+export declare function todoList({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, { json, open, ready }?: TodoListOptions): Promise<void>;
+export interface TodoShowOptions {
+    /** Print the todo as JSON instead of prose. */
+    json?: boolean;
+}
+/** One todo in full: what `todo list` shows of it, its files, and its detail. */
+export declare function todoShow({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, id: number, { json }?: TodoShowOptions): Promise<void>;

package/todo-take.d.ts

@@ -0,0 +1,27 @@
+import { type Logger } from "webappwiz/log";
+import type { Todo } from "./todo.js";
+import type { Todos } from "./todos.js";
+/**
+ * Takes up todos for `task` after it started, as when one turns out to be
+ * part of the work. Every id is checked before any is taken, so one that is
+ * gone or another task's refuses them all.
+ */
+export declare function todoTake({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, ids: number[], task: string | null): Promise<Todo[]>;
+/**
+ * Puts todos back on the list, as when a task is landing without finishing
+ * them: say what is left with `splates todo update` first. From a worktree it
+ * gives back only its own task's todos.
+ */
+export declare function todoRelease({ todos, log }: {
+    todos: Todos;
+    log: Logger;
+}, ids: number[], task: string | null): Promise<Todo[]>;
+/**
+ * The lines warning that `todo` was taken while `blockers` have yet to merge,
+ * or none when nothing blocks it: it may be started, but what it builds on
+ * is not there yet.
+ */
+export declare function blockedWarning(todo: Todo, blockers: Todo[]): string[];

package/todo.d.ts

@@ -0,0 +1,146 @@
+import type { Attachment, Attachments } from "./attachments.js";
+import type { Journal } from "./journal.js";
+import type { AgentPick } from "./roster.js";
+import type { Todos } from "./todos.js";
+/** What a todo is on disk: one file apiece, so two agents never rewrite one. */
+export interface TodoState {
+    id: number;
+    /** What is left to do, in a line. */
+    subject: string;
+    /** Whatever more there is to say about it, or empty when the line is enough. */
+    text: string;
+    /** Where it stands in the list, 1 at the top: the one to pick up first. */
+    position: number;
+    /** The task it came up in, or null when a person added it from the main tree. */
+    from: string | null;
+    createdAt: string;
+    /** The task working on it now, or null while it waits to be picked up. */
+    takenBy: string | null;
+    /** Absolute paths of the files attached, in `todos/<id>/`. */
+    files: string[];
+    /**
+     * The todos that have to merge before this one starts, sorted. One leaves
+     * the list when it merges or is removed, and with it every link to it.
+     */
+    blockedBy: number[];
+    /** The lane it runs in, or null for none. */
+    lane: number | null;
+    /** The agent, and model, that should work it, over its lane's; absent for none. */
+    assignee?: AgentPick;
+    /** The other project it was added from; absent for one added here. */
+    origin?: TodoOrigin;
+}
+/**
+ * Work deferred for later: what an agent notes when something outside its
+ * task comes up, so it can move on instead of growing the task. Kept under the
+ * shared `.git`, so every worktree sees a new one at once, with nothing to
+ * commit and nothing to merge.
+ */
+export declare class Todo {
+    private readonly todos;
+    readonly state: TodoState;
+    constructor(todos: Todos, state: TodoState);
+    get id(): number;
+    get subject(): string;
+    get text(): string;
+    get position(): number;
+    get from(): string | null;
+    get takenBy(): string | null;
+    get createdAt(): Date;
+    /** How long it has waited, in milliseconds. */
+    get waited(): number;
+    /**
+     * The todos blocking it that have yet to merge, leaving out those `task`
+     * has or takes in the same breath, among `together`: what it should not be
+     * started before.
+     */
+    blockers(task: string, together?: number[]): Promise<Todo[]>;
+    /** Marks it as the work of `task`, refusing one another task already has. */
+    take(task: string): Promise<Todo>;
+    /** Puts it back on the list, as when the task that took it is removed. */
+    release(): Promise<Todo>;
+    get files(): string[];
+    /** The todos that have to merge before it starts. */
+    get blockedBy(): number[];
+    get lane(): number | null;
+    get attachments(): Attachments;
+    /**
+     * Says what is left to do in other words, with other files, or higher or
+     * lower in the list, keeping its id and history.
+     */
+    update({ subject, text, position, files, keep, blockedBy, lane, assignee, }: TodoChange): Promise<Todo>;
+    remove(): Promise<void>;
+    /** Removes it, as the person did, keeping it for `Todos.restore` to put back. */
+    discard(): Promise<void>;
+}
+/** A todo's words, place or files changed: new ones added, some of the old kept. */
+export interface TodoChange {
+    /** A new line; the old one stays when this is absent. */
+    subject?: string;
+    /** New detail, empty for none; the old stays when this is absent. */
+    text?: string;
+    /** Where to move it in the list; it stays put when this is absent. */
+    position?: number;
+    /** Files to add. */
+    files?: Attachment[];
+    /** The paths of the files it has now to keep; absent keeps them all. */
+    keep?: string[];
+    /** Every todo blocking it from now on; the old stay when this is absent. */
+    blockedBy?: number[];
+    /** The lane it runs in, `"new"` for one of its own, null for none; it stays when absent. */
+    lane?: number | "new" | null;
+    /** The agent that should work it, null for none; it stays when absent. */
+    assignee?: AgentPick | null;
+}
+/**
+ * Where a todo came up, as a list shows it: its task here, or for one added
+ * from another project, `<project>/<task>`, the project by its directory's
+ * name; null for one a person added from the main tree.
+ */
+export declare function cameFrom({ from, origin }: TodoState): string | null;
+/** The other project a todo was added from, and the task there it came up in. */
+export interface TodoOrigin {
+    /** That project's main tree. */
+    project: string;
+    /** Its task the todo came up in, or null for its main tree. */
+    task: string | null;
+}
+/** What a new todo has besides its subject, all of it optional. */
+export interface TodoNew {
+    /** Whatever more there is to say about it. */
+    text?: string;
+    files?: Attachment[];
+    /** Where it goes in the list, pushing those from there down; the bottom by default. */
+    position?: number;
+    /** The todos blocking it: each has to merge before it starts. */
+    blockedBy?: number[];
+    /** The lane it goes in, `"new"` for one of its own; none by default. */
+    lane?: number | "new" | null;
+    /** The agent that should work it; none by default. */
+    assignee?: AgentPick | null;
+    /** The other project it is added from; none by default. */
+    origin?: TodoOrigin;
+}
+/** `state` worked by `assignee`, or by nobody in particular for null. */
+export declare function assigned<State extends {
+    assignee?: AgentPick;
+}>(state: State, assignee: AgentPick | null | undefined): State;
+/**
+ * A subject and its detail, trimmed. A subject running past one line keeps
+ * only the first, the rest leading the detail, so the list stays one line a
+ * todo however it was written.
+ */
+export declare function wording(subject: string, text: string): {
+    subject: string;
+    text: string;
+};
+/**
+ * Runs `update`, which changes todo `id`, and journals it with what moved
+ * between the todo before and after, so a refused one is journaled bare.
+ */
+export declare function recordUpdate(journal: Journal, todos: Todos, id: number, update: () => Promise<Todo>): Promise<Todo>;
+/** `todos` as an event names them: each by its id and subject. */
+export declare function todosNamed(todos: readonly Todo[]): {
+    id: number;
+    subject: string;
+}[];

package/todos.d.ts

@@ -0,0 +1,157 @@
+import { type IdProvider } from "webappwiz/id";
+import { type Fs, type Lock } from "webappwiz/system";
+import { Attachments } from "./attachments.js";
+import { type LaneRecord } from "./lanes.js";
+import { Todo, type TodoNew, type TodoState } from "./todo.js";
+/** Every todo in the repo, one JSON file each under `.git/splates/todos`. */
+export declare class Todos {
+    readonly dir: string;
+    /**
+     * Held while numbering a new todo, so two agents never share an id, and
+     * while writing one, so a move renumbering the rest never loses to a
+     * write of a position it just changed.
+     */
+    private readonly lock;
+    private readonly fs;
+    private readonly ids;
+    private readonly laneFiles;
+    constructor(dir: string, 
+    /**
+     * Held while numbering a new todo, so two agents never share an id, and
+     * while writing one, so a move renumbering the rest never loses to a
+     * write of a position it just changed.
+     */
+    lock: Lock, opts?: TodosOptions);
+    /** Where a todo's files live, beside its record. */
+    attachments(id: number): Attachments;
+    /** Whether `path` is a file some todo holds, and not a way out of here. */
+    owns(path: string): boolean;
+    add(subject: string, from: string | null, { text, files, position, blockedBy, lane, assignee, origin, }?: TodoNew): Promise<Todo>;
+    /**
+     * Top of the list first. A file that will not parse is skipped rather than
+     * fatal, and positions are counted again from 1 as they are read, so a
+     * gap or a tie left by a crash, or a todo saved before they had any (it
+     * goes below those that do, oldest first), never shows.
+     */
+    all(): Promise<Todo[]>;
+    find(id: number): Promise<Todo>;
+    /** The todos `task` has taken; what a merge or remove settles. */
+    takenBy(task: string): Promise<Todo[]>;
+    /**
+     * Puts a todo at `position`, 1 at the top, past the bottom meaning the
+     * bottom, and numbers the rest around it. Refuses to put one above a todo
+     * in its own lane that it comes after, or below one that comes after it.
+     */
+    move(id: number, position: number): Promise<Todo>;
+    /**
+     * Says `id` comes after the todos in `add`, and no longer after those in
+     * `drop`: it is not to be started until they merge. Refuses a link that
+     * would make a loop, naming the todos in it, and moves a todo down below
+     * anything in its own lane it now comes after.
+     */
+    link(id: number, { add, drop }: {
+        add?: number[];
+        drop?: number[];
+    }): Promise<Todo>;
+    /**
+     * Puts a todo in a lane, or in none for null. `"new"` starts a lane of its
+     * own, called `name`, or after the todo without one. With `before`, it goes just above that todo; otherwise it goes
+     * below the rest of the lane, or keeps its place when that is in none or
+     * new. Refuses a place above a todo in the lane that it comes after, or
+     * below one that comes after it.
+     */
+    arrange(id: number, lane: number | "new" | null, { before, name }?: {
+        before?: number;
+        name?: string;
+    }): Promise<Todo>;
+    /** Every lane, in board order. */
+    lanes(): Promise<LaneRecord[]>;
+    /** The name of every lane there has been, those on the board first. */
+    laneNames(): Promise<LaneRecord[]>;
+    /** Moves every todo in lane `from` to the bottom of lane `into`; `from` is gone. */
+    joinLanes(from: number, into: number): Promise<void>;
+    /** Starts an empty lane called `name`, after the others. */
+    addLane(name: string): Promise<LaneRecord>;
+    /** Calls lane `id` by another name. */
+    renameLane(id: number, name: string): Promise<LaneRecord>;
+    /** Puts lane `id` at `position` among the lanes, 1 the first column. */
+    moveLane(id: number, position: number): Promise<LaneRecord[]>;
+    /** Removes lane `id`, putting its todos back in none, untriaged. */
+    dropLane(id: number): Promise<void>;
+    /** @internal Removes each lane in `ids` that no todo is in any more. */
+    endLanes(ids: number[]): Promise<void>;
+    /** Moves todos saved while splates kept tags into lanes, one lane a tag. */
+    moveTagsToLanes(): Promise<{
+        lane: LaneRecord;
+        todos: number[];
+    }[]>;
+    /**
+     * @internal Rewrites one todo as it stands on disk now, under the lock, so
+     * a change to its words or who has it never undoes a move made meanwhile.
+     */
+    revise(id: number, change: (state: TodoState) => TodoState): Promise<Todo>;
+    /** @internal Writes one todo. Rename makes the swap atomic for readers. */
+    save(state: TodoState): Promise<Todo>;
+    /**
+     * @internal Removes one, moving those below it up to close the gap. What
+     * came after it no longer waits on it, so no todo is left naming one that
+     * is gone.
+     */
+    delete(id: number): Promise<void>;
+    /**
+     * @internal Removes one as `delete` does, keeping it and its files under
+     * `removed/` for `restore` to put back. Only the newest `REMOVED_KEPT` are
+     * kept, the older going for good.
+     */
+    discard(state: TodoState): Promise<void>;
+    /**
+     * Puts a todo `discard` removed back under its id, where it stood in the
+     * list, untaken: in its lane while that lane is still on the board, after
+     * those it waited on that still are.
+     */
+    restore(id: number): Promise<Todo>;
+    /** @internal Runs `run` holding the lock every write goes through. */
+    locked<T>(run: () => Promise<T>): Promise<T>;
+    /**
+     * Settles the list after a link or a lane changed, moving each todo below
+     * what it comes after in its lane, and gives back `id` as it ends up.
+     * Call it under the lock.
+     */
+    private settled;
+    /** Refuses `order` when a lane in it puts a todo above one it comes after. */
+    private ordered;
+    /** One todo as it stands on disk; call it under the lock. */
+    private state;
+    /**
+     * Slots `state` in at `position` among the rest and saves whichever moved.
+     * Call it under the lock.
+     */
+    private place;
+    /**
+     * @internal Every todo in list order, with the positions it has on disk. `tagged`
+     * are read though they still have tags, to move them into lanes.
+     */
+    stored(tagged?: number[]): Promise<TodoState[]>;
+    /** @internal Saves each todo in `order` whose position on disk is not its place there. */
+    renumber(order: TodoState[]): Promise<void>;
+    private get removedDir();
+    private removedPath;
+    /** The todos `discard` kept, the oldest removed first. */
+    private removed;
+    private path;
+    private lastId;
+    /**
+     * One todo, or null when it will not parse. One saved with tags is
+     * refused, unless it is one of `tagged`: dropping them unasked would lose
+     * what they grouped.
+     */
+    private read;
+}
+/** How many removed todos `Todos.discard` keeps for `restore`. */
+export declare const REMOVED_KEPT = 50;
+/** What `Todos` is stored through; the real filesystem by default. */
+export interface TodosOptions {
+    fs?: Fs;
+    /** What names stored files apart; random ids by default. */
+    ids?: IdProvider;
+}

package/tool-calls.d.ts

@@ -0,0 +1,18 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import type { ConversationState, Tool } from "./conversation-state.js";
+/** How much of a tool call's output, and of each side of an edit, is kept. */
+export declare const TOOL_CHARS = 20000;
+/**
+ * Takes what an update says of a tool call into it. Adapters say it in
+ * different places: Claude sends a command's output whole as `rawOutput`
+ * once it ends, Codex streams it in `_meta` and says how it exited there.
+ */
+export declare function fill(tool: Tool, update: acp.ToolCall | acp.ToolCallUpdate, at: string | null): void;
+/** The tool call `id`, wherever in the conversation it was made. */
+export declare function toolIn(state: ConversationState, id: string): Tool | null;
+/** The subagent's tool call an update came from; null for the agent's own. */
+export declare function parentOf(update: {
+    _meta?: {
+        [key: string]: unknown;
+    } | null;
+}): string | null;

package/tunnel-provider.d.ts

@@ -0,0 +1,37 @@
+import type { AsyncResource } from "webappwiz/disposable";
+import type { Logger } from "webappwiz/log";
+/** What a provider is asked to publish. */
+export interface TunnelRoute {
+    /** The public host name that must reach `url`. */
+    host: string;
+    /** The page on this machine, `http://localhost:<port>`. */
+    url: string;
+    /** Where the provider says what it is doing, such as where it is reachable. */
+    log: Logger;
+}
+/**
+ * TunnelProvider is the seam onto whatever puts the `splates server` page on a
+ * public host name: `cloudflared` by default, or any tunnel a repo's
+ * `splates.config.ts` names as `tunnel`:
+ *
+ * ```ts
+ * export default { tunnel: new MyTunnel() } satisfies ConfigFile;
+ * ```
+ *
+ * Whatever it is, `--tunnel` still refuses to run without Cloudflare Access in
+ * front, which is what decides who may enter; a provider only carries traffic.
+ */
+export interface TunnelProvider {
+    /**
+     * Throws unless whatever runs the tunnel is installed and signed in, with a
+     * message saying what to do about it. Asked before `run`, which is skipped
+     * when it throws: the page keeps serving on this machine.
+     */
+    ready(): Promise<void>;
+    /**
+     * Starts carrying `route.host` to `route.url`, and answers with the run,
+     * which serves until it is disposed of. Disposing stops the tunnel and
+     * returns once it is gone; disposing one that stopped on its own is silent.
+     */
+    run(route: TunnelRoute): AsyncResource;
+}

package/tunnel-remove.d.ts

@@ -0,0 +1,28 @@
+import { type Logger } from "webappwiz/log";
+import type { Fs } from "webappwiz/system";
+import type { Creds } from "./creds.js";
+import { type SavedTunnel } from "./saved-tunnel.js";
+/** What `splates tunnel remove` is asked to remove, and what it runs with. */
+export interface RemoveOptions {
+    /** The tunnel `splates tunnel setup` saved for this machine. */
+    saved: SavedTunnel;
+    /** Each slot home's tunnel, in the pool's order, whether or not it has one. */
+    slots: SavedTunnel[];
+    /** Where the API token is read from, and the tunnels' tokens forgotten. */
+    creds: Creds;
+    /** The task asking, for the request to name; null outside any. */
+    task: string | null;
+    fs: Fs;
+    log: Logger;
+    fetch?: typeof fetch;
+}
+/**
+ * Deletes what `splates tunnel setup` and `splates server --slot` made, by what they
+ * saved: each tunnel and the DNS record routing to it, the Access application
+ * in front of the machine's host and the one in front of every slot, and the
+ * policy they share. Then forgets each saved file and the tunnel token kept
+ * for it. What is already gone is passed over, and a file is forgotten only
+ * once its tunnel is, so running it again after a failure finishes the job.
+ * The Cloudflare API token is kept, for `splates tunnel setup` to use again.
+ */
+export declare function tunnelRemove(opts: RemoveOptions): Promise<void>;

package/tunnel-setup.d.ts

@@ -0,0 +1,104 @@
+import { type Logger } from "webappwiz/log";
+import { z } from "zod";
+import { CloudflareApi } from "./cloudflare-api.js";
+import type { Creds } from "./creds.js";
+import { type SavedTunnel } from "./saved-tunnel.js";
+/** What `splates tunnel setup` is asked to make, and what it runs with. */
+export interface SetupOptions {
+    /** The public host name, in a zone of the account. */
+    host: string;
+    /** Who Access lets in, comma separated. */
+    email: string;
+    /** What the tunnel, the Access application and its policy are called. */
+    name: string;
+    /**
+     * The Zero Trust team to make, as in `<team>.cloudflareaccess.com`, when
+     * the account has none yet; "" to use the one it has.
+     */
+    team: string;
+    /** Where the API token is read from, or requested, and the tunnel's token saved. */
+    creds: Creds;
+    /** The task asking, for the request to name; null outside any. */
+    task: string | null;
+    /** Where what it made is saved for `splates server`. */
+    saved: SavedTunnel;
+    log: Logger;
+    fetch?: typeof fetch;
+}
+/**
+ * Makes everything that carries `host` to `splates server` behind Cloudflare
+ * Access, through the API alone, with the API token the person pasted as
+ * `API_TOKEN`: the Zero Trust organization when the account has none, a
+ * tunnel and its token, the DNS record routing `host` to it, and an Access
+ * application letting in only `email`. What already exists by name is
+ * reused, and changed only where it differs, so running it again is safe,
+ * like `splates init`. Saves what it made, so a bare `splates server` runs it.
+ *
+ * Without the API token, it requests one with instructions for making it,
+ * and refuses with `requested`, to run again once it is saved.
+ */
+export declare function tunnelSetup(opts: SetupOptions): Promise<void>;
+/**
+ * The cred the Cloudflare API token is kept as, on the device, since the
+ * account is the person's. Not `CLOUDFLARE_API_TOKEN`, which scry's Workers
+ * AI token goes by in the same store.
+ */
+export declare const API_TOKEN = "SPLATES_CLOUDFLARE_API_TOKEN";
+/** What the API token has to be allowed, as the dashboard names each. */
+export declare const TOKEN_PERMISSIONS: string[];
+/** Where an API token is made. */
+export declare const TOKENS_PAGE = "https://dash.cloudflare.com/profile/api-tokens";
+declare const Zone: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    account: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const Tunnel: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const App: z.ZodObject<{
+    id: z.ZodString;
+    domain: z.ZodOptional<z.ZodString>;
+    aud: z.ZodString;
+    policies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * The Cloudflare account `splates tunnel` works in, through the API with the
+ * token kept as `API_TOKEN`, reporting what it makes to `log`.
+ */
+export declare class CloudflareTunnels {
+    readonly api: CloudflareApi;
+    private readonly log;
+    private constructor();
+    /**
+     * Opens the account with the token kept as `API_TOKEN`. Without it,
+     * requests it with instructions for making it, and refuses with
+     * `requested`, to run again once it is saved.
+     */
+    static open(creds: Creds, host: string, task: string | null, log: Logger, fetch?: typeof globalThis.fetch): Promise<CloudflareTunnels>;
+    /** The zone serving `host`: the longest of its suffixes the account has. */
+    findZone(host: string): Promise<z.infer<typeof Zone>>;
+    /**
+     * The tunnel called `name`, made when there is none. Configured locally, so
+     * `cloudflared` carries the host to whichever port `splates server` bound, which
+     * its `--url` says, rather than to one the dashboard pins.
+     */
+    ensureTunnel(account: string, name: string): Promise<z.infer<typeof Tunnel>>;
+    /**
+     * The proxied CNAME routing `host` to the tunnel. One already pointing at
+     * another tunnel is moved to this one; any other record for `host` is someone
+     * else's, and refused rather than replaced.
+     */
+    ensureRoute(zone: string, host: string, tunnel: string): Promise<void>;
+    /**
+     * The self-hosted Access application in front of `host`, guarded by
+     * `policy` alone, and its AUD tag, which Cloudflare assigns when it is made.
+     */
+    ensureApp(account: string, name: string, host: string, policy: string): Promise<string>;
+}
+export {};

package/unix-worker-listener.d.ts

@@ -0,0 +1,23 @@
+import type { AsyncResource } from "webappwiz/disposable";
+import { type Eventful } from "webappwiz/events";
+import type { Fs } from "webappwiz/system";
+import { UnixWorkerSocket } from "./unix-worker-socket.js";
+/** What a `UnixWorkerListener` hears: a worker dialed in. */
+export interface UnixWorkerListenerEvents extends Record<string, unknown> {
+    socket: UnixWorkerSocket;
+}
+/**
+ * Where the local worker dials its coordinator: a Unix socket only this
+ * user may open. Listening takes the path over from a coordinator that died
+ * without cleaning up, and refuses one still answering there.
+ */
+export declare class UnixWorkerListener implements Eventful<UnixWorkerListenerEvents>, AsyncResource {
+    readonly path: string;
+    private readonly listener;
+    private readonly fs;
+    private readonly dispatcher;
+    readonly events: import("webappwiz/events").Events<UnixWorkerListenerEvents>;
+    private constructor();
+    static listen(path: string, fs: Fs): Promise<UnixWorkerListener>;
+    disposeAsync(): Promise<void>;
+}