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

package/dist/terminal-stream-router.js

@@ -1,107 +1,60 @@
-import { decodeTerminalSnapshotPayload, encodeTerminalResizePayload, encodeTerminalStreamFrame, TerminalStreamOpcode, } from "@camerontaylor/paseo-protocol/binary-frames/index";
+import { decodeTerminalSnapshotPayload, TerminalStreamOpcode, } from "@camerontaylor/paseo-protocol/binary-frames/index";
 export class TerminalStreamRouter {
     constructor() {
-        this.terminalSlots = new Map();
-        this.slotTerminals = new Map();
+        this.slots = new Map();
         this.listeners = new Set();
     }
+    /** Passive wire diagnostics. App state consumes the registration's callback. */
     onEvent(handler) {
         this.listeners.add(handler);
         return () => {
             this.listeners.delete(handler);
         };
     }
-    setSlot(terminalId, slot) {
-        const existingTerminalId = this.slotTerminals.get(slot);
-        if (existingTerminalId && existingTerminalId !== terminalId) {
-            this.terminalSlots.delete(existingTerminalId);
-        }
-        const existingSlot = this.terminalSlots.get(terminalId);
-        if (typeof existingSlot === "number" && existingSlot !== slot) {
-            this.slotTerminals.delete(existingSlot);
-        }
-        this.terminalSlots.set(terminalId, slot);
-        this.slotTerminals.set(slot, terminalId);
-    }
-    removeTerminal(terminalId) {
-        const slot = this.terminalSlots.get(terminalId);
-        if (typeof slot !== "number") {
-            return;
-        }
-        this.terminalSlots.delete(terminalId);
-        if (this.slotTerminals.get(slot) === terminalId) {
-            this.slotTerminals.delete(slot);
-        }
+    attach(subscriptionId, terminalId, slot, receive) {
+        const registration = { subscriptionId, terminalId, receive };
+        const registrations = this.slots.get(slot) ?? new Set();
+        registrations.add(registration);
+        this.slots.set(slot, registrations);
+        return () => {
+            registrations.delete(registration);
+            if (registrations.size === 0)
+                this.slots.delete(slot);
+        };
     }
     clearSlots() {
-        this.terminalSlots.clear();
-        this.slotTerminals.clear();
-    }
-    encodeInput(terminalId, message) {
-        const slot = this.terminalSlots.get(terminalId);
-        if (typeof slot !== "number") {
-            return null;
-        }
-        if (message.type === "input") {
-            return encodeTerminalStreamFrame({
-                opcode: TerminalStreamOpcode.Input,
-                slot,
-                payload: message.data,
-            });
-        }
-        if (message.type === "resize") {
-            return encodeTerminalStreamFrame({
-                opcode: TerminalStreamOpcode.Resize,
-                slot,
-                payload: encodeTerminalResizePayload({
-                    rows: message.rows,
-                    cols: message.cols,
-                    ...(message.intent ? { intent: message.intent } : {}),
-                }),
-            });
-        }
-        return null;
+        this.slots.clear();
     }
     handleFrame(frame) {
-        const terminalId = this.slotTerminals.get(frame.slot);
-        if (!terminalId) {
-            return;
-        }
-        if (frame.opcode === TerminalStreamOpcode.Output) {
-            this.emit({
-                terminalId,
-                type: "output",
-                data: frame.payload,
-            });
+        const registrations = this.slots.get(frame.slot);
+        if (!registrations)
             return;
-        }
-        if (frame.opcode === TerminalStreamOpcode.Restore) {
-            this.emit({
-                terminalId,
-                type: "restore",
-                data: frame.payload,
-            });
-            return;
-        }
-        if (frame.opcode === TerminalStreamOpcode.Snapshot) {
-            const state = decodeTerminalSnapshotPayload(frame.payload);
-            if (!state) {
-                return;
+        for (const registration of registrations) {
+            const identity = {
+                subscriptionId: registration.subscriptionId,
+                terminalId: registration.terminalId,
+            };
+            let event;
+            if (frame.opcode === TerminalStreamOpcode.Output)
+                event = { ...identity, type: "output", data: frame.payload };
+            else if (frame.opcode === TerminalStreamOpcode.Restore)
+                event = { ...identity, type: "restore", data: frame.payload };
+            else if (frame.opcode === TerminalStreamOpcode.Snapshot) {
+                const state = decodeTerminalSnapshotPayload(frame.payload);
+                if (!state)
+                    return;
+                event = { ...identity, type: "snapshot", state };
             }
-            this.emit({
-                terminalId,
-                type: "snapshot",
-                state,
-            });
-        }
-    }
-    emit(event) {
-        for (const listener of this.listeners) {
-            try {
-                listener(event);
-            }
-            catch {
-                // no-op
+            else
+                return;
+            registration.receive(event);
+            for (const listener of this.listeners) {
+                try {
+                    listener(event);
+                }
+                catch {
+                    /* Passive diagnostics cannot interrupt delivery. */
+                }
             }
         }
     }

package/dist/timeline-subscription/index.d.ts

@@ -0,0 +1,25 @@
+import type { SessionOutboundMessage } from "@camerontaylor/paseo-protocol/messages";
+import type { OwnedSubscription, TimelineSubscription } from "../connection/index.js";
+type TimelineUpdate = Extract<SessionOutboundMessage, {
+    type: "agent_stream" | "agent.timeline.replacement";
+}>;
+/** Local SDK lifecycle messages; these are not additional wire RPCs. */
+export type TimelineMessage = TimelineUpdate | {
+    type: "agent.timeline.subscription_restored";
+    payload: {
+        agentId: string;
+        subscriptionId: string;
+    };
+} | {
+    type: "agent.timeline.error";
+    payload: {
+        agentId: string;
+        error: string;
+    };
+};
+/** Restores live delivery; the consumer owns history reads and gap recovery. */
+export declare function subscribeTimeline(agentId: string, observation: OwnedSubscription<{
+    agentIds: string[];
+}>, handler: (message: TimelineMessage) => void, reportError: (error: unknown) => void): TimelineSubscription;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/timeline-subscription/index.js

@@ -0,0 +1,56 @@
+/** Restores live delivery; the consumer owns history reads and gap recovery. */
+export function subscribeTimeline(agentId, observation, handler, reportError) {
+    let established = false;
+    let released = false;
+    const notify = (message) => {
+        if (released)
+            return;
+        try {
+            handler(message);
+        }
+        catch (error) {
+            reportError(error);
+        }
+    };
+    const release = () => {
+        released = true;
+        return observation.release();
+    };
+    const stop = () => {
+        // Use the public release entry point so the owning API also forgets this handle.
+        void subscription.release().catch(reportError);
+    };
+    const fail = (error) => {
+        notify({
+            type: "agent.timeline.error",
+            payload: { agentId, error: error instanceof Error ? error.message : String(error) },
+        });
+        stop();
+    };
+    observation.subscribe({
+        snapshot: ({ subscriptionId }) => {
+            if (!established) {
+                established = true;
+                return;
+            }
+            notify({
+                type: "agent.timeline.subscription_restored",
+                payload: { agentId, subscriptionId },
+            });
+        },
+        update: (message) => {
+            if (message.type === "agent_stream" || message.type === "agent.timeline.replacement")
+                notify(message);
+        },
+        error: fail,
+    });
+    const subscription = Object.assign(stop, {
+        ready: observation.ready.then(() => undefined),
+        release,
+        subscriptionId: null,
+    });
+    Object.defineProperty(subscription, "subscriptionId", { get: () => observation.subscriptionId });
+    void subscription.ready.catch(fail);
+    return subscription;
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camerontaylor/paseo-client",
-  "version": "0.8.0-fork.1",
+  "version": "0.9.0-beta.2.fork.1",
   "description": "Paseo client SDK package",
   "files": [
     "dist",
@@ -39,13 +39,17 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@camerontaylor/paseo-protocol": "0.8.0-fork.1",
-    "@camerontaylor/paseo-relay": "0.8.0-fork.1",
+    "@camerontaylor/paseo-protocol": "0.9.0-beta.2.fork.1",
+    "@camerontaylor/paseo-relay": "0.9.0-beta.2.fork.1",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "^20.9.0",
     "typescript": "^5.2.2",
     "vitest": "^4.1.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/camerontaylor/paseo"
   }
 }