@tutti-os/workspace-terminal 0.0.1

package/dist/chunk-FEJT6FJ4.js

@@ -0,0 +1,1722 @@
+import {
+  createBufferedTerminalInputQueue,
+  createTerminalAttachmentController,
+  createTerminalCloseDiagnostics,
+  createTerminalScreenStateCache,
+  createTerminalSessionRecoveryDiagnostics,
+  createTerminalSurfaceDiagnostics,
+  detectTerminalFileLinks,
+  isTerminalSessionEndedStatus,
+  resolveTerminalScrollbackDelta,
+  toTerminalLinkTarget,
+  truncateTerminalScrollback,
+  writeQueuedTerminalInput
+} from "./chunk-56B5GYMU.js";
+
+// src/core/sessionControllerRecovery.ts
+function createTerminalSessionRecovery(input) {
+  let disposed = false;
+  let hydrationReady = false;
+  const hydrationReplayChunks = [];
+  const disposeData = input.transportRuntime.onData((event) => {
+    if (disposed || event.sessionId !== input.sessionId) {
+      return;
+    }
+    if (!hydrationReady) {
+      hydrationReplayChunks.push(event.data);
+      return;
+    }
+    input.store.appendRawOutput(event.data);
+  });
+  const disposeState = input.transportRuntime.onState((event) => {
+    if (disposed || event.sessionId !== input.sessionId) {
+      return;
+    }
+    if (typeof event.gapStartSeq === "number" && typeof event.gapEndSeq === "number") {
+      input.diagnostics.hydrationGap({
+        fromSeq: event.gapStartSeq,
+        toSeq: event.gapEndSeq
+      });
+      input.store.setSurfaceError(input.replayGapMessage);
+      return;
+    }
+    if (event.error) {
+      input.store.setSurfaceError(event.error);
+    }
+    if (event.status === "detached") {
+      input.onWriteReadyChange(false);
+      input.store.setInputReady(false);
+      input.onRecoverableDetach();
+      return;
+    }
+    if (event.status === "exited") {
+      input.onWriteReadyChange(false);
+      input.store.setInputReady(false);
+    }
+  });
+  const disposeExit = input.transportRuntime.onExit((event) => {
+    if (disposed || event.sessionId !== input.sessionId) {
+      return;
+    }
+    input.onWriteReadyChange(false);
+    input.store.setInputReady(false);
+  });
+  const disposeMetadata = input.transportRuntime.onMetadata(() => void 0);
+  return {
+    dispose() {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      hydrationReady = false;
+      hydrationReplayChunks.length = 0;
+      disposeData();
+      disposeState();
+      disposeExit();
+      disposeMetadata();
+    },
+    async start() {
+      input.diagnostics.hydrationStart();
+      input.diagnostics.snapshotStart();
+      try {
+        const snapshot = await input.transportRuntime.snapshot();
+        if (disposed) {
+          return;
+        }
+        input.store.replaceRawOutput(snapshot.data);
+        const snapshotState = input.store.getState();
+        input.diagnostics.outputProjected({
+          contentEpoch: snapshotState.contentEpoch,
+          previewHead: previewTerminalOutput(snapshot.data, "head"),
+          previewTail: previewTerminalOutput(snapshot.data, "tail"),
+          rawBytes: snapshotState.rawOutput.length,
+          source: "snapshot",
+          writeBytes: snapshot.data.length
+        });
+        if (snapshot.truncated) {
+          input.store.setSurfaceError(input.snapshotTruncatedMessage);
+        } else {
+          input.store.setSurfaceError(null);
+        }
+        input.diagnostics.snapshotComplete({
+          toSeq: snapshot.toSeq ?? null,
+          truncated: snapshot.truncated ?? false
+        });
+        input.diagnostics.attachStart(snapshot.toSeq ?? null);
+        await input.transportRuntime.attach(snapshot.toSeq);
+        if (disposed) {
+          return;
+        }
+        hydrationReady = true;
+        const replayChunks = hydrationReplayChunks.splice(0);
+        replayChunks.forEach((chunk) => {
+          input.store.appendRawOutput(chunk);
+        });
+        if (replayChunks.length > 0) {
+          const replayState = input.store.getState();
+          input.diagnostics.outputProjected({
+            contentEpoch: replayState.contentEpoch,
+            previewHead: previewTerminalOutput(replayChunks.join(""), "head"),
+            previewTail: previewTerminalOutput(replayChunks.join(""), "tail"),
+            rawBytes: replayState.rawOutput.length,
+            source: "replay",
+            writeBytes: replayChunks.reduce(
+              (total, chunk) => total + chunk.length,
+              0
+            )
+          });
+        }
+        input.onWriteReadyChange(true);
+        input.store.setInputReady(true);
+        await writeQueuedTerminalInput({
+          queue: input.inputQueue,
+          sessionId: input.sessionId,
+          transport: input.transport
+        });
+        if (disposed) {
+          return;
+        }
+        input.diagnostics.attachComplete();
+        input.diagnostics.hydrationComplete(replayChunks.length);
+      } catch (error) {
+        if (disposed) {
+          return;
+        }
+        input.diagnostics.attachError();
+        input.store.setSurfaceError(errorMessage(error));
+      }
+    }
+  };
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function previewTerminalOutput(value, side, maxChars = 48) {
+  const slice = side === "head" ? value.slice(0, maxChars) : value.slice(Math.max(0, value.length - maxChars));
+  return slice.replaceAll("\\", "\\\\").replaceAll("\r", "\\r").replaceAll("\n", "\\n");
+}
+
+// src/core/sessionControllerStore.ts
+var initialState = {
+  contentEpoch: 0,
+  inputReady: false,
+  rawOutput: "",
+  surfaceError: null
+};
+function createTerminalSessionControllerStore(input) {
+  let state = initialState;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    appendRawOutput(data) {
+      if (!data) {
+        return;
+      }
+      const nextOutput = truncateTerminalScrollback(
+        `${state.rawOutput}${data}`,
+        {
+          maxChars: input.maxScrollbackChars
+        }
+      );
+      if (nextOutput === state.rawOutput) {
+        return;
+      }
+      state = {
+        ...state,
+        rawOutput: nextOutput
+      };
+      emitState(listeners);
+    },
+    clearListeners() {
+      listeners.clear();
+    },
+    getState() {
+      return state;
+    },
+    replaceRawOutput(rawOutput) {
+      state = {
+        ...state,
+        contentEpoch: state.contentEpoch + 1,
+        rawOutput: truncateTerminalScrollback(rawOutput, {
+          maxChars: input.maxScrollbackChars
+        })
+      };
+      emitState(listeners);
+    },
+    setInputReady(inputReady) {
+      if (state.inputReady === inputReady) {
+        return;
+      }
+      state = {
+        ...state,
+        inputReady
+      };
+      emitState(listeners);
+    },
+    setSurfaceError(surfaceError) {
+      if (state.surfaceError === surfaceError) {
+        return;
+      }
+      state = {
+        ...state,
+        surfaceError
+      };
+      emitState(listeners);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function emitState(listeners) {
+  for (const listener of listeners) {
+    listener();
+  }
+}
+
+// src/core/sessionTransportRuntime.ts
+var defaultDetachGraceMs = 200;
+var runtimeRegistry = /* @__PURE__ */ new Map();
+var runtimeClientSequence = 0;
+function acquireTerminalSessionTransportRuntime(input) {
+  const entry = runtimeRegistry.get(input.sessionId) ?? createTerminalSessionTransportRuntimeEntry(input);
+  if (!runtimeRegistry.has(input.sessionId)) {
+    runtimeRegistry.set(input.sessionId, entry);
+  }
+  entry.refCount += 1;
+  if (entry.detachTimer !== null) {
+    clearTimeout(entry.detachTimer);
+    entry.detachTimer = null;
+  }
+  return {
+    attach(afterSeq) {
+      return entry.attach(afterSeq);
+    },
+    onData(listener) {
+      entry.dataListeners.add(listener);
+      flushBufferedEvents(entry.dataBuffer, listener);
+      return () => {
+        entry.dataListeners.delete(listener);
+      };
+    },
+    onExit(listener) {
+      entry.exitListeners.add(listener);
+      flushBufferedEvents(entry.exitBuffer, listener);
+      return () => {
+        entry.exitListeners.delete(listener);
+      };
+    },
+    onMetadata(listener) {
+      entry.metadataListeners.add(listener);
+      flushBufferedEvents(entry.metadataBuffer, listener);
+      return () => {
+        entry.metadataListeners.delete(listener);
+      };
+    },
+    onState(listener) {
+      entry.stateListeners.add(listener);
+      flushBufferedEvents(entry.stateBuffer, listener);
+      return () => {
+        entry.stateListeners.delete(listener);
+      };
+    },
+    release() {
+      entry.release();
+    },
+    snapshot() {
+      return entry.snapshot();
+    }
+  };
+}
+function createTerminalSessionTransportRuntimeEntry(input) {
+  const attachmentController = createTerminalAttachmentController({
+    clientId: createTerminalTransportClientId(),
+    sessionId: input.sessionId,
+    transport: input.transport
+  });
+  const entry = {
+    attach(afterSeq) {
+      return attachmentController.attach(afterSeq);
+    },
+    dataBuffer: [],
+    dataListeners: /* @__PURE__ */ new Set(),
+    detachGraceMs: input.detachGraceMs ?? defaultDetachGraceMs,
+    detachTimer: null,
+    exitBuffer: [],
+    exitListeners: /* @__PURE__ */ new Set(),
+    metadataBuffer: [],
+    metadataListeners: /* @__PURE__ */ new Set(),
+    refCount: 0,
+    release() {
+      entry.refCount = Math.max(0, entry.refCount - 1);
+      if (entry.refCount > 0 || entry.detachTimer !== null) {
+        return;
+      }
+      entry.detachTimer = setTimeout(() => {
+        entry.detachTimer = null;
+        if (entry.refCount > 0) {
+          return;
+        }
+        void attachmentController.detach().finally(() => {
+          entry.teardown();
+          runtimeRegistry.delete(entry.sessionId);
+        });
+      }, entry.detachGraceMs);
+    },
+    sessionId: input.sessionId,
+    snapshot() {
+      if (entry.snapshotPromise) {
+        return entry.snapshotPromise;
+      }
+      if (entry.snapshotCache) {
+        return Promise.resolve(entry.snapshotCache);
+      }
+      entry.snapshotPromise = input.transport.snapshot({ sessionId: input.sessionId }).then((snapshot) => {
+        entry.snapshotCache = snapshot;
+        return snapshot;
+      }).finally(() => {
+        entry.snapshotPromise = null;
+      });
+      return entry.snapshotPromise;
+    },
+    snapshotCache: null,
+    snapshotPromise: null,
+    stateBuffer: [],
+    stateListeners: /* @__PURE__ */ new Set(),
+    teardown() {
+      disposeData();
+      disposeState();
+      disposeExit();
+      disposeMetadata?.();
+      entry.dataBuffer.length = 0;
+      entry.exitBuffer.length = 0;
+      entry.metadataBuffer.length = 0;
+      entry.stateBuffer.length = 0;
+      entry.snapshotCache = null;
+      entry.snapshotPromise = null;
+    }
+  };
+  const disposeData = input.transport.onData((event) => {
+    if (event.sessionId !== input.sessionId) {
+      return;
+    }
+    entry.snapshotCache = null;
+    dispatchOrBuffer(entry.dataListeners, entry.dataBuffer, event);
+  });
+  const disposeState = input.transport.onState((event) => {
+    if (event.sessionId !== input.sessionId) {
+      return;
+    }
+    if (event.status === "detached" || event.status === "exited") {
+      attachmentController.markDetached();
+    }
+    if (typeof event.gapStartSeq === "number" || typeof event.gapEndSeq === "number") {
+      entry.snapshotCache = null;
+    }
+    dispatchOrBuffer(entry.stateListeners, entry.stateBuffer, event);
+  });
+  const disposeExit = input.transport.onExit((event) => {
+    if (event.sessionId !== input.sessionId) {
+      return;
+    }
+    dispatchOrBuffer(entry.exitListeners, entry.exitBuffer, event);
+  });
+  const disposeMetadata = input.transport.onMetadata?.((event) => {
+    if (event.sessionId !== input.sessionId) {
+      return;
+    }
+    dispatchOrBuffer(entry.metadataListeners, entry.metadataBuffer, event);
+  });
+  return entry;
+}
+function createTerminalTransportClientId() {
+  runtimeClientSequence += 1;
+  return `terminal-runtime-${runtimeClientSequence}`;
+}
+function dispatchOrBuffer(listeners, buffer, event) {
+  if (listeners.size === 0) {
+    buffer.push(event);
+    return;
+  }
+  for (const listener of listeners) {
+    listener(event);
+  }
+}
+function flushBufferedEvents(buffer, listener) {
+  if (buffer.length === 0) {
+    return;
+  }
+  const pending = buffer.splice(0);
+  for (const event of pending) {
+    listener(event);
+  }
+}
+
+// src/core/sessionController.ts
+var defaultControllerRetainMs = 5e3;
+var controllerRegistry = /* @__PURE__ */ new Map();
+function acquireTerminalSessionController(input) {
+  const entry = controllerRegistry.get(input.sessionId) ?? createTerminalSessionControllerEntry({
+    feature: input.feature,
+    nodeId: input.nodeId,
+    retainMs: input.retainMs ?? defaultControllerRetainMs,
+    sessionId: input.sessionId
+  });
+  if (!controllerRegistry.has(input.sessionId)) {
+    controllerRegistry.set(input.sessionId, entry);
+  }
+  entry.context = {
+    feature: input.feature,
+    nodeId: input.nodeId,
+    sessionId: input.sessionId
+  };
+  return {
+    getState() {
+      return entry.store.getState();
+    },
+    retain() {
+      entry.refCount += 1;
+      if (entry.retainTimer !== null) {
+        clearTimeout(entry.retainTimer);
+        entry.retainTimer = null;
+      }
+      ensureRecoveryStarted(entry);
+    },
+    release() {
+      entry.release();
+    },
+    resize({ cols, rows }) {
+      return entry.context.feature.transport.resize({
+        cols,
+        rows,
+        sessionId: entry.context.sessionId
+      });
+    },
+    subscribe(listener) {
+      return entry.store.subscribe(listener);
+    },
+    write(data, encoding = "utf8") {
+      if (!entry.runtimeWriteReady) {
+        entry.inputQueue.enqueue(data, encoding);
+        ensureRecoveryStarted(entry);
+        return;
+      }
+      void writeTerminalInput(entry, data, encoding);
+    }
+  };
+}
+function createTerminalSessionControllerEntry(input) {
+  const transportRuntime = acquireTerminalSessionTransportRuntime({
+    sessionId: input.sessionId,
+    transport: input.feature.transport
+  });
+  const inputQueue = createBufferedTerminalInputQueue();
+  const store = createTerminalSessionControllerStore({
+    maxScrollbackChars: resolveMaxScrollbackChars(input.feature.limits)
+  });
+  const entry = {
+    context: {
+      feature: input.feature,
+      nodeId: input.nodeId,
+      sessionId: input.sessionId
+    },
+    disposed: false,
+    inputQueue,
+    recovery: null,
+    refCount: 0,
+    release: () => void 0,
+    retainTimer: null,
+    runtimeWriteReady: false,
+    startPromise: null,
+    store,
+    teardown: () => void 0,
+    transportRuntime
+  };
+  entry.release = () => {
+    entry.refCount = Math.max(0, entry.refCount - 1);
+    if (entry.refCount > 0 || entry.retainTimer !== null) {
+      return;
+    }
+    entry.retainTimer = setTimeout(() => {
+      entry.retainTimer = null;
+      if (entry.refCount > 0) {
+        return;
+      }
+      entry.teardown();
+      controllerRegistry.delete(entry.context.sessionId);
+    }, input.retainMs);
+  };
+  entry.teardown = () => {
+    if (entry.disposed) {
+      return;
+    }
+    entry.disposed = true;
+    inputQueue.reset();
+    entry.runtimeWriteReady = false;
+    entry.recovery.dispose();
+    transportRuntime.release();
+    store.clearListeners();
+  };
+  entry.recovery = createTerminalSessionRecovery({
+    diagnostics: createTerminalSessionRecoveryDiagnostics({
+      diagnostics: input.feature.diagnostics,
+      nodeId: input.nodeId,
+      sessionId: input.sessionId
+    }),
+    inputQueue,
+    onRecoverableDetach() {
+      if (entry.disposed || entry.refCount === 0) {
+        return;
+      }
+      ensureRecoveryStarted(entry);
+    },
+    onWriteReadyChange(ready) {
+      if (entry.disposed) {
+        return;
+      }
+      entry.runtimeWriteReady = ready;
+    },
+    replayGapMessage: input.feature.i18n.t("recovery.replayGap"),
+    sessionId: input.sessionId,
+    snapshotTruncatedMessage: input.feature.i18n.t(
+      "recovery.snapshotTruncated"
+    ),
+    store,
+    transport: input.feature.transport,
+    transportRuntime
+  });
+  return entry;
+}
+function ensureRecoveryStarted(entry) {
+  if (entry.disposed || entry.startPromise !== null || entry.runtimeWriteReady) {
+    return;
+  }
+  entry.startPromise = entry.recovery.start().finally(() => {
+    entry.startPromise = null;
+  });
+}
+function resolveMaxScrollbackChars(limits) {
+  return Math.max(limits.maxScrollbackLines * 160, 4e5);
+}
+function writeTerminalInput(entry, data, encoding) {
+  return entry.context.feature.transport.write({
+    data,
+    encoding,
+    provenance: "user",
+    sessionId: entry.context.sessionId
+  }).catch((error) => {
+    entry.runtimeWriteReady = false;
+    entry.store.setInputReady(false);
+    entry.inputQueue.enqueue(data, encoding);
+    ensureRecoveryStarted(entry);
+    entry.context.feature.diagnostics.log("write-error", {
+      nodeId: entry.context.nodeId,
+      sessionId: entry.context.sessionId
+    });
+    entry.store.setSurfaceError(errorMessage2(error));
+  });
+}
+function errorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/react/TerminalNode.tsx
+import { useState as useState3 } from "react";
+import { Badge, StatusDot } from "@tutti-os/ui-system";
+
+// src/react/headerActions.ts
+function hasTerminalHeaderDefaultActions(defaultActions) {
+  return defaultActions !== void 0 && defaultActions !== null;
+}
+
+// src/react/TerminalSurface.tsx
+import { useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
+
+// src/react/terminalSurfaceRuntime.ts
+import { FitAddon } from "@xterm/addon-fit";
+import { SearchAddon } from "@xterm/addon-search";
+import { SerializeAddon } from "@xterm/addon-serialize";
+import { WebLinksAddon } from "@xterm/addon-web-links";
+import { Terminal } from "@xterm/xterm";
+
+// src/react/terminalFileLinkProvider.ts
+function createTerminalFileLinkProvider(input) {
+  return {
+    provideLinks(bufferLineNumber, callback) {
+      if (!input.feature.linkHandler) {
+        callback(void 0);
+        return;
+      }
+      const line = input.terminal.buffer.active.getLine(bufferLineNumber - 1);
+      if (!line) {
+        callback(void 0);
+        return;
+      }
+      const text = line.translateToString(true);
+      const links = detectTerminalFileLinks(text).map((link) => ({
+        activate: () => {
+          void input.feature.linkHandler?.open({
+            ...toTerminalLinkTarget(link),
+            cwd: input.getCwd()
+          });
+        },
+        range: {
+          end: {
+            x: link.index + link.text.length,
+            y: bufferLineNumber
+          },
+          start: {
+            x: link.index + 1,
+            y: bufferLineNumber
+          }
+        },
+        text: link.text
+      }));
+      callback(links.length > 0 ? links : void 0);
+    }
+  };
+}
+
+// src/react/terminalSurfaceOutputPlan.ts
+function resolveTerminalSurfaceOutputPlan(input) {
+  if (input.nextContentEpoch === 0 && input.rawOutput.length === 0 && input.committedRawOutput.length > 0) {
+    return null;
+  }
+  if (input.nextContentEpoch !== input.contentEpoch) {
+    if (input.rawOutput === input.committedRawOutput) {
+      return {
+        nextCommittedRawOutput: input.committedRawOutput,
+        nextContentEpoch: input.nextContentEpoch,
+        reset: false,
+        write: null
+      };
+    }
+    return {
+      nextCommittedRawOutput: input.rawOutput,
+      nextContentEpoch: input.nextContentEpoch,
+      reset: true,
+      write: input.rawOutput || null
+    };
+  }
+  if (input.rawOutput === input.committedRawOutput) {
+    return null;
+  }
+  const delta = resolveTerminalScrollbackDelta(
+    input.committedRawOutput,
+    input.rawOutput
+  );
+  return {
+    nextCommittedRawOutput: input.rawOutput,
+    nextContentEpoch: input.nextContentEpoch,
+    reset: !delta,
+    write: delta || input.rawOutput || null
+  };
+}
+
+// src/react/terminalSurfaceResizePlan.ts
+function resolveTerminalSurfaceResizePlan(input) {
+  if (input.lastSize?.cols === input.nextSize.cols && input.lastSize.rows === input.nextSize.rows) {
+    return null;
+  }
+  return input.nextSize;
+}
+
+// src/react/terminalSurfaceScreenCachePlan.ts
+function resolveTerminalSurfaceScreenCachePlan(input) {
+  if (input.hasPendingWrites) {
+    return {
+      action: input.serialized ? "skip" : "remove"
+    };
+  }
+  if (!input.serialized) {
+    return { action: "skip" };
+  }
+  return {
+    action: "save",
+    rawSnapshot: input.rawSnapshot,
+    serialized: input.serialized
+  };
+}
+
+// src/react/terminalWriteBatch.ts
+function drainTerminalWriteBatch(chunks, maxBytes) {
+  let remaining = maxBytes;
+  let nextWrite = "";
+  const remainingChunks = chunks.slice();
+  while (remaining > 0 && remainingChunks.length > 0) {
+    const chunk = remainingChunks.shift() ?? "";
+    if (chunk.length <= remaining) {
+      nextWrite += chunk;
+      remaining -= chunk.length;
+      continue;
+    }
+    nextWrite += chunk.slice(0, remaining);
+    remainingChunks.unshift(chunk.slice(remaining));
+    remaining = 0;
+  }
+  return {
+    nextWrite,
+    remainingChunks
+  };
+}
+
+// src/react/terminalSurfaceRuntime.ts
+var terminalScreenStateCache = createTerminalScreenStateCache();
+function createTerminalSurfaceRuntime(input) {
+  let contentEpoch = 0;
+  let committedRawOutput = "";
+  let initialLayoutFrame = null;
+  let initialLayoutTimeout = null;
+  let lastSize = null;
+  let pendingRevealFinalizeFrame = null;
+  let pendingRevealStartFrame = null;
+  let pendingRevealWrite = null;
+  let pendingWriteFrame = null;
+  let pendingWriteChunks = [];
+  let pendingRenderedWrite = null;
+  const terminal = new Terminal({
+    allowProposedApi: false,
+    convertEol: true,
+    cursorBlink: true,
+    fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',
+    fontSize: 13,
+    scrollback: input.feature.limits.maxScrollbackLines,
+    theme: resolveXtermTheme(input.theme)
+  });
+  const fitAddon = new FitAddon();
+  const searchAddon = new SearchAddon();
+  const serializeAddon = new SerializeAddon();
+  const webLinksAddon = new WebLinksAddon((_event, uri) => {
+    void input.feature.linkHandler?.open({ url: uri });
+  });
+  terminal.loadAddon(fitAddon);
+  terminal.loadAddon(searchAddon);
+  terminal.loadAddon(serializeAddon);
+  terminal.loadAddon(webLinksAddon);
+  const fileLinkDisposable = terminal.registerLinkProvider(
+    createTerminalFileLinkProvider({
+      feature: input.feature,
+      getCwd: input.getCwd,
+      terminal
+    })
+  );
+  terminal.open(input.container);
+  const dataSubscription = terminal.onData((data) => {
+    input.onUserInput(data);
+  });
+  const binarySubscription = terminal.onBinary((data) => {
+    input.onUserInput(data, "binary");
+  });
+  const writeParsedSubscription = typeof terminal.onWriteParsed === "function" ? terminal.onWriteParsed(() => {
+    if (!pendingRenderedWrite) {
+      refreshTerminalSurface();
+      return;
+    }
+    const renderedWrite = pendingRenderedWrite;
+    pendingRenderedWrite = null;
+    if (renderedWrite.mode === "cache" || renderedWrite.mode === "replace") {
+      scheduleHydratedReveal({
+        bytes: renderedWrite.bytes,
+        mode: renderedWrite.mode,
+        remainingChunkCount: renderedWrite.remainingChunkCount
+      });
+      return;
+    }
+    refreshTerminalSurface();
+    logSurfaceWrite(
+      renderedWrite.mode,
+      renderedWrite.bytes,
+      renderedWrite.remainingChunkCount
+    );
+  }) : { dispose: () => void 0 };
+  const resizeTerminal = () => {
+    try {
+      fitAddon.fit();
+    } catch {
+      return;
+    }
+    const plan = resolveTerminalSurfaceResizePlan({
+      lastSize,
+      nextSize: { cols: terminal.cols, rows: terminal.rows }
+    });
+    if (!plan) {
+      return;
+    }
+    lastSize = plan;
+    input.onResize(plan);
+  };
+  const resizeObserver = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(() => resizeTerminal());
+  resizeObserver?.observe(input.container);
+  scheduleInitialLayoutSync();
+  const cached = terminalScreenStateCache.get(input.nodeId, input.sessionId);
+  if (cached) {
+    terminal.write(cached.serialized, () => {
+      queueRenderedWrite("cache", cached.serialized.length, 0);
+    });
+    committedRawOutput = cached.rawSnapshot;
+  }
+  return {
+    dispose() {
+      resizeObserver?.disconnect();
+      dataSubscription.dispose();
+      binarySubscription.dispose();
+      writeParsedSubscription.dispose();
+      fileLinkDisposable.dispose();
+      clearInitialLayoutSync();
+      clearPendingReveal();
+      const hasPendingWrites = pendingWriteFrame !== null || pendingWriteChunks.length > 0;
+      const cachePlan = resolveTerminalSurfaceScreenCachePlan({
+        hasPendingWrites,
+        rawSnapshot: committedRawOutput,
+        serialized: hasPendingWrites ? "" : serializeAddon.serialize()
+      });
+      if (cachePlan.action === "save") {
+        terminalScreenStateCache.set(input.nodeId, {
+          cols: terminal.cols,
+          rawSnapshot: cachePlan.rawSnapshot,
+          rows: terminal.rows,
+          serialized: cachePlan.serialized,
+          sessionId: input.sessionId
+        });
+      } else if (cachePlan.action === "remove") {
+        terminalScreenStateCache.remove(input.nodeId, input.sessionId);
+      }
+      clearPendingWrites();
+      terminal.dispose();
+    },
+    findNext(query, options) {
+      searchAddon.findNext(query, options);
+    },
+    findPrevious(query, options) {
+      searchAddon.findPrevious(query, options);
+    },
+    focus() {
+      terminal.focus();
+      resizeTerminal();
+    },
+    setTheme(theme) {
+      terminal.options.theme = resolveXtermTheme(theme);
+    },
+    syncOutput(rawOutput, nextContentEpoch) {
+      const plan = resolveTerminalSurfaceOutputPlan({
+        committedRawOutput,
+        contentEpoch,
+        nextContentEpoch,
+        rawOutput
+      });
+      input.diagnostics.outputSync({
+        contentEpoch: nextContentEpoch,
+        nextCommittedBytes: plan?.nextCommittedRawOutput.length ?? committedRawOutput.length,
+        plan: resolveOutputSyncPlan(plan),
+        previousCommittedBytes: committedRawOutput.length,
+        rawBytes: rawOutput.length,
+        writeBytes: plan?.write?.length ?? 0
+      });
+      if (!plan) {
+        return;
+      }
+      contentEpoch = plan.nextContentEpoch;
+      if (plan.reset && plan.write) {
+        replaceTerminalView(plan.write, { reset: true });
+      } else if (plan.reset) {
+        resetTerminalView();
+      }
+      if (plan.write && !plan.reset) {
+        writeToTerminal(plan.write);
+      }
+      committedRawOutput = plan.nextCommittedRawOutput;
+    }
+  };
+  function clearPendingWrites() {
+    pendingWriteChunks = [];
+    if (pendingWriteFrame === null) {
+      return;
+    }
+    if (typeof cancelAnimationFrame === "function") {
+      cancelAnimationFrame(pendingWriteFrame);
+    } else {
+      clearTimeout(pendingWriteFrame);
+    }
+    pendingWriteFrame = null;
+  }
+  function clearInitialLayoutSync() {
+    if (initialLayoutFrame !== null) {
+      if (typeof cancelAnimationFrame === "function") {
+        cancelAnimationFrame(initialLayoutFrame);
+      } else {
+        clearTimeout(initialLayoutFrame);
+      }
+      initialLayoutFrame = null;
+    }
+    if (initialLayoutTimeout !== null) {
+      clearTimeout(initialLayoutTimeout);
+      initialLayoutTimeout = null;
+    }
+  }
+  function clearPendingReveal() {
+    if (pendingRevealStartFrame !== null) {
+      if (typeof cancelAnimationFrame === "function") {
+        cancelAnimationFrame(pendingRevealStartFrame);
+      } else {
+        clearTimeout(pendingRevealStartFrame);
+      }
+      pendingRevealStartFrame = null;
+    }
+    if (pendingRevealFinalizeFrame !== null) {
+      if (typeof cancelAnimationFrame === "function") {
+        cancelAnimationFrame(pendingRevealFinalizeFrame);
+      } else {
+        clearTimeout(pendingRevealFinalizeFrame);
+      }
+      pendingRevealFinalizeFrame = null;
+    }
+    pendingRevealWrite = null;
+  }
+  function flushPendingWrites() {
+    pendingWriteFrame = null;
+    const batch = drainTerminalWriteBatch(
+      pendingWriteChunks,
+      input.feature.limits.maxWriteBatchBytes
+    );
+    pendingWriteChunks = batch.remainingChunks;
+    if (!batch.nextWrite) {
+      return;
+    }
+    terminal.write(batch.nextWrite, () => {
+      queueRenderedWrite(
+        "append",
+        batch.nextWrite.length,
+        pendingWriteChunks.length
+      );
+      if (pendingWriteChunks.length > 0) {
+        requestWriteFlush();
+      }
+    });
+  }
+  function requestWriteFlush() {
+    if (pendingWriteFrame !== null) {
+      return;
+    }
+    if (typeof requestAnimationFrame === "function") {
+      pendingWriteFrame = requestAnimationFrame(flushPendingWrites);
+      return;
+    }
+    pendingWriteFrame = window.setTimeout(flushPendingWrites, 0);
+  }
+  function resetTerminalView() {
+    clearPendingReveal();
+    clearPendingWrites();
+    terminal.reset();
+    refreshTerminalSurface();
+    logSurfaceWrite("reset", 0, 0);
+  }
+  function replaceTerminalView(data, options) {
+    const transformed = input.feature.outputTransform?.({
+      data,
+      sessionId: input.sessionId
+    }) ?? data;
+    if (transformed == null || transformed === "") {
+      return;
+    }
+    clearPendingReveal();
+    clearPendingWrites();
+    if (options?.reset) {
+      terminal.reset();
+    }
+    terminal.write(transformed, () => {
+      queueRenderedWrite("replace", transformed.length, 0);
+    });
+  }
+  function refreshTerminalSurface() {
+    if (terminal.rows <= 0) {
+      return;
+    }
+    terminal.refresh(0, terminal.rows - 1);
+  }
+  function scheduleInitialLayoutSync() {
+    resizeTerminal();
+    if (typeof requestAnimationFrame === "function") {
+      initialLayoutFrame = requestAnimationFrame(() => {
+        initialLayoutFrame = null;
+        resizeTerminal();
+        refreshTerminalSurface();
+      });
+    } else {
+      initialLayoutFrame = window.setTimeout(() => {
+        initialLayoutFrame = null;
+        resizeTerminal();
+        refreshTerminalSurface();
+      }, 0);
+    }
+    initialLayoutTimeout = window.setTimeout(() => {
+      initialLayoutTimeout = null;
+      resizeTerminal();
+      refreshTerminalSurface();
+    }, 32);
+  }
+  function scheduleTerminalWrite(data) {
+    pendingWriteChunks.push(data);
+    requestWriteFlush();
+  }
+  function writeToTerminal(data) {
+    const transformed = input.feature.outputTransform?.({
+      data,
+      sessionId: input.sessionId
+    }) ?? data;
+    if (transformed == null || transformed === "") {
+      return;
+    }
+    scheduleTerminalWrite(transformed);
+  }
+  function queueRenderedWrite(mode, bytes, remainingChunkCount) {
+    if (pendingRenderedWrite && pendingRenderedWrite.mode === mode) {
+      pendingRenderedWrite = {
+        bytes: pendingRenderedWrite.bytes + bytes,
+        mode,
+        remainingChunkCount
+      };
+      return;
+    }
+    pendingRenderedWrite = {
+      bytes,
+      mode,
+      remainingChunkCount
+    };
+  }
+  function scheduleHydratedReveal(write) {
+    if (pendingRevealWrite) {
+      pendingRevealWrite = {
+        bytes: pendingRevealWrite.bytes + write.bytes,
+        mode: write.mode,
+        remainingChunkCount: write.remainingChunkCount
+      };
+    } else {
+      pendingRevealWrite = write;
+    }
+    if (pendingRevealStartFrame !== null || pendingRevealFinalizeFrame !== null) {
+      return;
+    }
+    pendingRevealStartFrame = requestTerminalFrame(() => {
+      pendingRevealStartFrame = null;
+      resizeTerminal();
+      pendingRevealFinalizeFrame = requestTerminalFrame(() => {
+        pendingRevealFinalizeFrame = null;
+        refreshTerminalSurface();
+        const revealWrite = pendingRevealWrite;
+        pendingRevealWrite = null;
+        if (!revealWrite) {
+          return;
+        }
+        logSurfaceWrite(
+          revealWrite.mode,
+          revealWrite.bytes,
+          revealWrite.remainingChunkCount
+        );
+      });
+    });
+  }
+  function logSurfaceWrite(mode, bytes, remainingChunkCount) {
+    const buffer = terminal.buffer.active;
+    const xtermElement = input.container.querySelector(".xterm") instanceof HTMLElement ? input.container.querySelector(".xterm") : null;
+    const screenElement = input.container.querySelector(".xterm-screen") instanceof HTMLElement ? input.container.querySelector(".xterm-screen") : null;
+    const helperElement = input.container.querySelector(".xterm-helpers") instanceof HTMLElement ? input.container.querySelector(".xterm-helpers") : null;
+    const rowContainerElement = input.container.querySelector(".xterm-rows") instanceof HTMLElement ? input.container.querySelector(".xterm-rows") : null;
+    const firstCanvas = screenElement?.querySelector("canvas") instanceof HTMLCanvasElement ? screenElement.querySelector("canvas") : null;
+    const firstLine = buffer.getLine(0)?.translateToString(true) ?? "";
+    const cursorLine = buffer.getLine(buffer.cursorY)?.translateToString(true) ?? "";
+    const xtermStyle = xtermElement ? window.getComputedStyle(xtermElement) : null;
+    const screenStyle = screenElement ? window.getComputedStyle(screenElement) : null;
+    const renderDimensions = resolveXtermRenderDimensions(terminal);
+    input.diagnostics.outputWritten({
+      bufferCursorX: buffer.cursorX,
+      bufferCursorY: buffer.cursorY,
+      bufferLength: buffer.length,
+      bytes,
+      canvasClientHeight: firstCanvas?.clientHeight ?? 0,
+      canvasClientWidth: firstCanvas?.clientWidth ?? 0,
+      canvasCount: screenElement?.querySelectorAll("canvas").length ?? 0,
+      cols: terminal.cols,
+      containerClientHeight: input.container.clientHeight,
+      containerClientWidth: input.container.clientWidth,
+      cursorLinePreview: previewTerminalLine(cursorLine),
+      firstLinePreview: previewTerminalLine(firstLine),
+      helperChildCount: helperElement?.childElementCount ?? 0,
+      mode,
+      remainingChunkCount,
+      renderDimensionsReady: renderDimensions !== void 0,
+      rowContainerChildCount: rowContainerElement?.childElementCount ?? 0,
+      rowContainerTextPreview: previewTerminalLine(
+        rowContainerElement?.textContent ?? ""
+      ),
+      rows: terminal.rows,
+      screenChildCount: screenElement?.childElementCount ?? 0,
+      screenClientHeight: screenElement?.clientHeight ?? 0,
+      screenClientWidth: screenElement?.clientWidth ?? 0,
+      screenDisplay: screenStyle?.display ?? "",
+      screenOpacity: screenStyle?.opacity ?? "",
+      screenVisibility: screenStyle?.visibility ?? "",
+      serializedBytes: serializeAddon.serialize().length,
+      xtermClientHeight: xtermElement?.clientHeight ?? 0,
+      xtermClientWidth: xtermElement?.clientWidth ?? 0,
+      xtermDisplay: xtermStyle?.display ?? "",
+      xtermOpacity: xtermStyle?.opacity ?? "",
+      xtermVisibility: xtermStyle?.visibility ?? ""
+    });
+  }
+}
+function requestTerminalFrame(callback) {
+  if (typeof requestAnimationFrame === "function") {
+    return requestAnimationFrame(callback);
+  }
+  return window.setTimeout(callback, 0);
+}
+function resolveOutputSyncPlan(plan) {
+  if (!plan) {
+    return "skip";
+  }
+  if (plan.reset && plan.write) {
+    return "replace";
+  }
+  if (plan.reset) {
+    return "reset";
+  }
+  return "append";
+}
+function resolveXtermRenderDimensions(terminal) {
+  const core = Reflect.get(terminal, "_core");
+  if (core == null || typeof core !== "object") {
+    return void 0;
+  }
+  const renderService = Reflect.get(core, "_renderService");
+  if (renderService == null || typeof renderService !== "object") {
+    return void 0;
+  }
+  return Reflect.get(renderService, "dimensions");
+}
+function previewTerminalLine(value, maxChars = 80) {
+  return value.slice(0, maxChars).replaceAll("\\", "\\\\").replaceAll("\r", "\\r").replaceAll("\n", "\\n");
+}
+function resolveXtermTheme(theme) {
+  return {
+    background: theme.background,
+    cursor: theme.cursor,
+    foreground: theme.foreground,
+    selectionBackground: theme.selectionBackground
+  };
+}
+
+// src/react/terminalFindShortcut.ts
+function isTerminalFindShortcut(event) {
+  if (event.altKey) {
+    return false;
+  }
+  if (!(event.metaKey || event.ctrlKey)) {
+    return false;
+  }
+  return event.key.toLowerCase() === "f";
+}
+
+// src/react/useTerminalFindController.ts
+import { useState } from "react";
+function useTerminalFindController(input) {
+  const [open, setOpen] = useState(false);
+  const [caseSensitive, setCaseSensitive] = useState(false);
+  const [query, setQuery] = useState("");
+  const [regex, setRegex] = useState(false);
+  const resolveFindOptions = () => ({
+    caseSensitive,
+    regex
+  });
+  return {
+    actions: {
+      close() {
+        setOpen(false);
+      },
+      findNext() {
+        input.getRuntime()?.findNext(query, resolveFindOptions());
+      },
+      findPrevious() {
+        input.getRuntime()?.findPrevious(query, resolveFindOptions());
+      },
+      open() {
+        setOpen(true);
+      },
+      onQueryChange(nextQuery) {
+        setQuery(nextQuery);
+        if (!nextQuery) {
+          return;
+        }
+        input.getRuntime()?.findNext(nextQuery, {
+          ...resolveFindOptions(),
+          incremental: true
+        });
+      },
+      onSubmit() {
+        input.getRuntime()?.findNext(query, resolveFindOptions());
+      },
+      toggleCaseSensitive() {
+        setCaseSensitive((enabled) => !enabled);
+      },
+      toggleOpen() {
+        setOpen((enabled) => !enabled);
+      },
+      toggleRegex() {
+        setRegex((enabled) => !enabled);
+      }
+    },
+    state: {
+      caseSensitive,
+      open,
+      query,
+      regex
+    }
+  };
+}
+
+// src/react/useTerminalSessionController.ts
+import { useEffect, useMemo } from "react";
+import { useExternalStoreSnapshot } from "@tutti-os/ui-react-hooks";
+function useTerminalSessionController(input) {
+  const controller = useMemo(
+    () => acquireTerminalSessionController({
+      feature: input.feature,
+      nodeId: input.nodeId,
+      sessionId: input.sessionId
+    }),
+    [input.nodeId, input.sessionId]
+  );
+  useEffect(() => {
+    if (input.retainLease === false) {
+      return;
+    }
+    controller.retain();
+    return () => {
+      controller.release();
+    };
+  }, [controller, input.retainLease]);
+  const state = useExternalStoreSnapshot({
+    getSnapshot() {
+      return controller.getState();
+    },
+    subscribe(listener) {
+      return controller.subscribe(listener);
+    }
+  });
+  return {
+    controller,
+    state
+  };
+}
+
+// src/react/TerminalSurface.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function TerminalSurface({
+  controllerLeaseRetainedExternally = false,
+  externalState,
+  feature,
+  nodeId,
+  sessionId,
+  status
+}) {
+  const containerRef = useRef(null);
+  const currentCwdRef = useRef(externalState?.cwd ?? null);
+  const featureRef = useRef(feature);
+  const findInputRef = useRef(null);
+  const runtimeRef = useRef(null);
+  const [interactionError, setInteractionError] = useState2(null);
+  const { controller, state } = useTerminalSessionController({
+    feature,
+    nodeId,
+    retainLease: !controllerLeaseRetainedExternally,
+    sessionId
+  });
+  const find = useTerminalFindController({
+    getRuntime: () => runtimeRef.current
+  });
+  const theme = useMemo2(
+    () => feature.resolveTheme({
+      runtimeKind: externalState?.runtimeKind ?? "local",
+      sessionId,
+      status
+    }),
+    [externalState?.runtimeKind, feature, sessionId, status]
+  );
+  const surfaceDiagnostics = useMemo2(
+    () => createTerminalSurfaceDiagnostics({
+      diagnostics: feature.diagnostics,
+      nodeId,
+      sessionId
+    }),
+    [feature.diagnostics, nodeId, sessionId]
+  );
+  const surfaceError = interactionError ?? state.surfaceError;
+  useEffect2(() => {
+    currentCwdRef.current = externalState?.cwd ?? null;
+  }, [externalState?.cwd]);
+  useEffect2(() => {
+    featureRef.current = feature;
+  }, [feature]);
+  useEffect2(() => {
+    if (!find.state.open) {
+      return;
+    }
+    const input = findInputRef.current;
+    if (!input) {
+      return;
+    }
+    input.focus();
+    input.select();
+  }, [find.state.open]);
+  useEffect2(() => {
+    const container = containerRef.current;
+    if (!container) {
+      return;
+    }
+    surfaceDiagnostics.mount();
+    setInteractionError(null);
+    const runtime = createTerminalSurfaceRuntime({
+      container,
+      diagnostics: surfaceDiagnostics,
+      feature: featureRef.current,
+      getCwd: () => currentCwdRef.current,
+      nodeId,
+      onResize: ({ cols, rows }) => {
+        surfaceDiagnostics.resize({ cols, rows });
+        void controller.resize({ cols, rows });
+      },
+      onUserInput: (data, encoding) => {
+        controller.write(data, encoding);
+      },
+      sessionId,
+      theme
+    });
+    runtimeRef.current = runtime;
+    runtime.syncOutput(state.rawOutput, state.contentEpoch);
+    runtime.focus();
+    return () => {
+      surfaceDiagnostics.dispose();
+      runtime.dispose();
+      if (runtimeRef.current === runtime) {
+        runtimeRef.current = null;
+      }
+    };
+  }, [controller, nodeId, sessionId, surfaceDiagnostics]);
+  useEffect2(() => {
+    runtimeRef.current?.setTheme(theme);
+  }, [theme]);
+  useEffect2(() => {
+    runtimeRef.current?.syncOutput(state.rawOutput, state.contentEpoch);
+  }, [state.contentEpoch, state.rawOutput]);
+  const writeInput = (data) => {
+    controller.write(data);
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "workspace-terminal__surface-shell",
+      onKeyDownCapture: (event) => {
+        if (!isTerminalFindShortcut(event)) {
+          if (event.key === "Escape" && find.state.open) {
+            find.actions.close();
+            runtimeRef.current?.focus();
+          }
+          return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        find.actions.open();
+      },
+      onDragOver: (event) => {
+        if (feature.dropInput) {
+          event.preventDefault();
+        }
+      },
+      onDrop: (event) => {
+        if (!feature.dropInput) {
+          return;
+        }
+        event.preventDefault();
+        void Promise.resolve(
+          feature.dropInput({
+            cwd: externalState?.cwd ?? null,
+            dataTransfer: event.dataTransfer,
+            sessionId
+          })
+        ).then((input) => {
+          if (input) {
+            writeInput(input);
+          }
+        }).catch((error) => setInteractionError(errorMessage3(error)));
+      },
+      children: [
+        find.state.open ? /* @__PURE__ */ jsxs(
+          "form",
+          {
+            className: "workspace-terminal__find",
+            onSubmit: (event) => {
+              event.preventDefault();
+              find.actions.onSubmit();
+            },
+            children: [
+              /* @__PURE__ */ jsx(
+                "input",
+                {
+                  "aria-label": feature.i18n.t("findPlaceholder"),
+                  ref: findInputRef,
+                  onChange: (event) => {
+                    find.actions.onQueryChange(event.currentTarget.value);
+                  },
+                  placeholder: feature.i18n.t("findPlaceholder"),
+                  type: "search",
+                  value: find.state.query
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  className: "workspace-terminal__find-toggle",
+                  "aria-label": feature.i18n.t("actions.caseSensitive"),
+                  "aria-pressed": find.state.caseSensitive,
+                  onClick: () => find.actions.toggleCaseSensitive(),
+                  type: "button",
+                  children: "Aa"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  className: "workspace-terminal__find-toggle",
+                  "aria-label": feature.i18n.t("actions.regex"),
+                  "aria-pressed": find.state.regex,
+                  onClick: () => find.actions.toggleRegex(),
+                  type: "button",
+                  children: ".*"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  className: "workspace-terminal__find-nav workspace-terminal__find-nav--previous",
+                  "aria-label": feature.i18n.t("actions.previous"),
+                  onClick: () => find.actions.findPrevious(),
+                  type: "button"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  className: "workspace-terminal__find-nav workspace-terminal__find-nav--next",
+                  "aria-label": feature.i18n.t("actions.next"),
+                  onClick: () => find.actions.findNext(),
+                  type: "submit"
+                }
+              )
+            ]
+          }
+        ) : null,
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "workspace-terminal__xterm",
+            "data-terminal-xterm": "",
+            ref: containerRef
+          }
+        ),
+        surfaceError ? /* @__PURE__ */ jsx("div", { className: "workspace-terminal__surface-error", role: "status", children: surfaceError }) : null
+      ]
+    }
+  );
+}
+function errorMessage3(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/react/TerminalNode.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function TerminalNode({
+  children,
+  controllerLeaseRetainedExternally = false,
+  externalState = null,
+  feature,
+  headerAccessory,
+  nodeId,
+  onFocusRequest,
+  sessionId,
+  showHeader = true
+}) {
+  const resolvedSessionId = sessionId ?? externalState?.sessionId ?? null;
+  const status = externalState?.status ?? "created";
+  return /* @__PURE__ */ jsxs2(
+    "section",
+    {
+      className: "workspace-terminal",
+      "data-terminal-node": nodeId,
+      "data-terminal-session-id": resolvedSessionId ?? void 0,
+      onClick: onFocusRequest,
+      children: [
+        showHeader ? /* @__PURE__ */ jsx2(
+          TerminalNodeHeader,
+          {
+            externalState,
+            feature,
+            headerAccessory,
+            sessionId: resolvedSessionId
+          }
+        ) : null,
+        /* @__PURE__ */ jsx2("div", { className: "workspace-terminal__body", children: children ?? (resolvedSessionId ? /* @__PURE__ */ jsx2(
+          TerminalSurface,
+          {
+            controllerLeaseRetainedExternally,
+            externalState,
+            feature,
+            nodeId,
+            sessionId: resolvedSessionId,
+            status
+          }
+        ) : /* @__PURE__ */ jsx2("div", { className: "workspace-terminal__placeholder", children: feature.i18n.t("emptySession") })) })
+      ]
+    }
+  );
+}
+function TerminalNodeHeader({
+  className,
+  defaultActions,
+  externalState = null,
+  feature,
+  headerAccessory,
+  onCloseRequest,
+  sessionId,
+  ...headerProps
+}) {
+  const status = externalState?.status ?? "created";
+  const statusLabel = resolveTerminalStatusLabel(feature, status);
+  const resolvedSessionId = sessionId ?? externalState?.sessionId ?? null;
+  const hasDefaultActions = hasTerminalHeaderDefaultActions(defaultActions);
+  const [pendingCloseGuard, setPendingCloseGuard] = useState3(null);
+  const [closeError, setCloseError] = useState3(null);
+  const closeDiagnostics = resolvedSessionId ? createTerminalCloseDiagnostics({
+    diagnostics: feature.diagnostics,
+    sessionId: resolvedSessionId
+  }) : null;
+  const closeTerminal = async (skipConfirmation) => {
+    if (!resolvedSessionId || isTerminalSessionEndedStatus(externalState?.status ?? "created")) {
+      onCloseRequest?.();
+      return;
+    }
+    setCloseError(null);
+    try {
+      if (!skipConfirmation) {
+        closeDiagnostics?.requested();
+        const guard = await feature.closeGuard.check({
+          sessionId: resolvedSessionId
+        });
+        if (guard.requiresConfirmation) {
+          setPendingCloseGuard(guard);
+          return;
+        }
+      }
+      await feature.launchService.terminate({ sessionId: resolvedSessionId });
+      closeDiagnostics?.confirmed();
+      setPendingCloseGuard(null);
+      onCloseRequest?.();
+    } catch (error) {
+      setCloseError(errorMessage4(error));
+    }
+  };
+  return /* @__PURE__ */ jsxs2(
+    "header",
+    {
+      ...headerProps,
+      className: joinClassName("workspace-terminal__header", className),
+      children: [
+        /* @__PURE__ */ jsxs2("div", { className: "workspace-terminal__header-main", children: [
+          /* @__PURE__ */ jsx2("span", { className: "workspace-terminal__title", children: externalState?.title?.trim() || feature.i18n.t("title") }),
+          /* @__PURE__ */ jsxs2(Badge, { className: "workspace-terminal__status-tag", variant: "default", children: [
+            /* @__PURE__ */ jsx2(
+              StatusDot,
+              {
+                pulse: status === "running" || status === "starting",
+                size: "xs",
+                tone: resolveTerminalStatusTone(status)
+              }
+            ),
+            statusLabel
+          ] })
+        ] }),
+        headerAccessory?.({
+          externalState,
+          sessionId: resolvedSessionId
+        }),
+        /* @__PURE__ */ jsxs2(
+          "div",
+          {
+            className: "workspace-terminal__actions",
+            onDoubleClick: (event) => {
+              event.stopPropagation();
+            },
+            onPointerDown: (event) => {
+              event.stopPropagation();
+            },
+            children: [
+              defaultActions,
+              onCloseRequest && !hasDefaultActions ? /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  "aria-label": feature.i18n.t("actions.close"),
+                  className: "workspace-terminal__icon-button",
+                  onClick: () => {
+                    void closeTerminal(false);
+                  },
+                  onPointerDown: (event) => {
+                    event.stopPropagation();
+                  },
+                  type: "button",
+                  children: "x"
+                }
+              ) : null
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          TerminalCloseGuardDialog,
+          {
+            feature,
+            leaderCommand: pendingCloseGuard?.leaderCommand,
+            onCancel: () => setPendingCloseGuard(null),
+            onConfirm: () => {
+              void closeTerminal(true);
+            },
+            open: Boolean(pendingCloseGuard)
+          }
+        ),
+        closeError ? /* @__PURE__ */ jsx2("div", { className: "workspace-terminal__close-error", role: "status", children: closeError }) : null
+      ]
+    }
+  );
+}
+function TerminalCloseGuardDialog({
+  feature,
+  leaderCommand,
+  onCancel,
+  onConfirm,
+  open
+}) {
+  if (!open) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs2("div", { className: "workspace-terminal__close-guard", role: "alertdialog", children: [
+    /* @__PURE__ */ jsx2("h2", { children: feature.i18n.t("closeGuard.title") }),
+    /* @__PURE__ */ jsx2("p", { children: feature.i18n.t("closeGuard.description") }),
+    leaderCommand ? /* @__PURE__ */ jsx2("code", { children: leaderCommand }) : null,
+    /* @__PURE__ */ jsxs2("div", { className: "workspace-terminal__close-guard-actions", children: [
+      /* @__PURE__ */ jsx2("button", { onClick: () => onCancel(), type: "button", children: feature.i18n.t("closeGuard.cancel") }),
+      /* @__PURE__ */ jsx2("button", { onClick: () => onConfirm(), type: "button", children: feature.i18n.t("closeGuard.confirm") })
+    ] })
+  ] });
+}
+function resolveTerminalStatusLabel(feature, status) {
+  return feature.i18n.t(`status.${status}`);
+}
+function resolveTerminalStatusTone(status) {
+  switch (status) {
+    case "running":
+    case "starting":
+      return "blue";
+    case "exited":
+      return "green";
+    case "failed":
+      return "red";
+    case "detached":
+      return "amber";
+    case "created":
+      return "neutral";
+  }
+}
+function errorMessage4(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function joinClassName(...values) {
+  return values.filter(Boolean).join(" ");
+}
+
+export {
+  acquireTerminalSessionController,
+  TerminalNode,
+  TerminalNodeHeader,
+  TerminalCloseGuardDialog
+};
+//# sourceMappingURL=chunk-FEJT6FJ4.js.map