@songsid/agend 2.1.12 → 2.2.0-alpha.2

package/dist/tmux-control.d.ts

@@ -1,11 +1,19 @@
 import { EventEmitter } from "node:events";
 import type { Logger } from "./logger.js";
+import { type TmuxReadQuery, type TmuxReadPort } from "./tmux-read.js";
 export interface TmuxPaneOutputEvent {
     paneId: string;
     windowId?: string;
     at: number;
 }
 export declare const CONTROL_SAFETY_SWEEP_MS = 60000;
+/**
+ * The sweep's listeners — one per daemon, each capturing and evaluating its pane —
+ * are spread over this much of the period instead of all running in one tick (#1402): measured live, that one tick was
+ * 150–860 ms of unbroken spawning under normal load and 1–2.5 s when the host was busy (#1235). Half the period, so a
+ * sweep's last slot is always well before the next sweep starts.
+ */
+export declare const CONTROL_SAFETY_SWEEP_SPREAD_MS: number;
 /**
  * Persistent tmux control mode client that monitors %output events
  * to detect per-pane idle state. One instance per tmux session.
@@ -16,25 +24,51 @@ export declare const CONTROL_SAFETY_SWEEP_MS = 60000;
  *   await ctrl.waitForIdle("@5");  // wait until window @5 is idle
  *   tmux.pasteText(msg);
  */
-export declare class TmuxControlClient extends EventEmitter {
+export declare class TmuxControlClient extends EventEmitter implements TmuxReadPort {
     private sessionName;
     private silenceMs;
     private logger?;
-    private proc;
-    private rl;
+    /** A retired child still owns this slot until exit/close proves it is gone. */
+    private attachment;
+    private activeRead;
+    private reconnectAfter;
+    private readonly socket;
+    private readonly reads;
+    private registrationSerial;
+    private registrationTokens;
     private lastOutputAt;
     private paneToWindow;
     private registeredWindows;
     private resolveFailures;
+    /**
+     * Registered windows that stopped resolving (#1490). They leave the reconnect set — a dead window's registration was
+     * a permanent per-reconnect cost — but are not forgotten: their state is unknown, and unknown is not idle. A caller's
+     * question retries the resolve (at most every LOST_WINDOW_RETRY_MS); success registers the window again.
+     */
+    private lostWindows;
+    /** Monotonic time a lost window resolved again: until it has been silent this long, it is not idle. */
+    private recoveredAt;
+    /** Monotonic clock for retry spacing and the recovery silence (elapsed budgets, never wall time). */
+    private mono;
     private stopped;
     private reconnectTimer;
     /** Epoch ms of the last observation reset. Everything before it is unobservable:
      *  the pane cache was dropped, so the absence of a record proves nothing. */
     private observationResetAt;
     private safetySweepTimer;
+    /** The current sweep's pending per-listener slots. */
+    private safetySweepSlots;
     constructor(sessionName: string, silenceMs?: number, logger?: Logger | undefined);
     start(): void;
+    /**
+     * One sweep: every daemon's listener, each in a tick of its own, spread evenly over CONTROL_SAFETY_SWEEP_SPREAD_MS
+     * (#1402). A listener removed before its slot (its daemon stopped) is skipped; stop() drops slots still pending.
+     */
+    private runSafetySweep;
+    private clearSafetySweepSlots;
     stop(): void;
+    isFor(session: string, socket: string | null): boolean;
+    read(query: TmuxReadQuery, timeoutMs?: number): Promise<string>;
     /**
      * Register a window so we can track its pane's output.
      * Call this after createWindow().
@@ -46,8 +80,8 @@ export declare class TmuxControlClient extends EventEmitter {
      * Resolve a window's current pane id and cache the mapping.
      *
      * Drops a registration that has failed to resolve `RESOLVE_FAILURES_BEFORE_DROP`
-     * times in a row. Every reconnect re-resolves every registered window, one tmux
-     * subprocess each, so a registration for a window that no longer exists is a
+     * times in a row. Every reconnect re-resolves every registered window through the read FIFO,
+     * so a registration for a window that no longer exists is a
      * permanent per-reconnect cost — and callers do forget to unregister (a crash
      * respawn creates a new window id and the dead one used to stay forever).
      *
@@ -63,6 +97,13 @@ export declare class TmuxControlClient extends EventEmitter {
      * without arming it is precisely the bug this exists to prevent.
      */
     private resetPaneObservations;
+    /**
+     * Whether a read started on `owner` may still commit what it learned: the same attachment, not retired. A retired
+     * attachment stays in `this.attachment` until its child exits, and a completed frame followed by `%exit` in one
+     * chunk resolves the read before the retirement is visible to identity alone (#1494 review). A read started with
+     * no attachment (the fallback lane) counts while there is still none.
+     */
+    private admissible;
     /**
      * True while a freshly (re)connected client has not had time to observe output.
      *
@@ -89,6 +130,11 @@ export declare class TmuxControlClient extends EventEmitter {
     getObservationResetAt(): number;
     /** Check if a window's pane has been silent for at least silenceMs */
     isIdle(windowId: string): boolean;
+    /**
+     * Try a lost window again (at most every LOST_WINDOW_RETRY_MS). Success re-registers it under a fresh token; the
+     * result counts only for the same lost record, the same attachment, and a client that has not stopped.
+     */
+    private retryLostWindow;
     /** Timestamp of the window pane's last observed output, or undefined if unknown. */
     getLastOutputAt(windowId: string): number | undefined;
     /** True if the window's pane produced output strictly after `ts` (an idle→busy transition). */
@@ -117,6 +163,12 @@ export declare class TmuxControlClient extends EventEmitter {
     waitForOutput(windowId: string, timeoutMs?: number): Promise<boolean>;
     private windowToPaneId;
     private connect;
+    private scheduleReconnect;
+    private release;
+    private retire;
+    private receive;
+    private executeRead;
     private parseLine;
+    private observeOutput;
     private cleanup;
 }