@cortexkit/aft-opencode 0.42.0 → 0.43.0

package/src/tui/notification-socket.ts

@@ -0,0 +1,421 @@
+import { AftRpcClient, type AftRpcEndpoint } from "../shared/rpc-client";
+import { resolveCortexKitStorageRoot } from "../shared/storage-paths";
+
+export interface SocketNotification {
+  id: number;
+  type: string;
+  payload: Record<string, unknown>;
+  sessionId?: string;
+}
+
+export interface StatusInvalidation {
+  sessionId?: string;
+}
+
+export interface TuiSocketOptions {
+  getDirectory: () => string | null | undefined;
+  getSessionId: () => string | null;
+  onNotification: (notification: SocketNotification) => boolean | Promise<boolean>;
+}
+
+interface WebSocketLike {
+  readyState: number;
+  addEventListener(
+    type: "open" | "message" | "close" | "error",
+    listener: (event: unknown) => void,
+  ): void;
+  send(data: string): void;
+  close(): void;
+}
+
+type WebSocketFactory = new (url: string) => WebSocketLike;
+type RpcClientLike = Pick<AftRpcClient, "resolveEndpoint" | "reset">;
+
+interface SocketDeps {
+  createClient: (directory: string) => RpcClientLike;
+  WebSocketCtor: WebSocketFactory | null;
+  setTimeout: typeof setTimeout;
+  clearTimeout: typeof clearTimeout;
+}
+
+interface SocketScope {
+  directory: string;
+  sessionId: string;
+}
+
+const RECONNECT_BASE_MS = 500;
+const RECONNECT_MAX_MS = 10_000;
+const WEB_SOCKET_OPEN = 1;
+const clients = new Map<string, AftRpcClient>();
+const statusInvalidationListeners = new Set<(event: StatusInvalidation) => void>();
+const lastHandledIdBySession = new Map<string, number>();
+
+function defaultWebSocketCtor(): WebSocketFactory | null {
+  const ctor = (globalThis as typeof globalThis & { WebSocket?: WebSocketFactory }).WebSocket;
+  return ctor ?? null;
+}
+
+function defaultClient(directory: string): AftRpcClient {
+  let client = clients.get(directory);
+  if (!client) {
+    client = new AftRpcClient(resolveCortexKitStorageRoot(), directory);
+    clients.set(directory, client);
+  }
+  return client;
+}
+
+let deps: SocketDeps = {
+  createClient: defaultClient,
+  WebSocketCtor: defaultWebSocketCtor(),
+  setTimeout,
+  clearTimeout,
+};
+
+let opts: TuiSocketOptions | null = null;
+let socket: WebSocketLike | null = null;
+let socketScope: SocketScope | null = null;
+let helloedScope: SocketScope | null = null;
+let reconnectTimer: ReturnType<typeof setTimeout> | undefined;
+let reconnectAttempt = 0;
+let closed = true;
+let generation = 0;
+let connectingGeneration: number | null = null;
+let connectingScope: SocketScope | null = null;
+
+export function startAftTuiSocket(options: TuiSocketOptions): void {
+  opts = options;
+  closed = false;
+  generation += 1;
+  void reconcileSocketScope();
+}
+
+export function stopAftTuiSocket(): void {
+  closed = true;
+  generation += 1;
+  connectingGeneration = null;
+  connectingScope = null;
+  if (reconnectTimer) {
+    deps.clearTimeout(reconnectTimer);
+    reconnectTimer = undefined;
+  }
+  closeCurrentSocket(false);
+  for (const client of clients.values()) client.reset();
+  clients.clear();
+  reconnectAttempt = 0;
+}
+
+export function refreshAftTuiSocketScope(): void {
+  if (closed) return;
+  void reconcileSocketScope();
+}
+
+export function subscribeStatusInvalidations(
+  listener: (event: StatusInvalidation) => void,
+): () => void {
+  statusInvalidationListeners.add(listener);
+  return () => {
+    statusInvalidationListeners.delete(listener);
+  };
+}
+
+export function createDebouncedStatusRefresh(
+  refresh: () => void | Promise<void>,
+  delayMs: number,
+): { schedule: () => void; dispose: () => void } {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let disposed = false;
+  return {
+    schedule() {
+      if (disposed) return;
+      if (timer) deps.clearTimeout(timer);
+      timer = deps.setTimeout(() => {
+        timer = undefined;
+        void refresh();
+      }, delayMs);
+    },
+    dispose() {
+      disposed = true;
+      if (timer) {
+        deps.clearTimeout(timer);
+        timer = undefined;
+      }
+    },
+  };
+}
+
+function currentScope(): SocketScope | null {
+  const directory = opts?.getDirectory() ?? "";
+  const sessionId = opts?.getSessionId() ?? "";
+  if (!directory || !sessionId) return null;
+  return { directory, sessionId };
+}
+
+function sameScope(a: SocketScope | null, b: SocketScope | null): boolean {
+  return a?.directory === b?.directory && a?.sessionId === b?.sessionId;
+}
+
+async function reconcileSocketScope(): Promise<void> {
+  if (closed || !opts) return;
+  const scope = currentScope();
+  if (!scope) {
+    generation += 1;
+    connectingGeneration = null;
+    connectingScope = null;
+    closeCurrentSocket(false);
+    return;
+  }
+
+  if (socket && socketScope?.directory === scope.directory) {
+    if (!sameScope(socketScope, scope) && socket.readyState !== WEB_SOCKET_OPEN) {
+      generation += 1;
+      closeCurrentSocket(false);
+      await connect(scope, generation);
+      return;
+    }
+    if (socket.readyState === WEB_SOCKET_OPEN && !sameScope(helloedScope, scope)) {
+      await sendHelloWithFreshToken(socket, scope, generation);
+    }
+    return;
+  }
+
+  if (sameScope(connectingScope, scope)) return;
+
+  generation += 1;
+  connectingGeneration = null;
+  connectingScope = null;
+  closeCurrentSocket(false);
+  await connect(scope, generation);
+}
+
+async function connect(scope: SocketScope, connectGeneration: number): Promise<void> {
+  if (closed || socket || connectingGeneration !== null) return;
+  const WebSocketCtor = deps.WebSocketCtor ?? defaultWebSocketCtor();
+  if (!WebSocketCtor) {
+    scheduleReconnect();
+    return;
+  }
+
+  connectingGeneration = connectGeneration;
+  connectingScope = scope;
+  let endpoint: AftRpcEndpoint | null = null;
+  try {
+    endpoint = await deps.createClient(scope.directory).resolveEndpoint();
+  } catch {
+    endpoint = null;
+  }
+
+  if (connectingGeneration === connectGeneration) {
+    connectingGeneration = null;
+    connectingScope = null;
+  }
+  if (closed || connectGeneration !== generation || !sameScope(currentScope(), scope)) return;
+  if (!endpoint) {
+    scheduleReconnect();
+    return;
+  }
+
+  let ws: WebSocketLike;
+  try {
+    ws = new WebSocketCtor(`ws://127.0.0.1:${endpoint.port}/ws`);
+  } catch {
+    scheduleReconnect();
+    return;
+  }
+
+  socket = ws;
+  socketScope = scope;
+  helloedScope = null;
+
+  ws.addEventListener("open", () => {
+    if (socket !== ws || connectGeneration !== generation) return;
+    reconnectAttempt = 0;
+    sendHello(ws, scope, endpoint.token);
+  });
+
+  ws.addEventListener("message", (event) => {
+    if (socket !== ws || connectGeneration !== generation) return;
+    const data =
+      typeof (event as { data?: unknown }).data === "string"
+        ? (event as { data: string }).data
+        : String((event as { data?: unknown }).data ?? "");
+    void handleSocketMessage(ws, data, connectGeneration);
+  });
+
+  const onDown = () => {
+    if (socket !== ws) return;
+    socket = null;
+    socketScope = null;
+    helloedScope = null;
+    generation += 1;
+    scheduleReconnect();
+  };
+  ws.addEventListener("close", onDown);
+  ws.addEventListener("error", () => {
+    try {
+      ws.close();
+    } catch {
+      // best-effort
+    }
+    onDown();
+  });
+}
+
+function closeCurrentSocket(schedule: boolean): void {
+  const ws = socket;
+  socket = null;
+  socketScope = null;
+  helloedScope = null;
+  if (ws) {
+    try {
+      ws.close();
+    } catch {
+      // best-effort
+    }
+  }
+  if (schedule) scheduleReconnect();
+}
+
+function scheduleReconnect(): void {
+  if (closed || reconnectTimer) return;
+  const scope = currentScope();
+  if (!scope) return;
+  const delay = Math.min(RECONNECT_BASE_MS * 2 ** reconnectAttempt, RECONNECT_MAX_MS);
+  reconnectAttempt += 1;
+  reconnectTimer = deps.setTimeout(() => {
+    reconnectTimer = undefined;
+    const nextScope = currentScope();
+    if (!nextScope) return;
+    void connect(nextScope, generation);
+  }, delay);
+}
+
+async function sendHelloWithFreshToken(
+  ws: WebSocketLike,
+  scope: SocketScope,
+  expectedGeneration: number,
+): Promise<void> {
+  let endpoint: AftRpcEndpoint | null = null;
+  try {
+    endpoint = await deps.createClient(scope.directory).resolveEndpoint();
+  } catch {
+    endpoint = null;
+  }
+  if (
+    closed ||
+    socket !== ws ||
+    expectedGeneration !== generation ||
+    !sameScope(currentScope(), scope)
+  ) {
+    return;
+  }
+  sendHello(ws, scope, endpoint?.token ?? null);
+}
+
+function sendHello(ws: WebSocketLike, scope: SocketScope, token: string | null): void {
+  helloedScope = scope;
+  if (socket === ws) socketScope = scope;
+  const lastReceivedId = lastHandledIdBySession.get(scope.sessionId) ?? 0;
+  ws.send(
+    JSON.stringify({
+      type: "hello",
+      token: token ?? "",
+      sessionId: scope.sessionId,
+      lastReceivedId,
+    }),
+  );
+}
+
+async function handleSocketMessage(
+  ws: WebSocketLike,
+  raw: string,
+  messageGeneration: number,
+): Promise<void> {
+  let msg: {
+    type?: string;
+    notification?: SocketNotification;
+    sessionId?: string;
+    error?: string;
+  };
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+
+  if (msg.type === "status-changed") {
+    for (const listener of statusInvalidationListeners) {
+      try {
+        listener({ sessionId: msg.sessionId });
+      } catch {
+        // One sidebar/dialog listener must not block the others.
+      }
+    }
+    return;
+  }
+
+  if (msg.type === "notification" && msg.notification) {
+    const notification = msg.notification;
+    const active = opts?.getSessionId() ?? null;
+    if (!active) return;
+    if (notification.sessionId && notification.sessionId !== active) return;
+
+    let consumed = false;
+    try {
+      consumed = await Promise.resolve(opts?.onNotification(notification) ?? false);
+    } catch {
+      consumed = false;
+    }
+
+    if (
+      socket !== ws ||
+      messageGeneration !== generation ||
+      (opts?.getSessionId() ?? null) !== active
+    ) {
+      return;
+    }
+    if (consumed && notification.id > (lastHandledIdBySession.get(active) ?? 0)) {
+      lastHandledIdBySession.set(active, notification.id);
+      try {
+        ws.send(JSON.stringify({ type: "ack", lastReceivedId: notification.id }));
+      } catch {
+        // best-effort; reconnect hello replays the cursor.
+      }
+    }
+    return;
+  }
+
+  if (msg.type === "error") {
+    try {
+      ws.close();
+    } catch {
+      // best-effort
+    }
+  }
+}
+
+export function __setAftTuiSocketDepsForTest(overrides: Partial<SocketDeps>): () => void {
+  const previous = deps;
+  deps = { ...deps, ...overrides };
+  return () => {
+    deps = previous;
+  };
+}
+
+export function __resetAftTuiSocketForTest(): void {
+  stopAftTuiSocket();
+  opts = null;
+  statusInvalidationListeners.clear();
+  lastHandledIdBySession.clear();
+  clients.clear();
+  reconnectAttempt = 0;
+  generation = 0;
+  connectingGeneration = null;
+  connectingScope = null;
+  closed = true;
+  deps = {
+    createClient: defaultClient,
+    WebSocketCtor: defaultWebSocketCtor(),
+    setTimeout,
+    clearTimeout,
+  };
+}

package/src/tui/sidebar.tsx

@@ -1,11 +1,10 @@
 /** @jsxImportSource @opentui/solid */
 // @ts-nocheck
 
-// AFT sidebar slot — mirrors opencode-magic-context's sidebar pattern.
-// Header with "AFT" badge + version, then live status of search and semantic
-// indexes plus their on-disk size. Refreshes on session change and on
-// session.updated/message.updated events with a small debounce, same as
-// magic-context, so the panel stays current without polling.
+// AFT sidebar slot. Header with "AFT" badge + version, then live status of search and semantic
+// indexes plus their on-disk size. Refreshes on mount/session change and on
+// server-pushed status invalidations with a small debounce, so the panel stays
+// current without polling.
 
 import { canonicalizeProjectRoot } from "@cortexkit/aft-bridge";
 import type { TuiPluginApi, TuiSlotPlugin, TuiThemeCurrent } from "@opencode-ai/plugin/tui";
@@ -20,6 +19,11 @@ import {
   type StatusCompression,
 } from "../shared/status";
 import { resolveCortexKitStorageRoot } from "../shared/storage-paths";
+import {
+  createDebouncedStatusRefresh,
+  refreshAftTuiSocketScope,
+  subscribeStatusInvalidations,
+} from "./notification-socket";
 import {
   type AftTuiPrefs,
   computeEffectiveOrder,
@@ -35,10 +39,6 @@ import {
 
 const SINGLE_BORDER = { type: "single" } as any;
 const REFRESH_DEBOUNCE_MS = 200;
-// The sidebar polls the bridge as a backstop because not every state change
-// (e.g. semantic index transitioning from "loading" → "ready" mid-session)
-// emits a session/message event. 1.5s matches the /aft-status dialog cadence.
-const POLL_INTERVAL_MS = 1500;
 
 function formatBytes(n: number): string {
   if (!Number.isFinite(n) || n <= 0) return "—";
@@ -277,7 +277,7 @@ export function scopedSidebarSnapshot(
  * mid-respawn after a binary swap, or a momentary session-dir key miss) arrives
  * over RPC as `success: true`, so a naive `setStatus` would overwrite a good
  * snapshot and collapse the panel to the lazy-bridge placeholder — the blank
- * flicker that recovers on the next poll. Suppress the downgrade only when we
+ * flicker that recovers on the next refresh. Suppress the downgrade only when we
  * already hold initialized data for the same context; never blocks the first
  * real snapshot, and a genuine context switch clears separately.
  */
@@ -353,8 +353,6 @@ const SidebarContent = (props: {
     sessionID: string;
   } | null = null;
   let generation = 0;
-  let debounceTimer: ReturnType<typeof setTimeout> | undefined;
-  let pollTimer: ReturnType<typeof setInterval> | undefined;
 
   const currentDirectory = () => props.api.state.path.directory ?? "";
   const requestRender = () => {
@@ -443,6 +441,22 @@ const SidebarContent = (props: {
           current.sessionID === sid &&
           current.snapshot.cache_role !== "not_initialized";
         if (shouldSuppressUninitializedDowngrade(snapshot.cache_role, haveGoodForContext)) return;
+        // Equality gate: a pushed invalidation can still produce the same
+        // snapshot (for example, a session-scoped status frame that does not
+        // affect this sidebar's visible fields). Minting a new status object
+        // would run SolidJS reactivity and schedule a host frame for no visible
+        // change. Skip the update when the freshly-fetched snapshot is
+        // byte-identical to what we already show for this exact context.
+        // JSON.stringify is sound here because the snapshot is a plain object
+        // coerced from the status RPC's JSON.
+        if (
+          current !== null &&
+          current.directory === directory &&
+          current.sessionID === sid &&
+          JSON.stringify(current.snapshot) === JSON.stringify(snapshot)
+        ) {
+          return;
+        }
         setStatus({ directory, sessionID: sid, snapshot });
         requestRender();
       }
@@ -456,13 +470,8 @@ const SidebarContent = (props: {
     }
   };
 
-  const scheduleRefresh = () => {
-    if (debounceTimer) clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(() => {
-      debounceTimer = undefined;
-      void refresh();
-    }, REFRESH_DEBOUNCE_MS);
-  };
+  const statusDebouncer = createDebouncedStatusRefresh(refresh, REFRESH_DEBOUNCE_MS);
+  const scheduleRefresh = () => statusDebouncer.schedule();
 
   const reloadPrefs = async () => {
     const root = await readTuiPreferencesFile();
@@ -481,58 +490,33 @@ const SidebarContent = (props: {
     unwatchPrefs();
     generation++;
     abortInflight();
-    if (debounceTimer) clearTimeout(debounceTimer);
-    if (pollTimer) clearInterval(pollTimer);
+    statusDebouncer.dispose();
   });
 
   // Refresh on session id change + initial load
   createEffect(
     on(props.sessionID, () => {
+      refreshAftTuiSocketScope();
       void refresh();
     }),
   );
 
-  // Wire live updates: session/message events are cheap signals that
-  // *something* AFT-relevant probably changed (formatted edit, lsp activity,
-  // index pre-warm completion). The status RPC is debounced so we don't
-  // recompute disk usage on every keystroke.
+  // Wire live updates: the server pushes a lightweight invalidation whenever
+  // the bridge reports a status change. The sidebar coalesces bursts into one
+  // trailing status fetch and stays completely idle when no backend state changes.
   createEffect(
     on(
       props.sessionID,
       (sessionID) => {
         if (!sessionID) return;
-        const unsubs = [
-          props.api.event.on("message.updated", (event) => {
-            if (event.properties?.info?.sessionID !== sessionID) return;
-            scheduleRefresh();
-          }),
-          props.api.event.on("session.updated", (event) => {
-            if (event.properties?.info?.id !== sessionID) return;
-            scheduleRefresh();
-          }),
-        ];
-        // Background poller for state that doesn't emit session events
-        // (semantic index `loading` → `ready`, disk size growth during
-        // a background indexer rebuild). Self-cancelling on cleanup.
-        if (!pollTimer) {
-          pollTimer = setInterval(() => {
-            scheduleRefresh();
-          }, POLL_INTERVAL_MS);
-        }
+        const unsubscribe = subscribeStatusInvalidations((event) => {
+          if (event.sessionId && event.sessionId !== props.sessionID()) return;
+          scheduleRefresh();
+        });
         onCleanup(() => {
-          for (const unsub of unsubs) {
-            try {
-              unsub();
-            } catch {
-              // best effort
-            }
-          }
+          unsubscribe();
           generation++;
           abortInflight();
-          if (pollTimer) {
-            clearInterval(pollTimer);
-            pollTimer = undefined;
-          }
         });
       },
       { defer: false },

package/dist/patch-parser.d.ts

@@ -1,33 +0,0 @@
-/**
- * Minimal patch parser for the opencode `*** Begin Patch` format.
- * Ported from opencode's internal Patch module.
- */
-export interface AddHunk {
-    type: "add";
-    path: string;
-    contents: string;
-}
-export interface DeleteHunk {
-    type: "delete";
-    path: string;
-}
-export interface UpdateFileChunk {
-    old_lines: string[];
-    new_lines: string[];
-    change_context?: string;
-    is_end_of_file?: boolean;
-}
-export interface UpdateHunk {
-    type: "update";
-    path: string;
-    move_path?: string;
-    chunks: UpdateFileChunk[];
-}
-export type Hunk = AddHunk | DeleteHunk | UpdateHunk;
-export declare function parsePatch(patchText: string): Hunk[];
-/**
- * Apply update chunks to the original file content, producing new content.
- * Ported from opencode's deriveNewContentsFromChunks.
- */
-export declare function applyUpdateChunks(originalContent: string, filePath: string, chunks: UpdateFileChunk[]): string;
-//# sourceMappingURL=patch-parser.d.ts.map

package/dist/patch-parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"patch-parser.d.ts","sourceRoot":"","sources":["../src/patch-parser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,KAAK,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED,MAAM,MAAM,IAAI,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,CAAC;AAqHrD,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,CAqDpD;AAwQD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,eAAe,EAAE,GACxB,MAAM,CAmHR"}

package/dist/shared/opencode-config-dir.d.ts

@@ -1,16 +0,0 @@
-export type OpenCodeBinaryType = "opencode" | "opencode-desktop";
-export interface OpenCodeConfigDirOptions {
-    binary: OpenCodeBinaryType;
-    version?: string | null;
-    checkExisting?: boolean;
-}
-export interface OpenCodeConfigPaths {
-    configDir: string;
-    configJson: string;
-    configJsonc: string;
-    packageJson: string;
-    omoConfig: string;
-}
-export declare function getOpenCodeConfigDir(_options: OpenCodeConfigDirOptions): string;
-export declare function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths;
-//# sourceMappingURL=opencode-config-dir.d.ts.map

package/dist/shared/opencode-config-dir.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"opencode-config-dir.d.ts","sourceRoot":"","sources":["../../src/shared/opencode-config-dir.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,kBAAkB,CAAC;AAEjE,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAeD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,MAAM,CAE/E;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,wBAAwB,GAAG,mBAAmB,CAS7F"}

package/dist/shared/pty-cache.d.ts

@@ -1,18 +0,0 @@
-import * as fs from "node:fs/promises";
-import { Terminal } from "@xterm/headless";
-export interface PtyTerminalState {
-    terminal: Terminal;
-    fileHandle: fs.FileHandle;
-    offset: number;
-    rows: number;
-    cols: number;
-    lastAccessMs: number;
-}
-export declare function getOrCreatePtyTerminal(key: string, outputPath: string, rows?: number, cols?: number): Promise<PtyTerminalState>;
-export declare function readPtyBytes(state: PtyTerminalState): Promise<Buffer>;
-export declare function disposePtyTerminal(key: string): Promise<void>;
-export declare function disposeAllPtyTerminals(): Promise<void>;
-export declare function renderScreen(state: PtyTerminalState, rows?: number, cols?: number): string;
-export declare function __resetPtyCacheForTests(): void;
-export declare function __ptyCacheSizeForTests(): number;
-//# sourceMappingURL=pty-cache.d.ts.map

package/dist/shared/pty-cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pty-cache.d.ts","sourceRoot":"","sources":["../../src/shared/pty-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAM3C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,QAAQ,CAAC;IACnB,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACtB;AAID,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,IAAI,SAAe,EACnB,IAAI,SAAe,GAClB,OAAO,CAAC,gBAAgB,CAAC,CAuB3B;AAED,wBAAsB,YAAY,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAa3E;AAED,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMnE;AAED,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC,CAE5D;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,gBAAgB,EACvB,IAAI,SAAa,EACjB,IAAI,SAAa,GAChB,MAAM,CAiBR;AAED,wBAAgB,uBAAuB,IAAI,IAAI,CAM9C;AAED,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C"}

package/dist/shared/tui-config.d.ts

@@ -1,2 +0,0 @@
-export declare function ensureTuiPluginEntry(): boolean;
-//# sourceMappingURL=tui-config.d.ts.map

package/dist/shared/tui-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tui-config.d.ts","sourceRoot":"","sources":["../../src/shared/tui-config.ts"],"names":[],"mappings":"AAmBA,wBAAgB,oBAAoB,IAAI,OAAO,CAsC9C"}