omnius 1.0.860 → 1.0.862

package/dist/tui/native/worker.js

@@ -0,0 +1,2010 @@
+// packages/cli/src/tui/native/worker.ts
+import { createWriteStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { PassThrough } from "node:stream";
+import { CliRenderEvents as CliRenderEvents2, NativeSession, RGBA as RGBA2, createCliRenderer } from "@opentui/core";
+
+// packages/cli/src/tui/native/components/frontend.ts
+import {
+  BoxRenderable as BoxRenderable3,
+  CliRenderEvents,
+  EmbeddedTerminalRenderable as EmbeddedTerminalRenderable2,
+  ScrollBoxRenderable as ScrollBoxRenderable3,
+  SyntaxStyle as SyntaxStyle2,
+  TabSelectRenderable,
+  TextareaRenderable as TextareaRenderable2,
+  TextRenderable as TextRenderable3,
+  createClipboard,
+  createHostClipboard,
+  createRendererClipboardAdapter
+} from "@opentui/core";
+
+// packages/cli/src/tui/native/components/blocks.ts
+import {
+  BoxRenderable,
+  CodeRenderable,
+  EmbeddedTerminalRenderable,
+  ImageRenderable,
+  MarkdownRenderable,
+  ScrollBoxRenderable,
+  TextRenderable
+} from "@opentui/core";
+
+// packages/cli/src/tui/native/components/text.ts
+import { RGBA, StyledText } from "@opentui/core";
+
+// packages/cli/src/tui/native/text.ts
+function stripTextControls(value) {
+  return value.replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, "").replace(/\x1b[P_^X][\s\S]*?\x1b\\/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b[\s\S]/g, "").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "").replace(/\r\n/g, "\n").replace(/\r/g, "");
+}
+function nativeTextFromAnsi(value) {
+  const result = [];
+  let style = { attributes: 0 };
+  let previous = 0;
+  const pattern = /\x1b(?:\[[0-?]*[ -/]*[@-~]|\][\s\S]*?(?:\x07|\x1b\\)|[P_^X][\s\S]*?\x1b\\|[\s\S])/g;
+  const append = (text) => {
+    const clean = stripTextControls(text);
+    if (!clean) return;
+    const last = result.at(-1);
+    if (last && last.fg === style.fg && last.bg === style.bg && last.attributes === style.attributes && last.link === style.link)
+      last.text += clean;
+    else result.push({ ...style, text: clean });
+  };
+  for (const match of value.matchAll(pattern)) {
+    append(value.slice(previous, match.index));
+    previous = match.index + match[0].length;
+    const seq = match[0];
+    if (seq.startsWith("\x1B]8;")) {
+      const url = seq.replace(/^\x1b\]8;[^;]*;/, "").replace(/(?:\x07|\x1b\\)$/, "");
+      if (/^(?:https?:|file:)/.test(url)) style.link = url;
+      else delete style.link;
+      continue;
+    }
+    if (!/^\x1b\[[\d;:]*m$/.test(seq)) continue;
+    const codes = seq.slice(2, -1).replace(/:/g, ";").split(";").map(Number);
+    for (let i = 0; i < codes.length; i++) {
+      const code = codes[i];
+      const attr = style.attributes ?? 0;
+      if (code === 0) style = { attributes: 0 };
+      else if (code >= 1 && code <= 9) {
+        const bit = {
+          1: 1,
+          2: 2,
+          3: 4,
+          4: 8,
+          5: 16,
+          6: 16,
+          7: 32,
+          8: 64,
+          9: 128
+        }[code];
+        style.attributes = attr | bit;
+      } else if (code >= 22 && code <= 29) {
+        const bit = { 22: 3, 23: 4, 24: 8, 25: 16, 27: 32, 28: 64, 29: 128 }[code] ?? 0;
+        style.attributes = attr & ~bit;
+      } else if (code === 39) delete style.fg;
+      else if (code === 49) delete style.bg;
+      else if (code >= 30 && code <= 37) style.fg = `index:${code - 30}`;
+      else if (code >= 90 && code <= 97) style.fg = `index:${code - 90 + 8}`;
+      else if (code >= 40 && code <= 47) style.bg = `index:${code - 40}`;
+      else if (code >= 100 && code <= 107) style.bg = `index:${code - 100 + 8}`;
+      else if ((code === 38 || code === 48) && codes[i + 1] === 5) {
+        style[code === 38 ? "fg" : "bg"] = `index:${Math.max(0, Math.min(255, codes[i + 2] ?? 0))}`;
+        i += 2;
+      } else if ((code === 38 || code === 48) && codes[i + 1] === 2) {
+        const rgb = codes.slice(i + 2, i + 5).map(
+          (n) => Math.max(0, Math.min(255, n)).toString(16).padStart(2, "0")
+        );
+        if (rgb.length === 3)
+          style[code === 38 ? "fg" : "bg"] = `#${rgb.join("")}`;
+        i += 4;
+      }
+    }
+  }
+  append(value.slice(previous));
+  return result;
+}
+
+// packages/cli/src/tui/native/components/text.ts
+var colorCache = /* @__PURE__ */ new Map();
+function nativeColor(value, background = false) {
+  if (value === void 0 || value === -1 || value === "default")
+    return background ? RGBA.defaultBackground() : RGBA.defaultForeground();
+  const key = String(value);
+  if (key === "index:-1") return background ? RGBA.defaultBackground() : RGBA.defaultForeground();
+  let color = colorCache.get(key);
+  if (!color) {
+    color = typeof value === "number" || /^\d+$/.test(key) ? RGBA.fromIndex(Number(value)) : key.startsWith("index:") ? RGBA.fromIndex(Number(key.slice(6))) : RGBA.fromHex(key);
+    if (colorCache.size >= 1024) colorCache.delete(colorCache.keys().next().value);
+    colorCache.set(key, color);
+  }
+  return color;
+}
+function plainText(value) {
+  return typeof value === "string" ? stripTextControls(value) : (value ?? []).map((span) => stripTextControls(span.text)).join("");
+}
+function textSpans(value) {
+  return Array.isArray(value) ? value.map((span) => ({ ...span, text: stripTextControls(span.text) })) : nativeTextFromAnsi(value ?? "");
+}
+function styledText(value) {
+  return new StyledText(textSpans(value).map((span) => ({
+    __isChunk: true,
+    text: span.text,
+    ...span.fg === void 0 ? {} : { fg: nativeColor(span.fg) },
+    ...span.bg === void 0 ? {} : { bg: nativeColor(span.bg, true) },
+    ...span.attributes === void 0 ? {} : { attributes: span.attributes },
+    ...span.link ? { link: { url: span.link } } : {}
+  })));
+}
+function palette(theme) {
+  return {
+    background: nativeColor(theme.bg, true),
+    foreground: nativeColor(theme.textPrimary),
+    accent: nativeColor(theme.accent),
+    dim: nativeColor(theme.textDim),
+    border: nativeColor(theme.boxColor),
+    warning: nativeColor(theme.mode === "branding" ? 180 : 214),
+    error: nativeColor(theme.mode === "branding" ? 173 : 198),
+    success: nativeColor(theme.mode === "branding" ? 114 : 78),
+    selection: nativeColor(theme.mode === "branding" ? 65 : theme.accent < 0 ? 240 : theme.accent)
+  };
+}
+
+// packages/cli/src/tui/native/components/blocks.ts
+var NativeBlockView = class {
+  constructor(context, spec, inline = false) {
+    this.context = context;
+    this.inline = inline;
+    this.spec = spec;
+    this.pixel = inline && spec.kind === "text" && Boolean(spec.actions?.length) && spec.actions.every((action) => action.id.startsWith("pixel:"));
+    this.root = new BoxRenderable(context.renderer, {
+      id: `block:${spec.id}`,
+      flexDirection: "column",
+      flexShrink: inline && !this.pixel ? 1 : 0,
+      flexGrow: inline && !this.pixel ? 1 : 0,
+      flexBasis: inline && !this.pixel ? 0 : "auto",
+      minWidth: inline && !this.pixel ? 0 : void 0,
+      width: this.pixel ? 1 : inline ? "auto" : "100%"
+    });
+    this.build();
+    this.update(spec);
+  }
+  context;
+  inline;
+  root;
+  spec;
+  title;
+  text;
+  body;
+  children;
+  actions;
+  progressBar;
+  progressValue;
+  image;
+  terminal;
+  collapsed = false;
+  previousModelCollapsed;
+  signature = "";
+  pixel;
+  get block() {
+    return this.spec;
+  }
+  build() {
+    const { renderer: renderer2, colors, syntax } = this.context;
+    const spec = this.spec;
+    if (spec.kind === "card") this.root.borderStyle = "rounded";
+    this.root.border = spec.kind === "card";
+    this.root.paddingX = spec.kind === "card" ? 1 : 0;
+    this.root.marginBottom = spec.kind === "card" ? 1 : 0;
+    this.root.flexDirection = spec.kind === "row" ? "row" : "column";
+    if (spec.title) {
+      this.title = new TextRenderable(renderer2, {
+        id: `block-title:${spec.id}`,
+        content: "",
+        fg: colors.accent,
+        flexShrink: 0,
+        width: "100%",
+        wrapMode: "word",
+        selectable: false,
+        onMouseDown: (event) => {
+          if (event.button !== 0 || !this.spec.collapsible) return;
+          this.toggle();
+          event.stopPropagation();
+        }
+      });
+      this.root.add(this.title);
+    }
+    this.body = new BoxRenderable(renderer2, {
+      id: `block-body:${spec.id}`,
+      flexDirection: spec.kind === "row" ? "row" : "column",
+      width: this.pixel ? "auto" : "100%",
+      flexShrink: 0
+    });
+    this.root.add(this.body);
+    if (spec.kind === "terminal") {
+      this.terminal = new EmbeddedTerminalRenderable(renderer2, {
+        id: `embedded:${spec.id}`,
+        width: "100%",
+        height: spec.height ?? 14,
+        maxScrollback: 1e4,
+        transparentBackground: true,
+        selectable: true,
+        onData: (data) => this.context.emit({ type: "embedded-data", id: this.spec.id, data: Buffer.from(data).toString("base64") }),
+        onTerminalResize: (columns, rows) => this.context.emit({ type: "embedded-resize", id: this.spec.id, columns, rows })
+      });
+      this.context.terminals.set(spec.id, this.terminal);
+      this.body.add(this.terminal);
+    } else if (spec.kind === "image" && spec.imagePath) {
+      this.image = new ImageRenderable(renderer2, {
+        id: `image:${spec.id}`,
+        source: spec.imagePath,
+        width: "100%",
+        height: spec.height ?? 12,
+        fit: "fit",
+        protocol: "auto",
+        onError: (error) => {
+          if (this.image) this.image.visible = false;
+          if (this.text) {
+            this.text.visible = true;
+            if (this.text instanceof TextRenderable) this.text.content = styledText(this.spec.text ?? "Image unavailable");
+          }
+          this.context.emit({ type: "action", action: "image-error", id: spec.id, text: String(error) });
+        },
+        onLoad: () => {
+          if (this.image) this.image.visible = true;
+          if (this.text) this.text.visible = false;
+        }
+      });
+      this.body.add(this.image);
+      this.text = new TextRenderable(renderer2, { id: `image-fallback:${spec.id}`, content: "", visible: false, width: "100%", wrapMode: "word", fg: colors.dim, selectable: true });
+      this.body.add(this.text);
+    } else if (spec.kind === "markdown") {
+      this.text = new MarkdownRenderable(renderer2, {
+        id: `markdown:${spec.id}`,
+        content: "",
+        syntaxStyle: syntax,
+        fg: colors.foreground,
+        bg: colors.background,
+        streaming: spec.streaming ?? false,
+        width: "100%",
+        flexShrink: 0,
+        internalBlockMode: "top-level",
+        conceal: true,
+        tableOptions: { style: "columns", widthMode: "full", wrapMode: "word", selectable: true }
+      });
+      this.body.add(this.text);
+    } else if (spec.kind === "code") {
+      this.text = new CodeRenderable(renderer2, {
+        id: `code:${spec.id}`,
+        content: "",
+        filetype: spec.language,
+        syntaxStyle: syntax,
+        fg: colors.foreground,
+        bg: colors.background,
+        width: "100%",
+        flexShrink: 0,
+        streaming: spec.streaming ?? false,
+        selectable: true,
+        wrapMode: "word",
+        drawUnstyledText: true
+      });
+      this.body.add(this.text);
+    } else if (spec.text !== void 0) {
+      this.text = new TextRenderable(renderer2, {
+        id: `text:${spec.id}`,
+        content: "",
+        width: this.pixel ? "auto" : "100%",
+        flexShrink: 0,
+        wrapMode: "word",
+        fg: colors.foreground,
+        bg: colors.background,
+        selectable: true
+      });
+      this.body.add(this.text);
+    }
+    if (spec.kind === "progress") {
+      this.progressBar = new BoxRenderable(renderer2, {
+        id: `progress-track:${spec.id}`,
+        width: "100%",
+        height: 1,
+        backgroundColor: colors.dim
+      });
+      this.progressValue = new BoxRenderable(renderer2, {
+        id: `progress-value:${spec.id}`,
+        height: 1,
+        width: "0%",
+        backgroundColor: colors.accent
+      });
+      this.progressBar.add(this.progressValue);
+      this.body.add(this.progressBar);
+    }
+    this.children = new NativeBlockList(this.context, this.body);
+    this.actions = new BoxRenderable(renderer2, {
+      id: `block-actions:${spec.id}`,
+      flexDirection: "row",
+      gap: 2,
+      flexShrink: 0
+    });
+    this.root.add(this.actions);
+  }
+  reset() {
+    this.children?.destroy();
+    if (this.terminal) this.context.terminals.delete(this.spec.id);
+    for (const child of [...this.root.getChildren()]) child.destroyRecursively();
+    this.title = this.text = this.body = this.actions = this.progressBar = this.progressValue = this.image = this.terminal = void 0;
+    this.children = void 0;
+    this.build();
+  }
+  update(spec) {
+    const signature = JSON.stringify(spec);
+    if (signature === this.signature) return;
+    const rebuild = spec.kind !== this.spec.kind || Boolean(spec.title) !== Boolean(this.spec.title) || spec.text !== void 0 !== (this.spec.text !== void 0) || Boolean(spec.imagePath) !== Boolean(this.spec.imagePath) || spec.kind === "image" && spec.imageRevision !== this.spec.imageRevision;
+    this.spec = spec;
+    if (rebuild) this.reset();
+    this.signature = signature;
+    if (spec.collapsed !== this.previousModelCollapsed) {
+      this.collapsed = spec.collapsed ?? false;
+      this.previousModelCollapsed = spec.collapsed;
+    }
+    if (this.title) this.title.content = styledText(`${spec.collapsible ? this.collapsed ? "▸ " : "▾ " : ""}${spec.title ?? ""}`);
+    if (this.body) this.body.visible = !this.collapsed;
+    if (this.text instanceof TextRenderable) this.text.content = styledText(spec.kind === "image" ? spec.text ?? "Image unavailable" : spec.text);
+    else if (this.text instanceof MarkdownRenderable || this.text instanceof CodeRenderable) {
+      this.text.content = plainText(spec.text);
+      this.text.streaming = spec.streaming ?? false;
+      if (this.text instanceof CodeRenderable) this.text.filetype = spec.language;
+    }
+    if (this.image && spec.imagePath && this.image.source !== spec.imagePath) this.image.source = spec.imagePath;
+    if (this.terminal) this.terminal.height = spec.height ?? 14;
+    if (this.image) this.image.height = spec.height ?? 12;
+    if (this.progressValue) this.progressValue.width = `${Math.round(Math.min(1, Math.max(0, spec.progress ?? 0)) * 100)}%`;
+    this.children?.replace(spec.children ?? []);
+    if (this.actions) {
+      for (const child of [...this.actions.getChildren()]) child.destroy();
+      for (const action of spec.actions ?? []) {
+        const button = new TextRenderable(this.context.renderer, {
+          id: `block-action:${spec.id}:${action.id}`,
+          content: styledText(action.label),
+          fg: action.disabled ? this.context.colors.dim : spec.color ? nativeColor(spec.color) : this.context.colors.accent,
+          attributes: action.active ? 33 : 0,
+          flexShrink: 0,
+          selectable: false,
+          onMouseDown: (event) => {
+            if (event.button !== 0 || action.disabled) return;
+            this.context.emit({ type: "action", action: action.command ?? action.id, id: this.spec.id });
+            event.stopPropagation();
+          },
+          onKeyDown: (key) => {
+            if (key.name !== "return" || action.disabled) return;
+            this.context.emit({ type: "action", action: action.command ?? action.id, id: this.spec.id });
+            key.preventDefault();
+          }
+        });
+        button.focusable = !action.disabled;
+        if (action.id.startsWith("pixel:") && !action.disabled) {
+          button.onMouseOver = () => this.context.emit({ type: "action", action: `hover:${action.id}`, id: this.spec.id });
+          button.onMouseOut = () => this.context.emit({ type: "action", action: `hover-end:${action.id}`, id: this.spec.id });
+        }
+        this.actions.add(button);
+      }
+      this.actions.visible = (spec.actions?.length ?? 0) > 0;
+    }
+    this.applyTheme();
+  }
+  toggle() {
+    this.collapsed = !this.collapsed;
+    if (this.body) this.body.visible = !this.collapsed;
+    if (this.title) this.title.content = styledText(`${this.collapsed ? "▸ " : "▾ "}${this.spec.title ?? ""}`);
+    this.context.emit({ type: "action", action: "toggle-block", id: this.spec.id });
+  }
+  applyTheme() {
+    const colors = this.context.colors;
+    this.root.backgroundColor = colors.background;
+    if (this.spec.kind === "card") this.root.borderColor = this.spec.color ? nativeColor(this.spec.color) : colors.border;
+    else this.root.border = false;
+    if (this.title) {
+      this.title.fg = this.spec.color ? nativeColor(this.spec.color) : colors.accent;
+      this.title.bg = colors.background;
+    }
+    if (this.body) this.body.backgroundColor = colors.background;
+    if (this.text) {
+      this.text.fg = this.spec.color ? nativeColor(this.spec.color) : colors.foreground;
+      this.text.bg = colors.background;
+    }
+    if (this.progressBar) this.progressBar.backgroundColor = colors.dim;
+    if (this.progressValue) this.progressValue.backgroundColor = colors.accent;
+    this.children?.applyTheme();
+  }
+  destroy() {
+    this.children?.destroy();
+    if (this.terminal) this.context.terminals.delete(this.spec.id);
+    this.root.destroyRecursively();
+  }
+};
+var NativeBlockList = class {
+  constructor(context, parent) {
+    this.context = context;
+    this.parent = parent;
+  }
+  context;
+  parent;
+  views = /* @__PURE__ */ new Map();
+  order = [];
+  patch(patch) {
+    if (patch.reset) this.clear();
+    for (const id of patch.remove) this.remove(id);
+    for (const spec of patch.upsert) {
+      const existing = this.views.get(spec.id);
+      if (existing) existing.update(spec);
+      else {
+        const direction = this.parent instanceof ScrollBoxRenderable ? this.parent.content.primaryAxis : this.parent.primaryAxis;
+        const view = new NativeBlockView(this.context, spec, direction === "row");
+        this.views.set(spec.id, view);
+        this.order.push(spec.id);
+        this.parent.add(view.root);
+      }
+    }
+    if (patch.order) this.reorder(patch.order);
+  }
+  replace(blocks) {
+    const keep = new Set(blocks.map((block) => block.id));
+    this.patch({ remove: [...this.views.keys()].filter((id) => !keep.has(id)), upsert: blocks, order: blocks.map((block) => block.id) });
+  }
+  reorder(order) {
+    const next = order.filter((id) => this.views.has(id));
+    if (next.length === this.order.length && next.every((id, index) => this.order[index] === id)) return;
+    next.forEach((id, index) => this.parent.add(this.views.get(id).root, index));
+    this.order = next;
+  }
+  remove(id) {
+    this.views.get(id)?.destroy();
+    this.views.delete(id);
+    this.order = this.order.filter((value) => value !== id);
+  }
+  applyTheme() {
+    for (const view of this.views.values()) view.applyTheme();
+  }
+  clear() {
+    for (const view of this.views.values()) view.destroy();
+    this.views.clear();
+    this.order = [];
+  }
+  destroy() {
+    this.clear();
+  }
+};
+
+// packages/cli/src/tui/native/components/modals.ts
+import {
+  BoxRenderable as BoxRenderable2,
+  InputRenderable,
+  ScrollBoxRenderable as ScrollBoxRenderable2,
+  TextareaRenderable,
+  TextRenderable as TextRenderable2
+} from "@opentui/core";
+
+// packages/cli/src/tui/native/components/select.ts
+import { SelectRenderable } from "@opentui/core";
+var NativeSelectRenderable = class extends SelectRenderable {
+  onActivate;
+  constructor(renderer2, options) {
+    super(renderer2, options);
+  }
+  disabled(index) {
+    const option = this.options[index];
+    return !option || option.value?.disabled === true;
+  }
+  moveUp(steps = 1) {
+    this.move(-steps);
+  }
+  moveDown(steps = 1) {
+    this.move(steps);
+  }
+  move(delta) {
+    if (this.options.length === 0) return;
+    const direction = delta < 0 ? -1 : 1;
+    let index = Math.min(this.options.length - 1, Math.max(0, this.getSelectedIndex() + delta));
+    for (let attempts = 0; attempts < this.options.length && this.disabled(index); attempts++) {
+      index += direction;
+      if (index < 0 || index >= this.options.length) {
+        if (!this.wrapSelection) return;
+        index = index < 0 ? this.options.length - 1 : 0;
+      }
+    }
+    if (!this.disabled(index)) this.setSelectedIndex(index);
+  }
+  selectCurrent() {
+    if (!this.disabled(this.getSelectedIndex())) super.selectCurrent();
+  }
+  onMouseEvent(event) {
+    if (event.type === "scroll") {
+      if (event.scroll?.direction === "up") this.moveUp(1);
+      else if (event.scroll?.direction === "down") this.moveDown(1);
+      event.stopPropagation();
+      return;
+    }
+    if (event.type !== "down" || event.button !== 0) return;
+    const lines = this.showDescription ? 2 : 1;
+    const count = Math.max(1, Math.floor(this.height / lines));
+    const start = Math.max(0, Math.min(this.getSelectedIndex() - Math.floor(count / 2), this.options.length - count));
+    const index = start + Math.floor((event.y - this.y) / lines);
+    if (index >= start && index < Math.min(start + count, this.options.length) && !this.disabled(index)) {
+      this.setSelectedIndex(index);
+      this.onActivate?.();
+    }
+    event.stopPropagation();
+  }
+};
+
+// packages/cli/src/tui/native/components/modals.ts
+var NativeModalView = class {
+  constructor(context, spec, close2) {
+    this.context = context;
+    this.close = close2;
+    this.spec = spec;
+    const { renderer: renderer2, colors } = context;
+    this.root = new BoxRenderable2(renderer2, {
+      id: `modal:${spec.id}`,
+      position: "absolute",
+      top: 0,
+      left: 0,
+      width: "100%",
+      height: "100%",
+      flexDirection: "column",
+      justifyContent: "center",
+      alignItems: "center",
+      zIndex: 100,
+      backgroundColor: colors.background
+    });
+    this.panel = new BoxRenderable2(renderer2, {
+      id: `modal-panel:${spec.id}`,
+      flexDirection: "column",
+      width: "94%",
+      maxHeight: "94%",
+      border: true,
+      borderStyle: "rounded",
+      borderColor: colors.border,
+      backgroundColor: colors.background,
+      paddingX: 1,
+      paddingY: 1,
+      onMouseDown: () => this.focus()
+    });
+    this.root.add(this.panel);
+    this.breadcrumb = this.addText(`modal-breadcrumb:${spec.id}`);
+    this.heading = this.addText(`modal-title:${spec.id}`);
+    this.description = this.addText(`modal-description:${spec.id}`);
+    if (spec.kind === "select") this.buildSelect();
+    else if (spec.kind === "input") this.buildInput();
+    else if (spec.kind === "document") {
+      this.document = new ScrollBoxRenderable2(renderer2, {
+        id: `modal-document:${spec.id}`,
+        width: "100%",
+        height: Math.max(5, Math.floor(renderer2.terminalHeight * 0.6)),
+        scrollY: true,
+        scrollX: false,
+        viewportCulling: true,
+        contentOptions: { flexDirection: "column" }
+      });
+      this.blocks = new NativeBlockList(this.modalContext(), this.document);
+      this.panel.add(this.document);
+    } else {
+      this.progressTrack = new BoxRenderable2(renderer2, { id: `modal-progress:${spec.id}`, width: "100%", height: 1, backgroundColor: colors.dim });
+      this.progressValue = new BoxRenderable2(renderer2, { id: `modal-progress-value:${spec.id}`, width: "0%", height: 1, backgroundColor: colors.accent });
+      this.progressTrack.add(this.progressValue);
+      this.panel.add(this.progressTrack);
+      const progressBlocks = new BoxRenderable2(renderer2, { id: `modal-progress-blocks:${spec.id}`, flexDirection: "column", width: "100%" });
+      this.panel.add(progressBlocks);
+      this.blocks = new NativeBlockList(this.modalContext(), progressBlocks);
+    }
+    this.error = this.addText(`modal-error:${spec.id}`);
+    this.hints = this.addText(`modal-hints:${spec.id}`);
+    this.actions = new BoxRenderable2(renderer2, { id: `modal-actions:${spec.id}`, flexDirection: "row", gap: 2, width: "100%", marginTop: 1 });
+    this.panel.add(this.actions);
+    this.update(spec);
+  }
+  context;
+  close;
+  root;
+  panel;
+  spec;
+  heading;
+  description;
+  breadcrumb;
+  error;
+  hints;
+  actions;
+  filterInput;
+  editor;
+  secretMask;
+  select;
+  document;
+  blocks;
+  progressTrack;
+  progressValue;
+  filtered = [];
+  filter = "";
+  changing = false;
+  addText(id) {
+    const text = new TextRenderable2(this.context.renderer, { id, content: "", width: "100%", wrapMode: "word", flexShrink: 0, fg: this.context.colors.foreground, selectable: true });
+    this.panel.add(text);
+    return text;
+  }
+  buildSelect() {
+    const { renderer: renderer2, colors } = this.context;
+    this.filterInput = new InputRenderable(renderer2, {
+      id: `modal-filter:${this.spec.id}`,
+      width: "100%",
+      value: this.spec.filter ?? "",
+      placeholder: "Filter…",
+      textColor: colors.foreground,
+      backgroundColor: colors.background,
+      focusedTextColor: colors.foreground,
+      focusedBackgroundColor: colors.background,
+      onContentChange: () => {
+        if (this.changing || !this.filterInput) return;
+        this.filter = this.filterInput.plainText;
+        this.refreshOptions();
+        this.emitAction("filter", this.filter);
+      }
+    });
+    this.filter = this.spec.filter ?? "";
+    this.panel.add(this.filterInput);
+    this.select = new NativeSelectRenderable(renderer2, {
+      id: `modal-select:${this.spec.id}`,
+      width: "100%",
+      height: 5,
+      options: [],
+      showDescription: false,
+      showScrollIndicator: true,
+      showSelectionIndicator: true,
+      wrapSelection: false,
+      backgroundColor: colors.background,
+      focusedBackgroundColor: colors.background,
+      textColor: colors.foreground,
+      focusedTextColor: colors.foreground,
+      selectedBackgroundColor: colors.selection,
+      selectedTextColor: colors.foreground
+    });
+    this.select.onActivate = () => this.confirm();
+    this.select.on("selectionChanged", () => {
+      if (!this.changing) this.emitAction("focus");
+    });
+    this.select.on("itemSelected", () => this.confirm());
+    this.panel.add(this.select);
+  }
+  buildInput() {
+    const { renderer: renderer2, colors } = this.context;
+    const options = {
+      id: `modal-input:${this.spec.id}`,
+      width: "100%",
+      textColor: colors.foreground,
+      backgroundColor: colors.background,
+      focusedTextColor: colors.foreground,
+      focusedBackgroundColor: colors.background,
+      placeholder: this.spec.placeholder ?? "",
+      selectionBg: colors.selection,
+      cursorColor: colors.accent,
+      onContentChange: () => {
+        if (!this.editor || this.changing) return;
+        this.refreshMask();
+        if (!this.spec.secret) this.emitAction("change", this.editor.plainText);
+      },
+      onSubmit: () => this.confirm()
+    };
+    this.editor = this.spec.multiline ? new TextareaRenderable(renderer2, {
+      ...options,
+      initialValue: this.spec.value ?? "",
+      height: Math.max(3, Math.min(10, Math.floor(renderer2.terminalHeight / 3))),
+      wrapMode: "word",
+      keyBindings: [{ name: "return", ctrl: true, action: "submit" }]
+    }) : new InputRenderable(renderer2, { ...options, value: this.spec.value ?? "" });
+    if (this.spec.secret) {
+      this.secretMask = this.addText(`modal-secret:${this.spec.id}`);
+      this.secretMask.selectable = false;
+      this.editor.showCursor = false;
+    } else this.panel.add(this.editor);
+  }
+  refreshMask() {
+    if (this.secretMask && this.editor) this.secretMask.content = "•".repeat(Array.from(this.editor.plainText).length);
+  }
+  update(patch) {
+    const old = this.spec;
+    this.spec = { ...old, ...patch };
+    const spec = this.spec;
+    this.changing = true;
+    try {
+      this.heading.content = styledText(spec.title);
+      this.description.content = styledText(spec.description);
+      this.description.visible = plainText(spec.description).length > 0;
+      this.breadcrumb.content = (spec.breadcrumbs ?? []).join(" › ");
+      this.breadcrumb.visible = (spec.breadcrumbs?.length ?? 0) > 0;
+      this.error.content = spec.validationError ?? "";
+      this.error.visible = Boolean(spec.validationError);
+      this.hints.content = spec.hints ?? (spec.kind === "select" ? "↑ ↓ select · Enter confirm · Esc return" : spec.multiline ? "Ctrl+Enter confirm · Esc return" : "Enter confirm · Esc return");
+      if (this.filterInput && patch.filter !== void 0 && patch.filter !== old.filter) {
+        this.filter = patch.filter;
+        this.filterInput.setText(patch.filter);
+      }
+      if (this.editor && patch.value !== void 0 && patch.value !== old.value) this.editor.setText(patch.value);
+      this.refreshMask();
+      this.refreshOptions(patch.selectedIndex);
+      this.blocks?.replace(spec.blocks ?? []);
+      if (this.progressValue) this.progressValue.width = `${Math.round(Math.max(0, Math.min(1, spec.progress ?? 0)) * 100)}%`;
+      for (const child of [...this.actions.getChildren()]) child.destroy();
+      for (const action of spec.actions ?? []) {
+        const button = new TextRenderable2(this.context.renderer, {
+          id: `modal-action:${spec.id}:${action.id}`,
+          content: styledText(action.label),
+          fg: action.disabled ? this.context.colors.dim : this.context.colors.accent,
+          selectable: false,
+          onMouseDown: (event) => {
+            if (event.button !== 0 || action.disabled) return;
+            this.emitAction(action.command ?? action.id, this.editor?.plainText);
+            event.stopPropagation();
+          },
+          onKeyDown: (key) => {
+            if (key.name !== "return" || action.disabled) return;
+            this.emitAction(action.command ?? action.id, this.editor?.plainText);
+            key.preventDefault();
+          }
+        });
+        button.focusable = !action.disabled;
+        this.actions.add(button);
+      }
+      this.actions.visible = (spec.actions?.length ?? 0) > 0;
+    } finally {
+      this.changing = false;
+    }
+    this.applyTheme();
+  }
+  refreshOptions(selectedIndex) {
+    if (!this.select) return;
+    const query = this.filter.trim().toLocaleLowerCase();
+    const previousKey = this.current()?.item.key;
+    this.filtered = (this.spec.items ?? []).map((item, index) => ({ item, index })).filter(({ item }) => !query || `${plainText(item.label)} ${plainText(item.description)}`.toLocaleLowerCase().includes(query));
+    this.select.options = this.filtered.map(({ item, index }) => ({
+      name: `${item.heading ? "── " : ""}${plainText(item.label)}`,
+      description: plainText(item.description),
+      value: { key: item.key, index, disabled: item.disabled || item.heading }
+    }));
+    this.select.showDescription = this.filtered.some(({ item }) => Boolean(plainText(item.description)));
+    const rowCount = this.select.showDescription ? 2 : 1;
+    this.select.height = Math.max(1, Math.min(Math.max(3, Math.floor(this.context.renderer.terminalHeight * 0.55)), this.filtered.length * rowCount));
+    const preferred = selectedIndex !== void 0 ? this.filtered.findIndex((entry) => entry.index === selectedIndex) : this.filtered.findIndex((entry) => entry.item.key === previousKey);
+    const firstEnabled = this.filtered.findIndex((entry) => !entry.item.disabled && !entry.item.heading);
+    this.select.setSelectedIndex(preferred >= 0 && !this.filtered[preferred].item.disabled && !this.filtered[preferred].item.heading ? preferred : Math.max(0, firstEnabled));
+  }
+  current() {
+    return this.filtered[this.select?.getSelectedIndex() ?? -1];
+  }
+  modalContext() {
+    const scoped = Object.create(this.context);
+    scoped.emit = (event) => {
+      if (event.type === "action") this.emitAction(event.action, event.id);
+      else this.context.emit(event);
+    };
+    return scoped;
+  }
+  emitAction(action, value) {
+    const current = this.current();
+    this.context.emit({ type: "modal-action", id: this.spec.id, action, key: current?.item.key, index: current?.index, value });
+  }
+  confirm() {
+    if (this.spec.kind === "progress") {
+      this.emitAction("enter");
+      return;
+    }
+    const current = this.current();
+    if (this.spec.kind === "select" && (!current || current.item.disabled || current.item.heading)) return;
+    const value = this.editor?.plainText;
+    if (this.spec.deferSelection) {
+      this.emitAction("enter", value);
+      return;
+    }
+    this.close(this.spec.id, { confirmed: true, key: current?.item.key ?? null, index: current?.index ?? -1, ...value === void 0 ? {} : { value } });
+  }
+  cancel(action = "cancel") {
+    if (this.spec.deferSelection) {
+      this.emitAction(action);
+      return;
+    }
+    this.close(this.spec.id, { confirmed: false, key: this.spec.breadcrumbs?.length ? "__back__" : null, index: this.current()?.index ?? -1 });
+  }
+  focus() {
+    if (this.filterInput) this.filterInput.focus();
+    else if (this.editor && !this.spec.secret) this.editor.focus();
+    else if (this.document) this.document.focus();
+    else this.panel.focus();
+  }
+  handleKey(key) {
+    const consume = () => {
+      key.preventDefault();
+      key.stopPropagation();
+      return true;
+    };
+    if (key.name === "escape" || key.ctrl && key.name === "c") {
+      this.cancel();
+      return consume();
+    }
+    if (key.name === "tab") {
+      this.emitAction(key.shift ? "shift-tab" : "tab");
+      return consume();
+    }
+    if (this.spec.kind === "select") {
+      if (key.name === "up" || key.name === "down" || key.name === "pageup" || key.name === "pagedown") {
+        const amount = key.name.startsWith("page") ? Math.max(1, Math.floor((this.select?.height ?? 5) / (this.select?.showDescription ? 2 : 1))) : 1;
+        if (key.name === "up" || key.name === "pageup") this.select?.moveUp(amount);
+        else this.select?.moveDown(amount);
+        return consume();
+      }
+      if (key.name === "return") {
+        this.confirm();
+        return consume();
+      }
+      if (key.name === "left" || key.name === "right" || key.name === "delete" || key.name === "backspace" && !this.filter) {
+        const action = key.name;
+        if (this.spec.deferSelection) this.emitAction(action);
+        else if (action === "backspace") this.cancel("backspace");
+        return consume();
+      }
+      if (key.sequence === " " && !this.filter && this.spec.deferSelection) {
+        this.emitAction("space");
+        return consume();
+      }
+      if (key.name && key.sequence.length === 1 && !key.ctrl && !key.meta && this.spec.deferSelection && this.spec.captureKeys) {
+        this.emitAction("key", key.sequence);
+        return consume();
+      }
+      this.filterInput?.handleKeyPress(key);
+      return consume();
+    }
+    if (this.spec.kind === "input") {
+      if (key.name === "return" && (!this.spec.multiline || key.ctrl)) {
+        this.confirm();
+        return consume();
+      }
+      if (!key.ctrl && !key.meta && key.sequence && !key.sequence.startsWith("\x1B") && key.sequence.charCodeAt(0) >= 32 && this.overBudget(key.sequence, this.editor?.plainText ?? "")) return consume();
+      if (this.spec.secret) {
+        this.editor?.handleKeyPress(key);
+        this.refreshMask();
+        return consume();
+      }
+      return false;
+    }
+    if (key.name === "return") {
+      this.confirm();
+      return consume();
+    }
+    if (this.document && (key.name === "pageup" || key.name === "pagedown" || key.name === "up" || key.name === "down")) {
+      this.document.scrollBy(key.name === "up" ? -1 : key.name === "down" ? 1 : key.name === "pageup" ? -1 : 1, key.name.startsWith("page") ? "viewport" : "absolute");
+      return consume();
+    }
+    if (key.sequence.length === 1 && !key.ctrl && !key.meta) {
+      this.emitAction("key", key.sequence);
+      return consume();
+    }
+    return false;
+  }
+  handlePaste(event) {
+    const text = new TextDecoder().decode(event.bytes);
+    if (this.overBudget(text, this.filterInput?.plainText ?? this.editor?.plainText ?? "")) {
+      event.preventDefault();
+      event.stopPropagation();
+      return true;
+    }
+    if (this.filterInput) this.filterInput.handlePaste(event);
+    else if (this.spec.secret) {
+      this.editor?.handlePaste(event);
+      this.refreshMask();
+    } else return false;
+    event.preventDefault();
+    event.stopPropagation();
+    return true;
+  }
+  overBudget(text, current) {
+    const budget = this.spec.maxBytes ?? 1024 * 1024;
+    if (Buffer.byteLength(text, "utf8") + Buffer.byteLength(current, "utf8") <= budget) return false;
+    this.error.content = `Input exceeds the ${budget.toLocaleString()} byte limit.`;
+    this.error.visible = true;
+    return true;
+  }
+  applyTheme() {
+    const colors = this.context.colors;
+    this.root.backgroundColor = colors.background;
+    this.panel.backgroundColor = colors.background;
+    this.panel.borderColor = colors.border;
+    this.heading.fg = colors.accent;
+    this.description.fg = colors.foreground;
+    this.breadcrumb.fg = colors.dim;
+    this.error.fg = colors.error;
+    this.hints.fg = colors.dim;
+    if (this.select) {
+      this.select.backgroundColor = this.select.focusedBackgroundColor = colors.background;
+      this.select.textColor = this.select.focusedTextColor = colors.foreground;
+      this.select.selectedBackgroundColor = colors.selection;
+      this.select.selectedTextColor = colors.foreground;
+      this.select.descriptionColor = colors.dim;
+      this.select.selectedDescriptionColor = colors.foreground;
+    }
+    for (const editor of [this.editor, this.filterInput]) if (editor) {
+      editor.backgroundColor = editor.focusedBackgroundColor = colors.background;
+      editor.textColor = editor.focusedTextColor = colors.foreground;
+      editor.selectionBg = colors.selection;
+      editor.cursorColor = colors.accent;
+    }
+    if (this.secretMask) this.secretMask.fg = colors.foreground;
+    this.blocks?.applyTheme();
+  }
+  destroy() {
+    this.blocks?.destroy();
+    if (this.spec.secret) this.editor?.destroy();
+    this.root.destroyRecursively();
+  }
+};
+var NativeModalStack = class {
+  constructor(context, restoreFocus) {
+    this.context = context;
+    this.restoreFocus = restoreFocus;
+  }
+  context;
+  restoreFocus;
+  views = [];
+  byId = /* @__PURE__ */ new Map();
+  get active() {
+    return this.views.at(-1);
+  }
+  open(spec) {
+    const existing = this.byId.get(spec.id);
+    if (existing) {
+      existing.update(spec);
+      existing.focus();
+      return;
+    }
+    if (this.active) this.active.root.visible = false;
+    const view = new NativeModalView(this.context, spec, (id, result) => this.close(id, result, true));
+    this.views.push(view);
+    this.byId.set(spec.id, view);
+    this.context.renderer.root.add(view.root);
+    view.focus();
+  }
+  update(id, patch) {
+    this.byId.get(id)?.update(patch);
+  }
+  close(id, result, notify = false) {
+    const view = this.byId.get(id);
+    if (!view) return;
+    const wasActive = view === this.active;
+    view.destroy();
+    this.byId.delete(id);
+    this.views = this.views.filter((candidate) => candidate !== view);
+    if (wasActive) {
+      if (this.active) {
+        this.active.root.visible = true;
+        this.active.focus();
+      } else this.restoreFocus();
+    }
+    if (notify) this.context.emit({ type: "modal-result", id, result });
+  }
+  applyTheme() {
+    for (const view of this.views) view.applyTheme();
+  }
+  destroy() {
+    for (const view of this.views) view.destroy();
+    this.views = [];
+    this.byId.clear();
+  }
+};
+
+// packages/cli/src/tui/native/components/frontend.ts
+var initialTheme = { mode: "branding", bg: -1, accent: 108, textPrimary: 254, textDim: 145, boxColor: 108 };
+var spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+var NativeFrontend = class {
+  constructor(renderer2, emit) {
+    this.renderer = renderer2;
+    this.emit = emit;
+    const colors = palette(initialTheme);
+    this.context = { renderer: renderer2, colors, syntax: SyntaxStyle2.fromStyles({}, renderer2.nativeScene), emit, terminals: /* @__PURE__ */ new Map() };
+    this.clipboard = createClipboard({ host: createHostClipboard({ timeoutMs: 1500 }), terminal: createRendererClipboardAdapter(renderer2) });
+    this.root = new BoxRenderable3(renderer2, {
+      id: "omnius-native",
+      width: "100%",
+      height: "100%",
+      flexDirection: "column",
+      backgroundColor: colors.background
+    });
+    renderer2.root.add(this.root);
+    this.header = new BoxRenderable3(renderer2, {
+      id: "omnius-header",
+      width: "100%",
+      flexDirection: "column",
+      flexShrink: 0,
+      border: true,
+      borderStyle: "rounded",
+      borderColor: colors.border,
+      paddingX: 1
+    });
+    this.root.add(this.header);
+    const headerRow = new BoxRenderable3(renderer2, { id: "omnius-header-row", width: "100%", height: 1, flexDirection: "row", gap: 2 });
+    this.header.add(headerRow);
+    this.identity = new TextRenderable3(renderer2, {
+      id: "omnius-identity",
+      content: "Omnius",
+      fg: colors.foreground,
+      flexShrink: 1,
+      flexGrow: 1,
+      wrapMode: "none",
+      truncate: true,
+      minWidth: 8,
+      selectable: false
+    });
+    headerRow.add(this.identity);
+    this.headerActions = new ScrollBoxRenderable3(renderer2, {
+      id: "omnius-header-actions",
+      width: "50%",
+      flexGrow: 0,
+      flexShrink: 0,
+      minWidth: 0,
+      height: 1,
+      scrollX: true,
+      scrollY: false,
+      contentOptions: { flexDirection: "row", gap: 2 },
+      verticalScrollbarOptions: { visible: false },
+      horizontalScrollbarOptions: { visible: false }
+    });
+    headerRow.add(this.headerActions);
+    this.headerPanel = new TextRenderable3(renderer2, { id: "omnius-header-panel", content: "", width: "100%", wrapMode: "word", visible: false });
+    this.header.add(this.headerPanel);
+    this.routeWarning = new TextRenderable3(renderer2, { id: "omnius-route-warning", content: "", width: "100%", wrapMode: "word", fg: colors.warning, visible: false, flexShrink: 0 });
+    this.root.add(this.routeWarning);
+    this.tabs = new TabSelectRenderable(renderer2, {
+      id: "omnius-agent-tabs",
+      width: "100%",
+      height: 1,
+      showDescription: false,
+      showUnderline: false,
+      showScrollArrows: true,
+      tabWidth: 18,
+      wrapSelection: true,
+      visible: false,
+      backgroundColor: colors.background,
+      focusedBackgroundColor: colors.background,
+      textColor: colors.dim,
+      selectedTextColor: colors.foreground,
+      selectedBackgroundColor: colors.selection,
+      onMouseDown: (event) => {
+        if (event.button !== 0) return;
+        const count = Math.max(1, Math.floor(this.tabs.width / this.tabs.getTabWidth()));
+        const start = Math.max(0, Math.min(this.tabs.getSelectedIndex() - Math.floor(count / 2), this.tabs.options.length - count));
+        this.tabs.setSelectedIndex(start + Math.floor((event.x - this.tabs.x) / this.tabs.getTabWidth()));
+        event.stopPropagation();
+      }
+    });
+    this.tabs.on("selectionChanged", () => {
+      if (this.changing) return;
+      const selected = this.tabs.getSelectedOption();
+      if (selected) this.emit({ type: "action", action: "view", id: String(selected.value) });
+      this.editor.focus();
+    });
+    this.root.add(this.tabs);
+    this.taskPane = new BoxRenderable3(renderer2, { id: "omnius-tasks", width: "100%", flexDirection: "column", maxHeight: 6, flexShrink: 0, overflow: "hidden", visible: false });
+    this.tasks = new NativeBlockList(this.context, this.taskPane);
+    this.root.add(this.taskPane);
+    this.body = new BoxRenderable3(renderer2, { id: "omnius-body", width: "100%", flexDirection: "row", flexGrow: 1, minHeight: 1 });
+    this.root.add(this.body);
+    this.scroll = new ScrollBoxRenderable3(renderer2, {
+      id: "omnius-conversation",
+      flexGrow: 1,
+      flexShrink: 1,
+      minWidth: 0,
+      minHeight: 1,
+      scrollY: true,
+      scrollX: false,
+      stickyScroll: true,
+      stickyStart: "bottom",
+      viewportCulling: true,
+      verticalScrollbarOptions: { showArrows: false, trackOptions: { foregroundColor: colors.dim, backgroundColor: colors.background } },
+      contentOptions: { flexDirection: "column", onMouseDown: (event) => {
+        if (!this.selectionArmed || event.button !== 0 || !event.target) return;
+        this.selectionArmed = false;
+        let block = event.target;
+        while (block && !block.id.startsWith("block:")) block = block.parent;
+        if (!block) return;
+        const selectables = [];
+        const visit = (node) => {
+          if (!node.visible) return;
+          if (node.selectable && node.height > 0 && node.width > 0) selectables.push(node);
+          for (const child of node.getChildren()) visit(child);
+        };
+        visit(block);
+        const first = selectables[0], last = selectables.at(-1);
+        if (first && last) {
+          this.renderer.startSelection(first, first.x, first.y, "line");
+          this.renderer.updateSelection(last, last.x + Math.max(0, last.width - 1), last.y + Math.max(0, last.height - 1), { finishDragging: true });
+        }
+        event.preventDefault();
+        event.stopPropagation();
+      } }
+    });
+    this.body.add(this.scroll);
+    this.content = new NativeBlockList(this.context, this.scroll);
+    this.embeddedPane = new BoxRenderable3(renderer2, {
+      id: "omnius-editor-pane",
+      width: "50%",
+      flexShrink: 0,
+      flexDirection: "column",
+      border: true,
+      borderStyle: "rounded",
+      borderColor: colors.border,
+      visible: false
+    });
+    this.body.add(this.embeddedPane);
+    this.liveButton = new TextRenderable3(renderer2, {
+      id: "omnius-live-button",
+      content: "↓ Live",
+      width: "100%",
+      height: 1,
+      visible: false,
+      fg: colors.accent,
+      selectable: false,
+      onMouseDown: (event) => {
+        if (event.button === 0) {
+          this.scrollToLive();
+          event.stopPropagation();
+        }
+      },
+      onKeyDown: (key) => {
+        if (key.name === "return") {
+          this.scrollToLive();
+          key.preventDefault();
+        }
+      }
+    });
+    this.liveButton.focusable = true;
+    this.root.add(this.liveButton);
+    this.queue = new TextRenderable3(renderer2, { id: "omnius-steering-queue", content: "", width: "100%", height: 1, wrapMode: "none", truncate: true, fg: colors.dim, visible: false, flexShrink: 0 });
+    this.root.add(this.queue);
+    this.suggestions = new NativeSelectRenderable(renderer2, {
+      id: "omnius-suggestions",
+      width: "100%",
+      height: 1,
+      visible: false,
+      showDescription: false,
+      showScrollIndicator: true,
+      showSelectionIndicator: true,
+      backgroundColor: colors.background,
+      focusedBackgroundColor: colors.background,
+      textColor: colors.dim,
+      selectedTextColor: colors.foreground,
+      selectedBackgroundColor: colors.selection
+    });
+    this.suggestions.onActivate = () => this.acceptSuggestion();
+    this.suggestions.on("itemSelected", () => this.acceptSuggestion());
+    this.root.add(this.suggestions);
+    this.footer = new BoxRenderable3(renderer2, {
+      id: "omnius-input-box",
+      width: "100%",
+      flexShrink: 0,
+      border: true,
+      borderStyle: "rounded",
+      borderColor: colors.border,
+      flexDirection: "column",
+      paddingX: 1
+    });
+    this.root.add(this.footer);
+    const inputRow = new BoxRenderable3(renderer2, { id: "omnius-input-row", width: "100%", flexDirection: "row", gap: 1 });
+    this.footer.add(inputRow);
+    this.prompt = new TextRenderable3(renderer2, { id: "omnius-prompt", content: "❯", fg: colors.accent, wrapMode: "none", selectable: false, flexShrink: 0 });
+    inputRow.add(this.prompt);
+    this.editor = new TextareaRenderable2(renderer2, {
+      id: "omnius-input",
+      flexGrow: 1,
+      minWidth: 0,
+      height: 1,
+      maxHeight: 8,
+      wrapMode: "word",
+      textColor: colors.foreground,
+      backgroundColor: colors.background,
+      focusedTextColor: colors.foreground,
+      focusedBackgroundColor: colors.background,
+      selectionBg: colors.selection,
+      cursorColor: colors.accent,
+      cursorStyle: { style: "block", blinking: true },
+      keyBindings: [{ name: "return", action: "submit" }, { name: "return", shift: true, action: "newline" }],
+      onContentChange: () => this.editorChanged(),
+      onCursorChange: () => this.editorChanged(),
+      onSubmit: () => this.submit()
+    });
+    inputRow.add(this.editor);
+    this.enhance = new BoxRenderable3(renderer2, { id: "omnius-enhance", flexDirection: "row", gap: 1, flexShrink: 0, visible: false });
+    inputRow.add(this.enhance);
+    this.activity = new TextRenderable3(renderer2, { id: "omnius-activity", content: "", width: "100%", height: 1, wrapMode: "none", truncate: true, visible: false, fg: colors.accent });
+    this.footer.add(this.activity);
+    this.media = new BoxRenderable3(renderer2, { id: "omnius-media", width: "100%", height: 1, flexDirection: "row", gap: 1, visible: false });
+    this.mediaText = new TextRenderable3(renderer2, { id: "omnius-media-text", content: "", flexGrow: 1, minWidth: 0, wrapMode: "none", truncate: true, fg: colors.accent });
+    this.media.add(this.mediaText);
+    this.micTrack = new BoxRenderable3(renderer2, { id: "omnius-mic-meter", width: 12, height: 1, flexShrink: 0, backgroundColor: colors.dim, visible: false });
+    this.micLevel = new BoxRenderable3(renderer2, { id: "omnius-mic-level", width: "0%", height: 1, backgroundColor: colors.accent });
+    this.micTrack.add(this.micLevel);
+    this.media.add(this.micTrack);
+    this.footer.add(this.media);
+    this.metricsRow = new BoxRenderable3(renderer2, { id: "omnius-metrics-row", width: "100%", height: 1, flexShrink: 0, flexDirection: "row", gap: 1 });
+    this.metricsStartActions = new BoxRenderable3(renderer2, { id: "omnius-metrics-start-actions", flexDirection: "row", gap: 1, flexShrink: 0 });
+    this.metricsRow.add(this.metricsStartActions);
+    this.metrics = new TextRenderable3(renderer2, { id: "omnius-metrics", content: "", height: 1, wrapMode: "none", truncate: true, fg: colors.dim, flexShrink: 1, flexGrow: 1, minWidth: 0 });
+    this.metricsRow.add(this.metrics);
+    this.metricsEndActions = new BoxRenderable3(renderer2, { id: "omnius-metrics-end-actions", flexDirection: "row", gap: 1, flexShrink: 0 });
+    this.metricsRow.add(this.metricsEndActions);
+    this.root.add(this.metricsRow);
+    this.modals = new NativeModalStack(this.context, () => this.restoreFocus());
+    renderer2.keyInput.on("keypress", this.onKey);
+    renderer2.keyInput.on("paste", this.onPaste);
+    renderer2.on(CliRenderEvents.FRAME, this.onFrame);
+    renderer2.on(CliRenderEvents.RESIZE, this.onResize);
+    this.applyTheme(initialTheme);
+    this.editor.focus();
+  }
+  renderer;
+  emit;
+  root;
+  scroll;
+  editor;
+  content;
+  modals;
+  context;
+  header;
+  identity;
+  headerActions;
+  headerPanel;
+  routeWarning;
+  tabs;
+  taskPane;
+  tasks;
+  body;
+  embeddedPane;
+  liveButton;
+  queue;
+  suggestions;
+  footer;
+  prompt;
+  enhance;
+  metrics;
+  metricsRow;
+  metricsStartActions;
+  metricsEndActions;
+  activity;
+  media;
+  mediaText;
+  micTrack;
+  micLevel;
+  clipboard;
+  state;
+  themeSignature = "";
+  headerSignature = "";
+  tabsSignature = "";
+  suggestionSignature = "";
+  metricsActionsSignature = "";
+  changing = false;
+  paused = false;
+  editorInitialized = false;
+  lastInput = "";
+  lastCursor = -1;
+  history = [];
+  historyIndex = -1;
+  savedInput = "";
+  animation;
+  animationIndex = 0;
+  inputEventPending = false;
+  viewportSignature = "";
+  newEntries = 0;
+  destroyed = false;
+  pendingScrollRestore;
+  viewScroll = /* @__PURE__ */ new Map();
+  embeddedId;
+  selectionArmed = false;
+  update(state, patch) {
+    const inputWasEnabled = this.state?.input.enabled;
+    const previousView = this.state ? `${this.state.activeViewId}:${this.state.presentation ?? "stack"}` : void 0;
+    const currentView = `${state.activeViewId}:${state.presentation ?? "stack"}`;
+    const viewChanged = previousView !== void 0 && previousView !== currentView;
+    if (viewChanged) {
+      this.viewScroll.set(previousView, { top: this.scroll.scrollTop, live: this.offset === 0 });
+      this.pendingScrollRestore = this.viewScroll.get(currentView) ?? { top: 0, live: true };
+      this.newEntries = 0;
+    }
+    this.state = state;
+    this.changing = true;
+    try {
+      this.applyTheme(state.theme);
+      const headerSignature = JSON.stringify(state.header);
+      if (headerSignature !== this.headerSignature) {
+        this.headerSignature = headerSignature;
+        this.identity.content = styledText([
+          { text: state.header.title, ...state.theme.accent < 0 ? {} : { fg: `index:${state.theme.accent}` } },
+          ...state.header.detail ? [{ text: "  " }, ...textSpans(state.header.detail)] : []
+        ]);
+        this.headerPanel.content = styledText(state.header.panel);
+        this.headerPanel.visible = plainText(state.header.panel).length > 0;
+        this.replaceActions(this.headerActions, state.header.actions, "header");
+        this.headerActions.visible = state.header.actions.length > 0;
+      }
+      this.routeWarning.content = state.routeWarning ?? "";
+      this.routeWarning.visible = Boolean(state.routeWarning);
+      const tabsSignature = JSON.stringify(state.tabs);
+      if (tabsSignature !== this.tabsSignature) {
+        this.tabsSignature = tabsSignature;
+        this.tabs.setOptions(state.tabs.map((tab) => ({ name: plainText(tab.label), description: "", value: tab.id })));
+      }
+      this.tabs.visible = state.tabs.length > 1;
+      const activeTab = state.tabs.findIndex((tab) => tab.id === state.activeViewId);
+      if (activeTab >= 0 && activeTab !== this.tabs.getSelectedIndex()) this.tabs.setSelectedIndex(activeTab);
+      this.tasks.replace(state.tasks);
+      this.taskPane.visible = state.tasks.length > 0;
+      if (patch) {
+        if (this.offset > 0 && !viewChanged && !patch.reset) this.newEntries += patch.upsert.filter((block) => !this.content.views.has(block.id)).length;
+        this.content.patch(patch);
+      }
+      this.queue.content = state.queued.length ? `Queued (${state.queued.length}) · ${state.queued.join("  ·  ")}` : "";
+      this.queue.visible = state.queued.length > 0;
+      const suggestionSignature = JSON.stringify(state.suggestions);
+      if (suggestionSignature !== this.suggestionSignature) {
+        this.suggestionSignature = suggestionSignature;
+        const selected = this.suggestions.getSelectedOption()?.value;
+        this.suggestions.options = state.suggestions.map((item) => ({ name: item.value, description: item.description ?? "", value: item.value }));
+        const index = state.suggestions.findIndex((item) => item.value === selected);
+        if (index >= 0) this.suggestions.setSelectedIndex(index);
+      }
+      this.suggestions.visible = state.suggestions.length > 0;
+      this.suggestions.height = Math.min(4, state.suggestions.length || 1);
+      this.prompt.content = styledText(state.prompt.trimEnd() || "❯");
+      if (!this.editorInitialized) {
+        this.editor.setText(state.input.text);
+        this.editor.cursorOffset = Math.max(0, Math.min(state.input.text.length, state.input.cursor));
+        this.editorInitialized = true;
+      }
+      this.editor.focusable = state.input.enabled && !this.paused;
+      if (state.input.enabled && !this.paused && !this.modals.active && (inputWasEnabled === false || !this.renderer.currentFocusedRenderable)) this.editor.focus();
+      this.metrics.content = styledText(state.metrics);
+      this.metricsRow.visible = state.metricsVisible;
+      const metricsActions = JSON.stringify(state.metricsActions ?? []);
+      if (metricsActions !== this.metricsActionsSignature) {
+        this.metricsActionsSignature = metricsActions;
+        this.replaceActions(this.metricsStartActions, (state.metricsActions ?? []).filter((action) => action.id === "agents"), "metrics");
+        this.replaceActions(this.metricsEndActions, (state.metricsActions ?? []).filter((action) => action.id !== "agents"), "metrics");
+      }
+      this.renderEnhance();
+      this.renderActivity();
+      this.renderMedia();
+      this.updateAnimation();
+    } finally {
+      this.changing = false;
+    }
+    this.editorChanged();
+    this.renderer.requestRender();
+  }
+  replaceActions(parent, actions, prefix) {
+    for (const child of [...parent.getChildren()]) child.destroy();
+    for (const action of actions) {
+      const colors = this.context.colors;
+      const filled = prefix === "enhance" || prefix === "header" && !action.id.startsWith("header-");
+      const inverse = filled && prefix === "header" && (this.state?.theme.mode === "system" || this.state?.theme.accent === -1);
+      const backing = prefix === "enhance" ? colors.warning : colors.accent;
+      const [r, g, b] = backing.toInts();
+      const foreground = filled && !inverse ? nativeColor(r * 0.299 + g * 0.587 + b * 0.114 > 140 ? 16 : 231) : colors.accent;
+      const button = new TextRenderable3(this.renderer, {
+        id: `${prefix}:${action.id}`,
+        content: styledText(filled ? ` ${action.label} ` : action.label),
+        flexShrink: 0,
+        wrapMode: "none",
+        selectable: false,
+        fg: action.disabled ? colors.dim : foreground,
+        bg: filled && !inverse ? backing : colors.background,
+        attributes: (action.active ? 1 : 0) | (inverse ? 32 : 0),
+        onMouseDown: (event) => {
+          if (event.button !== 0 || action.disabled) return;
+          this.emit({ type: "action", action: action.command ?? action.id, id: action.id });
+          event.stopPropagation();
+        },
+        onKeyDown: (key) => {
+          if (key.name !== "return" || action.disabled) return;
+          this.emit({ type: "action", action: action.command ?? action.id, id: action.id });
+          key.preventDefault();
+        }
+      });
+      button.focusable = !action.disabled;
+      if (!action.disabled) {
+        button.onMouseOver = () => {
+          button.bg = colors.selection;
+          button.fg = colors.foreground;
+        };
+        button.onMouseOut = () => {
+          button.bg = filled && !inverse ? backing : colors.background;
+          button.fg = foreground;
+        };
+      }
+      parent.add(button);
+    }
+  }
+  renderEnhance() {
+    const state = this.state?.enhance;
+    this.enhance.visible = Boolean(state);
+    if (!state) return;
+    const actions = state.state === "confirm" ? [{ id: "enhance-accept", label: "✓" }, { id: "enhance-reject", label: "×" }] : [{ id: "enhance", label: state.state === "busy" ? `${spinner[this.animationIndex % spinner.length]} Enhance` : state.label ?? "Enhance", disabled: state.state === "busy" }];
+    this.replaceActions(this.enhance, actions, "enhance");
+  }
+  renderActivity() {
+    const activity = this.state?.activity;
+    const stage = activity?.stage === "idle" ? void 0 : activity?.stage;
+    this.activity.visible = Boolean(activity?.processing || activity?.label || stage);
+    this.activity.content = `${activity?.processing ? spinner[this.animationIndex % spinner.length] + " " : ""}${[activity?.label, stage].filter(Boolean).join(" · ")}`;
+  }
+  renderMedia() {
+    const media = this.state?.media;
+    this.media.visible = Boolean(media && (media.audio || media.video || media.voiceEnabled || media.recording || media.countdown > 0 || media.label));
+    if (!media) return;
+    this.mediaText.content = [
+      media.recording ? `${this.animationIndex % 10 < 5 ? "●" : "○"} REC` : void 0,
+      media.speech ? "speech" : void 0,
+      media.audio ? "audio" : void 0,
+      media.video ? "video" : void 0,
+      media.voiceEnabled ? "voice" : void 0,
+      media.countdown > 0 ? `${media.countdown}s` : void 0,
+      media.levelDb === void 0 ? void 0 : `${media.levelDb} dB`,
+      media.label
+    ].filter(Boolean).join(" · ");
+    this.mediaText.fg = media.recording ? this.context.colors.warning : this.context.colors.accent;
+    this.micTrack.visible = media.recording && media.levelDb !== void 0;
+    this.micLevel.width = `${Math.round(Math.max(0, Math.min(1, ((media.levelDb ?? -60) + 60) / 60)) * 100)}%`;
+    this.micLevel.backgroundColor = media.speech ? this.context.colors.success : this.context.colors.accent;
+  }
+  updateAnimation() {
+    const active = this.state?.activity?.processing || this.state?.enhance?.state === "busy" || this.state?.media?.recording;
+    if (active && !this.animation) {
+      this.animation = setInterval(() => {
+        this.animationIndex++;
+        this.renderActivity();
+        this.renderMedia();
+        if (this.state?.enhance?.state === "busy") this.renderEnhance();
+      }, 100);
+      this.animation.unref();
+    } else if (!active && this.animation) {
+      clearInterval(this.animation);
+      this.animation = void 0;
+    }
+  }
+  applyTheme(theme) {
+    const signature = JSON.stringify(theme);
+    if (signature === this.themeSignature) return;
+    this.themeSignature = signature;
+    this.headerSignature = "";
+    this.metricsActionsSignature = "";
+    const colors = this.context.colors = palette(theme);
+    for (const [name, style] of Object.entries({
+      default: { fg: colors.foreground },
+      "markup.heading": { fg: colors.accent, bold: true },
+      "markup.strong": { fg: colors.foreground, bold: true },
+      "markup.italic": { fg: colors.foreground, italic: true },
+      "markup.link": { fg: colors.accent, underline: true },
+      "markup.link.url": { fg: colors.dim },
+      "markup.raw": { fg: colors.accent },
+      "markup.list": { fg: colors.accent },
+      "markup.quote": { fg: colors.dim },
+      comment: { fg: colors.dim, italic: true },
+      keyword: { fg: colors.accent, bold: true },
+      string: { fg: colors.success },
+      number: { fg: colors.warning },
+      function: { fg: colors.foreground },
+      type: { fg: colors.accent },
+      punctuation: { fg: colors.dim }
+    })) this.context.syntax.registerStyle(name, style);
+    this.root.backgroundColor = colors.background;
+    this.header.backgroundColor = this.footer.backgroundColor = colors.background;
+    this.header.borderColor = this.footer.borderColor = this.embeddedPane.borderColor = colors.border;
+    this.identity.fg = colors.foreground;
+    this.headerPanel.fg = colors.foreground;
+    this.routeWarning.fg = colors.warning;
+    this.prompt.fg = this.activity.fg = this.liveButton.fg = colors.accent;
+    this.micTrack.backgroundColor = colors.dim;
+    this.micLevel.backgroundColor = colors.accent;
+    this.queue.fg = this.metrics.fg = colors.dim;
+    this.editor.backgroundColor = this.editor.focusedBackgroundColor = colors.background;
+    this.editor.textColor = this.editor.focusedTextColor = colors.foreground;
+    this.editor.cursorColor = colors.accent;
+    this.editor.selectionBg = colors.selection;
+    this.tabs.backgroundColor = this.tabs.focusedBackgroundColor = colors.background;
+    this.tabs.textColor = colors.dim;
+    this.tabs.selectedTextColor = colors.foreground;
+    this.tabs.selectedBackgroundColor = colors.selection;
+    this.suggestions.backgroundColor = this.suggestions.focusedBackgroundColor = colors.background;
+    this.suggestions.textColor = colors.dim;
+    this.suggestions.selectedTextColor = colors.foreground;
+    this.suggestions.selectedBackgroundColor = colors.selection;
+    this.content.applyTheme();
+    this.tasks.applyTheme();
+    this.modals?.applyTheme();
+  }
+  get offset() {
+    return Math.max(0, this.scroll.scrollHeight - this.scroll.viewport.height - this.scroll.scrollTop);
+  }
+  getRenderable(id) {
+    const visit = (node) => {
+      if (node.id === id) return node;
+      for (const child of node.getChildren()) {
+        const found = visit(child);
+        if (found) return found;
+      }
+      return void 0;
+    };
+    return visit(this.renderer.root);
+  }
+  onFrame = () => {
+    if (this.destroyed) return;
+    if (this.pendingScrollRestore) {
+      const restore = this.pendingScrollRestore;
+      this.pendingScrollRestore = void 0;
+      this.scroll.scrollTo(restore.live ? this.scroll.scrollHeight : restore.top);
+      this.renderer.requestRender();
+    }
+    const height = Math.max(1, Math.min(8, this.editor.editorView.getTotalVirtualLineCount(), this.renderer.terminalHeight - 8));
+    if (height !== this.editor.height) this.editor.height = height;
+    const offset = this.offset;
+    if (offset === 0) this.newEntries = 0;
+    this.liveButton.visible = offset > 0;
+    const liveLabel = offset > 0 ? `↓ Live${this.newEntries ? ` · ${this.newEntries} new` : ""}` : "↓ Live";
+    if (this.liveButton.plainText !== liveLabel) this.liveButton.content = liveLabel;
+    const event = { type: "viewport", offset: this.scroll.scrollTop, height: this.scroll.viewport.height, width: this.scroll.viewport.width, total: this.scroll.scrollHeight };
+    const signature = JSON.stringify(event);
+    if (signature !== this.viewportSignature) {
+      this.viewportSignature = signature;
+      this.emit(event);
+    }
+  };
+  onResize = () => {
+    this.emit({ type: "resize", columns: this.renderer.terminalWidth, rows: this.renderer.terminalHeight });
+  };
+  editorChanged() {
+    if (!this.editor || this.changing || this.destroyed || this.inputEventPending) return;
+    this.inputEventPending = true;
+    queueMicrotask(() => {
+      this.inputEventPending = false;
+      if (this.destroyed) return;
+      this.flushLatestInput();
+      const height = Math.max(1, Math.min(8, this.editor.editorView.getTotalVirtualLineCount(), this.renderer.terminalHeight - 8));
+      if (height !== this.editor.height) this.editor.height = height;
+    });
+  }
+  flushLatestInput() {
+    const text = this.editor.plainText;
+    const cursor = this.editor.cursorOffset;
+    if (text === this.lastInput && cursor === this.lastCursor) return;
+    this.lastInput = text;
+    this.lastCursor = cursor;
+    this.emit({ type: "input", text, cursor });
+  }
+  submit() {
+    if (this.paused || this.state?.input.enabled === false) return;
+    if (this.suggestions.visible && this.editor.plainText.startsWith("/") && this.acceptSuggestion()) return;
+    const text = this.editor.plainText;
+    if (text.trim() && this.history[0] !== text) {
+      this.history.unshift(text);
+      this.history.length = Math.min(this.history.length, 1e3);
+    }
+    this.historyIndex = -1;
+    this.savedInput = "";
+    this.editor.clear();
+    this.emit({ type: "submit", text });
+    this.editorChanged();
+  }
+  navigateHistory(direction) {
+    if (this.history.length === 0) return;
+    if (direction < 0) {
+      if (this.historyIndex < 0) this.savedInput = this.editor.plainText;
+      this.historyIndex = Math.min(this.history.length - 1, this.historyIndex + 1);
+    } else this.historyIndex = Math.max(-1, this.historyIndex - 1);
+    this.setInput(this.historyIndex < 0 ? this.savedInput : this.history[this.historyIndex]);
+  }
+  acceptSuggestion() {
+    const selected = this.suggestions.getSelectedOption();
+    if (!selected || selected.value === this.editor.plainText.trimEnd()) return false;
+    const text = String(selected.value);
+    this.setInput(text + (text.endsWith(" ") ? "" : " "));
+    this.suggestions.visible = false;
+    this.emit({ type: "action", action: "completion", id: text });
+    return true;
+  }
+  setInput(text, cursor = text.length) {
+    this.editor.replaceText(text);
+    this.editor.cursorOffset = Math.max(0, Math.min(text.length, cursor));
+    this.editorInitialized = true;
+    this.editorChanged();
+  }
+  shortcut(name, key) {
+    this.flushLatestInput();
+    this.emit({ type: "shortcut", name });
+    key.preventDefault();
+    key.stopPropagation();
+  }
+  onKey = (key) => {
+    if (this.modals.active) {
+      this.modals.active.handleKey(key);
+      return;
+    }
+    if (key.eventType === "release") return;
+    if (key.ctrl && key.name.toLowerCase() === "n") {
+      this.shortcut("ctrl-n", key);
+      return;
+    }
+    if (this.renderer.currentFocusedRenderable instanceof EmbeddedTerminalRenderable2) return;
+    const headerButtons = (this.state?.header.actions ?? []).filter((action) => !action.disabled).map((action) => this.getRenderable(`header:${action.id}`)).filter((button) => Boolean(button));
+    const headerIndex = headerButtons.indexOf(this.renderer.currentFocusedRenderable);
+    if (headerIndex >= 0) {
+      const direction = key.name === "left" || key.name === "tab" && key.shift ? -1 : key.name === "right" || key.name === "tab" ? 1 : 0;
+      if (direction || key.name === "home" || key.name === "end") {
+        const index = key.name === "home" ? 0 : key.name === "end" ? headerButtons.length - 1 : (headerIndex + direction + headerButtons.length) % headerButtons.length;
+        const button = headerButtons[index];
+        button.focus();
+        this.headerActions.scrollChildIntoView(button.id);
+        key.preventDefault();
+        key.stopPropagation();
+        return;
+      }
+      if (key.name === "escape") {
+        this.restoreFocus();
+        key.preventDefault();
+        key.stopPropagation();
+        return;
+      }
+      if (key.name === "return") return;
+    }
+    if (key.ctrl && key.shift && key.name.toLowerCase() === "c") {
+      void this.copy();
+      key.preventDefault();
+      return;
+    }
+    if (key.ctrl && key.shift && key.name.toLowerCase() === "v") {
+      void this.paste();
+      key.preventDefault();
+      return;
+    }
+    if (key.ctrl && key.shift && key.name.toLowerCase() === "b") {
+      this.selectionArmed = true;
+      this.scroll.focus();
+      this.shortcut("ctrl-shift-b", key);
+      return;
+    }
+    if (key.ctrl && key.name === "c") {
+      this.shortcut("SIGINT", key);
+      return;
+    }
+    if (key.ctrl && key.name === "d" && !this.editor.plainText) {
+      this.shortcut("close", key);
+      return;
+    }
+    const control = { o: "ctrl-o", l: "ctrl-l", v: "ctrl-v", "\\": "ctrl-backslash", i: "ctrl-i" };
+    if (key.ctrl && control[key.name]) {
+      this.shortcut(control[key.name], key);
+      return;
+    }
+    if (key.ctrl && key.name === "u" && !this.editor.plainText) {
+      this.shortcut("ctrl-u", key);
+      return;
+    }
+    if (key.name === "escape") {
+      if (this.suggestions.visible) this.suggestions.visible = false;
+      this.shortcut("escape", key);
+      return;
+    }
+    if (key.name === "tab") {
+      if (key.ctrl) this.shortcut("ctrl-tab", key);
+      else if (this.suggestions.visible) {
+        this.acceptSuggestion();
+        key.preventDefault();
+      } else this.shortcut("tab", key);
+      return;
+    }
+    if (key.ctrl && (key.name === "left" || key.name === "right")) {
+      this.shortcut(`ctrl-${key.name}`, key);
+      return;
+    }
+    if (!this.editor.plainText && (key.name === "left" || key.name === "right")) {
+      this.shortcut(`${key.name}-empty`, key);
+      return;
+    }
+    if (key.name === "pageup" || key.name === "pagedown") {
+      this.scroll.scrollBy(key.name === "pageup" ? -1 : 1, "viewport");
+      key.preventDefault();
+      return;
+    }
+    if ((key.name === "up" || key.name === "down") && key.shift) {
+      this.scroll.scrollBy(key.name === "up" ? -3 : 3, "absolute");
+      key.preventDefault();
+      return;
+    }
+    if (key.name === "end" && !this.editor.plainText) {
+      this.scrollToLive();
+      key.preventDefault();
+      return;
+    }
+    if (key.name === "up" || key.name === "down") {
+      if (this.suggestions.visible) {
+        if (key.name === "up") this.suggestions.moveUp();
+        else this.suggestions.moveDown();
+        key.preventDefault();
+        return;
+      }
+      if (this.renderer.currentFocusedRenderable === this.scroll || this.offset > 0 || this.state?.activity?.processing && !this.editor.plainText) {
+        this.scroll.scrollBy(key.name === "up" ? -1 : 1, "absolute");
+        key.preventDefault();
+        return;
+      }
+      const cursor = this.editor.visualCursor;
+      const absoluteVisualRow = cursor.visualRow + this.editor.scrollY;
+      if (key.name === "up" && absoluteVisualRow === 0 || key.name === "down" && absoluteVisualRow >= this.editor.editorView.getTotalVirtualLineCount() - 1) {
+        this.navigateHistory(key.name === "up" ? -1 : 1);
+        key.preventDefault();
+        return;
+      }
+    }
+    if (this.paused || this.state?.input.enabled === false) {
+      if (this.renderer.currentFocusedRenderable === this.editor) key.preventDefault();
+      return;
+    }
+  };
+  onPaste = (event) => {
+    if (this.modals.active) {
+      this.modals.active.handlePaste(event);
+      return;
+    }
+    if (this.paused || this.state?.input.enabled === false) event.preventDefault();
+  };
+  scrollToLive() {
+    this.scroll.scrollTo(this.scroll.scrollHeight);
+    this.newEntries = 0;
+    this.editor.focus();
+  }
+  restoreFocus() {
+    if (this.modals.active) this.modals.active.focus();
+    else if (!this.paused && this.state?.input.enabled !== false) this.editor.focus();
+  }
+  async copy(text) {
+    const value = text ?? this.renderer.getSelection()?.getSelectedText() ?? this.editor.getSelectedText();
+    if (value) await this.clipboard.writeText(value, { destination: "best-available" });
+  }
+  async paste() {
+    const result = await this.clipboard.read({ preferredTypes: ["text/plain;charset=utf-8", "text/plain"] });
+    if (result.status === "read") this.editor.insertText(new TextDecoder().decode(result.representation.bytes));
+  }
+  command(command2) {
+    switch (command2.type) {
+      case "resize":
+        this.renderer.resize(command2.columns, command2.rows);
+        break;
+      case "scroll":
+        if (command2.position === "bottom") this.scrollToLive();
+        else if (command2.position === "top") this.scroll.scrollTo(0);
+        else this.scroll.scrollBy(command2.delta ?? 0, "absolute");
+        break;
+      case "focus": {
+        const target = command2.target === "input" ? this.editor : command2.target === "content" ? this.scroll : command2.target === "header" ? this.getRenderable(`header:${this.state?.header.actions.find((action) => !action.disabled)?.id}`) : this.context.terminals.get(command2.target) ?? this.getRenderable(command2.target);
+        target?.focus();
+        if (target?.id.startsWith("header:")) this.headerActions.scrollChildIntoView(target.id);
+        break;
+      }
+      case "input":
+        if (command2.expectedText !== void 0 && command2.expectedText !== this.editor.plainText || command2.expectedCursor !== void 0 && command2.expectedCursor !== this.editor.cursorOffset) {
+          this.flushLatestInput();
+        } else this.setInput(command2.text, command2.cursor);
+        break;
+      case "input-action":
+        this.inputAction(command2.action, command2.value);
+        break;
+      case "mouse":
+        this.renderer.useMouse = command2.enabled;
+        break;
+      case "copy":
+        void this.copy(command2.text);
+        break;
+      case "title":
+        this.renderer.setTerminalTitle(command2.text);
+        break;
+      case "modal-open":
+        this.modals.open(command2.modal);
+        break;
+      case "modal-update":
+        this.modals.update(command2.id, command2.patch);
+        break;
+      case "modal-close":
+        this.modals.close(command2.id, command2.result);
+        break;
+      case "embedded-write":
+        this.context.terminals.get(command2.id)?.write(Buffer.from(command2.data, "base64"));
+        break;
+      case "embedded-open":
+        this.openEmbedded(command2.id, command2.title);
+        break;
+      case "embedded-close":
+        this.closeEmbedded(command2.id);
+        break;
+    }
+    this.renderer.requestRender();
+  }
+  inputAction(action, value) {
+    if (action === "pause") {
+      this.paused = true;
+      this.editor.focusable = false;
+    } else if (action === "resume") {
+      this.paused = false;
+      this.editor.focusable = this.state?.input.enabled !== false;
+      this.restoreFocus();
+    } else if (action === "history-up") this.navigateHistory(-1);
+    else if (action === "history-down") this.navigateHistory(1);
+    else if (action === "history-set") {
+      try {
+        const entries = JSON.parse(value ?? "[]");
+        if (Array.isArray(entries)) this.history = entries.filter((entry) => typeof entry === "string").slice(0, 1e3);
+      } catch {
+      }
+    } else if (action === "insert") this.editor.insertText(value ?? "");
+    else if (action === "clear") this.editor.clear();
+    else if (action === "submit") this.submit();
+    else if (action === "complete") this.acceptSuggestion();
+    else if (action === "focus") this.restoreFocus();
+    else if (action === "select-block") {
+      this.selectionArmed = true;
+      this.scroll.focus();
+    } else if (action === "close") this.paused = true;
+  }
+  openEmbedded(id, title) {
+    if (this.embeddedId && this.embeddedId !== id) this.closeEmbedded(this.embeddedId);
+    this.embeddedId = id;
+    this.embeddedPane.title = title;
+    this.embeddedPane.visible = true;
+    let terminal = this.context.terminals.get(id);
+    if (!terminal) {
+      terminal = new EmbeddedTerminalRenderable2(this.renderer, {
+        id: `embedded:${id}`,
+        width: "100%",
+        height: "100%",
+        flexGrow: 1,
+        maxScrollback: 1e4,
+        transparentBackground: true,
+        selectable: true,
+        onData: (data) => this.emit({ type: "embedded-data", id, data: Buffer.from(data).toString("base64") }),
+        onTerminalResize: (columns, rows) => this.emit({ type: "embedded-resize", id, columns, rows })
+      });
+      this.context.terminals.set(id, terminal);
+      this.embeddedPane.add(terminal);
+    }
+    terminal.focus();
+  }
+  closeEmbedded(id) {
+    this.context.terminals.get(id)?.destroy();
+    this.context.terminals.delete(id);
+    if (this.embeddedId === id) {
+      this.embeddedId = void 0;
+      this.embeddedPane.visible = false;
+      this.restoreFocus();
+    }
+  }
+  async dispose() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    if (this.animation) clearInterval(this.animation);
+    this.renderer.keyInput.off("keypress", this.onKey);
+    this.renderer.keyInput.off("paste", this.onPaste);
+    this.renderer.off(CliRenderEvents.FRAME, this.onFrame);
+    this.renderer.off(CliRenderEvents.RESIZE, this.onResize);
+    this.modals.destroy();
+    this.content.destroy();
+    this.tasks.destroy();
+    this.root.destroyRecursively();
+    this.context.syntax.destroy();
+    await this.clipboard.dispose();
+  }
+};
+
+// packages/cli/src/tui/native/worker.ts
+var replies = createWriteStream("", { fd: 3, autoClose: false });
+var reply = (message) => replies.write(JSON.stringify(message) + "\n");
+var terminalInput = new PassThrough();
+var renderer;
+var frontend;
+var stopping = false;
+var failed = false;
+async function close() {
+  if (stopping) return;
+  stopping = true;
+  await frontend?.dispose();
+  if (renderer) {
+    renderer.destroy();
+    await renderer.closed;
+  }
+}
+async function fail(error) {
+  if (failed || stopping) return;
+  failed = true;
+  reply({ type: "error", message: error instanceof Error ? error.message : String(error) });
+  await close().catch(() => {
+  });
+  replies.end(() => process.exit(1));
+}
+async function command(message) {
+  if (message.type === "command") {
+    frontend.command(message.command);
+    return;
+  }
+  if (message.type === "state") {
+    frontend.update(message.snapshot, message.content);
+    renderer.requestRender();
+    await renderer.idle();
+  } else if (message.type === "suspend") await renderer.suspend();
+  else if (message.type === "resume") {
+    await renderer.resume();
+    renderer.requestRender();
+    await renderer.idle();
+  } else if (message.type === "stop") await close();
+  reply({ type: "ack", id: message.id });
+  if (message.type === "stop") replies.end(() => process.exit(0));
+}
+try {
+  renderer = await createCliRenderer({
+    nativeSession: new NativeSession(process.stdout),
+    stdin: terminalInput,
+    stdout: process.stdout,
+    exitOnCtrlC: false,
+    exitSignals: [],
+    useMouse: true,
+    enableMouseMovement: true,
+    useKittyKeyboard: { disambiguate: true, alternateKeys: true, events: true },
+    screenMode: "alternate-screen",
+    consoleMode: "disabled",
+    externalOutputMode: "passthrough",
+    backgroundColor: RGBA2.defaultBackground(),
+    openConsoleOnError: false,
+    targetFps: 60,
+    maxFps: 60,
+    clearOnShutdown: false
+  });
+  renderer.on(CliRenderEvents2.RENDER_ERROR, (event) => {
+    void fail(event.error);
+  });
+  renderer.on(CliRenderEvents2.HANDLER_ERROR, (event) => {
+    void fail(event.error);
+  });
+  renderer.on("error", (event) => {
+    void fail(event);
+  });
+  frontend = new NativeFrontend(renderer, (event) => reply({ type: "event", event }));
+  const controls = createInterface({ input: process.stdin, crlfDelay: Infinity });
+  let pending = Promise.resolve();
+  controls.on("line", (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch (error) {
+      void fail(error);
+      return;
+    }
+    if (message.type === "input-bytes") {
+      terminalInput.write(Buffer.from(message.data, "base64"));
+    } else if (message.type === "command") {
+      try {
+        frontend.command(message.command);
+      } catch (error) {
+        void fail(error);
+      }
+    } else pending = pending.then(() => command(message)).catch(fail);
+  });
+  controls.on("close", () => {
+    void pending.then(close).finally(() => process.exit(0));
+  });
+  process.on("SIGTERM", () => {
+    void close().finally(() => process.exit(0));
+  });
+  process.on("SIGINT", () => {
+  });
+  renderer.requestRender();
+  await renderer.idle();
+  reply({ type: "ready" });
+} catch (error) {
+  await fail(error);
+}