Merge origin/main into fix/233-default-q-quit

Author: RtlZeroMemory

CHANGELOG.md

@@ -9,6 +9,7 @@ The format is based on Keep a Changelog and the project follows Semantic Version
 ### Bug Fixes
 
 - **core/runtime**: Unhandled top-level `q`/`Q` and `Ctrl+C` inputs now stop the app by default, while preserving explicit keybinding handlers.
+- **native/detect**: Startup terminal probing now exits after a short DA1 drain window instead of waiting the full 500ms budget when XTVERSION never responds, reducing first-render delay on VTE-like terminals.
 - **core/constraints**: Constraint input signatures now include all required runtime dependencies, preventing stale cache reuse when unconstrained referenced widget geometry changes.
 - **core/layout**: Constraint resolution now performs bounded in-frame settle passes for deeper parent-dependent chains, eliminating first-frame/resize layout jump artifacts in nested constraint trees.
 - **core/layout**: Constraint and scroll override traversal now covers modal/layer slot children (`content`/`actions`) so display and geometry overrides apply consistently to overlay subtrees.

packages/core/src/app/__tests__/widgetRenderer.integration.test.ts

@@ -10,6 +10,7 @@ import type { DrawlistBuilder } from "../../drawlist/index.js";
 import type { ZrevEvent } from "../../events.js";
 import { type VNode, defineWidget, ui } from "../../index.js";
 import { DEFAULT_TERMINAL_CAPS } from "../../terminalCaps.js";
+import { createTestRenderer } from "../../testing/index.js";
 import { defaultTheme } from "../../theme/defaultTheme.js";
 import { TOAST_HEIGHT, getToastActionFocusId } from "../../widgets/toast.js";
 import { createApp } from "../createApp.js";
@@ -1089,6 +1090,67 @@ describe("WidgetRenderer integration battery", () => {
     assert.deepEqual(events, []);
   });
 
+  test("modal actions preserve declared order and click behavior", () => {
+    const backend = createNoopBackend();
+    const renderer = new WidgetRenderer<void>({
+      backend,
+      requestRender: () => {},
+    });
+
+    const calls: string[] = [];
+    const vnode = ui.modal({
+      id: "confirm-quit",
+      title: "Confirm quit",
+      content: ui.text("Are you sure?"),
+      actions: [
+        ui.button({
+          id: "cancel",
+          label: "Cancel",
+          onPress: () => calls.push("cancel"),
+        }),
+        ui.button({
+          id: "confirm",
+          label: "Quit",
+          onPress: () => calls.push("confirm"),
+        }),
+      ],
+    });
+
+    const res = renderer.submitFrame(
+      () => vnode,
+      undefined,
+      { cols: 80, rows: 24 },
+      defaultTheme,
+      noRenderHooks(),
+    );
+    assert.ok(res.ok);
+    const textSnapshot = createTestRenderer({ viewport: { cols: 80, rows: 24 } })
+      .render(vnode)
+      .toText();
+    assert.equal(textSnapshot.includes("Cancel"), true);
+
+    const rects = renderer.getRectByIdIndex();
+    const cancelRect = rects.get("cancel");
+    const confirmRect = rects.get("confirm");
+    assert.ok(cancelRect !== undefined, "cancel rect should exist");
+    assert.ok(confirmRect !== undefined, "confirm rect should exist");
+    if (!cancelRect || !confirmRect) return;
+
+    assert.equal(cancelRect.x < confirmRect.x, true, "cancel should render left of confirm");
+
+    const cancelX = cancelRect.x + Math.max(0, Math.floor((cancelRect.w - 1) / 2));
+    const cancelY = cancelRect.y;
+    renderer.routeEngineEvent(mouseDownEvent(cancelX, cancelY));
+    renderer.routeEngineEvent(mouseEvent(cancelX, cancelY, 4));
+
+    const confirmX = confirmRect.x + Math.max(0, Math.floor((confirmRect.w - 1) / 2));
+    const confirmY = confirmRect.y;
+    renderer.routeEngineEvent(mouseDownEvent(confirmX, confirmY));
+    renderer.routeEngineEvent(mouseEvent(confirmX, confirmY, 4));
+
+    assert.deepEqual(calls, ["cancel", "confirm"]);
+  });
+
   test("splitPane double-click toggles collapse via onCollapse", () => {
     const backend = createNoopBackend();
     const renderer = new WidgetRenderer<void>({

packages/core/src/renderer/__tests__/renderer.text.test.ts

@@ -11,10 +11,11 @@ import {
   parseCommandHeaders,
   parseInternedStrings,
 } from "../../__tests__/drawlistDecode.js";
-import { type VNode, createDrawlistBuilder } from "../../index.js";
+import { type VNode, createDrawlistBuilder, ui } from "../../index.js";
 import { layout } from "../../layout/layout.js";
 import { commitVNodeTree } from "../../runtime/commit.js";
 import { createInstanceIdAllocator } from "../../runtime/instance.js";
+import { createTestRenderer } from "../../testing/renderer.js";
 import { renderToDrawlist } from "../renderToDrawlist.js";
 
 const decoder = new TextDecoder();
@@ -296,6 +297,47 @@ function expectBlob(frame: ParsedFrame, blobIndex: number): TextRunBlob {
   return blob;
 }
 
+describe("renderer text - wrap newline handling", () => {
+  test("wrap=true renders explicit newline lines on separate rows", () => {
+    const renderer = createTestRenderer({ viewport: { cols: 20, rows: 4 } });
+    const frame = renderer.render(
+      ui.text("First line\nSecond line", {
+        id: "wrapped",
+        wrap: true,
+      }),
+    );
+    const lines = frame.toText().split("\n");
+
+    assert.equal(lines[0]?.includes("First line"), true);
+    assert.equal(lines[1]?.includes("Second line"), true);
+
+    const wrapped = frame.findById("wrapped");
+    assert.notEqual(wrapped, null);
+    assert.equal(wrapped?.rect.y, 0);
+    assert.ok((wrapped?.rect.h ?? 0) >= 2);
+  });
+
+  test("wrap=true preserves blank lines from double newlines", () => {
+    const renderer = createTestRenderer({ viewport: { cols: 20, rows: 6 } });
+    const frame = renderer.render(
+      ui.text("Alpha\n\nOmega", {
+        id: "wrapped-blank",
+        wrap: true,
+      }),
+    );
+    const lines = frame.toText().split("\n");
+
+    assert.equal(lines[0]?.includes("Alpha"), true);
+    assert.equal((lines[1] ?? "").trim(), "");
+    assert.equal(lines[2]?.includes("Omega"), true);
+
+    const wrapped = frame.findById("wrapped-blank");
+    assert.notEqual(wrapped, null);
+    assert.equal(wrapped?.rect.y, 0);
+    assert.ok((wrapped?.rect.h ?? 0) >= 3);
+  });
+});
+
 describe("renderer text - transform ANSI styling", () => {
   const gradientTransform = (): string => "\u001b[31mA\u001b[32mB\u001b[0m";
 

packages/native/vendor/VENDOR_COMMIT.txt

@@ -1 +1 @@
-c0849ae29483322623d4ab564877a8940896affb
+97a7b907cc6c5a2886fdaef2ea82c8f9e337013e

packages/native/vendor/zireael/src/core/zr_detect.c

@@ -18,6 +18,7 @@ enum {
   ZR_DETECT_READ_ACCUM_CAP = 4096u,
   ZR_DETECT_QUERY_TIMEOUT_MS = 100u,
   ZR_DETECT_TOTAL_TIMEOUT_MS = 500u,
+  ZR_DETECT_DA1_DRAIN_TIMEOUT_MS = 20u,
   ZR_DETECT_DECRQM_SET = 1u,
 };
 
@@ -756,6 +757,23 @@ static int32_t zr_detect_read_timeout_slice(uint64_t start_ms, uint32_t spent_ms
   return remaining;
 }
 
+static int32_t zr_detect_remaining_da1_drain_budget(uint32_t spent_ms) {
+  if (spent_ms >= (uint32_t)ZR_DETECT_DA1_DRAIN_TIMEOUT_MS) {
+    return 0;
+  }
+  return (int32_t)((uint32_t)ZR_DETECT_DA1_DRAIN_TIMEOUT_MS - spent_ms);
+}
+
+static int32_t zr_detect_clamp_timeout_budget(int32_t timeout_ms, int32_t budget_ms) {
+  if (timeout_ms <= 0 || budget_ms <= 0) {
+    return 0;
+  }
+  if (timeout_ms > budget_ms) {
+    return budget_ms;
+  }
+  return timeout_ms;
+}
+
 static zr_terminal_id_t zr_detect_fallback_terminal_id(plat_t* plat) {
   zr_terminal_id_t id = ZR_TERM_UNKNOWN;
   if (plat_guess_terminal_id(plat, &id) != ZR_OK) {
@@ -847,8 +865,25 @@ zr_result_t zr_detect_probe_terminal(plat_t* plat, const plat_caps_t* baseline_c
 
     uint64_t start_ms = plat_now_ms();
     uint32_t timeout_spent_ms = 0u;
+    /* DA1 acts as a probe sentinel; after it arrives, drain briefly then stop. */
+    uint8_t da1_responded = 0u;
+    uint64_t da1_seen_ms = 0u;
+    uint32_t da1_drain_spent_ms = 0u;
     while (true) {
-      const int32_t timeout_ms = zr_detect_read_timeout_slice(start_ms, timeout_spent_ms);
+      int32_t timeout_ms = zr_detect_read_timeout_slice(start_ms, timeout_spent_ms);
+      if (da1_responded != 0u) {
+        const uint64_t now_ms = plat_now_ms();
+        uint32_t da1_elapsed_ms = 0u;
+        if (now_ms > da1_seen_ms) {
+          const uint64_t delta_ms = now_ms - da1_seen_ms;
+          da1_elapsed_ms = (delta_ms > UINT32_MAX) ? UINT32_MAX : (uint32_t)delta_ms;
+        }
+        if (da1_elapsed_ms > da1_drain_spent_ms) {
+          da1_drain_spent_ms = da1_elapsed_ms;
+        }
+        const int32_t da1_budget_ms = zr_detect_remaining_da1_drain_budget(da1_drain_spent_ms);
+        timeout_ms = zr_detect_clamp_timeout_budget(timeout_ms, da1_budget_ms);
+      }
       if (timeout_ms <= 0) {
         break;
       }
@@ -860,6 +895,9 @@ zr_result_t zr_detect_probe_terminal(plat_t* plat, const plat_caps_t* baseline_c
       }
       if (n == 0) {
         timeout_spent_ms += (uint32_t)timeout_ms;
+        if (da1_responded != 0u) {
+          da1_drain_spent_ms += (uint32_t)timeout_ms;
+        }
         continue;
       }
 
@@ -871,6 +909,15 @@ zr_result_t zr_detect_probe_terminal(plat_t* plat, const plat_caps_t* baseline_c
         memcpy(collected + collected_len, chunk, copy_len);
         collected_len += copy_len;
       }
+      if (da1_responded == 0u) {
+        zr_detect_parsed_t partial;
+        zr_detect_parsed_reset(&partial);
+        (void)zr_detect_parse_responses(collected, collected_len, &partial);
+        da1_responded = partial.da1_responded;
+        if (da1_responded != 0u) {
+          da1_seen_ms = plat_now_ms();
+        }
+      }
       if (collected_len == sizeof(collected)) {
         break;
       }