@camerontaylor/paseo-client 0.8.0-fork.1 → 0.9.0-beta.2.fork.1

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import type { OwnedSubscription } from "./connection/index.js";
+export type { OwnedSubscription, SubscriptionObserver } from "./connection/index.js";
 import type { DaemonClientConfig } from "./daemon-client.js";
 import type { AgentPermissionResponse } from "@camerontaylor/paseo-protocol/agent-types";
 import type { AgentSnapshotPayload, CreationSnapshot, CreateAgentRequestMessage, FetchWorkspacesRequestMessage, FetchWorkspacesResponseMessage, GetProvidersSnapshotResponseMessage, ListAvailableProvidersResponse, ListCommandsResponse, ListProviderFeaturesRequestMessage, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ProjectListRequestMessage, ProjectListResponseMessage, ListProviderModesResponseMessage, MutableDaemonConfig, MutableDaemonConfigPatch, ProviderDiagnosticResponseMessage, ProviderUsageListResponseMessage, ProjectPlacementPayload, WorkspaceProjectDescriptorPayload, RefreshProvidersSnapshotResponseMessage, SendAgentMessageRequest, SessionOutboundMessage, WorkspaceDescriptorPayload, WorkspaceCreateRequest } from "@camerontaylor/paseo-protocol/messages";
@@ -61,6 +63,7 @@ export type PaseoProjectUpdate = Extract<SessionOutboundMessage, {
 }>["payload"];
 export type PaseoProjectUpdateHandler = (update: PaseoProjectUpdate) => void;
 export interface PaseoAgentListResult {
+    subscription?: OwnedSubscription<PaseoAgentListResult>;
     requestId: string;
     subscriptionId?: string | null;
     entries: FetchAgentsEntry[];
@@ -70,6 +73,7 @@ export type PaseoWorkspaceListOptions = Omit<FetchWorkspacesRequestMessage, "typ
     requestId?: string;
 };
 export interface PaseoWorkspaceListResult {
+    subscription?: OwnedSubscription<PaseoWorkspaceListResult>;
     requestId: string;
     subscriptionId?: string | null;
     entries: PaseoWorkspace[];
@@ -125,6 +129,12 @@ export interface PaseoProjectActions {
     subscribe(handler: PaseoProjectUpdateHandler): () => void;
 }
 export interface PaseoWorkspaceActions {
+    list(options: PaseoWorkspaceListOptions & {
+        subscribe: {};
+    }): Promise<PaseoWorkspaceListResult & {
+        subscriptionId: string;
+        subscription: OwnedSubscription<PaseoWorkspaceListResult>;
+    }>;
     list(options?: PaseoWorkspaceListOptions): Promise<PaseoWorkspaceListResult>;
     ref(workspace: string | PaseoWorkspace): PaseoWorkspaceHandle;
     open(input: string | PaseoWorkspaceOpenOptions, requestId?: string): Promise<PaseoWorkspaceHandle>;
@@ -217,6 +227,18 @@ export type PaseoAgentTimelineEvent = PaseoAgentStream | {
         type: "replacement";
         epoch: string;
     };
+} | {
+    agentId: string;
+    subscriptionId: string;
+    event: {
+        type: "subscription_restored";
+    };
+} | {
+    agentId: string;
+    event: {
+        type: "error";
+        error: string;
+    };
 };
 export type PaseoAgentTimelineSubscription = ReturnType<DaemonClient["subscribeAgentTimeline"]>;
 export interface PaseoAgentTimelineHandle {
@@ -231,8 +253,10 @@ export interface PaseoAgentTimelineHandle {
      */
     refetch(options?: PaseoAgentTimelineRefetchOptions): Promise<FetchAgentTimelinePayload>;
     /**
-     * Subscribe to this agent and restore demand after reconnect. A replacement
-     * event invalidates previously fetched history; refetch the page you need.
+     * Delivers live events only. After reconnect, subscription_restored precedes
+     * subsequent updates. History may have been missed; use refetch() to request
+     * the range you need. No history is fetched automatically. A replacement event
+     * invalidates the previous epoch. Subscription errors release this observation.
      * Await the returned unsubscribe function's `ready` promise before starting
      * work that must be observed. It rejects if establishment fails.
      */
@@ -283,6 +307,12 @@ export interface PaseoAgentHandle {
     subscribe(handler: (update: PaseoAgentUpdate) => void): () => void;
 }
 export interface PaseoAgentActions {
+    list(options: PaseoAgentListOptions & {
+        subscribe: {};
+    }): Promise<PaseoAgentListResult & {
+        subscriptionId: string;
+        subscription: OwnedSubscription<PaseoAgentListResult>;
+    }>;
     list(options?: PaseoAgentListOptions): Promise<PaseoAgentListResult>;
     ref(agent: string | PaseoAgent): PaseoAgentHandle;
     create(options: PaseoAgentCreateOptions): Promise<PaseoAgentHandle>;
@@ -365,6 +395,8 @@ export interface PaseoConfigActions {
     }>;
 }
 export interface PaseoApi {
+    dispose(): Promise<void>;
+    observeEvents: DaemonClient["observeEvents"];
     readonly terminals: PaseoTerminalActions;
     readonly workspaces: PaseoWorkspaceActions;
     readonly projects: PaseoProjectActions;
@@ -379,5 +411,7 @@ export interface PaseoClient extends PaseoApi {
     getConnectionState(): ConnectionState;
 }
 export declare function createPaseoClient(config: PaseoClientConfig): PaseoClient;
-export declare function createPaseoApi(daemonClient: DaemonClient): PaseoApi;
+export declare function createPaseoApi(daemonClient: DaemonClient, scopeOptions?: {
+    signal?: AbortSignal;
+}): PaseoApi;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -11,10 +11,18 @@ export function createPaseoClient(config) {
         clientId: config.clientId ?? createGeneratedClientId(),
         clientType: "cli",
     });
+    const api = createPaseoApi(daemonClient);
     return {
-        ...createPaseoApi(daemonClient),
+        ...api,
         connect: () => daemonClient.connect(),
-        close: () => daemonClient.close(),
+        close: async () => {
+            try {
+                await api.dispose();
+            }
+            finally {
+                await daemonClient.close();
+            }
+        },
         ensureConnected: () => daemonClient.ensureConnected(),
         getConnectionState: () => daemonClient.getConnectionState(),
     };
@@ -38,8 +46,40 @@ function toDaemonAgentCreateOptions(options, placement) {
         ...(prompt !== undefined ? { initialPrompt: prompt } : {}),
     };
 }
-export function createPaseoApi(daemonClient) {
-    const createAgentHandle = createAgentHandleFactory(daemonClient);
+export function createPaseoApi(daemonClient, scopeOptions) {
+    const handles = new Set();
+    const agentListeners = new Set();
+    const workspaceListeners = new Set();
+    const lifetime = new AbortController();
+    const own = (create) => {
+        if (lifetime.signal.aborted)
+            throw new Error("Paseo API is disposed");
+        const handle = create();
+        handles.add(handle);
+        const release = handle.release.bind(handle);
+        handle.release = async () => {
+            await release();
+            handles.delete(handle);
+        };
+        return handle;
+    };
+    const listenAgents = (handler) => {
+        if (lifetime.signal.aborted)
+            throw new Error("Paseo API is disposed");
+        agentListeners.add(handler);
+        return () => {
+            agentListeners.delete(handler);
+        };
+    };
+    const listenWorkspaces = (handler) => {
+        if (lifetime.signal.aborted)
+            throw new Error("Paseo API is disposed");
+        workspaceListeners.add(handler);
+        return () => {
+            workspaceListeners.delete(handler);
+        };
+    };
+    const createAgentHandle = createAgentHandleFactory(daemonClient, listenAgents, (agentId, handler) => own(() => daemonClient.subscribeAgentTimeline(agentId, handler)));
     const createAgent = async (options, placement) => {
         const agent = await daemonClient.createAgent(toDaemonAgentCreateOptions(options, placement));
         return createAgentHandle(agent);
@@ -51,17 +91,88 @@ export function createPaseoApi(daemonClient) {
         }
         return workspace.workspaceDirectory;
     });
-    const createWorkspaceHandle = createWorkspaceHandleFactory(daemonClient, createAgent, terminals);
+    const createWorkspaceHandle = createWorkspaceHandleFactory(daemonClient, createAgent, terminals, listenWorkspaces);
+    let disposal = null;
+    const dispose = () => {
+        if (disposal)
+            return disposal;
+        lifetime.abort();
+        scopeOptions?.signal?.removeEventListener("abort", abort);
+        agentListeners.clear();
+        workspaceListeners.clear();
+        disposal = Promise.allSettled([...handles].map((handle) => handle.release())).then((results) => {
+            handles.clear();
+            const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+            if (failures.length)
+                throw new AggregateError(failures, "Failed to release API subscriptions");
+            return undefined;
+        });
+        return disposal;
+    };
+    const abort = () => {
+        void dispose().catch((error) => console.error("API subscription cleanup failed", error));
+    };
+    if (scopeOptions?.signal?.aborted)
+        abort();
+    else
+        scopeOptions?.signal?.addEventListener("abort", abort, { once: true });
+    const observeEvents = (events, options) => own(() => daemonClient.observeEvents(events, options));
+    const subscribeEvent = (event, update) => {
+        const observation = observeEvents([event]);
+        observation.subscribe({ snapshot: () => { }, update });
+        return () => {
+            void observation
+                .release()
+                .catch((error) => console.error("Event subscription cleanup failed", error));
+        };
+    };
+    async function listWorkspaces(options) {
+        if (!options?.subscribe)
+            return daemonClient.fetchWorkspaces(options);
+        if (options.subscribe.subscriptionId !== undefined)
+            throw new Error("Subscription IDs are assigned by the host");
+        const subscription = own(() => daemonClient.observeWorkspaces(options));
+        subscription.subscribe({
+            snapshot: () => { },
+            update: (message) => {
+                if (message.type === "workspace_update")
+                    for (const listener of workspaceListeners)
+                        listener(message.payload);
+            },
+        });
+        return { ...(await subscription.ready), subscription };
+    }
+    async function listAgents(options) {
+        if (!options?.subscribe)
+            return daemonClient.fetchAgents(options);
+        if (options.subscribe.subscriptionId !== undefined)
+            throw new Error("Subscription IDs are assigned by the host");
+        const subscription = own(() => daemonClient.observeAgents(options));
+        subscription.subscribe({
+            snapshot: () => { },
+            update: (message) => {
+                if (message.type === "agent_update")
+                    for (const listener of agentListeners)
+                        listener(message.payload);
+            },
+        });
+        return { ...(await subscription.ready), subscription };
+    }
     return {
+        dispose,
+        observeEvents,
         terminals,
         projects: {
             list: (options) => daemonClient.listProjects(options),
-            subscribe: (handler) => daemonClient.on("project.update", (message) => {
-                handler(message.payload);
-            }),
+            subscribe: (handler) => {
+                return subscribeEvent("project.update", (message) => {
+                    if (message.type === "project.update")
+                        handler(message.payload);
+                });
+            },
         },
         workspaces: {
-            list: (options) => daemonClient.fetchWorkspaces(options),
+            list: listWorkspaces,
             ref: (workspace) => createWorkspaceHandle(workspace),
             open: (input, requestId) => openWorkspace(daemonClient, createWorkspaceHandle, input, requestId),
             create: async ({ requestId, agent, ...options }) => {
@@ -72,17 +183,13 @@ export function createPaseoApi(daemonClient) {
                 return createWorkspaceHandle(result.workspace);
             },
             archive: (workspace, requestId) => daemonClient.archiveWorkspace(resolveWorkspaceId(workspace), requestId),
-            subscribe: (handler) => daemonClient.on("workspace_update", (message) => {
-                handler(message.payload);
-            }),
+            subscribe: listenWorkspaces,
         },
         agents: {
-            list: (options) => daemonClient.fetchAgents(options),
+            list: listAgents,
             ref: (agent) => createAgentHandle(agent),
             create: (options) => createAgent(options),
-            subscribe: (handler) => daemonClient.on("agent_update", (message) => {
-                handler(message.payload);
-            }),
+            subscribe: listenAgents,
         },
         providers: {
             listModels: (provider, options) => daemonClient.listProviderModels(provider, options),
@@ -93,13 +200,16 @@ export function createPaseoApi(daemonClient) {
             },
             listAvailable: (options) => daemonClient.listAvailableProviders(options),
             snapshot: (options) => daemonClient.getProvidersSnapshot(options),
-            waitForReady: (options) => waitForProvidersReady(daemonClient, options),
+            waitForReady: (options) => waitForProvidersReady(daemonClient, observeEvents(["providers_snapshot_update"]), lifetime.signal, options),
             refresh: (options) => daemonClient.refreshProvidersSnapshot(options),
             diagnostic: (provider, options) => daemonClient.getProviderDiagnostic(provider, options),
             listUsage: (options) => listProviderUsage(daemonClient, options),
-            subscribe: (handler) => daemonClient.on("providers_snapshot_update", (message) => {
-                handler(message.payload);
-            }),
+            subscribe: (handler) => {
+                return subscribeEvent("providers_snapshot_update", (message) => {
+                    if (message.type === "providers_snapshot_update")
+                        handler(message.payload);
+                });
+            },
         },
         config: {
             get: (requestId) => daemonClient.getDaemonConfig(requestId),
@@ -107,7 +217,7 @@ export function createPaseoApi(daemonClient) {
         },
     };
 }
-function createWorkspaceHandleFactory(daemonClient, createAgent, terminals) {
+function createWorkspaceHandleFactory(daemonClient, createAgent, terminals, listen) {
     return (workspace) => {
         const id = typeof workspace === "string" ? workspace : workspace.id;
         let current = typeof workspace === "string" ? null : workspace;
@@ -167,21 +277,19 @@ function createWorkspaceHandleFactory(daemonClient, createAgent, terminals) {
                 }
                 return result;
             },
-            subscribe: (handler) => daemonClient.on("workspace_update", (message) => {
-                const update = message.payload;
+            subscribe: (handler) => listen((update) => {
                 if (update.kind === "upsert" && update.workspace.id === id) {
                     current = update.workspace;
                     handler(update);
                 }
                 if (update.kind === "remove" && update.id === id) {
-                    current = null;
                     handler(update);
                 }
             }),
         };
     };
 }
-function createAgentHandleFactory(daemonClient) {
+function createAgentHandleFactory(daemonClient, listen, subscribeTimeline) {
     return (agent) => {
         const id = typeof agent === "string" ? agent : agent.id;
         let current = typeof agent === "string" ? null : agent;
@@ -196,13 +304,27 @@ function createAgentHandleFactory(daemonClient) {
                     }
                     return result;
                 },
-                subscribe: (handler) => daemonClient.subscribeAgentTimeline(id, (message) => {
-                    handler(message.type === "agent_stream"
-                        ? message.payload
-                        : {
-                            agentId: message.payload.agentId,
-                            event: { type: "replacement", epoch: message.payload.epoch },
-                        });
+                subscribe: (handler) => subscribeTimeline(id, (message) => {
+                    switch (message.type) {
+                        case "agent_stream":
+                            return handler(message.payload);
+                        case "agent.timeline.subscription_restored":
+                            return handler({
+                                agentId: id,
+                                subscriptionId: message.payload.subscriptionId,
+                                event: { type: "subscription_restored" },
+                            });
+                        case "agent.timeline.error":
+                            return handler({
+                                agentId: id,
+                                event: { type: "error", error: message.payload.error },
+                            });
+                        case "agent.timeline.replacement":
+                            return handler({
+                                agentId: id,
+                                event: { type: "replacement", epoch: message.payload.epoch },
+                            });
+                    }
                 }),
             },
             get workspaceId() {
@@ -280,14 +402,12 @@ function createAgentHandleFactory(daemonClient) {
             detach: async () => {
                 await daemonClient.detachAgent(id);
             },
-            subscribe: (handler) => daemonClient.on("agent_update", (message) => {
-                const update = message.payload;
+            subscribe: (handler) => listen((update) => {
                 if (update.kind === "upsert" && update.agent.id === id) {
                     current = update.agent;
                     handler(update);
                 }
                 if (update.kind === "remove" && update.agentId === id) {
-                    current = null;
                     handler(update);
                 }
             }),
@@ -326,77 +446,88 @@ function listProviderUsage(daemonClient, options) {
     }
     return daemonClient.listProviderUsage(options);
 }
-function waitForProvidersReady(daemonClient, options = {}) {
-    // COMPAT(providersSnapshotCwd): added in v0.3.2, remove gate after 2027-02-10.
-    if (daemonClient.getLastServerInfoMessage()?.features?.providersSnapshotCwd !== true) {
-        return Promise.reject(new Error("Update the host to wait for provider discovery."));
-    }
+async function waitForProvidersReady(daemonClient, observation, signal, options = {}) {
     const { timeoutMs = 60000, ...snapshotOptions } = options;
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        let requestId = null;
-        let snapshotCwd;
-        const pendingUpdates = new Map();
-        let latestEntries = [];
-        const cleanup = () => {
-            clearTimeout(timeout);
-            unsubscribe();
-        };
-        const finish = (snapshot) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(snapshot);
-        };
-        const fail = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(error instanceof Error ? error : new Error(String(error)));
-        };
-        const updateMatches = (update) => update.cwd === snapshotCwd;
-        const unsubscribe = daemonClient.on("providers_snapshot_update", (message) => {
-            const update = message.payload;
-            if (!requestId) {
-                pendingUpdates.set(update.cwd, update);
-                return;
-            }
-            if (!updateMatches(update))
-                return;
-            latestEntries = update.entries;
-            if (update.entries.some((entry) => entry.status === "loading"))
-                return;
-            finish({ ...update, requestId });
+    try {
+        await observation.ready;
+        signal.throwIfAborted();
+        return await new Promise((resolve, reject) => {
+            let settled = false;
+            let requestId = null;
+            let snapshotCwd;
+            const pendingUpdates = new Map();
+            let latestEntries = [];
+            const cleanup = () => {
+                clearTimeout(timeout);
+                unsubscribe();
+                signal.removeEventListener("abort", abort);
+            };
+            const finish = (snapshot) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(snapshot);
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(error instanceof Error ? error : new Error(String(error)));
+            };
+            const updateMatches = (update) => update.cwd === snapshotCwd;
+            const unsubscribe = observation.subscribe({
+                snapshot: () => { },
+                update: (message) => {
+                    if (message.type !== "providers_snapshot_update")
+                        return;
+                    const update = message.payload;
+                    if (!requestId) {
+                        pendingUpdates.set(update.cwd, update);
+                        return;
+                    }
+                    if (!updateMatches(update))
+                        return;
+                    latestEntries = update.entries;
+                    if (update.entries.some((entry) => entry.status === "loading"))
+                        return;
+                    finish({ ...update, requestId });
+                },
+            });
+            const abort = () => fail(new Error("Paseo API is disposed"));
+            signal.addEventListener("abort", abort, { once: true });
+            const timeout = setTimeout(() => {
+                const loading = latestEntries
+                    .filter((entry) => entry.status === "loading")
+                    .map((entry) => entry.provider)
+                    .join(", ");
+                fail(new Error(loading
+                    ? `Timed out waiting for providers: ${loading}`
+                    : "Timed out waiting for provider discovery"));
+            }, timeoutMs);
+            void daemonClient
+                .getProvidersSnapshot(snapshotOptions)
+                .then((snapshot) => {
+                requestId = snapshot.requestId;
+                snapshotCwd = snapshot.cwd;
+                latestEntries = snapshot.entries;
+                if (!snapshot.entries.some((entry) => entry.status === "loading")) {
+                    finish(snapshot);
+                    return;
+                }
+                const pendingUpdate = pendingUpdates.get(snapshotCwd);
+                if (pendingUpdate && !pendingUpdate.entries.some((entry) => entry.status === "loading")) {
+                    finish({ ...pendingUpdate, requestId });
+                }
+                return undefined;
+            })
+                .catch(fail);
         });
-        const timeout = setTimeout(() => {
-            const loading = latestEntries
-                .filter((entry) => entry.status === "loading")
-                .map((entry) => entry.provider)
-                .join(", ");
-            fail(new Error(loading
-                ? `Timed out waiting for providers: ${loading}`
-                : "Timed out waiting for provider discovery"));
-        }, timeoutMs);
-        void daemonClient
-            .getProvidersSnapshot(snapshotOptions)
-            .then((snapshot) => {
-            requestId = snapshot.requestId;
-            snapshotCwd = snapshot.cwd;
-            latestEntries = snapshot.entries;
-            if (!snapshot.entries.some((entry) => entry.status === "loading")) {
-                finish(snapshot);
-                return;
-            }
-            const pendingUpdate = pendingUpdates.get(snapshotCwd);
-            if (pendingUpdate && !pendingUpdate.entries.some((entry) => entry.status === "loading")) {
-                finish({ ...pendingUpdate, requestId });
-            }
-            return undefined;
-        })
-            .catch(fail);
-    });
+    }
+    finally {
+        await observation.release();
+    }
 }
 function createGeneratedClientId() {
     const randomId = typeof globalThis.crypto?.randomUUID === "function"

package/dist/provider-snapshots/index.d.ts

@@ -7,15 +7,13 @@ type Snapshot = GetProvidersSnapshotResponseMessage["payload"];
 export declare class ProviderSnapshotUpdates {
     private readonly host;
     private pending;
-    private paused;
     constructor(host: {
+        active(update: Update): boolean;
         fetch(cwd: string | undefined): Promise<Snapshot>;
         emit(update: Update): void;
         failed(error: unknown): void;
     });
     clear(): void;
-    pause(): void;
-    resume(): void;
     receive(update: Update): void;
     private resolve;
 }

package/dist/provider-snapshots/index.js

@@ -3,57 +3,53 @@ export class ProviderSnapshotUpdates {
     constructor(host) {
         this.host = host;
         this.pending = new Map();
-        this.paused = false;
     }
     clear() {
         this.pending.clear();
     }
-    pause() {
-        this.paused = true;
-        // Invalidate old responses while retaining the announcements they would resolve.
-        for (const [cwd, pending] of this.pending) {
-            this.pending.set(cwd, { latest: pending.latest, running: false });
-        }
-    }
-    resume() {
-        this.paused = false;
-        for (const pending of this.pending.values())
-            this.receive(pending.latest);
-    }
     receive(update) {
-        const cwd = update.payload.cwd;
-        const pending = this.pending.get(cwd) ?? { latest: update, running: false };
+        if (!this.host.active(update))
+            return;
+        const key = JSON.stringify([update.payload.subscriptionId, update.payload.cwd]);
+        const pending = this.pending.get(key) ?? { latest: update, running: false };
         pending.latest = update;
-        this.pending.set(cwd, pending);
-        if (this.paused || pending.running)
+        this.pending.set(key, pending);
+        if (pending.running)
             return;
         pending.running = true;
-        void this.resolve(cwd, pending);
+        void this.resolve(key, pending);
     }
-    async resolve(cwd, pending) {
+    async resolve(key, pending) {
         try {
-            while (this.pending.get(cwd) === pending) {
+            while (this.pending.get(key) === pending) {
                 const announced = pending.latest;
-                const snapshot = await this.host.fetch(cwd);
-                if (this.pending.get(cwd) !== pending)
+                if (!this.host.active(announced))
+                    return;
+                const snapshot = await this.host.fetch(announced.payload.cwd);
+                if (!this.host.active(announced))
+                    return;
+                if (this.pending.get(key) !== pending)
                     return;
                 // A change arriving while the body was in flight needs the current body.
                 // If that response already covers it, no second fetch is necessary.
                 if (pending.latest !== announced &&
                     pending.latest.payload.snapshotHash !== snapshot.snapshotHash)
                     continue;
-                this.pending.delete(cwd);
-                this.host.emit({ type: "providers_snapshot_update", payload: snapshot });
+                this.pending.delete(key);
+                this.host.emit({
+                    type: "providers_snapshot_update",
+                    payload: { ...snapshot, subscriptionId: announced.payload.subscriptionId },
+                });
                 return;
             }
         }
         catch (error) {
-            if (this.pending.get(cwd) === pending)
+            if (this.pending.get(key) === pending)
                 this.host.failed(error);
         }
         finally {
-            if (this.pending.get(cwd) === pending)
-                this.pending.delete(cwd);
+            if (this.pending.get(key) === pending)
+                this.pending.delete(key);
         }
     }
 }

package/dist/terminal-stream-router.d.ts

@@ -1,28 +1,25 @@
 import { type TerminalStreamFrame } from "@camerontaylor/paseo-protocol/binary-frames/index";
-import type { TerminalInput, TerminalState } from "@camerontaylor/paseo-protocol/messages";
+import type { TerminalState } from "@camerontaylor/paseo-protocol/messages";
 export type TerminalStreamEvent = {
     terminalId: string;
+    subscriptionId: string;
+} & ({
     type: "output";
     data: Uint8Array;
 } | {
-    terminalId: string;
     type: "snapshot";
     state: TerminalState;
 } | {
-    terminalId: string;
     type: "restore";
     data: Uint8Array;
-};
+});
 export declare class TerminalStreamRouter {
-    private readonly terminalSlots;
-    private readonly slotTerminals;
+    private readonly slots;
     private readonly listeners;
+    /** Passive wire diagnostics. App state consumes the registration's callback. */
     onEvent(handler: (event: TerminalStreamEvent) => void): () => void;
-    setSlot(terminalId: string, slot: number): void;
-    removeTerminal(terminalId: string): void;
+    attach(subscriptionId: string, terminalId: string, slot: number, receive: (event: TerminalStreamEvent) => void): () => void;
     clearSlots(): void;
-    encodeInput(terminalId: string, message: TerminalInput["message"]): Uint8Array | null;
     handleFrame(frame: TerminalStreamFrame): void;
-    private emit;
 }
 //# sourceMappingURL=terminal-stream-router.d.ts.map