adhdev 0.8.50 → 0.8.54

package/vendor/terminal-mux-cli/node_modules/@adhdev/terminal-mux-control/storage.js

@@ -0,0 +1,222 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  TerminalMuxStorage: () => TerminalMuxStorage,
+  buildWorkspaceName: () => buildWorkspaceName,
+  getRootDir: () => getRootDir,
+  getWorkspaceControlEndpoint: () => getWorkspaceControlEndpoint,
+  sanitizeWorkspaceName: () => sanitizeWorkspaceName,
+  toWorkspaceRef: () => toWorkspaceRef
+});
+module.exports = __toCommonJS(storage_exports);
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+function getRootDir() {
+  return import_path.default.join(import_os.default.homedir(), ".adhdev", "terminal-mux");
+}
+var WINDOW_MARKER = "--w--";
+function getWorkspacesDir() {
+  return import_path.default.join(getRootDir(), "workspaces");
+}
+function getStatePath() {
+  return import_path.default.join(getRootDir(), "state.json");
+}
+function sanitizeWorkspaceName(name) {
+  return name.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+function toWorkspaceRef(name) {
+  const workspaceName = sanitizeWorkspaceName(name);
+  const markerIndex = workspaceName.indexOf(WINDOW_MARKER);
+  if (markerIndex < 0) {
+    return {
+      sessionName: workspaceName,
+      windowName: workspaceName,
+      workspaceName
+    };
+  }
+  return {
+    sessionName: workspaceName.slice(0, markerIndex),
+    windowName: workspaceName.slice(markerIndex + WINDOW_MARKER.length),
+    workspaceName
+  };
+}
+function buildWorkspaceName(sessionName, windowName) {
+  const session = sanitizeWorkspaceName(sessionName);
+  const window = sanitizeWorkspaceName(windowName);
+  if (!session || session === window) return window;
+  return `${session}${WINDOW_MARKER}${window}`;
+}
+function getWorkspaceControlEndpoint(name) {
+  const sanitized = sanitizeWorkspaceName(name);
+  if (process.platform === "win32") {
+    return {
+      kind: "pipe",
+      path: `\\\\.\\pipe\\adhmux-${sanitized}`
+    };
+  }
+  return {
+    kind: "unix",
+    path: import_path.default.join(import_os.default.tmpdir(), `adhmux-${sanitized}.sock`)
+  };
+}
+var TerminalMuxStorage = class {
+  workspacesDir = getWorkspacesDir();
+  statePath = getStatePath();
+  listWorkspaceNames() {
+    return this.listWorkspaces().map((workspace) => workspace.name);
+  }
+  listWorkspaces() {
+    if (!import_fs.default.existsSync(this.workspacesDir)) return [];
+    return import_fs.default.readdirSync(this.workspacesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).flatMap((entry) => {
+      const name = entry.name.replace(/\.json$/, "");
+      const filePath = this.getWorkspacePath(name);
+      let title = name;
+      let paneCount = 0;
+      let updatedAt = 0;
+      try {
+        const parsed = JSON.parse(import_fs.default.readFileSync(filePath, "utf8"));
+        title = parsed.title || name;
+        paneCount = Object.keys(parsed.panes || {}).length;
+        updatedAt = import_fs.default.statSync(filePath).mtimeMs;
+      } catch {
+        return [];
+      }
+      return [{
+        name,
+        title,
+        paneCount,
+        updatedAt
+      }];
+    }).sort((a, b) => b.updatedAt - a.updatedAt || a.name.localeCompare(b.name));
+  }
+  listSessions() {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const workspace of this.listWorkspaces()) {
+      const ref = toWorkspaceRef(workspace.name);
+      const items = grouped.get(ref.sessionName) || [];
+      items.push(workspace);
+      grouped.set(ref.sessionName, items);
+    }
+    return Array.from(grouped.entries()).map(([sessionName, workspaces]) => {
+      const sorted = [...workspaces].sort((a, b) => b.updatedAt - a.updatedAt || a.name.localeCompare(b.name));
+      const active = sorted[0];
+      return {
+        name: sessionName,
+        title: toWorkspaceRef(active.name).sessionName,
+        windowCount: workspaces.length,
+        updatedAt: active.updatedAt,
+        activeWindowName: toWorkspaceRef(active.name).windowName
+      };
+    }).sort((a, b) => b.updatedAt - a.updatedAt || a.name.localeCompare(b.name));
+  }
+  listSessionWindows(sessionName) {
+    const normalizedSession = sanitizeWorkspaceName(sessionName);
+    return this.listWorkspaces().filter((workspace) => toWorkspaceRef(workspace.name).sessionName === normalizedSession);
+  }
+  resolveSessionWindowWorkspace(sessionName, windowName) {
+    const windows = this.listSessionWindows(sessionName);
+    if (windows.length === 0) return null;
+    if (!windowName) return windows[0].name;
+    const normalizedWindow = sanitizeWorkspaceName(windowName);
+    const exact = windows.find((workspace) => toWorkspaceRef(workspace.name).windowName === normalizedWindow);
+    return exact?.name || null;
+  }
+  loadWorkspace(name) {
+    const filePath = this.getWorkspacePath(name);
+    if (!import_fs.default.existsSync(filePath)) return null;
+    const parsed = JSON.parse(import_fs.default.readFileSync(filePath, "utf8"));
+    return parsed?.workspaceId ? parsed : null;
+  }
+  saveWorkspace(name, workspace) {
+    import_fs.default.mkdirSync(this.workspacesDir, { recursive: true });
+    import_fs.default.writeFileSync(this.getWorkspacePath(name), JSON.stringify(workspace, null, 2), "utf8");
+  }
+  renameWorkspace(fromName, toName) {
+    const fromPath = this.getWorkspacePath(fromName);
+    const toPath = this.getWorkspacePath(toName);
+    if (!import_fs.default.existsSync(fromPath)) {
+      throw new Error(`Workspace not found: ${fromName}`);
+    }
+    import_fs.default.mkdirSync(this.workspacesDir, { recursive: true });
+    import_fs.default.renameSync(fromPath, toPath);
+  }
+  deleteWorkspace(name) {
+    const filePath = this.getWorkspacePath(name);
+    if (!import_fs.default.existsSync(filePath)) {
+      throw new Error(`Workspace not found: ${name}`);
+    }
+    import_fs.default.unlinkSync(filePath);
+    const state = this.loadClientState();
+    if (state.lastWorkspace === sanitizeWorkspaceName(name)) {
+      this.saveClientState({ ...state, lastWorkspace: void 0, updatedAt: Date.now() });
+    }
+  }
+  getLastWorkspace() {
+    const state = this.loadClientState();
+    return state.lastWorkspace || null;
+  }
+  setLastWorkspace(name) {
+    this.saveClientState({
+      ...this.loadClientState(),
+      lastWorkspace: sanitizeWorkspaceName(name),
+      updatedAt: Date.now()
+    });
+  }
+  getWorkspacePath(name) {
+    return import_path.default.join(this.workspacesDir, `${sanitizeWorkspaceName(name)}.json`);
+  }
+  loadClientState() {
+    if (!import_fs.default.existsSync(this.statePath)) {
+      return { updatedAt: 0 };
+    }
+    try {
+      const parsed = JSON.parse(import_fs.default.readFileSync(this.statePath, "utf8"));
+      return typeof parsed === "object" && parsed ? parsed : { updatedAt: 0 };
+    } catch {
+      return { updatedAt: 0 };
+    }
+  }
+  saveClientState(state) {
+    import_fs.default.mkdirSync(getRootDir(), { recursive: true });
+    import_fs.default.writeFileSync(this.statePath, JSON.stringify(state, null, 2), "utf8");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TerminalMuxStorage,
+  buildWorkspaceName,
+  getRootDir,
+  getWorkspaceControlEndpoint,
+  sanitizeWorkspaceName,
+  toWorkspaceRef
+});

package/vendor/terminal-mux-cli/node_modules/@adhdev/terminal-mux-control/storage.mjs

@@ -0,0 +1,16 @@
+import {
+  TerminalMuxStorage,
+  buildWorkspaceName,
+  getRootDir,
+  getWorkspaceControlEndpoint,
+  sanitizeWorkspaceName,
+  toWorkspaceRef
+} from "./chunk-7RNMRPVZ.mjs";
+export {
+  TerminalMuxStorage,
+  buildWorkspaceName,
+  getRootDir,
+  getWorkspaceControlEndpoint,
+  sanitizeWorkspaceName,
+  toWorkspaceRef
+};

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

@@ -0,0 +1,164 @@
+import { SessionHostRecord, SessionWriteOwner, SessionAttachedClient, SessionHostEvent, SessionHostClientOptions } from '@adhdev/session-host-core';
+
+type MuxAxis = 'horizontal' | 'vertical';
+type PaneAccessMode = 'interactive' | 'read-only';
+type MuxPaneKind = 'runtime' | 'mirror';
+type MuxLayoutPreset = 'even' | 'main-vertical' | 'main-horizontal' | 'tiled';
+interface TerminalViewportState {
+    cols: number;
+    rows: number;
+    snapshotSeq: number;
+    text: string;
+}
+interface RuntimePaneState {
+    paneId: string;
+    paneKind: MuxPaneKind;
+    runtimeId: string;
+    runtimeKey: string;
+    displayName: string;
+    workspaceLabel: string;
+    accessMode: PaneAccessMode;
+    lifecycle: SessionHostRecord['lifecycle'];
+    writeOwner: SessionWriteOwner | null;
+    attachedClients: SessionAttachedClient[];
+    viewport: TerminalViewportState;
+}
+type MuxLayoutNode = {
+    type: 'pane';
+    paneId: string;
+} | {
+    type: 'split';
+    axis: MuxAxis;
+    ratio: number;
+    first: MuxLayoutNode;
+    second: MuxLayoutNode;
+};
+interface MuxWorkspaceState {
+    workspaceId: string;
+    title: string;
+    root: MuxLayoutNode;
+    focusedPaneId: string;
+    zoomedPaneId?: string | null;
+    panes: Record<string, RuntimePaneState>;
+}
+interface OpenRuntimeOptions {
+    readOnly?: boolean;
+    takeover?: boolean;
+    cols?: number;
+    rows?: number;
+    paneId?: string;
+}
+interface CreateWorkspaceOptions extends OpenRuntimeOptions {
+    workspaceId?: string;
+    title?: string;
+}
+interface SplitPaneOptions extends OpenRuntimeOptions {
+    axis: MuxAxis;
+}
+interface RuntimePaneUpdate {
+    kind: 'runtime';
+    pane: RuntimePaneState;
+    event?: SessionHostEvent;
+}
+interface WorkspaceUpdate {
+    kind: 'workspace';
+    workspace: MuxWorkspaceState;
+}
+type MuxControllerEvent = RuntimePaneUpdate | WorkspaceUpdate;
+interface PersistedMuxWorkspaceState {
+    workspaceId: string;
+    title: string;
+    focusedPaneId: string;
+    zoomedPaneId?: string | null;
+    root: MuxLayoutNode;
+    panes: Record<string, {
+        runtimeId?: string;
+        runtimeKey: string;
+        paneKind: MuxPaneKind;
+        accessMode: PaneAccessMode;
+    }>;
+}
+
+type ResizeDirection = 'left' | 'right' | 'up' | 'down';
+declare function createMuxWorkspace(initialPane: RuntimePaneState, options?: {
+    workspaceId?: string;
+    title?: string;
+}): MuxWorkspaceState;
+declare function splitMuxPane(workspace: MuxWorkspaceState, targetPaneId: string, axis: MuxAxis, nextPane: RuntimePaneState): MuxWorkspaceState;
+declare function removeMuxPane(workspace: MuxWorkspaceState, paneId: string): MuxWorkspaceState | null;
+declare function focusMuxPane(workspace: MuxWorkspaceState, paneId: string): MuxWorkspaceState;
+declare function updateMuxPane(workspace: MuxWorkspaceState, pane: RuntimePaneState): MuxWorkspaceState;
+declare function toggleMuxPaneZoom(workspace: MuxWorkspaceState, paneId: string): MuxWorkspaceState;
+declare function resizeMuxPane(workspace: MuxWorkspaceState, paneId: string, direction: ResizeDirection, amount?: number): MuxWorkspaceState;
+declare function rebalanceMuxLayout(workspace: MuxWorkspaceState): MuxWorkspaceState;
+declare function swapMuxPanePositions(workspace: MuxWorkspaceState, firstPaneId: string, secondPaneId: string): MuxWorkspaceState;
+declare function applyMuxLayoutPreset(workspace: MuxWorkspaceState, preset: MuxLayoutPreset): MuxWorkspaceState;
+
+interface GhosttyTerminalSurfaceOptions {
+    cols?: number;
+    rows?: number;
+    scrollback?: number;
+}
+declare class GhosttyTerminalSurface {
+    private terminal;
+    private cols;
+    private rows;
+    private snapshotSeq;
+    constructor(options?: GhosttyTerminalSurfaceOptions);
+    resetFromText(text: string, snapshotSeq?: number): void;
+    write(data: string, snapshotSeq?: number): void;
+    resize(cols: number, rows: number): void;
+    getViewportState(): TerminalViewportState;
+    dispose(): void;
+}
+
+declare function resolveMuxOpenRuntimeRecord(records: SessionHostRecord[], identifier: string): SessionHostRecord;
+
+declare class SessionHostMuxClient {
+    readonly clientId: string;
+    readonly clientType = "local-terminal";
+    private client;
+    private paneById;
+    private paneIdsByRuntime;
+    private workspaceById;
+    private listeners;
+    private unsubEvents;
+    constructor(options?: SessionHostClientOptions & {
+        clientId?: string;
+    });
+    connect(): Promise<void>;
+    onEvent(listener: (event: MuxControllerEvent) => void): () => void;
+    createWorkspace(target: string, options?: CreateWorkspaceOptions): Promise<MuxWorkspaceState>;
+    splitWorkspacePane(workspaceId: string, targetPaneId: string, runtimeTarget: string, options: SplitPaneOptions): Promise<MuxWorkspaceState>;
+    splitWorkspaceMirror(workspaceId: string, targetPaneId: string, sourcePaneId: string, axis: SplitPaneOptions['axis']): Promise<MuxWorkspaceState>;
+    replacePaneRuntime(workspaceId: string, paneId: string, runtimeTarget: string, options?: OpenRuntimeOptions): Promise<MuxWorkspaceState>;
+    restoreWorkspace(snapshot: PersistedMuxWorkspaceState): Promise<MuxWorkspaceState>;
+    closePane(workspaceId: string, paneId: string): Promise<MuxWorkspaceState | null>;
+    focusPane(workspaceId: string, paneId: string): Promise<MuxWorkspaceState>;
+    resizeLayoutPane(workspaceId: string, paneId: string, direction: 'left' | 'right' | 'up' | 'down', amount?: number): Promise<MuxWorkspaceState>;
+    rebalanceWorkspaceLayout(workspaceId: string): Promise<MuxWorkspaceState>;
+    applyLayoutPreset(workspaceId: string, preset: MuxLayoutPreset): Promise<MuxWorkspaceState>;
+    swapPanePositions(workspaceId: string, firstPaneId: string, secondPaneId: string): Promise<MuxWorkspaceState>;
+    togglePaneZoom(workspaceId: string, paneId: string): Promise<MuxWorkspaceState>;
+    sendInput(paneId: string, data: string): Promise<void>;
+    resizePane(paneId: string, cols: number, rows: number): Promise<void>;
+    takeoverPane(paneId: string): Promise<void>;
+    releasePane(paneId: string): Promise<void>;
+    listWorkspaces(): MuxWorkspaceState[];
+    listRuntimes(): Promise<SessionHostRecord[]>;
+    resumeRuntime(target: string): Promise<SessionHostRecord>;
+    serializeWorkspace(workspaceId: string): PersistedMuxWorkspaceState;
+    close(): Promise<void>;
+    private openRuntime;
+    private openMirrorRuntime;
+    private handleHostEvent;
+    private publishPaneUpdate;
+    private emit;
+    private requireWorkspace;
+    private requirePane;
+    private computeAccessMode;
+}
+
+declare function serializeWorkspace(workspace: MuxWorkspaceState): PersistedMuxWorkspaceState;
+
+export { type CreateWorkspaceOptions, GhosttyTerminalSurface, type GhosttyTerminalSurfaceOptions, type MuxAxis, type MuxControllerEvent, type MuxLayoutNode, type MuxLayoutPreset, type MuxWorkspaceState, type OpenRuntimeOptions, type PaneAccessMode, type PersistedMuxWorkspaceState, type RuntimePaneState, SessionHostMuxClient, type SplitPaneOptions, type TerminalViewportState, applyMuxLayoutPreset, createMuxWorkspace, focusMuxPane, rebalanceMuxLayout, removeMuxPane, resizeMuxPane, resolveMuxOpenRuntimeRecord, serializeWorkspace, splitMuxPane, swapMuxPanePositions, toggleMuxPaneZoom, updateMuxPane };

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

@@ -0,0 +1,164 @@
+import { SessionHostRecord, SessionWriteOwner, SessionAttachedClient, SessionHostEvent, SessionHostClientOptions } from '@adhdev/session-host-core';
+
+type MuxAxis = 'horizontal' | 'vertical';
+type PaneAccessMode = 'interactive' | 'read-only';
+type MuxPaneKind = 'runtime' | 'mirror';
+type MuxLayoutPreset = 'even' | 'main-vertical' | 'main-horizontal' | 'tiled';
+interface TerminalViewportState {
+    cols: number;
+    rows: number;
+    snapshotSeq: number;
+    text: string;
+}
+interface RuntimePaneState {
+    paneId: string;
+    paneKind: MuxPaneKind;
+    runtimeId: string;
+    runtimeKey: string;
+    displayName: string;
+    workspaceLabel: string;
+    accessMode: PaneAccessMode;
+    lifecycle: SessionHostRecord['lifecycle'];
+    writeOwner: SessionWriteOwner | null;
+    attachedClients: SessionAttachedClient[];
+    viewport: TerminalViewportState;
+}
+type MuxLayoutNode = {
+    type: 'pane';
+    paneId: string;
+} | {
+    type: 'split';
+    axis: MuxAxis;
+    ratio: number;
+    first: MuxLayoutNode;
+    second: MuxLayoutNode;
+};
+interface MuxWorkspaceState {
+    workspaceId: string;
+    title: string;
+    root: MuxLayoutNode;
+    focusedPaneId: string;
+    zoomedPaneId?: string | null;
+    panes: Record<string, RuntimePaneState>;
+}
+interface OpenRuntimeOptions {
+    readOnly?: boolean;
+    takeover?: boolean;
+    cols?: number;
+    rows?: number;
+    paneId?: string;
+}
+interface CreateWorkspaceOptions extends OpenRuntimeOptions {
+    workspaceId?: string;
+    title?: string;
+}
+interface SplitPaneOptions extends OpenRuntimeOptions {
+    axis: MuxAxis;
+}
+interface RuntimePaneUpdate {
+    kind: 'runtime';
+    pane: RuntimePaneState;
+    event?: SessionHostEvent;
+}
+interface WorkspaceUpdate {
+    kind: 'workspace';
+    workspace: MuxWorkspaceState;
+}
+type MuxControllerEvent = RuntimePaneUpdate | WorkspaceUpdate;
+interface PersistedMuxWorkspaceState {
+    workspaceId: string;
+    title: string;
+    focusedPaneId: string;
+    zoomedPaneId?: string | null;
+    root: MuxLayoutNode;
+    panes: Record<string, {
+        runtimeId?: string;
+        runtimeKey: string;
+        paneKind: MuxPaneKind;
+        accessMode: PaneAccessMode;
+    }>;
+}
+
+type ResizeDirection = 'left' | 'right' | 'up' | 'down';
+declare function createMuxWorkspace(initialPane: RuntimePaneState, options?: {
+    workspaceId?: string;
+    title?: string;
+}): MuxWorkspaceState;
+declare function splitMuxPane(workspace: MuxWorkspaceState, targetPaneId: string, axis: MuxAxis, nextPane: RuntimePaneState): MuxWorkspaceState;
+declare function removeMuxPane(workspace: MuxWorkspaceState, paneId: string): MuxWorkspaceState | null;
+declare function focusMuxPane(workspace: MuxWorkspaceState, paneId: string): MuxWorkspaceState;
+declare function updateMuxPane(workspace: MuxWorkspaceState, pane: RuntimePaneState): MuxWorkspaceState;
+declare function toggleMuxPaneZoom(workspace: MuxWorkspaceState, paneId: string): MuxWorkspaceState;
+declare function resizeMuxPane(workspace: MuxWorkspaceState, paneId: string, direction: ResizeDirection, amount?: number): MuxWorkspaceState;
+declare function rebalanceMuxLayout(workspace: MuxWorkspaceState): MuxWorkspaceState;
+declare function swapMuxPanePositions(workspace: MuxWorkspaceState, firstPaneId: string, secondPaneId: string): MuxWorkspaceState;
+declare function applyMuxLayoutPreset(workspace: MuxWorkspaceState, preset: MuxLayoutPreset): MuxWorkspaceState;
+
+interface GhosttyTerminalSurfaceOptions {
+    cols?: number;
+    rows?: number;
+    scrollback?: number;
+}
+declare class GhosttyTerminalSurface {
+    private terminal;
+    private cols;
+    private rows;
+    private snapshotSeq;
+    constructor(options?: GhosttyTerminalSurfaceOptions);
+    resetFromText(text: string, snapshotSeq?: number): void;
+    write(data: string, snapshotSeq?: number): void;
+    resize(cols: number, rows: number): void;
+    getViewportState(): TerminalViewportState;
+    dispose(): void;
+}
+
+declare function resolveMuxOpenRuntimeRecord(records: SessionHostRecord[], identifier: string): SessionHostRecord;
+
+declare class SessionHostMuxClient {
+    readonly clientId: string;
+    readonly clientType = "local-terminal";
+    private client;
+    private paneById;
+    private paneIdsByRuntime;
+    private workspaceById;
+    private listeners;
+    private unsubEvents;
+    constructor(options?: SessionHostClientOptions & {
+        clientId?: string;
+    });
+    connect(): Promise<void>;
+    onEvent(listener: (event: MuxControllerEvent) => void): () => void;
+    createWorkspace(target: string, options?: CreateWorkspaceOptions): Promise<MuxWorkspaceState>;
+    splitWorkspacePane(workspaceId: string, targetPaneId: string, runtimeTarget: string, options: SplitPaneOptions): Promise<MuxWorkspaceState>;
+    splitWorkspaceMirror(workspaceId: string, targetPaneId: string, sourcePaneId: string, axis: SplitPaneOptions['axis']): Promise<MuxWorkspaceState>;
+    replacePaneRuntime(workspaceId: string, paneId: string, runtimeTarget: string, options?: OpenRuntimeOptions): Promise<MuxWorkspaceState>;
+    restoreWorkspace(snapshot: PersistedMuxWorkspaceState): Promise<MuxWorkspaceState>;
+    closePane(workspaceId: string, paneId: string): Promise<MuxWorkspaceState | null>;
+    focusPane(workspaceId: string, paneId: string): Promise<MuxWorkspaceState>;
+    resizeLayoutPane(workspaceId: string, paneId: string, direction: 'left' | 'right' | 'up' | 'down', amount?: number): Promise<MuxWorkspaceState>;
+    rebalanceWorkspaceLayout(workspaceId: string): Promise<MuxWorkspaceState>;
+    applyLayoutPreset(workspaceId: string, preset: MuxLayoutPreset): Promise<MuxWorkspaceState>;
+    swapPanePositions(workspaceId: string, firstPaneId: string, secondPaneId: string): Promise<MuxWorkspaceState>;
+    togglePaneZoom(workspaceId: string, paneId: string): Promise<MuxWorkspaceState>;
+    sendInput(paneId: string, data: string): Promise<void>;
+    resizePane(paneId: string, cols: number, rows: number): Promise<void>;
+    takeoverPane(paneId: string): Promise<void>;
+    releasePane(paneId: string): Promise<void>;
+    listWorkspaces(): MuxWorkspaceState[];
+    listRuntimes(): Promise<SessionHostRecord[]>;
+    resumeRuntime(target: string): Promise<SessionHostRecord>;
+    serializeWorkspace(workspaceId: string): PersistedMuxWorkspaceState;
+    close(): Promise<void>;
+    private openRuntime;
+    private openMirrorRuntime;
+    private handleHostEvent;
+    private publishPaneUpdate;
+    private emit;
+    private requireWorkspace;
+    private requirePane;
+    private computeAccessMode;
+}
+
+declare function serializeWorkspace(workspace: MuxWorkspaceState): PersistedMuxWorkspaceState;
+
+export { type CreateWorkspaceOptions, GhosttyTerminalSurface, type GhosttyTerminalSurfaceOptions, type MuxAxis, type MuxControllerEvent, type MuxLayoutNode, type MuxLayoutPreset, type MuxWorkspaceState, type OpenRuntimeOptions, type PaneAccessMode, type PersistedMuxWorkspaceState, type RuntimePaneState, SessionHostMuxClient, type SplitPaneOptions, type TerminalViewportState, applyMuxLayoutPreset, createMuxWorkspace, focusMuxPane, rebalanceMuxLayout, removeMuxPane, resizeMuxPane, resolveMuxOpenRuntimeRecord, serializeWorkspace, splitMuxPane, swapMuxPanePositions, toggleMuxPaneZoom, updateMuxPane };