opencode-usage 0.4.5 → 0.4.6

package/dist/index.js

@@ -648,7 +648,7 @@ function renderTable(dailyStats) {
   console.log();
 }
 
-// node_modules/@opentui/core/index-zrvzvh6r.js
+// node_modules/@opentui/core/index-vnvba6q9.js
 function wrapAssembly(lib) {
   function patch(prototype, name, fn) {
     const original = prototype[name];
@@ -1420,8 +1420,23 @@ function extractCompleteSequences(buffer) {
         return { sequences, remainder: remaining };
       }
     } else {
-      sequences.push(remaining[0]);
-      pos++;
+      const code = remaining.charCodeAt(0);
+      if (code >= 55296 && code <= 56319) {
+        if (remaining.length === 1) {
+          return { sequences, remainder: remaining };
+        }
+        const next = remaining.charCodeAt(1);
+        if (next >= 56320 && next <= 57343) {
+          sequences.push(remaining.slice(0, 2));
+          pos += 2;
+        } else {
+          sequences.push(remaining[0]);
+          pos++;
+        }
+      } else {
+        sequences.push(remaining[0]);
+        pos++;
+      }
     }
   }
   return { sequences, remainder: "" };
@@ -1866,7 +1881,7 @@ var highlights_default5 = "./highlights-hk7bwhj4.scm";
 // node_modules/@opentui/core/assets/zig/tree-sitter-zig.wasm
 var tree_sitter_zig_default = "./tree-sitter-zig-e78zbjpm.wasm";
 
-// node_modules/@opentui/core/index-zrvzvh6r.js
+// node_modules/@opentui/core/index-vnvba6q9.js
 function getParsers() {
   if (!_cachedParsers) {
     _cachedParsers = [
@@ -2628,6 +2643,18 @@ function defineStruct(fields, structDefOptions) {
   };
 }
 import { ptr as ptr3, toArrayBuffer as toArrayBuffer3 } from "bun:ffi";
+function toPointer(value) {
+  if (typeof value === "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("Pointer exceeds safe integer range");
+    }
+    return Number(value);
+  }
+  return value;
+}
+function toNumber(value) {
+  return typeof value === "bigint" ? Number(value) : value;
+}
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
   const rawSymbols = dlopen(resolvedLibPath, {
@@ -2787,10 +2814,6 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "i32", "i32", "bool"],
       returns: "void"
     },
-    setCursorStyle: {
-      args: ["ptr", "ptr", "u32", "bool"],
-      returns: "void"
-    },
     setCursorColor: {
       args: ["ptr", "ptr"],
       returns: "void"
@@ -2799,6 +2822,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr"],
       returns: "void"
     },
+    setCursorStyleOptions: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
     setDebugOverlay: {
       args: ["ptr", "bool", "u8"],
       returns: "void"
@@ -3526,6 +3553,54 @@ function getOpenTUILib(libPath) {
     bufferDrawChar: {
       args: ["ptr", "u32", "u32", "u32", "ptr", "ptr", "u32"],
       returns: "void"
+    },
+    createNativeSpanFeed: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    attachNativeSpanFeed: {
+      args: ["ptr"],
+      returns: "i32"
+    },
+    destroyNativeSpanFeed: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    streamWrite: {
+      args: ["ptr", "ptr", "u64"],
+      returns: "i32"
+    },
+    streamCommit: {
+      args: ["ptr"],
+      returns: "i32"
+    },
+    streamDrainSpans: {
+      args: ["ptr", "ptr", "u32"],
+      returns: "u32"
+    },
+    streamClose: {
+      args: ["ptr"],
+      returns: "i32"
+    },
+    streamReserve: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "i32"
+    },
+    streamCommitReserved: {
+      args: ["ptr", "u32"],
+      returns: "i32"
+    },
+    streamSetOptions: {
+      args: ["ptr", "ptr"],
+      returns: "i32"
+    },
+    streamGetStats: {
+      args: ["ptr", "ptr"],
+      returns: "i32"
+    },
+    streamSetCallback: {
+      args: ["ptr", "ptr"],
+      returns: "void"
     }
   });
   if (env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) {
@@ -9276,95 +9351,168 @@ class MouseParser {
   reset() {
     this.mouseButtonsPressed.clear();
   }
+  decodeInput(data) {
+    return data.toString();
+  }
   parseMouseEvent(data) {
-    const str = data.toString();
-    const sgrMatch = str.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
-    if (sgrMatch) {
-      const [, buttonCode, x, y, pressRelease] = sgrMatch;
-      const rawButtonCode = parseInt(buttonCode);
-      const button = rawButtonCode & 3;
-      const isScroll = (rawButtonCode & 64) !== 0;
-      const scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
-      const isMotion = (rawButtonCode & 32) !== 0;
-      const modifiers = {
-        shift: (rawButtonCode & 4) !== 0,
-        alt: (rawButtonCode & 8) !== 0,
-        ctrl: (rawButtonCode & 16) !== 0
-      };
-      let type;
-      let scrollInfo;
-      if (isScroll && pressRelease === "M") {
-        type = "scroll";
-        scrollInfo = {
-          direction: scrollDirection,
-          delta: 1
-        };
-      } else if (isMotion) {
-        const isDragging = this.mouseButtonsPressed.size > 0;
-        if (button === 3) {
-          type = "move";
-        } else if (isDragging) {
-          type = "drag";
-        } else {
-          type = "move";
+    const str = this.decodeInput(data);
+    const parsed = this.parseMouseSequenceAt(str, 0);
+    return parsed?.event ?? null;
+  }
+  parseAllMouseEvents(data) {
+    const str = this.decodeInput(data);
+    const events = [];
+    let offset = 0;
+    while (offset < str.length) {
+      const parsed = this.parseMouseSequenceAt(str, offset);
+      if (!parsed) {
+        break;
+      }
+      events.push(parsed.event);
+      offset += parsed.consumed;
+    }
+    return events;
+  }
+  parseMouseSequenceAt(str, offset) {
+    if (!str.startsWith("\x1B[", offset))
+      return null;
+    const introducer = str[offset + 2];
+    if (introducer === "<") {
+      return this.parseSgrSequence(str, offset);
+    }
+    if (introducer === "M") {
+      return this.parseBasicSequence(str, offset);
+    }
+    return null;
+  }
+  parseSgrSequence(str, offset) {
+    let index = offset + 3;
+    const values = [0, 0, 0];
+    let part = 0;
+    let hasDigit = false;
+    while (index < str.length) {
+      const char = str[index];
+      const charCode = str.charCodeAt(index);
+      if (charCode >= 48 && charCode <= 57) {
+        hasDigit = true;
+        values[part] = values[part] * 10 + (charCode - 48);
+        index++;
+        continue;
+      }
+      switch (char) {
+        case ";": {
+          if (!hasDigit || part >= 2)
+            return null;
+          part++;
+          hasDigit = false;
+          index++;
+          break;
         }
-      } else {
-        type = pressRelease === "M" ? "down" : "up";
-        if (type === "down" && button !== 3) {
-          this.mouseButtonsPressed.add(button);
-        } else if (type === "up") {
-          this.mouseButtonsPressed.clear();
+        case "M":
+        case "m": {
+          if (!hasDigit || part !== 2)
+            return null;
+          return {
+            event: this.decodeSgrEvent(values[0], values[1], values[2], char),
+            consumed: index - offset + 1
+          };
         }
+        default:
+          return null;
       }
-      return {
-        type,
-        button: button === 3 ? 0 : button,
-        x: parseInt(x) - 1,
-        y: parseInt(y) - 1,
-        modifiers,
-        scroll: scrollInfo
-      };
     }
-    if (str.startsWith("\x1B[M") && str.length >= 6) {
-      const buttonByte = str.charCodeAt(3) - 32;
-      const x = str.charCodeAt(4) - 33;
-      const y = str.charCodeAt(5) - 33;
-      const button = buttonByte & 3;
-      const isScroll = (buttonByte & 64) !== 0;
-      const isMotion = (buttonByte & 32) !== 0;
-      const scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
-      const modifiers = {
-        shift: (buttonByte & 4) !== 0,
-        alt: (buttonByte & 8) !== 0,
-        ctrl: (buttonByte & 16) !== 0
+    return null;
+  }
+  parseBasicSequence(str, offset) {
+    if (offset + 6 > str.length)
+      return null;
+    const buttonByte = str.charCodeAt(offset + 3) - 32;
+    const x = str.charCodeAt(offset + 4) - 33;
+    const y = str.charCodeAt(offset + 5) - 33;
+    return {
+      event: this.decodeBasicEvent(buttonByte, x, y),
+      consumed: 6
+    };
+  }
+  decodeSgrEvent(rawButtonCode, wireX, wireY, pressRelease) {
+    const button = rawButtonCode & 3;
+    const isScroll = (rawButtonCode & 64) !== 0;
+    const scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
+    const isMotion = (rawButtonCode & 32) !== 0;
+    const modifiers = {
+      shift: (rawButtonCode & 4) !== 0,
+      alt: (rawButtonCode & 8) !== 0,
+      ctrl: (rawButtonCode & 16) !== 0
+    };
+    let type;
+    let scrollInfo;
+    if (isScroll && pressRelease === "M") {
+      type = "scroll";
+      scrollInfo = {
+        direction: scrollDirection,
+        delta: 1
       };
-      let type;
-      let actualButton;
-      let scrollInfo;
-      if (isScroll) {
-        type = "scroll";
-        actualButton = 0;
-        scrollInfo = {
-          direction: scrollDirection,
-          delta: 1
-        };
-      } else if (isMotion) {
+    } else if (isMotion) {
+      const isDragging = this.mouseButtonsPressed.size > 0;
+      if (button === 3) {
         type = "move";
-        actualButton = button === 3 ? -1 : button;
+      } else if (isDragging) {
+        type = "drag";
       } else {
-        type = button === 3 ? "up" : "down";
-        actualButton = button === 3 ? 0 : button;
+        type = "move";
       }
-      return {
-        type,
-        button: actualButton,
-        x,
-        y,
-        modifiers,
-        scroll: scrollInfo
+    } else {
+      type = pressRelease === "M" ? "down" : "up";
+      if (type === "down" && button !== 3) {
+        this.mouseButtonsPressed.add(button);
+      } else if (type === "up") {
+        this.mouseButtonsPressed.clear();
+      }
+    }
+    return {
+      type,
+      button: button === 3 ? 0 : button,
+      x: wireX - 1,
+      y: wireY - 1,
+      modifiers,
+      scroll: scrollInfo
+    };
+  }
+  decodeBasicEvent(buttonByte, x, y) {
+    const button = buttonByte & 3;
+    const isScroll = (buttonByte & 64) !== 0;
+    const isMotion = (buttonByte & 32) !== 0;
+    const scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
+    const modifiers = {
+      shift: (buttonByte & 4) !== 0,
+      alt: (buttonByte & 8) !== 0,
+      ctrl: (buttonByte & 16) !== 0
+    };
+    let type;
+    let actualButton;
+    let scrollInfo;
+    if (isScroll) {
+      type = "scroll";
+      actualButton = 0;
+      scrollInfo = {
+        direction: scrollDirection,
+        delta: 1
       };
+    } else if (isMotion) {
+      type = "move";
+      actualButton = button === 3 ? -1 : button;
+    } else {
+      type = button === 3 ? "up" : "down";
+      actualButton = button === 3 ? 0 : button;
     }
-    return null;
+    return {
+      type,
+      button: actualButton,
+      x,
+      y,
+      modifiers,
+      scroll: scrollInfo
+    };
   }
 }
 
@@ -11556,6 +11704,59 @@ var CursorStateStruct = defineStruct([
   ["b", "f32"],
   ["a", "f32"]
 ]);
+var CursorStyleOptionsStruct = defineStruct([
+  ["style", "u8", { default: 255 }],
+  ["blinking", "u8", { default: 255 }],
+  [
+    "color",
+    "pointer",
+    {
+      optional: true,
+      packTransform: rgbaPackTransform,
+      unpackTransform: rgbaUnpackTransform
+    }
+  ],
+  ["cursor", "u8", { default: 255 }]
+]);
+var GrowthPolicyEnum = defineEnum({ grow: 0, block: 1 }, "u8");
+var NativeSpanFeedOptionsStruct = defineStruct([
+  ["chunkSize", "u32", { default: 65536 }],
+  ["initialChunks", "u32", { default: 2 }],
+  ["maxBytes", "u64", { default: 0n }],
+  ["growthPolicy", GrowthPolicyEnum, { default: "grow" }],
+  ["autoCommitOnFull", "bool_u8", { default: true }],
+  ["spanQueueCapacity", "u32", { default: 0 }]
+]);
+var NativeSpanFeedStatsStruct = defineStruct([
+  ["bytesWritten", "u64"],
+  ["spansCommitted", "u64"],
+  ["chunks", "u32"],
+  ["pendingSpans", "u32"]
+]);
+var SpanInfoStruct = defineStruct([
+  ["chunkPtr", "pointer"],
+  ["offset", "u32"],
+  ["len", "u32"],
+  ["chunkIndex", "u32"],
+  ["reserved", "u32", { default: 0 }]
+], {
+  reduceValue: (value) => ({
+    chunkPtr: value.chunkPtr,
+    offset: value.offset,
+    len: value.len,
+    chunkIndex: value.chunkIndex
+  })
+});
+var ReserveInfoStruct = defineStruct([
+  ["ptr", "pointer"],
+  ["len", "u32"],
+  ["reserved", "u32", { default: 0 }]
+], {
+  reduceValue: (value) => ({
+    ptr: value.ptr,
+    len: value.len
+  })
+});
 var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
 var targetLibPath = module.default;
 if (isBunfsPath(targetLibPath)) {
@@ -11600,6 +11801,9 @@ registerEnvVar({
   type: "boolean",
   default: false
 });
+var CURSOR_STYLE_TO_ID = { block: 0, line: 1, underline: 2 };
+var CURSOR_ID_TO_STYLE = ["block", "line", "underline"];
+var MOUSE_STYLE_TO_ID = { default: 0, pointer: 1, text: 2, crosshair: 3, move: 4, "not-allowed": 5 };
 var globalTraceSymbols = null;
 var globalFFILogWriter = null;
 var exitHandlerRegistered = false;
@@ -11619,6 +11823,8 @@ class FFIRenderLib {
   eventCallbackWrapper;
   _nativeEvents = new EventEmitter5;
   _anyEventHandlers = [];
+  nativeSpanFeedCallbackWrapper = null;
+  nativeSpanFeedHandlers = new Map;
   constructor(libPath) {
     this.opentui = getOpenTUILib(libPath);
     this.setupLogging();
@@ -11708,6 +11914,25 @@ class FFIRenderLib {
     }
     this.setEventCallback(eventCallback.ptr);
   }
+  ensureNativeSpanFeedCallback() {
+    if (this.nativeSpanFeedCallbackWrapper) {
+      return this.nativeSpanFeedCallbackWrapper;
+    }
+    const callback = new JSCallback((streamPtr, eventId, arg0, arg1) => {
+      const handler = this.nativeSpanFeedHandlers.get(toPointer(streamPtr));
+      if (handler) {
+        handler(eventId, arg0, arg1);
+      }
+    }, {
+      args: ["ptr", "u32", "ptr", "u64"],
+      returns: "void"
+    });
+    this.nativeSpanFeedCallbackWrapper = callback;
+    if (!callback.ptr) {
+      throw new Error("Failed to create native span feed callback");
+    }
+    return callback;
+  }
   setEventCallback(callbackPtr) {
     this.opentui.symbols.setEventCallback(callbackPtr);
   }
@@ -11875,10 +12100,6 @@ class FFIRenderLib {
   setCursorPosition(renderer, x, y, visible) {
     this.opentui.symbols.setCursorPosition(renderer, x, y, visible);
   }
-  setCursorStyle(renderer, style, blinking) {
-    const stylePtr = this.encoder.encode(style);
-    this.opentui.symbols.setCursorStyle(renderer, stylePtr, style.length, blinking);
-  }
   setCursorColor(renderer, color) {
     this.opentui.symbols.setCursorColor(renderer, color.buffer);
   }
@@ -11886,20 +12107,22 @@ class FFIRenderLib {
     const cursorBuffer = new ArrayBuffer(CursorStateStruct.size);
     this.opentui.symbols.getCursorState(renderer, ptr4(cursorBuffer));
     const struct = CursorStateStruct.unpack(cursorBuffer);
-    const styleMap = {
-      0: "block",
-      1: "line",
-      2: "underline"
-    };
     return {
       x: struct.x,
       y: struct.y,
       visible: struct.visible,
-      style: styleMap[struct.style] || "block",
+      style: CURSOR_ID_TO_STYLE[struct.style] ?? "block",
       blinking: struct.blinking,
       color: RGBA.fromValues(struct.r, struct.g, struct.b, struct.a)
     };
   }
+  setCursorStyleOptions(renderer, options) {
+    const style = options.style != null ? CURSOR_STYLE_TO_ID[options.style] : 255;
+    const blinking = options.blinking != null ? options.blinking ? 1 : 0 : 255;
+    const cursor = options.cursor != null ? MOUSE_STYLE_TO_ID[options.cursor] : 255;
+    const buffer = CursorStyleOptionsStruct.pack({ style, blinking, color: options.color, cursor });
+    this.opentui.symbols.setCursorStyleOptions(renderer, ptr4(buffer));
+  }
   render(renderer, force) {
     this.opentui.symbols.render(renderer, force);
   }
@@ -12739,6 +12962,73 @@ class FFIRenderLib {
   bufferDrawChar(buffer, char, x, y, fg2, bg2, attributes = 0) {
     this.opentui.symbols.bufferDrawChar(buffer, char, x, y, fg2.buffer, bg2.buffer, attributes);
   }
+  registerNativeSpanFeedStream(stream, handler) {
+    const callback = this.ensureNativeSpanFeedCallback();
+    this.nativeSpanFeedHandlers.set(toPointer(stream), handler);
+    this.opentui.symbols.streamSetCallback(stream, callback.ptr);
+  }
+  unregisterNativeSpanFeedStream(stream) {
+    this.opentui.symbols.streamSetCallback(stream, null);
+    this.nativeSpanFeedHandlers.delete(toPointer(stream));
+  }
+  createNativeSpanFeed(options) {
+    const optionsBuffer = options == null ? null : NativeSpanFeedOptionsStruct.pack(options);
+    const streamPtr = this.opentui.symbols.createNativeSpanFeed(optionsBuffer ? ptr4(optionsBuffer) : null);
+    if (!streamPtr) {
+      throw new Error("Failed to create stream");
+    }
+    return toPointer(streamPtr);
+  }
+  attachNativeSpanFeed(stream) {
+    return this.opentui.symbols.attachNativeSpanFeed(stream);
+  }
+  destroyNativeSpanFeed(stream) {
+    this.opentui.symbols.destroyNativeSpanFeed(stream);
+    this.nativeSpanFeedHandlers.delete(toPointer(stream));
+  }
+  streamWrite(stream, data) {
+    const bytes = typeof data === "string" ? this.encoder.encode(data) : data;
+    return this.opentui.symbols.streamWrite(stream, ptr4(bytes), bytes.length);
+  }
+  streamCommit(stream) {
+    return this.opentui.symbols.streamCommit(stream);
+  }
+  streamDrainSpans(stream, outBuffer, maxSpans) {
+    const count = this.opentui.symbols.streamDrainSpans(stream, ptr4(outBuffer), maxSpans);
+    return toNumber(count);
+  }
+  streamClose(stream) {
+    return this.opentui.symbols.streamClose(stream);
+  }
+  streamSetOptions(stream, options) {
+    const optionsBuffer = NativeSpanFeedOptionsStruct.pack(options);
+    return this.opentui.symbols.streamSetOptions(stream, ptr4(optionsBuffer));
+  }
+  streamGetStats(stream) {
+    const statsBuffer = new ArrayBuffer(NativeSpanFeedStatsStruct.size);
+    const status = this.opentui.symbols.streamGetStats(stream, ptr4(statsBuffer));
+    if (status !== 0) {
+      return null;
+    }
+    const stats = NativeSpanFeedStatsStruct.unpack(statsBuffer);
+    return {
+      bytesWritten: typeof stats.bytesWritten === "bigint" ? stats.bytesWritten : BigInt(stats.bytesWritten),
+      spansCommitted: typeof stats.spansCommitted === "bigint" ? stats.spansCommitted : BigInt(stats.spansCommitted),
+      chunks: stats.chunks,
+      pendingSpans: stats.pendingSpans
+    };
+  }
+  streamReserve(stream, minLen) {
+    const reserveBuffer = new ArrayBuffer(ReserveInfoStruct.size);
+    const status = this.opentui.symbols.streamReserve(stream, minLen, ptr4(reserveBuffer));
+    if (status !== 0) {
+      return { status, info: null };
+    }
+    return { status, info: ReserveInfoStruct.unpack(reserveBuffer) };
+  }
+  streamCommitReserved(stream, length) {
+    return this.opentui.symbols.streamCommitReserved(stream, length);
+  }
   createSyntaxStyle() {
     const stylePtr = this.opentui.symbols.createSyntaxStyle();
     if (!stylePtr) {
@@ -15489,6 +15779,7 @@ class CliRenderer extends EventEmitter9 {
   _latestPointer = { x: 0, y: 0 };
   _hasPointer = false;
   _lastPointerModifiers = { shift: false, alt: false, ctrl: false };
+  _currentMousePointerStyle = undefined;
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
   _openConsoleOnError = true;
@@ -16073,127 +16364,135 @@ Captured output:
     return event;
   }
   handleMouseData(data) {
-    const mouseEvent = this.mouseParser.parseMouseEvent(data);
-    if (mouseEvent) {
-      if (this._splitHeight > 0) {
-        if (mouseEvent.y < this.renderOffset) {
-          return false;
-        }
-        mouseEvent.y -= this.renderOffset;
-      }
-      this._latestPointer.x = mouseEvent.x;
-      this._latestPointer.y = mouseEvent.y;
-      this._hasPointer = true;
-      this._lastPointerModifiers = mouseEvent.modifiers;
-      if (this._console.visible) {
-        const consoleBounds = this._console.bounds;
-        if (mouseEvent.x >= consoleBounds.x && mouseEvent.x < consoleBounds.x + consoleBounds.width && mouseEvent.y >= consoleBounds.y && mouseEvent.y < consoleBounds.y + consoleBounds.height) {
-          const event2 = new MouseEvent(null, mouseEvent);
-          const handled = this._console.handleMouse(event2);
-          if (handled)
-            return true;
-        }
+    const mouseEvents = this.mouseParser.parseAllMouseEvents(data);
+    if (mouseEvents.length === 0)
+      return false;
+    let anyHandled = false;
+    for (const mouseEvent of mouseEvents) {
+      if (this.processSingleMouseEvent(mouseEvent)) {
+        anyHandled = true;
       }
-      if (mouseEvent.type === "scroll") {
-        const maybeRenderableId2 = this.hitTest(mouseEvent.x, mouseEvent.y);
-        const maybeRenderable2 = Renderable.renderablesByNumber.get(maybeRenderableId2);
-        const fallbackTarget = this._currentFocusedRenderable && !this._currentFocusedRenderable.isDestroyed && this._currentFocusedRenderable.focused ? this._currentFocusedRenderable : null;
-        const scrollTarget = maybeRenderable2 ?? fallbackTarget;
-        if (scrollTarget) {
-          const event2 = new MouseEvent(scrollTarget, mouseEvent);
-          scrollTarget.processMouseEvent(event2);
-        }
-        return true;
+    }
+    return anyHandled;
+  }
+  processSingleMouseEvent(mouseEvent) {
+    if (this._splitHeight > 0) {
+      if (mouseEvent.y < this.renderOffset) {
+        return false;
       }
-      const maybeRenderableId = this.hitTest(mouseEvent.x, mouseEvent.y);
-      const sameElement = maybeRenderableId === this.lastOverRenderableNum;
-      this.lastOverRenderableNum = maybeRenderableId;
-      const maybeRenderable = Renderable.renderablesByNumber.get(maybeRenderableId);
-      if (mouseEvent.type === "down" && mouseEvent.button === 0 && !this.currentSelection?.isDragging && !mouseEvent.modifiers.ctrl) {
-        if (maybeRenderable && maybeRenderable.selectable && !maybeRenderable.isDestroyed && maybeRenderable.shouldStartSelection(mouseEvent.x, mouseEvent.y)) {
-          this.startSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
-          this.dispatchMouseEvent(maybeRenderable, mouseEvent);
+      mouseEvent.y -= this.renderOffset;
+    }
+    this._latestPointer.x = mouseEvent.x;
+    this._latestPointer.y = mouseEvent.y;
+    this._hasPointer = true;
+    this._lastPointerModifiers = mouseEvent.modifiers;
+    if (this._console.visible) {
+      const consoleBounds = this._console.bounds;
+      if (mouseEvent.x >= consoleBounds.x && mouseEvent.x < consoleBounds.x + consoleBounds.width && mouseEvent.y >= consoleBounds.y && mouseEvent.y < consoleBounds.y + consoleBounds.height) {
+        const event2 = new MouseEvent(null, mouseEvent);
+        const handled = this._console.handleMouse(event2);
+        if (handled)
           return true;
-        }
       }
-      if (mouseEvent.type === "drag" && this.currentSelection?.isDragging) {
-        this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
-        if (maybeRenderable) {
-          const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
-          maybeRenderable.processMouseEvent(event2);
-        }
-        return true;
+    }
+    if (mouseEvent.type === "scroll") {
+      const maybeRenderableId2 = this.hitTest(mouseEvent.x, mouseEvent.y);
+      const maybeRenderable2 = Renderable.renderablesByNumber.get(maybeRenderableId2);
+      const fallbackTarget = this._currentFocusedRenderable && !this._currentFocusedRenderable.isDestroyed && this._currentFocusedRenderable.focused ? this._currentFocusedRenderable : null;
+      const scrollTarget = maybeRenderable2 ?? fallbackTarget;
+      if (scrollTarget) {
+        const event2 = new MouseEvent(scrollTarget, mouseEvent);
+        scrollTarget.processMouseEvent(event2);
       }
-      if (mouseEvent.type === "up" && this.currentSelection?.isDragging) {
-        if (maybeRenderable) {
-          const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
-          maybeRenderable.processMouseEvent(event2);
-        }
-        this.finishSelection();
+      return true;
+    }
+    const maybeRenderableId = this.hitTest(mouseEvent.x, mouseEvent.y);
+    const sameElement = maybeRenderableId === this.lastOverRenderableNum;
+    this.lastOverRenderableNum = maybeRenderableId;
+    const maybeRenderable = Renderable.renderablesByNumber.get(maybeRenderableId);
+    if (mouseEvent.type === "down" && mouseEvent.button === 0 && !this.currentSelection?.isDragging && !mouseEvent.modifiers.ctrl) {
+      if (maybeRenderable && maybeRenderable.selectable && !maybeRenderable.isDestroyed && maybeRenderable.shouldStartSelection(mouseEvent.x, mouseEvent.y)) {
+        this.startSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
+        this.dispatchMouseEvent(maybeRenderable, mouseEvent);
         return true;
       }
-      if (mouseEvent.type === "down" && mouseEvent.button === 0 && this.currentSelection) {
-        if (mouseEvent.modifiers.ctrl) {
-          this.currentSelection.isDragging = true;
-          this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
-          return true;
-        }
+    }
+    if (mouseEvent.type === "drag" && this.currentSelection?.isDragging) {
+      this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
+      if (maybeRenderable) {
+        const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
+        maybeRenderable.processMouseEvent(event2);
       }
-      if (!sameElement && (mouseEvent.type === "drag" || mouseEvent.type === "move")) {
-        if (this.lastOverRenderable && this.lastOverRenderable !== this.capturedRenderable) {
-          const event2 = new MouseEvent(this.lastOverRenderable, { ...mouseEvent, type: "out" });
-          this.lastOverRenderable.processMouseEvent(event2);
-        }
-        this.lastOverRenderable = maybeRenderable;
-        if (maybeRenderable) {
-          const event2 = new MouseEvent(maybeRenderable, {
-            ...mouseEvent,
-            type: "over",
-            source: this.capturedRenderable
-          });
-          maybeRenderable.processMouseEvent(event2);
-        }
+      return true;
+    }
+    if (mouseEvent.type === "up" && this.currentSelection?.isDragging) {
+      if (maybeRenderable) {
+        const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
+        maybeRenderable.processMouseEvent(event2);
       }
-      if (this.capturedRenderable && mouseEvent.type !== "up") {
-        const event2 = new MouseEvent(this.capturedRenderable, mouseEvent);
-        this.capturedRenderable.processMouseEvent(event2);
+      this.finishSelection();
+      return true;
+    }
+    if (mouseEvent.type === "down" && mouseEvent.button === 0 && this.currentSelection) {
+      if (mouseEvent.modifiers.ctrl) {
+        this.currentSelection.isDragging = true;
+        this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
         return true;
       }
-      if (this.capturedRenderable && mouseEvent.type === "up") {
-        const event2 = new MouseEvent(this.capturedRenderable, { ...mouseEvent, type: "drag-end" });
-        this.capturedRenderable.processMouseEvent(event2);
-        this.capturedRenderable.processMouseEvent(new MouseEvent(this.capturedRenderable, mouseEvent));
-        if (maybeRenderable) {
-          const event3 = new MouseEvent(maybeRenderable, {
-            ...mouseEvent,
-            type: "drop",
-            source: this.capturedRenderable
-          });
-          maybeRenderable.processMouseEvent(event3);
-        }
-        this.lastOverRenderable = this.capturedRenderable;
-        this.lastOverRenderableNum = this.capturedRenderable.num;
-        this.setCapturedRenderable(undefined);
-        this.requestRender();
+    }
+    if (!sameElement && (mouseEvent.type === "drag" || mouseEvent.type === "move")) {
+      if (this.lastOverRenderable && this.lastOverRenderable !== this.capturedRenderable) {
+        const event2 = new MouseEvent(this.lastOverRenderable, { ...mouseEvent, type: "out" });
+        this.lastOverRenderable.processMouseEvent(event2);
       }
-      let event;
+      this.lastOverRenderable = maybeRenderable;
       if (maybeRenderable) {
-        if (mouseEvent.type === "drag" && mouseEvent.button === 0) {
-          this.setCapturedRenderable(maybeRenderable);
-        } else {
-          this.setCapturedRenderable(undefined);
-        }
-        event = this.dispatchMouseEvent(maybeRenderable, mouseEvent);
+        const event2 = new MouseEvent(maybeRenderable, {
+          ...mouseEvent,
+          type: "over",
+          source: this.capturedRenderable
+        });
+        maybeRenderable.processMouseEvent(event2);
+      }
+    }
+    if (this.capturedRenderable && mouseEvent.type !== "up") {
+      const event2 = new MouseEvent(this.capturedRenderable, mouseEvent);
+      this.capturedRenderable.processMouseEvent(event2);
+      return true;
+    }
+    if (this.capturedRenderable && mouseEvent.type === "up") {
+      const event2 = new MouseEvent(this.capturedRenderable, { ...mouseEvent, type: "drag-end" });
+      this.capturedRenderable.processMouseEvent(event2);
+      this.capturedRenderable.processMouseEvent(new MouseEvent(this.capturedRenderable, mouseEvent));
+      if (maybeRenderable) {
+        const event3 = new MouseEvent(maybeRenderable, {
+          ...mouseEvent,
+          type: "drop",
+          source: this.capturedRenderable
+        });
+        maybeRenderable.processMouseEvent(event3);
+      }
+      this.lastOverRenderable = this.capturedRenderable;
+      this.lastOverRenderableNum = this.capturedRenderable.num;
+      this.setCapturedRenderable(undefined);
+      this.requestRender();
+    }
+    let event;
+    if (maybeRenderable) {
+      if (mouseEvent.type === "drag" && mouseEvent.button === 0) {
+        this.setCapturedRenderable(maybeRenderable);
       } else {
         this.setCapturedRenderable(undefined);
-        this.lastOverRenderable = undefined;
-      }
-      if (!event?.defaultPrevented && mouseEvent.type === "down" && this.currentSelection) {
-        this.clearSelection();
       }
-      return true;
+      event = this.dispatchMouseEvent(maybeRenderable, mouseEvent);
+    } else {
+      this.setCapturedRenderable(undefined);
+      this.lastOverRenderable = undefined;
     }
-    return false;
+    if (!event?.defaultPrevented && mouseEvent.type === "down" && this.currentSelection) {
+      this.clearSelection();
+    }
+    return true;
   }
   recheckHoverState() {
     if (this._isDestroyed || !this._hasPointer)
@@ -16228,6 +16527,10 @@ Captured output:
       hitRenderable.processMouseEvent(event);
     }
   }
+  setMousePointer(style) {
+    this._currentMousePointerStyle = style;
+    this.lib.setCursorStyleOptions(this.rendererPtr, { cursor: style });
+  }
   hitTest(x, y) {
     return this.lib.checkHit(this.rendererPtr, x, y);
   }
@@ -16370,11 +16673,11 @@ Captured output:
     const lib = resolveRenderLib();
     lib.setCursorPosition(renderer.rendererPtr, x, y, visible);
   }
-  static setCursorStyle(renderer, style, blinking = false, color) {
+  static setCursorStyle(renderer, options) {
     const lib = resolveRenderLib();
-    lib.setCursorStyle(renderer.rendererPtr, style, blinking);
-    if (color) {
-      lib.setCursorColor(renderer.rendererPtr, color);
+    lib.setCursorStyleOptions(renderer.rendererPtr, options);
+    if (options.cursor !== undefined) {
+      renderer._currentMousePointerStyle = options.cursor;
     }
   }
   static setCursorColor(renderer, color) {
@@ -16384,10 +16687,10 @@ Captured output:
   setCursorPosition(x, y, visible = true) {
     this.lib.setCursorPosition(this.rendererPtr, x, y, visible);
   }
-  setCursorStyle(style, blinking = false, color) {
-    this.lib.setCursorStyle(this.rendererPtr, style, blinking);
-    if (color) {
-      this.lib.setCursorColor(this.rendererPtr, color);
+  setCursorStyle(options) {
+    this.lib.setCursorStyleOptions(this.rendererPtr, options);
+    if (options.cursor !== undefined) {
+      this._currentMousePointerStyle = options.cursor;
     }
   }
   setCursorColor(color) {
@@ -16893,6 +17196,19 @@ function convertThemeToStyles(theme) {
   }
   return flatStyles;
 }
+import { toArrayBuffer as toArrayBuffer5 } from "bun:ffi";
+function toPointer2(value) {
+  if (typeof value === "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("Pointer exceeds safe integer range");
+    }
+    return Number(value);
+  }
+  return value;
+}
+function toNumber2(value) {
+  return typeof value === "bigint" ? Number(value) : value;
+}
 function isGapType(value) {
   if (value === undefined) {
     return true;
@@ -18248,6 +18564,252 @@ class TimelineEngine {
 }
 var engine = new TimelineEngine;
 
+class NativeSpanFeed {
+  static create(options) {
+    const lib = resolveRenderLib();
+    const streamPtr = lib.createNativeSpanFeed(options);
+    const stream = new NativeSpanFeed(streamPtr);
+    lib.registerNativeSpanFeedStream(streamPtr, stream.eventHandler);
+    const status = lib.attachNativeSpanFeed(streamPtr);
+    if (status !== 0) {
+      lib.unregisterNativeSpanFeedStream(streamPtr);
+      lib.destroyNativeSpanFeed(streamPtr);
+      throw new Error(`Failed to attach stream: ${status}`);
+    }
+    return stream;
+  }
+  static attach(streamPtr, _options) {
+    const lib = resolveRenderLib();
+    const ptr5 = toPointer2(streamPtr);
+    const stream = new NativeSpanFeed(ptr5);
+    lib.registerNativeSpanFeedStream(ptr5, stream.eventHandler);
+    const status = lib.attachNativeSpanFeed(ptr5);
+    if (status !== 0) {
+      lib.unregisterNativeSpanFeedStream(ptr5);
+      throw new Error(`Failed to attach stream: ${status}`);
+    }
+    return stream;
+  }
+  streamPtr;
+  lib = resolveRenderLib();
+  eventHandler;
+  chunkMap = new Map;
+  chunkSizes = new Map;
+  dataHandlers = new Set;
+  errorHandlers = new Set;
+  drainBuffer = null;
+  stateBuffer = null;
+  closed = false;
+  destroyed = false;
+  draining = false;
+  pendingDataAvailable = false;
+  pendingClose = false;
+  closing = false;
+  pendingAsyncHandlers = 0;
+  inCallback = false;
+  closeQueued = false;
+  constructor(streamPtr) {
+    this.streamPtr = streamPtr;
+    this.eventHandler = (eventId, arg0, arg1) => {
+      this.handleEvent(eventId, arg0, arg1);
+    };
+    this.ensureDrainBuffer();
+  }
+  ensureDrainBuffer() {
+    if (this.drainBuffer)
+      return;
+    const capacity = 256;
+    this.drainBuffer = new Uint8Array(capacity * SpanInfoStruct.size);
+  }
+  onData(handler) {
+    this.dataHandlers.add(handler);
+    if (this.pendingDataAvailable) {
+      this.pendingDataAvailable = false;
+      this.drainAll();
+    }
+    return () => this.dataHandlers.delete(handler);
+  }
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => this.errorHandlers.delete(handler);
+  }
+  close() {
+    if (this.destroyed)
+      return;
+    if (this.inCallback || this.draining || this.pendingAsyncHandlers > 0) {
+      this.pendingClose = true;
+      if (!this.closeQueued) {
+        this.closeQueued = true;
+        queueMicrotask(() => {
+          this.closeQueued = false;
+          this.processPendingClose();
+        });
+      }
+      return;
+    }
+    this.performClose();
+  }
+  processPendingClose() {
+    if (!this.pendingClose || this.destroyed)
+      return;
+    if (this.inCallback || this.draining || this.pendingAsyncHandlers > 0)
+      return;
+    this.pendingClose = false;
+    this.performClose();
+  }
+  performClose() {
+    if (this.closing)
+      return;
+    this.closing = true;
+    if (!this.closed) {
+      const status = this.lib.streamClose(this.streamPtr);
+      if (status !== 0) {
+        this.closing = false;
+        return;
+      }
+      this.closed = true;
+    }
+    this.finalizeDestroy();
+  }
+  finalizeDestroy() {
+    if (this.destroyed)
+      return;
+    this.lib.unregisterNativeSpanFeedStream(this.streamPtr);
+    this.lib.destroyNativeSpanFeed(this.streamPtr);
+    this.destroyed = true;
+    this.chunkMap.clear();
+    this.chunkSizes.clear();
+    this.stateBuffer = null;
+    this.drainBuffer = null;
+    this.dataHandlers.clear();
+    this.errorHandlers.clear();
+    this.pendingDataAvailable = false;
+  }
+  handleEvent(eventId, arg0, arg1) {
+    this.inCallback = true;
+    try {
+      switch (eventId) {
+        case 8: {
+          const len = toNumber2(arg1);
+          if (len > 0 && arg0) {
+            const buffer = toArrayBuffer5(arg0, 0, len);
+            this.stateBuffer = new Uint8Array(buffer);
+          }
+          break;
+        }
+        case 7: {
+          if (this.closing)
+            break;
+          if (this.dataHandlers.size === 0) {
+            this.pendingDataAvailable = true;
+            break;
+          }
+          this.drainAll();
+          break;
+        }
+        case 2: {
+          const chunkLen = toNumber2(arg1);
+          if (chunkLen > 0 && arg0) {
+            if (!this.chunkMap.has(arg0)) {
+              const buffer = toArrayBuffer5(arg0, 0, chunkLen);
+              this.chunkMap.set(arg0, buffer);
+            }
+            this.chunkSizes.set(arg0, chunkLen);
+          }
+          break;
+        }
+        case 6: {
+          const code = arg0;
+          for (const handler of this.errorHandlers)
+            handler(code);
+          break;
+        }
+        case 5: {
+          this.closed = true;
+          break;
+        }
+        default:
+          break;
+      }
+    } finally {
+      this.inCallback = false;
+    }
+  }
+  decrementRefcount(chunkIndex) {
+    if (this.stateBuffer && chunkIndex < this.stateBuffer.length) {
+      const prev = this.stateBuffer[chunkIndex];
+      this.stateBuffer[chunkIndex] = prev > 0 ? prev - 1 : 0;
+    }
+  }
+  drainOnce() {
+    if (!this.drainBuffer || this.draining || this.pendingClose)
+      return 0;
+    const capacity = Math.floor(this.drainBuffer.byteLength / SpanInfoStruct.size);
+    if (capacity === 0)
+      return 0;
+    const count = this.lib.streamDrainSpans(this.streamPtr, this.drainBuffer, capacity);
+    if (count === 0)
+      return 0;
+    this.draining = true;
+    const spans = SpanInfoStruct.unpackList(this.drainBuffer.buffer, count);
+    let firstError = null;
+    try {
+      for (const span of spans) {
+        if (span.len === 0)
+          continue;
+        let buffer = this.chunkMap.get(span.chunkPtr);
+        if (!buffer) {
+          const size = this.chunkSizes.get(span.chunkPtr);
+          if (!size)
+            continue;
+          buffer = toArrayBuffer5(span.chunkPtr, 0, size);
+          this.chunkMap.set(span.chunkPtr, buffer);
+        }
+        if (span.offset + span.len > buffer.byteLength)
+          continue;
+        const slice = new Uint8Array(buffer, span.offset, span.len);
+        let asyncResults = null;
+        for (const handler of this.dataHandlers) {
+          try {
+            const result = handler(slice);
+            if (result && typeof result.then === "function") {
+              asyncResults ??= [];
+              asyncResults.push(result);
+            }
+          } catch (e) {
+            firstError ??= e;
+          }
+        }
+        const shouldStopAfterThisSpan = this.pendingClose;
+        if (asyncResults) {
+          const chunkIndex = span.chunkIndex;
+          this.pendingAsyncHandlers += 1;
+          Promise.allSettled(asyncResults).then(() => {
+            this.decrementRefcount(chunkIndex);
+            this.pendingAsyncHandlers -= 1;
+            this.processPendingClose();
+          });
+        } else {
+          this.decrementRefcount(span.chunkIndex);
+        }
+        if (shouldStopAfterThisSpan)
+          break;
+      }
+    } finally {
+      this.draining = false;
+    }
+    if (firstError)
+      throw firstError;
+    return count;
+  }
+  drainAll() {
+    let count = this.drainOnce();
+    while (count > 0) {
+      count = this.drainOnce();
+    }
+  }
+}
+
 class FrameBufferRenderable extends Renderable {
   frameBuffer;
   respectAlpha;
@@ -19935,6 +20497,23 @@ class LineNumberRenderable extends Renderable {
   getLineNumbers() {
     return this._lineNumbers;
   }
+  highlightLines(startLine, endLine, color) {
+    for (let i = startLine;i <= endLine; i++) {
+      this.parseLineColor(i, color);
+    }
+    if (this.gutter) {
+      this.gutter.setLineColors(this._lineColorsGutter, this._lineColorsContent);
+    }
+  }
+  clearHighlightLines(startLine, endLine) {
+    for (let i = startLine;i <= endLine; i++) {
+      this._lineColorsGutter.delete(i);
+      this._lineColorsContent.delete(i);
+    }
+    if (this.gutter) {
+      this.gutter.setLineColors(this._lineColorsGutter, this._lineColorsContent);
+    }
+  }
 }
 
 class Diff {
@@ -21328,6 +21907,30 @@ class DiffRenderable extends Renderable {
       }
     }
   }
+  setLineColor(line, color) {
+    this.leftSide?.setLineColor(line, color);
+    this.rightSide?.setLineColor(line, color);
+  }
+  clearLineColor(line) {
+    this.leftSide?.clearLineColor(line);
+    this.rightSide?.clearLineColor(line);
+  }
+  setLineColors(lineColors) {
+    this.leftSide?.setLineColors(lineColors);
+    this.rightSide?.setLineColors(lineColors);
+  }
+  clearAllLineColors() {
+    this.leftSide?.clearAllLineColors();
+    this.rightSide?.clearAllLineColors();
+  }
+  highlightLines(startLine, endLine, color) {
+    this.leftSide?.highlightLines(startLine, endLine, color);
+    this.rightSide?.highlightLines(startLine, endLine, color);
+  }
+  clearHighlightLines(startLine, endLine) {
+    this.leftSide?.clearHighlightLines(startLine, endLine);
+    this.rightSide?.clearHighlightLines(startLine, endLine);
+  }
 }
 
 class EditBufferRenderable extends Renderable {
@@ -21759,13 +22362,11 @@ class EditBufferRenderable extends Renderable {
     const cursorX = this.x + visualCursor.visualCol + 1;
     const cursorY = this.y + visualCursor.visualRow + 1;
     this._ctx.setCursorPosition(cursorX, cursorY, true);
-    this._ctx.setCursorColor(this._cursorColor);
-    this._ctx.setCursorStyle(this._cursorStyle.style, this._cursorStyle.blinking);
+    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
   }
   focus() {
     super.focus();
-    this._ctx.setCursorStyle(this._cursorStyle.style, this._cursorStyle.blinking);
-    this._ctx.setCursorColor(this._cursorColor);
+    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
     this.requestRender();
   }
   blur() {
@@ -23786,7 +24387,8 @@ class MarkdownRenderable extends Renderable {
   constructor(ctx, options) {
     super(ctx, {
       ...options,
-      flexDirection: "column"
+      flexDirection: "column",
+      flexShrink: options.flexShrink ?? 0
     });
     this._syntaxStyle = options.syntaxStyle;
     this._conceal = options.conceal ?? this._contentDefaultOptions.conceal;
@@ -23830,8 +24432,7 @@ class MarkdownRenderable extends Renderable {
   set streaming(value) {
     if (this._streaming !== value) {
       this._streaming = value;
-      this.updateBlocks();
-      this.requestRender();
+      this.clearCache();
     }
   }
   getStyle(group) {
@@ -27610,6 +28211,10 @@ function _getParentNode(childNode) {
   if (parent instanceof RootTextNodeRenderable) {
     parent = parent.textParent ?? undefined;
   }
+  const scrollBoxCandidate = parent?.parent?.parent?.parent;
+  if (scrollBoxCandidate instanceof ScrollBoxRenderable && scrollBoxCandidate.content === parent) {
+    parent = scrollBoxCandidate;
+  }
   return parent;
 }
 function getComponentCatalogue() {
@@ -28110,9 +28715,19 @@ async function readJsonFile(filePath) {
     return null;
   }
 }
+async function readJsonFileFromPaths(filePaths) {
+  for (const filePath of filePaths) {
+    const data = await readJsonFile(filePath);
+    if (data !== null)
+      return data;
+  }
+  return null;
+}
 async function loadMultiAccountQuota() {
-  const path2 = join3(homedir2(), ".local/share/opencode/multi-account-state.json");
-  const state = await readJsonFile(path2);
+  const state = await readJsonFileFromPaths([
+    ANTHROPIC_MULTI_ACCOUNT_STATE_PATH,
+    ANTHROPIC_MULTI_ACCOUNT_STATE_LEGACY_PATH
+  ]);
   if (!state?.usage) {
     return [
       {
@@ -28183,8 +28798,10 @@ function normalizeThresholds(value) {
   };
 }
 async function loadMultiAccountThresholds() {
-  const path2 = join3(homedir2(), ".local/share/opencode/multi-account-state.json");
-  const state = await readJsonFile(path2);
+  const state = await readJsonFileFromPaths([
+    ANTHROPIC_MULTI_ACCOUNT_STATE_PATH,
+    ANTHROPIC_MULTI_ACCOUNT_STATE_LEGACY_PATH
+  ]);
   if (!state)
     return null;
   return normalizeThresholds(state.config?.threshold);
@@ -28245,6 +28862,8 @@ async function loadAntigravityQuota() {
   ];
 }
 var isBun = typeof globalThis.Bun !== "undefined";
+var ANTHROPIC_MULTI_ACCOUNT_STATE_PATH = join3(homedir2(), ".config/opencode/anthropic-multi-account-state.json");
+var ANTHROPIC_MULTI_ACCOUNT_STATE_LEGACY_PATH = join3(homedir2(), ".local/share/opencode/multi-account-state.json");
 
 // src/codex-client.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -28255,11 +28874,18 @@ function getCodexMultiAuthStorePaths() {
   if (explicitFile)
     return [explicitFile];
   const explicitDir = process.env[CODEX_MULTI_AUTH_STORE_DIR_ENV]?.trim();
-  if (explicitDir)
-    return [join4(explicitDir, "accounts.json")];
+  if (explicitDir) {
+    return [
+      join4(explicitDir, "codex-multi-account-accounts.json"),
+      join4(explicitDir, "codex-multi-accounts.json"),
+      join4(explicitDir, "accounts.json")
+    ];
+  }
   return [
-    CODEX_MULTI_AUTH_DEFAULT_STORE_PATH,
-    CODEX_MULTI_AUTH_LEGACY_STORE_PATH
+    CODEX_MULTI_AUTH_STORE_PATH,
+    CODEX_MULTI_AUTH_LEGACY_STORE_PATH,
+    CODEX_MULTI_AUTH_OLDER_STORE_PATH,
+    CODEX_MULTI_AUTH_OLDEST_STORE_PATH
   ];
 }
 function windowToUsed(window) {
@@ -28447,8 +29073,10 @@ async function loadCodexQuota(token) {
 var isBun2 = typeof globalThis.Bun !== "undefined";
 var CODEX_API_URL = "https://chatgpt.com/backend-api/wham/usage";
 var CODEX_AUTH_PATH = join4(homedir3(), ".codex", "auth.json");
-var CODEX_MULTI_AUTH_DEFAULT_STORE_PATH = join4(homedir3(), ".config", "oc-codex-multi-account", "accounts.json");
-var CODEX_MULTI_AUTH_LEGACY_STORE_PATH = join4(homedir3(), ".config", "opencode-multi-auth", "accounts.json");
+var CODEX_MULTI_AUTH_STORE_PATH = join4(homedir3(), ".config", "opencode", "codex-multi-account-accounts.json");
+var CODEX_MULTI_AUTH_LEGACY_STORE_PATH = join4(homedir3(), ".config", "opencode", "codex-multi-accounts.json");
+var CODEX_MULTI_AUTH_OLDER_STORE_PATH = join4(homedir3(), ".config", "oc-codex-multi-account", "accounts.json");
+var CODEX_MULTI_AUTH_OLDEST_STORE_PATH = join4(homedir3(), ".config", "opencode-multi-auth", "accounts.json");
 var CODEX_MULTI_AUTH_STORE_FILE_ENV = "OPENCODE_MULTI_AUTH_STORE_FILE";
 var CODEX_MULTI_AUTH_STORE_DIR_ENV = "OPENCODE_MULTI_AUTH_STORE_DIR";
 
@@ -28698,7 +29326,7 @@ function UsageTable(props) {
     insert(_el$11, () => padLeft2(formatNum(totalStats().tokens), 13));
     insert(_el$12, () => padLeft2(formatCost2(totalStats().cost), 10));
     effect((_p$) => {
-      var _v$ = props.isSelected ? COLORS.accent.teal : COLORS.border, _v$2 = props.width ?? "50%", _v$3 = COLORS.bg.secondary, _v$4 = COLORS.accent.teal, _v$5 = COLORS.border, _v$6 = COLORS.text.muted, _v$7 = COLORS.border, _v$8 = {
+      var _v$ = props.isSelected ? COLORS.accent.teal : COLORS.border, _v$2 = props.width ?? "49%", _v$3 = COLORS.bg.secondary, _v$4 = COLORS.accent.teal, _v$5 = COLORS.border, _v$6 = COLORS.text.muted, _v$7 = COLORS.border, _v$8 = {
         fg: COLORS.accent.teal,
         bold: true
       }, _v$9 = {
@@ -28753,7 +29381,7 @@ function QuotaPanel(props) {
     const resetDate = new Date(resetAt * 1000);
     const now = new Date;
     if (resetDate <= now)
-      return "\u27F3 resetting...";
+      return compact ? "\u27F3 reset" : "\u27F3 resetting...";
     const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
     const tomorrow = new Date(today);
     tomorrow.setDate(tomorrow.getDate() + 1);
@@ -28874,6 +29502,7 @@ function QuotaPanel(props) {
                 children: ([accountName, accountQuotas]) => {
                   const isActive = accountName.includes("[ACTIVE]");
                   const cleanName = accountName.replace(" [ACTIVE]", "").trim();
+                  const displayAccountName = props.twoColumns ? truncateText(cleanName, isActive ? 15 : 22) : cleanName;
                   return (() => {
                     var _el$52 = createElement("box"), _el$53 = createElement("box"), _el$54 = createElement("text");
                     insertNode(_el$52, _el$53);
@@ -28897,7 +29526,7 @@ function QuotaPanel(props) {
                     insert(_el$54, isActive ? [(() => {
                       var _el$55 = createElement("span"), _el$56 = createTextNode(`\u25CF `);
                       insertNode(_el$55, _el$56);
-                      insert(_el$55, cleanName, null);
+                      insert(_el$55, displayAccountName, null);
                       effect((_$p) => setProp(_el$55, "style", {
                         fg: COLORS.accent.teal,
                         bold: true
@@ -28912,7 +29541,7 @@ function QuotaPanel(props) {
                       return _el$57;
                     })()] : (() => {
                       var _el$60 = createElement("span");
-                      insert(_el$60, cleanName);
+                      insert(_el$60, displayAccountName);
                       effect((_$p) => setProp(_el$60, "style", {
                         fg: COLORS.text.primary,
                         bold: true
@@ -28925,22 +29554,24 @@ function QuotaPanel(props) {
                         const rawDisplayLabel = quota.label.replace(accountName, "").replace(/^[\s-]+/, "").trim();
                         const displayLabel = rawDisplayLabel || "Status";
                         const compact = Boolean(props.twoColumns);
-                        const labelWidth = compact ? 12 : 15;
-                        const barWidth = compact ? 14 : 20;
+                        const labelWidth = compact ? 10 : 15;
+                        const barWidth = compact ? 10 : 20;
+                        const displayLabelText = compact ? truncateText(displayLabel, labelWidth) : displayLabel;
+                        const resetText = formatResetTime(quota.resetAt, compact);
+                        const compactResetText = compact ? truncateText(resetText, 8) : resetText;
+                        const errorText = compact ? truncateText(`${displayLabel}: ${quota.error ?? "Error"}`, 28) : `${displayLabel}: ${quota.error}`;
                         return createComponent2(Show, {
                           get when() {
                             return !quota.error;
                           },
                           get fallback() {
                             return (() => {
-                              var _el$69 = createElement("box"), _el$70 = createElement("text"), _el$71 = createTextNode(`\u2717 `), _el$72 = createTextNode(`: `);
+                              var _el$69 = createElement("box"), _el$70 = createElement("text"), _el$71 = createTextNode(`\u2717 `);
                               insertNode(_el$69, _el$70);
                               setProp(_el$69, "paddingLeft", 1);
                               setProp(_el$69, "flexShrink", 0);
                               insertNode(_el$70, _el$71);
-                              insertNode(_el$70, _el$72);
-                              insert(_el$70, displayLabel, _el$72);
-                              insert(_el$70, () => quota.error, null);
+                              insert(_el$70, errorText, null);
                               effect((_$p) => setProp(_el$70, "fg", COLORS.accent.red, _$p));
                               return _el$69;
                             })();
@@ -28955,12 +29586,12 @@ function QuotaPanel(props) {
                             insertNode(_el$62, _el$65);
                             insertNode(_el$62, _el$67);
                             setProp(_el$62, "wrapMode", "none");
-                            insert(_el$63, () => padRight2(displayLabel, labelWidth));
+                            insert(_el$63, () => padRight2(displayLabelText, labelWidth));
                             insert(_el$64, () => renderBar(quota.used, barWidth));
                             insertNode(_el$65, _el$66);
                             insert(_el$65, () => padLeft2((quota.used * 100).toFixed(0) + "%", 4), null);
                             insertNode(_el$67, _el$68);
-                            insert(_el$67, () => formatResetTime(quota.resetAt, compact), null);
+                            insert(_el$67, compactResetText, null);
                             effect((_p$) => {
                               var _v$24 = {
                                 fg: COLORS.text.secondary
@@ -28987,7 +29618,7 @@ function QuotaPanel(props) {
                         });
                       }
                     }), null);
-                    effect((_$p) => setProp(_el$52, "width", props.twoColumns ? "50%" : undefined, _$p));
+                    effect((_$p) => setProp(_el$52, "width", props.twoColumns ? "49%" : undefined, _$p));
                     return _el$52;
                   })();
                 }
@@ -29010,7 +29641,7 @@ function QuotaPanel(props) {
       }
     }), null);
     effect((_p$) => {
-      var _v$18 = props.isSelected ? COLORS.accent.teal : COLORS.border, _v$19 = props.width ?? "50%", _v$20 = COLORS.bg.secondary, _v$21 = COLORS.accent.teal;
+      var _v$18 = props.isSelected ? COLORS.accent.teal : COLORS.border, _v$19 = props.width ?? "49%", _v$20 = COLORS.bg.secondary, _v$21 = COLORS.accent.teal;
       _v$18 !== _p$.e && (_p$.e = setProp(_el$37, "borderColor", _v$18, _p$.e));
       _v$19 !== _p$.t && (_p$.t = setProp(_el$37, "width", _v$19, _p$.t));
       _v$20 !== _p$.a && (_p$.a = setProp(_el$37, "backgroundColor", _v$20, _p$.a));
@@ -29045,22 +29676,22 @@ function StatusBar(props) {
     return days.toString();
   };
   return (() => {
-    var _el$73 = createElement("box"), _el$74 = createElement("text"), _el$75 = createElement("span"), _el$76 = createTextNode(`\u27F3 `), _el$77 = createTextNode(` \u2502 DAYS: `), _el$79 = createElement("span"), _el$80 = createTextNode(` \u2502 `), _el$81 = createElement("span");
+    var _el$72 = createElement("box"), _el$73 = createElement("text"), _el$74 = createElement("span"), _el$75 = createTextNode(`\u27F3 `), _el$76 = createTextNode(` \u2502 DAYS: `), _el$78 = createElement("span"), _el$79 = createTextNode(` \u2502 `), _el$80 = createElement("span");
+    insertNode(_el$72, _el$73);
+    setProp(_el$72, "height", 1);
+    setProp(_el$72, "border-top", true);
+    setProp(_el$72, "padding-left", 1);
+    setProp(_el$72, "padding-right", 1);
     insertNode(_el$73, _el$74);
-    setProp(_el$73, "height", 1);
-    setProp(_el$73, "border-top", true);
-    setProp(_el$73, "padding-left", 1);
-    setProp(_el$73, "padding-right", 1);
+    insertNode(_el$73, _el$76);
+    insertNode(_el$73, _el$78);
+    insertNode(_el$73, _el$79);
+    insertNode(_el$73, _el$80);
+    setProp(_el$73, "wrapMode", "none");
     insertNode(_el$74, _el$75);
-    insertNode(_el$74, _el$77);
-    insertNode(_el$74, _el$79);
-    insertNode(_el$74, _el$80);
-    insertNode(_el$74, _el$81);
-    setProp(_el$74, "wrapMode", "none");
-    insertNode(_el$75, _el$76);
-    insert(_el$75, () => formatTime(props.lastUpdate), null);
-    insert(_el$79, daysLabel);
-    insertNode(_el$81, createTextNode(`TAB:PANEL \u2191\u2193:SCROLL \u2190\u2192:DAYS t:TODAY w:WEEK m:MONTH a:ALL HOME:RESET ^C:EXIT`));
+    insert(_el$74, () => formatTime(props.lastUpdate), null);
+    insert(_el$78, daysLabel);
+    insertNode(_el$80, createTextNode(`TAB:PANEL \u2191\u2193:SCROLL \u2190\u2192:DAYS t:TODAY w:WEEK m:MONTH a:ALL HOME:RESET ^C:EXIT`));
     effect((_p$) => {
       var _v$28 = COLORS.border, _v$29 = COLORS.bg.accent, _v$30 = COLORS.text.secondary, _v$31 = {
         fg: COLORS.accent.teal
@@ -29069,12 +29700,12 @@ function StatusBar(props) {
       }, _v$33 = {
         fg: COLORS.text.muted
       };
-      _v$28 !== _p$.e && (_p$.e = setProp(_el$73, "border-color", _v$28, _p$.e));
-      _v$29 !== _p$.t && (_p$.t = setProp(_el$73, "background-color", _v$29, _p$.t));
-      _v$30 !== _p$.a && (_p$.a = setProp(_el$74, "fg", _v$30, _p$.a));
-      _v$31 !== _p$.o && (_p$.o = setProp(_el$75, "style", _v$31, _p$.o));
-      _v$32 !== _p$.i && (_p$.i = setProp(_el$79, "style", _v$32, _p$.i));
-      _v$33 !== _p$.n && (_p$.n = setProp(_el$81, "style", _v$33, _p$.n));
+      _v$28 !== _p$.e && (_p$.e = setProp(_el$72, "border-color", _v$28, _p$.e));
+      _v$29 !== _p$.t && (_p$.t = setProp(_el$72, "background-color", _v$29, _p$.t));
+      _v$30 !== _p$.a && (_p$.a = setProp(_el$73, "fg", _v$30, _p$.a));
+      _v$31 !== _p$.o && (_p$.o = setProp(_el$74, "style", _v$31, _p$.o));
+      _v$32 !== _p$.i && (_p$.i = setProp(_el$78, "style", _v$32, _p$.i));
+      _v$33 !== _p$.n && (_p$.n = setProp(_el$80, "style", _v$33, _p$.n));
       return _p$;
     }, {
       e: undefined,
@@ -29084,7 +29715,7 @@ function StatusBar(props) {
       i: undefined,
       n: undefined
     });
-    return _el$73;
+    return _el$72;
   })();
 }
 function Dashboard(props) {
@@ -29250,15 +29881,15 @@ function Dashboard(props) {
   const sideBySide = () => dimensions().width >= 168;
   const quotaTwoColumns = () => dimensions().width >= 150;
   return (() => {
-    var _el$83 = createElement("box"), _el$84 = createElement("box");
-    insertNode(_el$83, _el$84);
-    setProp(_el$83, "width", "100%");
-    setProp(_el$83, "height", "100%");
-    setProp(_el$83, "flex-direction", "column");
-    setProp(_el$84, "flex-grow", 1);
-    setProp(_el$84, "gap", 0);
-    setProp(_el$84, "padding", 0);
-    insert(_el$84, createComponent2(UsageTable, {
+    var _el$82 = createElement("box"), _el$83 = createElement("box");
+    insertNode(_el$82, _el$83);
+    setProp(_el$82, "width", "100%");
+    setProp(_el$82, "height", "100%");
+    setProp(_el$82, "flex-direction", "column");
+    setProp(_el$83, "flex-grow", 1);
+    setProp(_el$83, "gap", 0);
+    setProp(_el$83, "padding", 0);
+    insert(_el$83, createComponent2(UsageTable, {
       get stats() {
         return displayedStats();
       },
@@ -29281,10 +29912,10 @@ function Dashboard(props) {
         return selectedPanel() === "usage";
       },
       get width() {
-        return sideBySide() ? "50%" : "100%";
+        return sideBySide() ? "49%" : "100%";
       }
     }), null);
-    insert(_el$84, createComponent2(QuotaPanel, {
+    insert(_el$83, createComponent2(QuotaPanel, {
       get quotas() {
         return quotas();
       },
@@ -29292,7 +29923,7 @@ function Dashboard(props) {
         return selectedPanel() === "quota";
       },
       get width() {
-        return sideBySide() ? "50%" : "100%";
+        return sideBySide() ? "49%" : "100%";
       },
       get twoColumns() {
         return quotaTwoColumns();
@@ -29304,7 +29935,7 @@ function Dashboard(props) {
         return codexThresholds();
       }
     }), null);
-    insert(_el$83, createComponent2(StatusBar, {
+    insert(_el$82, createComponent2(StatusBar, {
       get daysFilter() {
         return daysFilter();
       },
@@ -29314,14 +29945,14 @@ function Dashboard(props) {
     }), null);
     effect((_p$) => {
       var _v$34 = COLORS.bg.primary, _v$35 = sideBySide() ? "row" : "column";
-      _v$34 !== _p$.e && (_p$.e = setProp(_el$83, "background-color", _v$34, _p$.e));
-      _v$35 !== _p$.t && (_p$.t = setProp(_el$84, "flex-direction", _v$35, _p$.t));
+      _v$34 !== _p$.e && (_p$.e = setProp(_el$82, "background-color", _v$34, _p$.e));
+      _v$35 !== _p$.t && (_p$.t = setProp(_el$83, "flex-direction", _v$35, _p$.t));
       return _p$;
     }, {
       e: undefined,
       t: undefined
     });
-    return _el$83;
+    return _el$82;
   })();
 }
 async function runSolidDashboard(options) {
@@ -29362,6 +29993,15 @@ var COLORS = {
 };
 var padLeft2 = (str, width) => str.padStart(width, " ");
 var padRight2 = (str, width) => str.padEnd(width, " ");
+var truncateText = (str, width) => {
+  if (width <= 0)
+    return "";
+  if (str.length <= width)
+    return str;
+  if (width <= 3)
+    return str.slice(0, width);
+  return `${str.slice(0, width - 3)}...`;
+};
 
 // src/config-commands.ts
 import { readFile as readFile3 } from "fs/promises";
@@ -29372,7 +30012,7 @@ import { join as join6 } from "path";
 import { join as join5 } from "path";
 function getConfigPath() {
   const configDir = "/home/runner/.config";
-  return join5(configDir, "opencode-usage", "config.json");
+  return join5(configDir, "opencode", "opencode-usage-config.json");
 }
 
 // src/config-commands.ts
@@ -29485,4 +30125,4 @@ async function main2() {
 var WATCH_INTERVAL_MS = 5 * 60 * 1000;
 main2().catch(console.error);
 
-//# debugId=DB4C88253D44E5AC64756E2164756E21
+//# debugId=97BCA2744D0BF01A64756E2164756E21