@stringsync/splates 0.0.61 → 1.13.3

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

@@ -0,0 +1,40 @@
+export { drainWorker, removeWorker, setQueuePaused, } from "./admin";
+export { WorkerChannel } from "./channel";
+export { CoordinatorState } from "./coordinator-state";
+export { WorkerDaemon } from "./daemon";
+export { workerGit } from "./git";
+export { CoordinatorIdentity } from "./identity";
+export { SUPERVISOR } from "./lifecycle";
+export type { HeldListing, WorkerListing, WorkerListings, WorkerPool, } from "./list";
+export { fetchWorkers, listWorkers, workerList } from "./list";
+export type { MachineReading, MachineSensors } from "./load";
+export { Machine } from "./load";
+export { LOCAL_WORKER } from "./local-id";
+export { LocalWorkerUpdate } from "./local-update";
+export { FileLogger, LOG_FILE_BYTES } from "./log-file";
+export type { WorkerMachine } from "./machine";
+export { LocalWorkerMachine } from "./machine";
+export { OsSensors } from "./os-sensors";
+export { AgentPlacement } from "./placement";
+export { WorkerProcess } from "./process";
+export { descendants, WorkerProcessHost } from "./process-host";
+export { WorkerProtocol } from "./protocol";
+export type { QueueListing } from "./queue";
+export { listQueue, moveQueued, queueListing } from "./queue";
+export { WorkerRecords } from "./records";
+export { WorkerRegistry } from "./registry";
+export type { DevWorkersOptions } from "./routes";
+export { DevWorkers } from "./routes";
+export { workerRun, workerSocketPath } from "./run";
+export type { Grant, PlacedAgent, PoolWorker, QueueEntry } from "./scheduler";
+export { Scheduler, type StartRequest } from "./scheduler";
+export type { ServerOf, ServerSend } from "./server-of";
+export { serverOf } from "./server-of";
+export { ServerWorkerSocket } from "./server-socket";
+export { WorkerSession } from "./session";
+export type { WorkerSocket } from "./socket";
+export { UnixWorkerListener } from "./unix-listener";
+export { UnixWorkerSocket } from "./unix-socket";
+export { WebSocketWorkerSocket } from "./websocket-socket";
+export type { RemotePtyOptions, WorkerKind } from "./worker";
+export { ConnectedWorker } from "./worker";

package/vendor/@stringsync/splates-server/workers/index.js

@@ -0,0 +1,90 @@
+import {
+  LOCAL_WORKER2,
+  serverOf2,
+  drainWorker2,
+  removeWorker2,
+  setQueuePaused2,
+  WorkerProtocol2,
+  WorkerChannel2,
+  CoordinatorState2,
+  CoordinatorIdentity2,
+  LocalWorkerMachine2,
+  WorkerProcessHost2,
+  descendants2,
+  WorkerSession2,
+  WorkerDaemon2,
+  workerGit2,
+  SUPERVISOR2,
+  workerList2,
+  fetchWorkers2,
+  listWorkers2,
+  Machine2,
+  LocalWorkerUpdate2,
+  LOG_FILE_BYTES2,
+  FileLogger2,
+  OsSensors2,
+  Scheduler3,
+  AgentPlacement2,
+  WorkerProcess2,
+  queueListing2,
+  listQueue2,
+  moveQueued2,
+  WorkerRecords2,
+  ConnectedWorker2,
+  WorkerRegistry2,
+  UnixWorkerSocket2,
+  UnixWorkerListener2,
+  DevWorkers2,
+  workerSocketPath2,
+  workerRun2,
+  ServerWorkerSocket2,
+  WebSocketWorkerSocket2
+} from "../index-caep3sde.js";
+import"../index-01z7ycdk.js";
+import"../index-e9z7s5hh.js";
+import"../index-kmzdvvt0.js";
+import"../index-t9w5a8ed.js";
+import"../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  AgentPlacement2 as AgentPlacement,
+  ConnectedWorker2 as ConnectedWorker,
+  CoordinatorIdentity2 as CoordinatorIdentity,
+  CoordinatorState2 as CoordinatorState,
+  DevWorkers2 as DevWorkers,
+  FileLogger2 as FileLogger,
+  LOCAL_WORKER2 as LOCAL_WORKER,
+  LOG_FILE_BYTES2 as LOG_FILE_BYTES,
+  LocalWorkerMachine2 as LocalWorkerMachine,
+  LocalWorkerUpdate2 as LocalWorkerUpdate,
+  Machine2 as Machine,
+  OsSensors2 as OsSensors,
+  SUPERVISOR2 as SUPERVISOR,
+  Scheduler3 as Scheduler,
+  ServerWorkerSocket2 as ServerWorkerSocket,
+  UnixWorkerListener2 as UnixWorkerListener,
+  UnixWorkerSocket2 as UnixWorkerSocket,
+  WebSocketWorkerSocket2 as WebSocketWorkerSocket,
+  WorkerChannel2 as WorkerChannel,
+  WorkerDaemon2 as WorkerDaemon,
+  WorkerProcess2 as WorkerProcess,
+  WorkerProcessHost2 as WorkerProcessHost,
+  WorkerProtocol2 as WorkerProtocol,
+  WorkerRecords2 as WorkerRecords,
+  WorkerRegistry2 as WorkerRegistry,
+  WorkerSession2 as WorkerSession,
+  descendants2 as descendants,
+  drainWorker2 as drainWorker,
+  fetchWorkers2 as fetchWorkers,
+  listQueue2 as listQueue,
+  listWorkers2 as listWorkers,
+  moveQueued2 as moveQueued,
+  queueListing2 as queueListing,
+  removeWorker2 as removeWorker,
+  serverOf2 as serverOf,
+  setQueuePaused2 as setQueuePaused,
+  workerGit2 as workerGit,
+  workerList2 as workerList,
+  workerRun2 as workerRun,
+  workerSocketPath2 as workerSocketPath
+};

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

@@ -0,0 +1,14 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Ps } from "../../../core/system/index.js";
+import { type Timer } from "../../../core/time/index.js";
+/**
+ * The environment variable that ends a worker with the process that started
+ * it. Set it to that process's pid on the worker `splates server` runs beside
+ * itself, and the worker ends once the pid is gone.
+ */
+export declare const SUPERVISOR = "SPLATES_WORKER_SUPERVISOR";
+/**
+ * Calls `end` once the supervisor `SUPERVISOR` names has gone, looking every
+ * `SUPERVISOR_POLL`; null for a worker no server supervises.
+ */
+export declare function endWithSupervisor(ps: Pick<Ps, "env" | "alive">, timer: Timer, end: () => void): Resource | null;

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

@@ -0,0 +1,93 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { type WallClock } from "../../../core/time/index.js";
+import { type ServerCallOptions } from "./admin";
+import type { WorkerRecord } from "./records";
+import type { WorkerRegistry } from "./registry";
+import type { WorkerKind } from "./worker";
+/** One worker as `GET /api/workers` and `splates worker list` give it. */
+export interface WorkerListing {
+    id: string;
+    kind: WorkerKind;
+    platform: string | null;
+    /** What the platform runs inside, such as `wsl2`; null on the bare machine. */
+    host: string | null;
+    build: string | null;
+    /** What its link settled on; null before any handshake. */
+    protocol: string | null;
+    /** `connected` while the link is up, else `away`. */
+    health: "connected" | "away";
+    /** Takes no new agents, by `splates worker drain` or a removal waiting on its agents. */
+    draining: boolean;
+    /** Is removed once its last agent ends. */
+    removing: boolean;
+    /**
+     * 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, until it joins again; null while it is away.
+     */
+    verified: boolean | null;
+    /** Drains to be brought to the server's build, a rollout's one at a time. */
+    updating: boolean;
+    /** When anything last came from it, epoch milliseconds; null before the first. */
+    lastHeard: number | null;
+    /** The tasks its agents run, a conversation's id for one in no task. */
+    tasks: string[];
+}
+/**
+ * The workers a registry keeps and the ones it turned away; `placed`, the
+ * tasks each runs, by its id, a conversation's id for one in no task;
+ * `record`, what was set on each by hand; `pooled`, whether each takes
+ * agents at all, leaving out this machine's own once it is removed.
+ */
+export declare function workerList(registry: WorkerRegistry, placed?: Map<string, string[]>, record?: (id: string) => WorkerRecord | undefined, pooled?: (id: string) => boolean): WorkerListings;
+/** What a registry keeps and turned away, as `workerList` gives them. */
+export interface WorkerListings {
+    workers: WorkerListing[];
+    refused: {
+        id: string;
+        protocol: string;
+        reason: string;
+    }[];
+}
+/**
+ * What `GET /api/workers` answers: the listings, the build the server
+ * runs, which a worker on another waits to be updated to, and where the
+ * rollout bringing them to it stands.
+ */
+export interface WorkerPool extends WorkerListings {
+    build: string;
+    /** Whether everything splates starts on its own waits, the person's own agents alone starting. */
+    paused: boolean;
+    /** Every agent placed on a worker, on whichever one, the person's own included. */
+    held: HeldListing[];
+}
+/** One agent placed on a worker, as `GET /api/workers` lists it. */
+export interface HeldListing {
+    /** The conversation's id. */
+    id: string;
+    /** The project's main tree. */
+    project: string;
+    task: string | null;
+    /** Whether splates started it on its own, so Pause holds the like of it: an automation, a hook or the groomer. */
+    automatic: boolean;
+    /** When it was placed, an ISO time. */
+    since: string;
+}
+/** What `splates worker list` is run with. */
+export interface ListWorkersOptions {
+    /** The `splates server` to ask; empty for the one this agent runs under. */
+    dev: string;
+    json: boolean;
+    log: Logger;
+    fs?: Fs;
+    ps: Ps;
+    send?: typeof fetch;
+    wall?: WallClock;
+}
+/** The workers the running `splates server` lists. */
+export declare function fetchWorkers(opts: ServerCallOptions): Promise<WorkerListing[]>;
+/** `splates worker list`: asks the running `splates server` which workers it has. */
+export declare function listWorkers(opts: ListWorkersOptions): Promise<void>;
+/** Its platform as the list shows it, with what it runs inside: `linux (wsl2)`. */
+export declare function platformLabel(worker: Pick<WorkerListing, "platform" | "host">): string;

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

@@ -0,0 +1,55 @@
+/** How hard the machine `splates server` runs on is working right now. */
+export interface MachineReading {
+    /** What the page calls the machine: "Mac" on macOS, else "machine". */
+    kind: "Mac" | "machine";
+    /** The share of CPU time busy since the reading before, 0 to 1. */
+    cpu: number;
+    /** The share of memory in use, 0 to 1. */
+    memory: number;
+    /** The load average over the last minute. */
+    load: number;
+    cores: number;
+    /** The hottest CPU sensor in °C, or null where none can be read. */
+    temperature: number | null;
+    /**
+     * What splates itself takes of the machine: the server, the supervisor it
+     * runs under and every process under them, agents and their tools
+     * included. CPU and memory are shares of the whole machine, as `cpu` and
+     * `memory` are; null where the process table cannot be read.
+     */
+    splates: {
+        cpu: number;
+        memory: number;
+        bytes: number;
+    } | null;
+}
+/** One of splates' processes, as a reading counts it. */
+export interface ProcessUse {
+    pid: number;
+    /** CPU time it has spent since it started, in seconds. */
+    cpu: number;
+    /** Memory it holds, in bytes. */
+    memory: number;
+}
+/** Where a reading comes from: the OS by default, a fake in tests. */
+export interface MachineSensors {
+    platform: NodeJS.Platform;
+    cpus(): {
+        times: Record<"user" | "nice" | "sys" | "idle" | "irq", number>;
+    }[];
+    loadavg(): number[];
+    freemem(): number;
+    totalmem(): number;
+    temperature(): Promise<number | null>;
+    /** Each of splates' processes, or null where they cannot be listed. */
+    splates(): Promise<ProcessUse[] | null>;
+}
+/**
+ * Reads the machine on each ask, its CPU share taken over the time since the
+ * ask before, or since it was made for the first.
+ */
+export declare class Machine {
+    #private;
+    constructor(sensors: MachineSensors);
+    read(): Promise<MachineReading>;
+}

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

@@ -0,0 +1,11 @@
+/** What the worker the supervisor starts beside the server is known by. */
+export declare const LOCAL_WORKER = "local";
+/**
+ * The worker started beside this machine's own on `build`, to take new
+ * agents while its own drains to be brought to that build.
+ */
+export declare function handoffWorker(build: string): string;
+/** Whether `id` is one of this machine's workers: its own or one taking over while it updates. */
+export declare function isLocalWorker(id: string): boolean;
+/** Whether `id` is a worker started to take new agents while this machine's own updates. */
+export declare function isHandoffWorker(id: string): boolean;

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

@@ -0,0 +1,81 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import type { WorkerRecords } from "./records";
+import type { WorkerRegistry } from "./registry";
+/** What a `LocalWorkerUpdate` updates workers over. */
+export interface LocalWorkerUpdateOptions {
+    registry: WorkerRegistry;
+    records: WorkerRecords;
+    /** The build the server runs, which every worker is brought to. */
+    build: string;
+    /** What agents each worker holds, by its id. */
+    used: () => Map<string, string[]>;
+    /** Whether worker `id` takes agents at all: not this machine's own once it is removed. */
+    pooled: (id: string) => boolean;
+    /** Tells the scheduler a worker started or stopped draining. */
+    poke: () => void;
+    /**
+     * Starts a worker known by `id` on the server's build beside this
+     * machine's own, answering whether it could; with none, new agents wait
+     * while this machine's own updates.
+     */
+    start?: (id: string) => boolean;
+    /** Hangs up on a handoff worker that has stopped and forgets it. */
+    forget?: (id: string) => Promise<void>;
+    log: Logger;
+}
+/**
+ * Drains and restarts the local worker on the server's build, preserving
+ * its agents until they finish. A handoff worker started on the build
+ * beside it takes new agents meanwhile, and once this machine's own is back
+ * on the build, takes none, stopping once its last agent ends.
+ */
+export declare class LocalWorkerUpdate implements Resource {
+    private readonly opts;
+    /**
+     * Those whose update the person took back, by `splates worker drain
+     * --undo`, or that came back on the old build; tried again next run.
+     */
+    private readonly passed;
+    /** Those asked to restart on the build, until they join again. */
+    private readonly asked;
+    private looking;
+    private again;
+    private readonly unlisten;
+    constructor(opts: LocalWorkerUpdateOptions);
+    /**
+     * Carries the local update on: finishes the worker under way once it is back
+     * on the build, replaces it once it is empty, and starts on the next once
+     * none is under way. Looks once at a time, and once more after for what
+     * changed meanwhile.
+     */
+    look(): Promise<void>;
+    dispose(): void;
+    private step;
+    /**
+     * Starts a worker on the build to take new agents while this machine's
+     * own drains, unless one is already kept for it.
+     */
+    private startHandoff;
+    /**
+     * Drains each handoff worker once this machine's own is back on the
+     * build, or once it is on another build itself, and stops and forgets
+     * each drained one once empty. One no record keeps, as one left
+     * running by an earlier server, is stopped at once.
+     */
+    private handOver;
+    /**
+     * The worker a local update is updating, if any: one asked to restart that
+     * has yet to come back holds up none, so one that never does leaves the
+     * rest to carry on, drained meanwhile.
+     */
+    private underWay;
+    /**
+     * Those in the pool on another build, but for any the person drains or
+     * removes, or took back from this run.
+     */
+    private behind;
+    private pool;
+    /** Whether `worker` can be brought to the build from here: asked to restart. */
+    private updatable;
+}

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

@@ -0,0 +1,24 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs } from "../../../core/system/index.js";
+import { type WallClock } from "../../../core/time/index.js";
+/** How large the log grows before it is moved aside to `<path>.1`, replacing the one there. */
+export declare const LOG_FILE_BYTES: number;
+/**
+ * Appends each line, stamped with the time, to the file at `path`, in the
+ * order said, keeping it and the one before it under `LOG_FILE_BYTES` each:
+ * where a worker with no terminal to read says what it did, so a stall
+ * after a restart can be traced. A line that cannot be written is dropped.
+ */
+export declare class FileLogger implements Logger {
+    private readonly fs;
+    private readonly path;
+    private readonly wall;
+    private writing;
+    constructor(fs: Fs, path: string, wall?: WallClock);
+    info(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+    /** Resolves once every line said so far is written. */
+    flushed(): Promise<void>;
+    private say;
+    private write;
+}

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

@@ -0,0 +1,47 @@
+import type { Fs, ListeningEntry, ProcessEntry, Ps } from "../../../core/system/index.js";
+import { type GitResult, type GitRunner } from "../git";
+/** A file's size, and its bytes from where the caller last read up to. */
+export interface WorkerRead {
+    size: number;
+    bytes: Uint8Array;
+}
+/**
+ * What the server asks of the machine a task runs on: git in its
+ * worktree around each tool call (`Watch`), a background command's output
+ * (`ConversationBackground`), the process table (`heldBy`), and the ports
+ * its processes listen on (`TaskPorts`).
+ */
+export interface WorkerMachine extends GitRunner {
+    /**
+     * `git -C <cwd> <args>`, `env` added to its environment, as `GitRunner`
+     * runs it: untrimmed. A token in `env` is held in memory there, never on
+     * disk.
+     */
+    git(cwd: string, args: string[], env?: Record<string, string>): Promise<GitResult>;
+    processes(): Promise<ProcessEntry[]>;
+    listening(): Promise<ListeningEntry[]>;
+    /** `path` from byte `from` on; a missing file reads as empty. */
+    read(path: string, from: number): Promise<WorkerRead>;
+    /** Whether anything is at `path`, a file or a directory. */
+    exists(path: string): Promise<boolean>;
+    /** Makes the directories `agent` may write in its scratch workspace at `cwd`. */
+    scratch(agent: string, cwd: string): Promise<void>;
+}
+/** The machine this process runs on, as a worker answers for it. */
+export declare class LocalWorkerMachine implements WorkerMachine {
+    private readonly ps;
+    private readonly fs;
+    readonly git: WorkerMachine["git"];
+    constructor(ps: Ps, fs: Fs);
+    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>;
+}
+/**
+ * What the platform runs inside, for the list to show: `wsl2` under
+ * Windows' WSL, which sets `WSL_DISTRO_NAME` in every process it starts;
+ * null on the bare machine.
+ */
+export declare function hostOf(ps: Ps): string | null;

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

@@ -0,0 +1,31 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import { type Clock, Duration, type Timer } from "../../../core/time/index.js";
+/**
+ * Counts the time a worker spends without its server while the machine
+ * is awake, so a laptop whose lid was shut for an hour does not wake to end
+ * every agent it runs before it has even redialed. Time asleep shows as a
+ * gap between ticks far longer than one: only a tick of it counts, and the
+ * worker is told it woke, to redial at once rather than wait out its backoff.
+ */
+export declare class OrphanBound implements Resource {
+    private readonly opts;
+    private readonly tick;
+    private readonly ticking;
+    private last;
+    private awake;
+    private due;
+    constructor(opts: OrphanBoundOptions);
+    private count;
+    dispose(): void;
+}
+/** What an `OrphanBound` counts against and tells. */
+export interface OrphanBoundOptions {
+    /** How long awake without a server before what it left ends. */
+    bound: Duration;
+    timer: Timer;
+    clock: Clock;
+    /** Called on waking from a sleep, to redial now. */
+    woke: () => void;
+    /** Called once, when the bound has passed awake. */
+    due: () => void;
+}

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

@@ -0,0 +1,49 @@
+import os from "node:os";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { MachineSensors, ProcessUse } from "./load";
+/**
+ * The machine this process runs on, for a `Machine` to read. Temperature
+ * reads on Linux and Apple Silicon only, null elsewhere.
+ */
+export declare class OsSensors implements MachineSensors {
+    private readonly fs;
+    readonly platform: NodeJS.Platform;
+    private readonly ps;
+    private readonly supervised;
+    private readonly thermal;
+    /**
+     * Pass `ps` to have `splates()` answer, and `supervised` for a server
+     * `splates server` supervises, to count its supervisor's tree.
+     */
+    constructor(fs: Fs, { ps, supervised, thermal, }?: {
+        ps?: Ps | null;
+        supervised?: boolean;
+        thermal?: string;
+    });
+    cpus(): os.CpuInfo[];
+    loadavg(): number[];
+    freemem(): number;
+    totalmem(): number;
+    temperature(): Promise<number | null>;
+    splates(): Promise<ProcessUse[] | null>;
+    /** The hottest of Linux's thermal zones, in °C, or null for none. */
+    thermalZones(): Promise<number | null>;
+}
+/**
+ * The pids of the process table that count as `root`'s: itself, every
+ * process under it, and the processes orphaned in its group and theirs.
+ */
+export declare function ownPids(table: Row[], root: number): Set<number>;
+/** A row of `ps -axo pid=,ppid=,pgid=,time=,rss=`. */
+interface Row {
+    pid: number;
+    ppid: number;
+    pgid: number;
+    /** CPU seconds. */
+    cpu: number;
+    /** Resident bytes. */
+    rss: number;
+}
+/** The rows of `ps -axo pid=,ppid=,pgid=,time=,rss=`. */
+export declare function parseTable(stdout: string): Row[];
+export {};

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

@@ -0,0 +1,39 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import { type WallClock } from "../../../core/time/index.js";
+import type { ConversationPlacer } from "../conversations";
+import type { WorkerRecord } from "./records";
+import type { WorkerRegistry } from "./registry";
+import { type Pool, Scheduler } from "./scheduler";
+/**
+ * The machine's queue for workers, over the workers its registry
+ * keeps: the agents other agents start, from every project, wait in one
+ * line, and each starts on the worker it was placed on.
+ */
+export declare class AgentPlacement implements Resource {
+    readonly registry: WorkerRegistry;
+    readonly scheduler: Scheduler;
+    /** The workers placement sees. */
+    readonly pool: Pool;
+    private readonly unlisten;
+    /** What frees the agents of a worker away too long; none without a log. */
+    private readonly gone;
+    constructor(registry: WorkerRegistry, { wall, record, pooled, build, log, paused, }: {
+        wall?: WallClock;
+        /** What was set on worker `id` by hand: whether it drains. */
+        record?: (id: string) => WorkerRecord | undefined;
+        /** Whether worker `id` takes agents at all: not this machine's own once it is removed. */
+        pooled?: (id: string) => boolean;
+        /** The build the server runs, which a worker on another waits to be updated to. */
+        build?: string;
+        /** Where it says a worker away too long lets go of its agents; with none, they wait for it. */
+        log?: Logger | null;
+        /** Whether everything splates starts on its own waits, the person's own agents alone placed. */
+        paused?: () => boolean;
+    });
+    /** The queue as the agents of the project at `root` are placed from it. */
+    project(root: string): ConversationPlacer;
+    /** What runs on each worker, by its id: a task, or a conversation's id for one in no task. */
+    used(): Map<string, string[]>;
+    dispose(): void;
+}

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

@@ -0,0 +1,60 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { ProcessEntry, Ps } from "../../../core/system/index.js";
+import type { Timer } from "../../../core/time/index.js";
+import { z } from "zod";
+import type { WorkerChannel } from "./channel";
+import type { WorkerSession } from "./session";
+/** What a server opens a `process` channel with. */
+export declare const ProcessParams: z.ZodObject<{
+    argv: z.ZodArray<z.ZodString>;
+    cwd: z.ZodString;
+    env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * One process a `process` channel started on the worker, such as an agent:
+ * its stdout as the channel's bytes, its stdin from them, and its pid,
+ * stderr and exit code as messages. A server away for long stalls the
+ * process rather than losing what it says. Closing the channel kills it,
+ * and everything it started.
+ */
+export declare class WorkerProcessHost implements Resource {
+    private readonly channel;
+    private readonly session;
+    private readonly ps;
+    private readonly child;
+    private readonly stdin;
+    /** Every descendant seen while the child ran, for the ones it leaves behind. */
+    private readonly seen;
+    private ended;
+    private watch;
+    constructor(channel: WorkerChannel, session: WorkerSession, ps: Ps, opts?: WorkerProcessHostOptions);
+    dispose(): void;
+    /** Remembers what runs under the child now. */
+    private note;
+    /**
+     * Ends what the child left running when it exited by itself: reparented
+     * to init, those commands would keep their ports and memory after its
+     * slot is freed. Only a remembered process still in the table whose
+     * parent is init, gone, or another remembered one is ended, so a pid the
+     * system has since reused is left alone.
+     */
+    private reap;
+    /**
+     * Ends the child with `signal`, and everything under it with the same:
+     * the commands an agent runs, dev servers among them, lead process
+     * groups of their own and outlive it otherwise, holding their ports
+     * after its slot is freed. Listed before the child goes, while they
+     * are still its descendants.
+     */
+    private end;
+    private told;
+    private run;
+    private pump;
+}
+/** What a {@link WorkerProcessHost} is set up with, beyond its channel. */
+export interface WorkerProcessHostOptions {
+    /** What notes the child's descendants while it runs; absent to note none. */
+    timer?: Timer | null;
+}
+/** Every process under `pid` in `table`, children first. */
+export declare function descendants(table: Pick<ProcessEntry, "pid" | "ppid">[], pid: number): number[];