opencode-usage 0.4.6 → 0.4.7

package/dist/index.js

@@ -648,7 +648,7 @@ function renderTable(dailyStats) {
   console.log();
 }
 
-// node_modules/@opentui/core/index-vnvba6q9.js
+// node_modules/@opentui/core/index-rje6z21e.js
 function wrapAssembly(lib) {
   function patch(prototype, name, fn) {
     const original = prototype[name];
@@ -1420,23 +1420,8 @@ function extractCompleteSequences(buffer) {
         return { sequences, remainder: remaining };
       }
     } else {
-      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++;
-      }
+      sequences.push(remaining[0]);
+      pos++;
     }
   }
   return { sequences, remainder: "" };
@@ -1881,7 +1866,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-vnvba6q9.js
+// node_modules/@opentui/core/index-rje6z21e.js
 function getParsers() {
   if (!_cachedParsers) {
     _cachedParsers = [
@@ -2643,18 +2628,6 @@ 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, {
@@ -2814,15 +2787,15 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "i32", "i32", "bool"],
       returns: "void"
     },
-    setCursorColor: {
-      args: ["ptr", "ptr"],
+    setCursorStyle: {
+      args: ["ptr", "ptr", "u32", "bool"],
       returns: "void"
     },
-    getCursorState: {
+    setCursorColor: {
       args: ["ptr", "ptr"],
       returns: "void"
     },
-    setCursorStyleOptions: {
+    getCursorState: {
       args: ["ptr", "ptr"],
       returns: "void"
     },
@@ -3553,54 +3526,6 @@ 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) {
@@ -9351,168 +9276,91 @@ class MouseParser {
   reset() {
     this.mouseButtonsPressed.clear();
   }
-  decodeInput(data) {
-    return data.toString();
-  }
   parseMouseEvent(data) {
-    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;
+    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";
         }
-        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
-          };
+      } else {
+        type = pressRelease === "M" ? "down" : "up";
+        if (type === "down" && button !== 3) {
+          this.mouseButtonsPressed.add(button);
+        } else if (type === "up") {
+          this.mouseButtonsPressed.clear();
         }
-        default:
-          return null;
       }
+      return {
+        type,
+        button: button === 3 ? 0 : button,
+        x: parseInt(x) - 1,
+        y: parseInt(y) - 1,
+        modifiers,
+        scroll: scrollInfo
+      };
     }
-    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
+    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 scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
+      const modifiers = {
+        shift: (buttonByte & 4) !== 0,
+        alt: (buttonByte & 8) !== 0,
+        ctrl: (buttonByte & 16) !== 0
       };
-    } else if (isMotion) {
-      const isDragging = this.mouseButtonsPressed.size > 0;
-      if (button === 3) {
-        type = "move";
-      } else if (isDragging) {
-        type = "drag";
+      let type;
+      let actualButton;
+      let scrollInfo;
+      if (isScroll) {
+        type = "scroll";
+        actualButton = 0;
+        scrollInfo = {
+          direction: scrollDirection,
+          delta: 1
+        };
       } else {
-        type = "move";
+        type = button === 3 ? "up" : "down";
+        actualButton = button === 3 ? 0 : button;
       }
-    } 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
+      return {
+        type,
+        button: actualButton,
+        x,
+        y,
+        modifiers,
+        scroll: scrollInfo
       };
-    } else if (isMotion) {
-      type = "move";
-      actualButton = button === 3 ? -1 : button;
-    } else {
-      type = button === 3 ? "up" : "down";
-      actualButton = button === 3 ? 0 : button;
     }
-    return {
-      type,
-      button: actualButton,
-      x,
-      y,
-      modifiers,
-      scroll: scrollInfo
-    };
+    return null;
   }
 }
 
@@ -11704,59 +11552,6 @@ 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)) {
@@ -11801,9 +11596,6 @@ 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;
@@ -11823,8 +11615,6 @@ class FFIRenderLib {
   eventCallbackWrapper;
   _nativeEvents = new EventEmitter5;
   _anyEventHandlers = [];
-  nativeSpanFeedCallbackWrapper = null;
-  nativeSpanFeedHandlers = new Map;
   constructor(libPath) {
     this.opentui = getOpenTUILib(libPath);
     this.setupLogging();
@@ -11914,25 +11704,6 @@ 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);
   }
@@ -12100,6 +11871,10 @@ 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);
   }
@@ -12107,22 +11882,20 @@ 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: CURSOR_ID_TO_STYLE[struct.style] ?? "block",
+      style: styleMap[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);
   }
@@ -12962,73 +12735,6 @@ 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) {
@@ -15779,7 +15485,6 @@ 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;
@@ -16364,135 +16069,125 @@ Captured output:
     return event;
   }
   handleMouseData(data) {
-    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;
+    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;
+        }
       }
-    }
-    return anyHandled;
-  }
-  processSingleMouseEvent(mouseEvent) {
-    if (this._splitHeight > 0) {
-      if (mouseEvent.y < this.renderOffset) {
-        return false;
+      if (mouseEvent.type === "scroll") {
+        const maybeRenderableId2 = this.hitTest(mouseEvent.x, mouseEvent.y);
+        const maybeRenderable2 = Renderable.renderablesByNumber.get(maybeRenderableId2);
+        if (maybeRenderable2) {
+          const event2 = new MouseEvent(maybeRenderable2, mouseEvent);
+          maybeRenderable2.processMouseEvent(event2);
+        }
+        return true;
       }
-      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)
+      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 === "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 === "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;
       }
-      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);
+      if (mouseEvent.type === "up" && this.currentSelection?.isDragging) {
+        if (maybeRenderable) {
+          const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
+          maybeRenderable.processMouseEvent(event2);
+        }
+        this.finishSelection();
         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 (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;
+        }
       }
-      return true;
-    }
-    if (mouseEvent.type === "up" && this.currentSelection?.isDragging) {
-      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);
+        }
       }
-      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);
+      if (this.capturedRenderable && mouseEvent.type !== "up") {
+        const event2 = new MouseEvent(this.capturedRenderable, mouseEvent);
+        this.capturedRenderable.processMouseEvent(event2);
         return true;
       }
-    }
-    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);
+      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 (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));
+      let event;
       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);
+        if (mouseEvent.type === "drag" && mouseEvent.button === 0) {
+          this.setCapturedRenderable(maybeRenderable);
+        } else {
+          this.setCapturedRenderable(undefined);
+        }
+        event = this.dispatchMouseEvent(maybeRenderable, mouseEvent);
       } else {
         this.setCapturedRenderable(undefined);
+        this.lastOverRenderable = undefined;
       }
-      event = this.dispatchMouseEvent(maybeRenderable, mouseEvent);
-    } else {
-      this.setCapturedRenderable(undefined);
-      this.lastOverRenderable = undefined;
-    }
-    if (!event?.defaultPrevented && mouseEvent.type === "down" && this.currentSelection) {
-      this.clearSelection();
+      if (!event?.defaultPrevented && mouseEvent.type === "down" && this.currentSelection) {
+        this.clearSelection();
+      }
+      return true;
     }
-    return true;
+    return false;
   }
   recheckHoverState() {
     if (this._isDestroyed || !this._hasPointer)
@@ -16527,10 +16222,6 @@ 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);
   }
@@ -16673,11 +16364,11 @@ Captured output:
     const lib = resolveRenderLib();
     lib.setCursorPosition(renderer.rendererPtr, x, y, visible);
   }
-  static setCursorStyle(renderer, options) {
+  static setCursorStyle(renderer, style, blinking = false, color) {
     const lib = resolveRenderLib();
-    lib.setCursorStyleOptions(renderer.rendererPtr, options);
-    if (options.cursor !== undefined) {
-      renderer._currentMousePointerStyle = options.cursor;
+    lib.setCursorStyle(renderer.rendererPtr, style, blinking);
+    if (color) {
+      lib.setCursorColor(renderer.rendererPtr, color);
     }
   }
   static setCursorColor(renderer, color) {
@@ -16687,10 +16378,10 @@ Captured output:
   setCursorPosition(x, y, visible = true) {
     this.lib.setCursorPosition(this.rendererPtr, x, y, visible);
   }
-  setCursorStyle(options) {
-    this.lib.setCursorStyleOptions(this.rendererPtr, options);
-    if (options.cursor !== undefined) {
-      this._currentMousePointerStyle = options.cursor;
+  setCursorStyle(style, blinking = false, color) {
+    this.lib.setCursorStyle(this.rendererPtr, style, blinking);
+    if (color) {
+      this.lib.setCursorColor(this.rendererPtr, color);
     }
   }
   setCursorColor(color) {
@@ -17196,19 +16887,6 @@ 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;
@@ -18564,252 +18242,6 @@ 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;
@@ -20497,23 +19929,6 @@ 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 {
@@ -21907,30 +21322,6 @@ 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 {
@@ -22362,11 +21753,13 @@ 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.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
+    this._ctx.setCursorColor(this._cursorColor);
+    this._ctx.setCursorStyle(this._cursorStyle.style, this._cursorStyle.blinking);
   }
   focus() {
     super.focus();
-    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
+    this._ctx.setCursorStyle(this._cursorStyle.style, this._cursorStyle.blinking);
+    this._ctx.setCursorColor(this._cursorColor);
     this.requestRender();
   }
   blur() {
@@ -23142,41 +22535,6 @@ class InputRenderable extends TextareaRenderable {
     this.emit("input", this.plainText);
     return result;
   }
-  deleteLine() {
-    const result = super.deleteLine();
-    this.emit("input", this.plainText);
-    return result;
-  }
-  deleteWordBackward() {
-    const result = super.deleteWordBackward();
-    this.emit("input", this.plainText);
-    return result;
-  }
-  deleteWordForward() {
-    const result = super.deleteWordForward();
-    this.emit("input", this.plainText);
-    return result;
-  }
-  deleteToLineStart() {
-    const result = super.deleteToLineStart();
-    this.emit("input", this.plainText);
-    return result;
-  }
-  deleteToLineEnd() {
-    const result = super.deleteToLineEnd();
-    this.emit("input", this.plainText);
-    return result;
-  }
-  undo() {
-    const result = super.undo();
-    this.emit("input", this.plainText);
-    return result;
-  }
-  redo() {
-    const result = super.redo();
-    this.emit("input", this.plainText);
-    return result;
-  }
   deleteCharacter(direction) {
     if (direction === "backward") {
       this.deleteCharBackward();
@@ -24387,8 +23745,7 @@ class MarkdownRenderable extends Renderable {
   constructor(ctx, options) {
     super(ctx, {
       ...options,
-      flexDirection: "column",
-      flexShrink: options.flexShrink ?? 0
+      flexDirection: "column"
     });
     this._syntaxStyle = options.syntaxStyle;
     this._conceal = options.conceal ?? this._contentDefaultOptions.conceal;
@@ -24432,7 +23789,8 @@ class MarkdownRenderable extends Renderable {
   set streaming(value) {
     if (this._streaming !== value) {
       this._streaming = value;
-      this.clearCache();
+      this.updateBlocks();
+      this.requestRender();
     }
   }
   getStyle(group) {
@@ -28057,7 +27415,7 @@ function createRenderer({
       while (removed = getFirstChild(parent))
         removeNode(parent, removed);
       replacement && insertNode(parent, replacement);
-      return replacement ?? "";
+      return replacement;
     }
     const node = replacement || createSlotNode();
     if (current.length) {
@@ -28211,10 +27569,6 @@ 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() {
@@ -30125,4 +29479,4 @@ async function main2() {
 var WATCH_INTERVAL_MS = 5 * 60 * 1000;
 main2().catch(console.error);
 
-//# debugId=97BCA2744D0BF01A64756E2164756E21
+//# debugId=C12EF127A8F53A8064756E2164756E21