@cascadetui/core 0.1.5 → 0.1.7

package/{index-jx194wn1.js → index-r7vqrd61.js}

@@ -6112,15 +6112,16 @@ class StdinBuffer extends EventEmitter2 {
       this.timeout = null;
     }
     let str;
-    if (Buffer.isBuffer(data)) {
-      if (data.length === 1 && data[0] > 127) {
-        const byte = data[0] - 128;
+    if (typeof data === "string") {
+      str = data;
+    } else {
+      const chunk = this.toBuffer(data);
+      if (chunk.length === 1 && chunk[0] > 127) {
+        const byte = chunk[0] - 128;
         str = "\x1B" + String.fromCharCode(byte);
       } else {
-        str = data.toString();
+        str = chunk.toString();
       }
-    } else {
-      str = data;
     }
     if (str.length === 0 && this.buffer.length === 0) {
       this.emit("data", "");
@@ -6210,6 +6211,15 @@ class StdinBuffer extends EventEmitter2 {
   destroy() {
     this.clear();
   }
+  toBuffer(data) {
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (data instanceof Uint8Array) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+  }
 }
 
 // src/lib/yoga.options.ts
@@ -6515,7 +6525,16 @@ class MouseParser {
     this.mouseButtonsPressed.clear();
   }
   decodeInput(data) {
-    return data.toString();
+    if (typeof data === "string") {
+      return data;
+    }
+    if (Buffer.isBuffer(data)) {
+      return data.toString();
+    }
+    if (data instanceof Uint8Array) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString();
+    }
+    return Buffer.from(data).toString();
   }
   parseMouseEvent(data) {
     const str = this.decodeInput(data);
@@ -13351,6 +13370,15 @@ class Renderable extends BaseRenderable {
   childrenPrimarySortDirty = true;
   childrenSortedByPrimaryAxis = [];
   _shouldUpdateBefore = new Set;
+  renderRequestDepth = 0;
+  renderRequestPending = false;
+  lastLayoutVersion = -1;
+  dirtyLayout = false;
+  dirtyPaint = false;
+  dirtyStructure = false;
+  subtreeDirtyLayout = false;
+  subtreeDirtyPaint = false;
+  subtreeDirtyStructure = false;
   onLifecyclePass = null;
   renderBefore;
   renderAfter;
@@ -13415,6 +13443,7 @@ class Renderable extends BaseRenderable {
     const wasVisible = this._visible;
     this._visible = value;
     this.yogaNode.setDisplay(value ? Display.Flex : Display.None);
+    this.markDirtyStructure();
     if (this._live) {
       if (!wasVisible && value) {
         this.propagateLiveCount(1);
@@ -13434,6 +13463,7 @@ class Renderable extends BaseRenderable {
     const clamped = Math.max(0, Math.min(1, value));
     if (this._opacity !== clamped) {
       this._opacity = clamped;
+      this.markDirtyStructure();
       this.requestRender();
     }
   }
@@ -13449,6 +13479,15 @@ class Renderable extends BaseRenderable {
   shouldStartSelection(x, y) {
     return false;
   }
+  selectWord(_x, _y) {
+    return false;
+  }
+  selectLine(_x, _y) {
+    return false;
+  }
+  updateSelectionWordSnap(_x, _y) {
+    return false;
+  }
   focus() {
     if (this._isDestroyed || this._focused || !this._focusable)
       return;
@@ -13517,21 +13556,89 @@ class Renderable extends BaseRenderable {
     this.parent?.propagateLiveCount(delta);
   }
   findDescendantById(id) {
-    for (const child of this._childrenInLayoutOrder) {
-      if (child.id === id)
-        return child;
-      if (isRenderable(child)) {
-        const found = child.findDescendantById(id);
-        if (found)
-          return found;
+    const visited = new Set;
+    const stack = [...this._childrenInLayoutOrder];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (visited.has(current)) {
+        continue;
+      }
+      visited.add(current);
+      if (current.id === id) {
+        return current;
+      }
+      const children = current.getChildren();
+      for (let i = children.length - 1;i >= 0; i -= 1) {
+        const child = children[i];
+        if (isRenderable(child)) {
+          stack.push(child);
+        }
       }
     }
     return;
   }
+  markClean() {
+    super.markClean();
+    this.dirtyPaint = false;
+  }
+  markSubtreeDirtyPaint(force = false) {
+    if (this.subtreeDirtyPaint)
+      return;
+    this.subtreeDirtyPaint = true;
+    if (this.parent && (force || this._visible)) {
+      this.parent.markSubtreeDirtyPaint(force);
+    }
+  }
+  markSubtreeDirtyLayout(force = false) {
+    if (this.subtreeDirtyLayout)
+      return;
+    this.subtreeDirtyLayout = true;
+    if (this.parent && (force || this._visible)) {
+      this.parent.markSubtreeDirtyLayout(force);
+    }
+  }
+  markSubtreeDirtyStructure(force = false) {
+    if (this.subtreeDirtyStructure)
+      return;
+    this.subtreeDirtyStructure = true;
+    if (this.parent && (force || this._visible)) {
+      this.parent.markSubtreeDirtyStructure(force);
+    }
+  }
+  markDirtyPaint() {
+    this.dirtyPaint = true;
+    this.markSubtreeDirtyPaint();
+  }
+  markDirtyLayout() {
+    this.dirtyLayout = true;
+    this.markSubtreeDirtyLayout();
+  }
+  markDirtyStructure() {
+    this.dirtyStructure = true;
+    this.markSubtreeDirtyStructure(true);
+    this.markDirtyLayout();
+  }
   requestRender() {
     this.markDirty();
+    this.markDirtyPaint();
+    if (this.renderRequestDepth > 0) {
+      this.renderRequestPending = true;
+      return;
+    }
     this._ctx.requestRender();
   }
+  beginRenderBatch() {
+    this.renderRequestDepth += 1;
+  }
+  endRenderBatch() {
+    if (this.renderRequestDepth === 0)
+      return;
+    this.renderRequestDepth -= 1;
+    if (this.renderRequestDepth === 0 && this.renderRequestPending) {
+      this.renderRequestPending = false;
+      this._ctx.requestRender();
+    }
+  }
   get translateX() {
     return this._translateX;
   }
@@ -13541,6 +13648,7 @@ class Renderable extends BaseRenderable {
     this._translateX = value;
     if (this.parent)
       this.parent.childrenPrimarySortDirty = true;
+    this.markDirtyStructure();
     this.requestRender();
   }
   get translateY() {
@@ -13552,6 +13660,7 @@ class Renderable extends BaseRenderable {
     this._translateY = value;
     if (this.parent)
       this.parent.childrenPrimarySortDirty = true;
+    this.markDirtyStructure();
     this.requestRender();
   }
   get x() {
@@ -14005,6 +14114,7 @@ class Renderable extends BaseRenderable {
   }
   onLayoutResize(width, height) {
     if (this._visible) {
+      this.markDirtyLayout();
       this.handleFrameBufferResize(width, height);
       this.onResize(width, height);
       this.requestRender();
@@ -14046,10 +14156,30 @@ class Renderable extends BaseRenderable {
     }
     obj.parent = this;
   }
+  assertCanAdoptChild(renderable) {
+    if (renderable === this) {
+      throw new Error(`Invalid render tree operation: '${this.id}' cannot contain itself`);
+    }
+    let current = this;
+    const visited = new Set;
+    while (current) {
+      if (visited.has(current)) {
+        throw new Error(`Invalid render tree operation: parent chain cycle detected near '${current.id}'`);
+      }
+      visited.add(current);
+      if (current === renderable) {
+        throw new Error(`Invalid render tree operation: adding '${renderable.id}' to '${this.id}' would create a cycle`);
+      }
+      current = current.parent;
+    }
+  }
   add(obj, index) {
     if (!obj) {
       return -1;
     }
+    const trace = this._ctx.trace;
+    const traceEnabled = trace?.enabled === true;
+    const traceStart = traceEnabled ? trace.now() : 0;
     const renderable = maybeMakeRenderable(this._ctx, obj);
     if (!renderable) {
       return -1;
@@ -14060,6 +14190,7 @@ class Renderable extends BaseRenderable {
       }
       return -1;
     }
+    this.assertCanAdoptChild(renderable);
     const anchorRenderable = index !== undefined ? this._childrenInLayoutOrder[index] : undefined;
     if (anchorRenderable) {
       return this.insertBefore(renderable, anchorRenderable);
@@ -14085,7 +14216,11 @@ class Renderable extends BaseRenderable {
     this.yogaNode.insertChild(childLayoutNode, insertedIndex);
     this.childrenPrimarySortDirty = true;
     this._shouldUpdateBefore.add(renderable);
+    this.markDirtyStructure();
     this.requestRender();
+    if (traceEnabled) {
+      trace.write(`trace.container.add id=${this.id} child=${renderable.id} index=${insertedIndex} ms=${(trace.now() - traceStart).toFixed(3)}`);
+    }
     return insertedIndex;
   }
   insertBefore(obj, anchor) {
@@ -14095,6 +14230,9 @@ class Renderable extends BaseRenderable {
     if (!obj) {
       return -1;
     }
+    const trace = this._ctx.trace;
+    const traceEnabled = trace?.enabled === true;
+    const traceStart = traceEnabled ? trace.now() : 0;
     const renderable = maybeMakeRenderable(this._ctx, obj);
     if (!renderable) {
       return -1;
@@ -14105,6 +14243,7 @@ class Renderable extends BaseRenderable {
       }
       return -1;
     }
+    this.assertCanAdoptChild(renderable);
     if (!isRenderable(anchor)) {
       throw new Error("Anchor must be a Renderable");
     }
@@ -14147,9 +14286,120 @@ class Renderable extends BaseRenderable {
     this._childrenInLayoutOrder.splice(insertedIndex, 0, renderable);
     this.yogaNode.insertChild(renderable.getLayoutNode(), insertedIndex);
     this._shouldUpdateBefore.add(renderable);
+    this.markDirtyStructure();
     this.requestRender();
+    if (traceEnabled) {
+      trace.write(`trace.container.insertBefore id=${this.id} child=${renderable.id} index=${insertedIndex} ms=${(trace.now() - traceStart).toFixed(3)}`);
+    }
     return insertedIndex;
   }
+  replaceChildren(nextChildren, options) {
+    const trace = this._ctx.trace;
+    const traceEnabled = trace?.enabled === true;
+    const traceStart = traceEnabled ? trace.now() : 0;
+    const destroyRemoved = options?.destroyRemoved ?? false;
+    this.beginRenderBatch();
+    let removedCount = 0;
+    let addedCount = 0;
+    let orderChanged = false;
+    try {
+      const nextRenderables = [];
+      const nextIds = new Set;
+      const added = [];
+      for (const child of nextChildren ?? []) {
+        if (!child)
+          continue;
+        const renderable = maybeMakeRenderable(this._ctx, child);
+        if (!renderable)
+          continue;
+        if (renderable.isDestroyed)
+          continue;
+        if (nextIds.has(renderable.id))
+          continue;
+        this.assertCanAdoptChild(renderable);
+        if (renderable.parent !== this) {
+          this.replaceParent(renderable);
+          this.needsZIndexSort = true;
+          this.renderableMapById.set(renderable.id, renderable);
+          this._childrenInZIndexOrder.push(renderable);
+          if (typeof renderable.onLifecyclePass === "function") {
+            this._ctx.registerLifecyclePass(renderable);
+          }
+          if (renderable._liveCount > 0) {
+            this.propagateLiveCount(renderable._liveCount);
+          }
+          added.push(renderable);
+        }
+        nextRenderables.push(renderable);
+        nextIds.add(renderable.id);
+      }
+      const previousChildren = this._childrenInLayoutOrder;
+      const removed = [];
+      if (previousChildren.length > 0) {
+        for (const child of previousChildren) {
+          if (!nextIds.has(child.id)) {
+            removed.push(child);
+          }
+        }
+      }
+      removedCount = removed.length;
+      addedCount = added.length;
+      if (removed.length > 0) {
+        for (const child of removed) {
+          if (child._liveCount > 0) {
+            this.propagateLiveCount(-child._liveCount);
+          }
+          child.onRemove();
+          child.parent = null;
+          this._ctx.unregisterLifecyclePass(child);
+          this.renderableMapById.delete(child.id);
+        }
+        this._childrenInZIndexOrder = this._childrenInZIndexOrder.filter((child) => nextIds.has(child.id));
+      }
+      if (previousChildren.length !== nextRenderables.length) {
+        orderChanged = true;
+      } else {
+        for (let i = 0;i < previousChildren.length; i += 1) {
+          if (previousChildren[i] !== nextRenderables[i]) {
+            orderChanged = true;
+            break;
+          }
+        }
+      }
+      if (orderChanged) {
+        for (const child of previousChildren) {
+          this.yogaNode.removeChild(child.getLayoutNode());
+        }
+        for (let i = 0;i < nextRenderables.length; i += 1) {
+          this.yogaNode.insertChild(nextRenderables[i].getLayoutNode(), i);
+        }
+      }
+      this._childrenInLayoutOrder = nextRenderables;
+      if (added.length > 0) {
+        for (const child of added) {
+          this._shouldUpdateBefore.add(child);
+        }
+      }
+      if (orderChanged || removed.length > 0 || added.length > 0) {
+        this.childrenPrimarySortDirty = true;
+        this.markDirtyStructure();
+        this.requestRender();
+      }
+      if (destroyRemoved) {
+        for (const child of removed) {
+          child.destroyRecursively();
+        }
+      }
+    } finally {
+      this.endRenderBatch();
+    }
+    if (traceEnabled) {
+      trace.write(`trace.container.replaceChildren id=${this.id} next=${this._childrenInLayoutOrder.length} added=${addedCount} removed=${removedCount} reordered=${orderChanged} ms=${(trace.now() - traceStart).toFixed(3)}`);
+    }
+  }
+  setChildren(nextChildren) {
+    this.replaceChildren(nextChildren);
+  }
   getRenderable(id) {
     return this.renderableMapById.get(id);
   }
@@ -14157,6 +14407,9 @@ class Renderable extends BaseRenderable {
     if (!id) {
       return;
     }
+    const trace = this._ctx.trace;
+    const traceEnabled = trace?.enabled === true;
+    const traceStart = traceEnabled ? trace.now() : 0;
     if (this.renderableMapById.has(id)) {
       const obj = this.renderableMapById.get(id);
       if (obj) {
@@ -14165,6 +14418,7 @@ class Renderable extends BaseRenderable {
         }
         const childLayoutNode = obj.getLayoutNode();
         this.yogaNode.removeChild(childLayoutNode);
+        this.markDirtyStructure();
         this.requestRender();
         obj.onRemove();
         obj.parent = null;
@@ -14181,6 +14435,9 @@ class Renderable extends BaseRenderable {
         this.childrenPrimarySortDirty = true;
       }
     }
+    if (traceEnabled) {
+      trace.write(`trace.container.remove id=${this.id} child=${id} ms=${(trace.now() - traceStart).toFixed(3)}`);
+    }
   }
   onRemove() {}
   getChildren() {
@@ -14195,11 +14452,16 @@ class Renderable extends BaseRenderable {
     this.onUpdate(deltaTime);
     if (this._isDestroyed)
       return;
-    this.updateFromLayout();
+    const layoutVersion = this._ctx.layoutVersion;
+    if (this.lastLayoutVersion !== layoutVersion) {
+      this.updateFromLayout();
+      this.lastLayoutVersion = layoutVersion;
+    }
     if (this._shouldUpdateBefore.size > 0) {
       for (const child of this._shouldUpdateBefore) {
         if (!child.isDestroyed) {
           child.updateFromLayout();
+          child.lastLayoutVersion = layoutVersion;
         }
       }
       this._shouldUpdateBefore.clear();
@@ -14226,13 +14488,39 @@ class Renderable extends BaseRenderable {
       });
     }
     const visibleChildren = this._getVisibleChildren();
-    for (const child of this._childrenInZIndexOrder) {
-      if (!visibleChildren.includes(child.num)) {
-        child.updateFromLayout();
-        continue;
+    if (visibleChildren.length === this._childrenInZIndexOrder.length) {
+      for (const child of this._childrenInZIndexOrder) {
+        child.updateLayout(deltaTime, renderList);
+      }
+    } else {
+      const visibleSet = new Set(visibleChildren);
+      for (const child of this._childrenInZIndexOrder) {
+        if (!visibleSet.has(child.num)) {
+          if (child.lastLayoutVersion !== layoutVersion) {
+            child.updateFromLayout();
+            child.lastLayoutVersion = layoutVersion;
+          }
+          continue;
+        }
+        child.updateLayout(deltaTime, renderList);
       }
-      child.updateLayout(deltaTime, renderList);
     }
+    let hasDirtyStructure = this.dirtyStructure;
+    let hasDirtyLayout = this.dirtyLayout;
+    let hasDirtyPaint = this.dirtyPaint;
+    for (const child of this._childrenInZIndexOrder) {
+      if (child.subtreeDirtyStructure)
+        hasDirtyStructure = true;
+      if (child.subtreeDirtyLayout)
+        hasDirtyLayout = true;
+      if (child.subtreeDirtyPaint)
+        hasDirtyPaint = true;
+    }
+    this.dirtyStructure = false;
+    this.dirtyLayout = false;
+    this.subtreeDirtyStructure = hasDirtyStructure;
+    this.subtreeDirtyLayout = hasDirtyLayout;
+    this.subtreeDirtyPaint = hasDirtyPaint;
     if (shouldPushScissor) {
       renderList.push({ action: "popScissorRect" });
     }
@@ -14286,7 +14574,10 @@ class Renderable extends BaseRenderable {
       this.frameBuffer.destroy();
       this.frameBuffer = null;
     }
-    for (const child of this._childrenInLayoutOrder) {
+    while (this._childrenInLayoutOrder.length > 0) {
+      const child = this._childrenInLayoutOrder[0];
+      if (!child)
+        break;
       this.remove(child.id);
     }
     this._childrenInLayoutOrder = [];
@@ -14308,6 +14599,9 @@ class Renderable extends BaseRenderable {
   }
   destroySelf() {}
   processMouseEvent(event) {
+    if (!event.tryVisit(this)) {
+      return;
+    }
     this._mouseListener?.call(this, event);
     this._mouseListeners[event.type]?.call(this, event);
     this.onMouseEvent(event);
@@ -14416,6 +14710,8 @@ class Renderable extends BaseRenderable {
 
 class RootRenderable extends Renderable {
   renderList = [];
+  renderListDirty = true;
+  lastRenderListLayoutVersion = -1;
   constructor(ctx) {
     super(ctx, { id: "__root__", zIndex: 0, visible: true, width: ctx.width, height: ctx.height, enableLayout: true });
     if (this.yogaNode) {
@@ -14430,14 +14726,38 @@ class RootRenderable extends Renderable {
   render(buffer, deltaTime) {
     if (!this.visible)
       return;
+    const trace = this._ctx.trace;
+    const traceEnabled = trace?.enabled === true;
     for (const renderable of this._ctx.getLifecyclePasses()) {
       renderable.onLifecyclePass?.call(renderable);
     }
+    const layoutStart = traceEnabled ? trace.now() : 0;
     if (this.yogaNode.isDirty()) {
       this.calculateLayout();
     }
-    this.renderList.length = 0;
-    this.updateLayout(deltaTime, this.renderList);
+    const layoutMs = traceEnabled ? trace.now() - layoutStart : 0;
+    const layoutVersion = this._ctx.layoutVersion;
+    if (this.renderList.length === 0) {
+      this.renderListDirty = true;
+    }
+    if (this.subtreeDirtyStructure || this.subtreeDirtyLayout) {
+      this.renderListDirty = true;
+    }
+    if (layoutVersion !== this.lastRenderListLayoutVersion) {
+      this.renderListDirty = true;
+    }
+    let updateMs = 0;
+    let renderListBuildMs = 0;
+    if (this.renderListDirty) {
+      const updateStart = traceEnabled ? trace.now() : 0;
+      this.renderList.length = 0;
+      this.updateLayout(deltaTime, this.renderList);
+      updateMs = traceEnabled ? trace.now() - updateStart : 0;
+      renderListBuildMs = updateMs;
+      this.renderListDirty = false;
+      this.lastRenderListLayoutVersion = layoutVersion;
+    }
+    const renderStart = traceEnabled ? trace.now() : 0;
     this._ctx.clearHitGridScissorRects();
     for (let i = 1;i < this.renderList.length; i++) {
       const command = this.renderList[i];
@@ -14463,6 +14783,13 @@ class RootRenderable extends Renderable {
           break;
       }
     }
+    if (traceEnabled) {
+      const drawMs = trace.now() - renderStart;
+      trace.write(`trace.render.layout ms=${layoutMs.toFixed(3)}`);
+      trace.write(`trace.render.updateTraversal ms=${updateMs.toFixed(3)}`);
+      trace.write(`trace.render.renderListBuild ms=${renderListBuildMs.toFixed(3)} count=${this.renderList.length}`);
+      trace.write(`trace.render.draw ms=${drawMs.toFixed(3)}`);
+    }
   }
   propagateLiveCount(delta) {
     const oldCount = this._liveCount;
@@ -14475,6 +14802,7 @@ class RootRenderable extends Renderable {
   }
   calculateLayout() {
     this.yogaNode.calculateLayout(this.width, this.height, Direction.LTR);
+    this._ctx.layoutVersion += 1;
     this.emit("layout-changed" /* LAYOUT_CHANGED */);
   }
   resize(width, height) {
@@ -16024,6 +16352,12 @@ registerEnvVar({
   type: "boolean",
   default: false
 });
+registerEnvVar({
+  name: "CASCADE_LOG_CRASH_REPORTS",
+  description: "Log detailed crash reports to the console when a crash is captured.",
+  type: "boolean",
+  default: false
+});
 var DEFAULT_FORWARDED_ENV_KEYS = [
   "TMUX",
   "TERM",
@@ -16080,8 +16414,10 @@ class MouseEvent {
   scroll;
   target;
   isDragging;
+  clickCount;
   _propagationStopped = false;
   _defaultPrevented = false;
+  _visitedRenderableNums = new Set;
   get propagationStopped() {
     return this._propagationStopped;
   }
@@ -16098,6 +16434,7 @@ class MouseEvent {
     this.scroll = attributes.scroll;
     this.source = attributes.source;
     this.isDragging = attributes.isDragging;
+    this.clickCount = attributes.clickCount ?? 1;
   }
   stopPropagation() {
     this._propagationStopped = true;
@@ -16105,6 +16442,13 @@ class MouseEvent {
   preventDefault() {
     this._defaultPrevented = true;
   }
+  tryVisit(renderable) {
+    if (this._visitedRenderableNums.has(renderable.num)) {
+      return false;
+    }
+    this._visitedRenderableNums.add(renderable.num);
+    return true;
+  }
 }
 var MouseButton;
 ((MouseButton2) => {
@@ -16169,6 +16513,7 @@ var CliRenderEvents;
 ((CliRenderEvents2) => {
   CliRenderEvents2["DEBUG_OVERLAY_TOGGLE"] = "debugOverlay:toggle";
   CliRenderEvents2["DESTROY"] = "destroy";
+  CliRenderEvents2["CRASH"] = "crash";
 })(CliRenderEvents ||= {});
 var RendererControlState;
 ((RendererControlState2) => {
@@ -16206,6 +16551,8 @@ class CliRenderer extends EventEmitter9 {
     arrayBuffers: 0
   };
   root;
+  trace;
+  layoutVersion = 0;
   width;
   height;
   _useThread = false;
@@ -16282,9 +16629,12 @@ class CliRenderer extends EventEmitter9 {
   _hasPointer = false;
   _lastPointerModifiers = { shift: false, alt: false, ctrl: false };
   _currentMousePointerStyle = undefined;
+  _lastClick = null;
+  clickCountThresholdMs = 400;
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
   _openConsoleOnError = true;
+  _logCrashReportsToConsole = env.CASCADE_LOG_CRASH_REPORTS;
   _paletteDetector = null;
   _cachedPalette = null;
   _paletteDetectionPromise = null;
@@ -16295,11 +16645,23 @@ class CliRenderer extends EventEmitter9 {
   idleResolvers = [];
   _debugInputs = [];
   _debugModeEnabled = env.CASCADE_DEBUG;
-  handleError = ((error) => {
-    console.error(error);
+  recentRuntimeEvents = [];
+  crashReports = [];
+  maxRecentRuntimeEvents = 200;
+  maxCrashReports = 20;
+  handleProcessCrash = (reason, source) => {
+    const report = this.reportCrash(reason, source);
+    console.error(reason);
     if (this._openConsoleOnError) {
       this.console.show();
+      console.log(`[crash:${report.source}] ${report.message}`);
     }
+  };
+  uncaughtExceptionHandler = ((error) => {
+    this.handleProcessCrash(error, "uncaughtException");
+  }).bind(this);
+  unhandledRejectionHandler = ((reason) => {
+    this.handleProcessCrash(reason, "unhandledRejection");
   }).bind(this);
   dumpOutputCache(optionalMessage = "") {
     const cachedLogs = this.console.getCachedLogs();
@@ -16391,6 +16753,17 @@ Captured output:
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
     this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this.postProcessFns = config.postProcessFns || [];
+    if (config.trace) {
+      const writer = config.traceWriter ?? ((line) => {
+        this.realStdoutWrite.call(this.stdout, `${line}
+`);
+      });
+      this.trace = {
+        enabled: true,
+        now: () => performance.now(),
+        write: writer
+      };
+    }
     this.prependedInputHandlers = config.prependInputHandlers || [];
     this.root = new RootRenderable(this);
     if (this.memorySnapshotInterval > 0) {
@@ -16401,8 +16774,8 @@ Captured output:
     }
     process.on("SIGWINCH", this.sigwinchHandler);
     process.on("warning", this.warningHandler);
-    process.on("uncaughtException", this.handleError);
-    process.on("unhandledRejection", this.handleError);
+    process.on("uncaughtException", this.uncaughtExceptionHandler);
+    process.on("unhandledRejection", this.unhandledRejectionHandler);
     process.on("beforeExit", this.exitHandler);
     const kittyConfig = config.useKittyKeyboard ?? {};
     const useKittyForParsing = kittyConfig !== null;
@@ -16432,6 +16805,7 @@ Captured output:
     this._console = new TerminalConsole(this, consoleOptions);
     this.useConsole = config.useConsole ?? true;
     this._openConsoleOnError = config.openConsoleOnError ?? true;
+    this._logCrashReportsToConsole = config.logCrashReportsToConsole ?? env.CASCADE_LOG_CRASH_REPORTS;
     this._onDestroy = config.onDestroy;
     global.requestAnimationFrame = (callback) => {
       const id = CliRenderer.animationFrameId++;
@@ -16773,10 +17147,11 @@ Captured output:
     this.queryPixelResolution();
   }
   stdinListener = ((data) => {
-    if (this._useMouse && this.handleMouseData(data)) {
+    const chunk = this.normalizeInputChunk(data);
+    if (this._useMouse && this.handleMouseData(chunk)) {
       return;
     }
-    this._stdinBuffer.process(data);
+    this._stdinBuffer.process(chunk);
   }).bind(this);
   addInputHandler(handler) {
     this.inputHandlers.push(handler);
@@ -16853,6 +17228,10 @@ Captured output:
     this.stdin.setEncoding("utf8");
     this.stdin.on("data", this.stdinListener);
     this._stdinBuffer.on("data", (sequence) => {
+      this.recordRuntimeEvent("input:data", {
+        sequence: sequence.length > 120 ? `${sequence.slice(0, 120)}...` : sequence,
+        length: sequence.length
+      });
       if (this._debugModeEnabled) {
         this._debugInputs.push({
           timestamp: new Date().toISOString(),
@@ -16866,6 +17245,9 @@ Captured output:
       }
     });
     this._stdinBuffer.on("paste", (data) => {
+      this.recordRuntimeEvent("input:paste", {
+        length: data.length
+      });
       this._keyHandler.processPaste(data);
     });
   }
@@ -16874,7 +17256,12 @@ Captured output:
     target.processMouseEvent(event);
     if (this.autoFocus && event.type === "down" && event.button === 0 /* LEFT */ && !event.defaultPrevented) {
       let current = target;
+      const visited = new Set;
       while (current) {
+        if (visited.has(current)) {
+          break;
+        }
+        visited.add(current);
         if (current.focusable) {
           current.focus();
           break;
@@ -16903,6 +17290,18 @@ Captured output:
       }
       mouseEvent.y -= this.renderOffset;
     }
+    const clickCount = this.resolveClickCount(mouseEvent);
+    const mouseEventWithClickCount = { ...mouseEvent, clickCount };
+    this.recordRuntimeEvent("input:mouse", {
+      type: mouseEvent.type,
+      x: mouseEvent.x,
+      y: mouseEvent.y,
+      button: mouseEvent.button,
+      clickCount,
+      ctrl: mouseEvent.modifiers.ctrl,
+      alt: mouseEvent.modifiers.alt,
+      shift: mouseEvent.modifiers.shift
+    });
     this._latestPointer.x = mouseEvent.x;
     this._latestPointer.y = mouseEvent.y;
     this._hasPointer = true;
@@ -16910,7 +17309,7 @@ Captured output:
     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 event2 = new MouseEvent(null, mouseEventWithClickCount);
         const handled = this._console.handleMouse(event2);
         if (handled)
           return true;
@@ -16922,7 +17321,7 @@ Captured output:
       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);
+        const event2 = new MouseEvent(scrollTarget, mouseEventWithClickCount);
         scrollTarget.processMouseEvent(event2);
       }
       return true;
@@ -16935,21 +17334,21 @@ Captured output:
       const canStartSelection = Boolean(maybeRenderable && maybeRenderable.selectable && !maybeRenderable.isDestroyed && maybeRenderable.shouldStartSelection(mouseEvent.x, mouseEvent.y));
       if (canStartSelection && maybeRenderable) {
         this.startSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
-        this.dispatchMouseEvent(maybeRenderable, mouseEvent);
+        this.dispatchMouseEvent(maybeRenderable, mouseEventWithClickCount);
         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 });
+        const event2 = new MouseEvent(maybeRenderable, { ...mouseEventWithClickCount, isDragging: true });
         maybeRenderable.processMouseEvent(event2);
       }
       return true;
     }
     if (mouseEvent.type === "up" && this.currentSelection?.isDragging) {
       if (maybeRenderable) {
-        const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
+        const event2 = new MouseEvent(maybeRenderable, { ...mouseEventWithClickCount, isDragging: true });
         maybeRenderable.processMouseEvent(event2);
       }
       this.finishSelection();
@@ -16964,13 +17363,13 @@ Captured output:
     }
     if (!sameElement && (mouseEvent.type === "drag" || mouseEvent.type === "move")) {
       if (this.lastOverRenderable && this.lastOverRenderable !== this.capturedRenderable) {
-        const event2 = new MouseEvent(this.lastOverRenderable, { ...mouseEvent, type: "out" });
+        const event2 = new MouseEvent(this.lastOverRenderable, { ...mouseEventWithClickCount, type: "out" });
         this.lastOverRenderable.processMouseEvent(event2);
       }
       this.lastOverRenderable = maybeRenderable;
       if (maybeRenderable) {
         const event2 = new MouseEvent(maybeRenderable, {
-          ...mouseEvent,
+          ...mouseEventWithClickCount,
           type: "over",
           source: this.capturedRenderable
         });
@@ -16978,17 +17377,17 @@ Captured output:
       }
     }
     if (this.capturedRenderable && mouseEvent.type !== "up") {
-      const event2 = new MouseEvent(this.capturedRenderable, mouseEvent);
+      const event2 = new MouseEvent(this.capturedRenderable, mouseEventWithClickCount);
       this.capturedRenderable.processMouseEvent(event2);
       return true;
     }
     if (this.capturedRenderable && mouseEvent.type === "up") {
-      const event2 = new MouseEvent(this.capturedRenderable, { ...mouseEvent, type: "drag-end" });
+      const event2 = new MouseEvent(this.capturedRenderable, { ...mouseEventWithClickCount, type: "drag-end" });
       this.capturedRenderable.processMouseEvent(event2);
-      this.capturedRenderable.processMouseEvent(new MouseEvent(this.capturedRenderable, mouseEvent));
+      this.capturedRenderable.processMouseEvent(new MouseEvent(this.capturedRenderable, mouseEventWithClickCount));
       if (maybeRenderable) {
         const event3 = new MouseEvent(maybeRenderable, {
-          ...mouseEvent,
+          ...mouseEventWithClickCount,
           type: "drop",
           source: this.capturedRenderable
         });
@@ -17006,7 +17405,7 @@ Captured output:
       } else {
         this.setCapturedRenderable(undefined);
       }
-      event = this.dispatchMouseEvent(maybeRenderable, mouseEvent);
+      event = this.dispatchMouseEvent(maybeRenderable, mouseEventWithClickCount);
     } else {
       this.setCapturedRenderable(undefined);
       this.lastOverRenderable = undefined;
@@ -17176,6 +17575,115 @@ Captured output:
   copyToClipboardOSC52(text, target) {
     return this.clipboard.copyToClipboardOSC52(text, target);
   }
+  normalizeInputChunk(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (data instanceof Uint8Array) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+  }
+  resolveClickCount(mouseEvent) {
+    if (mouseEvent.type !== "down" || mouseEvent.button > 2 /* RIGHT */) {
+      return 1;
+    }
+    const now = Date.now();
+    const previous = this._lastClick;
+    const isConsecutive = previous && previous.button === mouseEvent.button && previous.x === mouseEvent.x && previous.y === mouseEvent.y && now - previous.timestamp <= this.clickCountThresholdMs;
+    const count = isConsecutive ? previous.count + 1 : 1;
+    this._lastClick = {
+      x: mouseEvent.x,
+      y: mouseEvent.y,
+      button: mouseEvent.button,
+      timestamp: now,
+      count
+    };
+    return count;
+  }
+  normalizeCrashError(reason) {
+    if (reason instanceof Error) {
+      return {
+        message: reason.message || reason.name || "Unknown error",
+        stack: reason.stack
+      };
+    }
+    if (typeof reason === "string") {
+      return { message: reason };
+    }
+    try {
+      return { message: JSON.stringify(reason) };
+    } catch {
+      return { message: String(reason) };
+    }
+  }
+  recordRuntimeEvent(type, payload) {
+    this.recentRuntimeEvents.push({
+      timestamp: new Date().toISOString(),
+      type,
+      payload
+    });
+    if (this.recentRuntimeEvents.length > this.maxRecentRuntimeEvents) {
+      this.recentRuntimeEvents.shift();
+    }
+  }
+  reportCrash(reason, source = "manual", extra) {
+    const error = this.normalizeCrashError(reason);
+    const report = {
+      timestamp: new Date().toISOString(),
+      source,
+      message: error.message,
+      stack: error.stack,
+      recentEvents: [...this.recentRuntimeEvents]
+    };
+    if (extra && Object.keys(extra).length > 0) {
+      report.recentEvents.push({
+        timestamp: report.timestamp,
+        type: "crash:context",
+        payload: extra
+      });
+    }
+    this.crashReports.push(report);
+    if (this.crashReports.length > this.maxCrashReports) {
+      this.crashReports.shift();
+    }
+    if (this._logCrashReportsToConsole) {
+      console.error(this.formatCrashReportForConsole(report));
+    }
+    this.emit("crash" /* CRASH */, report);
+    return report;
+  }
+  formatCrashReportForConsole(report) {
+    const lines = [];
+    lines.push("[Cascade Crash Report]");
+    lines.push(`timestamp=${report.timestamp}`);
+    lines.push(`source=${report.source}`);
+    lines.push(`message=${report.message}`);
+    if (report.stack) {
+      lines.push("stack:");
+      lines.push(report.stack);
+    }
+    if (report.recentEvents.length > 0) {
+      lines.push(`recentEvents(${report.recentEvents.length}):`);
+      for (const entry of report.recentEvents) {
+        lines.push(`${entry.timestamp} ${entry.type} ${JSON.stringify(entry.payload)}`);
+      }
+    }
+    return lines.join(`
+`);
+  }
+  getCrashReports() {
+    return [...this.crashReports];
+  }
+  getRecentRuntimeEvents() {
+    return [...this.recentRuntimeEvents];
+  }
+  clearCrashReports() {
+    this.crashReports = [];
+  }
   copyToSystemClipboard(text) {
     return this.clipboard.copyToSystemClipboard(text);
   }
@@ -17379,8 +17887,8 @@ Captured output:
     this._destroyFinalized = true;
     this._destroyPending = false;
     process.removeListener("SIGWINCH", this.sigwinchHandler);
-    process.removeListener("uncaughtException", this.handleError);
-    process.removeListener("unhandledRejection", this.handleError);
+    process.removeListener("uncaughtException", this.uncaughtExceptionHandler);
+    process.removeListener("unhandledRejection", this.unhandledRejectionHandler);
     process.removeListener("warning", this.warningHandler);
     process.removeListener("beforeExit", this.exitHandler);
     capture.removeListener("write", this.captureCallback);
@@ -17468,6 +17976,8 @@ Captured output:
       this.renderStats.frameCount++;
       this.renderStats.fps = this.currentFps;
       const overallStart = performance.now();
+      const trace = this.trace;
+      const traceEnabled = trace?.enabled === true;
       const frameRequests = Array.from(this.animationRequest.values());
       this.animationRequest.clear();
       const animationRequestStart = performance.now();
@@ -17482,22 +17992,33 @@ Captured output:
         try {
           await frameCallback(deltaTime);
         } catch (error) {
+          this.reportCrash(error, "frame-callback");
           console.error("Error in frame callback:", error);
         }
       }
       const end = performance.now();
       this.renderStats.frameCallbackTime = end - start;
+      const renderTreeStart = traceEnabled ? trace.now() : 0;
       this.root.render(this.nextRenderBuffer, deltaTime);
+      const renderTreeMs = traceEnabled ? trace.now() - renderTreeStart : 0;
+      const postProcessStart = traceEnabled ? trace.now() : 0;
       for (const postProcessFn of this.postProcessFns) {
         postProcessFn(this.nextRenderBuffer, deltaTime);
       }
       this._console.renderToBuffer(this.nextRenderBuffer);
+      const postProcessMs = traceEnabled ? trace.now() - postProcessStart : 0;
       if (!this._isDestroyed) {
+        const nativeStart = traceEnabled ? trace.now() : 0;
         this.renderNative();
+        const nativeMs = traceEnabled ? trace.now() - nativeStart : 0;
         if (this._useMouse && this.lib.getHitGridDirty(this.rendererPtr)) {
           this.recheckHoverState();
         }
         const overallFrameTime = performance.now() - overallStart;
+        if (traceEnabled) {
+          trace.write(`trace.render.native ms=${nativeMs.toFixed(3)}`);
+          trace.write(`trace.render.pipeline treeMs=${renderTreeMs.toFixed(3)} postMs=${postProcessMs.toFixed(3)} nativeMs=${nativeMs.toFixed(3)} frameMs=${overallFrameTime.toFixed(3)} animMs=${animationRequestTime.toFixed(3)}`);
+        }
         this.lib.updateStats(this.rendererPtr, overallFrameTime, this.renderStats.fps, this.renderStats.frameCallbackTime);
         if (this.gatherStats) {
           this.collectStatSample(overallFrameTime);
@@ -17515,6 +18036,9 @@ Captured output:
           this.renderTimeout = null;
         }
       }
+    } catch (error) {
+      this.reportCrash(error, "render-loop");
+      console.error("Error in render loop:", error);
     } finally {
       this.rendering = false;
       if (this._destroyPending) {
@@ -17591,6 +18115,30 @@ Captured output:
     }
     this.selectionContainers = [];
   }
+  selectWord(x, y) {
+    let current = this.resolveSelectionMethodTarget(x, y);
+    while (current) {
+      if (current.selectWord(x, y))
+        return;
+      current = current.parent;
+    }
+  }
+  selectLine(x, y) {
+    let current = this.resolveSelectionMethodTarget(x, y);
+    while (current) {
+      if (current.selectLine(x, y))
+        return;
+      current = current.parent;
+    }
+  }
+  updateSelectionWordSnap(x, y) {
+    let current = this.resolveSelectionMethodTarget(x, y);
+    while (current) {
+      if (current.updateSelectionWordSnap(x, y))
+        return;
+      current = current.parent;
+    }
+  }
   startSelection(renderable, x, y) {
     if (!renderable.selectable)
       return;
@@ -17636,7 +18184,11 @@ Captured output:
   }
   isWithinContainer(renderable, container) {
     let current = renderable;
+    const visited = new Set;
     while (current) {
+      if (visited.has(current))
+        return false;
+      visited.add(current);
       if (current === container)
         return true;
       current = current.parent;
@@ -17650,6 +18202,24 @@ Captured output:
       this.notifySelectablesOfSelectionChange();
     }
   }
+  resolveSelectionMethodTarget(x, y) {
+    const maybeRenderableId = this.hitTest(x, y);
+    let current = Renderable.renderablesByNumber.get(maybeRenderableId) ?? null;
+    while (current) {
+      if (current.selectable && !current.isDestroyed) {
+        return current;
+      }
+      current = current.parent;
+    }
+    const candidates = [...Renderable.renderablesByNumber.values()];
+    for (let i = candidates.length - 1;i >= 0; i -= 1) {
+      const candidate = candidates[i];
+      if (candidate.selectable && !candidate.isDestroyed && x >= candidate.x && x < candidate.x + candidate.width && y >= candidate.y && y < candidate.y + candidate.height) {
+        return candidate;
+      }
+    }
+    return null;
+  }
   notifySelectablesOfSelectionChange() {
     const selectedRenderables = [];
     const touchedRenderables = [];
@@ -17719,5 +18289,5 @@ Captured output:
 
 export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, StdinBuffer, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=0377C87661B220C664756E2164756E21
-//# sourceMappingURL=index-jx194wn1.js.map
+//# debugId=A43FA725E26A0ABA64756E2164756E21
+//# sourceMappingURL=index-r7vqrd61.js.map