@stringsync/splates 0.0.0-stage → 0.0.45

package/port-forward.d.ts

@@ -0,0 +1,22 @@
+import type { Resource } from "webappwiz/disposable";
+import type { RemoteWorker } from "./remote-worker.js";
+/**
+ * A loopback port on the coordinator standing in for `port` on a worker:
+ * each connection made to it goes down the worker's socket as a `port`
+ * channel, so a task's dev server opens here wherever its worker runs.
+ */
+export declare class PortForward implements Resource {
+    readonly worker: RemoteWorker;
+    /** The worker's port, which this forwards to. */
+    readonly port: number;
+    private readonly listener;
+    private constructor();
+    /**
+     * Listens on `prefer` when it is free, so the task's port keeps its
+     * number here, and on any free port when not.
+     */
+    static listen(worker: RemoteWorker, port: number, prefer?: number | null): PortForward;
+    /** The coordinator's port it listens on. */
+    get local(): number;
+    dispose(): void;
+}

package/port-pipe.d.ts

@@ -0,0 +1,36 @@
+import type { Resource } from "webappwiz/disposable";
+import type { WorkerChannel } from "./worker-channel.js";
+import type { WorkerSession } from "./worker-session.js";
+/**
+ * Bun's TCP socket, whose handlers hand each event to the `PortPipe` it
+ * carries: none yet on one a listener just took in, until its `open` makes one.
+ */
+export type PipedSocket = Bun.Socket<PortPipe | undefined>;
+/** The handlers `Bun.connect` and `Bun.listen` take for a piped socket. */
+export declare const PIPE_HANDLERS: Bun.SocketHandler<PortPipe | undefined>;
+/**
+ * One TCP connection carried over a `port` channel, the same at both ends: at
+ * the worker, to the task's port; at the coordinator, from whoever opened its
+ * forward. Bytes go both ways as the channel's data, the socket stops reading
+ * while the session is full, and either end closing closes the other.
+ */
+export declare class PortPipe implements Resource {
+    private readonly channel;
+    private readonly session;
+    private socket;
+    /** What the kernel would not take yet, sent on the next drain. */
+    private unsent;
+    /** The channel closed, so the socket ends once `unsent` is out. */
+    private ending;
+    private done;
+    constructor(channel: WorkerChannel, session: WorkerSession);
+    /** Takes the socket it pipes, once it is open. */
+    attach(socket: PipedSocket): void;
+    /** Bun's `data` handler calls this with each chunk it read. */
+    received(chunk: Uint8Array): void;
+    /** Sends what the kernel has room for now, and ends once all is out. */
+    flush(): void;
+    /** The socket closed, from either end: so does the channel. */
+    closed(): void;
+    dispose(): void;
+}

package/ports-list.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from "webappwiz/log";
+import type { Ps } from "webappwiz/system";
+/** What `splates ports` is run with. */
+export interface PortsOptions {
+    /** Only this task's; empty for every task's. */
+    task: string;
+    /** The `splates server` to ask; empty for the one this agent runs under, or this machine's. */
+    dev: string;
+    json: boolean;
+    log: Logger;
+    ps: Ps;
+    send?: typeof fetch;
+}
+/**
+ * `splates ports`: asks the running `splates server` which ports tasks serve, each
+ * with its link through the saved ports host and its link on this machine,
+ * so an agent can hand the user both.
+ */
+export declare function portsLs(opts: PortsOptions): Promise<void>;

package/probe-runtime.d.ts

@@ -0,0 +1,5 @@
+/** Execution primitives shared with the focused skill eval runner. */
+export type { Agent, AgentProcess, Launch } from "./agent-process.js";
+export { framed } from "./agent-process.js";
+export { AgentStream } from "./agent-stream.js";
+export { Roster } from "./roster.js";

package/probe-runtime.js

@@ -0,0 +1,13 @@
+import {
+  AgentStream2,
+  framed2
+} from "./index-d4hjrzaq.js";
+import"./index-k73tsw5g.js";
+import {
+  Roster2
+} from "./index-43pq33n4.js";
+export {
+  AgentStream2 as AgentStream,
+  Roster2 as Roster,
+  framed2 as framed
+};

package/project-reaches.d.ts

@@ -0,0 +1,23 @@
+import type { Logger } from "webappwiz/log";
+import type { Git } from "./git.js";
+import type { Projects, Reach } from "./projects.js";
+/**
+ * `splates projects list`: each other project, with what it may do in the one
+ * `git` is in, and what that one may do there.
+ */
+export declare function listReaches({ projects, git, log }: {
+    projects: Projects;
+    git: Git;
+    log: Logger;
+}, { json }?: {
+    json?: boolean;
+}): Promise<void>;
+/**
+ * `splates projects grant`: lets agents of the project `slug` names do as much
+ * as `reach` in the one `git` is in.
+ */
+export declare function grantReach({ projects, git, log }: {
+    projects: Projects;
+    git: Git;
+    log: Logger;
+}, slug: string, reach: Reach): Promise<void>;

package/projects.d.ts

@@ -0,0 +1,136 @@
+import type { Logger } from "webappwiz/log";
+import { type Fs, type Lock, type Ps } from "webappwiz/system";
+/** A repository splates has run in, as the registry keeps it. */
+export interface ProjectRecord {
+    /** The main tree's root, never a task's worktree. */
+    root: string;
+    /** When splates first ran there, as an ISO timestamp. */
+    added: string;
+    /**
+     * What each other project may do here, by its root, those left out
+     * `DEFAULT_REACH`.
+     */
+    grants?: Record<string, Reach>;
+}
+/** A registered repository, as the registry reads it back. */
+export interface Project extends ProjectRecord {
+    /**
+     * What a URL names it by: the root's last part, `webappwiz`, with `-2`
+     * and on for a second of the same name, in the order they joined.
+     */
+    slug: string;
+    /** The repository is no longer there: moved or deleted since. */
+    gone: boolean;
+}
+/** What `Projects` works with. */
+export interface ProjectsOptions {
+    fs: Fs;
+    /** Held while the file is rewritten, so two commands never drop each other's. */
+    lock: Lock;
+    /** The current time; a test passes its own. */
+    now?: () => Date;
+}
+/**
+ * Every splates project on this machine, kept in one file under the user's
+ * home: an explicit roster that `splates init` writes each into, so one
+ * `splates server` can find them all without scanning the disk.
+ */
+export declare class Projects {
+    /** `~/.splates/projects.json`, or a test's own. */
+    readonly path: string;
+    private readonly fs;
+    private readonly lock;
+    private readonly now;
+    /**
+     * This machine's registry, in `SPLATES_HOME`, `~/.splates` for none, with a
+     * lock that counts as stale after `stalenessMs`.
+     */
+    static ofMachine({ fs, ps, log }: {
+        fs: Fs;
+        ps: Ps;
+        log: Logger;
+    }, stalenessMs?: number): Projects;
+    constructor(
+    /** `~/.splates/projects.json`, or a test's own. */
+    path: string, { fs, lock, now }: ProjectsOptions);
+    /**
+     * Adds the repository at `root`, once, saying whether it did: registering
+     * it again changes nothing.
+     */
+    register(root: string): Promise<boolean>;
+    /**
+     * Makes the registered repository at `root` the one an address naming
+     * none shows, as picking it on the page does, saying whether it is
+     * registered.
+     */
+    focus(root: string): Promise<boolean>;
+    /**
+     * The project an address naming none shows: the one focused last, else
+     * the one focused before it, and so on, else the first registered,
+     * skipping those gone; null while there is none.
+     */
+    focused(): Promise<Project | null>;
+    /**
+     * Every registered project, in the order splates first ran in each, those
+     * whose repository is gone flagged rather than dropped: one on a drive
+     * that is not mounted comes back.
+     */
+    list(): Promise<Project[]>;
+    /**
+     * What the project at `from` may do in the one at `to`: what `to` granted
+     * it, else `DEFAULT_REACH`.
+     */
+    reach(from: string, to: string): Promise<Reach>;
+    /**
+     * Lets the project at `from` do as much as `reach` in the registered one
+     * at `to`, saying whether `to` is registered.
+     */
+    grant(to: string, from: string, reach: Reach): Promise<boolean>;
+    /**
+     * The registered project a command names as `slug`, refusing one that is
+     * not there.
+     */
+    named(slug: string): Promise<Project>;
+    /**
+     * Drops the repository at `root`, saying whether it was there: one gone
+     * for good, or one `splates server` should no longer offer.
+     */
+    forget(root: string): Promise<boolean>;
+    /**
+     * Rewrites the file as `edit` says, under the lock, saying whether it
+     * did: `edit` returns null to leave it as it is.
+     */
+    private change;
+    private get dir();
+    private read;
+    private write;
+}
+/**
+ * What an agent working in one project may do in another through splates,
+ * each including those before it: read its tasks, todos, lanes and systems;
+ * add todos to its untriaged lane; or hand its tasks to agents and
+ * orchestrate them. Grants stop splates commands, not file edits.
+ */
+export declare const REACHES: readonly ["read", "todos", "tasks"];
+export type Reach = (typeof REACHES)[number];
+/** What a project lets another do that it has granted nothing. */
+export declare const DEFAULT_REACH: Reach;
+/** Whether `granted` covers what `needed` asks for. */
+export declare function reaches(granted: Reach, needed: Reach): boolean;
+/**
+ * One line telling an agent where a project a prompt names as `#slug` sits,
+ * and how to change it:
+ *
+ * ```
+ * #shop is the splates project at /Users/me/shop: read its code there, and land any change to it from a task added there.
+ * ```
+ */
+export declare function projectLine({ slug, root, reach, }: {
+    slug: string;
+    root: string;
+    /**
+     * What the project the prompt is in may do there; null when it is that
+     * project, or in none.
+     */
+    reach: Reach | null;
+}): string;

package/prompts.d.ts

@@ -0,0 +1,128 @@
+import type { AgentPick } from "./roster.js";
+/** What a chat with an agent takes to mean todo `id`. */
+export declare function todoReference(id: number): string;
+/**
+ * What the untriaged lane, the todos in no lane, goes by where a lane's
+ * number would: `[SPLATES LANE untriaged]`, `splates lane show untriaged`.
+ */
+export declare const UNTRIAGED = "untriaged";
+/**
+ * What a chat with an agent takes to mean "work down lane `id`", or, for
+ * null, "place the untriaged todos in lanes, then work those down".
+ */
+export declare function laneReference(id: number | null): string;
+/** What a chat with an agent takes to mean "claim `task` and carry on with it". */
+export declare function taskReference(task: string): string;
+/** What a chat with an agent takes to mean "walk the user through setup step `step`". */
+export declare function setupReference(step: string): string;
+/**
+ * What a chat with an agent takes to mean "the agent at work on `task` handed
+ * it to you: claim it and carry on from where its `SPLATES.md` says it stands".
+ */
+export declare function handoffReference(task: string): string;
+/**
+ * What asks the agent in a conversation to hand its task off to `pick`'s
+ * agent, on its model when it names one, as the page's Hand off action sends.
+ */
+export declare function handoffToReference(pick: AgentPick): string;
+/**
+ * What tells the conversation that handed `task` out that it stopped:
+ * escalated, merged or removed, which `splates show` says.
+ */
+export declare function reportReference(task: string): string;
+/**
+ * What tells the conversation that handed `task` out that the person
+ * terminated its agent, leaving the task as it stood.
+ */
+export declare function stoppedReference(task: string): string;
+/**
+ * What tells the conversation that handed `task` out that its agent's turn
+ * ended, or failed, with the task still under way and not escalated, so it
+ * waits on nothing that will come.
+ */
+export declare function idleReference(task: string): string;
+/**
+ * What asks the conversation that handed tasks out, idle `HEARTBEAT_IDLE` while
+ * an agent it handed one to is at work, to check on each and say where its
+ * lanes stand.
+ */
+export declare const HEARTBEAT = "[SPLATES HEARTBEAT]";
+/**
+ * What tells a lane's orchestrator that todo `id`, in a lane it works, left
+ * the list: merged, or removed.
+ */
+export declare function todoDoneReference(id: number): string;
+/**
+ * What tells a lane's orchestrator that todo `id`, in a lane it works, is
+ * open again: the task that took it released it or was removed.
+ */
+export declare function todoOpenReference(id: number): string;
+/**
+ * What tells a lane's orchestrator that every lane it works is done, however
+ * the last todo landed, so it ends on its Finished report.
+ */
+export declare const LANES_DONE = "[SPLATES LANES DONE]";
+/**
+ * Whether `text` is an update splates itself tells the conversation that handed
+ * tasks out: a report, idle, stopped, a todo done or open, heartbeat or
+ * lanes done, never the person's word.
+ */
+export declare function isUpdate(text: string): boolean;
+/**
+ * What asks an agent to bring its `SPLATES.md` up to date and stop, as before a
+ * restart: the splates skill says what it means.
+ */
+export declare const CHECKPOINT = "[SPLATES CHECKPOINT]";
+/**
+ * What asks an agent to carry on from where its `SPLATES.md` says it stopped,
+ * after a checkpoint: the splates skill says what it means.
+ */
+export declare const RESUME = "[SPLATES RESUME]";
+/**
+ * What asks an agent to carry on with a turn a lost connection cut short, as
+ * the page's Reconnect button sends: the splates skill says what it means.
+ */
+export declare const RECONNECT = "[SPLATES RECONNECT]";
+/**
+ * What approves a task's review and asks the agent to merge it, as the Ready
+ * to merge card's Merge button sends: the splates skill says what it means.
+ */
+export declare const MERGE = "[SPLATES MERGE]";
+/**
+ * What approves an agent's proposal as it stands and asks it to go ahead,
+ * the answers to any calls it chose nothing for after it, as the Proposed
+ * card's Approve button sends: the splates skill says what it means.
+ */
+export declare const APPROVE = "[SPLATES APPROVE]";
+/**
+ * What asks an agent long at work to say where its work stands and carry on,
+ * as the page's Check in button sends: the splates skill says what it means.
+ */
+export declare const CHECK_IN = "[SPLATES UPDATE]";
+/**
+ * What asks an agent to make the request after it a todo rather than do it,
+ * or, alone, to make the person's message before it one, with what it did on
+ * it since, and stop, as the composer's Defer offers: the splates skill says
+ * what it means.
+ */
+export declare const DEFER = "[SPLATES DEFER]";
+/**
+ * What the agent alone is told of a message the person dictated: the page
+ * marks it with a mic, and never shows these words.
+ */
+export declare const DICTATED = "(Dictated by voice: words that sound alike may be swapped, and names in this project misspelled. Read a near miss as the closest name in the project, and ask before acting on a reading that changes what you do.)";
+/** Each `[SPLATES ...]` directive in a text, wherever it stands. */
+export declare const DIRECTIVES: RegExp;
+/**
+ * The directives `text` starts with, in order, and what follows them; none
+ * when it starts with anything else.
+ */
+export declare function leadingDirectives(text: string): {
+    directives: string[];
+    rest: string;
+};
+/**
+ * `text` trimmed, read as splates's directive when it is one of arbor's, as a
+ * conversation from before the rename holds.
+ */
+export declare function directive(text: string): string;

package/pty.d.ts

@@ -0,0 +1,39 @@
+import type { AsyncResource } from "webappwiz/disposable";
+import { type Eventful } from "webappwiz/events";
+import type { Ps } from "webappwiz/system";
+/** What a shell on a `Pty` says: bytes it wrote, and that it is gone. */
+export interface PtyEvents extends Record<string, unknown> {
+    data: Uint8Array;
+    exit: number;
+}
+/** Where and how big a `Pty` starts. */
+export interface PtyOptions {
+    argv: string[];
+    cwd: string;
+    cols: number;
+    rows: number;
+    env?: Record<string, string>;
+    ps?: Ps;
+}
+/**
+ * A program on a pseudo-terminal of its own, the way a terminal window runs a
+ * shell: whatever it writes arrives as `data`, and `write` is typing at it.
+ * POSIX only, since `Bun.Terminal` is.
+ */
+export declare class Pty implements AsyncResource, Eventful<PtyEvents> {
+    private readonly dispatcher;
+    readonly events: import("webappwiz/events").Events<PtyEvents>;
+    private readonly child;
+    constructor({ argv, cwd, cols, rows, env, ps, }: PtyOptions);
+    /** The shell's pid, for the job it runs. */
+    get pid(): number;
+    /** Types `data` at the program, keys and pastes alike. */
+    write(data: string | Uint8Array): void;
+    /** What a window resize does: the program hears of it as SIGWINCH. */
+    resize(cols: number, rows: number): void;
+    /**
+     * Hangs up, as closing a terminal window does: the shell passes it on to
+     * its jobs, background ones included.
+     */
+    disposeAsync(): Promise<void>;
+}

package/pulse.d.ts

@@ -0,0 +1,8 @@
+import { Duration } from "webappwiz/time";
+/**
+ * How often `splates server` says a stream it serves is still there, so the page
+ * can tell one that went quiet, as across a sleep, from one with no news.
+ */
+export declare const PULSE: Duration;
+/** The event it says so with, one the page's handlers for news never hear. */
+export declare const PULSE_EVENT: Uint8Array<ArrayBuffer>;

package/recommend.d.ts

@@ -0,0 +1,31 @@
+import { type LaneRecord, type LaneState } from "./lanes.js";
+import type { Todo } from "./todo.js";
+import type { Todos } from "./todos.js";
+/** What a finished task should be followed by, and what should just go. */
+export interface Recommendation {
+    /** The todo to pick up next, or null when there is nothing fresh left. */
+    next: Todo | null;
+    /** Todos left waiting so long they probably no longer apply. */
+    stale: Todo[];
+    /**
+     * The lane the finished task's todos ran in, when it has more to do:
+     * `next` is its next step then, even one another lane still blocks.
+     */
+    lane?: LaneState;
+    /** Every lane there is now, to name those `lane` is blocked by. */
+    records?: LaneRecord[];
+    /** A lane the finished task's todos emptied: its agent is done. */
+    finished?: LaneRecord;
+}
+/**
+ * Which todo to take up after `task`. A task whose todos ran in a lane goes
+ * on down that lane, since that is what its agent was handed. Otherwise one
+ * that came up in it first, since whoever just finished it knows that context
+ * best, then the open one highest on the list, which is how
+ * whoever keeps the list says what matters most; never one still blocked by
+ * another yet to merge. Todos past `staleness` are never recommended, only
+ * offered for removal.
+ */
+export declare function recommend(todos: Todos, task: string | null, staleness: number, ran?: LaneRecord[]): Promise<Recommendation>;
+/** The lines `merge` ends with, or none when there is nothing to say. */
+export declare function recommendation({ next, stale, lane, records, finished, }: Recommendation): string[];

package/release.d.ts

@@ -0,0 +1,41 @@
+import type { Ps } from "webappwiz/system";
+/** The version of splates running now, as `ship` stamped it. */
+export declare const RUNNING: string;
+/** Where npm says which version of splates is the latest. */
+export declare const REGISTRY = "https://registry.npmjs.org/@stringsync%2fsplates/latest";
+/** A newer splates than the one serving, published since it started. */
+export interface Release {
+    running: string;
+    newest: string;
+}
+/**
+ * Commits to splates's own source since `splates server` started from a checkout of
+ * it, which a restart picks up.
+ */
+export interface Behind {
+    /** The last commit to the source as the server started. */
+    running: string;
+    /** The last commit to it now. */
+    newest: string;
+}
+/**
+ * The directories splates runs from in a checkout: its own, and the webappwiz
+ * library it imports, whose commits change what the server runs just as much.
+ */
+export declare const SOURCE: string[];
+/**
+ * The last commit to `source`, or null when splates does not run from a
+ * checkout, as from npm, or git cannot say. Never throws, like `newest`.
+ */
+export declare function sourceCommit(ps: Ps, source?: string[]): Promise<string | null>;
+/**
+ * The latest version of splates on npm, or null when the registry cannot say:
+ * offline, slow, or answering with something else. A check that fails has
+ * nothing to tell the person at the page, so it never throws.
+ */
+export declare function newest(registry?: string): Promise<string | null>;
+/**
+ * Whether `version` is past `than`, by major, minor and patch. A prerelease is
+ * never newer: only what `@latest` installs is worth a restart.
+ */
+export declare function isNewer(version: string, than: string): boolean;

package/remote-process.d.ts

@@ -0,0 +1,26 @@
+import type { AgentFrame, AgentProcess, ProcessHandle } from "./agent-process.js";
+import type { WorkerChannel } from "./worker-channel.js";
+import type { WorkerSession } from "./worker-session.js";
+/**
+ * A process running on a worker, seen from the coordinator as any
+ * `AgentProcess` is: writing `input` is its stdin, `output` its stdout, each
+ * frame in the seq its channel gave it, acked back to the worker once written
+ * down. Its pid is null until the worker says it started; one taken back
+ * after a restart asks again, since the word came before.
+ */
+export declare class RemoteProcess implements AgentProcess {
+    private readonly channel;
+    readonly input: WritableStream<Uint8Array>;
+    readonly output: ReadableStream<AgentFrame>;
+    readonly exited: Promise<number>;
+    readonly handle: ProcessHandle;
+    private _pid;
+    private tail;
+    constructor(channel: WorkerChannel, session: WorkerSession, worker: string, { resumed }?: {
+        resumed?: boolean;
+    });
+    get pid(): number | null;
+    stderr(): string;
+    ack(seq: number): void;
+    kill(): void;
+}

package/remote-pty.d.ts

@@ -0,0 +1,29 @@
+import type { AsyncResource } from "webappwiz/disposable";
+import { type Eventful } from "webappwiz/events";
+import type { ProcessHandle } from "./agent-process.js";
+import type { PtyEvents } from "./pty.js";
+import type { WorkerChannel } from "./worker-channel.js";
+/**
+ * A shell on a worker's pseudo-terminal, seen from the coordinator as a
+ * `Pty` is: what it writes arrives as `data`, and `write` is typing at it.
+ * Its pid is null until the worker says it started, or says it again when
+ * asked to `describe` itself, as one taken back after a restart is.
+ */
+export declare class RemotePty implements AsyncResource, Eventful<PtyEvents> {
+    private readonly channel;
+    private readonly dispatcher;
+    readonly events: import("webappwiz/events").Events<PtyEvents>;
+    /** What takes it back after a coordinator restart. */
+    readonly handle: ProcessHandle;
+    private _pid;
+    private exited;
+    constructor(channel: WorkerChannel, worker: string);
+    get pid(): number | null;
+    write(data: string | Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    /** Asks the worker to say the pid again and write the screen it kept, as `data`. */
+    describe(): void;
+    /** Hangs up, as closing a terminal window does. */
+    disposeAsync(): Promise<void>;
+    private exit;
+}

package/remote-worker.d.ts

@@ -0,0 +1,77 @@
+import type { ListeningEntry, ProcessEntry } from "webappwiz/system";
+import type { Launch, ProcessHandle } from "./agent-process.js";
+import type { GitResult } from "./git.js";
+import { RemoteProcess } from "./remote-process.js";
+import { RemotePty } from "./remote-pty.js";
+import type { WorkerChannel } from "./worker-channel.js";
+import type { WorkerMachine, WorkerRead } from "./worker-machine.js";
+import type { Json } from "./worker-protocol.js";
+import type { WorkerSession } from "./worker-session.js";
+/** Where and how big a shell on a worker starts, as `Pty` takes it. */
+export interface RemotePtyOptions {
+    argv: string[];
+    cwd: string;
+    cols: number;
+    rows: number;
+    env?: Record<string, string>;
+}
+/** How a worker joined: over this machine's socket, or by its own say-so. */
+export type WorkerKind = "local" | "registered";
+/**
+ * The coordinator's handle on one worker: what it said of itself in its
+ * hello, and the work it can be given. Its session outlives any one
+ * connection, so a call or process started before a drop finishes after it.
+ */
+export declare class RemoteWorker implements WorkerMachine {
+    readonly id: string;
+    /** Slots, platform and build, as its last hello said. */
+    info: {
+        [key: string]: Json;
+    };
+    readonly session: WorkerSession;
+    /** How its last connection arrived. */
+    kind: WorkerKind;
+    private calls;
+    private nextCall;
+    private readonly pending;
+    constructor(id: string, 
+    /** Slots, platform and build, as its last hello said. */
+    info: {
+        [key: string]: Json;
+    }, session: WorkerSession, 
+    /** How its last connection arrived. */
+    kind?: WorkerKind);
+    get connected(): boolean;
+    /** `start`, as the `Launch` that conversations start their agents with. */
+    readonly launch: Launch;
+    /** Starts `argv` in `cwd` on the worker, its stdio piped back here. */
+    start(argv: string[], cwd: string, env?: Record<string, string>): RemoteProcess;
+    /**
+     * Takes back the process `handle` names, which this worker kept running
+     * while its coordinator restarted: its output replays from past `held`,
+     * the last frame the coordinator wrote down, or from wherever the worker's
+     * replay starts for null.
+     */
+    resume(handle: ProcessHandle, held: number | null): RemoteProcess;
+    /** Starts a shell on a pseudo-terminal of the worker's. */
+    pty({ argv, cwd, cols, rows, env }: RemotePtyOptions): RemotePty;
+    /**
+     * Takes back a shell the worker kept through a coordinator restart, by
+     * the `handle` the last run's `pty` had; it says its pid and screen again
+     * once asked to describe itself. One the worker no longer runs exits.
+     */
+    resumePty(handle: ProcessHandle): RemotePty;
+    /**
+     * Opens a connection to `port` on the worker's loopback, such as a task's
+     * dev server, as a `port` channel for a `PortPipe` to carry.
+     */
+    port(port: number): WorkerChannel;
+    git(cwd: string, args: string[]): Promise<GitResult>;
+    processes(): Promise<ProcessEntry[]>;
+    listening(): Promise<ListeningEntry[]>;
+    exists(path: string): Promise<boolean>;
+    read(path: string, from: number): Promise<WorkerRead>;
+    private call;
+    /** One `calls` channel for every call, opened on the first. */
+    private channel;
+}