@stringsync/splates 0.0.60 → 1.13.3

package/vendor/@stringsync/splates-server/tasks/worktree-checkouts.d.ts

@@ -0,0 +1,10 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { Git, GitResult } from "../git";
+/** Linked worktrees of the main tree, as the local worker keeps. */
+export declare class WorktreeCheckouts {
+    private readonly git;
+    private readonly fs;
+    constructor(git: Git, fs: Fs);
+    add(_task: string, branch: string, path: string, base: string): Promise<GitResult>;
+    remove(path: string, branch: string): Promise<GitResult>;
+}

package/vendor/@stringsync/splates-server/tasks/worktree-service.d.ts

@@ -0,0 +1,151 @@
+import { type Fs, type Ps } from "../../../core/system/index.js";
+import { Attachments } from "../artifacts";
+import { TaskStore } from "../board";
+import type { Config } from "../config";
+import type { Entry } from "../conversations";
+import type { Git, GitResult } from "../git";
+import type { Adherence } from "../stats";
+import { type Outcomes } from "../stats";
+import { type Log, type Storage } from "../storage";
+import { Finished } from "./finished";
+import { type DiscardOptions, type TaskState, Worktree } from "./worktree";
+/** The task `branch` is the branch of, or null for any other branch. */
+export declare function taskOf(branch: string | null): string | null;
+export interface AddOptions {
+    /** Branch the new worktree starts from. Defaults to the trunk. */
+    base?: string;
+}
+/**
+ * Where tasks live and everything persistent about them: the worktree
+ * directories, the records under `.git/splates/tasks`, and the names of tasks
+ * already removed. One name, one lookup, whatever state it turns out to be in.
+ */
+export declare class WorktreeService {
+    readonly git: Git;
+    readonly config: Config;
+    /** The project's records. */
+    readonly storage: Storage;
+    private readonly records;
+    private readonly removed;
+    private readonly conversationsDir;
+    private readonly plans;
+    /** Every task that merged or was removed here, newest kept, to look back on. */
+    readonly finished: Finished;
+    private readonly fs;
+    private readonly outcomes;
+    private readonly adherence;
+    private readonly worktrees;
+    readonly ps: Ps;
+    constructor(git: Git, config: Config, splatesDir: string, opts?: WorktreeServiceOptions);
+    /**
+     * The `splates server` conversation whose agent runs this command, when it is
+     * one of this repo's: an agent from another project's page working here
+     * is, to this repo, an agent outside the page.
+     */
+    conversation(): Promise<string | undefined>;
+    /**
+     * The persistent agent's role of the conversation `conversation()` names,
+     * as `"groomer"`, read from its log's first entry, which says what it
+     * was started for; undefined for an ordinary one, or none.
+     */
+    callerRole(): Promise<string | undefined>;
+    /** The log of the conversation `id`. */
+    conversationLog(id: string): Log<Entry>;
+    /**
+     * Where the log of conversation `id` sits on this machine, which its
+     * artifacts, not on storage yet, are kept beside.
+     */
+    conversationPath(id: string): string;
+    /** Whether the `splates server` conversation `id` is one of this repo's. */
+    holds(id: string): Promise<boolean>;
+    init(): Promise<void>;
+    get trunk(): string;
+    /** Where a task's worktree lives: a sibling of the repo, never inside it. */
+    pathFor(task: string): string;
+    branchFor(task: string): string;
+    taskFor(branch: string | null): string | null;
+    /**
+     * Where a started task's files live, beside its record: the screenshots
+     * and videos its questions show, in `tasks/<N>/started/`, apart from those
+     * it was queued with. They go when the task ends. Null for a task with
+     * no record.
+     */
+    files(task: string): Promise<Attachments | null>;
+    /**
+     * Where a task's files live when it attaches them from `conversation`:
+     * beside that conversation's artifacts, in `attached/<task>/`, so they
+     * outlive the task and a merged card's images still show.
+     */
+    attached(conversation: string, task: string): Attachments;
+    /**
+     * Every folder holding files `task` attached: its own, and one in each
+     * conversation that attached some.
+     */
+    filesOf(task: string): Promise<Attachments[]>;
+    /**
+     * The bytes `conversation` keeps on disk, its artifacts and attached
+     * files, which together are held to `artifactConversationCapacity`.
+     */
+    conversationBytes(conversation: string): Promise<number>;
+    /**
+     * Whether `path` is a file some task or conversation holds for a task:
+     * one level inside a started task's folder, or inside a conversation's
+     * `attached/<task>/`, never a record or log, and not a way out of here.
+     */
+    owns(path: string): boolean;
+    /** Always answers; the returned worktree's status says what was found. */
+    find(task: string): Promise<Worktree>;
+    /** `task` as `find` gives it, its record already read. */
+    private found;
+    /** Changes task `task`'s started record as `StartedRecords.amend` does. */
+    amend(task: string, change: (state: TaskState) => TaskState | null): Promise<void>;
+    /** Every started task's record, as it stands. */
+    states(): Promise<TaskState[]>;
+    list(): Promise<Worktree[]>;
+    /** Adds the branch and the working directory. The record comes after. */
+    add(task: string, { base }?: AddOptions): Promise<GitResult>;
+    discard(worktree: Worktree, ended: "merged" | "removed", opts?: DiscardOptions): Promise<GitResult>;
+    /**
+     * Writes what a started task's record holds, leaving what the list holds
+     * of it alone.
+     */
+    saveRecord(state: TaskState): Promise<void>;
+    /**
+     * Writes down how a task with a record ended. One with none, a stray
+     * branch or a bare directory, never ran as a task, so says nothing.
+     */
+    /**
+     * What a task leaves to read as it ends: its plan's questions and diff size.
+     */
+    private ending;
+    /**
+     * The `SPLATES.md` a task ends on: its tree's, or the copy kept in repo
+     * state for a tree on a worker; "" for none.
+     */
+    finalPlan(worktree: Worktree): Promise<string>;
+    private recordOutcome;
+    private readRecord;
+    private removedAt;
+    /**
+     * Remembers a removed name so a second `remove` can say "already removed"
+     * instead of "never existed", then drops the oldest so the list of
+     * remembered names cannot grow without bound.
+     */
+    private rememberRemoved;
+}
+/** What a `WorktreeService` works through; the real ones by default. */
+export interface WorktreeServiceOptions {
+    fs?: Fs;
+    /** The project's storage, unless `store` brings it; the files under `splatesDir`, on `fs`, by default. */
+    storage?: Storage;
+    ps?: Ps;
+    /** Where each task's ending is written down; none, and nothing is. */
+    outcomes?: Outcomes;
+    /** How closely conversations follow the skill, which an ending's findings read. */
+    adherence?: Adherence;
+    /**
+     * The numbered records: pass the list of tasks' own so neither undoes
+     * the other's writes. One of its own by default.
+     */
+    store?: TaskStore;
+}

package/vendor/@stringsync/splates-server/tasks/worktree.d.ts

@@ -0,0 +1,342 @@
+import type { AutoPicked } from "../auto-pick";
+import type { Git, GitResult } from "../git";
+import type { TimedTest } from "../merge";
+import { type ComingConflict } from "./conflicts";
+import { type FileDiff } from "./diff";
+import type { FinishedTask } from "./finished";
+import type { WorktreeService } from "./worktree-service";
+/**
+ * One task, whether or not it is still there. Commands ask the service for
+ * one of these and read its status rather than assembling the same handful of
+ * existence checks themselves.
+ */
+export declare class Worktree {
+    private readonly service;
+    private readonly snapshot;
+    constructor(service: WorktreeService, snapshot: WorktreeSnapshot);
+    /** Latest background prediction, independent of the task's lease. */
+    comingConflict(): Promise<ComingConflict | null>;
+    /** Tasks that finished on this repo, newest first. */
+    landed(): Promise<FinishedTask[]>;
+    get task(): string;
+    get branch(): string;
+    /** Where this task's work lands: its recorded base branch, else trunk. */
+    get base(): string;
+    /** The conversation whose agent added the task, or null. */
+    get caller(): string | null;
+    get path(): string;
+    get state(): TaskState | null;
+    get lease(): LeaseState | null;
+    /** The `splates server` conversation whose agent last took the task, or null. */
+    get takenBy(): string | null;
+    get leaseHeld(): boolean;
+    /**
+     * Where its merge stands before landing, while the merge that wrote it
+     * still runs; null otherwise.
+     */
+    get gate(): Gate | null;
+    /** When the merge under way was asked for, while it still runs; null otherwise. */
+    get mergeSince(): string | null;
+    /** The place in line of the merge under way while it waits for the lock, 1 next; null otherwise. */
+    get mergePlace(): number | null;
+    /** How far the merge under way has got, while it still runs; null otherwise. */
+    get mergeSteps(): MergeProgress | null;
+    get leaseStatus(): "held" | "stale" | "none";
+    get leaseOurs(): boolean;
+    get leaseHeldByOther(): boolean;
+    get mergeAttempts(): number;
+    /** How many merge attempts a task gets before `merge` stops on `budget_exhausted`. */
+    get mergeAttemptLimit(): number;
+    get conflictAttempts(): number;
+    /** How many conflicted rebases a task gets before `merge` stops on `budget_exhausted`. */
+    get conflictAttemptLimit(): number;
+    /** Whether either budget is spent, so only `retry` lets it merge again. */
+    get budgetSpent(): boolean;
+    get exists(): boolean;
+    get hasBranch(): boolean;
+    get removedAt(): string | null;
+    /** The git its branch is read through. */
+    get git(): Git;
+    get status(): WorktreeStatus;
+    get gone(): boolean;
+    /**
+     * Merges changes into the record and writes it. Works on a name that has no
+     * record yet, which is how `add` writes the first one and how `claim`
+     * rebuilds one from a worktree found on disk.
+     */
+    save(changes?: Partial<TaskState>): Promise<Worktree>;
+    take(changes?: Partial<TaskState>): Promise<Worktree>;
+    /** Re-reads from disk. `merge` needs this: the record is the truth. */
+    reload(): Promise<Worktree>;
+    /**
+     * Removes the directory, the branch, and the record; remembers the name,
+     * and how the task ended.
+     */
+    discard(ended: "merged" | "removed", opts?: DiscardOptions): Promise<GitResult>;
+    /**
+     * Points its base branch at `commit`, in the repository its branch is
+     * in: the main tree's, or its clone's, whose branches are its own.
+     */
+    moveBase(commit: string): Promise<GitResult>;
+    /** The message of each commit it has that its base does not, oldest first. */
+    commitMessages(): Promise<string[] | null>;
+    commitsAhead(): Promise<number | null>;
+    /** Files and lines across all its pending work, as `diff` shows it; null without a branch. */
+    size(): Promise<DiffSize | null>;
+    /**
+     * Its committed and uncommitted changes, new files among them, parsed;
+     * null without a branch.
+     */
+    diff(): Promise<FileDiff[] | null>;
+    /** Committed and uncommitted paths this task touches; null without a branch. */
+    changedFiles(): Promise<string[] | null>;
+    uncommitted(): Promise<string[]>;
+    /** When its branch's latest commit was made, or null without a branch. */
+    committedAt(): Promise<string | null>;
+    interruptedOps(): Promise<string[]>;
+}
+export interface DiscardOptions {
+    /** The tasks sharing the landing gate, leader first; absent for a solo merge. */
+    batch?: string[];
+    /**
+     * The `splates server` conversation working on it, when ended from the page
+     * rather than by the agent, whose env names it.
+     */
+    conversation?: string;
+    /**
+     * The message of each commit a merge lands, read before landing.
+     */
+    commits?: string[];
+    /** Why it was removed, as `splates remove --reason` gives it. */
+    reason?: RemoveReason;
+    /**
+     * Whether the queued task it started from goes back to ready or the
+     * backlog rather than the queue, as when the person removes it.
+     */
+    unqueue?: boolean;
+    /** The commit a merge landed it as. */
+    commit?: string;
+    /** What a merge lands, read before landing. */
+    size?: DiffSize;
+    /** Each test the merge's passing gate run timed, from its JUnit report. */
+    testTimes?: TimedTest[];
+    /** How long the merge that lands it queued and ran, up to landing. */
+    merge?: MergeTimes;
+}
+/**
+ * How long a landing merge took: waiting its turn for the machine's premerge
+ * lock, then the rest of it, the gate, its retests and landing.
+ */
+export interface MergeTimes {
+    queuedMs: number;
+    ranMs: number;
+}
+/** How big a change is, as its diff counts it. */
+export interface DiffSize {
+    files: number;
+    added: number;
+    removed: number;
+}
+/** Why a task can be removed rather than merged, as `--reason` names it. */
+export declare const REMOVE_REASONS: readonly ["nothing", "moot", "superseded", "redo", "blocked"];
+/** Why a task was removed rather than merged. */
+export type RemoveReason = (typeof REMOVE_REASONS)[number];
+/** The status a task's own record carries. */
+export type RecordStatus = "working" | "merging";
+/** Where a merge stands before it lands, as `TaskState.gate` keeps it. */
+export type Gate = "queued" | "running";
+/**
+ * A step of a merge, in the order a merge takes them: rebasing onto its base
+ * and squashing, running the checks that come before the line, waiting its
+ * turn for the premerge lock, running the premerge, landing on the base, and
+ * finishing up, its worktree removed.
+ */
+export type MergeStep = "rebase" | "check" | "wait" | "test" | "land" | "finish";
+/** Every step a merge may take, in order, for a page to list those to come. */
+export declare const MERGE_STEPS: readonly MergeStep[];
+/** A phase the premerge timed while it runs, from its `SPLATES_GATE_PHASES` lines. */
+export interface LivePhase {
+    phase: string;
+    /** When it started; absent for a command that times its phases only once they end. */
+    at?: string;
+    /** How long it took, once it ended. */
+    ms?: number;
+    /** The phase it runs inside of, beside its siblings. */
+    within?: string;
+}
+/** How far the merge under way has got, as `TaskState.mergeSteps` keeps it. */
+export interface MergeProgress {
+    /**
+     * Each step it reached, in order, with when it began; the last runs now.
+     * A step that runs a command names the file it prints to, `output`. A
+     * premerge run in another merge's batch, which split before it landed,
+     * is `dissolved`: the branch's own turn was still to come.
+     */
+    steps: {
+        step: MergeStep;
+        at: string;
+        output?: string;
+        dissolved?: true;
+    }[];
+    /** The premerge's phases so far, while it tests. */
+    phases?: LivePhase[];
+}
+/** What a task's record stores about who is driving it. */
+export interface LeaseState {
+    pid: number;
+    hostname: string;
+    heartbeatAt: string;
+    /**
+     * The `splates server` conversation whose agent took it, or its caller's for a
+     * subagent; absent for an agent outside the page, and in older records.
+     */
+    conversation?: string;
+}
+/**
+ * A hand-over to a person from before `splates escalate` was retired, which
+ * old records still carry for the Stats page.
+ */
+export interface Escalation {
+    reason: string;
+    at: string;
+    /**
+     * Whether it was handed over to be approved rather than to answer
+     * questions; the reason then says what to look at.
+     */
+    review?: true | string;
+    /**
+     * When `claim` took the task back up, ending the wait on a person; absent
+     * while it waits, and in records from before it was kept.
+     */
+    resumedAt?: string;
+}
+/** Why a merge failed, as `merge` refuses it. */
+export type MergeFailure = "conflict" | "tests_failed" | "merge_failed";
+/** A test the gate named as failing, and what it said, as far as the runner printed. */
+export interface FailedTest {
+    name: string;
+    message: string;
+    /** The test file, when the runner located it. */
+    file?: string;
+}
+/** One time `merge` turned a task away, and what it said of why. */
+export interface GateFailure {
+    reason: MergeFailure | "budget_exhausted";
+    at: string;
+    /** The files the rebase conflicted in, for a conflict. */
+    files?: string[];
+    /** What git said, for a conflict that named no file: why the rebase failed. */
+    output?: string;
+    /** The tests the gate named as failing, for `tests_failed`. */
+    tests?: string[];
+    /** Those tests with what each said, for `tests_failed`. Absent in old records. */
+    failures?: FailedTest[];
+    /** What git said, for `merge_failed`. */
+    error?: string;
+    /** The base commit the gate ran on, for `tests_failed`. Absent in old records. */
+    rebasedOnto?: string;
+    /** Whether the failure spent a merge attempt, for `tests_failed`. Absent in old records. */
+    charged?: boolean;
+}
+export interface TaskState {
+    /** Its number, which it shares with the queued task it started from; absent until first saved. */
+    id?: number;
+    task: string;
+    branch: string;
+    worktree: string;
+    /** The branch this task lands on. Absent in old records: trunk. */
+    base?: string;
+    status: RecordStatus;
+    lease: LeaseState | null;
+    mergeAttempts: number;
+    /**
+     * Conflicted rebases since the last `retry`, spent from their own
+     * budget instead of `mergeAttempts`. Absent in old records: none.
+     */
+    conflictAttempts?: number;
+    /**
+     * How many merges failed in all, those before a `retry` gave the
+     * attempts back too. Absent in old records: none counted yet.
+     */
+    mergeFailures?: number;
+    /** `mergeFailures` by why each failed. Absent in old records. */
+    mergeFailuresBy?: Partial<Record<MergeFailure, number>>;
+    /**
+     * Each time the gate turned it away, oldest first, with what it named:
+     * every failed merge, and each refusal once its attempts ran out. Absent in
+     * old records.
+     */
+    gateFailures?: GateFailure[];
+    /** How many times `splates retry` granted it more attempts. Absent in old records. */
+    retries?: number;
+    /**
+     * Where a merge under way stands before it lands: waiting its turn for the
+     * machine's premerge lock, or holding it to test. Absent otherwise.
+     */
+    gate?: Gate;
+    /** When the merge under way was asked for, its wait for the lock included. Absent otherwise. */
+    mergeSince?: string;
+    /** Its place in line for the lock while it waits, 1 being next. Absent otherwise. */
+    mergePlace?: number;
+    /** The steps the merge under way has taken, and its premerge's phases. Absent otherwise. */
+    mergeSteps?: MergeProgress;
+    createdAt: string;
+    updatedAt: string;
+    escalations?: Escalation[];
+    /**
+     * The agent `splates server` handed the task to, for it to start.
+     */
+    dispatch?: Dispatched;
+    /**
+     * The `splates server` conversation whose agent added the task, which the page
+     * nests it under. Absent for one added outside a conversation, or before
+     * tasks remembered it.
+     */
+    caller?: string;
+    machine?: string;
+    stranded?: unknown[];
+    rescued?: unknown[];
+    /** The last Auto pick for it, beside what it was queued as; for reading only. */
+    autoPick?: AutoPicked;
+}
+/**
+ * The agent `splates server` handed a task to, as its queue starts each. `splates server` starts the agent in
+ * the task's tree and writes down the conversation it started, so it starts
+ * once.
+ */
+export interface Dispatched {
+    agent: string;
+    /** The model to pick, by the session's model setting; absent, the agent's own. */
+    model?: string;
+    /** The thinking level, by the session's thought_level setting; absent, the agent's own. */
+    effort?: string;
+    /** What the agent is told beyond claiming the task. */
+    prompt?: string;
+    /** The conversation `splates server` started, once it has. */
+    conversation?: string;
+    /**
+     * The conversation `splates server`'s queue held for the queued task,
+     * which takes the task rather than a new one; absent for none.
+     */
+    held?: string;
+    /** Whether the postCheckout hook is still readying the tree; `splates server` starts the agent once it is not. */
+    pending?: true;
+}
+/**
+ * Everything a name can turn out to be. The record's own status when the
+ * task is intact, and otherwise the way in which it is not.
+ */
+export type WorktreeStatus = RecordStatus | "absent" | "removed" | "orphaned" | "stray" | "unrecorded" | "unknown";
+/** What the service found on disk. */
+export interface WorktreeSnapshot {
+    task: string;
+    branch: string;
+    path: string;
+    state: TaskState | null;
+    exists: boolean;
+    hasBranch: boolean;
+    removedAt: string | null;
+    corrupt: boolean;
+    /** As `Worktree.git`. */
+    git: Git;
+}

package/vendor/@stringsync/splates-server/terminal/connection.d.ts

@@ -0,0 +1,19 @@
+import type { Connection } from "../server/shared";
+import type { Shell } from "./shell";
+/**
+ * One terminal's socket, which shows a `Shell`: bytes both ways are the
+ * shell's own; text is for what is not, as JSON: a resize or a question
+ * from the page, the shell's exit code and the job in front, null at a
+ * prompt, from here.
+ */
+export declare class TerminalConnection implements Connection {
+    private readonly shell;
+    /** Whether the page comes back to a shell it had, which redraws for it. */
+    private readonly back;
+    constructor(shell: Shell, 
+    /** Whether the page comes back to a shell it had, which redraws for it. */
+    back: boolean);
+    open(socket: Bun.ServerWebSocket<Connection>): void;
+    message(socket: Bun.ServerWebSocket<Connection>, message: string | Buffer<ArrayBuffer>): void;
+    closed(socket: Bun.ServerWebSocket<Connection>): void;
+}

package/vendor/@stringsync/splates-server/terminal/held.d.ts

@@ -0,0 +1,22 @@
+import type { ProcessEntry } from "../../../core/system/index.js";
+/** A command a restart would kill: where it runs, and what it runs. */
+export interface Held {
+    /** The agent that left it running, or `terminal` for a page's shell. */
+    where: string;
+    command: string;
+}
+/**
+ * What a restart would kill, from the process table: the job in front in
+ * each of the page's `shells`, and each command an idle agent in `agents`
+ * left running, in a shell under the agent leading a process group of its
+ * own, as an agent runs each command. Its MCP servers, and the shells and
+ * browsers they start in the agent's group, are not commands it ran, so they
+ * hold nothing.
+ */
+export declare function heldBy(table: ProcessEntry[], { shells, agents, }: {
+    shells: number[];
+    agents: {
+        name: string;
+        pid: number;
+    }[];
+}): Held[];

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

@@ -0,0 +1,7 @@
+export type { Held } from "./held";
+export { heldBy } from "./held";
+export { Pty } from "./pty";
+export { RemotePty } from "./remote-pty";
+export type { KeptShell } from "./shell";
+export { Shell } from "./spawn";
+export { Terminals } from "./terminal";

package/vendor/@stringsync/splates-server/terminal/pty.d.ts

@@ -0,0 +1,45 @@
+import type { AsyncResource } from "../../../core/disposable/index.js";
+import { type Eventful } from "../../../core/events/index.js";
+import type { Ps } from "../../../core/system/index.js";
+/** 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("../../../core/events/index.js").Events<PtyEvents>;
+    private readonly child;
+    private held;
+    constructor({ argv, cwd, cols, rows, env, ps, }: PtyOptions);
+    /** The shell's pid, for the job it runs. */
+    get pid(): number;
+    /**
+     * Stops reading the shell's output until `until` settles, so a full pipe
+     * makes the shell wait; call it from a `data` handler.
+     */
+    hold(until: Promise<void>): void;
+    /** 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/vendor/@stringsync/splates-server/terminal/remote-pty.d.ts

@@ -0,0 +1,34 @@
+import type { AsyncResource } from "../../../core/disposable/index.js";
+import { type Eventful } from "../../../core/events/index.js";
+import type { ProcessHandle } from "../agents";
+import type { WorkerChannel, WorkerSession } from "../workers";
+import type { PtyEvents } from "./pty";
+/**
+ * A shell on a worker's pseudo-terminal, seen from the server 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 worker;
+    /** Given for a shell taken back, whose `describe` waits for the worker to join. */
+    private readonly resumedOn;
+    private readonly dispatcher;
+    readonly events: import("../../../core/events/index.js").Events<PtyEvents>;
+    private _pid;
+    private exited;
+    /** What takes it back after a server restart. */
+    get handle(): ProcessHandle;
+    constructor(channel: WorkerChannel, worker: string, 
+    /** Given for a shell taken back, whose `describe` waits for the worker to join. */
+    resumedOn?: WorkerSession | null);
+    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;
+}