@cascadetui/core 0.1.9 → 0.1.11

package/3d.js

@@ -6,7 +6,7 @@ import {
   __export,
   __require,
   __toESM
-} from "./index-9j6zba34.js";
+} from "./index-gv8mtakv.js";
 
 // ../../node_modules/.bun/omggif@1.0.10/node_modules/omggif/omggif.js
 var require_omggif = __commonJS((exports) => {

package/{index-9j6zba34.js → index-gv8mtakv.js}

@@ -10533,6 +10533,24 @@ registerEnvVar({
   type: "boolean",
   default: false
 });
+registerEnvVar({
+  name: "CASCADE_TRACE_FFI_SLOW_MS",
+  description: "Log slow FFI calls (>= threshold, in ms).",
+  type: "number",
+  default: 0
+});
+registerEnvVar({
+  name: "CASCADE_TRACE_FFI_MAX_SAMPLES",
+  description: "Max timing samples to keep per FFI symbol when CASCADE_TRACE_FFI is enabled.",
+  type: "number",
+  default: 5000
+});
+registerEnvVar({
+  name: "CASCADE_TRACE_FRAME_BREAKDOWN",
+  description: "Enable detailed frame timing breakdown (yoga, render tree, native, stdout write)",
+  type: "boolean",
+  default: false
+});
 registerEnvVar({
   name: "CASCADE_FORCE_WCWIDTH",
   description: "Use wcwidth for character width calculations",
@@ -11553,9 +11571,56 @@ function convertToDebugSymbols(symbols) {
   if (env.CASCADE_DEBUG_FFI && !globalFFILogWriter) {
     const now = new Date;
     const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0];
-    const logFilePath = `ffi_otui_debug_${timestamp}.log`;
+    const logFilePath = `ffi_cascade_debug_${timestamp}.log`;
     globalFFILogWriter = Bun.file(logFilePath).writer();
   }
+  const slowThresholdMs = typeof env.CASCADE_TRACE_FFI_SLOW_MS === "number" ? env.CASCADE_TRACE_FFI_SLOW_MS : 0;
+  const maxSamples = typeof env.CASCADE_TRACE_FFI_MAX_SAMPLES === "number" && env.CASCADE_TRACE_FFI_MAX_SAMPLES > 0 ? env.CASCADE_TRACE_FFI_MAX_SAMPLES : 5000;
+  const formatArg = (arg) => {
+    if (arg === null)
+      return "null";
+    if (arg === undefined)
+      return "undefined";
+    const t2 = typeof arg;
+    if (t2 === "string")
+      return JSON.stringify(arg.length > 200 ? arg.slice(0, 200) + "\u2026" : arg);
+    if (t2 === "number" || t2 === "boolean" || t2 === "bigint")
+      return String(arg);
+    if (arg instanceof Uint8Array)
+      return `Uint8Array(${arg.byteLength})`;
+    if (arg instanceof ArrayBuffer)
+      return `ArrayBuffer(${arg.byteLength})`;
+    if (Array.isArray(arg))
+      return `Array(${arg.length})`;
+    if (t2 === "object") {
+      const ctor = arg?.constructor?.name;
+      if (ctor && ctor !== "Object")
+        return ctor;
+      try {
+        const json = JSON.stringify(arg);
+        if (typeof json === "string")
+          return json.length > 200 ? json.slice(0, 200) + "\u2026" : json;
+      } catch {
+        return "Object";
+      }
+      return "Object";
+    }
+    return String(arg);
+  };
+  let slowWriter = null;
+  const writeSlow = (line) => {
+    if (slowThresholdMs <= 0)
+      return;
+    if (!slowWriter) {
+      const now = new Date;
+      const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0];
+      const slowFilePath = `ffi_cascade_slow_${timestamp}.log`;
+      slowWriter = Bun.file(slowFilePath).writer();
+    }
+    const buffer = new TextEncoder().encode(line + `
+`);
+    slowWriter.write(buffer);
+  };
   const debugSymbols = {};
   let hasTracing = false;
   Object.entries(symbols).forEach(([key, value]) => {
@@ -11592,7 +11657,16 @@ function convertToDebugSymbols(symbols) {
           const start = performance.now();
           const result = originalFunc(...args);
           const end = performance.now();
-          globalTraceSymbols[key].push(end - start);
+          const dt = end - start;
+          const timings = globalTraceSymbols[key];
+          timings.push(dt);
+          if (timings.length > maxSamples) {
+            timings.splice(0, timings.length - maxSamples);
+          }
+          if (slowThresholdMs > 0 && dt >= slowThresholdMs) {
+            const argStr = args.map(formatArg).join(", ");
+            writeSlow(`${new Date().toISOString()} ${key} ${dt.toFixed(2)}ms (${argStr})`);
+          }
           return result;
         };
       }
@@ -11605,6 +11679,9 @@ function convertToDebugSymbols(symbols) {
         if (globalFFILogWriter) {
           globalFFILogWriter.end();
         }
+        if (slowWriter) {
+          slowWriter.end();
+        }
       } catch (e) {}
       if (globalTraceSymbols) {
         const allStats = [];
@@ -11676,7 +11753,7 @@ function convertToDebugSymbols(symbols) {
         try {
           const now = new Date;
           const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0];
-          const traceFilePath = `ffi_otui_trace_${timestamp}.log`;
+          const traceFilePath = `ffi_cascade_trace_${timestamp}.log`;
           Bun.write(traceFilePath, output);
         } catch (e) {
           console.error("Failed to write FFI trace file:", e);
@@ -16537,6 +16614,8 @@ class CliRenderer extends EventEmitter9 {
   _isDestroyed = false;
   _destroyPending = false;
   _destroyFinalized = false;
+  destroyTimeoutId = null;
+  destroyTimeoutMs = 100;
   nextRenderBuffer;
   currentRenderBuffer;
   _isRunning = false;
@@ -16578,6 +16657,10 @@ class CliRenderer extends EventEmitter9 {
   minTargetFrameTime = 1000 / this.maxFps;
   immediateRerenderRequested = false;
   updateScheduled = false;
+  consecutiveImmediateRerenders = 0;
+  lastImmediateRerenderTime = 0;
+  maxConsecutiveImmediateRerenders = 10;
+  immediateRerenderResetMs = 1000;
   liveRequestCounter = 0;
   _controlState = "idle" /* IDLE */;
   frameCallbacks = [];
@@ -16587,6 +16670,9 @@ class CliRenderer extends EventEmitter9 {
     renderTime: 0,
     frameCallbackTime: 0
   };
+  frameBreakdownBuffer = [];
+  frameBreakdownMaxSize = 100;
+  traceFrameBreakdown = env.CASCADE_TRACE_FRAME_BREAKDOWN;
   debugOverlay = {
     enabled: env.CASCADE_SHOW_STATS,
     corner: 3 /* bottomRight */
@@ -17660,6 +17746,16 @@ Captured output:
     if (this._logCrashReportsToConsole) {
       console.error(this.formatCrashReportForConsole(report));
     }
+    if (this.traceFrameBreakdown && this.frameBreakdownBuffer.length > 0) {
+      const breakdownDump = this.dumpFrameBreakdown();
+      console.error(`
+` + breakdownDump);
+      report.recentEvents.push({
+        timestamp: report.timestamp,
+        type: "crash:frame_breakdown",
+        payload: { breakdown: breakdownDump }
+      });
+    }
     this.emit("crash" /* CRASH */, report);
     return report;
   }
@@ -17925,6 +18021,14 @@ Captured output:
     this._isDestroyed = true;
     this._destroyPending = true;
     if (this.rendering) {
+      if (this.destroyTimeoutId === null) {
+        this.destroyTimeoutId = setTimeout(() => {
+          this.destroyTimeoutId = null;
+          if (this._destroyPending && !this._destroyFinalized && !this.renderingNative) {
+            this.finalizeDestroy();
+          }
+        }, this.destroyTimeoutMs);
+      }
       return;
     }
     this.finalizeDestroy();
@@ -17934,6 +18038,10 @@ Captured output:
       return;
     this._destroyFinalized = true;
     this._destroyPending = false;
+    if (this.destroyTimeoutId !== null) {
+      clearTimeout(this.destroyTimeoutId);
+      this.destroyTimeoutId = null;
+    }
     process.removeListener("SIGWINCH", this.sigwinchHandler);
     process.removeListener("uncaughtException", this.uncaughtExceptionHandler);
     process.removeListener("unhandledRejection", this.unhandledRejectionHandler);
@@ -17964,6 +18072,9 @@ Captured output:
       this.renderTimeout = null;
     }
     this._isRunning = false;
+    this.rendering = false;
+    this.updateScheduled = false;
+    this.immediateRerenderRequested = false;
     this.waitingForPixelResolution = false;
     this.setCapturedRenderable(undefined);
     try {
@@ -17992,6 +18103,26 @@ Captured output:
     }
     this.resolveIdleIfNeeded();
   }
+  dumpFrameBreakdown() {
+    if (this.frameBreakdownBuffer.length === 0) {
+      return "No frame breakdown data recorded";
+    }
+    const lines = this.frameBreakdownBuffer.map((f, i) => {
+      const time = new Date(f.timestamp).toISOString();
+      return `[${i}] ${time} total=${f.totalMs.toFixed(2)}ms tree=${f.renderTreeMs.toFixed(2)}ms native=${f.nativeMs.toFixed(2)}ms callback=${f.frameCallbackMs.toFixed(2)}ms`;
+    });
+    const totals = this.frameBreakdownBuffer.map((f) => f.totalMs);
+    const avgTotal = totals.reduce((a, b) => a + b, 0) / totals.length;
+    const maxTotal = Math.max(...totals);
+    const minTotal = Math.min(...totals);
+    return [
+      `=== Frame Breakdown (${this.frameBreakdownBuffer.length} frames) ===`,
+      `Avg: ${avgTotal.toFixed(2)}ms, Max: ${maxTotal.toFixed(2)}ms, Min: ${minTotal.toFixed(2)}ms`,
+      "",
+      ...lines
+    ].join(`
+`);
+  }
   startRenderLoop() {
     if (!this._isRunning)
       return;
@@ -18043,6 +18174,9 @@ Captured output:
       }
       const end = performance.now();
       this.renderStats.frameCallbackTime = end - start;
+      if (this._destroyPending) {
+        return;
+      }
       const renderTreeStart = traceEnabled ? trace.now() : 0;
       this.root.render(this.nextRenderBuffer, deltaTime);
       const renderTreeMs = traceEnabled ? trace.now() - renderTreeStart : 0;
@@ -18062,6 +18196,21 @@ Captured output:
           }
         }
         const overallFrameTime = performance.now() - overallStart;
+        if (this.traceFrameBreakdown) {
+          const breakdown = {
+            timestamp: Date.now(),
+            yogaMs: 0,
+            renderTreeMs,
+            nativeMs,
+            stdoutMs: 0,
+            frameCallbackMs: this.renderStats.frameCallbackTime,
+            totalMs: overallFrameTime
+          };
+          if (this.frameBreakdownBuffer.length >= this.frameBreakdownMaxSize) {
+            this.frameBreakdownBuffer.shift();
+          }
+          this.frameBreakdownBuffer.push(breakdown);
+        }
         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)}`);
@@ -18071,6 +18220,24 @@ Captured output:
           this.collectStatSample(overallFrameTime);
         }
         if (this._isRunning || this.immediateRerenderRequested) {
+          const now2 = Date.now();
+          if (this.immediateRerenderRequested) {
+            if (now2 - this.lastImmediateRerenderTime > this.immediateRerenderResetMs) {
+              this.consecutiveImmediateRerenders = 0;
+            }
+            this.consecutiveImmediateRerenders++;
+            this.lastImmediateRerenderTime = now2;
+            if (this.consecutiveImmediateRerenders > this.maxConsecutiveImmediateRerenders) {
+              console.warn(`[Cascade] Too many consecutive immediate re-renders (${this.consecutiveImmediateRerenders}), forcing delay`);
+              this.consecutiveImmediateRerenders = 0;
+              this.immediateRerenderRequested = false;
+              this.renderTimeout = setTimeout(() => {
+                this.renderTimeout = null;
+                this.loop();
+              }, 100);
+              return;
+            }
+          }
           const targetFrameTime = this.immediateRerenderRequested ? this.minTargetFrameTime : this.targetFrameTime;
           const delay = Math.max(1, targetFrameTime - Math.floor(overallFrameTime));
           this.immediateRerenderRequested = false;
@@ -18354,5 +18521,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=417D82C6F387312F64756E2164756E21
-//# sourceMappingURL=index-9j6zba34.js.map
+//# debugId=D41C1FFE474972FF64756E2164756E21
+//# sourceMappingURL=index-gv8mtakv.js.map