Merge pull request #39 from RtlZeroMemory/feat/runtime-polish-foundation-pass

feat: runtime polish pass across core/node/native layers

Author: RtlZeroMemory

.github/workflows/ci.yml

@@ -77,11 +77,32 @@ jobs:
       - name: Build native addon
         run: npm run build:native
 
-      - name: Terminal e2e
+      - name: Terminal e2e (Linux full)
         if: runner.os == 'Linux'
         run: npm run test:e2e
 
-      - name: Native smoke + worker integration
+      - name: Terminal e2e equivalent (non-Linux reduced)
+        if: runner.os != 'Linux'
+        run: npm run test:e2e:reduced
+
+      - name: Native smoke + worker integration (Unix PTY)
+        if: runner.os != 'Windows'
+        run: |
+          python3 - <<'PY'
+          import os
+          import pty
+          import sys
+
+          status = pty.spawn(["bash", "-lc", "npm run test:native:smoke"])
+          if os.WIFEXITED(status):
+              sys.exit(os.WEXITSTATUS(status))
+          if os.WIFSIGNALED(status):
+              sys.exit(128 + os.WTERMSIG(status))
+          sys.exit(1)
+          PY
+
+      - name: Native smoke + worker integration (Windows)
+        if: runner.os == 'Windows'
         run: npm run test:native:smoke
 
   docs:

package.json

@@ -28,6 +28,7 @@
     "check": "npm run check:core-portability && npm run check:docs && npm run check:unicode",
     "test": "node scripts/run-tests.mjs",
     "test:e2e": "node scripts/run-e2e.mjs",
+    "test:e2e:reduced": "node scripts/run-e2e.mjs --profile reduced",
     "test:scripts": "node scripts/run-tests.mjs --scope scripts",
     "test:packages": "node scripts/run-tests.mjs --scope packages",
     "bench": "node --expose-gc packages/bench/dist/run.js",

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

@@ -278,6 +278,47 @@ describe("WidgetRenderer integration battery", () => {
     assert.deepEqual(events, ["enter:zone-1", "exit:zone-1", "enter:zone-2"]);
   });
 
+  test("focusZone restores latest focused widget when leaving and returning in same cycle", () => {
+    const backend = createNoopBackend();
+    const renderer = new WidgetRenderer<void>({
+      backend,
+      requestRender: () => {},
+    });
+
+    const vnode = ui.column({}, [
+      ui.focusZone({ id: "zone-1", navigation: "linear", wrapAround: true }, [
+        ui.button({ id: "a", label: "A" }),
+        ui.button({ id: "b", label: "B" }),
+      ]),
+      ui.focusZone({ id: "zone-2", navigation: "linear", wrapAround: true }, [
+        ui.button({ id: "c", label: "C" }),
+        ui.button({ id: "d", label: "D" }),
+      ]),
+    ]);
+
+    const res = renderer.submitFrame(
+      () => vnode,
+      undefined,
+      { cols: 40, rows: 10 },
+      defaultTheme,
+      noRenderHooks(),
+    );
+    assert.ok(res.ok);
+
+    // Same interaction cycle: move within zone-1, leave to zone-2, then return via TAB wrap.
+    renderer.routeEngineEvent(keyEvent(3 /* TAB */));
+    assert.equal(renderer.getFocusedId(), "a");
+
+    renderer.routeEngineEvent(keyEvent(21 /* DOWN */));
+    assert.equal(renderer.getFocusedId(), "b");
+
+    renderer.routeEngineEvent(keyEvent(3 /* TAB */));
+    assert.equal(renderer.getFocusedId(), "c");
+
+    renderer.routeEngineEvent(keyEvent(3 /* TAB */));
+    assert.equal(renderer.getFocusedId(), "b");
+  });
+
   test("focusZone onEnter/onExit swallow exceptions", () => {
     const backend = createNoopBackend();
     const renderer = new WidgetRenderer<void>({

packages/core/src/app/widgetRenderer.ts

@@ -2105,6 +2105,7 @@ export class WidgetRenderer<S> {
             activeZoneId: this.focusState.activeZoneId,
             focusList: this.focusList,
             zones: this.focusState.zones,
+            lastFocusedByZone: this.focusState.lastFocusedByZone,
             traps: this.traps,
             trapStack: this.focusState.trapStack,
             enabledById,

packages/core/src/drawlist/__tests__/builder_style_attrs.test.ts

@@ -0,0 +1,78 @@
+import { assert, describe, test } from "@rezi-ui/testkit";
+import { createDrawlistBuilderV1, createDrawlistBuilderV2 } from "../../index.js";
+
+function u32(bytes: Uint8Array, off: number): number {
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return dv.getUint32(off, true);
+}
+
+function textRunAttrs(bytes: Uint8Array, segmentIndex: number): number {
+  const blobsBytesOffset = u32(bytes, 52);
+  return u32(bytes, blobsBytesOffset + 4 + segmentIndex * 28 + 8);
+}
+
+function firstCommandOffset(bytes: Uint8Array): number {
+  return u32(bytes, 16);
+}
+
+function drawTextAttrs(bytes: Uint8Array): number {
+  return u32(bytes, firstCommandOffset(bytes) + 36);
+}
+
+describe("drawlist style attrs encode dim", () => {
+  test("v1 drawText attrs include dim without shifting existing bits", () => {
+    const b = createDrawlistBuilderV1();
+    b.drawText(0, 0, "dim", { dim: true });
+    const res = b.build();
+    assert.equal(res.ok, true);
+    if (!res.ok) return;
+
+    assert.equal(drawTextAttrs(res.bytes), 1 << 4);
+  });
+
+  test("v2 drawText attrs include dim without shifting existing bits", () => {
+    const b = createDrawlistBuilderV2();
+    b.drawText(0, 0, "dim", { dim: true });
+    const res = b.build();
+    assert.equal(res.ok, true);
+    if (!res.ok) return;
+
+    assert.equal(drawTextAttrs(res.bytes), 1 << 4);
+  });
+
+  test("v1 text-run attrs include dim without shifting existing bits", () => {
+    const b = createDrawlistBuilderV1();
+    const blobIndex = b.addTextRunBlob([
+      { text: "dim", style: { dim: true } },
+      { text: "base", style: { bold: true, italic: true, underline: true, inverse: true } },
+    ]);
+    assert.equal(blobIndex, 0);
+    if (blobIndex === null) return;
+
+    b.drawTextRun(0, 0, blobIndex);
+    const res = b.build();
+    assert.equal(res.ok, true);
+    if (!res.ok) return;
+
+    assert.equal(textRunAttrs(res.bytes, 0), 1 << 4);
+    assert.equal(textRunAttrs(res.bytes, 1), (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3));
+  });
+
+  test("v2 text-run attrs include dim without shifting existing bits", () => {
+    const b = createDrawlistBuilderV2();
+    const blobIndex = b.addTextRunBlob([
+      { text: "dim", style: { dim: true } },
+      { text: "base", style: { bold: true, italic: true, underline: true, inverse: true } },
+    ]);
+    assert.equal(blobIndex, 0);
+    if (blobIndex === null) return;
+
+    b.drawTextRun(0, 0, blobIndex);
+    const res = b.build();
+    assert.equal(res.ok, true);
+    if (!res.ok) return;
+
+    assert.equal(textRunAttrs(res.bytes, 0), 1 << 4);
+    assert.equal(textRunAttrs(res.bytes, 1), (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3));
+  });
+});

packages/core/src/drawlist/builder_v1.ts

@@ -141,7 +141,7 @@ function packRgb(v: unknown): number {
 
 /**
  * Encode TextStyle to binary format: packed fg/bg colors and attribute flags.
- * Attribute bits: 0=bold, 1=italic, 2=underline, 3=inverse
+ * Attribute bits: 0=bold, 1=italic, 2=underline, 3=inverse, 4=dim
  */
 function encodeStyle(style: TextStyle | undefined): EncodedStyle {
   if (!style) return { fg: 0, bg: 0, attrs: 0 };
@@ -154,6 +154,7 @@ function encodeStyle(style: TextStyle | undefined): EncodedStyle {
   if (style.italic) attrs |= 1 << 1;
   if (style.underline) attrs |= 1 << 2;
   if (style.inverse) attrs |= 1 << 3;
+  if (style.dim) attrs |= 1 << 4;
 
   return { fg, bg, attrs };
 }

packages/core/src/drawlist/builder_v2.ts

@@ -130,6 +130,7 @@ function encodeStyle(style: TextStyle | undefined): EncodedStyle {
   if (style.italic) attrs |= 1 << 1;
   if (style.underline) attrs |= 1 << 2;
   if (style.inverse) attrs |= 1 << 3;
+  if (style.dim) attrs |= 1 << 4;
 
   return { fg, bg, attrs };
 }

packages/core/src/layout/__tests__/constraints.golden.test.ts

@@ -67,6 +67,34 @@ describe("constraints (deterministic) - golden cases", () => {
     assert.equal(out.children[0]?.children[0]?.rect.h, 10);
   });
 
+  test("nested row with capped flex children does not starve sibling width", () => {
+    const tree = ui.row({}, [
+      ui.row({}, [
+        ui.box({ border: "none", flex: 1, maxWidth: 3 }, []),
+        ui.box({ border: "none", flex: 1, maxWidth: 3 }, []),
+      ]),
+      ui.box({ border: "none" }, [ui.text("z")]),
+    ]);
+
+    const out = mustLayout(tree, 20, 5);
+    assert.equal(out.children[0]?.rect.w, 6);
+    assert.equal(out.children[1]?.rect.w, 1);
+  });
+
+  test("nested column with capped flex children does not starve sibling height", () => {
+    const tree = ui.column({}, [
+      ui.column({}, [
+        ui.box({ border: "none", flex: 1, maxHeight: 2 }, []),
+        ui.box({ border: "none", flex: 1, maxHeight: 2 }, []),
+      ]),
+      ui.box({ border: "none" }, [ui.text("y")]),
+    ]);
+
+    const out = mustLayout(tree, 10, 10);
+    assert.equal(out.children[0]?.rect.h, 4);
+    assert.equal(out.children[1]?.rect.h, 1);
+  });
+
   test("row child margin reserves outer space and offsets child rect", () => {
     const tree = ui.row({}, [
       ui.box({ border: "none", width: 4, height: 2, m: 1 }, [ui.text("x")]),

packages/core/src/layout/kinds/stack.ts

@@ -74,20 +74,21 @@ export function measureStackKinds(
       const forcedW = self.width === null ? null : clampWithin(self.width, minW, maxWCap);
       const forcedH = self.height === null ? null : clampWithin(self.height, minH, maxHCap);
 
-      const needsConstraintPass = vnode.children.some(
-        (c) => childHasFlexInMainAxis(c, "row") || childHasPercentInMainAxis(c, "row"),
-      );
-      const fillMain = forcedW === null && needsConstraintPass;
+      const hasFlexInMainAxis = vnode.children.some((c) => childHasFlexInMainAxis(c, "row"));
+      const hasPercentInMainAxis = vnode.children.some((c) => childHasPercentInMainAxis(c, "row"));
+      const needsConstraintPass = hasFlexInMainAxis || hasPercentInMainAxis;
+      const fillMain = forcedW === null && hasPercentInMainAxis;
       const fillCross =
         forcedH === null && vnode.children.some((c) => childHasPercentInCrossAxis(c, "row"));
 
-      const outerWLimit = forcedW ?? (fillMain ? maxWCap : maxWCap);
+      const outerWLimit = forcedW ?? maxWCap;
       const outerHLimit = forcedH ?? maxHCap;
 
       const cw = clampNonNegative(outerWLimit - padX);
       const chLimit = clampNonNegative(outerHLimit - padY);
 
       let maxChildH = 0;
+      let usedMainInConstraintPass = 0;
 
       if (needsConstraintPass) {
         const parentRect: Rect = { x: 0, y: 0, w: cw, h: chLimit };
@@ -193,6 +194,12 @@ export function measureStackKinds(
           const childH = align === "stretch" ? chLimit : sizeRes.value.h;
           if (childH > maxChildH) maxChildH = childH;
         }
+
+        for (let i = 0; i < mainSizes.length; i++) {
+          usedMainInConstraintPass += mainSizes[i] ?? 0;
+        }
+        usedMainInConstraintPass +=
+          vnode.children.length <= 1 ? 0 : gap * (vnode.children.length - 1);
       } else {
         let remainingWidth = cw;
         let cursorX = 0;
@@ -231,7 +238,8 @@ export function measureStackKinds(
         });
       }
 
-      const chosenW = forcedW ?? (fillMain ? maxWCap : maxWCap);
+      const shrinkW = padX + Math.min(cw, usedMainInConstraintPass);
+      const chosenW = forcedW ?? (fillMain ? maxWCap : Math.min(maxWCap, shrinkW));
       const chosenH = forcedH ?? (fillCross ? maxHCap : Math.min(maxHCap, padY + maxChildH));
       const innerW = clampWithin(chosenW, minW, maxWCap);
       const innerH = clampWithin(chosenH, minH, maxHCap);
@@ -268,20 +276,23 @@ export function measureStackKinds(
       const forcedW = self.width === null ? null : clampWithin(self.width, minW, maxWCap);
       const forcedH = self.height === null ? null : clampWithin(self.height, minH, maxHCap);
 
-      const needsConstraintPass = vnode.children.some(
-        (c) => childHasFlexInMainAxis(c, "column") || childHasPercentInMainAxis(c, "column"),
+      const hasFlexInMainAxis = vnode.children.some((c) => childHasFlexInMainAxis(c, "column"));
+      const hasPercentInMainAxis = vnode.children.some((c) =>
+        childHasPercentInMainAxis(c, "column"),
       );
-      const fillMain = forcedH === null && needsConstraintPass;
+      const needsConstraintPass = hasFlexInMainAxis || hasPercentInMainAxis;
+      const fillMain = forcedH === null && hasPercentInMainAxis;
       const fillCross =
         forcedW === null && vnode.children.some((c) => childHasPercentInCrossAxis(c, "column"));
 
       const outerWLimit = forcedW ?? maxWCap;
-      const outerHLimit = forcedH ?? (fillMain ? maxHCap : maxHCap);
+      const outerHLimit = forcedH ?? maxHCap;
 
       const cw = clampNonNegative(outerWLimit - padX);
       const ch = clampNonNegative(outerHLimit - padY);
 
       let maxChildW = 0;
+      let usedMainInConstraintPass = 0;
 
       if (needsConstraintPass) {
         const parentRect: Rect = { x: 0, y: 0, w: cw, h: ch };
@@ -387,6 +398,12 @@ export function measureStackKinds(
           const childW = align === "stretch" ? cw : sizeRes.value.w;
           if (childW > maxChildW) maxChildW = childW;
         }
+
+        for (let i = 0; i < mainSizes.length; i++) {
+          usedMainInConstraintPass += mainSizes[i] ?? 0;
+        }
+        usedMainInConstraintPass +=
+          vnode.children.length <= 1 ? 0 : gap * (vnode.children.length - 1);
       } else {
         let remainingHeight = ch;
         let cursorY = 0;
@@ -425,8 +442,9 @@ export function measureStackKinds(
         });
       }
 
+      const shrinkH = padY + Math.min(ch, usedMainInConstraintPass);
       const chosenW = forcedW ?? (fillCross ? maxWCap : Math.min(maxWCap, padX + maxChildW));
-      const chosenH = forcedH ?? (fillMain ? maxHCap : maxHCap);
+      const chosenH = forcedH ?? (fillMain ? maxHCap : Math.min(maxHCap, shrinkH));
       const innerW = clampWithin(chosenW, minW, maxWCap);
       const innerH = clampWithin(chosenH, minH, maxHCap);
       return ok({