@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/workers/scheduler.d.ts

@@ -0,0 +1,171 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import { type Eventful } from "../../../core/events/index.js";
+import type { WallClock } from "../../../core/time/index.js";
+/**
+ * Places agents on workers at once, however many run: nothing caps how
+ * many agents run. An agent waits
+ * only while no worker is up, or, for one splates starts on its own, while
+ * the pool is paused, first come, first served, in an order the person can
+ * change.
+ */
+export declare class Scheduler implements Eventful<SchedulerEvents>, Resource {
+    private readonly pool;
+    private readonly clock;
+    private readonly dispatcher;
+    readonly events: import("../../../core/events/index.js").Events<SchedulerEvents>;
+    private readonly waiting;
+    private readonly holding;
+    /** The workers last seen draining, so each new drain is told once. */
+    private drained;
+    /** Whether the pool was paused when last poked, so a pause or a resume alone is told. */
+    private wasPaused;
+    constructor(pool: Pool, clock: WallClock);
+    /**
+     * A place for `request`, at once when it may start, else once its turn
+     * comes; aborting `signal` takes it out of the queue, rejecting.
+     */
+    take(request: StartRequest, signal?: AbortSignal): Promise<Grant>;
+    /**
+     * Counts `request` against `worker` without queueing, for an agent that
+     * already runs there, as one taken back after a restart.
+     */
+    hold(request: StartRequest, worker: string): Grant;
+    /** Those waiting to start, first in line first. */
+    queue(): QueueEntry[];
+    /** Where `id` waits; null for one not in the queue. */
+    spot(id: string): QueueEntry | null;
+    /** The agents placed, on whichever worker. */
+    held(): PlacedAgent[];
+    /**
+     * Moves `id` to `position` in the queue, from 1, clamped to its ends.
+     * Answers whether it was waiting.
+     */
+    move(id: string, position: number): boolean;
+    /**
+     * Frees every agent placed on `worker`, as when it is removed with its
+     * agents still on it or has been away too long, saying `why`, telling each grant's holder through `lost`, and
+     * places whoever can go elsewhere: the holders that take their agents
+     * back up included, once `worker` is out of the pool.
+     */
+    release(worker: string, why?: string): void;
+    /**
+     * Places whoever can be placed now, as after a worker joins,
+     * and tells of each worker that has started draining since it last
+     * looked, for the agents on it to move off at their next pause.
+     */
+    poke(): void;
+    /** Whether `worker` drains, taking no new agents while those on it end. */
+    drains(worker: string): boolean;
+    /**
+     * Whether `worker` drains to be replaced, as a rollout does: its agents
+     * move to another at their next pause rather than run to their end.
+     */
+    replaces(worker: string): boolean;
+    dispose(): void;
+    /** Places each waiting agent, in order, that may start now; answers whether any did. */
+    private place;
+    /**
+     * The worker for `request`, among those awake: any on the server's build
+     * before every one waiting on an update, which a rollout is to take
+     * down, and among equals the one running fewest agents. While the pool
+     * is paused no automatic request is placed: the person's own agents
+     * still start.
+     */
+    private pick;
+    private grant;
+    private paused;
+    private changed;
+}
+/** The workers agents can be placed on, as they stand now. */
+export interface Pool {
+    workers(): PoolWorker[];
+    /**
+     * Whether everything splates starts on its own waits, the person's own
+     * agents alone being placed; absent for a pool never paused.
+     */
+    paused?(): boolean;
+}
+/** One worker as placement sees it. */
+export interface PoolWorker {
+    id: string;
+    /** Whether it is up and may be given work now. */
+    awake: boolean;
+    /**
+     * Whether it drains, taking no new agents while those on it end, as
+     * before it is removed or updated; absent for one that does not.
+     */
+    draining?: boolean;
+    /**
+     * Whether it runs another build than the server, so waits on an
+     * update; absent for one on the same build, or that has not said.
+     */
+    outdated?: boolean;
+    /**
+     * Whether it drains to be replaced by one on the server's build, so
+     * its agents move off it at their next pause; absent for one that does not.
+     */
+    replacing?: boolean;
+}
+/** What wants a worker: one conversation's agent. */
+export interface StartRequest {
+    /** The conversation's id. */
+    id: string;
+    /** The project's main tree. */
+    project: string;
+    task: string | null;
+    /** The agent it starts, by id. */
+    agent: string;
+    /**
+     * Started by splates on its own (an automation, a hook, the groomer),
+     * so held while the pool is paused; false for an agent the person
+     * started, or a task they queued, which is placed even then.
+     */
+    automatic: boolean;
+}
+/** Why a queued agent waits. */
+export type QueueReason = "no worker up" | "worker draining" | "paused";
+/** One agent waiting to start, first in line first. */
+export interface QueueEntry {
+    id: string;
+    project: string;
+    task: string | null;
+    /** The agent it starts, by id. */
+    agent: string;
+    /** From 1, the first to be placed. */
+    position: number;
+    /** When it joined the queue, epoch milliseconds. */
+    since: number;
+    reason: QueueReason;
+}
+/** One agent running on a worker. */
+export interface PlacedAgent {
+    id: string;
+    project: string;
+    task: string | null;
+    worker: string;
+    /** Started by splates on its own, not by the person (`StartRequest`). */
+    automatic: boolean;
+    /** When it was placed, epoch milliseconds. */
+    since: number;
+}
+/** A place an agent holds until it is disposed, which frees it. */
+export interface Grant extends Resource {
+    readonly worker: string;
+    /**
+     * Aborts once the place is taken away with its worker, as a forced
+     * remove does, while the agent may still think it runs there.
+     */
+    readonly lost: AbortSignal;
+    /** Whether its worker drains now, waiting on the agent to end. */
+    drains(): boolean;
+    /** Whether its worker drains to be replaced, for the agent to move off at its next pause. */
+    replaces(): boolean;
+}
+/**
+ * `changed` whenever the queue or the agents placed change; `drain` with a
+ * worker's id once it starts draining (`poke`).
+ */
+export type SchedulerEvents = {
+    changed: undefined;
+    drain: string;
+};

package/vendor/@stringsync/splates-server/workers/server-of.d.ts

@@ -0,0 +1,23 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+/** How a command sends the `splates server` a request: `fetch`, or a stand-in. */
+export type ServerSend = (url: string, init: RequestInit) => Promise<Response>;
+/** The `splates server` a command asks, and how it sends to it. */
+export interface ServerOf {
+    url: string;
+    send: ServerSend;
+}
+/** What `serverOf` reads to find the server. */
+export interface ServerOfOptions {
+    dev?: string;
+    ps: Ps;
+    fs?: Fs;
+    log: Logger;
+    send?: ServerSend;
+}
+/**
+ * The `splates server` a command reaches: `dev`, else the one the agent's
+ * env names. An explicit `send` stands in for how it is reached. Null when
+ * neither says.
+ */
+export declare function serverOf(opts: ServerOfOptions): Promise<ServerOf | null>;

package/vendor/@stringsync/splates-server/workers/server-socket.d.ts

@@ -0,0 +1,25 @@
+import type { Connection } from "../server/shared";
+import type { WorkerRegistry } from "./registry";
+import type { WorkerSocket, WorkerSocketEvents } from "./socket";
+/**
+ * A worker's WebSocket as `splates server` upgraded it on `/api/workers`, seen as
+ * a `WorkerSocket`: the server hands it each socket event, and it hands
+ * itself to the registry once open.
+ */
+export declare class ServerWorkerSocket implements WorkerSocket, Connection {
+    private readonly registry;
+    /** The worker its key proved it to be; null for one that proves it in its hello. */
+    private readonly identity;
+    private readonly dispatcher;
+    readonly events: import("../../../core/events/index.js").Events<WorkerSocketEvents>;
+    private socket;
+    private live;
+    constructor(registry: WorkerRegistry, 
+    /** The worker its key proved it to be; null for one that proves it in its hello. */
+    identity: string | null);
+    send(frame: string | Uint8Array): boolean;
+    dispose(): void;
+    open(socket: Bun.ServerWebSocket<Connection>): void;
+    message(_socket: Bun.ServerWebSocket<Connection>, message: string | Buffer<ArrayBuffer>): void;
+    closed(): void;
+}

package/vendor/@stringsync/splates-server/workers/session.d.ts

@@ -0,0 +1,240 @@
+import { type Resource } from "../../../core/disposable/index.js";
+import { type Eventful } from "../../../core/events/index.js";
+import { type Clock, Duration, type Timer, type WallClock } from "../../../core/time/index.js";
+import { WorkerChannel } from "./channel";
+import { type Frame, type Json, type Negotiated } from "./protocol";
+import type { WorkerSocket } from "./socket";
+/** A worker's hello, which the server reads to pick its session. */
+export type WorkerHello = Extract<Frame, {
+    type: "hello";
+}>;
+/** How a `WorkerSession` paces and bounds itself. */
+export interface WorkerSessionOptions {
+    /**
+     * What its hello or welcome names it by: the id a server started
+     * again answers as, so its worker finds it unchanged and keeps every
+     * channel; new by default.
+     */
+    id?: string;
+    /** The protocol the session it resumes spoke; of another major, none of its channels are taken back. */
+    resumedProtocol?: string;
+    capabilities?: string[];
+    /** Unacked bytes kept for replay before writes return `false`. */
+    bufferBytes?: number;
+    /** How often each end pings the other. */
+    heartbeat?: Duration;
+    /** How long without a frame before the other end counts as gone. */
+    timeout?: Duration;
+    /** How long acks gather before they go, so a burst costs one ack. */
+    ackDelay?: Duration;
+    /**
+     * `delivery` acks data and messages once listeners have them; `manual`
+     * waits for `WorkerChannel.ack`, for an end that must first write them
+     * down. Opens and closes are acked on arrival either way.
+     */
+    acks?: "delivery" | "manual";
+    timer?: Timer;
+    clock?: Clock;
+    /** Stamps `lastHeard`. */
+    wall?: WallClock;
+}
+/**
+ * One end of the link between a server and a worker, the same code on
+ * both. It outlives any one connection: channels stay open across a
+ * reconnect, every channel frame is kept until the other end acks it, and a
+ * new connection replays what was not acked, in order, once.
+ */
+export declare class WorkerSession implements Eventful<WorkerSessionEvents>, Resource {
+    readonly role: "worker" | "coordinator";
+    /** What its hello or welcome names it by, so the other end can tell one started again. */
+    readonly id: string;
+    private readonly dispatcher;
+    readonly events: import("../../../core/events/index.js").Events<WorkerSessionEvents>;
+    private readonly channels;
+    private readonly replay;
+    private readonly sent;
+    private readonly received;
+    /** Channels taken back without knowing where the other end's replay starts: its first frame says. */
+    private readonly unplaced;
+    /** Channels taken back from the session this one resumes, until the first handshake says the other end holds them. */
+    private readonly taken;
+    /**
+     * Channels opened before that handshake, which says what ids the other
+     * end still holds, so each takes its id then, past them all.
+     */
+    private readonly provisional;
+    /**
+     * What was sent on a taken channel before that handshake, which says
+     * where its seqs carry on from: numbered and sent then.
+     */
+    private readonly deferred;
+    private readonly held;
+    private readonly pendingAcks;
+    /** Channels both ends closed, kept until a pong proves the other end has their ack. */
+    private readonly forgetting;
+    private readonly capabilities;
+    private readonly heartbeat;
+    private readonly timeout;
+    private readonly ackDelay;
+    private readonly acks;
+    /** What its heartbeats and bounds run on, which what rides on it shares. */
+    readonly timer: Timer;
+    private readonly clock;
+    private readonly wall;
+    private readonly link;
+    private connection;
+    private nextChannel;
+    private nextPing;
+    private wasFull;
+    private _negotiated;
+    private _lastHeard;
+    private disposed;
+    /** Hung up for a restart: its channels live on at the other end, for the next session to take back. */
+    private detached;
+    /** Made with an id, so the other end may hold channels of the session it resumes. */
+    private readonly resumed;
+    private readonly priorFormat;
+    /** The other end's session at the last handshake; null before the first. */
+    private peer;
+    constructor(role: "worker" | "coordinator", opts?: WorkerSessionOptions);
+    /**
+     * Reads the first frame of a new connection, which must be a worker's
+     * hello, so the server can pick the session it resumes.
+     */
+    static hello(socket: WorkerSocket, answer?: (nonce: string) => Frame): Promise<WorkerHello>;
+    /** What the last handshake settled on, once there has been one. */
+    get negotiated(): Negotiated | undefined;
+    /** When any frame last came from the other end, in epoch milliseconds; null before the first. */
+    get lastHeard(): number | null;
+    get connected(): boolean;
+    /**
+     * Asks the worker to restart on `build`, answering whether it could be
+     * asked: connected, and offering `update`. Belongs to this connection
+     * alone, so one that drops first is asked again once it is back.
+     */
+    update(build: string): boolean;
+    /**
+     * Tells the server this worker is about to go, answering whether it
+     * could: connected to one that offers `leaving`.
+     */
+    leaving(reason: string): boolean;
+    /** False while unacked bytes are at the bound; `drain` says when that ends. */
+    get writable(): boolean;
+    /** Settles once writes may go on: at once, or at the next `drain`. */
+    drained(): Promise<void>;
+    /** Opens a channel to the other end, which hears it as `channel`. */
+    open(kind: string, params?: Json): WorkerChannel;
+    /**
+     * Takes back channel `id`, which the other end still holds from the
+     * session this one resumes, before the handshake: `held` is the last seq
+     * of the other end's this end has, which its replay then follows, or null
+     * to take the replay from wherever it starts. What this end sends on it
+     * carries on from what the other end's hello says it received.
+     */
+    resume(id: number, kind: string, params: Json, held: number | null): WorkerChannel;
+    /**
+     * The worker's side of a handshake: says hello on `socket`, and on welcome
+     * replays what the server does not hold. Resolves with what was
+     * negotiated, or why not: refused for another major, or the link went.
+     */
+    connect(socket: WorkerSocket, hello: {
+        id: string;
+        info?: {
+            [key: string]: Json;
+        };
+        key?: string;
+    }): Promise<Negotiated>;
+    /**
+     * The server's side of a handshake, given the hello
+     * `WorkerSession.hello` read: welcomes the worker and replays what it
+     * does not hold, or refuses one on another major, hanging up, so the
+     * server can drain it with the reason.
+     */
+    accept(socket: WorkerSocket, hello: WorkerHello): Negotiated;
+    /**
+     * What the worker's hello says it holds of the channels of the session
+     * this one resumes, at its first handshake: this end sends on each from
+     * past that, opens new ones past them all, and closes those nobody took
+     * back, which ends what they ran. One taken back that the worker does
+     * not hold, as after the worker too started again, ends here.
+     */
+    private takeBack;
+    /** Whether `id` is a channel opened before the first handshake, its id yet to be settled. */
+    private isProvisional;
+    /** Moves `channel`, opened before the first handshake, to `id`, with what it deferred. */
+    private renumber;
+    /** Opens new channels past `id`, one of this end's numbering. */
+    private openPast;
+    private takeBackHeld;
+    /**
+     * Hangs up for a restart, keeping every channel open at the other end:
+     * a session with this id takes them back once it comes up.
+     */
+    detach(): void;
+    /**
+     * Ends every channel here while staying up, for an other end that has not
+     * returned: what they ran stops now, and a server that does come back
+     * hears the closes it missed.
+     */
+    endChannels(): void;
+    /** Settles once the other end has acked everything sent, or at once with nothing out. */
+    acked(): Promise<void>;
+    /** Hangs up and closes every channel; the other end hears them close. */
+    dispose(): void;
+    private attach;
+    private go;
+    private hear;
+    private handshake;
+    private receive;
+    /**
+     * A frame on a channel this end never heard of: one the other end opened
+     * in the session this one resumes, its open acked but nothing said back,
+     * so its hello did not name it. Closed, as one nobody took back is,
+     * rather than hung up on, which it would replay at every reconnect.
+     */
+    private unheard;
+    /** Holds `frame` for the handshake that says what seq it goes out as. */
+    private defer;
+    /** Throws on a frame over the link's limit, true otherwise. */
+    private checkSize;
+    private sendOnChannel;
+    private nextSeq;
+    private ack;
+    private flushAcks;
+    private acknowledged;
+    /**
+     * Ends every channel at this end, for another end started again, which
+     * knows none of them: what they ran stops, as when the old one hung up.
+     */
+    private forget;
+    private channelDone;
+    private ponged;
+    private beat;
+    private write;
+    private lose;
+    private assertRole;
+    private assertOpen;
+}
+/** What a `WorkerSession` hears. */
+export interface WorkerSessionEvents extends Record<string, unknown> {
+    /** The other end opened a channel. */
+    channel: WorkerChannel;
+    /** A handshake settled, and what the other end missed has been sent again. */
+    connected: undefined;
+    /** The connection went, by hang-up, missed heartbeats or a bad frame; channels stay. */
+    lost: {
+        reason: string;
+    };
+    /** Acks brought unacked bytes back under the bound: writers may go on. */
+    drain: undefined;
+    /** The other end acked something; `acked()` waits on it. */
+    acked: undefined;
+    /** The server asks this worker to restart on its `build`. */
+    update: {
+        build: string;
+    };
+    /** The worker says its machine is about to be taken away. */
+    leaving: {
+        reason: string;
+    };
+}

package/vendor/@stringsync/splates-server/workers/socket.d.ts

@@ -0,0 +1,21 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Eventful } from "../../../core/events/index.js";
+/** What a `WorkerSocket` hears: one whole frame, or that it is gone. */
+export interface WorkerSocketEvents extends Record<string, unknown> {
+    frame: string | Uint8Array;
+    close: undefined;
+}
+/**
+ * One connection between a server and a worker, carrying whole frames in
+ * order: a WebSocket as it is, or a Unix socket behind length-prefixed
+ * framing. Disposing it hangs up, and both ends then hear `close`.
+ */
+export interface WorkerSocket extends Eventful<WorkerSocketEvents>, Resource {
+    /**
+     * Queues `frame` and says whether the socket still carries it. False means
+     * it is gone or dropped the frame, in which case it hangs up itself, so
+     * both ends hear `close` and the session replays the frame on the next
+     * connection.
+     */
+    send(frame: string | Uint8Array): boolean;
+}

package/vendor/@stringsync/splates-server/workers/unix-listener.d.ts

@@ -0,0 +1,23 @@
+import type { AsyncResource } from "../../../core/disposable/index.js";
+import { type Eventful } from "../../../core/events/index.js";
+import type { Fs } from "../../../core/system/index.js";
+import { UnixWorkerSocket } from "./unix-socket";
+/** 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 server 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("../../../core/events/index.js").Events<UnixWorkerListenerEvents>;
+    private constructor();
+    static listen(path: string, fs: Fs): Promise<UnixWorkerListener>;
+    disposeAsync(): Promise<void>;
+}

package/vendor/@stringsync/splates-server/workers/unix-socket.d.ts

@@ -0,0 +1,30 @@
+import type { WorkerSocket, WorkerSocketEvents } from "./socket";
+/** 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
+ * server 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("../../../core/events/index.js").Events<WorkerSocketEvents>;
+    private socket;
+    private pending;
+    /** What the kernel would not take yet, sent on the next drain. */
+    private unsent;
+    private open;
+    /** Dials the server 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): boolean;
+    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/vendor/@stringsync/splates-server/workers/websocket-socket.d.ts

@@ -0,0 +1,24 @@
+import { Duration } from "../../../core/time/index.js";
+import type { WorkerSocket, WorkerSocketEvents } from "./socket";
+/**
+ * A `WorkerSocket` over a WebSocket the worker dials, as a remote worker
+ * reaches its server'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("../../../core/events/index.js").Events<WorkerSocketEvents>;
+    private open;
+    private constructor();
+    /**
+     * Dials `url` with `headers`, settling once the socket is open, or
+     * rejecting once `within` is up: a box that takes the connection and
+     * never answers would otherwise hold the dial, and the worker's retries
+     * behind it, for good.
+     */
+    static connect(url: string, headers?: Record<string, string>, within?: Duration): Promise<WebSocketWorkerSocket>;
+    send(frame: string | Uint8Array): boolean;
+    dispose(): void;
+    private closed;
+}

package/vendor/@stringsync/splates-server/workers/worker.d.ts

@@ -0,0 +1,98 @@
+import type { ListeningEntry, ProcessEntry } from "../../../core/system/index.js";
+import { Duration } from "../../../core/time/index.js";
+import type { Launch, ProcessHandle } from "../agents";
+import type { GitResult } from "../git";
+import { RemotePty } from "../terminal";
+import { type CallRequest } from "./call-host";
+import type { WorkerMachine, WorkerRead } from "./machine";
+import { WorkerProcess } from "./process";
+import type { Json } from "./protocol";
+import type { WorkerSession } from "./session";
+/** 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>;
+}
+/** Spread into each request, which the channel gives its id. */
+type Call = CallRequest extends infer Each ? Each extends {
+    id: number;
+} ? Omit<Each, "id"> : never : never;
+/** How long each kind of call may go unanswered before it is given up on. */
+export type CallBounds = Record<Call["method"], Duration>;
+/**
+ * How long a worker may take over each call before whatever waits on it
+ * gives up: long enough for a slow worker's honest answer, short enough
+ * that a link gone silent, or a call hung on the worker, frees the caller.
+ */
+export declare const CALL_BOUNDS: CallBounds;
+/**
+ * How a worker joined: over this machine's socket, or by its own say-so.
+ */
+export type WorkerKind = "local" | "registered";
+/**
+ * The server'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 ConnectedWorker 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 readonly bounds;
+    private calls;
+    private nextCall;
+    /** The pieces of a git call's output heard so far, by call. */
+    private readonly parts;
+    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, bounds?: CallBounds);
+    /**
+     * Whether the worker checked this server's signing key before it
+     * sent its own key; false for one that joined before join tokens carried
+     * it, which re-joining makes verified.
+     */
+    verified: boolean;
+    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>): WorkerProcess;
+    /**
+     * Takes back the process `handle` names, which this worker kept running
+     * while its server restarted: its output replays from past `held`,
+     * the last frame the server wrote down, or from wherever the worker's
+     * replay starts for null.
+     */
+    resume(handle: ProcessHandle, held: number | null): WorkerProcess;
+    /** 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 server 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;
+    git(cwd: string, args: string[], env?: Record<string, string>): Promise<GitResult>;
+    processes(): Promise<ProcessEntry[]>;
+    listening(): Promise<ListeningEntry[]>;
+    exists(path: string): Promise<boolean>;
+    scratch(agent: string, cwd: string): Promise<void>;
+    read(path: string, from: number): Promise<WorkerRead>;
+    private call;
+    /** One `calls` channel for every call, opened on the first. */
+    private channel;
+}
+export {};