@h-rig/cli 0.0.6-alpha.8 → 0.0.6-alpha.81

package/dist/src/app-opentui/runtime.js

@@ -0,0 +1,3406 @@
+// @bun
+// packages/cli/src/app-opentui/runtime.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { createCliRenderer } from "@opentui/core";
+
+// packages/cli/src/app-opentui/events.ts
+function createAppEventBus() {
+  const listeners = new Set;
+  return {
+    emit(event) {
+      for (const listener of [...listeners])
+        listener(event);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function normalizeError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const rawHint = error instanceof Error ? error.hint : undefined;
+  return {
+    message: message || "Unknown Rig app error",
+    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {},
+    cause: error
+  };
+}
+
+// packages/cli/src/app-opentui/intent.ts
+var NAV_SCENES = new Map([
+  ["", "fleet"],
+  ["main", "fleet"],
+  ["home", "fleet"],
+  ["fleet", "fleet"],
+  ["runs", "fleet"],
+  ["run", "fleet"],
+  ["tasks", "tasks"],
+  ["task", "tasks"],
+  ["help", "help"]
+]);
+var TASK_VIEW_COMMANDS = new Set([
+  "",
+  "all",
+  "open",
+  "ready",
+  "blocked",
+  "closed",
+  "done",
+  "mine",
+  "me",
+  "sort",
+  "status",
+  "state",
+  "assignee",
+  "assigned",
+  "label",
+  "search",
+  "q"
+]);
+function isTaskViewCommand(command) {
+  return !command || TASK_VIEW_COMMANDS.has(command) || command.startsWith("-");
+}
+function intent(scene, argv, kind, payload, label, raw) {
+  return {
+    scene,
+    argv,
+    ...raw ? { raw } : {},
+    action: {
+      kind,
+      ...label ? { label } : {},
+      ...payload ? { payload } : {}
+    }
+  };
+}
+function unsupportedPlainCliIntent(argv, raw) {
+  const command = argv.join(" ").trim() || "command";
+  return intent("help", argv, "none", { unsupported: command }, `${command} is on the plain CLI path; exit Rig shell or rerun with RIG_PLAIN=1`, raw);
+}
+function firstValueAfter(args, option) {
+  const index = args.indexOf(option);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+function firstNonOption(args) {
+  return args.find((part) => part.trim() && !part.startsWith("-"));
+}
+function explicitTaskIdArg(args) {
+  const taskValue = firstValueAfter(args, "--task");
+  if (taskValue && !taskValue.startsWith("-"))
+    return taskValue;
+  return args.find((part) => part.trim() && part !== "next" && part !== "--next" && part !== "--task" && !part.startsWith("-"));
+}
+function taskViewPayload(command, rest) {
+  const normalized = command.toLowerCase();
+  const args = command ? [command, ...rest] : rest;
+  const sort = firstValueAfter(args, "--sort") ?? firstValueAfter(args, "-s");
+  const state = firstValueAfter(args, "--state");
+  const status = firstValueAfter(args, "--status");
+  const assignee = firstValueAfter(args, "--assignee") ?? firstValueAfter(args, "--assigned");
+  const label = firstValueAfter(args, "--label");
+  const search = firstValueAfter(args, "--search") ?? firstValueAfter(args, "-q");
+  const optionPayload = {
+    ...sort ? { taskSort: sort } : {},
+    ...state ? { taskState: state, taskFilterPreset: "custom" } : {},
+    ...status ? { taskStatus: status, taskFilterPreset: "custom" } : {},
+    ...assignee ? { taskAssignee: assignee, taskFilterPreset: "custom" } : {},
+    ...label ? { taskLabel: label, taskFilterPreset: "custom" } : {},
+    ...search ? { taskSearch: search, taskFilterPreset: "custom" } : {}
+  };
+  if (normalized === "sort") {
+    const value = firstNonOption(rest) ?? sort ?? "priority";
+    return { payload: { ...optionPayload, taskSort: value }, label: `Sorting tasks by ${value}` };
+  }
+  if (normalized === "status") {
+    const value = firstNonOption(rest) ?? status ?? "open";
+    return { payload: { ...optionPayload, taskStatus: value, taskFilterPreset: "custom" }, label: `Filtering tasks by status ${value}` };
+  }
+  if (normalized === "state") {
+    const value = firstNonOption(rest) ?? state ?? "open";
+    return { payload: { ...optionPayload, taskState: value, taskFilterPreset: "custom" }, label: `Filtering tasks by state ${value}` };
+  }
+  if (normalized === "assignee" || normalized === "assigned" || normalized === "mine" || normalized === "me") {
+    const value = normalized === "mine" || normalized === "me" ? "me" : firstNonOption(rest) ?? assignee ?? "me";
+    return { payload: { ...optionPayload, taskAssignee: value, taskState: "open", taskFilterPreset: value === "me" ? "mine" : "custom" }, label: value === "me" ? "Filtering my tasks" : `Filtering tasks for ${value}` };
+  }
+  if (normalized === "label") {
+    const value = firstNonOption(rest) ?? label;
+    return { payload: { ...optionPayload, ...value ? { taskLabel: value } : {}, taskFilterPreset: "custom" }, label: value ? `Filtering tasks labeled ${value}` : "Filtering tasks by label" };
+  }
+  if (normalized === "search" || normalized === "q") {
+    const value = rest.join(" ").trim() || search;
+    return { payload: { ...optionPayload, ...value ? { taskSearch: value } : {}, taskFilterPreset: "custom" }, label: value ? `Searching tasks for ${value}` : "Searching tasks" };
+  }
+  if (["all", "open", "ready", "blocked", "closed", "done"].includes(normalized)) {
+    return { payload: { ...optionPayload, taskFilterPreset: normalized === "done" ? "closed" : normalized }, label: `Filtering tasks: ${normalized}` };
+  }
+  if (Object.keys(optionPayload).length > 0)
+    return { payload: optionPayload, label: "Filtering tasks" };
+  return { label: "Loading tasks" };
+}
+function taskViewIntent(argv, command = "", rest = [], raw) {
+  const { payload, label } = taskViewPayload(command, rest);
+  return intent("tasks", argv, "refresh", payload, label, raw);
+}
+function intentFromArgv(argv) {
+  const [group = "", command = "", ...rest] = argv;
+  const normalizedGroup = group.toLowerCase();
+  const normalizedCommand = command.toLowerCase();
+  if (!normalizedGroup)
+    return intent("fleet", argv, "refresh", undefined, "Opening runs");
+  if (normalizedGroup === "--help" || normalizedGroup === "-h" || normalizedGroup === "help") {
+    return argv.length === 1 ? intent("help", argv, "none", undefined, "Help") : unsupportedPlainCliIntent(argv);
+  }
+  if (normalizedGroup === "task") {
+    if (normalizedCommand === "run") {
+      if (rest.includes("--next") || rest.includes("next")) {
+        return intent("tasks", argv, "task-run-next", undefined, "Dispatching next task");
+      }
+      const task = explicitTaskIdArg(rest);
+      if (task)
+        return intent("tasks", argv, "task-run-id", { task }, `Dispatching ${task}`);
+      return intent("tasks", argv, "refresh", undefined, "Select a task, then press Enter; or use run next");
+    }
+    if (!isTaskViewCommand(normalizedCommand))
+      return unsupportedPlainCliIntent(argv);
+    return taskViewIntent(argv, normalizedCommand, rest);
+  }
+  if (normalizedGroup === "tasks") {
+    if (!isTaskViewCommand(normalizedCommand))
+      return unsupportedPlainCliIntent(argv);
+    return taskViewIntent(argv, normalizedCommand, rest);
+  }
+  if (normalizedGroup === "run") {
+    if (normalizedCommand === "attach") {
+      const runId = firstNonOption(rest);
+      return intent("handoff", argv, "run-attach", { runId }, runId ? `Attaching ${runId}` : "Attaching run");
+    }
+    if (!normalizedCommand)
+      return intent("fleet", argv, "refresh", undefined, "Loading fleet");
+    return unsupportedPlainCliIntent(argv);
+  }
+  if (normalizedGroup === "attach") {
+    const runId = firstNonOption([command, ...rest]);
+    return intent("handoff", argv, "run-attach", { runId }, runId ? `Attaching ${runId}` : "Attaching run");
+  }
+  const nav = NAV_SCENES.get(normalizedGroup);
+  if (nav)
+    return intent(nav, argv, "navigate", undefined, `Opening ${nav}`);
+  return unsupportedPlainCliIntent(argv);
+}
+function intentFromTypeBar(value) {
+  const raw = value.trim();
+  if (!raw)
+    return intent("fleet", [], "refresh", undefined, "Opening runs", value);
+  const parts = raw.split(/\s+/).filter(Boolean);
+  const [first = "", second = "", ...rest] = parts;
+  const firstScene = NAV_SCENES.get(first.toLowerCase());
+  if (first === "tasks" || first === "task") {
+    if (second === "run") {
+      const task = explicitTaskIdArg(rest);
+      if (rest.includes("--next") || task === "next")
+        return intent("tasks", parts, "task-run-next", undefined, "Dispatching next task", value);
+      if (task)
+        return intent("tasks", parts, "task-run-id", { task }, `Dispatching ${task}`, value);
+      return intent("tasks", parts, "refresh", undefined, "Select a task, then press Enter; or use run next", value);
+    }
+    if (!isTaskViewCommand(second.toLowerCase()))
+      return unsupportedPlainCliIntent(parts, value);
+    return taskViewIntent(parts, second, rest, value);
+  }
+  if (first === "run") {
+    if (second === "next" || second === "--next")
+      return intent("tasks", parts, "task-run-next", undefined, "Dispatching next task", value);
+    if (second === "--task") {
+      const task = explicitTaskIdArg([second, ...rest]);
+      if (task)
+        return intent("tasks", parts, "task-run-id", { task }, `Dispatching ${task}`, value);
+      return intent("tasks", parts, "refresh", undefined, "Select a task, then press Enter; or use run next", value);
+    }
+    if (second && !second.startsWith("-"))
+      return intent("tasks", parts, "task-run-id", { task: second }, `Dispatching ${second}`, value);
+    return intent("tasks", parts, "refresh", undefined, "Select a task, then press Enter; or use run next", value);
+  }
+  if (firstScene && parts.length === 1) {
+    return intent(firstScene, parts, "navigate", undefined, `Opening ${firstScene}`, value);
+  }
+  if (first === "stop")
+    return intent("fleet", parts, "run-stop", { runId: second || undefined }, second ? `Stopping ${second}` : "Stopping run", value);
+  if (first === "attach") {
+    if (!second)
+      return intent("handoff", parts, "navigate", undefined, "Select a run to attach", value);
+    return intent("handoff", parts, "run-attach", { runId: second }, `Attaching ${second}`, value);
+  }
+  return intentFromArgv(parts);
+}
+
+// packages/cli/src/app-opentui/layout.ts
+function computeStageLayout(width, height) {
+  const safeWidth = Math.max(40, Math.trunc(width || 80));
+  const safeHeight = Math.max(18, Math.trunc(height || 24));
+  const compact = safeWidth < 92 || safeHeight < 30;
+  const horizontalGutter = compact ? 1 : 2;
+  const centerWidth = Math.max(36, safeWidth - horizontalGutter * 2);
+  const centerLeft = horizontalGutter;
+  const typeBarTop = Math.max(0, safeHeight - 3);
+  const footerTop = Math.max(0, safeHeight - 1);
+  const centerTop = compact ? 1 : Math.max(1, Math.floor(safeHeight * 0.055));
+  const centerHeight = Math.max(8, typeBarTop - centerTop - 1);
+  return { width: safeWidth, height: safeHeight, centerWidth, centerLeft, centerTop, centerHeight, typeBarTop, footerTop, compact };
+}
+function visibleWidth(text) {
+  return [...text].length;
+}
+function alignText(text, width, align = "left") {
+  const length = visibleWidth(text);
+  if (length >= width)
+    return text;
+  const pad = width - length;
+  if (align === "right")
+    return `${" ".repeat(pad)}${text}`;
+  if (align === "center") {
+    const left = Math.floor(pad / 2);
+    return `${" ".repeat(left)}${text}${" ".repeat(pad - left)}`;
+  }
+  return text;
+}
+function truncateText(text, width) {
+  if (visibleWidth(text) <= width)
+    return text;
+  if (width <= 1)
+    return "\u2026";
+  return `${[...text].slice(0, Math.max(0, width - 1)).join("")}\u2026`;
+}
+
+// packages/cli/src/app-opentui/list-search.ts
+function isListSearchScene(scene) {
+  return scene === "fleet" || scene === "tasks";
+}
+function listSearchQuery(state) {
+  return isListSearchScene(state.scene) ? state.typeBar.value.trim() : "";
+}
+function valueText(value) {
+  if (value === undefined || value === null)
+    return "";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (Array.isArray(value))
+    return value.map(valueText).join(" ");
+  if (typeof value === "object") {
+    const record = value;
+    return ["id", "runId", "taskId", "number", "title", "name", "summary", "status", "state", "label", "labels", "assignee", "assignees", "url"].map((key) => valueText(record[key])).join(" ");
+  }
+  return "";
+}
+function includesQuery(haystack, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle)
+    return true;
+  return haystack.map(valueText).join(" ").toLowerCase().includes(needle);
+}
+function filterRunsForSearch(runs, query) {
+  return query.trim() ? runs.filter((run) => includesQuery([run.runId, run.status, run.title, run.taskId, run.raw], query)) : [...runs];
+}
+function filterTasksForSearch(tasks, query) {
+  return query.trim() ? tasks.filter((task) => includesQuery([task.id, task.status, task.title, task.priority, task.labels, task.assignees, task.raw], query)) : [...tasks];
+}
+
+// packages/cli/src/app-opentui/state.ts
+function mergePatch(state, patch) {
+  return {
+    ...state,
+    ...patch,
+    typeBar: patch.typeBar ? { ...state.typeBar, ...patch.typeBar } : state.typeBar,
+    footer: patch.footer ? { ...state.footer, ...patch.footer } : state.footer,
+    selection: patch.selection ? { ...state.selection, ...patch.selection } : state.selection,
+    data: patch.data ? { ...state.data, ...patch.data } : state.data
+  };
+}
+function createInitialAppState(options) {
+  const initialIntent = intentFromArgv(options.argv);
+  const projectName = options.projectRoot.split(/[\\/]/).filter(Boolean).at(-1) ?? options.projectRoot;
+  return {
+    projectRoot: options.projectRoot,
+    scene: initialIntent.scene,
+    status: initialIntent.action.kind === "none" || initialIntent.action.kind === "navigate" ? "idle" : "loading",
+    tick: 0,
+    argv: options.argv,
+    intent: initialIntent,
+    typeBar: {
+      value: "",
+      placeholder: "runs \xB7 tasks \xB7 help \xB7 attach <run>"
+    },
+    footer: {
+      project: projectName,
+      ...options.initialFooter ?? {}
+    },
+    selection: { index: 0, count: 0 },
+    data: {
+      projectConfigured: options.projectConfigured ?? false
+    },
+    runtimeReady: false,
+    actionLabel: initialIntent.action.label
+  };
+}
+function createAppStore(initialState) {
+  let state = initialState;
+  const listeners = new Set;
+  const notify = () => {
+    for (const listener of [...listeners])
+      listener(state);
+  };
+  return {
+    getState() {
+      return state;
+    },
+    setState(next) {
+      state = next;
+      notify();
+    },
+    patch(patch) {
+      state = mergePatch(state, patch);
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function reduceAppEvent(state, event) {
+  switch (event.type) {
+    case "scene.change":
+      return {
+        scene: event.scene,
+        ...event.intent ? { intent: event.intent, actionLabel: event.intent.action.label } : {},
+        status: "idle",
+        error: undefined,
+        typeBar: { message: undefined }
+      };
+    case "action.started":
+      return {
+        status: "action",
+        actionLabel: event.label,
+        error: undefined,
+        data: event.optimistic ?? {},
+        typeBar: { message: event.label }
+      };
+    case "action.progress":
+      return {
+        status: "action",
+        actionLabel: event.label,
+        data: event.data ?? {},
+        typeBar: { message: event.detail ?? event.label }
+      };
+    case "action.completed":
+      return {
+        status: "success",
+        actionLabel: event.label,
+        data: event.data ?? {},
+        typeBar: { message: `${event.label} complete` }
+      };
+    case "action.failed":
+      return {
+        status: "error",
+        actionLabel: event.label,
+        error: { message: event.message, hint: event.hint, cause: event.cause },
+        typeBar: { message: event.message, placeholder: event.hint ?? "runs \xB7 tasks \xB7 help" }
+      };
+    case "data.patch":
+      return { data: event.data };
+    case "footer.patch":
+      return { footer: event.footer };
+    case "typebar.patch":
+      return { typeBar: event.typeBar };
+    case "runtime.ready":
+      return { runtimeReady: true, footer: { message: "runtime ready" } };
+    case "runtime.failed":
+      return {
+        scene: "error",
+        status: "error",
+        runtimeReady: false,
+        error: { message: event.message, hint: event.hint, cause: event.cause }
+      };
+  }
+}
+
+// packages/cli/src/app-opentui/theme.ts
+import {
+  bold as otuiBold,
+  dim as otuiDim,
+  fg as otuiFg,
+  t,
+  TextAttributes
+} from "@opentui/core";
+var RIG_UI = {
+  bg: "#070809",
+  bg2: "#0b0c0e",
+  panel: "#101115",
+  panel2: "#101115",
+  glass: "#14161b",
+  ink: "#f2f3f6",
+  ink2: "#aeb0ba",
+  ink3: "#6c6e79",
+  ink4: "#44464f",
+  lime: "#ccff4d",
+  limeDim: "#a9d63f",
+  cyan: "#56d8ff",
+  red: "#ff5d5d",
+  yellow: "#ffd24d",
+  magenta: "#ff79b0"
+};
+var styles = {
+  ink: otuiFg(RIG_UI.ink),
+  ink2: otuiFg(RIG_UI.ink2),
+  ink3: otuiFg(RIG_UI.ink3),
+  ink4: otuiFg(RIG_UI.ink4),
+  lime: otuiFg(RIG_UI.lime),
+  limeDim: otuiFg(RIG_UI.limeDim),
+  cyan: otuiFg(RIG_UI.cyan),
+  red: otuiFg(RIG_UI.red),
+  yellow: otuiFg(RIG_UI.yellow),
+  magenta: otuiFg(RIG_UI.magenta)
+};
+
+// packages/cli/src/app-opentui/render/graphics.ts
+import { FrameBufferRenderable, RGBA } from "@opentui/core";
+var TRANSPARENT = RGBA.fromValues(0, 0, 0, 0);
+var BACKDROP = RGBA.fromHex(RIG_UI.bg);
+var PANEL_BG = RGBA.fromInts(16, 17, 21, 184);
+var PANEL_HEADER_BG = RGBA.fromInts(16, 17, 21, 188);
+var PANEL_LINE = RGBA.fromInts(255, 255, 255, 20);
+var PANEL_LINE_DIM = RGBA.fromInts(255, 255, 255, 8);
+var PANEL_TEXT_DIM = RGBA.fromInts(108, 110, 121, 255);
+var AC_RGB = [204, 255, 77];
+var C2_RGB = [86, 216, 255];
+var MG_RGB = [255, 121, 176];
+var INK_RGB = [108, 110, 121];
+var BRAILLE_BITS = [
+  [1, 8],
+  [2, 16],
+  [4, 32],
+  [64, 128]
+];
+function sceneKind(scene) {
+  if (scene === "tasks")
+    return "loop";
+  if (scene === "help")
+    return "carrier";
+  return "dispatch";
+}
+function seeded(seed) {
+  let value = seed >>> 0;
+  return () => {
+    value = value * 1664525 + 1013904223 >>> 0;
+    return value / 4294967295;
+  };
+}
+function channelBuffer(canvas, channel) {
+  switch (channel) {
+    case 0:
+      return canvas.ac;
+    case 1:
+      return canvas.c2;
+    case 2:
+      return canvas.mg;
+    case 3:
+      return canvas.ink;
+  }
+}
+function addSample(canvas, channel, x, y, value) {
+  const ix = Math.trunc(x);
+  const iy = Math.trunc(y);
+  if (ix < 0 || iy < 0 || ix >= canvas.width || iy >= canvas.height)
+    return;
+  const buffer = channelBuffer(canvas, channel);
+  const index = iy * canvas.width + ix;
+  buffer[index] = Math.min(1, buffer[index] + value);
+}
+function drawDot(canvas, channel, cx, cy, radius, value) {
+  const minX = Math.floor(cx - radius);
+  const maxX = Math.ceil(cx + radius);
+  const minY = Math.floor(cy - radius);
+  const maxY = Math.ceil(cy + radius);
+  for (let y = minY;y <= maxY; y += 1) {
+    for (let x = minX;x <= maxX; x += 1) {
+      const dx = x - cx;
+      const dy = y - cy;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      if (distance > radius)
+        continue;
+      const falloff = 1 - distance / Math.max(0.001, radius);
+      addSample(canvas, channel, x, y, value * (0.28 + falloff * 0.72));
+    }
+  }
+}
+function drawGlow(canvas, channel, cx, cy, radius, value) {
+  const minX = Math.floor(cx - radius);
+  const maxX = Math.ceil(cx + radius);
+  const minY = Math.floor(cy - radius);
+  const maxY = Math.ceil(cy + radius);
+  for (let y = minY;y <= maxY; y += 1) {
+    for (let x = minX;x <= maxX; x += 1) {
+      const dx = x - cx;
+      const dy = y - cy;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      if (distance > radius)
+        continue;
+      const falloff = Math.pow(1 - distance / Math.max(0.001, radius), 2.2);
+      addSample(canvas, channel, x, y, value * falloff);
+    }
+  }
+}
+function drawLine(canvas, channel, x0, y0, x1, y1, value, width = 0.8) {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const steps = Math.max(1, Math.ceil(Math.hypot(dx, dy) * 1.7));
+  for (let step = 0;step <= steps; step += 1) {
+    const t2 = step / steps;
+    const x = x0 + dx * t2;
+    const y = y0 + dy * t2;
+    drawDot(canvas, channel, x, y, width, value);
+  }
+}
+function drawCircleStroke(canvas, channel, cx, cy, radius, value) {
+  const steps = Math.max(18, Math.ceil(radius * 8));
+  for (let step = 0;step < steps; step += 1) {
+    const a = step / steps * Math.PI * 2;
+    drawDot(canvas, channel, cx + Math.cos(a) * radius, cy + Math.sin(a) * radius, 0.72, value);
+  }
+}
+function paletteColor(ac, c2, mg, ink) {
+  const total = Math.max(0.001, ac + c2 + mg + ink);
+  const r = (AC_RGB[0] * ac + C2_RGB[0] * c2 + MG_RGB[0] * mg + INK_RGB[0] * ink) / total;
+  const g = (AC_RGB[1] * ac + C2_RGB[1] * c2 + MG_RGB[1] * mg + INK_RGB[1] * ink) / total;
+  const b = (AC_RGB[2] * ac + C2_RGB[2] * c2 + MG_RGB[2] * mg + INK_RGB[2] * ink) / total;
+  const intensity = Math.min(1, total / 4);
+  const lift = 0.34 + intensity * 0.66;
+  return RGBA.fromInts(Math.round(r * lift), Math.round(g * lift), Math.round(b * lift), 255);
+}
+function clearCanvas(canvas) {
+  canvas.ac.fill(0);
+  canvas.c2.fill(0);
+  canvas.mg.fill(0);
+  canvas.ink.fill(0);
+}
+function makeCanvas(layout) {
+  const width = Math.max(1, layout.width * 2);
+  const height = Math.max(1, layout.height * 4);
+  const size = width * height;
+  return {
+    width,
+    height,
+    ac: new Float32Array(size),
+    c2: new Float32Array(size),
+    mg: new Float32Array(size),
+    ink: new Float32Array(size)
+  };
+}
+
+class MarketingGlyphCanvas {
+  rand = seeded(6221137);
+  canvas;
+  layout;
+  activeKind = null;
+  lanes = [];
+  motes = [];
+  packets = [];
+  constructor(layout) {
+    this.layout = layout;
+    this.canvas = makeCanvas(layout);
+    this.reset("dispatch");
+  }
+  resize(layout) {
+    if (layout.width === this.layout.width && layout.height === this.layout.height)
+      return;
+    this.layout = layout;
+    this.canvas = makeCanvas(layout);
+    this.reset(this.activeKind ?? "dispatch");
+  }
+  render(layer, scene, tick) {
+    const kind = sceneKind(scene);
+    if (kind !== this.activeKind)
+      this.reset(kind);
+    clearCanvas(this.canvas);
+    this.drawMarketingRails(kind, tick);
+    if (kind === "loop")
+      this.drawLoop(tick);
+    else if (kind === "carrier")
+      this.drawCarrier(tick);
+    else
+      this.drawDispatch(tick);
+    this.blit(layer);
+  }
+  reset(kind) {
+    this.activeKind = kind;
+    this.lanes = [];
+    this.motes = [];
+    this.packets = [];
+    if (kind === "dispatch")
+      this.setupDispatch();
+    else if (kind === "loop")
+      this.setupLoop();
+    else
+      this.setupCarrier();
+  }
+  setupDispatch() {
+    const count = this.layout.compact ? 7 : 12;
+    for (let i = 0;i < count; i += 1) {
+      const ang = (-0.9 + 1.8 * (i / Math.max(1, count - 1))) * (Math.PI * 0.5);
+      this.lanes.push({ ang, len: this.canvas.width * (0.32 + this.rand() * 0.42), curve: (this.rand() - 0.5) * 0.7, phase: this.rand() * Math.PI * 2 });
+    }
+    const packets = this.layout.compact ? 70 : 150;
+    for (let i = 0;i < packets; i += 1)
+      this.packets.push(this.packet(true));
+  }
+  setupLoop() {
+    const lanes = this.layout.compact ? 4 : 7;
+    for (let i = 0;i < lanes; i += 1)
+      this.packets.push(this.packet(true));
+  }
+  setupCarrier() {
+    const nodes = this.layout.compact ? 5 : 7;
+    for (let i = 0;i < nodes * 6; i += 1)
+      this.packets.push(this.packet(true));
+  }
+  packet(random = false) {
+    return {
+      lane: Math.floor(this.rand() * Math.max(1, this.lanes.length || 7)),
+      p: random ? this.rand() : 0,
+      spd: 0.003 + this.rand() * 0.009,
+      channel: this.rand() < 0.22 ? 1 : 0,
+      wobble: (this.rand() - 0.5) * 7,
+      size: 0.8 + this.rand() * 1.3
+    };
+  }
+  core(kind) {
+    if (kind === "dispatch")
+      return { x: this.canvas.width * 0.3, y: this.canvas.height * 0.45 };
+    if (kind === "carrier")
+      return { x: this.canvas.width * 0.5, y: this.canvas.height * 0.54 };
+    return { x: this.canvas.width * 0.09, y: this.canvas.height * 0.56 };
+  }
+  lanePoint(lane, p, kind = "dispatch") {
+    const core = this.core(kind);
+    const dist = lane.len * p;
+    const bend = Math.sin(p * Math.PI) * lane.curve * 28;
+    const ux = Math.cos(lane.ang);
+    const uy = Math.sin(lane.ang);
+    return { x: core.x + ux * dist + -uy * bend, y: core.y + uy * dist + ux * bend };
+  }
+  drawMotes(tick) {
+    for (const mote of this.motes) {
+      mote.x += 0.1 * mote.z;
+      if (mote.x > this.canvas.width + 2)
+        mote.x = -2;
+      const alpha = (0.035 + 0.08 * mote.z) * (0.55 + 0.45 * Math.sin(tick * 0.03 + mote.tw));
+      drawDot(this.canvas, mote.channel, mote.x, mote.y, 0.45 * mote.z, alpha);
+    }
+  }
+  drawMarketingRails(kind, tick) {
+    const ys = kind === "loop" ? [0.18, 0.5, 0.82] : kind === "carrier" ? [0.24, 0.54, 0.82] : [0.18, 0.58, 0.82];
+    ys.forEach((ratio, index) => {
+      const y = this.canvas.height * ratio + Math.sin(tick * 0.018 + index) * 1.8;
+      drawLine(this.canvas, index === 1 ? 0 : 1, this.canvas.width * 0.06, y, this.canvas.width * 0.94, y + Math.sin(index) * 2, index === 1 ? 0.11 : 0.07, 0.55);
+      for (let p = (tick * 0.004 + index * 0.21) % 1;p < 1; p += 0.18 + index * 0.02) {
+        const x = this.canvas.width * (0.06 + 0.88 * p);
+        drawDot(this.canvas, index === 2 ? 1 : 0, x, y, 1 + index * 0.25, 0.24);
+        drawGlow(this.canvas, index === 2 ? 1 : 0, x, y, 3.8, 0.035);
+      }
+    });
+  }
+  drawDispatch(tick) {
+    const core = this.core("dispatch");
+    drawGlow(this.canvas, 0, core.x, core.y, 30, 0.12);
+    drawDot(this.canvas, 0, core.x, core.y, 2.2, 0.85);
+    for (const lane of this.lanes) {
+      let prev = this.lanePoint(lane, 0);
+      for (let i = 1;i <= 32; i += 1) {
+        const next = this.lanePoint(lane, i / 32);
+        drawLine(this.canvas, lane.phase > Math.PI ? 1 : 0, prev.x, prev.y, next.x, next.y, 0.045, 0.38);
+        prev = next;
+      }
+    }
+    for (const packet of this.packets) {
+      packet.p += packet.spd;
+      if (packet.p > 1)
+        Object.assign(packet, this.packet(false));
+      const lane = this.lanes[packet.lane % Math.max(1, this.lanes.length)];
+      if (!lane)
+        continue;
+      const pt = this.lanePoint(lane, packet.p);
+      const fade = packet.p < 0.1 ? packet.p / 0.1 : packet.p > 0.88 ? (1 - packet.p) / 0.12 : 1;
+      const y = pt.y + packet.wobble * Math.sin(packet.p * Math.PI * 2);
+      drawLine(this.canvas, packet.channel, pt.x - 4, y - 1, pt.x, y, 0.08 * fade, 0.38);
+      drawDot(this.canvas, packet.channel, pt.x, y, packet.size, 0.5 * fade);
+      drawGlow(this.canvas, packet.channel, pt.x, y, packet.size * 4, 0.045 * fade);
+    }
+    for (let i = 0;i < (this.layout.compact ? 4 : 8); i += 1) {
+      const lane = this.lanes[i % Math.max(1, this.lanes.length)];
+      if (!lane)
+        continue;
+      const p = (tick * 0.002 + i * 0.13) % 1;
+      const pt = this.lanePoint(lane, p);
+      this.drawDrone(pt.x, pt.y + Math.sin(tick * 0.04 + i) * 2, 2.6 + i % 2 * 0.6, tick + i * 11, i % 3 === 0 ? 1 : 0);
+    }
+  }
+  drawLoop(tick) {
+    const y = this.canvas.height * 0.56;
+    const x0 = this.canvas.width * 0.09;
+    const x1 = this.canvas.width * 0.91;
+    drawLine(this.canvas, 0, x0, y, x1, y, 0.12, 0.55);
+    const gates = this.layout.compact ? 4 : 5;
+    const active = Math.floor(tick / 16) % gates;
+    for (let i = 0;i < gates; i += 1) {
+      const x = x0 + (x1 - x0) * (i / Math.max(1, gates - 1));
+      drawLine(this.canvas, i === active ? 0 : 3, x, y - 22, x, y + 22, i === active ? 0.25 : 0.08, i === active ? 0.7 : 0.42);
+      drawDot(this.canvas, i <= active ? 0 : 3, x, y, i === active ? 2.2 : 1.2, i === active ? 0.72 : 0.25);
+      drawCircleStroke(this.canvas, i <= active ? 0 : 3, x, y, i === active ? 4.2 : 2.4, i === active ? 0.18 : 0.08);
+    }
+    for (const packet of this.packets) {
+      packet.p += packet.spd * 0.7;
+      if (packet.p > 1)
+        packet.p = 0;
+      const x = x0 + (x1 - x0) * packet.p;
+      const segment = Math.min(gates - 1, Math.floor(packet.p * gates));
+      const channel = segment < active ? 0 : segment === active ? 1 : 3;
+      const py = y + packet.wobble * Math.sin(packet.p * Math.PI * 2);
+      drawLine(this.canvas, channel, x - 6, py, x, py, 0.1, 0.42);
+      drawDot(this.canvas, channel, x, py, packet.size, channel === 3 ? 0.22 : 0.58);
+      drawGlow(this.canvas, channel, x, py, 3.8, channel === 3 ? 0.02 : 0.04);
+    }
+    this.drawDrone(x0 + (x1 - x0) * (tick * 0.003 % 1), y - 18, 2.7, tick, 0);
+    this.drawDrone(x0 + (x1 - x0) * ((tick * 0.002 + 0.5) % 1), y + 16, 2.2, tick + 40, 2);
+  }
+  drawCarrier(tick) {
+    const core = this.core("carrier");
+    drawGlow(this.canvas, 0, core.x, core.y, 26, 0.12);
+    drawDot(this.canvas, 0, core.x, core.y, 2.4, 0.92);
+    drawCircleStroke(this.canvas, 0, core.x, core.y, 8 + Math.sin(tick * 0.06) * 2, 0.14);
+    const nodes = this.layout.compact ? 5 : 7;
+    const rx = this.canvas.width * 0.36;
+    const ry = this.canvas.height * 0.22;
+    for (let i = 0;i < nodes; i += 1) {
+      const a = i / nodes * Math.PI * 2 - Math.PI / 2 + tick * 0.006;
+      const x = core.x + Math.cos(a) * rx;
+      const y = core.y + Math.sin(a) * ry;
+      drawLine(this.canvas, i % 2 ? 1 : 0, core.x, core.y, x, y, 0.055, 0.36);
+      drawCircleStroke(this.canvas, i % 2 ? 1 : 0, x, y, 4.2, 0.15);
+      drawDot(this.canvas, i % 2 ? 1 : 0, x, y, 1.7, 0.62);
+      this.drawDrone(x, y - 8, 2.1, tick + i * 9, i % 2 ? 1 : 0);
+    }
+    for (const packet of this.packets) {
+      packet.p += packet.spd;
+      if (packet.p > 1)
+        packet.p = 0;
+      const lane = packet.lane % nodes;
+      const a = lane / nodes * Math.PI * 2 - Math.PI / 2 + tick * 0.006;
+      const nx = core.x + Math.cos(a) * rx;
+      const ny = core.y + Math.sin(a) * ry;
+      const x = core.x + (nx - core.x) * packet.p;
+      const y = core.y + (ny - core.y) * packet.p;
+      drawDot(this.canvas, packet.channel, x, y, packet.size, 0.48);
+      drawGlow(this.canvas, packet.channel, x, y, 3.2, 0.035);
+    }
+  }
+  drawDrone(x, y, scale, tick, channel) {
+    const wobble = Math.sin(tick * 0.08) * 0.7;
+    drawDot(this.canvas, channel, x, y + wobble, scale, 0.58);
+    drawDot(this.canvas, 3, x, y + wobble, Math.max(0.6, scale * 0.28), 0.42);
+    const rotor = scale * 1.75;
+    const arms = [
+      [-rotor, -rotor * 0.75],
+      [rotor, -rotor * 0.75],
+      [-rotor, rotor * 0.75],
+      [rotor, rotor * 0.75]
+    ];
+    for (const [dx, dy] of arms) {
+      drawLine(this.canvas, channel, x, y + wobble, x + dx, y + dy + wobble, 0.11, 0.38);
+      drawCircleStroke(this.canvas, channel, x + dx, y + dy + wobble, scale * (0.65 + Math.abs(Math.sin(tick * 0.18)) * 0.25), 0.16);
+      drawDot(this.canvas, channel, x + dx, y + dy + wobble, 0.7, 0.25);
+    }
+    drawLine(this.canvas, channel === 1 ? 0 : 1, x - rotor * 2.4, y + wobble + 1.2, x - rotor * 1.2, y + wobble, 0.05, 0.35);
+  }
+  blit(layer) {
+    const fb = layer.frameBuffer;
+    fb.clear(BACKDROP);
+    const { width, height, ac, c2, mg, ink } = this.canvas;
+    for (let cy = 0;cy < this.layout.height; cy += 1) {
+      for (let cx = 0;cx < this.layout.width; cx += 1) {
+        let bits = 0;
+        let acSum = 0;
+        let c2Sum = 0;
+        let mgSum = 0;
+        let inkSum = 0;
+        for (let sy = 0;sy < 4; sy += 1) {
+          for (let sx = 0;sx < 2; sx += 1) {
+            const px = cx * 2 + sx;
+            const py = cy * 4 + sy;
+            if (px >= width || py >= height)
+              continue;
+            const index = py * width + px;
+            const a = ac[index];
+            const c = c2[index];
+            const m = mg[index];
+            const k = ink[index];
+            const total2 = a + c + m + k;
+            acSum += a;
+            c2Sum += c;
+            mgSum += m;
+            inkSum += k;
+            if (total2 > 0.11)
+              bits |= BRAILLE_BITS[sy][sx];
+          }
+        }
+        const total = acSum + c2Sum + mgSum + inkSum;
+        if (bits === 0 || total <= 0.02)
+          continue;
+        const char = String.fromCharCode(10240 + bits);
+        fb.setCellWithAlphaBlending(cx, cy, char, paletteColor(acSum, c2Sum, mgSum, inkSum), TRANSPARENT);
+      }
+    }
+  }
+}
+function createGraphicsLayer(renderer, layout) {
+  const layer = new FrameBufferRenderable(renderer, {
+    id: "rig-marketing-glyph-canvas",
+    width: layout.width,
+    height: layout.height,
+    position: "absolute",
+    left: 0,
+    top: 0,
+    respectAlpha: true
+  });
+  layer.__rigMarketingCanvas = new MarketingGlyphCanvas(layout);
+  return layer;
+}
+function resizeGraphicsLayer(layer, layout) {
+  if (layer.width !== layout.width)
+    layer.width = layout.width;
+  if (layer.height !== layout.height)
+    layer.height = layout.height;
+  layer.__rigMarketingCanvas?.resize(layout);
+}
+function clearGraphicsLayer(layer) {
+  layer.frameBuffer.clear(BACKDROP);
+}
+function panelRect(layout, panel) {
+  const left = Math.max(0, Math.min(layout.width - 1, layout.centerLeft + (panel.left ?? 0)));
+  const desiredWidth = panel.width ?? layout.centerWidth;
+  const width = Math.max(1, Math.min(layout.width - left, desiredWidth));
+  const top = Math.max(0, Math.min(layout.height - 1, layout.centerTop + panel.top));
+  const height = Math.max(1, Math.min(layout.height - top, panel.height));
+  return width > 3 && height > 3 ? { left, top, width, height } : null;
+}
+function writeCell(layer, x, y, char, fg, bg) {
+  layer.frameBuffer.setCellWithAlphaBlending(x, y, char, fg, bg);
+}
+function drawFullCell(layer, x, y, bg) {
+  writeCell(layer, x, y, " ", TRANSPARENT, bg);
+}
+function drawCornerCut(layer, x, y, char, fg) {
+  writeCell(layer, x, y, char, fg, BACKDROP);
+}
+function drawRoundedFill(layer, left, top, right, bottom, dividerY) {
+  const bgForY = (y) => y < dividerY ? PANEL_HEADER_BG : PANEL_BG;
+  for (let y = top;y <= bottom; y += 1) {
+    const bg = bgForY(y);
+    for (let x = left;x <= right; x += 1)
+      drawFullCell(layer, x, y, bg);
+  }
+  drawCornerCut(layer, left, top, "\u2597", PANEL_HEADER_BG);
+  drawCornerCut(layer, right, top, "\u2596", PANEL_HEADER_BG);
+  drawCornerCut(layer, left, bottom, "\u259D", PANEL_BG);
+  drawCornerCut(layer, right, bottom, "\u2598", PANEL_BG);
+}
+function drawAdTerminalPanel(layer, layout, panel) {
+  const rect = panelRect(layout, panel);
+  if (!rect)
+    return;
+  const { left, top, width, height } = rect;
+  const right = left + width - 1;
+  const bottom = top + height - 1;
+  const headerHeight = Math.max(3, Math.min(height - 2, panel.headerHeight ?? 3));
+  const dividerY = Math.min(bottom - 1, top + headerHeight);
+  drawRoundedFill(layer, left, top, right, bottom, dividerY);
+  if (dividerY > top && dividerY < bottom) {
+    for (let x = left + 2;x < right - 1; x += 1) {
+      writeCell(layer, x, dividerY, "\u2500", PANEL_LINE_DIM, PANEL_BG);
+    }
+  }
+  if (panel.headerText) {
+    const x = left + Math.max(2, Math.min(5, panel.paddingX ?? 4));
+    const y = top + Math.max(1, Math.floor(headerHeight / 2));
+    layer.frameBuffer.drawText(panel.headerText.slice(0, Math.max(0, width - 8)), x, y, PANEL_TEXT_DIM, TRANSPARENT);
+  }
+}
+function drawPanelChrome(layer, layout, panels) {
+  for (const panel of panels) {
+    if (panel.chrome === "ad-terminal")
+      drawAdTerminalPanel(layer, layout, panel);
+  }
+}
+function drawAmbientField(layer, layout, tick, scene = "fleet") {
+  layer.__rigMarketingCanvas?.render(layer, scene, tick);
+}
+
+// packages/cli/src/app-opentui/render/image-visual-layer.ts
+import { Worker } from "worker_threads";
+import { deflateSync } from "zlib";
+import { allocateImageId, deleteKittyImage, getCapabilities } from "@earendil-works/pi-tui";
+var BG = [7, 8, 9, 255];
+var PANEL = [16, 17, 21, 184];
+var PANEL_HEADER = [16, 17, 21, 190];
+var PANEL_LINE2 = [255, 255, 255, 24];
+var LIME = [204, 255, 77, 255];
+var LIME_DIM = [169, 214, 63, 255];
+var CYAN = [86, 216, 255, 255];
+var MAGENTA = [255, 121, 176, 255];
+var INK_DIM = [108, 110, 121, 255];
+var PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+var CRC_TABLE = makeCrcTable();
+var MAX_IMAGE_BYTES = 48 * 1024 * 1024;
+var KITTY_CHUNK_SIZE = 4096;
+var PANEL_BLUR_SCALE = 5;
+var PANEL_MASK_CACHE_LIMIT = 16;
+var ZLIB_LEVEL = 1;
+var DEFAULT_IMAGE_RESOLUTION_SCALE = 1;
+var DEFAULT_DRONE_LAYER_SCALE = 0.18;
+var DEFAULT_IMAGE_FPS = 24;
+var panelMaskCache = new Map;
+var BG_WORD = rgbaWord(BG);
+function imageTransport() {
+  const forced = process.env.RIG_OPENTUI_IMAGE_TRANSPORT;
+  if (forced === "rgba-zlib")
+    return "rgba-zlib";
+  return "png";
+}
+function imageResolutionScale() {
+  const raw = Number.parseFloat(process.env.RIG_OPENTUI_IMAGE_SCALE ?? "");
+  if (Number.isFinite(raw) && raw > 0)
+    return Math.max(0.25, Math.min(1, raw));
+  return DEFAULT_IMAGE_RESOLUTION_SCALE;
+}
+function droneLayerScale() {
+  const raw = Number.parseFloat(process.env.RIG_OPENTUI_DRONE_SCALE ?? "");
+  if (Number.isFinite(raw) && raw > 0)
+    return Math.max(0.15, Math.min(1, raw));
+  return DEFAULT_DRONE_LAYER_SCALE;
+}
+function scaledPixelSize(size, scale, layout) {
+  return {
+    width: Math.max(layout.width, Math.floor(size.width * scale)),
+    height: Math.max(layout.height, Math.floor(size.height * scale))
+  };
+}
+function imageFps() {
+  const raw = Number.parseFloat(process.env.RIG_OPENTUI_IMAGE_FPS ?? "");
+  if (Number.isFinite(raw) && raw > 0)
+    return Math.max(10, Math.min(60, raw));
+  return DEFAULT_IMAGE_FPS;
+}
+function rgbaWord(color) {
+  return (color[3] << 24 | color[2] << 16 | color[1] << 8 | color[0]) >>> 0;
+}
+function fillRgba(data, color, word = rgbaWord(color)) {
+  if (data.byteOffset % 4 === 0 && data.byteLength % 4 === 0) {
+    new Uint32Array(data.buffer, data.byteOffset, data.byteLength / 4).fill(word);
+    return;
+  }
+  for (let i = 0;i < data.length; i += 4) {
+    data[i] = color[0];
+    data[i + 1] = color[1];
+    data[i + 2] = color[2];
+    data[i + 3] = color[3];
+  }
+}
+function makeCrcTable() {
+  const table = new Uint32Array(256);
+  for (let n = 0;n < 256; n += 1) {
+    let c = n;
+    for (let k = 0;k < 8; k += 1)
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+}
+function crc32(bytes) {
+  let c = 4294967295;
+  for (let i = 0;i < bytes.length; i += 1)
+    c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function chunk(type, data) {
+  const out = new Uint8Array(12 + data.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, data.length);
+  out[4] = type.charCodeAt(0);
+  out[5] = type.charCodeAt(1);
+  out[6] = type.charCodeAt(2);
+  out[7] = type.charCodeAt(3);
+  out.set(data, 8);
+  view.setUint32(8 + data.length, crc32(out.subarray(4, 8 + data.length)));
+  return out;
+}
+function encodePng(width, height, rgba) {
+  const ihdr = new Uint8Array(13);
+  const ihdrView = new DataView(ihdr.buffer);
+  ihdrView.setUint32(0, width);
+  ihdrView.setUint32(4, height);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  const stride = width * 4;
+  const raw = new Uint8Array((stride + 1) * height);
+  for (let y = 0;y < height; y += 1) {
+    const rawOffset = y * (stride + 1);
+    raw[rawOffset] = 0;
+    raw.set(rgba.subarray(y * stride, y * stride + stride), rawOffset + 1);
+  }
+  const compressed = deflateSync(raw, { level: ZLIB_LEVEL });
+  return Buffer.concat([
+    Buffer.from(PNG_SIGNATURE),
+    Buffer.from(chunk("IHDR", ihdr)),
+    Buffer.from(chunk("IDAT", compressed)),
+    Buffer.from(chunk("IEND", new Uint8Array(0)))
+  ]);
+}
+function kittyImageSequence(base64, options) {
+  const params = [`a=T`, `f=${options.format}`, `q=2`, `C=1`, `c=${options.columns}`, `r=${options.rows}`, `i=${options.imageId}`, `z=${options.zIndex}`];
+  if (options.format === 32) {
+    params.push(`s=${options.pixelWidth ?? 1}`, `v=${options.pixelHeight ?? 1}`);
+    if (options.compressed)
+      params.push("o=z");
+  }
+  if (base64.length <= KITTY_CHUNK_SIZE)
+    return `\x1B_G${params.join(",")};${base64}\x1B\\`;
+  const chunks = [];
+  for (let offset = 0;offset < base64.length; offset += KITTY_CHUNK_SIZE) {
+    const part = base64.slice(offset, offset + KITTY_CHUNK_SIZE);
+    const last = offset + KITTY_CHUNK_SIZE >= base64.length;
+    chunks.push(`\x1B_G${offset === 0 ? `${params.join(",")},` : ""}m=${last ? 0 : 1};${part}\x1B\\`);
+  }
+  return chunks.join("");
+}
+function isModernImageTerminal(protocol) {
+  return protocol === "kitty";
+}
+function clampByte(value) {
+  return Math.max(0, Math.min(255, Math.round(value)));
+}
+function blendOver(data, index, color, alphaScale = 1) {
+  const alpha = color[3] / 255 * alphaScale;
+  const inv = 1 - alpha;
+  data[index] = clampByte(color[0] * alpha + data[index] * inv);
+  data[index + 1] = clampByte(color[1] * alpha + data[index + 1] * inv);
+  data[index + 2] = clampByte(color[2] * alpha + data[index + 2] * inv);
+  data[index + 3] = 255;
+}
+function drawDisc(data, width, height, cx, cy, radius, color, alpha = 1) {
+  const minX = Math.max(0, Math.floor(cx - radius));
+  const maxX = Math.min(width - 1, Math.ceil(cx + radius));
+  const minY = Math.max(0, Math.floor(cy - radius));
+  const maxY = Math.min(height - 1, Math.ceil(cy + radius));
+  for (let y = minY;y <= maxY; y += 1) {
+    for (let x = minX;x <= maxX; x += 1) {
+      const dx = x + 0.5 - cx;
+      const dy = y + 0.5 - cy;
+      const d = Math.sqrt(dx * dx + dy * dy);
+      if (d > radius)
+        continue;
+      const edge = Math.max(0, Math.min(1, radius - d));
+      blendOver(data, (y * width + x) * 4, color, alpha * Math.min(1, 0.35 + edge));
+    }
+  }
+}
+function drawGlow2(data, width, height, cx, cy, radius, color, alpha = 0.18) {
+  const minX = Math.max(0, Math.floor(cx - radius));
+  const maxX = Math.min(width - 1, Math.ceil(cx + radius));
+  const minY = Math.max(0, Math.floor(cy - radius));
+  const maxY = Math.min(height - 1, Math.ceil(cy + radius));
+  for (let y = minY;y <= maxY; y += 1) {
+    for (let x = minX;x <= maxX; x += 1) {
+      const dx = x + 0.5 - cx;
+      const dy = y + 0.5 - cy;
+      const d = Math.sqrt(dx * dx + dy * dy);
+      if (d > radius)
+        continue;
+      const falloff = Math.pow(1 - d / Math.max(1, radius), 2.4);
+      blendOver(data, (y * width + x) * 4, color, alpha * falloff);
+    }
+  }
+}
+function drawLine2(data, width, height, x0, y0, x1, y1, color, alpha = 0.5, thickness = 1.4) {
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const steps = Math.max(1, Math.ceil(Math.hypot(dx, dy) * 1.2));
+  for (let i = 0;i <= steps; i += 1) {
+    const t2 = i / steps;
+    drawDisc(data, width, height, x0 + dx * t2, y0 + dy * t2, thickness, color, alpha);
+  }
+}
+function drawDrone(data, width, height, x, y, scale, tick, color) {
+  const wobble = Math.sin(tick * 0.055) * scale * 0.35;
+  const cy = y + wobble;
+  drawGlow2(data, width, height, x, cy, scale * 7, color, 0.18);
+  drawDisc(data, width, height, x, cy, scale * 1.45, color, 0.92);
+  drawDisc(data, width, height, x, cy, scale * 0.55, [235, 255, 176, 255], 0.85);
+  const arm = scale * 4.1;
+  const rotor = scale * 1.6;
+  const arms = [[-arm, -arm * 0.72], [arm, -arm * 0.72], [-arm, arm * 0.72], [arm, arm * 0.72]];
+  for (const [dx, dy] of arms) {
+    drawLine2(data, width, height, x, cy, x + dx, cy + dy, color, 0.42, Math.max(1, scale * 0.22));
+    drawGlow2(data, width, height, x + dx, cy + dy, rotor * 2.6, color, 0.1);
+    drawDisc(data, width, height, x + dx, cy + dy, rotor, color, 0.34 + 0.12 * Math.sin(tick * 0.15));
+  }
+}
+function roundRectAlpha(px, py, x, y, w, h, r) {
+  const rx = Math.max(x + r, Math.min(px, x + w - r));
+  const ry = Math.max(y + r, Math.min(py, y + h - r));
+  const dx = px - rx;
+  const dy = py - ry;
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  return Math.max(0, Math.min(1, r + 0.75 - dist));
+}
+function panelRect2(layout, panel, size) {
+  const cellW = size.width / layout.width;
+  const cellH = size.height / layout.height;
+  const leftCells = layout.centerLeft + (panel.left ?? 0);
+  const topCells = layout.centerTop + panel.top;
+  const widthCells = panel.width ?? layout.centerWidth;
+  const heightCells = panel.height;
+  const left = Math.round(leftCells * cellW);
+  const top = Math.round(topCells * cellH);
+  const width = Math.round(widthCells * cellW);
+  const height = Math.round(heightCells * cellH);
+  return width > 8 && height > 8 ? { left, top, width, height } : null;
+}
+function downsampleRegion(data, canvasW, canvasH, rect, scale) {
+  const w = Math.max(1, Math.ceil(rect.width / scale));
+  const h = Math.max(1, Math.ceil(rect.height / scale));
+  const out = new Uint8ClampedArray(w * h * 3);
+  for (let y = 0;y < h; y += 1) {
+    for (let x = 0;x < w; x += 1) {
+      let r = 0, g = 0, b = 0, count = 0;
+      const sx0 = rect.left + x * scale;
+      const sy0 = rect.top + y * scale;
+      for (let yy = 0;yy < scale; yy += 1) {
+        const sy = sy0 + yy;
+        if (sy < 0 || sy >= canvasH)
+          continue;
+        for (let xx = 0;xx < scale; xx += 1) {
+          const sx = sx0 + xx;
+          if (sx < 0 || sx >= canvasW)
+            continue;
+          const i = (sy * canvasW + sx) * 4;
+          r += data[i];
+          g += data[i + 1];
+          b += data[i + 2];
+          count += 1;
+        }
+      }
+      const oi = (y * w + x) * 3;
+      out[oi] = count ? r / count : BG[0];
+      out[oi + 1] = count ? g / count : BG[1];
+      out[oi + 2] = count ? b / count : BG[2];
+    }
+  }
+  return { pixels: out, width: w, height: h };
+}
+function blurRgb(buffer, width, height, radius) {
+  const tmp = new Uint8ClampedArray(buffer.length);
+  const out = new Uint8ClampedArray(buffer.length);
+  const window = radius * 2 + 1;
+  for (let y = 0;y < height; y += 1) {
+    let r = 0, g = 0, b = 0;
+    for (let x = -radius;x <= radius; x += 1) {
+      const sx = Math.max(0, Math.min(width - 1, x));
+      const i = (y * width + sx) * 3;
+      r += buffer[i];
+      g += buffer[i + 1];
+      b += buffer[i + 2];
+    }
+    for (let x = 0;x < width; x += 1) {
+      const oi = (y * width + x) * 3;
+      tmp[oi] = r / window;
+      tmp[oi + 1] = g / window;
+      tmp[oi + 2] = b / window;
+      const removeX = Math.max(0, x - radius);
+      const addX = Math.min(width - 1, x + radius + 1);
+      const ri = (y * width + removeX) * 3;
+      const ai = (y * width + addX) * 3;
+      r += tmp.length ? buffer[ai] - buffer[ri] : 0;
+      g += tmp.length ? buffer[ai + 1] - buffer[ri + 1] : 0;
+      b += tmp.length ? buffer[ai + 2] - buffer[ri + 2] : 0;
+    }
+  }
+  for (let x = 0;x < width; x += 1) {
+    let r = 0, g = 0, b = 0;
+    for (let y = -radius;y <= radius; y += 1) {
+      const sy = Math.max(0, Math.min(height - 1, y));
+      const i = (sy * width + x) * 3;
+      r += tmp[i];
+      g += tmp[i + 1];
+      b += tmp[i + 2];
+    }
+    for (let y = 0;y < height; y += 1) {
+      const oi = (y * width + x) * 3;
+      out[oi] = r / window;
+      out[oi + 1] = g / window;
+      out[oi + 2] = b / window;
+      const removeY = Math.max(0, y - radius);
+      const addY = Math.min(height - 1, y + radius + 1);
+      const ri = (removeY * width + x) * 3;
+      const ai = (addY * width + x) * 3;
+      r += tmp[ai] - tmp[ri];
+      g += tmp[ai + 1] - tmp[ri + 1];
+      b += tmp[ai + 2] - tmp[ri + 2];
+    }
+  }
+  return out;
+}
+function panelMaskKey(width, height, rect, headerPx, blurScale) {
+  return `${width}x${height}:${rect.left},${rect.top},${rect.width},${rect.height}:${Math.round(headerPx * 100) / 100}:${blurScale}`;
+}
+function getPanelMask(width, height, rect, headerPx, blurScale) {
+  const key = panelMaskKey(width, height, rect, headerPx, blurScale);
+  const cached = panelMaskCache.get(key);
+  if (cached)
+    return cached;
+  const radius = Math.max(14, Math.min(34, Math.round(Math.min(rect.width, rect.height) * 0.035)));
+  const sampledWidth = Math.max(1, Math.ceil(rect.width / blurScale));
+  const sampledHeight = Math.max(1, Math.ceil(rect.height / blurScale));
+  const x0 = Math.max(0, rect.left);
+  const y0 = Math.max(0, rect.top);
+  const x1 = Math.min(width - 1, rect.left + rect.width - 1);
+  const y1 = Math.min(height - 1, rect.top + rect.height - 1);
+  const indices = [];
+  const sampleIndices = [];
+  const panelAlpha = [];
+  const edgeAlpha = [];
+  const headerFlags = [];
+  const dividerIndices = [];
+  for (let y = y0;y <= y1; y += 1) {
+    for (let x = x0;x <= x1; x += 1) {
+      const a = roundRectAlpha(x + 0.5, y + 0.5, rect.left, rect.top, rect.width, rect.height, radius);
+      if (a <= 0)
+        continue;
+      const edge = roundRectAlpha(x + 0.5, y + 0.5, rect.left + 1.2, rect.top + 1.2, rect.width - 2.4, rect.height - 2.4, Math.max(1, radius - 1.2));
+      const sx = Math.max(0, Math.min(sampledWidth - 1, Math.floor((x - rect.left) / blurScale)));
+      const sy = Math.max(0, Math.min(sampledHeight - 1, Math.floor((y - rect.top) / blurScale)));
+      indices.push((y * width + x) * 4);
+      sampleIndices.push((sy * sampledWidth + sx) * 3);
+      panelAlpha.push(a);
+      edgeAlpha.push(edge < 0.96 ? Math.min(1, (1 - edge) * 0.7) : 0);
+      headerFlags.push(y < rect.top + headerPx ? 1 : 0);
+    }
+  }
+  const dividerY = Math.round(rect.top + headerPx);
+  if (dividerY > y0 && dividerY < y1) {
+    for (let x = x0 + radius;x <= x1 - radius; x += 1) {
+      dividerIndices.push((dividerY * width + x) * 4);
+    }
+  }
+  const mask = {
+    key,
+    indices: Uint32Array.from(indices),
+    sampleIndices: Uint32Array.from(sampleIndices),
+    panelAlpha: Float32Array.from(panelAlpha),
+    edgeAlpha: Float32Array.from(edgeAlpha),
+    headerFlags: Uint8Array.from(headerFlags),
+    dividerIndices: Uint32Array.from(dividerIndices)
+  };
+  panelMaskCache.set(key, mask);
+  while (panelMaskCache.size > PANEL_MASK_CACHE_LIMIT) {
+    const oldest = panelMaskCache.keys().next().value;
+    if (!oldest)
+      break;
+    panelMaskCache.delete(oldest);
+  }
+  return mask;
+}
+function compositePanel(data, width, height, rect, headerPx) {
+  const blurScale = PANEL_BLUR_SCALE;
+  const sampled = downsampleRegion(data, width, height, rect, blurScale);
+  const blurred = blurRgb(sampled.pixels, sampled.width, sampled.height, 4);
+  const mask = getPanelMask(width, height, rect, headerPx, blurScale);
+  for (let i = 0;i < mask.indices.length; i += 1) {
+    const idx = mask.indices[i];
+    const sampleIdx = mask.sampleIndices[i];
+    data[idx] = blurred[sampleIdx];
+    data[idx + 1] = blurred[sampleIdx + 1];
+    data[idx + 2] = blurred[sampleIdx + 2];
+    data[idx + 3] = 255;
+    blendOver(data, idx, mask.headerFlags[i] ? PANEL_HEADER : PANEL, mask.panelAlpha[i]);
+    const edge = mask.edgeAlpha[i];
+    if (edge > 0)
+      blendOver(data, idx, PANEL_LINE2, edge);
+  }
+  for (let i = 0;i < mask.dividerIndices.length; i += 1) {
+    blendOver(data, mask.dividerIndices[i], PANEL_LINE2, 0.28);
+  }
+}
+function visualSceneKind(scene) {
+  if (scene === "tasks")
+    return "loop";
+  if (scene === "help")
+    return "carrier";
+  return "dispatch";
+}
+function seededUnit(seed) {
+  let value = seed >>> 0;
+  value = value * 1664525 + 1013904223 >>> 0;
+  return value / 4294967295;
+}
+function sceneCore(width, height, kind) {
+  if (kind === "dispatch")
+    return { x: width * 0.3, y: height * 0.45 };
+  if (kind === "carrier")
+    return { x: width * 0.5, y: height * 0.54 };
+  return { x: width * 0.09, y: height * 0.56 };
+}
+function dispatchLane(width, index, count) {
+  const a = seededUnit(28672 + index * 101);
+  const b = seededUnit(36864 + index * 131);
+  const c = seededUnit(45056 + index * 151);
+  const ang = (-0.9 + 1.8 * (index / Math.max(1, count - 1))) * (Math.PI * 0.5);
+  return { ang, len: width * (0.32 + a * 0.42), curve: (b - 0.5) * 0.7, phase: c * Math.PI * 2 };
+}
+function lanePoint(width, height, lane, p, kind = "dispatch") {
+  const core = sceneCore(width, height, kind);
+  const dist = lane.len * p;
+  const bend = Math.sin(p * Math.PI) * lane.curve * Math.min(width, height) * 0.035;
+  const ux = Math.cos(lane.ang);
+  const uy = Math.sin(lane.ang);
+  return { x: core.x + ux * dist + -uy * bend, y: core.y + uy * dist + ux * bend };
+}
+function drawMarketingRails(data, width, height, kind, tick) {
+  const ys = kind === "loop" ? [0.18, 0.5, 0.82] : kind === "carrier" ? [0.24, 0.54, 0.82] : [0.18, 0.58, 0.82];
+  ys.forEach((ratio, index) => {
+    const y = height * ratio + Math.sin(tick * 0.018 + index) * Math.max(2, height * 0.0025);
+    const color = index === 2 ? CYAN : index === 1 ? LIME : LIME_DIM;
+    drawLine2(data, width, height, width * 0.06, y, width * 0.94, y + Math.sin(index) * height * 0.002, color, index === 1 ? 0.11 : 0.07, Math.max(0.8, height * 0.0012));
+    for (let p = (tick * 0.004 + index * 0.21) % 1;p < 1; p += 0.18 + index * 0.02) {
+      const x = width * (0.06 + 0.88 * p);
+      drawDisc(data, width, height, x, y, Math.max(1.2, height * (0.0017 + index * 0.0004)), color, 0.24);
+      drawGlow2(data, width, height, x, y, Math.max(5, height * 0.006), color, 0.035);
+    }
+  });
+}
+function drawDispatchScene(data, width, height, tick) {
+  const core = sceneCore(width, height, "dispatch");
+  const min = Math.min(width, height);
+  drawGlow2(data, width, height, core.x, core.y, min * 0.085, LIME, 0.12);
+  drawDisc(data, width, height, core.x, core.y, min * 0.0065, LIME, 0.85);
+  const laneCount = width < 1000 ? 7 : 12;
+  const lanes = Array.from({ length: laneCount }, (_, index) => dispatchLane(width, index, laneCount));
+  lanes.forEach((lane) => {
+    let prev = lanePoint(width, height, lane, 0);
+    for (let step = 1;step <= 32; step += 1) {
+      const next = lanePoint(width, height, lane, step / 32);
+      drawLine2(data, width, height, prev.x, prev.y, next.x, next.y, lane.phase > Math.PI ? CYAN : LIME_DIM, 0.045, Math.max(0.7, min * 0.0009));
+      prev = next;
+    }
+  });
+  const packets = width < 1000 ? 70 : 150;
+  for (let i = 0;i < packets; i += 1) {
+    const lane = lanes[i % lanes.length];
+    const speed = 0.003 + seededUnit(12288 + i * 17) * 0.009;
+    const p = (seededUnit(16384 + i * 19) + tick * speed) % 1;
+    const pt = lanePoint(width, height, lane, p);
+    const wobble = (seededUnit(20480 + i * 23) - 0.5) * min * 0.012;
+    const fade = p < 0.1 ? p / 0.1 : p > 0.88 ? (1 - p) / 0.12 : 1;
+    const color = seededUnit(24576 + i * 29) < 0.22 ? CYAN : LIME_DIM;
+    const y = pt.y + wobble * Math.sin(p * Math.PI * 2);
+    drawLine2(data, width, height, pt.x - min * 0.012, y - min * 0.002, pt.x, y, color, 0.08 * fade, Math.max(0.7, min * 0.0008));
+    drawDisc(data, width, height, pt.x, y, Math.max(1.3, min * 0.0022), color, 0.5 * fade);
+    drawGlow2(data, width, height, pt.x, y, Math.max(4, min * 0.008), color, 0.045 * fade);
+  }
+  for (let i = 0;i < (width < 1000 ? 4 : 8); i += 1) {
+    const lane = lanes[i % lanes.length];
+    const p = (tick * 0.002 + i * 0.13) % 1;
+    const pt = lanePoint(width, height, lane, p);
+    drawDrone(data, width, height, pt.x, pt.y + Math.sin(tick * 0.04 + i) * min * 0.004, min * (0.006 + i % 2 * 0.0015), tick + i * 11, i % 3 === 0 ? CYAN : LIME_DIM);
+  }
+}
+function drawLoopScene(data, width, height, tick) {
+  const min = Math.min(width, height);
+  const y = height * 0.56;
+  const x0 = width * 0.09;
+  const x1 = width * 0.91;
+  drawLine2(data, width, height, x0, y, x1, y, LIME_DIM, 0.12, Math.max(0.8, min * 0.001));
+  const gates = width < 1000 ? 4 : 5;
+  const active = Math.floor(tick / 16) % gates;
+  for (let i = 0;i < gates; i += 1) {
+    const x = x0 + (x1 - x0) * (i / Math.max(1, gates - 1));
+    const color = i === active ? LIME : i <= active ? LIME_DIM : INK_DIM;
+    drawLine2(data, width, height, x, y - min * 0.05, x, y + min * 0.05, color, i === active ? 0.25 : 0.08, Math.max(0.8, min * 0.001));
+    drawDisc(data, width, height, x, y, i === active ? min * 0.006 : min * 0.0035, color, i === active ? 0.72 : 0.25);
+    drawGlow2(data, width, height, x, y, i === active ? min * 0.018 : min * 0.01, color, i === active ? 0.1 : 0.035);
+  }
+  const packets = width < 1000 ? 36 : 84;
+  for (let i = 0;i < packets; i += 1) {
+    const p = (seededUnit(33024 + i * 13) + tick * (0.0022 + seededUnit(33280 + i * 17) * 0.004)) % 1;
+    const x = x0 + (x1 - x0) * p;
+    const segment = Math.min(gates - 1, Math.floor(p * gates));
+    const color = segment < active ? LIME_DIM : segment === active ? CYAN : INK_DIM;
+    const py = y + (seededUnit(33536 + i * 19) - 0.5) * min * 0.018 * Math.sin(p * Math.PI * 2);
+    drawLine2(data, width, height, x - min * 0.014, py, x, py, color, 0.1, Math.max(0.7, min * 0.0008));
+    drawDisc(data, width, height, x, py, Math.max(1.2, min * 0.002), color, color === INK_DIM ? 0.22 : 0.58);
+  }
+  drawDrone(data, width, height, x0 + (x1 - x0) * (tick * 0.003 % 1), y - min * 0.04, min * 0.0065, tick, LIME_DIM);
+  drawDrone(data, width, height, x0 + (x1 - x0) * ((tick * 0.002 + 0.5) % 1), y + min * 0.036, min * 0.0055, tick + 40, MAGENTA);
+}
+function drawCarrierScene(data, width, height, tick) {
+  const min = Math.min(width, height);
+  const core = sceneCore(width, height, "carrier");
+  drawGlow2(data, width, height, core.x, core.y, min * 0.075, LIME, 0.12);
+  drawDisc(data, width, height, core.x, core.y, min * 0.0065, LIME, 0.92);
+  const nodes = width < 1000 ? 5 : 7;
+  const rx = width * 0.36;
+  const ry = height * 0.22;
+  for (let i = 0;i < nodes; i += 1) {
+    const a = i / nodes * Math.PI * 2 - Math.PI / 2 + tick * 0.006;
+    const x = core.x + Math.cos(a) * rx;
+    const y = core.y + Math.sin(a) * ry;
+    const color = i % 2 ? CYAN : LIME_DIM;
+    drawLine2(data, width, height, core.x, core.y, x, y, color, 0.055, Math.max(0.7, min * 0.0008));
+    drawGlow2(data, width, height, x, y, min * 0.018, color, 0.055);
+    drawDisc(data, width, height, x, y, min * 0.0048, color, 0.62);
+    drawDrone(data, width, height, x, y - min * 0.018, min * 0.005, tick + i * 9, color);
+  }
+  const packets = width < 1000 ? 30 : 72;
+  for (let i = 0;i < packets; i += 1) {
+    const lane = i % nodes;
+    const a = lane / nodes * Math.PI * 2 - Math.PI / 2 + tick * 0.006;
+    const nx = core.x + Math.cos(a) * rx;
+    const ny = core.y + Math.sin(a) * ry;
+    const p = (seededUnit(37120 + i * 37) + tick * (0.003 + seededUnit(37376 + i * 43) * 0.009)) % 1;
+    const x = core.x + (nx - core.x) * p;
+    const y = core.y + (ny - core.y) * p;
+    const color = seededUnit(37632 + i * 47) < 0.35 ? CYAN : LIME_DIM;
+    drawDisc(data, width, height, x, y, Math.max(1.2, min * 0.002), color, 0.48);
+    drawGlow2(data, width, height, x, y, min * 0.008, color, 0.035);
+  }
+}
+function drawBackground(data, width, height, tick, scene) {
+  fillRgba(data, BG, BG_WORD);
+  const kind = visualSceneKind(scene);
+  drawGlow2(data, width, height, width * 0.82, height * 0.04, Math.min(width, height) * 0.22, LIME, 0.035);
+  drawGlow2(data, width, height, width * 0.12, height * 0.18, Math.min(width, height) * 0.17, CYAN, 0.025);
+  drawMarketingRails(data, width, height, kind, tick);
+  if (kind === "loop")
+    drawLoopScene(data, width, height, tick);
+  else if (kind === "carrier")
+    drawCarrierScene(data, width, height, tick);
+  else
+    drawDispatchScene(data, width, height, tick);
+}
+function imageVisualFrameKey(input) {
+  const width = Math.max(1, Math.floor(input.pixelSize.width));
+  const height = Math.max(1, Math.floor(input.pixelSize.height));
+  const layer = "layer" in input ? input.layer ?? "full" : "full";
+  return `${layer}:${width}x${height}:${input.layout.width}x${input.layout.height}:${input.scene}:${input.tick}:${input.panels.map((panel) => `${panel.id}:${panel.top}:${panel.height}:${panel.width ?? ""}:${panel.left ?? ""}:${panel.headerHeight ?? ""}`).join("|")}`;
+}
+function encodeKittyFrame(width, height, data, input) {
+  if (input.transport === "png") {
+    const png = encodePng(width, height, data);
+    return kittyImageSequence(png.toString("base64"), { columns: input.layout.width, rows: input.layout.height, imageId: input.imageId, zIndex: input.zIndex, format: 100 });
+  }
+  const compressed = deflateSync(data, { level: ZLIB_LEVEL });
+  return kittyImageSequence(compressed.toString("base64"), {
+    columns: input.layout.width,
+    rows: input.layout.height,
+    imageId: input.imageId,
+    zIndex: input.zIndex,
+    format: 32,
+    pixelWidth: width,
+    pixelHeight: height,
+    compressed: true
+  });
+}
+function renderImageVisualFrame(input) {
+  const width = Math.max(1, Math.floor(input.pixelSize.width));
+  const height = Math.max(1, Math.floor(input.pixelSize.height));
+  const byteCount = width * height * 4;
+  if (byteCount > MAX_IMAGE_BYTES)
+    return null;
+  const data = new Uint8ClampedArray(byteCount);
+  drawBackground(data, width, height, input.tick, input.scene);
+  for (const panel of input.panels) {
+    if (panel.chrome !== "ad-terminal")
+      continue;
+    const rect = panelRect2(input.layout, panel, { width, height });
+    if (!rect)
+      continue;
+    const cellH = height / input.layout.height;
+    const headerPx = Math.max(cellH * 3, (panel.headerHeight ?? 3) * cellH);
+    compositePanel(data, width, height, rect, headerPx);
+  }
+  return { key: imageVisualFrameKey(input), sequence: encodeKittyFrame(width, height, data, input) };
+}
+function createImageWorker() {
+  if (process.env.RIG_OPENTUI_IMAGE_WORKER === "0")
+    return null;
+  const isTypeScriptRuntime = import.meta.url.endsWith(".ts");
+  const workerUrl = new URL(isTypeScriptRuntime ? "./image-visual-layer-worker.ts" : "./image-visual-layer-worker.js", import.meta.url);
+  try {
+    return new Worker(workerUrl);
+  } catch {
+    if (typeof process.versions.bun === "string") {
+      try {
+        return new Worker("./src/app-opentui/render/image-visual-layer-worker.ts");
+      } catch {}
+    }
+    return null;
+  }
+}
+var RECENT_WRITTEN_LIMIT = 24;
+var DEFAULT_PANEL_FPS = 24;
+var DEFAULT_PANEL_LAYER_SCALE = 0.22;
+var DEFAULT_IMAGE_OUTPUT_BACKLOG_BYTES = 256 * 1024;
+var DEFAULT_IMAGE_OUTPUT_BYTES_PER_SECOND = 850 * 1024;
+var MIN_BACKGROUND_BUDGET_BYTES = 24 * 1024;
+var MIN_PANEL_BUDGET_BYTES = 56 * 1024;
+function panelFps() {
+  const raw = Number.parseFloat(process.env.RIG_OPENTUI_PANEL_FPS ?? "");
+  if (Number.isFinite(raw) && raw > 0)
+    return Math.max(4, Math.min(60, raw));
+  return DEFAULT_PANEL_FPS;
+}
+function panelLayerScale() {
+  const raw = Number.parseFloat(process.env.RIG_OPENTUI_PANEL_SCALE ?? "");
+  if (Number.isFinite(raw) && raw > 0)
+    return Math.max(0.18, Math.min(1, raw));
+  return DEFAULT_PANEL_LAYER_SCALE;
+}
+function imageOutputBacklogBytes() {
+  const raw = Number.parseInt(process.env.RIG_OPENTUI_IMAGE_BACKLOG_BYTES ?? "", 10);
+  if (Number.isFinite(raw) && raw > 0)
+    return Math.max(64 * 1024, Math.min(2 * 1024 * 1024, raw));
+  return DEFAULT_IMAGE_OUTPUT_BACKLOG_BYTES;
+}
+function imageOutputBytesPerSecond() {
+  const raw = Number.parseInt(process.env.RIG_OPENTUI_IMAGE_BYTES_PER_SECOND ?? "", 10);
+  if (Number.isFinite(raw) && raw > 0)
+    return Math.max(128 * 1024, Math.min(2 * 1024 * 1024, raw));
+  return DEFAULT_IMAGE_OUTPUT_BYTES_PER_SECOND;
+}
+function pendingLayerKey(key) {
+  return key.split(":", 1)[0] || "full";
+}
+
+class ImageVisualLayer {
+  imageId = allocateImageId();
+  panelImageIds = Array.from({ length: 8 }, () => allocateImageId());
+  panelChromeImageIds = Array.from({ length: 8 }, () => allocateImageId());
+  stdout;
+  protocol;
+  transport = imageTransport();
+  frameIntervalMs = 1000 / imageFps();
+  panelIntervalMs = 1000 / panelFps();
+  maxOutputBacklogBytes = imageOutputBacklogBytes();
+  outputBytesPerSecond = imageOutputBytesPerSecond();
+  outputBudgetBytes = imageOutputBytesPerSecond();
+  lastBudgetAtMs = Date.now();
+  motionSlot = this.createSlot();
+  panelSlot = this.createSlot();
+  chromeSlot = this.createSlot();
+  pendingFrames = new Map;
+  recentWrittenKeys = [];
+  requestId = 0;
+  lastMotionFrameIndex = -1;
+  lastPanelFrameIndex = -1;
+  lastChromeKey = "";
+  destroyed = false;
+  constructor(stdout = process.stdout) {
+    this.stdout = stdout;
+    this.protocol = getCapabilities().images;
+    if (this.enabled) {
+      this.startWorker(this.motionSlot);
+      this.startWorker(this.panelSlot);
+      this.startWorker(this.chromeSlot);
+    }
+  }
+  get enabled() {
+    return isModernImageTerminal(this.protocol);
+  }
+  clear() {
+    if (this.enabled) {
+      this.stdout.write([this.imageId, ...this.panelImageIds, ...this.panelChromeImageIds].map((id) => deleteKittyImage(id)).join("") + "\x1B[?25h");
+      this.pendingFrames.clear();
+      this.recentWrittenKeys.length = 0;
+      this.resetSlot(this.motionSlot);
+      this.resetSlot(this.panelSlot);
+      this.resetSlot(this.chromeSlot);
+      this.lastMotionFrameIndex = -1;
+      this.lastPanelFrameIndex = -1;
+      this.lastChromeKey = "";
+      this.outputBudgetBytes = this.outputBytesPerSecond;
+      this.lastBudgetAtMs = Date.now();
+      this.motionSlot.clearedThroughRequestId = this.requestId;
+      this.panelSlot.clearedThroughRequestId = this.requestId;
+      this.chromeSlot.clearedThroughRequestId = this.requestId;
+    }
+  }
+  destroy() {
+    if (this.destroyed)
+      return;
+    this.clear();
+    this.destroyed = true;
+    const workers = [this.motionSlot.worker, this.panelSlot.worker, this.chromeSlot.worker];
+    this.motionSlot.worker = null;
+    this.panelSlot.worker = null;
+    this.chromeSlot.worker = null;
+    for (const worker of workers)
+      if (worker)
+        worker.terminate().catch(() => {
+          return;
+        });
+  }
+  render(input) {
+    if (!this.enabled || this.destroyed)
+      return;
+    const width = Math.max(1, Math.floor(input.pixelSize.width));
+    const height = Math.max(1, Math.floor(input.pixelSize.height));
+    if (width * height * 4 > MAX_IMAGE_BYTES)
+      return;
+    if (this.isOutputBackedUp())
+      return;
+    this.refillOutputBudget();
+    const now = Date.now();
+    const visualTick = Math.floor(now / (1000 / 60));
+    const useDynamicSplit = Boolean(this.motionSlot.worker && this.panelSlot.worker && this.chromeSlot.worker && this.transport === "png" && process.env.RIG_OPENTUI_DYNAMIC_SPLIT !== "0");
+    if (!useDynamicSplit) {
+      const frameIndex = Math.floor(now / this.frameIntervalMs);
+      if (!input.force && frameIndex === this.lastMotionFrameIndex)
+        return;
+      this.scheduleRender(this.motionSlot, { ...input, tick: visualTick, layer: "full" }, this.imageId, -10, input.force);
+      this.lastMotionFrameIndex = frameIndex;
+      return;
+    }
+    const motionFrameIndex = Math.floor(now / this.frameIntervalMs);
+    if ((input.force || motionFrameIndex !== this.lastMotionFrameIndex) && this.outputBudgetBytes >= MIN_BACKGROUND_BUDGET_BYTES) {
+      this.scheduleRender(this.motionSlot, { ...input, pixelSize: scaledPixelSize(input.pixelSize, droneLayerScale(), input.layout), panels: [], tick: visualTick, layer: "background" }, this.imageId, -30, input.force);
+      this.lastMotionFrameIndex = motionFrameIndex;
+    }
+    const panelFrameIndex = Math.floor(now / this.panelIntervalMs);
+    if ((input.force || panelFrameIndex !== this.lastPanelFrameIndex) && this.outputBudgetBytes >= MIN_PANEL_BUDGET_BYTES) {
+      this.scheduleRender(this.panelSlot, { ...input, pixelSize: scaledPixelSize(input.pixelSize, panelLayerScale(), input.layout), tick: visualTick, layer: "panel-patches" }, this.imageId, -12, input.force, this.panelImageIds);
+      this.lastPanelFrameIndex = panelFrameIndex;
+    }
+    const chromeInput = { ...input, tick: 0, layer: "panel-chrome" };
+    const chromeKey = imageVisualFrameKey(chromeInput);
+    if (input.force || chromeKey !== this.lastChromeKey) {
+      this.scheduleRender(this.chromeSlot, chromeInput, this.imageId, -8, input.force, this.panelChromeImageIds);
+      this.lastChromeKey = chromeKey;
+    }
+  }
+  flush() {
+    if (this.pendingFrames.size === 0)
+      return false;
+    this.refillOutputBudget();
+    if (this.isOutputBackedUp()) {
+      const chrome = this.pendingFrames.get("panel-chrome");
+      this.pendingFrames.clear();
+      if (chrome)
+        this.pendingFrames.set("panel-chrome", chrome);
+      return false;
+    }
+    const framePriority = (frame) => {
+      const layer = pendingLayerKey(frame.key);
+      if (layer === "panel-chrome")
+        return 0;
+      if (layer === "background")
+        return 1;
+      if (layer === "panel-patches")
+        return 2;
+      return 2;
+    };
+    const frames = Array.from(this.pendingFrames.values()).sort((a, b) => framePriority(a) - framePriority(b));
+    const prefix = "\x1B[?25l\x1B7\x1B[s\x1B[H";
+    const suffix = "\x1B[u\x1B8";
+    const selected = [];
+    const retained = new Map;
+    let sequence = "";
+    let byteLength = Buffer.byteLength(prefix + suffix);
+    for (const frame of frames) {
+      const candidate = sequence + frame.sequence;
+      const candidateBytes = Buffer.byteLength(prefix + candidate + suffix);
+      if (candidateBytes <= this.outputBudgetBytes) {
+        selected.push(frame);
+        sequence = candidate;
+        byteLength = candidateBytes;
+      } else if (pendingLayerKey(frame.key) === "panel-chrome") {
+        retained.set(pendingLayerKey(frame.key), frame);
+      }
+    }
+    this.pendingFrames.clear();
+    for (const [layer, frame] of retained)
+      this.pendingFrames.set(layer, frame);
+    if (!sequence || selected.length === 0)
+      return false;
+    const payload = `${prefix}${sequence}${suffix}`;
+    for (const frame of selected)
+      this.markWritten(frame.key);
+    this.outputBudgetBytes -= byteLength;
+    this.stdout.cork?.();
+    const accepted = this.stdout.write(payload);
+    this.stdout.uncork?.();
+    return accepted;
+  }
+  createSlot() {
+    return { worker: null, busy: false, queuedRequest: null, inFlightKey: "", queuedKey: "", clearedThroughRequestId: 0 };
+  }
+  resetSlot(slot) {
+    slot.busy = false;
+    slot.queuedRequest = null;
+    slot.inFlightKey = "";
+    slot.queuedKey = "";
+  }
+  markWritten(key) {
+    this.recentWrittenKeys.push(key);
+    while (this.recentWrittenKeys.length > RECENT_WRITTEN_LIMIT)
+      this.recentWrittenKeys.shift();
+  }
+  refillOutputBudget() {
+    const now = Date.now();
+    const elapsedMs = Math.max(0, now - this.lastBudgetAtMs);
+    this.lastBudgetAtMs = now;
+    this.outputBudgetBytes = Math.min(this.outputBytesPerSecond, this.outputBudgetBytes + elapsedMs / 1000 * this.outputBytesPerSecond);
+  }
+  isOutputBackedUp() {
+    return Boolean(this.stdout.writableNeedDrain) || this.stdout.writableLength > this.maxOutputBacklogBytes;
+  }
+  stageFrame(frame) {
+    this.pendingFrames.set(pendingLayerKey(frame.key), frame);
+  }
+  isKnownKey(slot, key) {
+    return this.recentWrittenKeys.includes(key) || Array.from(this.pendingFrames.values()).some((frame) => frame.key === key) || key === slot.inFlightKey || key === slot.queuedKey;
+  }
+  scheduleRender(slot, input, imageId, zIndex, force, imageIds) {
+    const key = imageVisualFrameKey(input);
+    if (!force && this.isKnownKey(slot, key))
+      return;
+    const request = {
+      ...input,
+      imageId,
+      ...imageIds ? { imageIds } : {},
+      zIndex,
+      transport: this.transport,
+      requestId: ++this.requestId,
+      key
+    };
+    if (slot.worker) {
+      this.enqueueWorkerRender(slot, request);
+      return;
+    }
+    this.renderSync(slot, request);
+  }
+  startWorker(slot) {
+    const worker = createImageWorker();
+    if (!worker)
+      return;
+    slot.worker = worker;
+    worker.on("message", (message) => this.handleWorkerMessage(slot, message));
+    worker.once("error", () => this.disableWorker(slot));
+    worker.once("exit", () => this.disableWorker(slot));
+  }
+  disableWorker(slot) {
+    if (this.destroyed)
+      return;
+    slot.worker = null;
+    slot.busy = false;
+    slot.inFlightKey = "";
+    const queued = slot.queuedRequest;
+    slot.queuedRequest = null;
+    slot.queuedKey = "";
+    if (queued?.layer === "full")
+      this.renderSync(slot, queued);
+  }
+  enqueueWorkerRender(slot, request) {
+    if (!slot.worker) {
+      this.renderSync(slot, request);
+      return;
+    }
+    if (slot.busy) {
+      slot.queuedRequest = request;
+      slot.queuedKey = request.key;
+      return;
+    }
+    this.dispatchWorkerRender(slot, request);
+  }
+  dispatchWorkerRender(slot, request) {
+    if (!slot.worker) {
+      this.renderSync(slot, request);
+      return;
+    }
+    slot.busy = true;
+    slot.inFlightKey = request.key;
+    slot.worker.postMessage(request);
+  }
+  handleWorkerMessage(slot, message) {
+    if (this.destroyed || !message || typeof message !== "object")
+      return;
+    const response = message;
+    slot.busy = false;
+    slot.inFlightKey = "";
+    if (response.requestId <= slot.clearedThroughRequestId)
+      return;
+    if (response.error) {
+      this.disableWorker(slot);
+      return;
+    }
+    if (response.sequence && !this.isKnownKey(slot, response.key) && (!this.isOutputBackedUp() || pendingLayerKey(response.key) === "panel-chrome")) {
+      this.stageFrame({ key: response.key, sequence: response.sequence });
+    }
+    const next = slot.queuedRequest;
+    slot.queuedRequest = null;
+    slot.queuedKey = "";
+    if (next && !this.isKnownKey(slot, next.key))
+      this.dispatchWorkerRender(slot, next);
+  }
+  renderSync(slot, request) {
+    const result = renderImageVisualFrame(request);
+    if (!result || this.isKnownKey(slot, result.key) || this.isOutputBackedUp())
+      return;
+    this.stageFrame(result);
+  }
+}
+function pixelSizeForRenderer(renderer) {
+  const resolution = renderer.resolution;
+  const base = resolution?.width && resolution?.height ? resolution : { width: renderer.width * 12, height: renderer.height * 24 };
+  const scale = imageResolutionScale();
+  return {
+    width: Math.max(renderer.width, Math.floor(base.width * scale)),
+    height: Math.max(renderer.height, Math.floor(base.height * scale))
+  };
+}
+function forceModernImageVisuals() {
+  return isModernImageTerminal(getCapabilities().images);
+}
+
+// packages/cli/src/app-opentui/render/text.ts
+import { TextAttributes as TextAttributes2, TextRenderable } from "@opentui/core";
+function selectableMouseHandler(currentLineRef, onLineMouseDown) {
+  return (event) => {
+    const currentLine = currentLineRef();
+    if (currentLine?.selectableIndex === undefined)
+      return;
+    onLineMouseDown?.(currentLine, event);
+  };
+}
+function createTextLine(renderer, id, top, onLineMouseDown) {
+  let currentLine;
+  const renderable = new TextRenderable(renderer, {
+    id,
+    content: "",
+    position: "absolute",
+    left: 0,
+    top,
+    width: 1,
+    fg: RIG_UI.ink2,
+    selectable: true,
+    onMouseDown: selectableMouseHandler(() => currentLine, onLineMouseDown)
+  });
+  renderable.setRigSceneLine = (line) => {
+    currentLine = line;
+  };
+  return renderable;
+}
+function createFlowTextLine(renderer, id, onLineMouseDown) {
+  let currentLine;
+  const renderable = new TextRenderable(renderer, {
+    id,
+    content: "",
+    width: "100%",
+    height: 1,
+    flexShrink: 0,
+    fg: RIG_UI.ink2,
+    selectable: true,
+    onMouseDown: selectableMouseHandler(() => currentLine, onLineMouseDown)
+  });
+  renderable.setRigSceneLine = (line) => {
+    currentLine = line;
+  };
+  return renderable;
+}
+function applyTextLine(renderable, line, top, left, width) {
+  renderable.setRigSceneLine?.(line);
+  renderable.top = top;
+  renderable.left = left;
+  renderable.width = width;
+  renderable.content = line?.styledText ?? line?.text ?? "";
+  renderable.fg = line?.fg ?? RIG_UI.ink2;
+  renderable.attributes = line?.bold ? TextAttributes2.BOLD : line?.dim ? TextAttributes2.DIM : 0;
+}
+function applyFlowTextLine(renderable, line, width) {
+  renderable.setRigSceneLine?.(line);
+  renderable.visible = Boolean(line);
+  renderable.height = line ? 1 : 0;
+  renderable.width = Math.max(1, width);
+  renderable.content = line?.styledText ?? line?.text ?? "";
+  renderable.fg = line?.fg ?? RIG_UI.ink2;
+  renderable.attributes = line?.bold ? TextAttributes2.BOLD : line?.dim ? TextAttributes2.DIM : 0;
+}
+function clearTextLines(renderables, from = 0) {
+  for (let index = from;index < renderables.length; index += 1) {
+    const renderable = renderables[index];
+    renderable.setRigSceneLine?.(undefined);
+    renderable.content = "";
+    renderable.top = -1;
+    renderable.left = 0;
+    renderable.width = 1;
+  }
+}
+
+// packages/cli/src/app-opentui/render/panels.ts
+import { RGBA as RGBA2, ScrollBoxRenderable } from "@opentui/core";
+var TRANSPARENT2 = RGBA2.fromInts(0, 0, 0, 0);
+var MAX_PANEL_LINES = 420;
+function hexToRgba(hex, alpha) {
+  const clean = hex.replace(/^#/, "");
+  const full = clean.length === 3 ? clean.split("").map((part) => `${part}${part}`).join("") : clean;
+  const value = Number.parseInt(full, 16);
+  if (!Number.isFinite(value))
+    return RGBA2.fromInts(14, 15, 17, alpha);
+  return RGBA2.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255, alpha);
+}
+function panelBackground(panel) {
+  return hexToRgba(panel.backgroundColor ?? RIG_UI.panel, panel.backgroundAlpha ?? 184);
+}
+function panelBorder(panel) {
+  return panel.borderColor ? hexToRgba(panel.borderColor, panel.borderAlpha ?? 54) : TRANSPARENT2;
+}
+function createScrollPanelLayer(renderer, id, onLineMouseDown) {
+  const panel = new ScrollBoxRenderable(renderer, {
+    id,
+    position: "absolute",
+    left: 0,
+    top: -2,
+    width: 1,
+    height: 1,
+    backgroundColor: TRANSPARENT2,
+    border: false,
+    shouldFill: true,
+    opacity: 1,
+    zIndex: 6,
+    scrollY: true,
+    scrollX: false,
+    stickyScroll: false,
+    viewportCulling: true,
+    paddingX: 2,
+    paddingY: 1,
+    verticalScrollbarOptions: {
+      showArrows: false,
+      visible: false,
+      width: 1,
+      trackOptions: {
+        backgroundColor: TRANSPARENT2,
+        foregroundColor: hexToRgba(RIG_UI.ink4, 84)
+      }
+    },
+    horizontalScrollbarOptions: {
+      height: 0,
+      visible: false,
+      trackOptions: {
+        backgroundColor: TRANSPARENT2,
+        foregroundColor: TRANSPARENT2
+      }
+    }
+  });
+  panel.__rigTextLines = [];
+  for (let index = 0;index < MAX_PANEL_LINES; index += 1) {
+    const line = createFlowTextLine(renderer, `${id}-line-${index}`, onLineMouseDown);
+    panel.__rigTextLines.push(line);
+    panel.add(line);
+  }
+  return panel;
+}
+function hidePanel(panel) {
+  panel.visible = false;
+  panel.top = -2;
+  panel.left = 0;
+  panel.width = 1;
+  panel.height = 1;
+  panel.backgroundColor = TRANSPARENT2;
+  panel.border = false;
+  panel.__rigPanelId = undefined;
+  panel.__rigTextLines.forEach((line) => applyFlowTextLine(line, undefined, 1));
+}
+function applyScrollPanels(panels, layout, scenePanels) {
+  panels.forEach((renderable, index) => {
+    const panel = scenePanels[index];
+    if (!panel || panel.height <= 0) {
+      hidePanel(renderable);
+      return;
+    }
+    const cardLeft = Math.max(0, Math.min(layout.width - 1, layout.centerLeft + (panel.left ?? 0)));
+    const desiredWidth = panel.width ?? layout.centerWidth;
+    const cardWidth = Math.max(1, Math.min(layout.width - cardLeft, desiredWidth));
+    const cardTop = Math.max(0, Math.min(layout.height - 1, layout.centerTop + panel.top));
+    const cardHeight = Math.max(1, Math.min(layout.height - cardTop, panel.height));
+    const headerHeight = panel.chrome === "ad-terminal" ? Math.max(3, Math.min(cardHeight - 2, panel.headerHeight ?? 3)) : 0;
+    const left = cardLeft + (panel.chrome === "ad-terminal" ? 1 : 0);
+    const top = cardTop + headerHeight + (panel.chrome === "ad-terminal" ? 1 : 0);
+    const width = Math.max(1, Math.min(layout.width - left, cardWidth - (panel.chrome === "ad-terminal" ? 2 : 0)));
+    const height = Math.max(1, Math.min(layout.height - top, cardHeight - headerHeight - (panel.chrome === "ad-terminal" ? 2 : 0)));
+    const paddingX = panel.paddingX ?? (panel.chrome === "ad-terminal" ? 5 : 2);
+    const paddingY = panel.paddingY ?? (panel.chrome === "ad-terminal" ? 2 : 1);
+    const contentWidth = Math.max(1, width - paddingX * 2 - 1);
+    renderable.visible = true;
+    renderable.left = left;
+    renderable.top = top;
+    renderable.width = width;
+    renderable.height = height;
+    renderable.zIndex = panel.zIndex ?? 6;
+    renderable.opacity = panel.opacity ?? 1;
+    renderable.backgroundColor = panel.chrome === "ad-terminal" ? TRANSPARENT2 : panelBackground(panel);
+    renderable.border = panel.chrome === "ad-terminal" ? false : panel.border ?? false;
+    renderable.borderColor = panelBorder(panel);
+    renderable.paddingX = paddingX;
+    renderable.paddingY = paddingY;
+    renderable.stickyScroll = panel.stickyScroll ?? false;
+    renderable.stickyStart = panel.stickyStart;
+    renderable.verticalScrollBar.visible = false;
+    renderable.horizontalScrollBar.visible = false;
+    if (renderable.__rigPanelId !== panel.id) {
+      renderable.__rigPanelId = panel.id;
+      renderable.scrollTo(0);
+    }
+    renderable.__rigTextLines.forEach((line, lineIndex) => {
+      applyFlowTextLine(line, panel.lines[lineIndex], contentWidth);
+    });
+  });
+}
+
+// packages/cli/src/app-opentui/render/type-bar.ts
+import { InputRenderable, InputRenderableEvents, TextRenderable as TextRenderable2 } from "@opentui/core";
+function createTypeBar(renderer) {
+  const prefix = new TextRenderable2(renderer, {
+    id: "rig-typebar-prefix",
+    content: " rig \u203A",
+    position: "absolute",
+    left: 0,
+    top: 0,
+    fg: RIG_UI.lime,
+    selectable: true
+  });
+  const input = new InputRenderable(renderer, {
+    id: "rig-typebar-input",
+    position: "absolute",
+    left: 7,
+    top: 0,
+    width: 40,
+    placeholder: "fleet \xB7 tasks \xB7 run next \xB7 help",
+    textColor: RIG_UI.ink,
+    cursorColor: RIG_UI.lime,
+    cursorStyle: { style: "block", blinking: false },
+    showCursor: true,
+    selectable: true
+  });
+  const footer = new TextRenderable2(renderer, {
+    id: "rig-footer",
+    content: "",
+    position: "absolute",
+    left: 0,
+    top: 1,
+    width: "100%",
+    fg: RIG_UI.ink4,
+    selectable: true
+  });
+  input.focus();
+  return { input, prefix, footer };
+}
+function positionTypeBar(renderables, input, footer, width, typeBarTop, footerTop) {
+  renderables.prefix.content = " rig \u203A";
+  renderables.prefix.top = typeBarTop;
+  renderables.input.top = typeBarTop;
+  renderables.input.left = 7;
+  renderables.input.width = Math.max(10, width - 9);
+  renderables.input.placeholder = input.placeholder;
+  renderables.input.showCursor = true;
+  renderables.footer.top = footerTop;
+  renderables.footer.width = "100%";
+  renderables.footer.content = formatFooter(footer, width);
+  if (!renderables.input.focused)
+    renderables.input.focus();
+}
+function hideTypeBar(renderables, height) {
+  renderables.prefix.content = "";
+  renderables.prefix.top = height + 1;
+  renderables.input.value = "";
+  renderables.input.placeholder = "";
+  renderables.input.top = height + 1;
+  renderables.input.left = 0;
+  renderables.input.width = 1;
+  renderables.input.blur();
+  renderables.footer.content = "";
+  renderables.footer.top = height + 1;
+}
+function bindTypeBar(renderables, handlers) {
+  renderables.input.on(InputRenderableEvents.INPUT, (value) => handlers.onInput(value));
+  renderables.input.on(InputRenderableEvents.ENTER, (value) => handlers.onEnter(value));
+}
+function formatFooter(footer, width) {
+  const parts = [
+    footer.project ? `project ${footer.project}` : null,
+    footer.server ? `server ${footer.server}` : null,
+    footer.auth ? `auth ${footer.auth}` : null,
+    footer.run ? `run ${footer.run}` : null,
+    footer.message ?? null
+  ].filter((part) => Boolean(part));
+  return ` ${truncateText(parts.join("  \xB7  "), Math.max(8, width - 2))}`;
+}
+
+// packages/cli/src/app-opentui/render/scene.ts
+function line(text, options = {}) {
+  return { text, ...options };
+}
+function blank() {
+  return { text: "" };
+}
+function center(text, fg = RIG_UI.ink2, bold = false) {
+  return { text, fg, bold, align: "center" };
+}
+function deckRow(input) {
+  const prefix = input.active ? "\u25B8" : " ";
+  const label = input.label.toUpperCase().padEnd(10);
+  return line(`${prefix} ${label} ${input.detail}`, {
+    fg: input.active ? RIG_UI.lime : RIG_UI.ink2,
+    bold: input.active,
+    selectableIndex: input.index,
+    activateOnClick: input.activateOnClick
+  });
+}
+function fitSceneLine(input, layout) {
+  const fitted = truncateText(input.text, layout.centerWidth);
+  return {
+    ...input,
+    text: alignText(fitted, layout.centerWidth, input.align ?? "left")
+  };
+}
+function fitSceneLines(lines, layout) {
+  return lines.slice(0, layout.centerHeight).map((entry) => fitSceneLine(entry, layout));
+}
+function makeSceneFrame(input) {
+  return input;
+}
+
+// packages/cli/src/app-opentui/drone.ts
+import { RGBA as RGBA3, StyledText, TextAttributes as TextAttributes3 } from "@opentui/core";
+var MINI_DRONE = [
+  "(!!!)   (!!!)",
+  "  \\%==%/  ",
+  "   %%?%%   ",
+  "  /%==%\\  ",
+  "(!!!)   (!!!)"
+];
+var LEAD_MARK = [
+  " .-=-. ",
+  "=%%?%%=",
+  " '-=-' "
+];
+var BLADE_FRAMES = ["---", "\\\\\\", "|||", "///"];
+var EYE_FRAMES = ["o", "@", "\u2022", "."];
+var COLOR = {
+  body: RGBA3.fromHex(RIG_UI.lime),
+  mini: RGBA3.fromHex(RIG_UI.limeDim),
+  rotor: RGBA3.fromHex(RIG_UI.cyan),
+  path: RGBA3.fromHex(RIG_UI.cyan),
+  eye: RGBA3.fromHex(RIG_UI.ink),
+  dim: RGBA3.fromHex(RIG_UI.ink4),
+  ink: RGBA3.fromHex(RIG_UI.ink2)
+};
+function bladeForTick(tick, phase = 0) {
+  return BLADE_FRAMES[(Math.floor(tick / 3) + phase) % BLADE_FRAMES.length];
+}
+function eyeForTick(tick, phase = 0) {
+  const pulse = Math.sin(tick * 0.09 + phase);
+  return pulse > 0.55 ? EYE_FRAMES[1] : pulse > 0.1 ? EYE_FRAMES[0] : pulse > -0.45 ? EYE_FRAMES[2] : EYE_FRAMES[3];
+}
+function chunk2(text, fg, bold = false, dim = false) {
+  let attributes = TextAttributes3.NONE;
+  if (bold)
+    attributes |= TextAttributes3.BOLD;
+  if (dim)
+    attributes |= TextAttributes3.DIM;
+  return { __isChunk: true, text, fg, ...attributes !== TextAttributes3.NONE ? { attributes } : {} };
+}
+function styledLine(text, colorFor) {
+  const chunks = [];
+  let run = "";
+  let runColor = null;
+  const flush = () => {
+    if (!run || !runColor)
+      return;
+    chunks.push(chunk2(run, COLOR[runColor], runColor === "body" || runColor === "eye", runColor === "dim"));
+    run = "";
+  };
+  for (const char of text) {
+    const next = colorFor(char);
+    if (next !== runColor) {
+      flush();
+      runColor = next;
+    }
+    run += char;
+  }
+  flush();
+  return new StyledText(chunks.length > 0 ? chunks : [chunk2("", COLOR.ink)]);
+}
+function droneColor(char) {
+  if (char === "?" || char === "o" || char === "@" || char === "\u2022")
+    return "eye";
+  if (char === "%" || char === "=")
+    return "mini";
+  if (char === "$")
+    return "body";
+  if (char === "(" || char === ")" || char === "/" || char === "\\" || char === "|" || char === "-")
+    return "rotor";
+  if (char === "\xB7" || char === "\u2022" || char === "'" || char === ".")
+    return "path";
+  if (char.trim() === "")
+    return "dim";
+  return "ink";
+}
+function motionColor(char) {
+  if (char === "\u25CF" || char === "\u25C6" || char === "\u25C9")
+    return "body";
+  if (char === "\u2022" || char === "\xB7" || char === "\u2500" || char === "\u2502" || char === "\u2571" || char === "\u2572" || char === "\u256D" || char === "\u256E" || char === "\u2570" || char === "\u256F")
+    return "path";
+  if (char === "\u258C" || char === "\u2590" || char === "\u2581" || char === "\u2594")
+    return "mini";
+  return droneColor(char);
+}
+function materializeDrone(lines, tick, phase = 0) {
+  const blade = bladeForTick(tick, phase);
+  const eye = eyeForTick(tick, phase);
+  return lines.map((line2) => line2.replaceAll("!!!", blade).replaceAll("?", eye));
+}
+function brandFleetLines(tick, align = "center") {
+  const left = materializeDrone(MINI_DRONE, tick, 0);
+  const right = materializeDrone(MINI_DRONE, tick, 2);
+  const lead = materializeDrone(LEAD_MARK, tick, 1);
+  const packet = ["\xB7", "\u2022", "\u25CF", "\u2022"][Math.floor(tick / 2) % 4];
+  const bridge = [
+    `    ${left[0]}       ${lead[0]}       ${right[0]}`,
+    `    ${left[1]}   \xB7\u2500\u2500${packet}\u2500\u2500\xB7   ${lead[1]}   \xB7\u2500\u2500${packet}\u2500\u2500\xB7   ${right[1]}`,
+    `    ${left[2]}  \xB7'       '${lead[2]}'       '\xB7  ${right[2]}`,
+    `    ${left[3]}       \u2572  signal bus  \u2571       ${right[3]}`,
+    `    ${left[4]}    \xB7\u2500\u2500\u2500${packet}\u2500\u2500\u2500\u2500\u2500\u2500${packet}\u2500\u2500\u2500\xB7    ${right[4]}`
+  ];
+  return bridge.map((text) => ({
+    text,
+    styledText: styledLine(text, motionColor),
+    fg: RIG_UI.limeDim,
+    align
+  }));
+}
+function errorDrone(tick) {
+  return brandFleetLines(tick).map((line2, index) => ({
+    ...line2,
+    fg: index % 2 === 0 ? RIG_UI.red : line2.fg
+  }));
+}
+
+// packages/cli/src/app-opentui/scenes/error.ts
+function renderErrorScene(state) {
+  const message = state.error?.message ?? "Unknown Rig app error";
+  const hint = state.error?.hint ?? "type main, help, or retry after fixing the issue";
+  return makeSceneFrame({
+    scene: "error",
+    title: "Rig error",
+    lines: [
+      ...errorDrone(state.tick).slice(2, 16),
+      blank(),
+      center("DRONE SIGNAL DEGRADED", RIG_UI.red, true),
+      center(message, RIG_UI.ink2),
+      blank(),
+      center(hint, RIG_UI.limeDim)
+    ],
+    typeBarPlaceholder: hint,
+    live: true
+  });
+}
+
+// packages/cli/src/app-opentui/scenes/help.ts
+var COMMANDS = [
+  ["runs", "show runs"],
+  ["tasks", "show task source"],
+  ["type in Runs", "search loaded runs"],
+  ["type in Tasks", "search loaded tasks"],
+  ["tasks open", "filter to open tasks"],
+  ["tasks all", "show every task returned by the source"],
+  ["tasks mine", "show tasks assigned to @me"],
+  ["tasks blocked", "show blocked work"],
+  ["tasks closed", "show closed work"],
+  ["tasks sort priority", "rank by priority"],
+  ["tasks sort recency", "rank by update time"],
+  ["tasks sort status", "group by status"],
+  ["run <task-id>", "dispatch selected task id"],
+  ["run next", "dispatch next runnable task"],
+  ["attach <run>", "open bundled Pi for a run"],
+  ["tab / \u2192", "next screen"],
+  ["\u2190", "previous screen"],
+  ["\u2191 \u2193", "move selection in Runs/Tasks"],
+  ["j k", "move selection outside search-first list screens"],
+  ["enter", "activate selected row"],
+  ["mouse wheel", "scroll panel under cursor"],
+  ["ctrl-]", "detach from embedded Pi"],
+  ["ctrl-c / q", "exit"]
+];
+function panelWidth(layout) {
+  return layout?.centerWidth ?? 100;
+}
+function panelHeight(layout, top = 3) {
+  return Math.max(4, (layout?.centerHeight ?? 24) - top);
+}
+function clip(value, width) {
+  if (width <= 0)
+    return "";
+  return value.length <= width ? value : `${value.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function commandRow(width, label, detail, index) {
+  const keyWidth = Math.min(22, Math.max(12, Math.floor(width * 0.28)));
+  const key = clip(label, keyWidth).padEnd(keyWidth);
+  return line(`${key}  ${clip(detail, Math.max(8, width - keyWidth - 4))}`, { fg: index < 3 ? RIG_UI.ink : RIG_UI.ink2 });
+}
+function unsupportedCommand(state) {
+  const value = state.intent.action.payload?.unsupported ?? state.intent.action.payload?.unknown;
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function renderHelpScene(state, layout) {
+  const width = panelWidth(layout);
+  const unsupported = unsupportedCommand(state);
+  const panelTop = 0;
+  const panelLines = [
+    ...unsupported ? [
+      line(`${unsupported} uses the plain CLI path.`, { fg: RIG_UI.yellow, bold: true }),
+      line("Exit and rerun with RIG_PLAIN=1 if you want legacy text output.", { fg: RIG_UI.ink3 }),
+      line("", { fg: RIG_UI.ink3 })
+    ] : [],
+    line("COMMAND                 ACTION", { fg: RIG_UI.ink3, bold: true }),
+    line("", { fg: RIG_UI.ink3 }),
+    ...COMMANDS.map(([label, detail], index) => commandRow(width - 6, label, detail, index))
+  ];
+  return makeSceneFrame({
+    scene: "help",
+    title: "Rig help",
+    lines: [
+      line("", { fg: RIG_UI.ink4 }),
+      line("   rig help", { fg: RIG_UI.ink3 })
+    ],
+    panels: [{
+      id: "help-reference",
+      top: panelTop,
+      width,
+      height: panelHeight(layout, panelTop),
+      lines: panelLines,
+      backgroundColor: RIG_UI.panel,
+      backgroundAlpha: 184,
+      opacity: 1,
+      border: false,
+      chrome: "ad-terminal",
+      headerText: "rig help",
+      headerHeight: 3,
+      paddingX: layout?.compact ? 2 : 3,
+      paddingY: 1
+    }],
+    typeBarPlaceholder: "runs \xB7 tasks \xB7 help \xB7 attach <run>",
+    footer: { message: "help" },
+    live: true
+  });
+}
+
+// packages/cli/src/app-opentui/scenes/main.ts
+var CONFIGURED_OPTIONS = [
+  ["runs", "run list and attach"],
+  ["tasks", "task source and dispatch"],
+  ["help", "command reference"]
+];
+function renderMainScene(state) {
+  const configured = state.data.projectConfigured === true;
+  const selected = configured ? Math.max(0, Math.min(CONFIGURED_OPTIONS.length - 1, state.selection.index)) : Math.max(0, Math.min(1, state.selection.index));
+  const lines = [
+    center(configured ? "rig" : "rig setup", RIG_UI.ink, true),
+    center(configured ? "runs \xB7 tasks \xB7 help" : "initialize this repo", RIG_UI.ink3),
+    blank()
+  ];
+  if (!configured) {
+    lines.push(deckRow({ label: "init", detail: "create config and server link", index: 0, active: selected === 0 }), deckRow({ label: "help", detail: "show command reference", index: 1, active: selected === 1 }), blank(), line("enter opens selection", { fg: RIG_UI.ink4, align: "center" }));
+  } else {
+    CONFIGURED_OPTIONS.forEach(([label, detail], index) => {
+      lines.push(deckRow({ label, detail, index, active: index === selected }));
+    });
+    lines.push(blank(), line(`  ${state.actionLabel ?? "ready"}`, { fg: state.status === "action" ? RIG_UI.cyan : RIG_UI.ink4 }));
+  }
+  return makeSceneFrame({
+    scene: "main",
+    title: "Rig",
+    lines,
+    typeBarPlaceholder: configured ? "runs \xB7 tasks \xB7 help" : "init \xB7 help",
+    live: true
+  });
+}
+
+// packages/cli/src/app-opentui/pi-pty-host.ts
+import { fileURLToPath } from "url";
+import { basename } from "path";
+import { RGBA as RGBA4, StyledText as StyledText2, TextAttributes as TextAttributes4 } from "@opentui/core";
+import { Terminal as XtermTerminal } from "@xterm/headless";
+var MIN_COLS = 40;
+var MIN_ROWS = 12;
+var MAX_ROWS = 300;
+var MAX_SNAPSHOT_LINES = 1200;
+var fallbackChildScriptPath = fileURLToPath(new URL("./pi-host-child.ts", import.meta.url));
+var activeHost = null;
+function clampCols(cols) {
+  return Math.max(MIN_COLS, Math.trunc(cols || 100));
+}
+function clampRows(rows) {
+  return Math.max(MIN_ROWS, Math.min(MAX_ROWS, Math.trunc(rows || 35)));
+}
+var XTERM_COLOR_MODE_INDEXED_16 = 16777216;
+var XTERM_COLOR_MODE_INDEXED_256 = 33554432;
+var XTERM_COLOR_MODE_RGB = 50331648;
+function rgbaFromXtermColor(mode, value) {
+  if (mode === 1 || mode === 2 || mode === XTERM_COLOR_MODE_INDEXED_16 || mode === XTERM_COLOR_MODE_INDEXED_256) {
+    return RGBA4.fromIndex(value);
+  }
+  if (mode === 3 || mode === XTERM_COLOR_MODE_RGB) {
+    return RGBA4.fromInts(value >> 16 & 255, value >> 8 & 255, value & 255);
+  }
+  return;
+}
+function textAttributesFromCell(cell) {
+  let attributes = TextAttributes4.NONE;
+  if (cell.isBold())
+    attributes |= TextAttributes4.BOLD;
+  if (cell.isDim())
+    attributes |= TextAttributes4.DIM;
+  if (cell.isItalic())
+    attributes |= TextAttributes4.ITALIC;
+  if (cell.isUnderline())
+    attributes |= TextAttributes4.UNDERLINE;
+  if (cell.isBlink())
+    attributes |= TextAttributes4.BLINK;
+  if (cell.isInverse())
+    attributes |= TextAttributes4.INVERSE;
+  if (cell.isInvisible())
+    attributes |= TextAttributes4.HIDDEN;
+  if (cell.isStrikethrough())
+    attributes |= TextAttributes4.STRIKETHROUGH;
+  return attributes;
+}
+function sameRgba(a, b) {
+  if (!a && !b)
+    return true;
+  return Boolean(a && b && a.equals(b));
+}
+function sameStyle(a, b) {
+  return sameRgba(a.fg, b.fg) && sameRgba(a.bg, b.bg) && (a.attributes ?? 0) === (b.attributes ?? 0);
+}
+function styleFromCell(cell) {
+  return {
+    fg: rgbaFromXtermColor(cell.getFgColorMode(), cell.getFgColor()),
+    bg: rgbaFromXtermColor(cell.getBgColorMode(), cell.getBgColor()),
+    attributes: textAttributesFromCell(cell)
+  };
+}
+function lineToStyledText(line2, cols) {
+  if (!line2)
+    return new StyledText2([{ __isChunk: true, text: "" }]);
+  const chunks = [];
+  let run = "";
+  let runStyle = null;
+  const flush = () => {
+    if (!run)
+      return;
+    chunks.push({
+      __isChunk: true,
+      text: run,
+      ...runStyle?.fg ? { fg: runStyle.fg } : {},
+      ...runStyle?.bg ? { bg: runStyle.bg } : {},
+      ...(runStyle?.attributes ?? 0) !== 0 ? { attributes: runStyle.attributes } : {}
+    });
+    run = "";
+  };
+  for (let index = 0;index < cols; index += 1) {
+    const cell = line2.getCell(index);
+    if (!cell) {
+      if (runStyle !== null)
+        flush();
+      runStyle = null;
+      run += " ";
+      continue;
+    }
+    if (cell.getWidth() === 0)
+      continue;
+    const style = styleFromCell(cell);
+    if (!runStyle || !sameStyle(runStyle, style)) {
+      flush();
+      runStyle = style;
+    }
+    run += cell.getChars() || " ";
+  }
+  flush();
+  return new StyledText2(chunks.length > 0 ? chunks : [{ __isChunk: true, text: "" }]);
+}
+function childCommandPrefix() {
+  const execName = basename(process.execPath).toLowerCase();
+  const currentEntry = process.argv[1];
+  if ((execName === "bun" || execName === "bun.exe") && currentEntry) {
+    return [process.execPath, currentEntry, "__opentui-pi-host"];
+  }
+  if (currentEntry)
+    return [process.execPath, "__opentui-pi-host"];
+  return [process.execPath, fallbackChildScriptPath];
+}
+function withEnv(base) {
+  const env = {};
+  for (const [key, value] of Object.entries(base ?? process.env)) {
+    if (key === "RIG_PLAIN" || key === "RIG_CLI_PLAIN_HELP")
+      continue;
+    if (typeof value === "string")
+      env[key] = value;
+  }
+  return {
+    ...env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    FORCE_COLOR: env.FORCE_COLOR ?? "1",
+    RIG_OPENTUI_PI_HOST: "1"
+  };
+}
+function getActivePiHost() {
+  return activeHost && !activeHost.disposed ? activeHost : null;
+}
+function stopActivePiHost(reason = "detach") {
+  activeHost?.dispose(reason);
+  activeHost = null;
+}
+
+class PiPtyHost {
+  runId;
+  projectRoot;
+  onSnapshot;
+  onExit;
+  onError;
+  terminal;
+  disposables = [];
+  decoder = new TextDecoder("utf-8");
+  proc = null;
+  pty = null;
+  status = "starting";
+  cols;
+  rows;
+  message = "starting bundled Pi";
+  exitCode;
+  signal;
+  notifyTimer = null;
+  _disposed = false;
+  constructor(options) {
+    this.runId = options.runId;
+    this.projectRoot = options.projectRoot;
+    this.cols = clampCols(options.cols);
+    this.rows = clampRows(options.rows);
+    this.onSnapshot = options.onSnapshot;
+    this.onExit = options.onExit;
+    this.onError = options.onError;
+    this.terminal = new XtermTerminal({
+      allowProposedApi: true,
+      cols: this.cols,
+      rows: this.rows,
+      scrollback: 5000
+    });
+    this.registerTerminalResponders();
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  get snapshot() {
+    return this.createSnapshot();
+  }
+  async start() {
+    if (this._disposed)
+      throw new Error("Pi PTY host is disposed.");
+    if (typeof Bun.Terminal !== "function") {
+      throw new Error("Bun native PTY is unavailable in this runtime. Rig OpenTUI Pi host requires Bun.Terminal.");
+    }
+    const spawnOptions = {
+      cwd: this.projectRoot,
+      env: withEnv(process.env),
+      terminal: {
+        cols: this.cols,
+        rows: this.rows,
+        name: "xterm-256color",
+        data: (_terminal, data) => this.handlePtyData(data)
+      }
+    };
+    const proc = Bun.spawn([
+      ...childCommandPrefix(),
+      "--run-id",
+      this.runId,
+      "--project-root",
+      this.projectRoot
+    ], spawnOptions);
+    if (!proc.terminal)
+      throw new Error("Bun did not attach a terminal to the bundled Pi child process.");
+    this.proc = proc;
+    this.pty = proc.terminal;
+    this.status = "running";
+    this.message = "bundled Pi running inside Rig";
+    this.emitSnapshotSoon(0);
+    proc.exited.then((exitCode) => {
+      if (this._disposed)
+        return;
+      this.status = exitCode === 0 ? "exited" : "failed";
+      this.exitCode = exitCode;
+      this.signal = null;
+      this.message = exitCode === 0 ? "bundled Pi exited" : `bundled Pi exited with code ${exitCode}`;
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onExit?.(snapshot);
+      if (activeHost === this)
+        activeHost = null;
+      this.dispose("exit", { kill: false, notify: false });
+    }).catch((error) => {
+      if (this._disposed)
+        return;
+      this.status = "failed";
+      this.message = error instanceof Error ? error.message : String(error);
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onError?.(error, snapshot);
+      if (activeHost === this)
+        activeHost = null;
+      this.dispose("error", { kill: false, notify: false });
+    });
+  }
+  write(data) {
+    if (this._disposed || !this.pty)
+      return;
+    try {
+      this.pty.write(data);
+    } catch (error) {
+      this.status = "failed";
+      this.message = error instanceof Error ? error.message : String(error);
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onError?.(error, snapshot);
+    }
+  }
+  resize(cols, rows) {
+    const nextCols = clampCols(cols);
+    const nextRows = clampRows(rows);
+    if (nextCols === this.cols && nextRows === this.rows)
+      return;
+    this.cols = nextCols;
+    this.rows = nextRows;
+    this.terminal.resize(nextCols, nextRows);
+    try {
+      this.pty?.resize(nextCols, nextRows);
+    } catch {}
+    this.emitSnapshotSoon(0);
+  }
+  detach() {
+    this.dispose("detach");
+    return this.createSnapshot("detached from bundled Pi");
+  }
+  dispose(reason = "dispose", options = {}) {
+    if (this._disposed)
+      return;
+    this._disposed = true;
+    if (this.notifyTimer)
+      clearTimeout(this.notifyTimer);
+    this.notifyTimer = null;
+    for (const disposable of this.disposables.splice(0)) {
+      try {
+        disposable.dispose();
+      } catch {}
+    }
+    if (options.kill !== false) {
+      try {
+        this.proc?.kill("SIGTERM");
+      } catch {}
+    }
+    try {
+      this.pty?.close();
+    } catch {}
+    try {
+      this.terminal.dispose();
+    } catch {}
+    if (activeHost === this)
+      activeHost = null;
+    if (options.notify) {
+      this.message = reason;
+      this.onSnapshot?.(this.createSnapshot(reason));
+    }
+  }
+  handlePtyData(data) {
+    if (this._disposed)
+      return;
+    const text = this.decoder.decode(data, { stream: true });
+    this.respondToRawTerminalQueries(text);
+    this.terminal.write(data, () => this.emitSnapshotSoon());
+  }
+  emitSnapshotSoon(delayMs = 16) {
+    if (this._disposed || this.notifyTimer)
+      return;
+    this.notifyTimer = setTimeout(() => {
+      this.notifyTimer = null;
+      if (this._disposed)
+        return;
+      this.onSnapshot?.(this.createSnapshot());
+    }, delayMs);
+  }
+  createSnapshot(message = this.message) {
+    const buffer = this.terminal.buffer.active;
+    const end = buffer.length;
+    const start = Math.max(0, end - MAX_SNAPSHOT_LINES);
+    const lines = [];
+    const styledLines = [];
+    for (let row = start;row < end; row += 1) {
+      const line2 = buffer.getLine(row);
+      lines.push((line2?.translateToString(false) ?? "").slice(0, this.cols));
+      styledLines.push(lineToStyledText(line2, this.cols));
+    }
+    while (lines.length < this.rows) {
+      lines.push("");
+      styledLines.push(new StyledText2([{ __isChunk: true, text: "" }]));
+    }
+    return {
+      runId: this.runId,
+      status: this.status,
+      cols: this.cols,
+      rows: this.rows,
+      lines,
+      styledLines,
+      message,
+      ...this.exitCode !== undefined ? { exitCode: this.exitCode } : {},
+      ...this.signal !== undefined ? { signal: this.signal } : {}
+    };
+  }
+  registerTerminalResponders() {
+    this.disposables.push(this.terminal.parser.registerCsiHandler({ final: "c" }, (params) => {
+      if (params.length === 0 || params[0] === 0)
+        this.write("\x1B[?62;22c");
+      return false;
+    }));
+    this.disposables.push(this.terminal.parser.registerCsiHandler({ prefix: ">", final: "c" }, (params) => {
+      if (params.length === 0 || params[0] === 0)
+        this.write("\x1B[>0;0;0c");
+      return false;
+    }));
+    this.disposables.push(this.terminal.parser.registerCsiHandler({ final: "n" }, (params) => {
+      if (params[0] === 5) {
+        this.write("\x1B[0n");
+      } else if (params[0] === 6) {
+        const row = this.terminal.buffer.active.cursorY + 1;
+        const col = this.terminal.buffer.active.cursorX + 1;
+        this.write(`\x1B[${row};${col}R`);
+      }
+      return false;
+    }));
+  }
+  respondToRawTerminalQueries(text) {
+    if (!text)
+      return;
+    const decrqm = /\x1b\[\?(\d+)\$p/g;
+    let match;
+    while ((match = decrqm.exec(text)) !== null) {
+      this.write(`\x1B[?${match[1]};2$y`);
+    }
+  }
+}
+
+// packages/cli/src/app-opentui/runtime.ts
+var MAX_SCENE_LINES = 200;
+var MAX_SCENE_PANELS = 5;
+var FRAME_MS = 16;
+var ANIMATION_SLOWDOWN = 3;
+var PRIMARY_NAV = [
+  { scene: "fleet", argv: ["runs"], label: "Opening runs" },
+  { scene: "tasks", argv: ["tasks"], label: "Opening tasks" },
+  { scene: "help", argv: ["help"], label: "Opening help" }
+];
+function primaryNavIntent(scene) {
+  const entry = PRIMARY_NAV.find((item) => item.scene === scene) ?? PRIMARY_NAV[0];
+  return { scene: entry.scene, argv: entry.argv, action: { kind: entry.scene === "help" ? "none" : "refresh", label: entry.label } };
+}
+function nextPrimaryScene(current, delta) {
+  const currentIndex = PRIMARY_NAV.findIndex((entry) => entry.scene === current);
+  const index = currentIndex < 0 ? 0 : currentIndex;
+  return PRIMARY_NAV[(index + delta + PRIMARY_NAV.length) % PRIMARY_NAV.length].scene;
+}
+function detectProjectConfigured(projectRoot) {
+  return [
+    "rig.config.ts",
+    "rig.config.json",
+    ".rig/state/connection.json",
+    "rig/task-config.json"
+  ].some((relative) => existsSync(resolve(projectRoot, relative)));
+}
+function defaultSceneRenderer(state) {
+  const title = state.scene;
+  return {
+    scene: state.scene,
+    title,
+    lines: [
+      { text: title.toUpperCase(), fg: RIG_UI.ink, bold: true, align: "center" },
+      { text: state.actionLabel ?? "adapter scene pending", fg: RIG_UI.limeDim, align: "center" },
+      { text: "support state", fg: RIG_UI.ink3, align: "center" },
+      { text: "runs \xB7 tasks \xB7 help", fg: RIG_UI.ink4, align: "center" }
+    ],
+    typeBarPlaceholder: "runs \xB7 tasks \xB7 help",
+    live: false
+  };
+}
+function rendererForScene(scene, extra) {
+  if (extra?.[scene])
+    return extra[scene];
+  switch (scene) {
+    case "main":
+      return renderMainScene;
+    case "help":
+      return renderHelpScene;
+    case "error":
+      return renderErrorScene;
+    default:
+      return defaultSceneRenderer;
+  }
+}
+function requestRender(renderer) {
+  renderer.requestRender?.();
+}
+function recordArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+}
+function stringField(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+      return String(value);
+  }
+  return;
+}
+function mainSelectableItems(_state) {
+  return [
+    { id: "runs", label: "runs", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }, message: "selected runs" },
+    { id: "tasks", label: "tasks", intent: { scene: "tasks", argv: ["tasks"], action: { kind: "refresh", label: "Opening tasks" } }, message: "selected tasks" },
+    { id: "help", label: "help", intent: { scene: "help", argv: ["help"], action: { kind: "none", label: "Opening help" } }, message: "selected help" }
+  ];
+}
+function fleetSelectableItems(state) {
+  const fleet = state.data.fleet;
+  const runs = fleet && typeof fleet === "object" && !Array.isArray(fleet) ? recordArray(fleet.runs) : [];
+  return filterRunsForSearch(runs, listSearchQuery(state)).flatMap((run) => {
+    const runId = stringField(run, ["runId", "id"]);
+    if (!runId)
+      return [];
+    const title = stringField(run, ["title", "taskTitle", "taskId"]) ?? "run";
+    return [{ id: runId, label: title, data: { selectedRunId: runId }, intent: { scene: "handoff", argv: ["attach", runId], action: { kind: "run-attach", payload: { runId }, label: `Attach Pi ${runId.slice(0, 8)}` } }, message: `attach Pi to ${runId.slice(0, 8)}` }];
+  });
+}
+function taskSelectableItems(state) {
+  const tasks = state.data.tasks;
+  const records = tasks && typeof tasks === "object" && !Array.isArray(tasks) ? recordArray(tasks.records) : [];
+  return filterTasksForSearch(records, listSearchQuery(state)).flatMap((task) => {
+    const taskId = stringField(task, ["id", "taskId", "number"]);
+    if (!taskId)
+      return [];
+    const title = stringField(task, ["title", "name", "summary"]) ?? "task";
+    return [{ id: taskId, label: title, data: { selectedTaskId: taskId }, intent: { scene: "tasks", argv: ["run", taskId], action: { kind: "task-run-id", payload: { task: taskId }, label: `Dispatching ${taskId}` } }, message: `dispatch task ${taskId}` }];
+  });
+}
+function selectedRunId(state) {
+  const selected = state.data.selectedRunId;
+  if (typeof selected === "string" && selected.trim())
+    return selected.trim();
+  const detail = state.data.runDetail;
+  if (detail && typeof detail === "object" && !Array.isArray(detail)) {
+    const runId = detail.runId;
+    if (typeof runId === "string" && runId.trim())
+      return runId.trim();
+  }
+  const latest = state.data.latestSubmittedRun;
+  if (latest && typeof latest === "object" && !Array.isArray(latest)) {
+    const runId = latest.runId;
+    if (typeof runId === "string" && runId.trim())
+      return runId.trim();
+  }
+  return;
+}
+function inboxSelectableItems(state) {
+  const inbox = state.data.inbox;
+  if (!inbox || typeof inbox !== "object" || Array.isArray(inbox))
+    return [];
+  const record = inbox;
+  const approvals = recordArray(record.approvals).map((entry) => ({ ...entry, kind: "approvals" }));
+  const inputs = recordArray(record.inputs).map((entry) => ({ ...entry, kind: "inputs" }));
+  return [...approvals, ...inputs].flatMap((item) => {
+    const requestId = stringField(item, ["requestId", "id"]);
+    if (!requestId)
+      return [];
+    const kind = item.kind === "inputs" ? "answer" : "approve/reject";
+    return [{ id: requestId, label: kind, data: { selectedInboxRequestId: requestId }, message: `selected request ${requestId}; type ${kind} ${requestId}` }];
+  });
+}
+function runDetailSelectableItems(state) {
+  const runId = selectedRunId(state);
+  if (!runId)
+    return [];
+  return [
+    { id: "attach", label: "attach", intent: { scene: "handoff", argv: ["attach", runId], action: { kind: "run-attach", payload: { runId }, label: `Attach Pi ${runId.slice(0, 8)}` } }, message: "attach real bundled Pi" },
+    { id: "stop", label: "stop", intent: { scene: "run-detail", argv: ["stop", runId], action: { kind: "run-stop", payload: { runId }, label: `Stop ${runId.slice(0, 8)}` } }, message: "request stop" },
+    { id: "fleet", label: "fleet", intent: { scene: "fleet", argv: ["fleet"], action: { kind: "refresh", label: "Opening fleet" } }, message: "back to fleet" }
+  ];
+}
+function selectableItems(state) {
+  switch (state.scene) {
+    case "main":
+      return mainSelectableItems(state);
+    case "fleet":
+      return fleetSelectableItems(state);
+    case "tasks":
+      return taskSelectableItems(state);
+    case "inbox":
+      return inboxSelectableItems(state);
+    case "run-detail":
+      return runDetailSelectableItems(state);
+    default:
+      return [];
+  }
+}
+function renderedItemsOrStateItems(state, renderedItems) {
+  return renderedItems && renderedItems.length > 0 ? [...renderedItems] : selectableItems(state);
+}
+function selectedRenderedItemId(state) {
+  if (state.scene === "fleet") {
+    const selected = state.data.selectedRunId;
+    return typeof selected === "string" && selected.trim() ? selected.trim() : undefined;
+  }
+  if (state.scene === "tasks") {
+    const selected = state.data.selectedTaskId;
+    return typeof selected === "string" && selected.trim() ? selected.trim() : undefined;
+  }
+  return;
+}
+function effectiveRenderedIndex(state, items) {
+  if (items.length === 0)
+    return -1;
+  const selectedId = selectedRenderedItemId(state);
+  if (selectedId) {
+    const renderedIndex = items.findIndex((item) => item.id === selectedId);
+    if (renderedIndex >= 0)
+      return renderedIndex;
+    if (state.scene === "fleet" || state.scene === "tasks")
+      return 0;
+  }
+  return Math.max(0, Math.min(items.length - 1, state.selection.index));
+}
+function selectIndex(store, index, renderedItems) {
+  const state = store.getState();
+  const items = renderedItemsOrStateItems(state, renderedItems);
+  if (items.length === 0)
+    return false;
+  const next = Math.max(0, Math.min(items.length - 1, index));
+  const item = items[next];
+  store.patch({
+    selection: { index: next, count: items.length },
+    ...item.data ? { data: item.data } : {},
+    typeBar: { message: item.message ?? item.label }
+  });
+  return true;
+}
+function moveSelection(store, delta, renderedItems) {
+  const state = store.getState();
+  const items = renderedItemsOrStateItems(state, renderedItems);
+  const current = effectiveRenderedIndex(state, items);
+  return current >= 0 && selectIndex(store, current + delta, items);
+}
+async function activateSelection(runtime, renderedItems) {
+  const state = runtime.getState();
+  const items = renderedItemsOrStateItems(state, renderedItems);
+  const index = effectiveRenderedIndex(state, items);
+  if (index < 0)
+    return false;
+  const item = items[index];
+  if (item.data)
+    runtime.patchState({ data: item.data });
+  if (item.intent) {
+    await runtime.runIntent(item.intent);
+    return true;
+  }
+  runtime.patchState({ typeBar: { message: item.message ?? item.label } });
+  return true;
+}
+async function launchRigOpenTuiApp(options) {
+  const initialState = createInitialAppState({
+    ...options,
+    projectConfigured: options.projectConfigured ?? detectProjectConfigured(options.projectRoot)
+  });
+  const store = createAppStore(initialState);
+  const events = createAppEventBus();
+  let renderer = null;
+  let graphics = null;
+  let imageVisuals = null;
+  const scrollPanels = [];
+  let typeBar = null;
+  const textLines = [];
+  let tickTimer = null;
+  let destroyed = false;
+  let runnerPromise = null;
+  let renderedSelectableItems = [];
+  const emitAsyncError = (label, error) => {
+    const normalized = normalizeError(error);
+    events.emit({ type: "action.failed", label, message: normalized.message, hint: normalized.hint, cause: normalized.cause });
+  };
+  const runAppAction = (label, action) => {
+    action().catch((error) => emitAsyncError(label, error));
+  };
+  const runtime = {
+    getState: () => store.getState(),
+    patchState: (patch) => store.patch(patch),
+    emit: (event) => events.emit(event),
+    setScene: (scene, intent2) => events.emit({ type: "scene.change", scene, ...intent2 ? { intent: intent2 } : {} }),
+    runIntent: async (nextIntent) => {
+      events.emit({ type: "scene.change", scene: nextIntent.scene, intent: nextIntent });
+      if (nextIntent.action.kind !== "none" && nextIntent.action.kind !== "navigate") {
+        events.emit({ type: "action.started", label: nextIntent.action.label ?? nextIntent.action.kind, optimistic: { lastIntent: nextIntent } });
+      }
+      let handled = false;
+      for (const adapter of options.adapters ?? []) {
+        const result = await adapter.handleIntent?.(runtime, nextIntent);
+        handled = handled || result === true;
+      }
+      if (!handled && nextIntent.action.kind !== "none" && nextIntent.action.kind !== "navigate") {
+        events.emit({
+          type: "action.progress",
+          label: nextIntent.action.label ?? nextIntent.action.kind,
+          detail: "adapter pending",
+          data: { lastIntent: nextIntent }
+        });
+      }
+    },
+    getRunnerContext: async () => {
+      if (!options.initializeRuntime)
+        throw new Error("Rig runtime initializer was not provided to the OpenTUI app.");
+      runnerPromise ??= options.initializeRuntime();
+      return runnerPromise;
+    },
+    suspend: () => renderer?.suspend(),
+    resume: () => {
+      renderer?.resume();
+      if (renderer && !destroyed)
+        renderedSelectableItems = renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, textLines, store.getState(), options.sceneRenderers);
+    },
+    destroy: () => renderer?.destroy()
+  };
+  events.subscribe((event) => store.patch(reduceAppEvent(store.getState(), event)));
+  store.subscribe(() => {
+    if (!destroyed && renderer)
+      renderedSelectableItems = renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, textLines, store.getState(), options.sceneRenderers);
+  });
+  try {
+    renderer = await createCliRenderer({
+      screenMode: "alternate-screen",
+      exitOnCtrlC: false,
+      targetFps: 60,
+      maxFps: 60,
+      useMouse: true,
+      autoFocus: false,
+      useKittyKeyboard: {
+        disambiguate: true,
+        alternateKeys: true,
+        events: false
+      },
+      consoleMode: "disabled",
+      openConsoleOnError: false,
+      backgroundColor: "transparent"
+    });
+    renderer.setTerminalTitle?.("Rig \u2014 operator cockpit");
+    const layout = computeStageLayout(renderer.width, renderer.height);
+    imageVisuals = forceModernImageVisuals() ? new ImageVisualLayer(process.stdout) : null;
+    if (imageVisuals?.enabled) {
+      renderer.setFrameCallback(async () => {
+        imageVisuals?.flush();
+      });
+    }
+    if (!imageVisuals?.enabled) {
+      graphics = createGraphicsLayer(renderer, layout);
+      renderer.root.add(graphics);
+    }
+    for (let index = 0;index < MAX_SCENE_PANELS; index += 1) {
+      const panel = createScrollPanelLayer(renderer, `rig-scroll-panel-${index}`, (line2) => {
+        const selectableIndex = line2.selectableIndex;
+        if (selectableIndex === undefined)
+          return;
+        selectIndex(store, selectableIndex, renderedSelectableItems);
+      });
+      scrollPanels.push(panel);
+      renderer.root.add(panel);
+    }
+    for (let index = 0;index < MAX_SCENE_LINES; index += 1) {
+      const textLine = createTextLine(renderer, `rig-scene-line-${index}`, index, (line2) => {
+        const selectableIndex = line2.selectableIndex;
+        if (selectableIndex === undefined)
+          return;
+        selectIndex(store, selectableIndex, renderedSelectableItems);
+      });
+      textLines.push(textLine);
+      renderer.root.add(textLine);
+    }
+    typeBar = createTypeBar(renderer);
+    renderer.root.add(typeBar.prefix);
+    renderer.root.add(typeBar.input);
+    renderer.root.add(typeBar.footer);
+    bindTypeBar(typeBar, {
+      onInput(value) {
+        const scene = store.getState().scene;
+        events.emit({
+          type: "typebar.patch",
+          typeBar: {
+            value,
+            ...isListSearchScene(scene) ? { message: value.trim() ? `search ${JSON.stringify(value.trim())}` : undefined } : {}
+          }
+        });
+      },
+      onEnter(value) {
+        const scene = store.getState().scene;
+        if (isListSearchScene(scene) && value.trim()) {
+          if (renderedSelectableItems.length === 0) {
+            events.emit({ type: "typebar.patch", typeBar: { message: "no search match" } });
+            return;
+          }
+          const snapshot = renderedSelectableItems;
+          typeBar?.input && (typeBar.input.value = "");
+          events.emit({ type: "typebar.patch", typeBar: { value: "" } });
+          runAppAction("Activate search result", () => activateSelection(runtime, snapshot));
+          return;
+        }
+        typeBar?.input && (typeBar.input.value = "");
+        events.emit({ type: "typebar.patch", typeBar: { value: "" } });
+        if (value.trim() === "") {
+          runAppAction("Activate selection", () => activateSelection(runtime, renderedSelectableItems));
+          return;
+        }
+        runAppAction("Run command", () => runtime.runIntent(intentFromTypeBar(value)));
+      }
+    });
+    renderer.keyInput.on("keypress", (key) => {
+      const host = getActivePiHost();
+      if (host && store.getState().scene === "handoff") {
+        if (key.ctrl && key.name === "]") {
+          stopActivePiHost("operator detach");
+          events.emit({ type: "typebar.patch", typeBar: { value: "", message: "detached from Pi" } });
+          runAppAction("Opening runs", () => runtime.runIntent({ scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }));
+          return;
+        }
+        const sequence = key.raw || key.sequence;
+        if (sequence)
+          host.write(sequence);
+        if (typeBar)
+          typeBar.input.value = "";
+        return;
+      }
+      if (key.ctrl && key.name === "c") {
+        renderer?.destroy();
+        return;
+      }
+      const currentScene = store.getState().scene;
+      const searchScene = isListSearchScene(currentScene);
+      const inputValue = typeBar?.input.value ?? "";
+      const typeBarEmpty = inputValue.trim() === "";
+      if (typeBarEmpty && (key.name === "right" || key.name === "tab")) {
+        runAppAction("Navigate", () => runtime.runIntent(primaryNavIntent(nextPrimaryScene(store.getState().scene, 1))));
+        return;
+      }
+      if (typeBarEmpty && key.name === "left") {
+        runAppAction("Navigate", () => runtime.runIntent(primaryNavIntent(nextPrimaryScene(store.getState().scene, -1))));
+        return;
+      }
+      if (!searchScene && typeBarEmpty && key.name === "r") {
+        runAppAction("Opening runs", () => runtime.runIntent(primaryNavIntent("fleet")));
+        return;
+      }
+      if (!searchScene && typeBarEmpty && key.name === "t") {
+        runAppAction("Opening tasks", () => runtime.runIntent(primaryNavIntent("tasks")));
+        return;
+      }
+      if (!searchScene && typeBarEmpty && (key.name === "h" || key.sequence === "?")) {
+        runAppAction("Opening help", () => runtime.runIntent(primaryNavIntent("help")));
+        return;
+      }
+      if (searchScene && key.name === "up" || !searchScene && typeBarEmpty && (key.name === "up" || key.name === "k")) {
+        if (moveSelection(store, -1, renderedSelectableItems))
+          return;
+      }
+      if (searchScene && key.name === "down" || !searchScene && typeBarEmpty && (key.name === "down" || key.name === "j")) {
+        if (moveSelection(store, 1, renderedSelectableItems))
+          return;
+      }
+      if (typeBarEmpty && (key.name === "return" || key.name === "enter")) {
+        runAppAction("Activate selection", () => activateSelection(runtime, renderedSelectableItems));
+        return;
+      }
+      if (!searchScene && key.name === "q" && typeBarEmpty) {
+        renderer?.destroy();
+        return;
+      }
+      if (key.name === "escape") {
+        if (inputValue) {
+          if (typeBar)
+            typeBar.input.value = "";
+          events.emit({ type: "typebar.patch", typeBar: { value: "", message: undefined } });
+        } else {
+          runAppAction("Opening runs", () => runtime.runIntent({ scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } }));
+        }
+      }
+    });
+    renderer.keyInput.on("paste", (event) => {
+      const host = getActivePiHost();
+      if (!host || store.getState().scene !== "handoff")
+        return;
+      host.write(event.bytes);
+      if (typeBar)
+        typeBar.input.value = "";
+    });
+    renderer.on("selection", (selection) => {
+      const selectedText = selection.getSelectedText();
+      if (!selectedText)
+        return;
+      renderer?.copyToClipboardOSC52?.(selectedText);
+      events.emit({ type: "typebar.patch", typeBar: { message: "copied selection" } });
+    });
+    renderer.on("resize", () => {
+      if (renderer)
+        renderedSelectableItems = renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, textLines, store.getState(), options.sceneRenderers);
+    });
+    renderer.on("destroy", () => {
+      destroyed = true;
+      stopActivePiHost("renderer destroyed");
+      imageVisuals?.destroy();
+      if (tickTimer)
+        clearInterval(tickTimer);
+      tickTimer = null;
+    });
+    renderer.requestLive?.();
+    renderedSelectableItems = renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, textLines, store.getState(), options.sceneRenderers);
+    requestRender(renderer);
+    queueMicrotask(() => {
+      (async () => {
+        try {
+          if (options.initializeRuntime) {
+            const runner = await runtime.getRunnerContext();
+            events.emit({ type: "runtime.ready", runner });
+          }
+          for (const adapter of options.adapters ?? [])
+            await adapter.start?.(runtime);
+          await runtime.runIntent(store.getState().intent);
+        } catch (error) {
+          const normalized = normalizeError(error);
+          events.emit({ type: "runtime.failed", message: normalized.message, hint: normalized.hint, cause: normalized.cause });
+        }
+      })();
+    });
+    tickTimer = setInterval(() => {
+      if (destroyed)
+        return;
+      const state = store.getState();
+      if (state.scene === "handoff" && getActivePiHost())
+        return;
+      store.patch({ tick: state.tick + 1 });
+    }, FRAME_MS);
+    await new Promise((resolveDestroy) => renderer?.on("destroy", resolveDestroy));
+  } finally {
+    destroyed = true;
+    if (tickTimer)
+      clearInterval(tickTimer);
+    tickTimer = null;
+    imageVisuals?.destroy();
+    stopActivePiHost("app shutdown");
+    try {
+      renderer?.dropLive?.();
+    } catch {}
+    if (renderer && !renderer.isDestroyed)
+      renderer.destroy();
+  }
+}
+function renderNow(renderer, graphics, imageVisuals, scrollPanels, typeBar, textLines, state, renderers) {
+  const layout = computeStageLayout(renderer.width, renderer.height);
+  const animationTick = Math.floor(state.tick / ANIMATION_SLOWDOWN);
+  const renderState = animationTick === state.tick ? state : { ...state, tick: animationTick };
+  const frame = rendererForScene(renderState.scene, renderers)(renderState, layout);
+  if (frame.terminalActive) {
+    getActivePiHost()?.resize(layout.width, Math.max(1, layout.height));
+  }
+  if (graphics) {
+    resizeGraphicsLayer(graphics, layout);
+    if (frame.terminalActive || frame.fullScreen)
+      clearGraphicsLayer(graphics);
+    else
+      drawAmbientField(graphics, layout, animationTick, state.scene);
+  }
+  if (imageVisuals && (frame.terminalActive || frame.fullScreen)) {
+    imageVisuals.clear();
+  }
+  const contentLayout = frame.fullScreen ? { ...layout, centerWidth: layout.width, centerLeft: 0, centerTop: 0, centerHeight: Math.min(layout.height, MAX_SCENE_LINES) } : layout;
+  const sceneLines = fitSceneLines(frame.lines, contentLayout);
+  const allSelectableItems = selectableItems(state);
+  const selectableIndexMap = new Map;
+  const renderedSelectableItems = [];
+  const remapSelectableLine = (entry) => {
+    if (entry.selectableIndex === undefined)
+      return entry;
+    const item = allSelectableItems[entry.selectableIndex];
+    if (!item)
+      return { ...entry, selectableIndex: undefined };
+    let renderedIndex = selectableIndexMap.get(entry.selectableIndex);
+    if (renderedIndex === undefined) {
+      renderedIndex = renderedSelectableItems.length;
+      selectableIndexMap.set(entry.selectableIndex, renderedIndex);
+      renderedSelectableItems.push(item);
+    }
+    return { ...entry, selectableIndex: renderedIndex };
+  };
+  const renderedSceneLines = sceneLines.map(remapSelectableLine);
+  const renderedPanels = (frame.panels ?? []).map((panel) => ({
+    ...panel,
+    lines: panel.lines.map(remapSelectableLine)
+  }));
+  if (imageVisuals && !frame.terminalActive && !frame.fullScreen) {
+    imageVisuals.render({
+      layout: contentLayout,
+      pixelSize: pixelSizeForRenderer(renderer),
+      panels: renderedPanels,
+      scene: state.scene,
+      tick: state.tick
+    });
+  }
+  if (graphics && !frame.terminalActive)
+    drawPanelChrome(graphics, contentLayout, renderedPanels);
+  renderedSceneLines.forEach((entry, index) => applyTextLine(textLines[index], entry, contentLayout.centerTop + index, contentLayout.centerLeft, contentLayout.centerWidth));
+  clearTextLines(textLines, renderedSceneLines.length);
+  applyScrollPanels(scrollPanels, contentLayout, renderedPanels);
+  if (typeBar) {
+    if (frame.hideTypeBar) {
+      hideTypeBar(typeBar, layout.height);
+    } else {
+      positionTypeBar(typeBar, {
+        ...state.typeBar,
+        placeholder: frame.typeBarPlaceholder ?? state.typeBar.placeholder
+      }, { ...state.footer, ...frame.footer ?? {} }, layout.width, layout.typeBarTop, layout.footerTop);
+    }
+  }
+  requestRender(renderer);
+  return renderedSelectableItems;
+}
+export {
+  launchRigOpenTuiApp
+};