opencode-vim 0.0.22 → 0.0.24

package/dist/tui.js

@@ -0,0 +1,3326 @@
+// @bun
+// tui.tsx
+import { createComponent as _$createComponent2 } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { Plugin } from "opentui:runtime-module:%40opencode%2Fplugin%2Ftui";
+import { InputRenderable, KeyEvent, PasteEvent } from "opentui:runtime-module:%40opentui%2Fcore";
+import { createEffect as createEffect2, createSignal as createSignal3, onCleanup as onCleanup2 } from "opentui:runtime-module:solid-js";
+
+// src/modules/vim/actions.ts
+function applyVimCursorStyle(ctx, style) {
+  const input = focusedInput(ctx);
+  if (!input)
+    return false;
+  input.cursorStyle = style;
+  return true;
+}
+function focusedInput(ctx) {
+  const focused = ctx.api.renderer.currentFocusedRenderable;
+  if (!focused || !hasEditBufferMethods(focused))
+    return;
+  return focused;
+}
+function setInput(ref, input) {
+  ref.set(toPromptInfo(ref, input));
+}
+function hasEditBufferMethods(input) {
+  return typeof input.moveCursorLeft === "function" || typeof input.moveCursorRight === "function" || typeof input.moveCursorUp === "function" || typeof input.moveCursorDown === "function" || typeof input.gotoLineEnd === "function";
+}
+function toPromptInfo(ref, input) {
+  return {
+    input,
+    mode: ref.current.mode,
+    parts: [...ref.current.parts]
+  };
+}
+
+// src/modules/vim/config.ts
+import { parseKeySequence } from "@vimee/core";
+var DEFAULT_CURSOR_STYLES = {
+  insert: {
+    style: "line",
+    blinking: true
+  },
+  normal: {
+    style: "block",
+    blinking: true
+  },
+  visual: {
+    style: "block",
+    blinking: true
+  },
+  "visual-line": {
+    style: "block",
+    blinking: true
+  }
+};
+function createVimConfig(options) {
+  const input = readOptions(options);
+  return {
+    defaultMode: input.defaultMode ?? "insert",
+    sessionKey: input.sessionKey ?? "s",
+    keymapTimeout: Math.max(0, input.keymapTimeout ?? 500),
+    pendingDisplayDelay: Math.max(0, input.pendingDisplayDelay ?? 120),
+    cursorStyles: {
+      insert: {
+        ...DEFAULT_CURSOR_STYLES.insert,
+        ...input.cursorStyles?.insert
+      },
+      normal: {
+        ...DEFAULT_CURSOR_STYLES.normal,
+        ...input.cursorStyles?.normal
+      },
+      visual: {
+        ...DEFAULT_CURSOR_STYLES.visual,
+        ...input.cursorStyles?.visual
+      },
+      "visual-line": {
+        ...DEFAULT_CURSOR_STYLES["visual-line"],
+        ...input.cursorStyles?.["visual-line"]
+      }
+    },
+    debug: input.debug ?? process.env.VIM_PROMPT_DEBUG === "1",
+    debugPath: input.debugPath,
+    keymaps: input.keymaps ?? {}
+  };
+}
+function readOptions(options) {
+  if (!options || typeof options !== "object")
+    return {};
+  const raw = "vim" in options ? options.vim : options;
+  if (!raw || typeof raw !== "object")
+    return {};
+  const source = raw;
+  return {
+    defaultMode: isMode(source.defaultMode) ? source.defaultMode : undefined,
+    sessionKey: readSessionKey(source.sessionKey),
+    keymapTimeout: readNumber(source.keymapTimeout),
+    pendingDisplayDelay: typeof source.pendingDisplayDelay === "number" ? source.pendingDisplayDelay : undefined,
+    cursorStyles: readCursorStyles(source.cursorStyles),
+    debug: typeof source.debug === "boolean" ? source.debug : undefined,
+    debugPath: typeof source.debugPath === "string" ? source.debugPath : undefined,
+    keymaps: readKeymaps(source.keymaps)
+  };
+}
+function readSessionKey(input) {
+  if (typeof input !== "string")
+    return;
+  try {
+    if (parseKeySequence(input).length === 1)
+      return input;
+  } catch {}
+}
+function readKeymaps(input) {
+  if (!input || typeof input !== "object")
+    return;
+  const source = input;
+  const keymaps = {};
+  for (const mode of ["insert", "normal", "visual", "visual-line"]) {
+    const raw = source[mode];
+    if (!raw || typeof raw !== "object")
+      continue;
+    keymaps[mode] = {};
+    for (const [key, action] of Object.entries(raw)) {
+      if (isMappedAction(action))
+        keymaps[mode][key] = action;
+    }
+  }
+  return keymaps;
+}
+function readCursorStyles(input) {
+  if (!input || typeof input !== "object")
+    return;
+  const source = input;
+  return {
+    insert: readCursorStyle(source.insert),
+    normal: readCursorStyle(source.normal),
+    visual: readCursorStyle(source.visual),
+    "visual-line": readCursorStyle(source["visual-line"])
+  };
+}
+function readCursorStyle(input) {
+  if (!input || typeof input !== "object")
+    return;
+  const source = input;
+  if (!isCursorStyle(source.style))
+    return;
+  return {
+    style: source.style,
+    blinking: typeof source.blinking === "boolean" ? source.blinking : undefined
+  };
+}
+function isCursorStyle(value) {
+  return value === "block" || value === "line" || value === "underline" || value === "default";
+}
+function isMode(value) {
+  return value === "insert" || value === "normal" || value === "visual" || value === "visual-line";
+}
+function isMappedAction(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function readNumber(value) {
+  return typeof value === "number" ? value : undefined;
+}
+
+// src/modules/vim/graphemes.ts
+var segments = new Intl.Segmenter(undefined, {
+  granularity: "grapheme"
+});
+function createGraphemeCodec() {
+  const encoded = new Map;
+  const decoded = new Map;
+  let next = 57344;
+  return {
+    encode(text) {
+      let result = "";
+      for (const {
+        segment
+      } of segments.segment(text)) {
+        const code = segment.charCodeAt(0);
+        if (segment.length === 1 && (code < 57344 || code > 63743)) {
+          result += segment;
+          continue;
+        }
+        let token = encoded.get(segment);
+        if (!token) {
+          if (next > 63743)
+            throw new Error("Vim grapheme dictionary is full");
+          token = String.fromCharCode(next++);
+          encoded.set(segment, token);
+          decoded.set(token, segment);
+        }
+        result += token;
+      }
+      return result;
+    },
+    decode(text) {
+      let result = "";
+      for (const token of text)
+        result += decoded.get(token) ?? token;
+      return result;
+    }
+  };
+}
+
+// src/modules/vim/map.ts
+var graphemes = new Intl.Segmenter(undefined, {
+  granularity: "grapheme"
+});
+function graphemeWidth(value) {
+  if (value === "\t")
+    return 2;
+  return value === `
+` ? 1 : Bun.stringWidth(value);
+}
+function charToDisplay(text, charIndex) {
+  let width = 0;
+  const limit = Math.max(0, Math.min(charIndex, text.length));
+  for (const part of graphemes.segment(text)) {
+    if (part.index + part.segment.length > limit)
+      break;
+    width += graphemeWidth(part.segment);
+  }
+  return width;
+}
+function displayToChar(text, displayOffset) {
+  let width = 0;
+  for (const part of graphemes.segment(text)) {
+    const next = width + graphemeWidth(part.segment);
+    if (next > displayOffset)
+      return part.index;
+    width = next;
+  }
+  return text.length;
+}
+function displayWidth(text) {
+  return charToDisplay(text, text.length);
+}
+function createPromptMap(hostText, codec = createGraphemeCodec()) {
+  const hostToVim = [];
+  const vimToHost = [];
+  let vimText = "";
+  let vimOffset = 0;
+  for (const {
+    index: hostOffset,
+    segment
+  } of graphemes.segment(hostText)) {
+    for (let index = hostOffset;index < hostOffset + segment.length; index++)
+      hostToVim[index] = vimOffset;
+    vimText += codec.encode(segment);
+    vimToHost[vimOffset] = hostOffset;
+    vimOffset++;
+  }
+  hostToVim[hostText.length] = vimOffset;
+  vimToHost[vimOffset] = hostText.length;
+  return {
+    hostText,
+    vimText,
+    hostToVim,
+    vimToHost
+  };
+}
+function hostPosition(map, hostDisplayOffset) {
+  const charIdx = displayToChar(map.hostText, hostDisplayOffset);
+  return positionFromOffset(map.vimText, map.hostToVim[clamp(charIdx, 0, map.hostText.length)]);
+}
+function hostOffset(map, position) {
+  return hostFromVimOffset(map, offsetFromPosition(map.vimText, position));
+}
+function hostFromVimOffset(map, offset) {
+  return charToDisplay(map.hostText, map.vimToHost[clamp(offset, 0, map.vimText.length)]);
+}
+function positionFromOffset(text, offset) {
+  const lines = text.slice(0, offset).split(`
+`);
+  return {
+    line: lines.length - 1,
+    col: lines[lines.length - 1]?.length ?? 0
+  };
+}
+function offsetFromPosition(text, position) {
+  const lines = text.split(`
+`);
+  const line = clamp(position.line, 0, Math.max(0, lines.length - 1));
+  let offset = 0;
+  for (let index = 0;index < line; index++)
+    offset += lines[index].length + 1;
+  return offset + clamp(position.col, 0, lines[line]?.length ?? 0);
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// src/modules/vim/edit.ts
+var graphemes2 = new Intl.Segmenter(undefined, {
+  granularity: "grapheme"
+});
+function editInput(input, value) {
+  if (input.plainText === value)
+    return;
+  input.clearSelection();
+  const before = [...graphemes2.segment(input.plainText)];
+  const after = [...graphemes2.segment(value)];
+  let prefix = 0;
+  while (prefix < before.length && prefix < after.length && before[prefix].segment === after[prefix].segment)
+    prefix++;
+  let suffix = 0;
+  while (suffix + prefix < before.length && suffix + prefix < after.length && before[before.length - suffix - 1].segment === after[after.length - suffix - 1].segment)
+    suffix++;
+  const start = before[prefix]?.index ?? input.plainText.length;
+  const end = suffix ? before[before.length - suffix].index : input.plainText.length;
+  const valueEnd = suffix ? after[after.length - suffix].index : value.length;
+  const startOffset = charToDisplay(input.plainText, start);
+  if (start === end)
+    input.cursorOffset = startOffset;
+  else
+    input.setSelection(startOffset, charToDisplay(input.plainText, end));
+  input.insertText(value.slice(start, valueEnd));
+}
+
+// src/modules/vim/keys.ts
+var graphemes3 = new Intl.Segmenter(undefined, {
+  granularity: "grapheme"
+});
+var NAMED_KEYS = {
+  escape: "<Esc>",
+  esc: "<Esc>",
+  return: "<CR>",
+  enter: "<CR>",
+  tab: "<Tab>",
+  backspace: "<BS>",
+  delete: "<Del>",
+  space: "<Space>",
+  up: "<Up>",
+  down: "<Down>",
+  left: "<Left>",
+  right: "<Right>",
+  home: "<Home>",
+  end: "<End>",
+  pageup: "<PageUp>",
+  pagedown: "<PageDown>"
+};
+function keyNotation(event) {
+  const name = event.name?.toLowerCase();
+  if (!name)
+    return;
+  if (event.ctrl)
+    return `<C-${ctrlKey(name)}>`;
+  if (event.meta)
+    return `<M-${name}>`;
+  if ([...graphemes3.segment(name)].length === 1)
+    return event.shift ? name.toUpperCase() : name;
+  return NAMED_KEYS[name] ?? `<${name}>`;
+}
+function ctrlKey(name) {
+  if (name === "escape" || name === "esc")
+    return "[";
+  if (name.length === 1)
+    return name;
+  return name;
+}
+
+// src/modules/vim/log.ts
+import { appendFile, mkdir } from "fs/promises";
+import { dirname, join } from "path";
+function createVimLog(config) {
+  if (!config.debug)
+    return () => {};
+  const path = config.debugPath ?? defaultPath();
+  append(path, `
+--- opencode-vim debug ${new Date().toISOString()} ---
+`);
+  return (event, data) => {
+    const suffix = data ? ` ${safeJson(data)}` : "";
+    append(path, `${new Date().toISOString()} ${event}${suffix}
+`);
+  };
+}
+function defaultPath() {
+  const home = process.env.HOME;
+  return home ? join(home, ".cache/opencode/opencode-vim.log") : "/tmp/opencode-vim.log";
+}
+async function append(path, text) {
+  try {
+    await mkdir(dirname(path), {
+      recursive: true
+    });
+    await appendFile(path, text);
+  } catch {}
+}
+function safeJson(data) {
+  try {
+    return JSON.stringify(data);
+  } catch {
+    return "{}";
+  }
+}
+
+// src/modules/vim/state.tsx
+import { createSignal } from "opentui:runtime-module:solid-js";
+function createVimState(defaultMode, log = () => {}) {
+  const [mode, setMode] = createSignal(defaultMode);
+  const [pending, setPending] = createSignal("");
+  const listeners = new Set;
+  log("state.init", {
+    mode: defaultMode
+  });
+  return {
+    mode,
+    setMode(next) {
+      const changed = mode() !== next;
+      if (changed)
+        log("state.mode", {
+          from: mode(),
+          to: next
+        });
+      setMode(next);
+      if (changed)
+        notify();
+    },
+    pending,
+    setPending(next) {
+      const changed = pending() !== next;
+      if (changed)
+        log("state.pending", {
+          from: pending(),
+          to: next
+        });
+      setPending(next);
+      if (changed)
+        notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+  function notify() {
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch (error) {
+        log("state.listener.error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+}
+
+// src/modules/vim/vimee.ts
+import { TextBuffer, createInitialContext, createKeybindMap, executeOperatorOnRange, parseKeySequence as parseKeySequence2, processKeystroke, resetContext, resolveMotion } from "@vimee/core";
+var YANK_FLASH_MS = 250;
+function createVimeeAdapter(state, config, log, options = {}) {
+  const codec = createGraphemeCodec();
+  let buffer = new TextBuffer("");
+  let activeMap = createPromptMap("", codec);
+  let vim = createInitialContext({
+    line: 0,
+    col: 0
+  });
+  const keybinds = options.readOnly ? undefined : createKeybinds(config, log);
+  let timer;
+  let yankTimer;
+  let yankFlashActive = false;
+  let pendingInsert = "";
+  let pendingTarget;
+  let pendingContext;
+  let nativeInsertUndoSaved = false;
+  let historyText;
+  let activeInput;
+  let preferredColumn;
+  let preferredScreen = false;
+  let generation = 0;
+  const defaultHistoryKeys = {
+    k: !hasNormalKeyPrefix(config, "k"),
+    j: !hasNormalKeyPrefix(config, "j")
+  };
+  return {
+    attach,
+    suspend,
+    setRegister(text) {
+      vim = {
+        ...vim,
+        register: codec.encode(text)
+      };
+    },
+    isPending: () => vim.phase !== "idle" || vim.count > 0 || !!keybinds?.isPending(),
+    handle(event, key, ctx) {
+      const ref = ctx.prompt();
+      if (!ref)
+        return false;
+      const input = focusedInput(ctx);
+      attach(ctx);
+      let vimeeKey = keyForVimee(event, key);
+      if (!vimeeKey)
+        return false;
+      if (options.readOnly && !readOnlyKey(vimeeKey, event.ctrl, vim)) {
+        vim = resetContext(vim);
+        state.setPending("");
+        return true;
+      }
+      vimeeKey = codec.encode(vimeeKey);
+      if (state.mode() === "insert") {
+        if (vimeeKey === "Escape") {
+          cancelPendingInsert(ctx);
+          enterNormal(ctx);
+          state.setPending("");
+          updateTimeout(ctx);
+          log("vimee.key", {
+            key,
+            mode: vim.mode,
+            phase: vim.phase,
+            cursor: vim.cursor,
+            actions: ["mode-change"]
+          });
+          return true;
+        }
+        return handleInsertKeybind(event, vimeeKey, ctx);
+      }
+      const text = input?.plainText ?? ref.current.input;
+      const dw = displayWidth(text);
+      const displayOff = clamp2(input?.cursorOffset ?? dw, 0, dw);
+      const charOff = displayToChar(text, displayOff);
+      const canBrowseHistory = !options.readOnly && vim.phase === "idle" && vim.count === 0 && !keybinds?.isPending();
+      const historyCommand = canBrowseHistory ? defaultHistoryCommand(vimeeKey, text, historyText, defaultHistoryKeys) : undefined;
+      if (historyCommand) {
+        const result = dispatchCommand(historyCommand, ctx);
+        historyText = result.ok ? focusedInput(ctx)?.plainText ?? ref.current.input : undefined;
+        state.setPending("");
+        updateTimeout(ctx);
+        log("vimee.history", {
+          key,
+          command: historyCommand,
+          handled: result.ok
+        });
+        return true;
+      }
+      historyText = undefined;
+      const map = mapForHostText(text);
+      const cursor = hostPosition(map, displayOff);
+      const wasPending = keybinds?.isPending() ?? false;
+      const pendingBefore = pendingInsert;
+      sync(map, cursor);
+      const shouldFlashYank = shouldFlashYankFor(vimeeKey);
+      const visualYankRange = visualYankRangeFor(map);
+      vimeeKey = textObjectAlias(vimeeKey, vim) ?? vimeeKey;
+      const textObjectHandled = handleTextObject(vimeeKey, ctx, map);
+      if (textObjectHandled !== undefined)
+        return textObjectHandled;
+      const resolved = keybinds?.resolve(vimeeKey, vim.mode, event.ctrl);
+      if (resolved?.status === "pending") {
+        vim = {
+          ...vim,
+          statusMessage: resolved.display
+        };
+        state.setPending(resolved.display);
+        updateTimeout(ctx);
+        log("vimee.key", {
+          key,
+          vimeeKey,
+          mode: vim.mode,
+          phase: vim.phase,
+          cursor: vim.cursor,
+          actions: []
+        });
+        return true;
+      }
+      if (vimeeKey === "Enter" && state.mode() === "normal" && vim.phase === "idle" && !wasPending && resolved?.status !== "matched") {
+        ref.submit();
+        state.setPending("");
+        updateTimeout(ctx);
+        log("vimee.key", {
+          key,
+          vimeeKey,
+          mode: vim.mode,
+          phase: vim.phase,
+          cursor: vim.cursor,
+          actions: ["submit"]
+        });
+        return true;
+      }
+      const commandKey = vimeeKey;
+      const definition = resolved?.status === "matched" ? resolved.definition : undefined;
+      if (options.readClipboard && needsClipboard(commandKey, event.ctrl, definition)) {
+        const before = generation;
+        return options.readClipboard().then((text) => {
+          if (before !== generation || input?.isDestroyed || input?.plainText !== map.hostText || input?.cursorOffset !== displayOff)
+            return false;
+          vim = {
+            ...vim,
+            register: codec.encode(text)
+          };
+          return finish();
+        });
+      }
+      return finish();
+      function finish() {
+        let result;
+        if (resolved?.status === "matched") {
+          const actions = applyKeybind(resolved.definition, ctx, map);
+          result = {
+            newCtx: vim,
+            actions
+          };
+        } else {
+          if (!event.ctrl && vim.phase === "idle" && vim.count === 0 && (commandKey === "j" || commandKey === "k" || commandKey === "ArrowDown" || commandKey === "ArrowUp")) {
+            vim = processKey("g").newCtx;
+          }
+          result = processKey(commandKey, event.ctrl);
+        }
+        vim = result.newCtx;
+        const actions = result.actions;
+        if (resolved?.status !== "matched")
+          applyActions(actions, ctx, map);
+        if (shouldFlashYank)
+          flashYank(ctx, activeMap, yankAction(actions), visualYankRange);
+        syncMode(state, vim.mode);
+        const keybindPending = keybinds?.isPending() ?? false;
+        if (wasPending && !keybindPending && pendingBefore && state.mode() === "insert")
+          flushPendingInsert(ctx, pendingBefore, charOff);
+        pendingInsert = keybindPending && state.mode() === "insert" ? plainPending(vim.statusMessage) : "";
+        state.setPending(pendingDisplay(vim, keybindPending));
+        updateTimeout(ctx);
+        log("vimee.key", {
+          key,
+          vimeeKey,
+          mode: vim.mode,
+          phase: vim.phase,
+          cursor: vim.cursor,
+          actions: actions.map((action) => action.type)
+        });
+        return consumesKey(commandKey, actions, vim, keybindPending);
+      }
+    },
+    cleanup: suspend
+  };
+  function needsClipboard(key, ctrl, definition) {
+    if (definition) {
+      if ("execute" in definition)
+        return false;
+      return parseKeySequence2(definition.keys).some((token) => ["p", "P", ".", "@"].includes(token));
+    }
+    if (ctrl)
+      return false;
+    if (vim.phase === "macro-execute-pending")
+      return true;
+    if (vim.phase !== "idle" || vim.selectedRegister)
+      return false;
+    if (key === "p" || key === "P")
+      return true;
+    return key === "." && vim.lastChange.some((token) => ["p", "P", "@"].includes(token));
+  }
+  function attach(ctx) {
+    const input = focusedInput(ctx);
+    if (activeInput === input)
+      return;
+    suspend();
+    activeInput = input;
+    activeMap = createPromptMap(input?.plainText ?? ctx.prompt()?.current.input ?? "", codec);
+    buffer = new TextBuffer(activeMap.vimText);
+    nativeInsertUndoSaved = false;
+    vim = {
+      ...resetContext(vim),
+      cursor: hostPosition(activeMap, input?.cursorOffset ?? 0),
+      mode: state.mode()
+    };
+  }
+  function suspend() {
+    generation++;
+    preferredColumn = undefined;
+    if (pendingContext)
+      cancelPendingInsert(pendingContext);
+    if (timer)
+      clearTimeout(timer);
+    timer = undefined;
+    keybinds?.cancel();
+    cancelYankFlash();
+    if (activeInput && !activeInput.isDestroyed)
+      clearVisualSelection(activeInput);
+    if (isVisualMode(state.mode()))
+      state.setMode("normal");
+    vim = resetContext(vim);
+    state.setPending("");
+    pendingTarget = undefined;
+    pendingContext = undefined;
+  }
+  function sync(map, cursor) {
+    if (cursor.line !== vim.cursor.line || cursor.col !== vim.cursor.col)
+      preferredColumn = undefined;
+    if (buffer.getContent() !== map.vimText)
+      buffer.replaceContent(map.vimText);
+    vim = {
+      ...vim,
+      cursor,
+      mode: state.mode()
+    };
+  }
+  function mapForHostText(text) {
+    if (activeMap.hostText === text)
+      return activeMap;
+    if (state.mode() === "insert")
+      recordNativeChange(text);
+    activeMap = createPromptMap(text, codec);
+    if (state.mode() === "insert") {
+      if (!nativeInsertUndoSaved) {
+        buffer.saveUndoPoint(vim.cursor);
+        nativeInsertUndoSaved = true;
+      }
+      buffer.replaceContent(activeMap.vimText);
+    } else {
+      buffer = new TextBuffer(activeMap.vimText);
+      nativeInsertUndoSaved = false;
+    }
+    return activeMap;
+  }
+  function recordNativeChange(text) {
+    const before = codec.encode(activeMap.hostText);
+    const after = codec.encode(text);
+    const start = codec.encode(activeMap.hostText.slice(0, displayToChar(activeMap.hostText, hostOffset(activeMap, vim.cursor)))).length;
+    let prefix = 0;
+    while (prefix < start && prefix < after.length && before[prefix] === after[prefix])
+      prefix++;
+    let suffix = 0;
+    while (suffix < before.length - start && suffix < after.length - prefix && before[before.length - suffix - 1] === after[after.length - suffix - 1])
+      suffix++;
+    const keys = [...vim.pendingChange];
+    if (!keys.length)
+      keys.push("i");
+    for (let index = prefix;index < start; index++)
+      keys.push("Backspace");
+    for (let index = start;index < before.length - suffix; index++)
+      keys.push("Delete");
+    for (const key of after.slice(prefix, after.length - suffix))
+      keys.push(key === `
+` ? "Enter" : key === "\t" ? "Tab" : key);
+    vim = {
+      ...vim,
+      pendingChange: keys
+    };
+  }
+  function applyActions(actions, ctx, map) {
+    const ref = ctx.prompt();
+    const input = focusedInput(ctx);
+    let currentMap = map;
+    if (!ref)
+      return;
+    for (const action of actions) {
+      switch (action.type) {
+        case "content-change":
+          currentMap = createPromptMap(codec.decode(action.content), codec);
+          activeMap = currentMap;
+          setInput(ref, currentMap.hostText);
+          buffer.replaceContent(action.content);
+          break;
+        case "cursor-move":
+          setCursor(input, currentMap, action.position);
+          break;
+        case "yank":
+          if (!action.register)
+            options.onYank?.(codec.decode(action.text));
+          break;
+        case "mode-change":
+          nativeInsertUndoSaved = action.mode === "insert" && actions.some((item) => item.type === "content-change");
+          if (action.mode === "insert") {
+            cancelYankFlash();
+            if (input)
+              clearVisualSelection(input);
+          }
+          syncMode(state, action.mode);
+          break;
+        case "quit":
+          ref.blur();
+          break;
+        case "submit":
+          ref.submit();
+          break;
+        case "command":
+          dispatchCommand(action.command, ctx);
+          return;
+      }
+    }
+    setCursor(input, currentMap, vim.cursor);
+    syncVisualSelection(input, currentMap, ctx);
+  }
+  function handleInsertKeybind(event, key, ctx) {
+    if (!keybinds?.hasKeybinds("insert") && !keybinds?.isPending())
+      return false;
+    const wasPending = keybinds.isPending();
+    const pendingBefore = pendingInsert;
+    const resolved = keybinds.resolve(key, "insert", event.ctrl);
+    switch (resolved.status) {
+      case "pending":
+        if (!wasPending) {
+          const input = focusedInput(ctx);
+          pendingTarget = input ? {
+            input,
+            offset: input.cursorOffset ?? 0
+          } : undefined;
+          pendingContext = ctx;
+        }
+        pendingInsert = codec.decode(plainPending(resolved.display));
+        state.setPending(resolved.display);
+        updateTimeout(ctx);
+        return true;
+      case "matched": {
+        if (applyInsertKeybind(resolved.definition, ctx)) {
+          pendingInsert = "";
+          state.setPending("");
+          updateTimeout(ctx);
+          log("vimee.keybind", {
+            key,
+            mode: vim.mode,
+            phase: vim.phase,
+            cursor: vim.cursor,
+            actions: ["mode-change"]
+          });
+          return true;
+        }
+        if (wasPending && pendingBefore)
+          flushPendingInsert(ctx, pendingBefore);
+        pendingInsert = "";
+        state.setPending("");
+        updateTimeout(ctx);
+        log("vimee.keybind.unsupported", {
+          key
+        });
+        return false;
+      }
+      case "none":
+        if (wasPending && pendingBefore)
+          flushPendingInsert(ctx, pendingBefore);
+        pendingInsert = "";
+        state.setPending("");
+        updateTimeout(ctx);
+        return wasPending ? handleInsertKeybind(event, key, ctx) : false;
+    }
+  }
+  function applyInsertKeybind(definition, ctx) {
+    switch (insertHostAction(definition)) {
+      case "normal":
+        enterNormal(ctx);
+        return true;
+      case "submit":
+        ctx.prompt()?.submit();
+        return true;
+      case "command":
+        dispatchCommand(definition.command, ctx);
+        return true;
+      default:
+        return false;
+    }
+  }
+  function enterNormal(ctx) {
+    const ref = ctx.prompt();
+    const input = focusedInput(ctx);
+    const text = input?.plainText ?? ref?.current.input ?? "";
+    const map = mapForHostText(text);
+    if (input && text.length > 0) {
+      const dw = displayWidth(text);
+      const offset = clamp2(input?.cursorOffset ?? dw, 0, dw);
+      const charOffset = displayToChar(text, offset);
+      if (charOffset > 0 && text[charOffset - 1] !== `
+`) {
+        input.cursorOffset = charToDisplay(text, displayToChar(text, Math.max(0, offset - 1)));
+      }
+      clampNormalCursor(input);
+    }
+    const lastChange = nativeInsertUndoSaved ? [...vim.pendingChange, "Escape"] : vim.lastChange;
+    vim = {
+      ...resetContext(vim),
+      cursor: hostPosition(map, input?.cursorOffset ?? 0),
+      mode: "normal",
+      statusMessage: "",
+      lastChange,
+      pendingChange: []
+    };
+    nativeInsertUndoSaved = false;
+    syncMode(state, "normal");
+  }
+  function insertHostAction(definition) {
+    const action = definition.hostAction;
+    if (action)
+      return action;
+    if ("execute" in definition)
+      return;
+    if (definition.keys === "<Esc>" || definition.keys === "<C-[>" || definition.keys === "Escape")
+      return "normal";
+    return;
+  }
+  function applyKeybind(definition, ctx, map) {
+    if ("execute" in definition) {
+      const actions = definition.execute(vim, buffer);
+      vim = {
+        ...vim,
+        cursor: hostPosition(map, hostOffset(map, vim.cursor))
+      };
+      applyActions(actions, ctx, map);
+      return actions;
+    }
+    let actions = [];
+    for (const token of parseKeySequence2(definition.keys)) {
+      const result = processKey(codec.encode(keyToken(token)), tokenCtrl(token));
+      vim = result.newCtx;
+      applyActions(result.actions, ctx, activeMap);
+      actions = [...actions, ...result.actions];
+    }
+    return actions;
+  }
+  function processKey(key, ctrl = false) {
+    const register = vim.selectedRegister;
+    const moving = !ctrl && vim.mode !== "insert" && (vim.phase === "idle" || vim.phase === "operator-pending" || vim.phase === "g-pending");
+    const vertical = moving && (key === "j" || key === "k" || key === "ArrowDown" || key === "ArrowUp");
+    const lineEnd = moving && key === "$" && vim.phase === "idle";
+    const result = processKeyInner(key, ctrl);
+    if (register) {
+      for (const action of result.actions) {
+        if (action.type === "yank")
+          action.register = register;
+      }
+    }
+    if (result.actions.some((action) => action.type === "content-change" || action.type === "mode-change"))
+      preferredColumn = undefined;
+    else if (!vertical && result.actions.some((action) => action.type === "cursor-move"))
+      preferredColumn = lineEnd ? Infinity : undefined;
+    return result;
+  }
+  function processKeyInner(key, ctrl) {
+    let range = ctrl ? undefined : lineMotion(key);
+    if (range && vim.operator && (key === "j" || key === "k" || key === "ArrowDown" || key === "ArrowUp") && range.start.line === range.end.line && range.start.col === range.end.col) {
+      return {
+        newCtx: {
+          ...resetContext(vim),
+          pendingChange: []
+        },
+        actions: []
+      };
+    }
+    if (range && !vim.operator) {
+      return {
+        newCtx: {
+          ...resetContext(vim),
+          cursor: range.end
+        },
+        actions: [{
+          type: "cursor-move",
+          position: range.end
+        }]
+      };
+    }
+    let wordRange;
+    if (!ctrl && vim.mode !== "insert" && (key === "w" || key === "W") && (vim.phase === "idle" || vim.phase === "operator-pending")) {
+      wordRange = forwardWordRange(key, vim.cursor, buffer, vim.count || 1);
+      if (vim.phase === "idle") {
+        const cursor = {
+          ...wordRange.end,
+          col: Math.min(wordRange.end.col, Math.max(0, buffer.getLineLength(wordRange.end.line) - 1))
+        };
+        return {
+          newCtx: {
+            ...resetContext(vim),
+            cursor
+          },
+          actions: [{
+            type: "cursor-move",
+            position: cursor
+          }]
+        };
+      }
+    }
+    if (key === "." && !ctrl && vim.mode === "normal" && vim.phase === "idle" && vim.lastChange.length) {
+      const original = buffer;
+      const before = buffer.getContent();
+      const cursor = vim.cursor;
+      const keys = [...vim.lastChange];
+      if (vim.count) {
+        while (/^[0-9]$/.test(keys[0] ?? ""))
+          keys.shift();
+        keys.unshift(...String(vim.count));
+      }
+      vim = {
+        ...vim,
+        count: 0
+      };
+      const actions = [];
+      buffer = new TextBuffer(before);
+      try {
+        for (const token of keys) {
+          const result = processKey(token);
+          vim = result.newCtx;
+          actions.push(...result.actions);
+        }
+        if (buffer.getContent() !== before) {
+          original.saveUndoPoint(cursor);
+          original.replaceContent(buffer.getContent());
+        }
+      } finally {
+        buffer = original;
+      }
+      return {
+        newCtx: {
+          ...vim,
+          lastChange: keys,
+          pendingChange: []
+        },
+        actions
+      };
+    }
+    const operator = vim.operator;
+    if (!range && !ctrl && operator && textObjectOperator(operator)) {
+      if (vim.phase === "operator-pending") {
+        const count = vim.count || 1;
+        if (key === "l" || key === "ArrowRight") {
+          range = {
+            start: vim.cursor,
+            end: {
+              line: vim.cursor.line,
+              col: Math.min(buffer.getLineLength(vim.cursor.line), vim.cursor.col + count)
+            },
+            inclusive: false,
+            linewise: false
+          };
+        } else if (key === operator) {
+          range = {
+            start: {
+              line: vim.cursor.line,
+              col: 0
+            },
+            end: {
+              line: Math.min(buffer.getLineCount() - 1, vim.cursor.line + count - 1),
+              col: 0
+            },
+            inclusive: true,
+            linewise: true
+          };
+        } else if (operator === "c" && key === "w" && /\S/.test(buffer.getLine(vim.cursor.line)[vim.cursor.col] ?? "")) {
+          range = resolveMotion("e", {
+            ...vim.cursor,
+            col: vim.cursor.col - 1
+          }, buffer, count, vim.count > 0, vim)?.range;
+          if (range)
+            range.start = vim.cursor;
+        } else if (wordRange) {
+          range = wordRange;
+          if (operator === "d" && range.end.line > range.start.line && /\S/.test(buffer.getLine(range.start.line)[range.start.col] ?? "") && range.end.col === Math.max(0, buffer.getLine(range.end.line).search(/\S/))) {
+            range.end = {
+              line: range.end.line - 1,
+              col: buffer.getLineLength(range.end.line - 1)
+            };
+          }
+        } else if (operator === "c") {
+          const motion = resolveMotion(key, vim.cursor, buffer, count, vim.count > 0, vim);
+          if (motion?.range.linewise)
+            range = motion.range;
+        }
+      } else if (vim.phase === "text-object-pending" && vim.textObjectModifier) {
+        range = resolvePromptTextObject(vim.textObjectModifier, key, vim.cursor, buffer) ?? undefined;
+      }
+    }
+    if (range && operator) {
+      if (vim.phase === "g-pending" && !range.inclusive) {
+        const ordered = orderedRange(range);
+        if (ordered.end.line > ordered.start.line && ordered.end.col === 0) {
+          const linewise = ordered.start.col <= Math.max(0, buffer.getLine(ordered.start.line).search(/\S/));
+          range = {
+            start: ordered.start,
+            end: {
+              line: ordered.end.line - 1,
+              col: buffer.getLineLength(ordered.end.line - 1)
+            },
+            linewise,
+            inclusive: false
+          };
+        }
+      }
+      const keys = [];
+      if (vim.count)
+        keys.push(...String(vim.count));
+      for (const token of vim.pendingChange) {
+        if (!/^[0-9]$/.test(token))
+          keys.push(token);
+      }
+      keys.push(key);
+      const result = executeTextObject(operator, range, buffer, vim);
+      if (operator === "y")
+        result.context.pendingChange = [];
+      else if (result.context.mode === "insert")
+        result.context.pendingChange = keys;
+      else {
+        result.context.lastChange = keys;
+        result.context.pendingChange = [];
+      }
+      return {
+        newCtx: result.context,
+        actions: result.actions
+      };
+    }
+    const yanking = operator === "y" || isVisualMode(vim.mode) && key === "y" || vim.mode === "normal" && key === "Y";
+    const register = vim.selectedRegister ? vim.registers[vim.selectedRegister] ?? "" : vim.register;
+    const emptyLinePaste = !ctrl && vim.mode === "normal" && vim.phase === "idle" && (key === "p" || key === "P") && buffer.getContent() === "" && register.endsWith(`
+`);
+    const result = processKeystroke(key, vim, yanking ? new TextBuffer(buffer.getContent()) : buffer, ctrl, false);
+    if (emptyLinePaste) {
+      buffer.deleteLines(key === "p" ? 0 : buffer.getLineCount() - 1, 1);
+      result.newCtx.cursor = {
+        line: 0,
+        col: 0
+      };
+      for (const action of result.actions) {
+        if (action.type === "content-change")
+          action.content = buffer.getContent();
+        if (action.type === "cursor-move")
+          action.position = result.newCtx.cursor;
+      }
+    }
+    return result;
+  }
+  function lineMotion(key) {
+    if (vim.mode !== "normal" && !isVisualMode(vim.mode))
+      return;
+    const screen = vim.phase === "g-pending";
+    if (!screen && vim.phase !== "idle" && vim.phase !== "operator-pending")
+      return;
+    const down = key === "j" || key === "ArrowDown";
+    const up = key === "k" || key === "ArrowUp";
+    if (!down && !up && !(screen && (key === "0" || key === "^" || key === "$")))
+      return;
+    const map = buffer.getContent() === activeMap.vimText ? activeMap : createPromptMap(codec.decode(buffer.getContent()), codec);
+    const offset = hostOffset(map, vim.cursor);
+    const count = vim.count || 1;
+    let start;
+    let end;
+    let column;
+    if (screen) {
+      const lines = activeInput?.editorView?.getLogicalLineInfo?.();
+      if (!lines?.lineStartCols.length)
+        return;
+      let row = 0;
+      while (row + 1 < lines.lineStartCols.length && lines.lineStartCols[row + 1] <= offset)
+        row++;
+      column = offset - lines.lineStartCols[row];
+      const delta = down ? count : up ? -count : key === "$" ? count - 1 : 0;
+      const target = clamp2(row + delta, 0, lines.lineStartCols.length - 1);
+      start = lines.lineStartCols[target];
+      end = start + Math.max(0, lines.lineWidthCols[target] - 1);
+      if ((down || up) && target === row)
+        return {
+          start: vim.cursor,
+          end: vim.cursor,
+          linewise: false,
+          inclusive: false
+        };
+    } else {
+      const lineStart = hostOffset(map, {
+        line: vim.cursor.line,
+        col: 0
+      });
+      column = offset - lineStart;
+      const line = clamp2(vim.cursor.line + (down ? count : -count), 0, buffer.getLineCount() - 1);
+      start = hostOffset(map, {
+        line,
+        col: 0
+      });
+      end = Math.max(start, hostOffset(map, {
+        line,
+        col: buffer.getLineLength(line)
+      }) - 1);
+    }
+    let target;
+    if (down || up) {
+      if (preferredColumn === undefined || preferredScreen !== screen && preferredColumn !== Infinity)
+        preferredColumn = column;
+      preferredScreen = screen;
+      target = Math.min(start + preferredColumn, end);
+    } else if (key === "$") {
+      target = end;
+    } else {
+      target = start;
+      if (key === "^") {
+        const from = displayToChar(map.hostText, start);
+        const to = displayToChar(map.hostText, end + 1);
+        const first = map.hostText.slice(from, to).search(/\S/);
+        if (first >= 0)
+          target = charToDisplay(map.hostText, from + first);
+      }
+    }
+    return {
+      start: vim.cursor,
+      end: hostPosition(map, target),
+      linewise: !screen,
+      inclusive: !screen || key === "$"
+    };
+  }
+  function handleTextObject(key, ctx, map) {
+    if (vim.phase !== "text-object-pending" || !vim.textObjectModifier)
+      return;
+    const range = resolvePromptTextObject(vim.textObjectModifier, key, vim.cursor, buffer);
+    if (!range)
+      return;
+    const flashRange = vim.operator === "y" ? motionHostRange(map, range) : undefined;
+    if (!vim.operator) {
+      vim = {
+        ...resetContext(vim),
+        visualAnchor: range.start,
+        cursor: range.end
+      };
+      applyActions([{
+        type: "cursor-move",
+        position: range.end
+      }], ctx, map);
+      state.setPending("");
+      updateTimeout(ctx);
+      log("vimee.textobject", {
+        key,
+        mode: vim.mode,
+        phase: vim.phase,
+        cursor: vim.cursor,
+        actions: ["cursor-move"]
+      });
+      return true;
+    }
+    if (!textObjectOperator(vim.operator))
+      return;
+    const result = processKey(key);
+    vim = result.newCtx;
+    applyActions(result.actions, ctx, map);
+    if (flashRange)
+      flashYank(ctx, activeMap, result.actions.find((action) => action.type === "yank"), flashRange);
+    syncMode(state, vim.mode);
+    state.setPending("");
+    updateTimeout(ctx);
+    log("vimee.textobject", {
+      key,
+      mode: vim.mode,
+      phase: vim.phase,
+      cursor: vim.cursor,
+      actions: result.actions.map((action) => action.type)
+    });
+    return true;
+  }
+  function updateTimeout(ctx) {
+    if (timer)
+      clearTimeout(timer);
+    timer = undefined;
+    if (!keybinds?.isPending())
+      return;
+    timer = setTimeout(() => {
+      keybinds.cancel();
+      flushPendingInsert(ctx, pendingInsert);
+      pendingInsert = "";
+      state.setPending("");
+      ctx.requestRender();
+    }, config.keymapTimeout);
+  }
+  function cancelPendingInsert(ctx, offset, flush = true) {
+    if (!keybinds?.isPending())
+      return;
+    if (timer)
+      clearTimeout(timer);
+    timer = undefined;
+    keybinds.cancel();
+    if (flush)
+      flushPendingInsert(ctx, pendingInsert, offset);
+    pendingInsert = "";
+    pendingTarget = undefined;
+    pendingContext = undefined;
+    state.setPending("");
+  }
+  function flushPendingInsert(ctx, value, charOffset) {
+    if (!value || state.mode() !== "insert")
+      return;
+    if (pendingTarget?.input.isDestroyed)
+      return;
+    if (pendingTarget?.input.insertText && !pendingTarget.input.isDestroyed) {
+      const {
+        input,
+        offset
+      } = pendingTarget;
+      const cursor = input.cursorOffset ?? 0;
+      input.clearSelection?.();
+      input.cursorOffset = offset;
+      input.insertText(value);
+      input.cursorOffset = cursor >= offset ? cursor + displayWidth(value) : cursor;
+      return;
+    }
+    const ref = ctx.prompt();
+    if (!ref)
+      return;
+    const input = focusedInput(ctx);
+    const text = input?.plainText ?? ref.current.input;
+    const currentDisplayOff = input?.cursorOffset ?? 0;
+    const currentCharOff = displayToChar(text, currentDisplayOff);
+    const insertAtChar = charOffset ?? currentCharOff;
+    const next = text.slice(0, insertAtChar) + value + text.slice(insertAtChar);
+    setInput(ref, next);
+    const nextCharOff = currentCharOff >= insertAtChar ? currentCharOff + value.length : currentCharOff;
+    if (input)
+      input.cursorOffset = displayWidth(next.slice(0, nextCharOff));
+  }
+  function setCursor(input, map, position) {
+    if (!input)
+      return;
+    input.cursorOffset = hostOffset(map, position);
+    if (vim.mode !== "insert")
+      clampNormalCursor(input);
+  }
+  function syncVisualSelection(input, map, ctx) {
+    if (!input)
+      return;
+    if (!isVisualMode(vim.mode) || !vim.visualAnchor) {
+      if (!yankFlashActive)
+        clearVisualSelection(input);
+      return;
+    }
+    cancelYankFlash();
+    const range = vim.mode === "visual-line" ? visualLineRange(map, vim.visualAnchor, vim.cursor) : visualCharRange(map, vim.visualAnchor, vim.cursor);
+    if (!range) {
+      clearVisualSelection(input);
+      return;
+    }
+    setSelection(input, range.start, range.end, ctx);
+  }
+  function visualYankRangeFor(map) {
+    if (!isVisualMode(vim.mode) || !vim.visualAnchor)
+      return;
+    return vim.mode === "visual-line" ? visualLineRange(map, vim.visualAnchor, vim.cursor) : visualCharRange(map, vim.visualAnchor, vim.cursor);
+  }
+  function flashYank(ctx, map, action, visualRange) {
+    if (!action)
+      return;
+    const input = focusedInput(ctx);
+    if (!input)
+      return;
+    const range = visualRange ?? yankedTextRange(map, vim.cursor, action.text);
+    if (!range)
+      return;
+    cancelYankFlash();
+    yankFlashActive = true;
+    setYankSelection(input, range.start, range.end, ctx);
+    ctx.requestRender();
+    yankTimer = setTimeout(() => {
+      yankTimer = undefined;
+      if (!yankFlashActive)
+        return;
+      yankFlashActive = false;
+      clearVisualSelection(input);
+      ctx.requestRender();
+    }, YANK_FLASH_MS);
+  }
+  function cancelYankFlash() {
+    if (yankTimer)
+      clearTimeout(yankTimer);
+    yankTimer = undefined;
+    yankFlashActive = false;
+  }
+  function shouldFlashYankFor(key) {
+    if (isVisualMode(vim.mode))
+      return key === "y";
+    return vim.operator === "y";
+  }
+}
+function readOnlyKey(key, ctrl, vim) {
+  if (key === "Escape")
+    return true;
+  if (ctrl)
+    return false;
+  if (vim.phase === "char-pending" || vim.phase === "text-object-pending" || vim.phase === "register-pending")
+    return true;
+  if (vim.phase === "g-pending")
+    return ["g", "j", "k", "0", "^", "$", "ArrowDown", "ArrowUp"].includes(key);
+  if ((vim.phase === "operator-pending" || isVisualMode(vim.mode)) && (key === "i" || key === "a"))
+    return true;
+  return /^[0-9hjklwWbBeE$^gGfFtT;,vVy%{}()"]$/.test(key) || ["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End"].includes(key);
+}
+function forwardWordRange(key, start, buffer, count) {
+  let {
+    line,
+    col
+  } = start;
+  for (let index = 0;index < count; index++) {
+    const text = buffer.getLine(line);
+    const kind = wordClass(text[col], key === "W");
+    while (col < text.length && wordClass(text[col], key === "W") === kind)
+      col++;
+    while (col < text.length && /\s/.test(text[col]))
+      col++;
+    while (col >= buffer.getLineLength(line) && line < buffer.getLineCount() - 1) {
+      line++;
+      col = 0;
+      const next = buffer.getLine(line);
+      if (!next.length)
+        break;
+      while (col < next.length && /\s/.test(next[col]))
+        col++;
+      if (col < next.length)
+        break;
+    }
+  }
+  return {
+    start,
+    end: {
+      line,
+      col
+    },
+    linewise: false,
+    inclusive: false
+  };
+}
+function wordClass(char, big) {
+  if (!char || /\s/.test(char))
+    return "space";
+  return big || /\w/.test(char) ? "word" : "punctuation";
+}
+function visualCharRange(map, anchor, cursor) {
+  const anchorOffset = hostOffset(map, anchor);
+  const cursorOffset = hostOffset(map, cursor);
+  return hostRange(map, anchorOffset, cursorOffset);
+}
+function visualLineRange(map, anchor, cursor) {
+  const startLine = Math.min(anchor.line, cursor.line);
+  const endLine = Math.max(anchor.line, cursor.line);
+  const start = hostOffset(map, {
+    line: startLine,
+    col: 0
+  });
+  const end = hostOffset(map, {
+    line: endLine,
+    col: vimLineLength(map.vimText, endLine)
+  });
+  return hostRange(map, start, end);
+}
+function yankedTextRange(map, cursor, text) {
+  if (!text)
+    return;
+  if (text.endsWith(`
+`)) {
+    const lineCount = text.split(`
+`).length - 1;
+    return visualLineRange(map, cursor, {
+      line: cursor.line + Math.max(0, lineCount - 1),
+      col: 0
+    });
+  }
+  const start = vimOffsetFromPosition(map.vimText, cursor);
+  return vimOffsetRange(map, start, start + text.length - 1);
+}
+function motionHostRange(map, range) {
+  if (range.linewise)
+    return visualLineRange(map, range.start, range.end);
+  const start = vimOffsetFromPosition(map.vimText, range.start);
+  const end = vimOffsetFromPosition(map.vimText, range.end);
+  return vimOffsetRange(map, start, end);
+}
+function vimOffsetRange(map, left, right) {
+  const start = hostFromVimOffset(map, Math.min(left, right));
+  const end = hostFromVimOffset(map, Math.max(left, right));
+  return hostRange(map, start, end);
+}
+function hostRange(map, left, right) {
+  if (!map.hostText)
+    return;
+  const dw = displayWidth(map.hostText);
+  const start = clamp2(Math.min(left, right), 0, Math.max(0, dw - 1));
+  const end = clamp2(Math.max(left, right), 0, Math.max(0, dw - 1));
+  return {
+    start,
+    end
+  };
+}
+function yankAction(actions) {
+  return actions.find((action) => action.type === "yank");
+}
+function setSelection(input, start, end, ctx) {
+  setSelectionColors(input, start, end, ctx.api.theme.current.warning, ctx.api.theme.current.background);
+}
+function setYankSelection(input, start, end, ctx) {
+  setSelectionColors(input, start, end, ctx.api.theme.current.info, ctx.api.theme.current.background);
+}
+function setSelectionColors(input, start, end, background, foreground) {
+  input.selectionBg = background;
+  input.selectionFg = foreground;
+  if (input.setSelectionInclusive) {
+    input.setSelectionInclusive(start, end);
+    return;
+  }
+  const exclusiveEnd = end + 1;
+  if (input.setSelection) {
+    input.setSelection(start, exclusiveEnd);
+    return;
+  }
+  input.editorView?.setSelection?.(start, exclusiveEnd, background, foreground);
+}
+function clearVisualSelection(input) {
+  if (input.clearSelection) {
+    input.clearSelection();
+    return;
+  }
+  input.editorView?.resetSelection?.();
+}
+function isVisualMode(mode) {
+  return mode === "visual" || mode === "visual-line";
+}
+function vimLineLength(text, line) {
+  return text.split(`
+`)[line]?.length ?? 0;
+}
+function vimOffsetFromPosition(text, position) {
+  const lines = text.split(`
+`);
+  const line = clamp2(position.line, 0, Math.max(0, lines.length - 1));
+  let offset = 0;
+  for (let index = 0;index < line; index++)
+    offset += lines[index].length + 1;
+  return offset + clamp2(position.col, 0, lines[line]?.length ?? 0);
+}
+function clampNormalCursor(input) {
+  const cursor = input.visualCursor;
+  const offset = input.cursorOffset;
+  const text = input.plainText;
+  if (!cursor || offset === undefined || text === undefined)
+    return;
+  if (cursor.visualCol === 0)
+    return;
+  const dw = displayWidth(text);
+  if (offset >= dw) {
+    input.cursorOffset = charToDisplay(text, displayToChar(text, Math.max(0, dw - 1)));
+    return;
+  }
+  const charIdx = displayToChar(text, offset);
+  if (charIdx < text.length && text[charIdx] === `
+`) {
+    input.cursorOffset = charToDisplay(text, displayToChar(text, Math.max(0, offset - 1)));
+  }
+}
+function dispatchCommand(command, ctx) {
+  const input = focusedInput(ctx);
+  if (command === "prompt.history.previous" && input)
+    input.cursorOffset = 0;
+  if (command === "prompt.history.next" && input)
+    input.cursorOffset = input.plainText?.length ?? 0;
+  const result = ctx.api.keymap.dispatchCommand(command);
+  if (command !== "prompt.history.next" || !result.ok)
+    return result;
+  const nextInput = focusedInput(ctx);
+  if (nextInput?.plainText !== undefined)
+    nextInput.cursorOffset = displayWidth(nextInput.plainText);
+  return result;
+}
+function defaultHistoryCommand(key, text, historyText, enabled) {
+  if (key !== "j" && key !== "k")
+    return;
+  if (!enabled[key])
+    return;
+  if (text.length > 0 && text !== historyText)
+    return;
+  return key === "k" ? "prompt.history.previous" : "prompt.history.next";
+}
+function hasNormalKeyPrefix(config, key) {
+  for (const sequence of Object.keys(config.keymaps.normal ?? {})) {
+    try {
+      if (keyToken(parseKeySequence2(sequence)[0] ?? "") === key)
+        return true;
+    } catch {}
+  }
+  return false;
+}
+function createKeybinds(config, log) {
+  const map = createKeybindMap();
+  let count = 0;
+  for (const [mode, keymaps] of Object.entries(config.keymaps)) {
+    if (!keymaps)
+      continue;
+    for (const [keys, action] of Object.entries(keymaps)) {
+      try {
+        const tokens = parseKeySequence2(keys);
+        if (tokens.length > 1 && tokens[0] === "<CR>")
+          throw new Error("<CR> cannot start a multi-key mapping");
+        map.addKeybind(mode, keys, keybindAction(action));
+        count++;
+      } catch (error) {
+        log("vimee.keymap.invalid", {
+          mode,
+          keys,
+          action,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  return count > 0 ? map : undefined;
+}
+function keybindAction(action) {
+  if (action.startsWith("command:")) {
+    const command = action.slice(8).trim();
+    if (!command)
+      throw new Error("Command name is required");
+    return {
+      execute: () => [{
+        type: "command",
+        command
+      }],
+      hostAction: "command",
+      command
+    };
+  }
+  switch (action) {
+    case "normal":
+      return {
+        keys: "<Esc>",
+        hostAction: "normal"
+      };
+    case "insert":
+      return {
+        keys: "i"
+      };
+    case "submit":
+      return {
+        execute: () => [{
+          type: "submit"
+        }],
+        hostAction: "submit"
+      };
+    default:
+      return {
+        keys: action
+      };
+  }
+}
+function keyForVimee(event, key) {
+  if (key === "<C-[>")
+    return "Escape";
+  if (event.ctrl)
+    return event.name?.toLowerCase();
+  const token = keyToken(key);
+  return token.startsWith("<") ? undefined : token;
+}
+function keyToken(token) {
+  if (token === "<Esc>" || token === "<C-[>")
+    return "Escape";
+  if (token === "<CR>")
+    return "Enter";
+  if (token === "<Tab>")
+    return "Tab";
+  if (token === "<BS>")
+    return "Backspace";
+  if (token === "<Del>")
+    return "Delete";
+  if (token === "<Space>")
+    return " ";
+  if (token === "<Up>")
+    return "ArrowUp";
+  if (token === "<Down>")
+    return "ArrowDown";
+  if (token === "<Left>")
+    return "ArrowLeft";
+  if (token === "<Right>")
+    return "ArrowRight";
+  if (token === "<Home>")
+    return "Home";
+  if (token === "<End>")
+    return "End";
+  if (token.startsWith("<C-") && token.endsWith(">"))
+    return token.slice(3, -1).toLowerCase();
+  return token;
+}
+function tokenCtrl(token) {
+  return token.startsWith("<C-") && token !== "<C-[>";
+}
+function syncMode(state, mode) {
+  state.setMode(mode === "insert" || mode === "visual" || mode === "visual-line" ? mode : "normal");
+}
+function pendingDisplay(ctx, keybindPending) {
+  const count = ctx.count > 0 ? String(ctx.count) : "";
+  if (ctx.phase === "operator-pending")
+    return count + (ctx.operator ?? "");
+  if (ctx.phase === "text-object-pending")
+    return count + (ctx.operator ?? "") + (ctx.textObjectModifier ?? "");
+  if (ctx.phase === "char-pending")
+    return count + (ctx.operator ?? "") + (ctx.charCommand ?? "");
+  if (keybindPending)
+    return ctx.statusMessage;
+  return count;
+}
+function plainPending(value) {
+  return value.includes("<") || value.includes(">") ? "" : value;
+}
+function consumesKey(key, actions, ctx, keybindPending) {
+  if (actions.length > 0)
+    return true;
+  if (keybindPending)
+    return true;
+  if (ctx.phase !== "idle")
+    return true;
+  return ctx.mode !== "insert" || key === "Escape";
+}
+function textObjectAlias(key, ctx) {
+  if (ctx.phase !== "text-object-pending")
+    return;
+  if (key === "b")
+    return "(";
+  if (key === "B")
+    return "{";
+  return;
+}
+function textObjectOperator(operator) {
+  return operator === "y" || operator === "d" || operator === "c";
+}
+function resolvePromptTextObject(modifier, key, cursor, buffer) {
+  if (key === "q")
+    return quoteRange(modifier, cursor, buffer);
+  if (key !== "p")
+    return null;
+  return paragraphRange(modifier, cursor, buffer);
+}
+function quoteRange(modifier, cursor, buffer) {
+  const pair = quoteObjectPair(cursor, buffer);
+  if (!pair)
+    return null;
+  const start = modifier === "i" ? pair.open + 1 : pair.open;
+  const end = modifier === "i" ? pair.close - 1 : pair.close;
+  return {
+    start: {
+      line: cursor.line,
+      col: start
+    },
+    end: {
+      line: cursor.line,
+      col: Math.max(start, end)
+    },
+    linewise: false,
+    inclusive: end >= start
+  };
+}
+function paragraphRange(modifier, cursor, buffer) {
+  const count = buffer.getLineCount();
+  if (count === 0)
+    return null;
+  let start = clamp2(cursor.line, 0, count - 1);
+  while (start < count && blankLine(buffer.getLine(start)))
+    start++;
+  if (start >= count) {
+    start = clamp2(cursor.line, 0, count - 1);
+    while (start >= 0 && blankLine(buffer.getLine(start)))
+      start--;
+  }
+  if (start < 0 || start >= count)
+    return null;
+  let end = start;
+  while (start > 0 && !blankLine(buffer.getLine(start - 1)))
+    start--;
+  while (end < count - 1 && !blankLine(buffer.getLine(end + 1)))
+    end++;
+  if (modifier === "a") {
+    if (end < count - 1 && blankLine(buffer.getLine(end + 1))) {
+      end++;
+      while (end < count - 1 && blankLine(buffer.getLine(end + 1)))
+        end++;
+    } else {
+      while (start > 0 && blankLine(buffer.getLine(start - 1)))
+        start--;
+    }
+  }
+  return {
+    start: {
+      line: start,
+      col: 0
+    },
+    end: {
+      line: end,
+      col: Math.max(0, buffer.getLineLength(end) - 1)
+    },
+    linewise: true,
+    inclusive: true
+  };
+}
+function quoteObjectPair(cursor, buffer) {
+  let best;
+  for (const quote of ['"', "'", "`"]) {
+    const pair = quotePair(cursor, buffer, quote);
+    if (!pair)
+      continue;
+    if (!best || pair.distance < best.distance)
+      best = pair;
+  }
+  return best;
+}
+function quotePair(cursor, buffer, quote) {
+  const line = buffer.getLine(cursor.line);
+  let open = -1;
+  let close = -1;
+  let inQuote = false;
+  let quoteStart = -1;
+  for (let index = 0;index < line.length; index++) {
+    if (line[index] !== quote || escaped(line, index))
+      continue;
+    if (!inQuote) {
+      quoteStart = index;
+      inQuote = true;
+      continue;
+    }
+    if (cursor.col >= quoteStart && cursor.col <= index) {
+      return {
+        open: quoteStart,
+        close: index,
+        distance: 0
+      };
+    }
+    inQuote = false;
+  }
+  for (let index = cursor.col;index < line.length; index++) {
+    if (line[index] !== quote || escaped(line, index))
+      continue;
+    if (open === -1)
+      open = index;
+    else {
+      close = index;
+      break;
+    }
+  }
+  if (open !== -1 && close !== -1)
+    return {
+      open,
+      close,
+      distance: open - cursor.col
+    };
+  close = -1;
+  open = -1;
+  for (let index = cursor.col;index >= 0; index--) {
+    if (line[index] !== quote || escaped(line, index))
+      continue;
+    if (close === -1)
+      close = index;
+    else {
+      open = index;
+      break;
+    }
+  }
+  if (open !== -1 && close !== -1)
+    return {
+      open,
+      close,
+      distance: cursor.col - close
+    };
+  return;
+}
+function executeTextObject(operator, range, buffer, ctx) {
+  if (operator !== "y")
+    buffer.saveUndoPoint(ctx.cursor);
+  if (operator === ">" || operator === "<") {
+    const result = executeOperatorOnRange(operator, range, buffer, ctx.cursor, {
+      style: ctx.indentStyle,
+      width: ctx.indentWidth
+    });
+    const cursor = {
+      line: result.newCursor.line,
+      col: Math.max(0, buffer.getLine(result.newCursor.line).search(/\S/))
+    };
+    return {
+      actions: [...result.actions, {
+        type: "cursor-move",
+        position: cursor
+      }],
+      context: {
+        ...resetContext(ctx),
+        cursor
+      },
+      yankedText: ""
+    };
+  }
+  const result = range.linewise ? executeLinewiseTextObject(operator, range, buffer, ctx.cursor) : executeCharwiseTextObject(operator, range, buffer);
+  const registers = ctx.selectedRegister ? {
+    ...ctx.registers,
+    [ctx.selectedRegister]: result.yankedText
+  } : ctx.registers;
+  const context = {
+    ...resetContext(ctx),
+    mode: result.mode,
+    cursor: result.cursor,
+    register: result.yankedText,
+    registers,
+    statusMessage: result.statusMessage
+  };
+  const actions = [{
+    type: "yank",
+    text: result.yankedText
+  }, ...result.actions, {
+    type: "mode-change",
+    mode: result.mode
+  }, {
+    type: "cursor-move",
+    position: result.cursor
+  }];
+  return {
+    actions,
+    context,
+    yankedText: result.yankedText
+  };
+}
+function executeLinewiseTextObject(operator, range, buffer, cursor) {
+  const startLine = Math.min(range.start.line, range.end.line);
+  const endLine = Math.max(range.start.line, range.end.line);
+  const lineCount = endLine - startLine + 1;
+  const yankedText = buffer.getLines().slice(startLine, endLine + 1).join(`
+`) + `
+`;
+  if (operator === "y") {
+    const col = Math.min(cursor.col, Math.max(0, buffer.getLineLength(startLine) - 1));
+    return {
+      actions: [],
+      cursor: {
+        line: startLine,
+        col
+      },
+      mode: "normal",
+      yankedText,
+      statusMessage: lineCount >= 2 ? `${lineCount} lines yanked` : ""
+    };
+  }
+  buffer.deleteLines(startLine, lineCount);
+  if (operator === "c")
+    buffer.insertLine(startLine, "");
+  else if (buffer.getLineCount() === 0)
+    buffer.insertLine(0, "");
+  const line = Math.min(startLine, buffer.getLineCount() - 1);
+  return {
+    actions: [{
+      type: "content-change",
+      content: buffer.getContent()
+    }],
+    cursor: {
+      line,
+      col: 0
+    },
+    mode: operator === "c" ? "insert" : "normal",
+    yankedText,
+    statusMessage: lineCount >= 2 ? `${lineCount} fewer lines` : ""
+  };
+}
+function executeCharwiseTextObject(operator, range, buffer) {
+  const ordered = orderedRange(range);
+  const endCol = range.inclusive ? ordered.end.col + 1 : ordered.end.col;
+  const yankedText = textInRange(buffer, ordered.start, {
+    line: ordered.end.line,
+    col: endCol
+  });
+  if (operator === "y") {
+    return {
+      actions: [],
+      cursor: ordered.start,
+      mode: "normal",
+      yankedText,
+      statusMessage: yankedText.split(`
+`).length >= 2 ? `${yankedText.split(`
+`).length} lines yanked` : ""
+    };
+  }
+  const linesBefore = buffer.getLineCount();
+  buffer.deleteRange(ordered.start.line, ordered.start.col, ordered.end.line, endCol);
+  const linesRemoved = linesBefore - buffer.getLineCount();
+  return {
+    actions: [{
+      type: "content-change",
+      content: buffer.getContent()
+    }],
+    cursor: {
+      line: ordered.start.line,
+      col: operator === "c" ? ordered.start.col : Math.min(ordered.start.col, Math.max(0, buffer.getLineLength(ordered.start.line) - 1))
+    },
+    mode: operator === "c" ? "insert" : "normal",
+    yankedText,
+    statusMessage: linesRemoved >= 2 ? `${linesRemoved} fewer lines` : ""
+  };
+}
+function orderedRange(range) {
+  if (range.start.line > range.end.line || range.start.line === range.end.line && range.start.col > range.end.col) {
+    return {
+      start: range.end,
+      end: range.start
+    };
+  }
+  return {
+    start: range.start,
+    end: range.end
+  };
+}
+function textInRange(buffer, start, end) {
+  if (start.line === end.line)
+    return buffer.getLine(start.line).slice(start.col, end.col);
+  const lines = [buffer.getLine(start.line).slice(start.col)];
+  for (let line = start.line + 1;line < end.line; line++)
+    lines.push(buffer.getLine(line));
+  lines.push(buffer.getLine(end.line).slice(0, end.col));
+  return lines.join(`
+`);
+}
+function blankLine(line) {
+  return line.trim().length === 0;
+}
+function escaped(line, index) {
+  let slashCount = 0;
+  for (let cursor = index - 1;cursor >= 0 && line[cursor] === "\\"; cursor--)
+    slashCount++;
+  return slashCount % 2 === 1;
+}
+function clamp2(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// view.tsx
+import { effect as _$effect } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { insertNode as _$insertNode } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { insert as _$insert } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { memo as _$memo } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { setProp as _$setProp } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createElement as _$createElement } from "opentui:runtime-module:%40opentui%2Fsolid";
+function VimStatus(props) {
+  return (() => {
+    var _el$ = _$createElement("box"), _el$2 = _$createElement("text");
+    _$insertNode(_el$, _el$2);
+    _$setProp(_el$, "paddingRight", 1);
+    _$setProp(_el$, "flexDirection", "row");
+    _$setProp(_el$, "flexShrink", 0);
+    _$insert(_el$2, (() => {
+      var _c$ = _$memo(() => !!props.enabled());
+      return () => _c$() ? modeLabel(props.mode()) : "";
+    })());
+    _$effect((_$p) => _$setProp(_el$2, "fg", props.mode() === "insert" ? props.theme.success : props.theme.warning, _$p));
+    return _el$;
+  })();
+}
+function modeLabel(mode) {
+  if (mode === "visual")
+    return "VISUAL";
+  if (mode === "visual-line")
+    return "VISUAL LINE";
+  return mode === "normal" ? "NORMAL" : "INSERT";
+}
+
+// src/session.tsx
+import { use as _$use } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createTextNode as _$createTextNode } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { insertNode as _$insertNode2 } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { setProp as _$setProp2 } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { effect as _$effect2 } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { insert as _$insert2 } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createElement as _$createElement2 } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createComponent as _$createComponent } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { memo as _$memo2 } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { useTerminalDimensions } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createEffect, createSignal as createSignal2, onCleanup, onMount, untrack } from "opentui:runtime-module:solid-js";
+
+// src/transcript.tsx
+import { MouseEvent, ScrollBoxRenderable } from "opentui:runtime-module:%40opentui%2Fcore";
+
+// src/transcript-items.tsx
+import { MarkdownRenderable, TextBufferRenderable } from "opentui:runtime-module:%40opentui%2Fcore";
+function parts(messages) {
+  const result = [];
+  for (const message of messages) {
+    if (message.type === "assistant") {
+      const ordinal = {
+        text: 0,
+        reasoning: 0
+      };
+      for (const part of message.content) {
+        const partID = part.type === "tool" ? part.id : `${part.type}:${ordinal[part.type]++}`;
+        let text = part.type === "tool" ? "" : part.text;
+        if (part.type === "reasoning")
+          text = text.replace("[REDACTED]", "");
+        if (part.type !== "tool" && !text.trim())
+          continue;
+        result.push({
+          id: `session-part:${message.id}:${partID}`,
+          messageID: message.id,
+          kind: part.type,
+          author: part.type === "text" ? "Assistant" : part.type === "reasoning" ? "Reasoning" : part.name,
+          text,
+          group: part.type === "reasoning" ? "reasoning" : part.type === "tool" && ["read", "glob", "grep", "webfetch", "websearch"].includes(part.name.toLowerCase()) ? "exploration" : undefined
+        });
+      }
+      if (message.finish && message.finish !== "tool-calls" && message.finish !== "unknown" || message.error || message.retry) {
+        result.push({
+          id: `footer:${message.id}`,
+          messageID: message.id,
+          kind: "footer",
+          author: "",
+          text: ""
+        });
+      }
+    } else {
+      result.push({
+        id: message.id,
+        messageID: message.id,
+        kind: "message",
+        author: message.type === "user" ? "You" : message.type,
+        text: message.type === "user" ? message.text : ""
+      });
+    }
+  }
+  return result;
+}
+function textOf(node) {
+  if (!node.visible)
+    return "";
+  if (node instanceof MarkdownRenderable)
+    return node.content;
+  if (node instanceof TextBufferRenderable)
+    return node.plainText;
+  let text = "";
+  let previous;
+  for (const child of node.getChildren()) {
+    const value = textOf(child);
+    if (!value)
+      continue;
+    if (text)
+      text += previous?.y === child.y ? " " : `
+`;
+    text += value;
+    previous = child;
+  }
+  return text;
+}
+function groupAt(node) {
+  const header = node.getChildren()[0];
+  if (!header)
+    return;
+  const body = header.getChildren()[0];
+  let label;
+  if (body instanceof TextBufferRenderable) {
+    if (!body.plainText.startsWith("\u22EF "))
+      return;
+    label = body.plainText.slice(2).trim();
+  } else {
+    const cells = body?.getChildren() ?? [];
+    if (cells.length < 2 || !cells.slice(1).every((cell) => cell instanceof TextBufferRenderable))
+      return;
+    label = cells.slice(1).map((cell) => cell.plainText).join(" ").trim();
+  }
+  let kind;
+  if (/^(Thought|Thinking)(?:$|[: \u00B7\u2026])/.test(label))
+    kind = "reasoning";
+  else if (/^Explor(?:ed|ing):/.test(label))
+    kind = "exploration";
+  else if (/^Instructions:/.test(label))
+    kind = "instructions";
+  else if (/^(?:\d+ (?:commands?|edits?|thoughts?|reads?|tools?|instructions?)(?:, |$))+$/.test(label) || /^(?:Running|Preparing) .+\u2026$/.test(label))
+    kind = "activity";
+  else
+    return;
+  return {
+    header,
+    kind,
+    label,
+    children: node.getChildren().slice(1)
+  };
+}
+function transcriptItems(rows, messages) {
+  const sources = parts(messages);
+  const ranges = [];
+  let cursor = 0;
+  let lastSource = -1;
+  function add(node, source, parentID) {
+    const text = source?.text || textOf(node);
+    if (!text.trim())
+      return;
+    ranges.push({
+      id: source?.id ?? node.id,
+      author: source?.author ?? "Tool",
+      text,
+      node,
+      top: node.y,
+      bottom: node.y + node.height,
+      parentID
+    });
+  }
+  function group(node, parentID) {
+    const info = groupAt(node);
+    if (!info)
+      return false;
+    const id = node.id;
+    ranges.push({
+      id,
+      author: info.label,
+      text: info.label,
+      node: info.header,
+      top: info.header.y,
+      bottom: info.header.y + info.header.height,
+      toggle: info.header,
+      parentID
+    });
+    let children = info.children;
+    if (info.kind !== "exploration" && children.length) {
+      children = [...children[0].getChildren(), ...children.slice(1)];
+    }
+    for (const child of children) {
+      if (!child.visible || !child.height)
+        continue;
+      if (!group(child, id))
+        add(child, undefined, id);
+    }
+    return true;
+  }
+  for (const row of rows) {
+    if (row.id === "session-navigation-slack")
+      break;
+    if (!row.visible || !row.height)
+      continue;
+    const anchor = row.getChildren()[0];
+    const info = anchor && groupAt(anchor);
+    let index = sources.findIndex((part) => part.id === row.id);
+    if (index === -1) {
+      index = sources.findIndex((part, position) => position >= cursor && part.messageID === row.id);
+      if (index !== -1 && !info) {
+        const text = textOf(row).trim();
+        const match = sources.findIndex((part, position) => position >= cursor && part.messageID === row.id && part.text.trim() === text);
+        if (text && match !== -1)
+          index = match;
+      }
+    }
+    if (index !== -1)
+      cursor = index;
+    if (!info && index === -1 && sources[cursor]?.kind === "footer") {
+      lastSource = cursor++;
+      continue;
+    }
+    const container = anchor && !(anchor instanceof TextBufferRenderable) && !(anchor instanceof MarkdownRenderable);
+    if (index === -1 && !info && sources[cursor]?.group && container)
+      index = cursor;
+    if (anchor && info) {
+      group(anchor);
+      while (cursor < sources.length) {
+        const part = sources[cursor];
+        if (info.kind === "activity" ? part.kind !== "tool" && part.kind !== "reasoning" : part.group !== info.kind)
+          break;
+        lastSource = cursor++;
+      }
+    } else if (index !== -1) {
+      const source = sources[index];
+      if (source.kind === "footer") {
+        lastSource = cursor++;
+      } else if (source.group && container && anchor.getChildren().length) {
+        for (const child of anchor.getChildren()) {
+          add(child, sources[cursor]);
+          cursor++;
+        }
+        lastSource = cursor - 1;
+      } else {
+        add(row, source);
+        lastSource = cursor++;
+      }
+    }
+  }
+  let last = sources.length - 1;
+  while (last >= 0 && (sources[last].kind === "message" || sources[last].kind === "footer") && !sources[last].text)
+    last--;
+  return {
+    ranges,
+    hasLatest: lastSource >= last
+  };
+}
+
+// src/transcript.tsx
+function createTranscriptSelection(context, sessionID, select) {
+  let scroll;
+  let requestedID;
+  let selectedParents = [];
+  let navigation;
+  function choose(range, view) {
+    requestedID = range.id;
+    select(requestedID);
+    let delta = 0;
+    if (range.bottom <= view.top)
+      delta = range.top - view.top;
+    else if (range.top >= view.bottom) {
+      delta = range.top - view.top - Math.max(0, view.bottom - view.top - (range.bottom - range.top));
+    }
+    if (delta) {
+      const slack = view.scroll.getRenderable("session-navigation-slack")?.height ?? 0;
+      const maximum = Math.max(0, view.scroll.scrollHeight - slack - view.scroll.viewport.height);
+      const position = Math.max(0, Math.min(maximum, view.scroll.scrollTop + delta));
+      if (slack)
+        context.keymap.dispatch(delta < 0 ? "session.line.up" : "session.line.down");
+      view.scroll.scrollTo(position);
+    }
+    context.renderer.requestRender();
+  }
+  function advance() {
+    if (!navigation)
+      return;
+    const view = inspect();
+    const ranges = view?.ranges ?? [];
+    const from = navigation.from ? ranges.findIndex((range) => range.id === navigation.from) : ranges.length;
+    if (navigation.from && from === -1) {
+      navigation = undefined;
+      return;
+    }
+    const target = navigation.latest ? ranges.length - 1 : from + navigation.offset;
+    const loading = navigation.loading;
+    if (loading && context.renderer.frameId < loading.frame) {
+      context.renderer.requestRender();
+      return;
+    }
+    if (view && loading?.up && view.scroll.scrollHeight > loading.height) {
+      const maximum = Math.max(0, view.scroll.scrollHeight - view.scroll.viewport.height);
+      const compensated = Math.max(0, Math.min(maximum, view.scroll.scrollHeight - loading.height - 1));
+      if (view.scroll.scrollTop < compensated)
+        return;
+    }
+    if (view && target >= 0 && target < ranges.length && (!navigation.latest || view.hasLatest)) {
+      navigation = undefined;
+      choose(ranges[target], view);
+      return;
+    }
+    const up = !navigation.latest && target < 0;
+    const messages = context.data.session.message.list(sessionID);
+    const key = `${messages[0]?.id}:${messages.length}:${ranges[0]?.id}:${ranges.at(-1)?.id}:${view?.scroll.scrollHeight}`;
+    if (loading?.key === key)
+      return;
+    navigation.loading = {
+      key,
+      frame: context.renderer.frameId + 2,
+      up,
+      height: view?.scroll.scrollHeight ?? 0
+    };
+    view?.scroll.scrollTo(up ? 0 : view.scroll.scrollHeight);
+    context.keymap.dispatch(up ? "session.line.up" : "session.line.down");
+    context.renderer.requestRender();
+  }
+  function latest() {
+    if (!context.data.session.message.list(sessionID).length) {
+      navigation = undefined;
+      requestedID = undefined;
+      select(undefined);
+      return;
+    }
+    navigation = {
+      from: undefined,
+      offset: 0,
+      latest: true
+    };
+    advance();
+  }
+  function move(direction, count) {
+    if (navigation && (navigation.latest || navigation.offset < 0 && direction === "next" || navigation.offset > 0 && direction === "previous")) {
+      navigation = undefined;
+    }
+    navigation ??= {
+      from: requestedID ?? inspect()?.selected?.id,
+      offset: 0
+    };
+    navigation.offset += direction === "next" ? count : -count;
+    if (navigation.loading)
+      navigation.loading.key = "";
+    advance();
+  }
+  function inspect() {
+    const messages = context.data.session.message.list(sessionID);
+    const ids = new Set(messages.map((message) => message.id));
+    function isRow(node) {
+      if (ids.has(node.id) || node.id?.startsWith("session-part:") && ids.has(node.id.split(":")[1]))
+        return true;
+      const anchor = node.getChildren()[0];
+      return Boolean(anchor && groupAt(anchor));
+    }
+    function findScroll(node) {
+      if (!node.visible)
+        return;
+      if (node instanceof ScrollBoxRenderable && node.getChildren().some(isRow))
+        return node;
+      for (const child of node.getChildren()) {
+        const found = findScroll(child);
+        if (found)
+          return found;
+      }
+    }
+    if (!scroll || scroll.isDestroyed)
+      scroll = findScroll(context.renderer.root);
+    if (!scroll) {
+      select(undefined);
+      return;
+    }
+    const {
+      ranges,
+      hasLatest
+    } = transcriptItems(scroll.getChildren(), messages);
+    const top = scroll.viewport.y;
+    const bottom = top + scroll.viewport.height;
+    let selected = ranges.find((range) => range.id === requestedID);
+    if (!selected && requestedID) {
+      for (const id of selectedParents) {
+        selected = ranges.find((range) => range.id === id);
+        if (selected) {
+          requestedID = id;
+          break;
+        }
+      }
+      if (!selected)
+        requestedID = undefined;
+    }
+    selected ??= ranges.find((range) => range.top <= top + 1 && range.bottom > top + 1) ?? ranges.find((range) => range.bottom > top && range.top < bottom);
+    selectedParents = [];
+    let parent = selected?.parentID;
+    while (parent) {
+      selectedParents.push(parent);
+      parent = ranges.find((range) => range.id === parent)?.parentID;
+    }
+    select(selected?.id);
+    return {
+      scroll,
+      selected,
+      ranges,
+      hasLatest,
+      top,
+      bottom
+    };
+  }
+  return {
+    latest,
+    move,
+    get(id) {
+      if (!scroll || scroll.isDestroyed)
+        return;
+      return transcriptItems(scroll.getChildren(), context.data.session.message.list(sessionID)).ranges.find((range) => range.id === id);
+    },
+    toggle() {
+      const range = inspect()?.selected;
+      if (!range?.toggle)
+        return false;
+      navigation = undefined;
+      requestedID = range.id;
+      const node = range.toggle;
+      node.processMouseEvent(new MouseEvent(node, {
+        type: "up",
+        button: 0,
+        x: node.x,
+        y: node.y,
+        modifiers: {
+          shift: false,
+          alt: false,
+          ctrl: false
+        }
+      }));
+      context.renderer.requestRender();
+      return true;
+    },
+    followViewport() {
+      navigation = undefined;
+      requestedID = undefined;
+      selectedParents = [];
+    },
+    focus() {
+      inspect()?.scroll.focus();
+    },
+    sync() {
+      advance();
+      navigation = undefined;
+      return inspect();
+    },
+    draw(buffer, yankID) {
+      advance();
+      const view = inspect();
+      if (!view?.selected)
+        return;
+      const top = Math.max(0, view.top, view.selected.top);
+      const bottom = Math.min(buffer.height, view.bottom, view.selected.bottom);
+      if (view.selected.id === yankID) {
+        const node = view.selected.node;
+        const left = Math.max(0, view.scroll.viewport.x, node.x);
+        const right = Math.min(buffer.width, view.scroll.viewport.x + view.scroll.viewport.width, node.x + node.width);
+        const foreground = context.theme.background.base.buffer;
+        const background = context.theme.text.feedback.info.base.buffer;
+        const colors = buffer.buffers;
+        for (let y = top;y < bottom; y++) {
+          for (let x = left;x < right; x++) {
+            const offset = (y * buffer.width + x) * 4;
+            colors.fg.set(foreground, offset);
+            colors.bg.set(background, offset);
+          }
+        }
+      }
+      const x = view.scroll.x - 1;
+      if (x < 0)
+        return;
+      for (let y = top;y < bottom; y++) {
+        buffer.drawText("\u258E", x, y, context.theme.text.feedback.info.base, context.theme.background.base);
+      }
+    }
+  };
+}
+
+// src/session.tsx
+var SESSION_MODE = "opencode-vim.session";
+function createSessionMode(context, config, clipboard) {
+  const [active, setActive] = createSignal2(false);
+  const [reading, setReading] = createSignal2();
+  const [notice, setNotice] = createSignal2("");
+  const positions = new Map;
+  let sessionID = "";
+  let selectedID;
+  let prompt = null;
+  let transcript;
+  let popMode;
+  let prefix = "";
+  let count = "";
+  let disposed = false;
+  let noticeTimer;
+  let yankTimer;
+  let yankID;
+  function selected() {
+    return transcript?.get(selectedID);
+  }
+  function clearYankFlash() {
+    if (yankTimer)
+      clearTimeout(yankTimer);
+    yankTimer = undefined;
+    if (!yankID)
+      return;
+    yankID = undefined;
+    context.renderer.requestRender();
+  }
+  function close() {
+    if (!active())
+      return;
+    clearYankFlash();
+    const wasReading = Boolean(reading());
+    if (wasReading)
+      context.ui.dialog.clear();
+    setActive(false);
+    context.renderer.removePostProcessFn(draw);
+    popMode?.();
+    popMode = undefined;
+    transcript = undefined;
+    const savedPrompt = prompt;
+    const savedSessionID = sessionID;
+    function restorePrompt() {
+      const route = context.ui.router.current();
+      if (!active() && context.keymap.mode.current() === "base" && route.type === "session" && route.sessionID === savedSessionID && savedPrompt && !savedPrompt.isDestroyed)
+        savedPrompt.focus();
+    }
+    restorePrompt();
+    if (wasReading)
+      setTimeout(restorePrompt, 1);
+    prompt = null;
+    context.renderer.requestRender();
+  }
+  function enter() {
+    const route = context.ui.router.current();
+    if (route.type !== "session")
+      return false;
+    sessionID = route.sessionID;
+    prompt = context.renderer.currentFocusedEditor;
+    prefix = count = "";
+    positions.clear();
+    setNotice("");
+    popMode = context.keymap.mode.push(SESSION_MODE);
+    transcript = createTranscriptSelection(context, sessionID, (id) => {
+      selectedID = id;
+    });
+    setActive(true);
+    prompt?.blur();
+    transcript.focus();
+    transcript.latest();
+    context.renderer.addPostProcessFn(draw);
+    context.renderer.requestRender();
+    return true;
+  }
+  const draw = (buffer) => {
+    if (active() && !reading() && context.keymap.mode.current() === SESSION_MODE)
+      transcript?.draw(buffer, yankID);
+  };
+  async function copy(text) {
+    const copied = await clipboard.write(text);
+    if (disposed)
+      return;
+    if (noticeTimer)
+      clearTimeout(noticeTimer);
+    setNotice(copied ? "Copied" : "Yanked \xB7 clipboard unavailable");
+    noticeTimer = setTimeout(() => setNotice(""), 1500);
+  }
+  function openMessage(message) {
+    transcript?.focus();
+    setReading(message);
+    context.ui.dialog.show(() => _$createComponent(MessageReader, {
+      context,
+      config,
+      message,
+      get offset() {
+        return positions.get(message.id) ?? 0;
+      },
+      copy,
+      notice,
+      remember: (offset) => positions.set(message.id, offset),
+      back: () => context.ui.dialog.clear(),
+      close
+    }), () => {
+      setReading(undefined);
+      setNotice("");
+    });
+  }
+  const onKey = (event) => {
+    if (!active() || reading())
+      return;
+    const key = readerKey(context, event, config.sessionKey);
+    if (!key)
+      return;
+    event.preventDefault();
+    event.stopPropagation();
+    clearYankFlash();
+    setNotice("");
+    if (key === config.sessionKey || key === "<Esc>" || key === "<C-[>") {
+      close();
+      return;
+    }
+    if (/^[0-9]$/.test(key) && (count || key !== "0")) {
+      count = (count + key).slice(0, 6);
+      return;
+    }
+    const amount = Number(count) || 1;
+    count = "";
+    const previous = prefix;
+    prefix = "";
+    let command = pageCommand(key);
+    if (key === "j" || key === "<Down>") {
+      transcript?.move("next", amount);
+      return;
+    } else if (key === "k" || key === "<Up>") {
+      transcript?.move("previous", amount);
+      return;
+    } else if (key === "G") {
+      transcript?.latest();
+      return;
+    } else if (key === "g" && previous === "g")
+      command = "session.first";
+    else if (key === "y" && previous === "y") {
+      const message = selected();
+      if (message) {
+        yankID = message.id;
+        yankTimer = setTimeout(clearYankFlash, YANK_FLASH_MS);
+        context.renderer.requestRender();
+        copy(message.text);
+      }
+    } else if (key === "g" || key === "y")
+      prefix = key;
+    else if (key === "<CR>") {
+      transcript?.sync();
+      if (transcript?.toggle())
+        return;
+      const message = selected();
+      if (message)
+        openMessage(message);
+    }
+    if (command) {
+      transcript?.followViewport();
+      for (let index = 0;index < amount; index++)
+        context.keymap.dispatch(command);
+    }
+  };
+  createEffect(() => {
+    const route = context.ui.router.current();
+    if (active() && (route.type !== "session" || route.sessionID !== sessionID))
+      untrack(close);
+  });
+  onMount(() => context.renderer.keyInput.prependListener("keypress", onKey));
+  onCleanup(() => {
+    disposed = true;
+    close();
+    if (noticeTimer)
+      clearTimeout(noticeTimer);
+    context.renderer.keyInput.off("keypress", onKey);
+  });
+  return {
+    active,
+    enter,
+    close,
+    Status() {
+      return (() => {
+        var _el$ = _$createElement2("text");
+        _$insert2(_el$, () => notice() || `SESSION \xB7 Enter open \xB7 yy copy \xB7 ${config.sessionKey} prompt`);
+        _$effect2((_$p) => _$setProp2(_el$, "fg", context.theme.text.feedback.info.base, _$p));
+        return _el$;
+      })();
+    }
+  };
+}
+function MessageReader(props) {
+  const context = props.context;
+  context.ui.dialog.set({
+    size: "large",
+    centered: true
+  });
+  const dimensions = useTerminalDimensions();
+  const theme = () => context.theme.surface("dialog");
+  const background = () => theme().background.raised.high;
+  const state = createVimState("normal");
+  const [line, setLine] = createSignal2(1);
+  let input;
+  const adapter = createVimeeAdapter(state, props.config, () => {}, {
+    readOnly: true,
+    onYank: props.copy
+  });
+  const editorContext = {
+    api: {
+      renderer: {
+        get currentFocusedRenderable() {
+          return input;
+        }
+      },
+      keymap: {
+        dispatchCommand: () => ({
+          ok: false
+        })
+      },
+      theme: {
+        get current() {
+          return {
+            warning: theme().text.feedback.warning.base,
+            info: theme().text.feedback.info.base,
+            background: background()
+          };
+        }
+      }
+    },
+    prompt: () => ({
+      get current() {
+        return {
+          input: input.plainText,
+          mode: "normal",
+          parts: []
+        };
+      },
+      set() {},
+      submit() {},
+      blur() {}
+    }),
+    requestRender: () => context.renderer.requestRender()
+  };
+  const onKey = (event) => {
+    if (context.renderer.currentFocusedEditor !== input)
+      return;
+    const key = readerKey(context, event, props.config.sessionKey, "modal");
+    if (!key)
+      return;
+    event.preventDefault();
+    event.stopPropagation();
+    if (key === props.config.sessionKey && state.mode() === "normal" && !adapter.isPending()) {
+      props.close();
+      return;
+    }
+    if (key === "<C-c>") {
+      props.back();
+      return;
+    }
+    if ((key === "<Esc>" || key === "<C-[>") && state.mode() === "normal" && !adapter.isPending()) {
+      props.back();
+      return;
+    }
+    if (pageCommand(key)) {
+      const down = key === "<C-d>" || key === "<C-f>" || key === "<PageDown>";
+      const half = key === "<C-d>" || key === "<C-u>";
+      const rows = Math.max(1, Math.floor(input.height / (half ? 2 : 1)));
+      for (let row = 0;row < rows; row++)
+        adapter.handle({
+          ...event,
+          ctrl: false
+        }, down ? "j" : "k", editorContext);
+    } else
+      adapter.handle(event, key, editorContext);
+    setLine(input.logicalCursor.row + 1);
+  };
+  onMount(() => {
+    input.cursorOffset = Math.min(props.offset, displayWidth(input.plainText));
+    adapter.attach(editorContext);
+    setLine(input.logicalCursor.row + 1);
+    input.focus();
+    context.renderer.keyInput.prependListener("keypress", onKey);
+  });
+  onCleanup(() => {
+    props.remember(input.cursorOffset);
+    context.renderer.keyInput.off("keypress", onKey);
+    adapter.cleanup();
+  });
+  function modeLabel() {
+    if (state.mode() === "visual")
+      return "VISUAL";
+    if (state.mode() === "visual-line")
+      return "VISUAL LINE";
+    return "MESSAGE";
+  }
+  return (() => {
+    var _el$2 = _$createElement2("box"), _el$3 = _$createElement2("box"), _el$4 = _$createElement2("text"), _el$5 = _$createElement2("b"), _el$6 = _$createElement2("text"), _el$8 = _$createElement2("box"), _el$9 = _$createElement2("textarea"), _el$0 = _$createElement2("box"), _el$1 = _$createElement2("text"), _el$10 = _$createTextNode(` \xB7 `), _el$11 = _$createTextNode(`/`), _el$12 = _$createElement2("text");
+    _$insertNode2(_el$2, _el$3);
+    _$insertNode2(_el$2, _el$8);
+    _$insertNode2(_el$2, _el$0);
+    _$setProp2(_el$2, "id", "vim-message-reader");
+    _$setProp2(_el$2, "gap", 1);
+    _$insertNode2(_el$3, _el$4);
+    _$insertNode2(_el$3, _el$6);
+    _$setProp2(_el$3, "paddingLeft", 2);
+    _$setProp2(_el$3, "paddingRight", 2);
+    _$setProp2(_el$3, "flexDirection", "row");
+    _$setProp2(_el$3, "justifyContent", "space-between");
+    _$insertNode2(_el$4, _el$5);
+    _$insert2(_el$5, () => props.message.author);
+    _$insertNode2(_el$6, _$createTextNode(`esc`));
+    _$setProp2(_el$6, "id", "vim-message-close");
+    _$insertNode2(_el$8, _el$9);
+    _$setProp2(_el$8, "paddingLeft", 2);
+    _$setProp2(_el$8, "paddingRight", 2);
+    _$setProp2(_el$8, "paddingTop", 1);
+    _$setProp2(_el$8, "paddingBottom", 1);
+    _$use((value) => {
+      input = value;
+      input.handleKeyPress = () => true;
+      input.handlePaste = () => {};
+    }, _el$9);
+    _$setProp2(_el$9, "id", "vim-session-message");
+    _$setProp2(_el$9, "minHeight", 1);
+    _$setProp2(_el$9, "wrapMode", "word");
+    _$setProp2(_el$9, "showCursor", true);
+    _$insertNode2(_el$0, _el$1);
+    _$insertNode2(_el$0, _el$12);
+    _$setProp2(_el$0, "paddingLeft", 2);
+    _$setProp2(_el$0, "paddingRight", 2);
+    _$setProp2(_el$0, "paddingBottom", 1);
+    _$setProp2(_el$0, "flexDirection", "row");
+    _$setProp2(_el$0, "flexWrap", "wrap");
+    _$setProp2(_el$0, "columnGap", 3);
+    _$insertNode2(_el$1, _el$10);
+    _$insertNode2(_el$1, _el$11);
+    _$insert2(_el$1, modeLabel, _el$10);
+    _$insert2(_el$1, line, _el$11);
+    _$insert2(_el$1, () => input?.lineCount ?? 1, null);
+    _$insert2(_el$12, () => props.notice() || (state.mode() !== "normal" ? "y copy \xB7 Esc cancel" : `v select \xB7 V lines \xB7 ${props.config.sessionKey} prompt`));
+    _$effect2((_p$) => {
+      var _v$ = theme().text.base, _v$2 = theme().text.muted, _v$3 = props.back, _v$4 = background(), _v$5 = props.message.text, _v$6 = Math.max(1, Math.min(20, dimensions().height - 10)), _v$7 = props.config.cursorStyles.normal, _v$8 = theme().text.base, _v$9 = background(), _v$0 = background(), _v$1 = theme().text.base, _v$10 = theme().text.muted, _v$11 = theme().text.muted;
+      _v$ !== _p$.e && (_p$.e = _$setProp2(_el$4, "fg", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp2(_el$6, "fg", _v$2, _p$.t));
+      _v$3 !== _p$.a && (_p$.a = _$setProp2(_el$6, "onMouseUp", _v$3, _p$.a));
+      _v$4 !== _p$.o && (_p$.o = _$setProp2(_el$8, "backgroundColor", _v$4, _p$.o));
+      _v$5 !== _p$.i && (_p$.i = _$setProp2(_el$9, "initialValue", _v$5, _p$.i));
+      _v$6 !== _p$.n && (_p$.n = _$setProp2(_el$9, "maxHeight", _v$6, _p$.n));
+      _v$7 !== _p$.s && (_p$.s = _$setProp2(_el$9, "cursorStyle", _v$7, _p$.s));
+      _v$8 !== _p$.h && (_p$.h = _$setProp2(_el$9, "textColor", _v$8, _p$.h));
+      _v$9 !== _p$.r && (_p$.r = _$setProp2(_el$9, "backgroundColor", _v$9, _p$.r));
+      _v$0 !== _p$.d && (_p$.d = _$setProp2(_el$9, "focusedBackgroundColor", _v$0, _p$.d));
+      _v$1 !== _p$.l && (_p$.l = _$setProp2(_el$9, "focusedTextColor", _v$1, _p$.l));
+      _v$10 !== _p$.u && (_p$.u = _$setProp2(_el$1, "fg", _v$10, _p$.u));
+      _v$11 !== _p$.c && (_p$.c = _$setProp2(_el$12, "fg", _v$11, _p$.c));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined,
+      o: undefined,
+      i: undefined,
+      n: undefined,
+      s: undefined,
+      h: undefined,
+      r: undefined,
+      d: undefined,
+      l: undefined,
+      u: undefined,
+      c: undefined
+    });
+    return _el$2;
+  })();
+}
+function readerKey(context, event, sessionKey, mode = SESSION_MODE) {
+  if (event.defaultPrevented || context.keymap.mode.current() !== mode)
+    return;
+  if (context.keymap.pending().length || event.super || event.meta)
+    return;
+  const key = keyNotation(event);
+  if (key && (key === sessionKey || !event.ctrl || key === "<C-[>" || pageCommand(key) || mode === "modal" && key === "<C-c>"))
+    return key;
+}
+function pageCommand(key) {
+  if (key === "<C-d>")
+    return "session.half.page.down";
+  if (key === "<C-u>")
+    return "session.half.page.up";
+  if (key === "<C-f>" || key === "<PageDown>")
+    return "session.page.down";
+  if (key === "<C-b>" || key === "<PageUp>")
+    return "session.page.up";
+}
+
+// src/clipboard.tsx
+import { createClipboard, createHostClipboard, createRendererClipboardAdapter } from "opentui:runtime-module:%40opentui%2Fcore";
+function createVimClipboard(renderer) {
+  const terminal = createRendererClipboardAdapter(renderer);
+  const clipboard = createClipboard({
+    host: createHostClipboard(),
+    terminal
+  });
+  let fallback = "";
+  let revision = 0;
+  let writes = Promise.resolve();
+  let disposed = false;
+  return {
+    write(text) {
+      text = text.replaceAll("\x00", "");
+      fallback = text;
+      revision++;
+      const result = writes.then(async () => {
+        if (disposed)
+          return false;
+        try {
+          const result = await clipboard.writeText(text, {
+            destination: "all-available",
+            selection: "clipboard"
+          });
+          return result.host.status === "written" || result.terminal.status === "attempted";
+        } catch {
+          return false;
+        }
+      });
+      writes = result.then(() => {});
+      return result;
+    },
+    async read() {
+      await writes;
+      if (disposed || terminal.remote)
+        return fallback;
+      const before = revision;
+      try {
+        const result = await clipboard.read({
+          preferredTypes: ["text/plain"],
+          selection: "clipboard"
+        });
+        if (before !== revision)
+          return fallback;
+        if (result.status === "empty")
+          fallback = "";
+        else if (result.status === "read" && result.representation.mimeType === "text/plain") {
+          fallback = new TextDecoder().decode(result.representation.bytes).replace(/\r\n?/g, `
+`).replaceAll("\x00", "");
+        }
+      } catch {}
+      return fallback;
+    },
+    dispose() {
+      disposed = true;
+      return clipboard.dispose();
+    }
+  };
+}
+
+// tui.tsx
+var tui_default = Plugin.define({
+  id: "opencode-vim",
+  setup(context) {
+    context.ui.slot({
+      append: "app",
+      render: () => _$createComponent2(VimHost, {
+        context
+      })
+    });
+  }
+});
+function VimHost(props) {
+  const config = createVimConfig(props.context.options);
+  const normalMappings = Object.keys(config.keymaps.normal ?? {});
+  const log = createVimLog(config);
+  const clipboard = createVimClipboard(props.context.renderer);
+  const clipboardOptions = {
+    onYank: (text) => {
+      clipboard.write(text);
+    },
+    readClipboard: clipboard.read
+  };
+  const state = createVimState(config.defaultMode, log);
+  const vimee = createVimeeAdapter(state, config, log, clipboardOptions);
+  const dialogState = createVimState(config.defaultMode, log);
+  const dialogVimee = createVimeeAdapter(dialogState, config, log, clipboardOptions);
+  const [dialogFocused, setDialogFocused] = createSignal3(false);
+  const promptVim = {
+    state,
+    vimee
+  };
+  const dialogVim = {
+    state: dialogState,
+    vimee: dialogVimee
+  };
+  let dialogInput = null;
+  const [saved, setSaved] = props.context.storage.store("state", {
+    initial: {
+      enabled: true
+    }
+  });
+  const enabled = () => saved.enabled;
+  const ctx = createCompatContext(props.context);
+  let cursorMode = "";
+  let cursorInput = null;
+  let originalCursorStyle;
+  const session = createSessionMode(props.context, config, clipboard);
+  let pendingKeys;
+  const removeStatus = props.context.ui.slot({
+    prepend: "prompt.footer",
+    render: (footer) => footer.mode === "normal" ? session.active() && !dialogFocused() ? _$createComponent2(session.Status, {}) : _$createComponent2(VimStatus, {
+      mode: () => dialogFocused() ? dialogState.mode() : state.mode(),
+      enabled,
+      get theme() {
+        return compatTheme(props.context);
+      }
+    }) : null
+  });
+  props.context.keymap.layer(() => ({
+    mode: "global",
+    commands: [{
+      id: "opencode-vim.toggle",
+      title: "Toggle Vim Mode",
+      description: "Enable or disable Vim key handling",
+      group: "Vim",
+      palette: true,
+      slash: {
+        name: "vim"
+      },
+      run() {
+        const next = !enabled();
+        setSaved((draft) => {
+          draft.enabled = next;
+        });
+        if (!next) {
+          pendingKeys = undefined;
+          session.close();
+          vimee.suspend();
+          dialogVimee.suspend();
+        }
+        props.context.ui.toast.show({
+          message: `Vim mode ${next ? "enabled" : "disabled"}`,
+          variant: "info"
+        });
+        props.context.renderer.requestRender();
+      }
+    }]
+  }));
+  const onKey = (event) => {
+    if (!enabled() || event.defaultPrevented)
+      return;
+    if (pendingKeys) {
+      pendingKeys.push(new KeyEvent(event));
+      event.preventDefault();
+      event.stopPropagation();
+      return;
+    }
+    if (props.context.keymap.mode.current() === SESSION_MODE)
+      return;
+    const kind = inputKind(props.context);
+    if (!kind)
+      return;
+    if (props.context.keymap.pending().length)
+      return;
+    const {
+      state,
+      vimee
+    } = kind === "dialog" ? dialogVim : promptVim;
+    const key = keyNotation(event);
+    if (!key)
+      return;
+    const mapped = normalMappings.some((sequence) => sequence.startsWith(key));
+    if (kind === "prompt" && key === config.sessionKey && !mapped && state.mode() === "normal" && !vimee.isPending()) {
+      if (session.enter()) {
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+    }
+    if (passThroughKey(event, key, state.mode(), vimee.isPending(), mapped))
+      return;
+    if (key === "<Esc>" && state.mode() === "normal" && !vimee.isPending())
+      return;
+    if (kind === "dialog" && !vimee.isPending() && !mapped && state.mode() === "normal") {
+      if (key === "<Tab>" || key === "<Home>" || key === "<End>" || key === "<PageUp>" || key === "<PageDown>")
+        return;
+      const command = key === "j" ? "dialog.select.next" : key === "k" ? "dialog.select.prev" : undefined;
+      if (command && props.context.keymap.commands().some((item) => item.id === command)) {
+        event.preventDefault();
+        event.stopPropagation();
+        props.context.keymap.dispatch(command);
+        return;
+      }
+    }
+    if (kind === "prompt" && !vimee.isPending() && sendCompletionKey(event, props.context, key, state.mode())) {
+      syncCursor(true);
+      return;
+    }
+    const before = state.mode();
+    let consumed = false;
+    try {
+      const result = vimee.handle(event, key, ctx);
+      if (typeof result === "boolean")
+        consumed = result;
+      else {
+        consumed = true;
+        const queued = [];
+        pendingKeys = queued;
+        const input = props.context.renderer.currentFocusedEditor;
+        result.then((handled) => {
+          if (pendingKeys !== queued)
+            return;
+          pendingKeys = undefined;
+          if (!handled)
+            return;
+          syncCursor(true);
+          for (const event of queued) {
+            if (!enabled() || props.context.renderer.currentFocusedEditor !== input)
+              break;
+            if (event instanceof PasteEvent)
+              props.context.renderer.keyInput.emit("paste", event);
+            else
+              props.context.renderer.keyInput.emit("keypress", event);
+          }
+        }).catch((error) => {
+          if (pendingKeys === queued)
+            pendingKeys = undefined;
+          log("vim.clipboard.paste.error", {
+            error: String(error)
+          });
+        });
+      }
+    } finally {
+      if (consumed || state.mode() !== before) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    }
+    if (consumed)
+      syncCursor(true);
+  };
+  const onFocus = () => {
+    pendingKeys = undefined;
+    vimee.suspend();
+    dialogVimee.suspend();
+    syncCursor();
+  };
+  const onPaste = (event) => {
+    if (!pendingKeys || event.defaultPrevented)
+      return;
+    pendingKeys.push(new PasteEvent(event.bytes, event.metadata));
+    event.preventDefault();
+    event.stopPropagation();
+  };
+  props.context.renderer.keyInput.prependListener("keypress", onKey);
+  props.context.renderer.keyInput.prependListener("paste", onPaste);
+  props.context.renderer.on("focused_editor", onFocus);
+  createEffect2(() => syncCursor());
+  let route = props.context.ui.router.current();
+  createEffect2(() => {
+    const next = props.context.ui.router.current();
+    if (next !== route && pendingKeys)
+      onFocus();
+    route = next;
+  });
+  onCleanup2(() => {
+    pendingKeys = undefined;
+    removeStatus();
+    session.close();
+    props.context.renderer.keyInput.off("keypress", onKey);
+    props.context.renderer.keyInput.off("paste", onPaste);
+    props.context.renderer.off("focused_editor", onFocus);
+    vimee.cleanup();
+    dialogVimee.cleanup();
+    clipboard.dispose();
+    restoreCursor();
+  });
+  return null;
+  function syncCursor(force = false) {
+    const input = props.context.renderer.currentFocusedEditor;
+    const kind = inputKind(props.context);
+    setDialogFocused(kind === "dialog");
+    if (!enabled() || !kind || !input) {
+      restoreCursor();
+      return;
+    }
+    const {
+      state,
+      vimee
+    } = kind === "dialog" ? dialogVim : promptVim;
+    if (kind === "dialog" && dialogInput !== input) {
+      dialogInput = input;
+      dialogVimee.suspend();
+      dialogState.setMode(promptVim.state.mode());
+    }
+    const mode = state.mode();
+    vimee.attach(ctx);
+    const inputChanged = cursorInput !== input;
+    if (inputChanged) {
+      restoreCursor();
+      cursorInput = input;
+      originalCursorStyle = input.cursorStyle;
+    }
+    if (!force && !inputChanged && cursorMode === mode)
+      return;
+    if (applyVimCursorStyle(ctx, config.cursorStyles[mode])) {
+      cursorMode = mode;
+      props.context.renderer.requestRender();
+    }
+  }
+  function restoreCursor() {
+    if (cursorInput && !cursorInput.isDestroyed && originalCursorStyle)
+      cursorInput.cursorStyle = originalCursorStyle;
+    cursorInput = null;
+    cursorMode = "";
+  }
+}
+function createCompatContext(context) {
+  const prompt = {
+    get current() {
+      return {
+        input: focusedInputValue(context),
+        mode: "normal",
+        parts: []
+      };
+    },
+    get focused() {
+      return inputKind(context) !== undefined;
+    },
+    set(value) {
+      const input = context.renderer.currentFocusedEditor;
+      if (input instanceof InputRenderable)
+        input.value = value.input;
+      else if (input)
+        editInput(input, value.input);
+    },
+    submit() {
+      if (inputKind(context) === "dialog") {
+        const command = context.keymap.commands().some((item) => item.id === "dialog.select.submit") ? "dialog.select.submit" : "dialog.prompt.submit";
+        context.keymap.dispatch(command);
+      } else {
+        context.keymap.dispatch("prompt.submit");
+      }
+    },
+    blur() {
+      context.renderer.currentFocusedEditor?.blur();
+    }
+  };
+  return {
+    api: {
+      renderer: context.renderer,
+      keymap: {
+        dispatchCommand(command) {
+          const ok = context.keymap.commands().some((item) => item.id === command);
+          if (ok)
+            context.keymap.dispatch(command);
+          return {
+            ok
+          };
+        }
+      },
+      theme: {
+        current: compatTheme(context)
+      }
+    },
+    kind: context.ui.router.current().type === "session" ? "session" : "home",
+    prompt: () => inputKind(context) ? prompt : undefined,
+    requestRender: () => context.renderer.requestRender()
+  };
+}
+function inputKind(context) {
+  if (context.keymap.mode.current() === SESSION_MODE)
+    return;
+  if (!context.renderer.currentFocusedEditor)
+    return;
+  const commands = context.keymap.commands();
+  if (context.keymap.mode.current() === "modal") {
+    if (commands.some((item) => item.id === "dialog.select.submit" || item.id === "dialog.prompt.submit"))
+      return "dialog";
+    return;
+  }
+  if (commands.some((item) => item.id === "prompt.submit" || item.id === "prompt.autocomplete.next" || item.id === "prompt.history.previous"))
+    return "prompt";
+}
+function focusedInputValue(context) {
+  return context.renderer.currentFocusedEditor?.plainText ?? "";
+}
+function compatTheme(context) {
+  return {
+    get background() {
+      return context.theme.background.base;
+    },
+    get info() {
+      return context.theme.text.feedback.info.base;
+    },
+    get success() {
+      return context.theme.text.feedback.success.base;
+    },
+    get warning() {
+      return context.theme.text.feedback.warning.base;
+    },
+    get textMuted() {
+      return context.theme.text.muted;
+    }
+  };
+}
+function passThroughKey(event, key, mode, pending, mapped) {
+  if (mode !== "normal")
+    return false;
+  if (mapped)
+    return false;
+  if (event.ctrl && key !== "<C-r>" && key !== "<C-[>")
+    return true;
+  return event.super === true || event.meta === true || isArrowKey(key) && !pending;
+}
+function sendCompletionKey(event, context, key, mode) {
+  if (mode !== "normal")
+    return false;
+  const command = key === "j" ? "prompt.autocomplete.next" : key === "k" ? "prompt.autocomplete.prev" : undefined;
+  if (!command || !isCompletionToken(context) || !context.keymap.commands().some((item) => item.id === command))
+    return false;
+  event.preventDefault();
+  event.stopPropagation();
+  context.keymap.dispatch(command);
+  return true;
+}
+function isCompletionToken(context) {
+  const input = context.renderer.currentFocusedEditor;
+  const text = input?.plainText ?? "";
+  const index = displayToChar(text, Math.max(0, input?.cursorOffset ?? 0));
+  const before = text.slice(0, Math.min(index + 1, text.length));
+  return /^\/\S*$/.test(before) || /(?:^|\s)@\S*$/.test(before);
+}
+function isArrowKey(key) {
+  return key === "<Left>" || key === "<Down>" || key === "<Up>" || key === "<Right>";
+}
+export {
+  tui_default as default
+};