@stringsync/splates 0.0.45 → 0.0.47

package/todos.d.ts

@@ -1,157 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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>;
-}

package/unix-worker-socket.d.ts

@@ -1,30 +0,0 @@
-import type { WorkerSocket, WorkerSocketEvents } from "./worker-socket.js";
-/** Bun's socket, whose handlers hand each event to the `UnixWorkerSocket` it carries. */
-export type UnixSocket = Bun.Socket<UnixWorkerSocket>;
-/** The handlers `Bun.listen` and `Bun.connect` take, the same at both ends. */
-export declare const UNIX_HANDLERS: Bun.SocketHandler<UnixWorkerSocket>;
-/**
- * A `WorkerSocket` over a Unix socket, how the local worker speaks to the
- * coordinator on its machine. Dial one with `connect`; a `UnixWorkerListener`
- * hands over the other end.
- */
-export declare class UnixWorkerSocket implements WorkerSocket {
-    private readonly dispatcher;
-    readonly events: import("webappwiz/events").Events<WorkerSocketEvents>;
-    private socket;
-    private pending;
-    /** What the kernel would not take yet, sent on the next drain. */
-    private unsent;
-    private open;
-    /** Dials the coordinator listening at `path`. */
-    static connect(path: string): Promise<UnixWorkerSocket>;
-    /** Takes the Bun socket it speaks over, as a listener or `connect` hands it. */
-    attach(socket: UnixSocket): void;
-    send(frame: string | Uint8Array): void;
-    dispose(): void;
-    /** Bun's `data` handler calls this with each chunk it read. */
-    received(chunk: Uint8Array): void;
-    /** Sends what the kernel has room for now. */
-    flush(): void;
-    closed(): void;
-}

package/update.d.ts

@@ -1,29 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import type { Fs, Ps } from "webappwiz/system";
-/**
- * Set in the environment of the splates `update` hands itself to, so that one
- * refreshes rather than looking for a newer one again: npm can name a version
- * a moment before `bunx` can fetch it.
- */
-export declare const UPDATING = "SPLATES_UPDATING";
-/**
- * Brings this repository up to the newest splates: when npm has a newer release
- * than the one running, runs `update` again on that one, which does the rest
- * itself; otherwise moves todos saved with tags into lanes, installs this
- * one's skill over whatever copy is there, through `bunx skills add` from
- * this release's tag, and moves what an older config holds to where this
- * one reads it. Offline, the running release is the newest there is to
- * have. `wiz update` names the release instead, as it pins every webappwiz
- * package to one. Answers with the exit code to end on.
- */
-export declare function update({ root, fs, ps, log, newest, release, }: {
-    /** The repository's main tree. */
-    root: string;
-    fs: Fs;
-    ps: Ps;
-    log: Logger;
-    /** The latest splates on npm, or null when it cannot say; unasked given `release`. */
-    newest?: () => Promise<string | null>;
-    /** The release whose skill to install, rather than the newest. */
-    release?: string;
-}): Promise<number>;

package/update.js

@@ -1,10 +0,0 @@
-import {
-  UPDATING2,
-  update2
-} from "./index-vcv9m93e.js";
-import"./index-4776671w.js";
-import"./index-k73tsw5g.js";
-export {
-  UPDATING2 as UPDATING,
-  update2 as update
-};

package/vocabulary.d.ts

@@ -1,9 +0,0 @@
-import type { System } from "./systems.js";
-/**
- * Every word a prompt to an agent in `project` may use that a speech model
- * would spell its own way: splates, the project's name, and each system's name
- * and aliases.
- */
-export declare function words(project: string, systems: Record<string, System>): string[];
-/** The prompt that gets the project's own words spelled its way. */
-export declare function vocabulary(project: string, systems: Record<string, System>): string;

package/wait.d.ts

@@ -1,36 +0,0 @@
-import { type Logger } from "webappwiz/log";
-import { Duration } from "webappwiz/time";
-import type { Todos } from "./todos.js";
-import type { WorktreeService } from "./worktree-service.js";
-/** How long `wait` gives a task before handing the wait back to its caller. */
-export declare const DEFAULT_TIMEOUT: Duration;
-/** When a wait begun now gives up after `timeout`, as an ISO time. */
-export declare function untilAfter(timeout: Duration): string;
-export interface WaitOptions {
-    /** How long to wait before giving up. */
-    timeout?: Duration;
-    /** How long between reads of the record; the default suits a human's patience. */
-    poll?: Duration;
-}
-/**
- * Blocks until a task stops moving: merged or removed (both leave the name
- * `removed`), escalated to a human, or broken. Waiting is for the agent whose
- * own work overlaps this one's and would rather rebase onto the result than
- * against it, which is why the timeout is short enough to come back and think
- * again rather than block a session for an afternoon.
- */
-export declare function wait({ service, log }: {
-    service: WorktreeService;
-    log: Logger;
-}, task: string, { timeout, poll }?: WaitOptions): Promise<void>;
-/**
- * Blocks until todo `id` leaves the list, which it does when the task that
- * took it merges (or it is removed): what an agent whose next todo comes
- * after it waits for, not knowing which task will take it. Ends early when
- * the task that has it is escalated, since that wait is on a person.
- */
-export declare function todoWait({ service, todos, log, }: {
-    service: WorktreeService;
-    todos: Todos;
-    log: Logger;
-}, id: number, { timeout, poll }?: WaitOptions): Promise<void>;

package/watch.d.ts

@@ -1,46 +0,0 @@
-import type { Git } from "./git.js";
-import { Watched } from "./watched.js";
-/** The git `Watch` runs, on whichever machine the agent works: `Git` here, or a worker's. */
-export type WatchGit = Pick<Git, "root" | "run" | "interruptedOps">;
-/**
- * Something a command did to git that an agent should not have, judged by
- * what it did rather than what it said: one that stashes and pops again, or
- * commits and squashes, did nothing worth a flag.
- */
-export type Flag = 
-/** Stashed `count` changes and left them there. */
-{
-    type: "stashed";
-    count: number;
-}
-/** Took commits off `branch` that its tree no longer holds. */
- | {
-    type: "dropped";
-    branch: string;
-}
-/** Checked out `now`, a branch or null for a detached HEAD, off `branch`. */
- | {
-    type: "left";
-    branch: string;
-    now: string | null;
-}
-/** Pushed, updating these remote branches, in a command that says `push`. */
- | {
-    type: "pushed";
-    refs: string[];
-}
-/** Changed these files in the main tree, from a task's worktree. */
- | {
-    type: "outside";
-    paths: string[];
-};
-/**
- * Watches the commands agents run in one repository, `git.root` its main
- * tree, for what they did to git.
- */
-export declare class Watch {
-    private readonly git;
-    constructor(git: WatchGit);
-    /** Starts watching a command run in `cwd`, looking at git as it stands. */
-    command(cwd: string): Watched;
-}

package/watched.d.ts

@@ -1,43 +0,0 @@
-import type { Flag, WatchGit } from "./watch.js";
-/** A command being watched, from the look before it ran. */
-export declare class Watched {
-    private readonly git;
-    private readonly cwd;
-    private readonly before;
-    constructor(git: WatchGit, cwd: string, before: Promise<Look>);
-    /** Starts watching a command run in `cwd`, looking at git as it stands. */
-    static start(git: WatchGit, cwd: string): Watched;
-    /** Settles once the look before the command is taken. */
-    looked(): Promise<void>;
-    /**
-     * Looks at git again, now that `command` is over, and says what it did.
-     * A push counts only in a command that says `push`.
-     */
-    done(command: string | null): Promise<Flag[]>;
-    /**
-     * Whether `branch` lost what it held at `tip`: merging that commit into
-     * what the branch is now changes nothing in its commit or its tree, as it
-     * would not after a squash or a rebase onto trunk.
-     */
-    private dropped;
-    /** A rebase detaches HEAD until it is done, as `splates merge` leaves one. */
-    private rebasing;
-    /** The remote branches a push moved, as their reflogs say. */
-    private pushed;
-}
-/** What git looked like around a command. */
-interface Look {
-    /** The stash's entries, by commit. */
-    stash: string[];
-    /** The branch HEAD is on in the command's tree, null when detached. */
-    branch: string | null;
-    /** That branch's commit; null when detached or the tree is gone. */
-    tip: string | null;
-    /** Whether the tree is gone, as a merged task's is. */
-    gone: boolean;
-    /** Every remote branch but a symbolic one like `origin/HEAD`, with its commit. */
-    remotes: Map<string, string>;
-    /** The main tree's uncommitted paths; null for a command run in it. */
-    dirty: Set<string> | null;
-}
-export {};

package/websocket-worker-socket.d.ts

@@ -1,18 +0,0 @@
-import type { WorkerSocket, WorkerSocketEvents } from "./worker-socket.js";
-/**
- * A `WorkerSocket` over a WebSocket the worker dials, as a remote worker
- * reaches its coordinator's `/api/workers`: each frame is one message, text
- * or binary as the protocol has it.
- */
-export declare class WebSocketWorkerSocket implements WorkerSocket {
-    private readonly socket;
-    private readonly dispatcher;
-    readonly events: import("webappwiz/events").Events<WorkerSocketEvents>;
-    private open;
-    private constructor();
-    /** Dials `url`, settling once the socket is open. */
-    static connect(url: string): Promise<WebSocketWorkerSocket>;
-    send(frame: string | Uint8Array): void;
-    dispose(): void;
-    private closed;
-}

package/worker-call-host.d.ts

@@ -1,51 +0,0 @@
-import type { Resource } from "webappwiz/disposable";
-import { z } from "zod";
-import type { WorkerChannel } from "./worker-channel.js";
-import type { WorkerMachine } from "./worker-machine.js";
-/** A question a coordinator asks on a `calls` channel, answered by its id. */
-export declare const CallRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    id: z.ZodNumber;
-    method: z.ZodLiteral<"git">;
-    cwd: z.ZodString;
-    args: z.ZodArray<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodNumber;
-    method: z.ZodLiteral<"processes">;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodNumber;
-    method: z.ZodLiteral<"listening">;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodNumber;
-    method: z.ZodLiteral<"exists">;
-    path: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodNumber;
-    method: z.ZodLiteral<"read">;
-    path: z.ZodString;
-    from: z.ZodNumber;
-}, z.core.$strip>], "method">;
-export type CallRequest = z.infer<typeof CallRequest>;
-/** How a worker answers: `{ id, result }`, or `{ id, error }` saying what went wrong. */
-export declare const CallAnswer: z.ZodUnion<readonly [z.ZodObject<{
-    id: z.ZodNumber;
-    result: z.ZodUnknown;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodNumber;
-    error: z.ZodString;
-}, z.core.$strip>]>;
-/**
- * Answers a coordinator's calls on the machine a task runs on, each request
- * a message on a `calls` channel and each answer one back, in whatever order
- * they finish. A read's bytes go as base64.
- */
-export declare class WorkerCallHost implements Resource {
-    private readonly channel;
-    private readonly machine;
-    private readonly unlisten;
-    constructor(channel: WorkerChannel, machine: WorkerMachine);
-    /** Stops answering, leaving the channel to whoever closes it. */
-    dispose(): void;
-    private answer;
-    private call;
-    private reply;
-}