restty 0.1.21 → 0.1.22

package/dist/{chunk-ym658zhj.js → chunk-d3xkkgrb.js}

@@ -26723,6 +26723,17 @@ function buildFontAtlasIfNeeded(params) {
   };
 }
 
+// src/app/clipboard-paste.ts
+function readPastePayloadFromDataTransfer(dataTransfer) {
+  if (!dataTransfer)
+    return null;
+  const text = dataTransfer.getData("text/plain") || "";
+  return text ? {
+    kind: "text",
+    text
+  } : null;
+}
+
 // src/app/font-sources.ts
 var DEFAULT_FONT_SOURCES = [
   {
@@ -50315,6 +50326,8 @@ var DEFAULT_EMOJI_CONSTRAINT = {
 };
 function createResttyApp(options) {
   const { canvas: canvasInput, imeInput: imeInputInput, elements, callbacks } = options;
+  const beforeInputHook = options.beforeInput;
+  const beforeRenderOutputHook = options.beforeRenderOutput;
   const session = options.session ?? getDefaultResttyAppSession();
   const textShaper = exports_dist;
   if (!canvasInput) {
@@ -51593,15 +51606,18 @@ function createResttyApp(options) {
   function sendKeyInput(text, source = "key") {
     if (!text)
       return;
+    const intercepted = runBeforeInputHook(text, source);
+    if (!intercepted)
+      return;
     if (source !== "program" && (selectionState.active || selectionState.dragging)) {
       clearSelection();
     }
     if (ptyTransport.isConnected()) {
-      const payload = inputHandler.mapKeyForPty(text);
+      const payload = inputHandler.mapKeyForPty(intercepted);
       ptyTransport.sendInput(payload);
       return;
     }
-    sendInput(text, source);
+    sendInput(intercepted, source, { skipHooks: true });
   }
   function formatPasteText(text) {
     if (!inputHandler?.isBracketedPaste?.())
@@ -51613,6 +51629,13 @@ function createResttyApp(options) {
       return;
     sendKeyInput(formatPasteText(text));
   }
+  function sendPastePayloadFromDataTransfer(dataTransfer) {
+    const payload = readPastePayloadFromDataTransfer(dataTransfer);
+    if (!payload)
+      return false;
+    sendPasteText(payload.text);
+    return true;
+  }
   function openLink(uri) {
     if (!uri || typeof window === "undefined")
       return;
@@ -51911,13 +51934,16 @@ function createResttyApp(options) {
         if (imeState.composing)
           return;
         if (event.inputType === "insertFromPaste") {
+          event.preventDefault();
+          suppressNextInput = true;
           const pasteText = event.dataTransfer?.getData("text/plain") || event.data || "";
           if (pasteText) {
-            event.preventDefault();
-            suppressNextInput = true;
             sendPasteText(pasteText);
             imeInput.value = "";
+            return;
           }
+          sendPastePayloadFromDataTransfer(event.dataTransfer);
+          imeInput.value = "";
           return;
         }
         const text = inputHandler.encodeBeforeInput(event);
@@ -51954,13 +51980,16 @@ function createResttyApp(options) {
       const onPaste = (event) => {
         if (!wasmReady || !wasmHandle)
           return;
+        event.preventDefault();
+        suppressNextInput = true;
         const text = event.clipboardData?.getData("text/plain") || "";
         if (text) {
-          event.preventDefault();
-          suppressNextInput = true;
           sendPasteText(text);
           imeInput.value = "";
+          return;
         }
+        sendPastePayloadFromDataTransfer(event.clipboardData);
+        imeInput.value = "";
       };
       imeInput.addEventListener("compositionstart", onCompositionStart);
       imeInput.addEventListener("compositionupdate", onCompositionUpdate);
@@ -53235,6 +53264,36 @@ function createResttyApp(options) {
     needsRender = true;
     lastRenderTime = 0;
   }
+  function resize(cols, rows) {
+    const nextCols = Math.max(1, Math.floor(Number(cols)));
+    const nextRows = Math.max(1, Math.floor(Number(rows)));
+    if (!Number.isFinite(nextCols) || !Number.isFinite(nextRows))
+      return;
+    const dpr = window.devicePixelRatio || 1;
+    if (dpr !== currentDpr) {
+      currentDpr = dpr;
+      if (dprEl)
+        dprEl.textContent = dpr.toFixed(2);
+      callbacks?.onDpr?.(dpr);
+    }
+    const metrics = computeCellMetrics2();
+    if (!metrics)
+      return;
+    canvas.width = Math.max(1, nextCols * metrics.cellW);
+    canvas.height = Math.max(1, nextRows * metrics.cellH);
+    if (sizeEl)
+      sizeEl.textContent = `${canvas.width}x${canvas.height}`;
+    callbacks?.onCanvasSize?.(canvas.width, canvas.height);
+    resizeState.dpr = currentDpr;
+    resizeState.active = true;
+    resizeState.lastAt = performance.now();
+    resizeState.cols = nextCols;
+    resizeState.rows = nextRows;
+    updateGrid();
+    scheduleTerminalResizeCommit(nextCols, nextRows, { immediate: true });
+    needsRender = true;
+    lastRenderTime = 0;
+  }
   function scheduleSizeUpdate() {
     updateSize();
     if (sizeRaf)
@@ -53244,22 +53303,35 @@ function createResttyApp(options) {
       updateSize();
     });
   }
+  function focusTypingInput() {
+    canvas.focus({ preventScroll: true });
+    if (!imeInput)
+      return;
+    imeInput.focus({ preventScroll: true });
+    if (typeof document !== "undefined" && document.activeElement !== imeInput) {
+      requestAnimationFrame(() => {
+        if (document.activeElement === canvas)
+          imeInput.focus({ preventScroll: true });
+      });
+    }
+  }
+  function focus() {
+    focusTypingInput();
+    isFocused = typeof document !== "undefined" && imeInput ? document.activeElement === canvas || document.activeElement === imeInput : true;
+  }
+  function blur() {
+    if (imeInput && document.activeElement === imeInput) {
+      imeInput.blur();
+    }
+    if (document.activeElement === canvas) {
+      canvas.blur();
+    }
+    isFocused = false;
+  }
   function bindFocusEvents() {
     if (!attachCanvasEvents)
       return;
     canvas.tabIndex = 0;
-    const focusTypingInput = () => {
-      canvas.focus({ preventScroll: true });
-      if (!imeInput)
-        return;
-      imeInput.focus({ preventScroll: true });
-      if (typeof document !== "undefined" && document.activeElement !== imeInput) {
-        requestAnimationFrame(() => {
-          if (document.activeElement === canvas)
-            imeInput.focus({ preventScroll: true });
-        });
-      }
-    };
     const handleFocus = () => {
       isFocused = true;
       focusTypingInput();
@@ -56063,12 +56135,48 @@ function createResttyApp(options) {
     return text.replace(/\r?\n/g, `\r
 `);
   }
-  function sendInput(text, source = "program") {
+  function runBeforeInputHook(text, source) {
+    if (!beforeInputHook)
+      return text;
+    try {
+      const next = beforeInputHook({ text, source });
+      if (next === null)
+        return null;
+      if (typeof next === "string")
+        return next;
+      return text;
+    } catch (error) {
+      console.error("[restty] beforeInput hook error:", error);
+      return text;
+    }
+  }
+  function runBeforeRenderOutputHook(text, source) {
+    if (!beforeRenderOutputHook)
+      return text;
+    try {
+      const next = beforeRenderOutputHook({ text, source });
+      if (next === null)
+        return null;
+      if (typeof next === "string")
+        return next;
+      return text;
+    } catch (error) {
+      console.error("[restty] beforeRenderOutput hook error:", error);
+      return text;
+    }
+  }
+  function sendInput(text, source = "program", options2 = {}) {
     if (!wasmReady || !wasm || !wasmHandle)
       return;
     if (!text)
       return;
-    const normalized = source === "pty" ? text : normalizeNewlines(text);
+    let intercepted = text;
+    if (!options2.skipHooks) {
+      intercepted = source === "pty" ? runBeforeRenderOutputHook(text, source) : runBeforeInputHook(text, source);
+    }
+    if (!intercepted)
+      return;
+    const normalized = source === "pty" ? intercepted : normalizeNewlines(intercepted);
     if (source === "key") {
       const bytes = textEncoder3.encode(normalized);
       const hex = Array.from(bytes, (b3) => b3.toString(16).padStart(2, "0")).join(" ");
@@ -56134,6 +56242,8 @@ function createResttyApp(options) {
     return false;
   }
   async function pasteFromClipboard() {
+    if (typeof navigator === "undefined" || !navigator.clipboard)
+      return false;
     try {
       const text = await navigator.clipboard.readText();
       if (text) {
@@ -56145,6 +56255,15 @@ function createResttyApp(options) {
     }
     return false;
   }
+  async function handlePasteShortcut(event) {
+    const pasted = await pasteFromClipboard();
+    if (pasted)
+      return;
+    const seq = inputHandler.encodeKeyEvent(event);
+    if (!seq)
+      return;
+    sendKeyInput(seq);
+  }
   function clearScreen() {
     sendInput("\x1B[2J\x1B[H");
   }
@@ -56193,7 +56312,9 @@ function createResttyApp(options) {
       }
       if (wantsPaste) {
         event.preventDefault();
-        pasteFromClipboard();
+        if (imeInput)
+          imeInput.focus({ preventScroll: true });
+        handlePasteShortcut(event);
         return;
       }
       const seq = inputHandler.encodeKeyEvent(event);
@@ -56395,6 +56516,9 @@ function createResttyApp(options) {
     copySelectionToClipboard,
     pasteFromClipboard,
     dumpAtlasForCodepoint,
+    resize,
+    focus,
+    blur,
     updateSize,
     getBackend: () => backend
   };
@@ -56514,6 +56638,8 @@ function createResttyAppPaneManager(options) {
 }
 
 // src/app/restty.ts
+var RESTTY_PLUGIN_API_VERSION = 1;
+
 class ResttyPaneHandle {
   resolvePane;
   constructor(resolvePane) {
@@ -56573,6 +56699,15 @@ class ResttyPaneHandle {
   dumpAtlasForCodepoint(cp) {
     this.resolvePane().app.dumpAtlasForCodepoint(cp);
   }
+  resize(cols, rows) {
+    this.resolvePane().app.resize(cols, rows);
+  }
+  focus() {
+    this.resolvePane().app.focus();
+  }
+  blur() {
+    this.resolvePane().app.blur();
+  }
   updateSize(force) {
     this.resolvePane().app.updateSize(force);
   }
@@ -56587,25 +56722,105 @@ class ResttyPaneHandle {
 class Restty {
   paneManager;
   fontSources;
+  pluginListeners = new Map;
+  pluginRuntimes = new Map;
+  pluginDiagnostics = new Map;
+  inputInterceptors = [];
+  outputInterceptors = [];
+  lifecycleHooks = [];
+  renderHooks = [];
+  nextInterceptorId = 1;
+  nextInterceptorOrder = 1;
   constructor(options) {
-    const { createInitialPane = true, appOptions, fontSources, ...paneManagerOptions } = options;
+    const {
+      createInitialPane = true,
+      appOptions,
+      fontSources,
+      onPaneCreated,
+      onPaneClosed,
+      onPaneSplit,
+      onActivePaneChange,
+      onLayoutChanged,
+      ...paneManagerOptions
+    } = options;
     this.fontSources = fontSources ? [...fontSources] : undefined;
     const mergedAppOptions = (context) => {
       const resolved = typeof appOptions === "function" ? appOptions(context) : appOptions ?? {};
-      if (!this.fontSources)
-        return resolved;
+      const resolvedBeforeInput = resolved.beforeInput;
+      const resolvedBeforeRenderOutput = resolved.beforeRenderOutput;
       return {
         ...resolved,
-        fontSources: this.fontSources
+        ...this.fontSources ? { fontSources: this.fontSources } : {},
+        beforeInput: ({ text, source }) => {
+          const maybeUserText = resolvedBeforeInput?.({ text, source });
+          if (maybeUserText === null)
+            return null;
+          const current = maybeUserText === undefined ? text : maybeUserText;
+          return this.applyInputInterceptors(context.id, current, source);
+        },
+        beforeRenderOutput: ({ text, source }) => {
+          this.runRenderHooks({
+            phase: "before",
+            paneId: context.id,
+            text,
+            source,
+            dropped: false
+          });
+          const maybeUserText = resolvedBeforeRenderOutput?.({ text, source });
+          if (maybeUserText === null) {
+            this.runRenderHooks({
+              phase: "after",
+              paneId: context.id,
+              text,
+              source,
+              dropped: true
+            });
+            return null;
+          }
+          const current = maybeUserText === undefined ? text : maybeUserText;
+          const next = this.applyOutputInterceptors(context.id, current, source);
+          this.runRenderHooks({
+            phase: "after",
+            paneId: context.id,
+            text: next === null ? current : next,
+            source,
+            dropped: next === null
+          });
+          return next;
+        }
       };
     };
     this.paneManager = createResttyAppPaneManager({
       ...paneManagerOptions,
-      appOptions: mergedAppOptions
+      appOptions: mergedAppOptions,
+      onPaneCreated: (pane) => {
+        this.emitPluginEvent("pane:created", { paneId: pane.id });
+        onPaneCreated?.(pane);
+      },
+      onPaneClosed: (pane) => {
+        this.emitPluginEvent("pane:closed", { paneId: pane.id });
+        onPaneClosed?.(pane);
+      },
+      onPaneSplit: (sourcePane, createdPane, direction) => {
+        this.emitPluginEvent("pane:split", {
+          sourcePaneId: sourcePane.id,
+          createdPaneId: createdPane.id,
+          direction
+        });
+        onPaneSplit?.(sourcePane, createdPane, direction);
+      },
+      onActivePaneChange: (pane) => {
+        this.emitPluginEvent("pane:active-changed", { paneId: pane?.id ?? null });
+        onActivePaneChange?.(pane);
+      },
+      onLayoutChanged: () => {
+        this.emitPluginEvent("layout:changed", {});
+        onLayoutChanged?.();
+      }
     });
     if (createInitialPane) {
       const focus = typeof createInitialPane === "object" ? createInitialPane.focus ?? true : true;
-      this.paneManager.createInitialPane({ focus });
+      this.createInitialPane({ focus });
     }
   }
   getPanes() {
@@ -56656,16 +56871,63 @@ class Restty {
     await Promise.all(updates);
   }
   createInitialPane(options) {
-    return this.paneManager.createInitialPane(options);
+    this.runLifecycleHooks({ phase: "before", action: "create-initial-pane" });
+    const pane = this.paneManager.createInitialPane(options);
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "create-initial-pane",
+      paneId: pane.id,
+      ok: true
+    });
+    return pane;
   }
   splitActivePane(direction) {
-    return this.paneManager.splitActivePane(direction);
+    const sourcePaneId = this.getActivePane()?.id ?? null;
+    this.runLifecycleHooks({
+      phase: "before",
+      action: "split-active-pane",
+      paneId: sourcePaneId,
+      direction
+    });
+    const pane = this.paneManager.splitActivePane(direction);
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "split-active-pane",
+      sourcePaneId: sourcePaneId ?? undefined,
+      createdPaneId: pane?.id ?? null,
+      direction,
+      ok: !!pane
+    });
+    return pane;
   }
   splitPane(id, direction) {
-    return this.paneManager.splitPane(id, direction);
+    this.runLifecycleHooks({
+      phase: "before",
+      action: "split-pane",
+      paneId: id,
+      direction
+    });
+    const pane = this.paneManager.splitPane(id, direction);
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "split-pane",
+      sourcePaneId: id,
+      createdPaneId: pane?.id ?? null,
+      direction,
+      ok: !!pane
+    });
+    return pane;
   }
   closePane(id) {
-    return this.paneManager.closePane(id);
+    this.runLifecycleHooks({ phase: "before", action: "close-pane", paneId: id });
+    const ok = this.paneManager.closePane(id);
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "close-pane",
+      paneId: id,
+      ok
+    });
+    return ok;
   }
   getPaneStyleOptions() {
     return this.paneManager.getStyleOptions();
@@ -56674,10 +56936,34 @@ class Restty {
     this.paneManager.setStyleOptions(options);
   }
   setActivePane(id, options) {
+    this.runLifecycleHooks({
+      phase: "before",
+      action: "set-active-pane",
+      paneId: id
+    });
     this.paneManager.setActivePane(id, options);
+    const activePaneId = this.getActivePane()?.id ?? null;
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "set-active-pane",
+      paneId: activePaneId,
+      ok: activePaneId === id
+    });
   }
   markPaneFocused(id, options) {
+    this.runLifecycleHooks({
+      phase: "before",
+      action: "mark-pane-focused",
+      paneId: id
+    });
     this.paneManager.markPaneFocused(id, options);
+    const focusedPaneId = this.getFocusedPane()?.id ?? null;
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "mark-pane-focused",
+      paneId: focusedPaneId,
+      ok: focusedPaneId === id
+    });
   }
   requestLayoutSync() {
     this.paneManager.requestLayoutSync();
@@ -56685,14 +56971,193 @@ class Restty {
   hideContextMenu() {
     this.paneManager.hideContextMenu();
   }
+  async use(plugin, options) {
+    if (!plugin || typeof plugin !== "object") {
+      throw new Error("Restty plugin must be an object");
+    }
+    const pluginId = plugin.id?.trim?.() ?? "";
+    if (!pluginId) {
+      throw new Error("Restty plugin id is required");
+    }
+    if (typeof plugin.activate !== "function") {
+      throw new Error(`Restty plugin ${pluginId} must define activate(context)`);
+    }
+    if (this.pluginRuntimes.has(pluginId))
+      return;
+    try {
+      this.assertPluginCompatibility(pluginId, plugin);
+    } catch (error) {
+      this.pluginDiagnostics.set(pluginId, {
+        id: pluginId,
+        version: plugin.version?.trim?.() || null,
+        apiVersion: Number.isFinite(plugin.apiVersion) ? Number(plugin.apiVersion) : null,
+        requires: plugin.requires ?? null,
+        active: false,
+        activatedAt: null,
+        lastError: this.errorToMessage(error)
+      });
+      throw error;
+    }
+    const runtime2 = {
+      plugin: this.normalizePluginMetadata(plugin, pluginId),
+      cleanup: null,
+      activatedAt: Date.now(),
+      options,
+      disposers: []
+    };
+    this.pluginDiagnostics.set(pluginId, {
+      id: pluginId,
+      version: runtime2.plugin.version?.trim?.() || null,
+      apiVersion: Number.isFinite(runtime2.plugin.apiVersion) ? Number(runtime2.plugin.apiVersion) : null,
+      requires: runtime2.plugin.requires ?? null,
+      active: false,
+      activatedAt: null,
+      lastError: null
+    });
+    this.pluginRuntimes.set(pluginId, runtime2);
+    try {
+      const cleanup = await runtime2.plugin.activate(this.createPluginContext(runtime2), runtime2.options);
+      runtime2.cleanup = this.normalizePluginCleanup(cleanup);
+      runtime2.activatedAt = Date.now();
+      this.updatePluginDiagnostic(pluginId, {
+        active: true,
+        activatedAt: runtime2.activatedAt,
+        lastError: null
+      });
+      this.emitPluginEvent("plugin:activated", { pluginId });
+    } catch (error) {
+      this.teardownPluginRuntime(runtime2);
+      this.pluginRuntimes.delete(pluginId);
+      this.updatePluginDiagnostic(pluginId, {
+        active: false,
+        activatedAt: null,
+        lastError: this.errorToMessage(error)
+      });
+      throw error;
+    }
+  }
+  async loadPlugins(manifest, registry) {
+    const results = [];
+    for (let i3 = 0;i3 < manifest.length; i3 += 1) {
+      const item = manifest[i3];
+      const pluginId = item.id?.trim?.() ?? "";
+      if (!pluginId) {
+        results.push({
+          id: "",
+          status: "failed",
+          error: "Restty plugin manifest entry is missing id"
+        });
+        continue;
+      }
+      if (item.enabled === false) {
+        results.push({ id: pluginId, status: "skipped", error: null });
+        continue;
+      }
+      const entry = this.lookupPluginRegistryEntry(registry, pluginId);
+      if (!entry) {
+        const message = `Restty plugin ${pluginId} was not found in registry`;
+        this.setPluginLoadError(pluginId, message);
+        results.push({ id: pluginId, status: "missing", error: message });
+        continue;
+      }
+      let plugin;
+      try {
+        plugin = await this.resolvePluginRegistryEntry(entry);
+      } catch (error) {
+        const message = this.errorToMessage(error);
+        this.setPluginLoadError(pluginId, message);
+        results.push({ id: pluginId, status: "failed", error: message });
+        continue;
+      }
+      const resolvedId = plugin.id?.trim?.() ?? "";
+      if (resolvedId !== pluginId) {
+        const message = `Restty plugin registry entry ${pluginId} resolved to id ${resolvedId || "(empty)"}`;
+        this.setPluginLoadError(pluginId, message);
+        results.push({ id: pluginId, status: "failed", error: message });
+        continue;
+      }
+      try {
+        await this.use(plugin, item.options);
+        results.push({ id: pluginId, status: "loaded", error: null });
+      } catch (error) {
+        results.push({
+          id: pluginId,
+          status: "failed",
+          error: this.errorToMessage(error)
+        });
+      }
+    }
+    return results;
+  }
+  unuse(pluginId) {
+    const key = pluginId?.trim?.() ?? "";
+    if (!key)
+      return false;
+    const runtime2 = this.pluginRuntimes.get(key);
+    if (!runtime2)
+      return false;
+    this.pluginRuntimes.delete(key);
+    this.teardownPluginRuntime(runtime2);
+    this.updatePluginDiagnostic(key, {
+      active: false,
+      activatedAt: null
+    });
+    this.emitPluginEvent("plugin:deactivated", { pluginId: key });
+    return true;
+  }
+  plugins() {
+    return Array.from(this.pluginRuntimes.keys());
+  }
+  pluginInfo(pluginId) {
+    if (typeof pluginId === "string") {
+      const key = pluginId.trim();
+      if (!key)
+        return null;
+      return this.buildPluginInfo(key);
+    }
+    const keys = new Set;
+    for (const key of this.pluginDiagnostics.keys())
+      keys.add(key);
+    for (const key of this.pluginRuntimes.keys())
+      keys.add(key);
+    return Array.from(keys).sort((a3, b3) => a3.localeCompare(b3)).map((key) => this.buildPluginInfo(key)).filter((entry) => entry !== null);
+  }
   destroy() {
+    const pluginIds = this.plugins();
+    for (let i3 = 0;i3 < pluginIds.length; i3 += 1) {
+      this.unuse(pluginIds[i3]);
+    }
     this.paneManager.destroy();
   }
   connectPty(url = "") {
-    this.requireActivePaneHandle().connectPty(url);
+    const pane = this.requireActivePaneHandle();
+    this.runLifecycleHooks({
+      phase: "before",
+      action: "connect-pty",
+      paneId: pane.id
+    });
+    pane.connectPty(url);
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "connect-pty",
+      paneId: pane.id,
+      ok: true
+    });
   }
   disconnectPty() {
-    this.requireActivePaneHandle().disconnectPty();
+    const pane = this.requireActivePaneHandle();
+    this.runLifecycleHooks({
+      phase: "before",
+      action: "disconnect-pty",
+      paneId: pane.id
+    });
+    pane.disconnectPty();
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "disconnect-pty",
+      paneId: pane.id,
+      ok: true
+    });
   }
   isPtyConnected() {
     return this.requireActivePaneHandle().isPtyConnected();
@@ -56739,6 +57204,58 @@ class Restty {
   dumpAtlasForCodepoint(cp) {
     this.requireActivePaneHandle().dumpAtlasForCodepoint(cp);
   }
+  resize(cols, rows) {
+    const pane = this.requireActivePaneHandle();
+    this.runLifecycleHooks({
+      phase: "before",
+      action: "resize",
+      paneId: pane.id,
+      cols,
+      rows
+    });
+    pane.resize(cols, rows);
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "resize",
+      paneId: pane.id,
+      cols,
+      rows,
+      ok: true
+    });
+    this.emitPluginEvent("pane:resized", { paneId: pane.id, cols, rows });
+  }
+  focus() {
+    const pane = this.requireActivePaneHandle();
+    this.runLifecycleHooks({
+      phase: "before",
+      action: "focus",
+      paneId: pane.id
+    });
+    pane.focus();
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "focus",
+      paneId: pane.id,
+      ok: true
+    });
+    this.emitPluginEvent("pane:focused", { paneId: pane.id });
+  }
+  blur() {
+    const pane = this.requireActivePaneHandle();
+    this.runLifecycleHooks({
+      phase: "before",
+      action: "blur",
+      paneId: pane.id
+    });
+    pane.blur();
+    this.runLifecycleHooks({
+      phase: "after",
+      action: "blur",
+      paneId: pane.id,
+      ok: true
+    });
+    this.emitPluginEvent("pane:blurred", { paneId: pane.id });
+  }
   updateSize(force) {
     this.requireActivePaneHandle().updateSize(force);
   }
@@ -56761,9 +57278,300 @@ class Restty {
     }
     return this.makePaneHandle(pane.id);
   }
+  createPluginContext(runtime2) {
+    return {
+      restty: this,
+      options: runtime2.options,
+      panes: () => this.panes(),
+      pane: (id) => this.pane(id),
+      activePane: () => this.activePane(),
+      focusedPane: () => this.focusedPane(),
+      on: (event, listener) => {
+        return {
+          dispose: this.attachRuntimeDisposer(runtime2, "event", this.onPluginEvent(event, listener))
+        };
+      },
+      addInputInterceptor: (interceptor, options) => {
+        return {
+          dispose: this.attachRuntimeDisposer(runtime2, "input-interceptor", this.addInputInterceptor(runtime2.plugin.id, interceptor, options))
+        };
+      },
+      addOutputInterceptor: (interceptor, options) => {
+        return {
+          dispose: this.attachRuntimeDisposer(runtime2, "output-interceptor", this.addOutputInterceptor(runtime2.plugin.id, interceptor, options))
+        };
+      },
+      addLifecycleHook: (hook, options) => {
+        return {
+          dispose: this.attachRuntimeDisposer(runtime2, "lifecycle-hook", this.addLifecycleHook(runtime2.plugin.id, hook, options))
+        };
+      },
+      addRenderHook: (hook, options) => {
+        return {
+          dispose: this.attachRuntimeDisposer(runtime2, "render-hook", this.addRenderHook(runtime2.plugin.id, hook, options))
+        };
+      }
+    };
+  }
+  attachRuntimeDisposer(runtime2, kind, dispose) {
+    const entry = {
+      kind,
+      active: true,
+      dispose: () => {
+        if (!entry.active)
+          return;
+        entry.active = false;
+        dispose();
+      }
+    };
+    runtime2.disposers.push(entry);
+    return entry.dispose;
+  }
+  addInputInterceptor(pluginId, interceptor, options) {
+    return this.registerInterceptor(this.inputInterceptors, pluginId, interceptor, options);
+  }
+  addOutputInterceptor(pluginId, interceptor, options) {
+    return this.registerInterceptor(this.outputInterceptors, pluginId, interceptor, options);
+  }
+  addLifecycleHook(pluginId, hook, options) {
+    return this.registerInterceptor(this.lifecycleHooks, pluginId, hook, options);
+  }
+  addRenderHook(pluginId, hook, options) {
+    return this.registerInterceptor(this.renderHooks, pluginId, hook, options);
+  }
+  registerInterceptor(bucket, pluginId, interceptor, options) {
+    const entry = {
+      id: this.nextInterceptorId++,
+      pluginId,
+      priority: Number.isFinite(options?.priority) ? Number(options?.priority) : 0,
+      order: this.nextInterceptorOrder++,
+      interceptor
+    };
+    bucket.push(entry);
+    bucket.sort((a3, b3) => {
+      if (a3.priority !== b3.priority)
+        return a3.priority - b3.priority;
+      return a3.order - b3.order;
+    });
+    return () => {
+      const index = bucket.findIndex((current) => current.id === entry.id);
+      if (index >= 0) {
+        bucket.splice(index, 1);
+      }
+    };
+  }
+  applyInputInterceptors(paneId, text, source) {
+    return this.applyInterceptors(this.inputInterceptors, "input", { paneId, text, source });
+  }
+  applyOutputInterceptors(paneId, text, source) {
+    return this.applyInterceptors(this.outputInterceptors, "output", { paneId, text, source });
+  }
+  runLifecycleHooks(payload) {
+    this.runHooks(this.lifecycleHooks, "lifecycle", payload);
+  }
+  runRenderHooks(payload) {
+    this.runHooks(this.renderHooks, "render", payload);
+  }
+  applyInterceptors(bucket, kind, payload) {
+    let currentText = payload.text;
+    for (let i3 = 0;i3 < bucket.length; i3 += 1) {
+      const entry = bucket[i3];
+      try {
+        const result = entry.interceptor({ ...payload, text: currentText });
+        if (result === null)
+          return null;
+        if (typeof result === "string")
+          currentText = result;
+      } catch (error) {
+        console.error(`[restty plugin] ${kind} interceptor error (${entry.pluginId}):`, error);
+      }
+    }
+    return currentText;
+  }
+  runHooks(bucket, kind, payload) {
+    for (let i3 = 0;i3 < bucket.length; i3 += 1) {
+      const entry = bucket[i3];
+      try {
+        entry.interceptor(payload);
+      } catch (error) {
+        console.error(`[restty plugin] ${kind} hook error (${entry.pluginId}):`, error);
+      }
+    }
+  }
+  normalizePluginMetadata(plugin, pluginId) {
+    return {
+      ...plugin,
+      id: pluginId,
+      version: plugin.version?.trim?.() || undefined,
+      apiVersion: Number.isFinite(plugin.apiVersion) ? Math.trunc(Number(plugin.apiVersion)) : undefined,
+      requires: plugin.requires ?? undefined
+    };
+  }
+  assertPluginCompatibility(pluginId, plugin) {
+    const version = plugin.version?.trim?.();
+    if (version !== undefined && !version) {
+      throw new Error(`Restty plugin ${pluginId} has an empty version`);
+    }
+    if (plugin.apiVersion !== undefined) {
+      if (!Number.isInteger(plugin.apiVersion) || plugin.apiVersion < 1) {
+        throw new Error(`Restty plugin ${pluginId} has invalid apiVersion ${String(plugin.apiVersion)}`);
+      }
+      if (plugin.apiVersion !== RESTTY_PLUGIN_API_VERSION) {
+        throw new Error(`Restty plugin ${pluginId} requires apiVersion ${plugin.apiVersion}, current is ${RESTTY_PLUGIN_API_VERSION}`);
+      }
+    }
+    const requirement = plugin.requires?.pluginApi;
+    if (requirement === undefined)
+      return;
+    if (typeof requirement === "number") {
+      if (!Number.isInteger(requirement) || requirement < 1) {
+        throw new Error(`Restty plugin ${pluginId} has invalid requires.pluginApi value`);
+      }
+      if (requirement !== RESTTY_PLUGIN_API_VERSION) {
+        throw new Error(`Restty plugin ${pluginId} requires pluginApi ${requirement}, current is ${RESTTY_PLUGIN_API_VERSION}`);
+      }
+      return;
+    }
+    const min = requirement.min;
+    const max = requirement.max;
+    if (!Number.isInteger(min) || min < 1) {
+      throw new Error(`Restty plugin ${pluginId} has invalid requires.pluginApi.min`);
+    }
+    if (max !== undefined && (!Number.isInteger(max) || max < min)) {
+      throw new Error(`Restty plugin ${pluginId} has invalid requires.pluginApi.max`);
+    }
+    if (RESTTY_PLUGIN_API_VERSION < min || max !== undefined && RESTTY_PLUGIN_API_VERSION > max) {
+      const range = max === undefined ? `>=${min}` : `${min}-${max}`;
+      throw new Error(`Restty plugin ${pluginId} requires pluginApi range ${range}, current is ${RESTTY_PLUGIN_API_VERSION}`);
+    }
+  }
+  lookupPluginRegistryEntry(registry, pluginId) {
+    if (registry instanceof Map) {
+      return registry.get(pluginId) ?? null;
+    }
+    if (Object.prototype.hasOwnProperty.call(registry, pluginId)) {
+      return registry[pluginId];
+    }
+    return null;
+  }
+  async resolvePluginRegistryEntry(entry) {
+    if (typeof entry === "function") {
+      return await entry();
+    }
+    return entry;
+  }
+  setPluginLoadError(pluginId, message) {
+    this.pluginDiagnostics.set(pluginId, {
+      id: pluginId,
+      version: null,
+      apiVersion: null,
+      requires: null,
+      active: false,
+      activatedAt: null,
+      lastError: message
+    });
+  }
+  updatePluginDiagnostic(pluginId, patch) {
+    const current = this.pluginDiagnostics.get(pluginId);
+    if (!current)
+      return;
+    this.pluginDiagnostics.set(pluginId, {
+      ...current,
+      ...patch
+    });
+  }
+  buildPluginInfo(pluginId) {
+    const diagnostic = this.pluginDiagnostics.get(pluginId) ?? null;
+    const runtime2 = this.pluginRuntimes.get(pluginId) ?? null;
+    if (!diagnostic && !runtime2)
+      return null;
+    const plugin = runtime2?.plugin;
+    const listeners = runtime2 ? runtime2.disposers.filter((entry) => entry.active && entry.kind === "event").length : 0;
+    const inputInterceptors = runtime2 ? runtime2.disposers.filter((entry) => entry.active && entry.kind === "input-interceptor").length : 0;
+    const outputInterceptors = runtime2 ? runtime2.disposers.filter((entry) => entry.active && entry.kind === "output-interceptor").length : 0;
+    const lifecycleHooks = runtime2 ? runtime2.disposers.filter((entry) => entry.active && entry.kind === "lifecycle-hook").length : 0;
+    const renderHooks = runtime2 ? runtime2.disposers.filter((entry) => entry.active && entry.kind === "render-hook").length : 0;
+    return {
+      id: pluginId,
+      version: plugin?.version?.trim?.() || diagnostic?.version || null,
+      apiVersion: plugin?.apiVersion ?? (Number.isFinite(diagnostic?.apiVersion) ? diagnostic?.apiVersion : null),
+      requires: plugin?.requires ?? diagnostic?.requires ?? null,
+      active: runtime2 ? true : diagnostic?.active ?? false,
+      activatedAt: runtime2?.activatedAt ?? diagnostic?.activatedAt ?? null,
+      lastError: diagnostic?.lastError ?? null,
+      listeners,
+      inputInterceptors,
+      outputInterceptors,
+      lifecycleHooks,
+      renderHooks
+    };
+  }
+  errorToMessage(error) {
+    if (error instanceof Error)
+      return error.message || error.name || "Unknown error";
+    return String(error);
+  }
+  onPluginEvent(event, listener) {
+    let listeners = this.pluginListeners.get(event);
+    if (!listeners) {
+      listeners = new Set;
+      this.pluginListeners.set(event, listeners);
+    }
+    const wrapped = listener;
+    listeners.add(wrapped);
+    return () => {
+      const current = this.pluginListeners.get(event);
+      if (!current)
+        return;
+      current.delete(wrapped);
+      if (current.size === 0) {
+        this.pluginListeners.delete(event);
+      }
+    };
+  }
+  emitPluginEvent(event, payload) {
+    const listeners = this.pluginListeners.get(event);
+    if (!listeners || listeners.size === 0)
+      return;
+    const snapshot = Array.from(listeners);
+    for (let i3 = 0;i3 < snapshot.length; i3 += 1) {
+      try {
+        snapshot[i3](payload);
+      } catch (error) {
+        console.error(`[restty plugin] listener error (${String(event)}):`, error);
+      }
+    }
+  }
+  teardownPluginRuntime(runtime2) {
+    for (let i3 = 0;i3 < runtime2.disposers.length; i3 += 1) {
+      try {
+        runtime2.disposers[i3].dispose();
+      } catch {}
+    }
+    runtime2.disposers.length = 0;
+    const cleanup = runtime2.cleanup;
+    runtime2.cleanup = null;
+    if (!cleanup)
+      return;
+    try {
+      cleanup();
+    } catch (error) {
+      console.error(`[restty plugin] cleanup error (${runtime2.plugin.id}):`, error);
+    }
+  }
+  normalizePluginCleanup(cleanup) {
+    if (!cleanup)
+      return null;
+    if (typeof cleanup === "function")
+      return cleanup;
+    if (typeof cleanup === "object" && typeof cleanup.dispose === "function") {
+      return () => cleanup.dispose();
+    }
+    return null;
+  }
 }
 function createRestty(options) {
   return new Restty(options);
 }
 
-export { BOX_LINE_MAP, BOX_STYLE_NONE, BOX_STYLE_LIGHT, BOX_STYLE_HEAVY, BOX_STYLE_DOUBLE, isPrivateUse, isSpaceCp, isBoxDrawing, isBlockElement, isLegacyComputing, isPowerline, isBraille, isGraphicsElement, isSymbolCp, applyAlpha, pushRect, pushRectSnapped, pushRectBox, drawBlockElement, drawBoxDrawing, drawBraille, drawPowerline, constrainGlyphBox, RECT_SHADER, GLYPH_SHADER, initWebGPUCore, initWebGPU, initWebGL, ensureInstanceBuffer, configureContext, ensureGLInstanceBuffer, createResizeState, createScrollbarState, ResttyWasm, loadResttyWasm, createInputHandler, NERD_SYMBOL_RANGES, isNerdSymbolCodepoint, fontHeightUnits, computeCellMetrics, createGridState, updateGridState, clamp, isSymbolFont, isNerdSymbolFont, fontMaxCellSpan, fontScaleOverride, fontRasterScale, createFontEntry, resetFontEntry, createFontManagerState, fontHasGlyph, fontAdvanceUnits, glyphWidthUnits, pickFontIndexForText, tryFetchFontBuffer, tryLocalFontBuffer, loadPrimaryFontBuffer, loadFallbackFontBuffers, NERD_CONSTRAINTS, getNerdConstraint, createPtyConnection, connectPty, disconnectPty, sendPtyInput, sendPtyResize, isPtyConnected, createWebSocketPtyTransport, parseGhosttyColor, colorToFloats, colorToRgbU32, parseGhosttyTheme, listBuiltinThemeNames, isBuiltinThemeName, getBuiltinThemeSource, getBuiltinTheme, createImeState, setPreedit, clearPreedit, startComposition, updateComposition, endComposition, syncImeSelection, updateImePosition, PREEDIT_BG, PREEDIT_ACTIVE_BG, PREEDIT_FG, PREEDIT_UL, PREEDIT_CARET, ResttyPaneHandle, Restty, createRestty };
+export { BOX_LINE_MAP, BOX_STYLE_NONE, BOX_STYLE_LIGHT, BOX_STYLE_HEAVY, BOX_STYLE_DOUBLE, isPrivateUse, isSpaceCp, isBoxDrawing, isBlockElement, isLegacyComputing, isPowerline, isBraille, isGraphicsElement, isSymbolCp, applyAlpha, pushRect, pushRectSnapped, pushRectBox, drawBlockElement, drawBoxDrawing, drawBraille, drawPowerline, constrainGlyphBox, RECT_SHADER, GLYPH_SHADER, initWebGPUCore, initWebGPU, initWebGL, ensureInstanceBuffer, configureContext, ensureGLInstanceBuffer, createResizeState, createScrollbarState, ResttyWasm, loadResttyWasm, createInputHandler, NERD_SYMBOL_RANGES, isNerdSymbolCodepoint, fontHeightUnits, computeCellMetrics, createGridState, updateGridState, clamp, isSymbolFont, isNerdSymbolFont, fontMaxCellSpan, fontScaleOverride, fontRasterScale, createFontEntry, resetFontEntry, createFontManagerState, fontHasGlyph, fontAdvanceUnits, glyphWidthUnits, pickFontIndexForText, tryFetchFontBuffer, tryLocalFontBuffer, loadPrimaryFontBuffer, loadFallbackFontBuffers, NERD_CONSTRAINTS, getNerdConstraint, createPtyConnection, connectPty, disconnectPty, sendPtyInput, sendPtyResize, isPtyConnected, createWebSocketPtyTransport, parseGhosttyColor, colorToFloats, colorToRgbU32, parseGhosttyTheme, listBuiltinThemeNames, isBuiltinThemeName, getBuiltinThemeSource, getBuiltinTheme, createImeState, setPreedit, clearPreedit, startComposition, updateComposition, endComposition, syncImeSelection, updateImePosition, PREEDIT_BG, PREEDIT_ACTIVE_BG, PREEDIT_FG, PREEDIT_UL, PREEDIT_CARET, RESTTY_PLUGIN_API_VERSION, ResttyPaneHandle, Restty, createRestty };