@stringsync/splates 0.0.45 → 0.0.47

package/plan.d.ts

@@ -1,236 +0,0 @@
-import type { Fs } from "webappwiz/system";
-/** The plan each task keeps at its worktree root, excluded from git. */
-export declare const PLAN_FILE = "SPLATES.md";
-/** Where tasks keep their plans: each worktree's `SPLATES.md`, read through `fs`. */
-export declare class Plans {
-    private readonly fs;
-    constructor(fs: Fs);
-    /**
-     * The plan in worktree `tree`, or null for none: an agent still on arbor's
-     * skill keeps it as `ARBOR.md`, read when there is no `SPLATES.md`.
-     */
-    read(tree: string): Promise<string | null>;
-    /**
-     * Keeps plans out of git in every worktree of the repository whose shared
-     * `.git` is `gitDir`, leaving the repo's own .gitignore alone.
-     */
-    exclude(gitDir: string): Promise<void>;
-}
-/**
- * The one step under `## Next` a fresh task's `SPLATES.md` starts with, asking
- * its agent to plan, which no one should read as the work under way.
- */
-export declare const STUB_STEP = "fill in Goal and list the steps here as `- [ ]` items";
-/**
- * What an `SPLATES.md` says its task is for: the first line under `## Goal`, or
- * null when it says nothing yet. One line, since it sits beside other tasks'
- * in `splates list --files`.
- */
-export declare function goalLine(text: string): string | null;
-/**
- * What an `SPLATES.md` says done means: all of `## Goal`, as markdown, or ""
- * when it says nothing yet.
- */
-export declare function goalOf(text: string): string;
-/**
- * One `- [ ] 9.` item under `## Blocked`: something only a person can do.
- * The item's line is its subject; lines indented under it are its body, and
- * `- (a) ...`, `- [a] ...` or `- a. ...` lines among them are the answers it
- * offers.
- */
-export interface Question {
-    /** As the plan numbers it, `9`: the name a reply goes by. */
-    number: string;
-    /** Checked off, which the agent does once it has acted on the reply. */
-    done: boolean;
-    /** The item's own line, without its checkbox, number, size or reply. */
-    text: string;
-    /**
-     * How far the call reaches, from the `(large)` that leads its line, one of
-     * `SIZES` as the skill writes it; null when it has none.
-     */
-    size: string | null;
-    /**
-     * The markdown indented under it, dedented, choices left out: detail,
-     * code blocks, `![shot](/abs/path.png)` images. Empty when there is none.
-     */
-    body: string;
-    /** Whatever follows ` → `, or null when nobody has answered yet. */
-    reply: string | null;
-    /**
-     * What a person added once the reply was read, oldest first: each an
-     * indented `→ ` line under the question.
-     */
-    followUps: string[];
-    /**
-     * The answers it offers, in order. Empty for a question answered in words
-     * alone. A reply can always add words to its picks, or answer in words
-     * instead.
-     */
-    choices: Choice[];
-    /**
-     * `one` for `- (a)` choices, at most one of which a reply picks; `any` for
-     * `- [a]` choices, where it picks all that apply; `order` for `- a.`
-     * choices, which a reply puts in order, every one of them, as `b, a, c`.
-     * Null without choices.
-     */
-    pick: "one" | "any" | "order" | null;
-}
-/** One answer a question offers: `- (b) Migrate on next login`. */
-export interface Choice {
-    /** The letter it goes by: `b`. */
-    key: string;
-    /** What it says, without the `(chosen)` that may end it. */
-    text: string;
-    /**
-     * The markdown indented under it, dedented: most often the screenshot of
-     * what it would look like. Empty when there is none.
-     */
-    body: string;
-    /**
-     * Why the agent would go with it, or not: a `Why:` line under it, without
-     * the label, kept out of `body`. The page folds
-     * it away until asked. Empty when there is none.
-     */
-    why: string;
-    /**
-     * Marked `(chosen)`: what the agent went with while it waits for the reply,
-     * which picks nothing for the person.
-     */
-    chosen: boolean;
-}
-/**
- * How far a call reaches, smallest first, as the skill defines each: small
- * stays local and is cheap to redo, medium shapes a feature or spans
- * systems, large is hard to undo or outward-facing. The one place the scheme
- * lives: outcomes keep each call's size as the word it was written with, so
- * a word dropped from here still reads back from older outcomes.
- */
-export declare const SIZES: readonly ["small", "medium", "large"];
-/** `text` without the size that leads it, and that size, or null. */
-export declare function sized(text: string): {
-    text: string;
-    size: string | null;
-};
-/**
- * Every numbered item under `## Blocked`, open or checked off, each with the
- * indented lines under it. The reply is read off the item's own line: an
- * answer is one line after the arrow, which the agent writes in from the
- * user's reply in chat.
- */
-export declare function questions(text: string): Question[];
-/**
- * Every numbered item under `## Assumptions`: a call the agent made without
- * asking, written as a question is, its `(chosen)` choice the one it took.
- * Numbered in the same sequence as `## Blocked`, since a challenged one moves
- * there under its number. None of them hold up a merge.
- */
-export declare function assumptions(text: string): Question[];
-/**
- * Adds what `line` offers to `asked`, saying whether it did: an indented
- * `- (a) text` picks one, `- [a] text` picks any, and `- a. text` is put in
- * order, and a line indented past a choice's dash, such as its screenshot,
- * belongs to that choice. The first choice says which for the question. The
- * same in a plan and in a conversation, which `asked.ts` reads with this.
- */
-export declare function offers(asked: Pick<Question, "choices" | "pick">, line: string): boolean;
-/** `asked` with `body` as its own, and each choice's dedented. */
-export declare function settled(asked: Question, body: string[]): Question;
-/** Lines with the indent they all share taken off, blank ends trimmed. */
-export declare function dedent(lines: string[]): string;
-/**
- * How the person met the agent's picks under `## Blocked`: the questions
- * asked, those that offered a `(chosen)` choice and were answered with a
- * choice, and of those, the ones answered with another, and the ones answered
- * with the agent's choice but with words added, in the reply or a follow-up.
- * A moot question, or one answered in words alone, is asked but picks nothing.
- */
-export declare function picks(text: string): {
-    asked: number;
-    picked: number;
-    overturned: number;
-    amended: number;
-};
-/**
- * One call a plan made, as an outcome keeps it: enough to count how the
- * agent's recommendations fare by size, and to size it again by its line if
- * the scheme changes.
- */
-export interface Decision {
-    /** As the plan numbers it. */
-    number: string;
-    /** The item's line, without its size. */
-    text: string;
-    /** The word its line was sized with, or null for none. */
-    size: string | null;
-    /** Put to the person under `## Blocked`, or made without asking. */
-    how: "asked" | "assumed";
-    /**
-     * What became of the agent's recommendation: an assumption left alone is
-     * kept; a pick taken as it was, kept; taken with words added, amended;
-     * answered with another choice, overturned; an assumption the person
-     * challenged, challenged. Null for a question with no pick to meet, or
-     * one never answered with a choice.
-     */
-    ended: "kept" | "amended" | "overturned" | "challenged" | null;
-}
-/** Every call in the plan `text`, asked and assumed, in the order numbered. */
-export declare function decisions(text: string): Decision[];
-/**
- * How many calls the agent made without asking, and how many of them the
- * person challenged. A challenged one moves to `## Blocked` under its number
- * with a reply starting `challenged:`, so it counts in both.
- */
-export declare function assumptionCounts(text: string): {
-    made: number;
-    challenged: number;
-};
-/** What still stands between a task and trunk, as its plan tells it. */
-export interface Unfinished {
-    /** Each unchecked question under `## Blocked`, by number: `["2", "4"]`. */
-    questions: string[];
-    /** Each unchecked step under `## Next`, as written. */
-    steps: string[];
-}
-/**
- * The questions and steps a plan leaves unchecked. Nothing in either means the
- * task is ready to merge: `splates merge` lands it, and `splates escalate --review`
- * asks a person to look first. A task with no plan has nothing left.
- */
-export declare function unfinished(text: string): Unfinished;
-/** Whether {@link unfinished} found nothing left. */
-export declare function ready({ questions, steps }: Unfinished): boolean;
-/** What {@link unfinished} found, as a clause: `questions 1, 2 unchecked under ## Blocked`. */
-export declare function whatIsLeft({ questions, steps }: Unfinished): string;
-/**
- * The plan with a new open question at the end of `## Blocked`, the section
- * made if missing, numbered after the highest there or under
- * `## Assumptions`. Returns the plan and the number it went by.
- */
-export declare function withQuestion(text: string, subject: string, body?: string): {
-    plan: string;
-    number: string;
-};
-/**
- * A question's number however a person typed it: `9`, `9.`, `Q9` and `q9:`
- * all mean `9`. Null for anything that is not a number at all.
- */
-export declare function questionNumber(raw: string): string | null;
-export interface PlanOptions {
-    /** The task name the title is expected to match. */
-    task: string;
-    /**
-     * Whether the task has escalated, which makes `## Blocked` required unless
-     * it escalated for a review.
-     */
-    escalated?: boolean;
-    /** Whether the escalation asks only to approve merging. */
-    review?: boolean;
-}
-/**
- * Every way a task's `SPLATES.md` departs from the shape the agent skill
- * prescribes, phrased for the agent that wrote it. Advisory only: a resumable
- * plan is the point, and a malformed one still beats none, so nothing here
- * blocks a merge.
- */
-export declare function checkPlan(text: string, { task, escalated, review }: PlanOptions): string[];

package/port-forward.d.ts

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

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

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

@@ -1,5 +0,0 @@
-/** 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

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

@@ -1,23 +0,0 @@
-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/prompts.d.ts

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

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

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

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

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

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

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