adhdev 0.8.50 → 0.8.54

package/vendor/terminal-mux-cli/node_modules/@adhdev/terminal-mux-core/index.mjs

@@ -0,0 +1,957 @@
+// src/layout.ts
+import { randomUUID } from "crypto";
+function cloneNode(node) {
+  if (node.type === "pane") {
+    return { ...node };
+  }
+  return {
+    ...node,
+    first: cloneNode(node.first),
+    second: cloneNode(node.second)
+  };
+}
+function replaceNode(node, paneId, next) {
+  if (node.type === "pane") {
+    return node.paneId === paneId ? next : node;
+  }
+  return {
+    ...node,
+    first: replaceNode(node.first, paneId, next),
+    second: replaceNode(node.second, paneId, next)
+  };
+}
+function removeNode(node, paneId) {
+  if (node.type === "pane") {
+    return node.paneId === paneId ? null : node;
+  }
+  const first = removeNode(node.first, paneId);
+  const second = removeNode(node.second, paneId);
+  if (!first && !second) return null;
+  if (!first) return second;
+  if (!second) return first;
+  return {
+    ...node,
+    first,
+    second
+  };
+}
+function cloneWorkspace(workspace) {
+  return {
+    ...workspace,
+    root: cloneNode(workspace.root),
+    panes: Object.fromEntries(
+      Object.entries(workspace.panes).map(([paneId, pane]) => [paneId, { ...pane, viewport: { ...pane.viewport } }])
+    )
+  };
+}
+function nodeContainsPane(node, paneId) {
+  if (node.type === "pane") {
+    return node.paneId === paneId;
+  }
+  return nodeContainsPane(node.first, paneId) || nodeContainsPane(node.second, paneId);
+}
+function clampRatio(value) {
+  return Math.max(0.15, Math.min(0.85, value));
+}
+function adjustNodeForPane(node, paneId, axis, delta) {
+  if (node.type === "pane") {
+    return { node, changed: false };
+  }
+  const firstContains = nodeContainsPane(node.first, paneId);
+  const secondContains = !firstContains && nodeContainsPane(node.second, paneId);
+  let changed = false;
+  let nextNode = node;
+  if (node.axis === axis && (firstContains || secondContains)) {
+    const directionDelta = firstContains ? delta : -delta;
+    nextNode = {
+      ...node,
+      ratio: clampRatio(node.ratio + directionDelta)
+    };
+    changed = true;
+  }
+  if (firstContains) {
+    const adjusted = adjustNodeForPane(nextNode.first, paneId, axis, delta);
+    if (adjusted.changed) {
+      nextNode = {
+        ...nextNode,
+        first: adjusted.node
+      };
+      changed = true;
+    }
+  } else if (secondContains) {
+    const adjusted = adjustNodeForPane(nextNode.second, paneId, axis, delta);
+    if (adjusted.changed) {
+      nextNode = {
+        ...nextNode,
+        second: adjusted.node
+      };
+      changed = true;
+    }
+  }
+  return { node: nextNode, changed };
+}
+function rebalanceNode(node) {
+  if (node.type === "pane") return node;
+  return {
+    ...node,
+    ratio: 0.5,
+    first: rebalanceNode(node.first),
+    second: rebalanceNode(node.second)
+  };
+}
+function mapPaneIds(node, firstPaneId, secondPaneId) {
+  if (node.type === "pane") {
+    if (node.paneId === firstPaneId) return { ...node, paneId: secondPaneId };
+    if (node.paneId === secondPaneId) return { ...node, paneId: firstPaneId };
+    return node;
+  }
+  return {
+    ...node,
+    first: mapPaneIds(node.first, firstPaneId, secondPaneId),
+    second: mapPaneIds(node.second, firstPaneId, secondPaneId)
+  };
+}
+function collectPaneIds(node, acc = []) {
+  if (node.type === "pane") {
+    acc.push(node.paneId);
+    return acc;
+  }
+  collectPaneIds(node.first, acc);
+  collectPaneIds(node.second, acc);
+  return acc;
+}
+function buildEvenLayout(paneIds, axis = "vertical") {
+  if (paneIds.length === 0) throw new Error("Cannot build layout without panes");
+  if (paneIds.length === 1) return { type: "pane", paneId: paneIds[0] };
+  const midpoint = Math.ceil(paneIds.length / 2);
+  const nextAxis = axis === "vertical" ? "horizontal" : "vertical";
+  return {
+    type: "split",
+    axis,
+    ratio: 0.5,
+    first: buildEvenLayout(paneIds.slice(0, midpoint), nextAxis),
+    second: buildEvenLayout(paneIds.slice(midpoint), nextAxis)
+  };
+}
+function buildStackLayout(paneIds, axis) {
+  if (paneIds.length === 0) throw new Error("Cannot build stack layout without panes");
+  if (paneIds.length === 1) return { type: "pane", paneId: paneIds[0] };
+  const [first, ...rest] = paneIds;
+  return {
+    type: "split",
+    axis,
+    ratio: 0.5,
+    first: { type: "pane", paneId: first },
+    second: buildStackLayout(rest, axis)
+  };
+}
+function buildMainLayout(paneIds, rootAxis) {
+  if (paneIds.length === 0) throw new Error("Cannot build layout without panes");
+  if (paneIds.length === 1) return { type: "pane", paneId: paneIds[0] };
+  const [primary, ...rest] = paneIds;
+  const stackAxis = rootAxis === "vertical" ? "horizontal" : "vertical";
+  return {
+    type: "split",
+    axis: rootAxis,
+    ratio: rest.length === 1 ? 0.5 : 0.62,
+    first: { type: "pane", paneId: primary },
+    second: buildStackLayout(rest, stackAxis)
+  };
+}
+function createMuxWorkspace(initialPane, options = {}) {
+  return {
+    workspaceId: options.workspaceId || randomUUID(),
+    title: options.title || initialPane.displayName,
+    root: {
+      type: "pane",
+      paneId: initialPane.paneId
+    },
+    focusedPaneId: initialPane.paneId,
+    zoomedPaneId: null,
+    panes: {
+      [initialPane.paneId]: initialPane
+    }
+  };
+}
+function splitMuxPane(workspace, targetPaneId, axis, nextPane) {
+  if (!workspace.panes[targetPaneId]) {
+    throw new Error(`Unknown pane: ${targetPaneId}`);
+  }
+  const next = cloneWorkspace(workspace);
+  next.root = replaceNode(next.root, targetPaneId, {
+    type: "split",
+    axis,
+    ratio: 0.5,
+    first: { type: "pane", paneId: targetPaneId },
+    second: { type: "pane", paneId: nextPane.paneId }
+  });
+  next.panes[nextPane.paneId] = nextPane;
+  next.focusedPaneId = nextPane.paneId;
+  return next;
+}
+function removeMuxPane(workspace, paneId) {
+  if (!workspace.panes[paneId]) return workspace;
+  const root = removeNode(workspace.root, paneId);
+  if (!root) return null;
+  const next = cloneWorkspace(workspace);
+  delete next.panes[paneId];
+  next.root = root;
+  if (next.focusedPaneId === paneId) {
+    next.focusedPaneId = Object.keys(next.panes)[0] || "";
+  }
+  if (next.zoomedPaneId === paneId) {
+    next.zoomedPaneId = null;
+  }
+  return next;
+}
+function focusMuxPane(workspace, paneId) {
+  if (!workspace.panes[paneId]) {
+    throw new Error(`Unknown pane: ${paneId}`);
+  }
+  return {
+    ...workspace,
+    focusedPaneId: paneId
+  };
+}
+function updateMuxPane(workspace, pane) {
+  if (!workspace.panes[pane.paneId]) return workspace;
+  return {
+    ...workspace,
+    panes: {
+      ...workspace.panes,
+      [pane.paneId]: pane
+    }
+  };
+}
+function toggleMuxPaneZoom(workspace, paneId) {
+  if (!workspace.panes[paneId]) {
+    throw new Error(`Unknown pane: ${paneId}`);
+  }
+  return {
+    ...workspace,
+    focusedPaneId: paneId,
+    zoomedPaneId: workspace.zoomedPaneId === paneId ? null : paneId
+  };
+}
+function resizeMuxPane(workspace, paneId, direction, amount = 0.05) {
+  if (!workspace.panes[paneId]) {
+    throw new Error(`Unknown pane: ${paneId}`);
+  }
+  const axis = direction === "left" || direction === "right" ? "vertical" : "horizontal";
+  const delta = direction === "left" || direction === "up" ? -Math.abs(amount) : Math.abs(amount);
+  const adjusted = adjustNodeForPane(workspace.root, paneId, axis, delta);
+  if (!adjusted.changed) {
+    return workspace;
+  }
+  return {
+    ...workspace,
+    root: adjusted.node
+  };
+}
+function rebalanceMuxLayout(workspace) {
+  return {
+    ...workspace,
+    root: rebalanceNode(workspace.root)
+  };
+}
+function swapMuxPanePositions(workspace, firstPaneId, secondPaneId) {
+  if (firstPaneId === secondPaneId) return workspace;
+  if (!workspace.panes[firstPaneId]) throw new Error(`Unknown pane: ${firstPaneId}`);
+  if (!workspace.panes[secondPaneId]) throw new Error(`Unknown pane: ${secondPaneId}`);
+  return {
+    ...workspace,
+    root: mapPaneIds(workspace.root, firstPaneId, secondPaneId),
+    focusedPaneId: workspace.focusedPaneId === firstPaneId ? secondPaneId : workspace.focusedPaneId === secondPaneId ? firstPaneId : workspace.focusedPaneId,
+    zoomedPaneId: workspace.zoomedPaneId === firstPaneId ? secondPaneId : workspace.zoomedPaneId === secondPaneId ? firstPaneId : workspace.zoomedPaneId
+  };
+}
+function applyMuxLayoutPreset(workspace, preset) {
+  const paneIds = collectPaneIds(workspace.root);
+  const orderedPaneIds = [workspace.focusedPaneId, ...paneIds.filter((paneId) => paneId !== workspace.focusedPaneId)];
+  let root;
+  switch (preset) {
+    case "main-vertical":
+      root = buildMainLayout(orderedPaneIds, "vertical");
+      break;
+    case "main-horizontal":
+      root = buildMainLayout(orderedPaneIds, "horizontal");
+      break;
+    case "tiled":
+    case "even":
+    default:
+      root = buildEvenLayout(orderedPaneIds, "vertical");
+      break;
+  }
+  return { ...workspace, root };
+}
+
+// src/ghostty-terminal-surface.ts
+import { createRequire } from "module";
+var require2 = createRequire(
+  typeof __filename === "string" ? __filename : import.meta.url
+);
+var ghosttyBinding = require2("@adhdev/ghostty-vt-node");
+var GhosttyTerminalSurface = class {
+  terminal;
+  cols;
+  rows;
+  snapshotSeq = 0;
+  constructor(options = {}) {
+    this.cols = Math.max(1, options.cols ?? 120);
+    this.rows = Math.max(1, options.rows ?? 36);
+    const terminalOptions = {
+      cols: this.cols,
+      rows: this.rows,
+      scrollback: Math.max(1024, options.scrollback ?? 32768)
+    };
+    this.terminal = ghosttyBinding.createTerminal(terminalOptions);
+  }
+  resetFromText(text, snapshotSeq = 0) {
+    this.terminal.dispose();
+    this.terminal = ghosttyBinding.createTerminal({
+      cols: this.cols,
+      rows: this.rows,
+      scrollback: 32768
+    });
+    if (text) {
+      this.terminal.write(text);
+    }
+    this.snapshotSeq = snapshotSeq;
+  }
+  write(data, snapshotSeq) {
+    if (data) {
+      this.terminal.write(data);
+    }
+    if (typeof snapshotSeq === "number") {
+      this.snapshotSeq = snapshotSeq;
+    }
+  }
+  resize(cols, rows) {
+    this.cols = Math.max(1, cols | 0);
+    this.rows = Math.max(1, rows | 0);
+    this.terminal.resize(this.cols, this.rows);
+  }
+  getViewportState() {
+    return {
+      cols: this.cols,
+      rows: this.rows,
+      snapshotSeq: this.snapshotSeq,
+      text: this.terminal.formatPlainText({ trim: true }) || ""
+    };
+  }
+  dispose() {
+    this.terminal.dispose();
+  }
+};
+
+// src/runtime-targeting.ts
+import {
+  resolveAttachableRuntimeRecord
+} from "@adhdev/session-host-core";
+function resolveMuxOpenRuntimeRecord(records, identifier) {
+  return resolveAttachableRuntimeRecord(records, identifier);
+}
+
+// src/session-host-mux-client.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  resolveRuntimeRecord,
+  SessionHostClient
+} from "@adhdev/session-host-core";
+
+// src/workspace-persistence.ts
+function serializeWorkspace(workspace) {
+  return {
+    workspaceId: workspace.workspaceId,
+    title: workspace.title,
+    focusedPaneId: workspace.focusedPaneId,
+    zoomedPaneId: workspace.zoomedPaneId || null,
+    root: workspace.root,
+    panes: Object.fromEntries(
+      Object.entries(workspace.panes).map(([paneId, pane]) => [
+        paneId,
+        {
+          runtimeId: pane.runtimeId,
+          runtimeKey: pane.runtimeKey,
+          paneKind: pane.paneKind,
+          accessMode: pane.accessMode
+        }
+      ])
+    )
+  };
+}
+
+// src/session-host-mux-client.ts
+function paneFromRecord(paneId, record, surface, paneKind, accessMode) {
+  return {
+    paneId,
+    paneKind,
+    runtimeId: record.sessionId,
+    runtimeKey: record.runtimeKey,
+    displayName: record.displayName,
+    workspaceLabel: record.workspaceLabel,
+    accessMode,
+    lifecycle: record.lifecycle,
+    writeOwner: record.writeOwner,
+    attachedClients: record.attachedClients,
+    viewport: surface.getViewportState()
+  };
+}
+var SessionHostMuxClient = class {
+  clientId;
+  clientType = "local-terminal";
+  client;
+  paneById = /* @__PURE__ */ new Map();
+  paneIdsByRuntime = /* @__PURE__ */ new Map();
+  workspaceById = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  unsubEvents = null;
+  constructor(options = {}) {
+    this.client = new SessionHostClient(options);
+    this.clientId = options.clientId || `terminal-ui-${randomUUID2()}`;
+  }
+  async connect() {
+    await this.client.connect();
+    if (!this.unsubEvents) {
+      this.unsubEvents = this.client.onEvent((event) => {
+        void this.handleHostEvent(event);
+      });
+    }
+  }
+  onEvent(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async createWorkspace(target, options = {}) {
+    const pane = await this.openRuntime(target, options);
+    const workspace = createMuxWorkspace(pane, {
+      workspaceId: options.workspaceId,
+      title: options.title
+    });
+    this.workspaceById.set(workspace.workspaceId, workspace);
+    this.emit({ kind: "workspace", workspace });
+    return workspace;
+  }
+  async splitWorkspacePane(workspaceId, targetPaneId, runtimeTarget, options) {
+    const workspace = this.requireWorkspace(workspaceId);
+    const nextPane = await this.openRuntime(runtimeTarget, options);
+    const updated = splitMuxPane(workspace, targetPaneId, options.axis, nextPane);
+    this.workspaceById.set(workspaceId, updated);
+    this.emit({ kind: "workspace", workspace: updated });
+    return updated;
+  }
+  async splitWorkspaceMirror(workspaceId, targetPaneId, sourcePaneId, axis) {
+    const workspace = this.requireWorkspace(workspaceId);
+    const source = this.requirePane(sourcePaneId);
+    const paneId = randomUUID2();
+    const viewport = source.surface.getViewportState();
+    const surface = new GhosttyTerminalSurface({
+      cols: viewport.cols,
+      rows: viewport.rows
+    });
+    surface.resetFromText(viewport.text, viewport.snapshotSeq);
+    const paneState = paneFromRecord(paneId, source.record, surface, "mirror", "read-only");
+    this.paneById.set(paneId, {
+      record: source.record,
+      surface,
+      paneKind: "mirror",
+      accessMode: "read-only",
+      requestedReadOnly: true
+    });
+    const paneIds = this.paneIdsByRuntime.get(source.record.sessionId) || /* @__PURE__ */ new Set();
+    paneIds.add(paneId);
+    this.paneIdsByRuntime.set(source.record.sessionId, paneIds);
+    const updated = splitMuxPane(workspace, targetPaneId, axis, paneState);
+    this.workspaceById.set(workspaceId, updated);
+    this.emit({ kind: "runtime", pane: paneState });
+    this.emit({ kind: "workspace", workspace: updated });
+    return updated;
+  }
+  async replacePaneRuntime(workspaceId, paneId, runtimeTarget, options = {}) {
+    const workspace = this.requireWorkspace(workspaceId);
+    const existing = this.requirePane(paneId);
+    const previousRuntimeId = existing.record.sessionId;
+    const replacement = await this.openRuntime(runtimeTarget, {
+      ...options,
+      paneId
+    });
+    existing.surface.dispose();
+    if (previousRuntimeId !== replacement.runtimeId) {
+      const existingPaneIds = this.paneIdsByRuntime.get(previousRuntimeId);
+      existingPaneIds?.delete(paneId);
+      if (existingPaneIds && existingPaneIds.size === 0) {
+        this.paneIdsByRuntime.delete(previousRuntimeId);
+        await this.client.request({
+          type: "detach_session",
+          payload: {
+            sessionId: previousRuntimeId,
+            clientId: this.clientId
+          }
+        });
+      }
+    }
+    const updated = updateMuxPane(workspace, replacement);
+    this.workspaceById.set(workspaceId, updated);
+    this.emit({ kind: "workspace", workspace: updated });
+    return updated;
+  }
+  async restoreWorkspace(snapshot) {
+    await this.connect();
+    const panes = Object.entries(snapshot.panes);
+    if (panes.length === 0) {
+      throw new Error(`Workspace ${snapshot.workspaceId} has no panes`);
+    }
+    const orderedPanes = panes.sort(([, left], [, right]) => {
+      const leftKind = left.paneKind || "runtime";
+      const rightKind = right.paneKind || "runtime";
+      if (leftKind === rightKind) return 0;
+      return leftKind === "runtime" ? -1 : 1;
+    });
+    const restoredPanes = [];
+    for (const [paneId, pane] of orderedPanes) {
+      const paneKind = pane.paneKind || "runtime";
+      const opened = paneKind === "mirror" ? await this.openMirrorRuntime(pane.runtimeId || pane.runtimeKey, { paneId }) : await this.openRuntime(pane.runtimeId || pane.runtimeKey, {
+        paneId,
+        readOnly: pane.accessMode === "read-only",
+        takeover: false
+      });
+      restoredPanes.push([paneId, opened]);
+    }
+    const workspace = {
+      workspaceId: snapshot.workspaceId,
+      title: snapshot.title,
+      root: snapshot.root,
+      focusedPaneId: snapshot.focusedPaneId in snapshot.panes ? snapshot.focusedPaneId : restoredPanes[0][0],
+      zoomedPaneId: snapshot.zoomedPaneId && snapshot.zoomedPaneId in snapshot.panes ? snapshot.zoomedPaneId : null,
+      panes: Object.fromEntries(restoredPanes)
+    };
+    this.workspaceById.set(workspace.workspaceId, workspace);
+    this.emit({ kind: "workspace", workspace });
+    return workspace;
+  }
+  async closePane(workspaceId, paneId) {
+    const workspace = this.requireWorkspace(workspaceId);
+    const next = removeMuxPane(workspace, paneId);
+    const pane = this.paneById.get(paneId);
+    if (pane) {
+      pane.surface.dispose();
+      this.paneById.delete(paneId);
+      const paneIds = this.paneIdsByRuntime.get(pane.record.sessionId);
+      paneIds?.delete(paneId);
+      if (paneIds && paneIds.size === 0) {
+        this.paneIdsByRuntime.delete(pane.record.sessionId);
+        await this.client.request({
+          type: "detach_session",
+          payload: {
+            sessionId: pane.record.sessionId,
+            clientId: this.clientId
+          }
+        });
+      }
+    }
+    if (!next) {
+      this.workspaceById.delete(workspaceId);
+      return null;
+    }
+    this.workspaceById.set(workspaceId, next);
+    this.emit({ kind: "workspace", workspace: next });
+    return next;
+  }
+  async focusPane(workspaceId, paneId) {
+    const workspace = this.requireWorkspace(workspaceId);
+    const next = focusMuxPane(workspace, paneId);
+    this.workspaceById.set(workspaceId, next);
+    this.emit({ kind: "workspace", workspace: next });
+    return next;
+  }
+  async resizeLayoutPane(workspaceId, paneId, direction, amount = 0.05) {
+    const workspace = this.requireWorkspace(workspaceId);
+    const next = resizeMuxPane(workspace, paneId, direction, amount);
+    this.workspaceById.set(workspaceId, next);
+    this.emit({ kind: "workspace", workspace: next });
+    return next;
+  }
+  async rebalanceWorkspaceLayout(workspaceId) {
+    const workspace = this.requireWorkspace(workspaceId);
+    const next = rebalanceMuxLayout(workspace);
+    this.workspaceById.set(workspaceId, next);
+    this.emit({ kind: "workspace", workspace: next });
+    return next;
+  }
+  async applyLayoutPreset(workspaceId, preset) {
+    const workspace = this.requireWorkspace(workspaceId);
+    const next = applyMuxLayoutPreset(workspace, preset);
+    this.workspaceById.set(workspaceId, next);
+    this.emit({ kind: "workspace", workspace: next });
+    return next;
+  }
+  async swapPanePositions(workspaceId, firstPaneId, secondPaneId) {
+    const workspace = this.requireWorkspace(workspaceId);
+    const next = swapMuxPanePositions(workspace, firstPaneId, secondPaneId);
+    this.workspaceById.set(workspaceId, next);
+    this.emit({ kind: "workspace", workspace: next });
+    return next;
+  }
+  async togglePaneZoom(workspaceId, paneId) {
+    const workspace = this.requireWorkspace(workspaceId);
+    const next = toggleMuxPaneZoom(workspace, paneId);
+    this.workspaceById.set(workspaceId, next);
+    this.emit({ kind: "workspace", workspace: next });
+    return next;
+  }
+  async sendInput(paneId, data) {
+    const pane = this.requirePane(paneId);
+    if (pane.accessMode === "read-only" && !pane.requestedReadOnly && pane.paneKind === "runtime") {
+      await this.takeoverPane(paneId);
+    }
+    if (pane.accessMode === "read-only") {
+      throw new Error(`Pane ${paneId} is read-only`);
+    }
+    const response = await this.client.request({
+      type: "send_input",
+      payload: {
+        sessionId: pane.record.sessionId,
+        clientId: this.clientId,
+        data
+      }
+    });
+    if (!response.success) {
+      if ((response.error || "").includes("Write owned by") && !pane.requestedReadOnly && pane.paneKind === "runtime") {
+        await this.takeoverPane(paneId);
+        const retry = await this.client.request({
+          type: "send_input",
+          payload: {
+            sessionId: pane.record.sessionId,
+            clientId: this.clientId,
+            data
+          }
+        });
+        if (!retry.success) {
+          throw new Error(retry.error || `Failed to send input to pane ${paneId}`);
+        }
+        return;
+      }
+      throw new Error(response.error || `Failed to send input to pane ${paneId}`);
+    }
+  }
+  async resizePane(paneId, cols, rows) {
+    const pane = this.requirePane(paneId);
+    pane.surface.resize(cols, rows);
+    await this.client.request({
+      type: "resize_session",
+      payload: {
+        sessionId: pane.record.sessionId,
+        cols,
+        rows
+      }
+    });
+    this.publishPaneUpdate(paneId);
+  }
+  async takeoverPane(paneId) {
+    const pane = this.requirePane(paneId);
+    const response = await this.client.request({
+      type: "acquire_write",
+      payload: {
+        sessionId: pane.record.sessionId,
+        clientId: this.clientId,
+        ownerType: "user",
+        force: true
+      }
+    });
+    if (!response.success || !response.result) {
+      throw new Error(response.error || "Failed to acquire write owner");
+    }
+    pane.record = response.result;
+    pane.requestedReadOnly = false;
+    pane.accessMode = "interactive";
+    this.publishPaneUpdate(paneId);
+  }
+  async releasePane(paneId) {
+    const pane = this.requirePane(paneId);
+    const response = await this.client.request({
+      type: "release_write",
+      payload: {
+        sessionId: pane.record.sessionId,
+        clientId: this.clientId
+      }
+    });
+    if (!response.success || !response.result) {
+      throw new Error(response.error || "Failed to release write owner");
+    }
+    pane.record = response.result;
+    pane.requestedReadOnly = false;
+    pane.accessMode = this.computeAccessMode(pane.record, false, pane.paneKind);
+    this.publishPaneUpdate(paneId);
+  }
+  listWorkspaces() {
+    return Array.from(this.workspaceById.values());
+  }
+  async listRuntimes() {
+    await this.connect();
+    const list = await this.client.request({ type: "list_sessions" });
+    if (!list.success || !list.result) {
+      throw new Error(list.error || "Failed to list runtimes");
+    }
+    return list.result;
+  }
+  async resumeRuntime(target) {
+    await this.connect();
+    const record = resolveRuntimeRecord(await this.listRuntimes(), target);
+    const response = await this.client.request({
+      type: "resume_session",
+      payload: {
+        sessionId: record.sessionId
+      }
+    });
+    if (!response.success || !response.result) {
+      throw new Error(response.error || `Failed to resume runtime ${target}`);
+    }
+    for (const [paneId, pane] of this.paneById) {
+      if (pane.record.sessionId !== record.sessionId) continue;
+      pane.record = response.result;
+      this.publishPaneUpdate(paneId);
+    }
+    return response.result;
+  }
+  serializeWorkspace(workspaceId) {
+    return serializeWorkspace(this.requireWorkspace(workspaceId));
+  }
+  async close() {
+    for (const [paneId, pane] of this.paneById) {
+      try {
+        if (pane.record.writeOwner?.clientId === this.clientId) {
+          await this.client.request({
+            type: "release_write",
+            payload: {
+              sessionId: pane.record.sessionId,
+              clientId: this.clientId
+            }
+          });
+        }
+        const siblings = this.paneIdsByRuntime.get(pane.record.sessionId);
+        if (siblings?.size === 1) {
+          await this.client.request({
+            type: "detach_session",
+            payload: {
+              sessionId: pane.record.sessionId,
+              clientId: this.clientId
+            }
+          });
+        }
+      } catch {
+      }
+      pane.surface.dispose();
+      this.paneById.delete(paneId);
+    }
+    this.paneIdsByRuntime.clear();
+    this.workspaceById.clear();
+    this.unsubEvents?.();
+    this.unsubEvents = null;
+    await this.client.close();
+  }
+  async openRuntime(target, options) {
+    await this.connect();
+    let record = resolveMuxOpenRuntimeRecord(await this.listRuntimes(), target);
+    if (record.lifecycle === "interrupted") {
+      try {
+        record = await this.resumeRuntime(target);
+      } catch {
+      }
+    }
+    const readOnly = options.takeover ? false : !!options.readOnly || !!(record.writeOwner && record.writeOwner.clientId !== this.clientId);
+    const attachResponse = await this.client.request({
+      type: "attach_session",
+      payload: {
+        sessionId: record.sessionId,
+        clientId: this.clientId,
+        clientType: this.clientType,
+        readOnly
+      }
+    });
+    if (!attachResponse.success || !attachResponse.result) {
+      throw new Error(attachResponse.error || `Failed to attach runtime ${target}`);
+    }
+    record = attachResponse.result;
+    if (options.takeover) {
+      const takeoverResponse = await this.client.request({
+        type: "acquire_write",
+        payload: {
+          sessionId: record.sessionId,
+          clientId: this.clientId,
+          ownerType: "user",
+          force: true
+        }
+      });
+      if (!takeoverResponse.success || !takeoverResponse.result) {
+        throw new Error(takeoverResponse.error || `Failed to acquire runtime ${target}`);
+      }
+      record = takeoverResponse.result;
+    }
+    const snapshot = await this.client.request({
+      type: "get_snapshot",
+      payload: {
+        sessionId: record.sessionId
+      }
+    });
+    if (!snapshot.success || !snapshot.result) {
+      throw new Error(snapshot.error || "Failed to get runtime snapshot");
+    }
+    const paneId = options.paneId || randomUUID2();
+    const surface = new GhosttyTerminalSurface({
+      cols: options.cols ?? 120,
+      rows: options.rows ?? 36
+    });
+    surface.resetFromText(snapshot.result.text, snapshot.result.seq);
+    const runtimeRecord = {
+      ...record,
+      attachedClients: record.attachedClients
+    };
+    const accessMode = this.computeAccessMode(runtimeRecord, readOnly, "runtime");
+    const paneState = paneFromRecord(paneId, runtimeRecord, surface, "runtime", accessMode);
+    this.paneById.set(paneId, {
+      record: runtimeRecord,
+      surface,
+      paneKind: "runtime",
+      accessMode,
+      requestedReadOnly: readOnly
+    });
+    const paneIds = this.paneIdsByRuntime.get(runtimeRecord.sessionId) || /* @__PURE__ */ new Set();
+    paneIds.add(paneId);
+    this.paneIdsByRuntime.set(runtimeRecord.sessionId, paneIds);
+    this.emit({ kind: "runtime", pane: paneState });
+    return paneState;
+  }
+  async openMirrorRuntime(target, options = {}) {
+    const record = resolveRuntimeRecord(await this.listRuntimes(), target);
+    const runtimePane = Array.from(this.paneById.values()).find((pane) => pane.record.sessionId === record.sessionId);
+    if (!runtimePane) {
+      throw new Error(`Cannot mirror runtime ${record.runtimeKey} before it is attached`);
+    }
+    const paneId = options.paneId || randomUUID2();
+    const viewport = runtimePane.surface.getViewportState();
+    const surface = new GhosttyTerminalSurface({
+      cols: viewport.cols,
+      rows: viewport.rows
+    });
+    surface.resetFromText(viewport.text, viewport.snapshotSeq);
+    const paneState = paneFromRecord(paneId, record, surface, "mirror", "read-only");
+    this.paneById.set(paneId, {
+      record,
+      surface,
+      paneKind: "mirror",
+      accessMode: "read-only",
+      requestedReadOnly: true
+    });
+    const paneIds = this.paneIdsByRuntime.get(record.sessionId) || /* @__PURE__ */ new Set();
+    paneIds.add(paneId);
+    this.paneIdsByRuntime.set(record.sessionId, paneIds);
+    this.emit({ kind: "runtime", pane: paneState });
+    return paneState;
+  }
+  async handleHostEvent(event) {
+    const sessionId = "sessionId" in event ? event.sessionId : event.type === "runtime_transition" ? event.transition.sessionId : event.type === "request_trace" ? event.trace.sessionId : event.entry.sessionId;
+    if (!sessionId) return;
+    const paneIds = this.paneIdsByRuntime.get(sessionId);
+    if (!paneIds || paneIds.size === 0) return;
+    for (const paneId of paneIds) {
+      const pane = this.paneById.get(paneId);
+      if (!pane) continue;
+      switch (event.type) {
+        case "session_output":
+          pane.surface.write(event.data, event.seq);
+          break;
+        case "session_started":
+        case "session_resumed":
+          pane.record = { ...pane.record, lifecycle: "running", osPid: event.pid ?? pane.record.osPid };
+          break;
+        case "session_exit":
+          pane.record = { ...pane.record, lifecycle: event.exitCode === 0 ? "stopped" : "failed" };
+          break;
+        case "session_stopped":
+          pane.record = { ...pane.record, lifecycle: "stopped" };
+          break;
+        case "session_resized":
+          pane.surface.resize(event.cols, event.rows);
+          break;
+        case "write_owner_changed":
+          pane.record = { ...pane.record, writeOwner: event.owner };
+          pane.accessMode = this.computeAccessMode(pane.record, pane.requestedReadOnly, pane.paneKind);
+          break;
+        case "client_attached":
+          pane.record = {
+            ...pane.record,
+            attachedClients: [
+              ...pane.record.attachedClients.filter((client) => client.clientId !== event.client.clientId),
+              event.client
+            ]
+          };
+          pane.accessMode = this.computeAccessMode(pane.record, pane.requestedReadOnly, pane.paneKind);
+          break;
+        case "client_detached":
+          pane.record = {
+            ...pane.record,
+            attachedClients: pane.record.attachedClients.filter((client) => client.clientId !== event.clientId)
+          };
+          pane.accessMode = this.computeAccessMode(pane.record, pane.requestedReadOnly, pane.paneKind);
+          break;
+        case "session_created":
+          pane.record = event.record;
+          pane.accessMode = this.computeAccessMode(pane.record, pane.requestedReadOnly, pane.paneKind);
+          break;
+      }
+      this.publishPaneUpdate(paneId, event);
+    }
+  }
+  publishPaneUpdate(paneId, event) {
+    const pane = this.requirePane(paneId);
+    const paneState = paneFromRecord(paneId, pane.record, pane.surface, pane.paneKind, pane.accessMode);
+    this.emit({ kind: "runtime", pane: paneState, event });
+    for (const [workspaceId, workspace] of this.workspaceById) {
+      if (!workspace.panes[paneId]) continue;
+      const updated = updateMuxPane(workspace, paneState);
+      this.workspaceById.set(workspaceId, updated);
+      this.emit({ kind: "workspace", workspace: updated });
+    }
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  requireWorkspace(workspaceId) {
+    const workspace = this.workspaceById.get(workspaceId);
+    if (!workspace) throw new Error(`Unknown workspace: ${workspaceId}`);
+    return workspace;
+  }
+  requirePane(paneId) {
+    const pane = this.paneById.get(paneId);
+    if (!pane) throw new Error(`Unknown pane: ${paneId}`);
+    return pane;
+  }
+  computeAccessMode(record, requestedReadOnly, paneKind) {
+    if (paneKind === "mirror") return "read-only";
+    if (requestedReadOnly) return "read-only";
+    if (record.writeOwner && record.writeOwner.clientId !== this.clientId) return "read-only";
+    const attachedClient = record.attachedClients.find((client) => client.clientId === this.clientId);
+    if (attachedClient?.readOnly) return "read-only";
+    return "interactive";
+  }
+};
+export {
+  GhosttyTerminalSurface,
+  SessionHostMuxClient,
+  applyMuxLayoutPreset,
+  createMuxWorkspace,
+  focusMuxPane,
+  rebalanceMuxLayout,
+  removeMuxPane,
+  resizeMuxPane,
+  resolveMuxOpenRuntimeRecord,
+  serializeWorkspace,
+  splitMuxPane,
+  swapMuxPanePositions,
+  toggleMuxPaneZoom,
+  updateMuxPane
+};