@cel-tui/core 0.6.2 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cel-tui/core",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "description": "Core framework engine for cel-tui — primitives, layout, rendering, input",
   "type": "module",
   "module": "src/index.ts",
@@ -34,7 +34,7 @@
     "layout"
   ],
   "dependencies": {
-    "@cel-tui/types": "0.6.2",
+    "@cel-tui/types": "0.7.1",
     "get-east-asian-width": "^1.5.0"
   },
   "peerDependencies": {

package/src/cel.ts

@@ -5,33 +5,36 @@ import type {
   Theme,
 } from "@cel-tui/types";
 import { CellBuffer } from "./cell-buffer.js";
-import { emitBuffer, emitDiff, defaultTheme } from "./emitter.js";
+import { defaultTheme, emitBuffer, emitDiff } from "./emitter.js";
 import {
-  hitTest,
+  collectFocusable,
+  collectKeyPressHandlers,
   findClickHandler,
   findScrollTarget,
-  collectKeyPressHandlers,
-  collectFocusable,
+  hitTest,
 } from "./hit-test.js";
 import { decodeKeyEvents, isEditingKey, type KeyInput } from "./keys.js";
-import { layout, type LayoutNode } from "./layout.js";
+import { type LayoutNode, layout } from "./layout.js";
 import {
-  paint,
   getTextInputCursor,
-  setTextInputCursor,
+  getTextInputCursorScreenPos,
   getTextInputScroll,
+  paint,
+  setTextInputCursor,
   setTextInputScroll,
-  getTextInputCursorScreenPos,
 } from "./paint.js";
+import { getMaxScrollOffset, getScrollStep } from "./scroll.js";
+import type { Terminal } from "./terminal.js";
 import {
-  insertChar,
   deleteBackward,
   deleteForward,
-  moveCursor,
+  deleteWordBackward,
+  deleteWordForward,
   type EditState,
+  insertChar,
+  moveCursor,
+  moveCursorByWord,
 } from "./text-edit.js";
-import type { Terminal } from "./terminal.js";
-import { getMaxScrollOffset, getScrollStep } from "./scroll.js";
 
 type RenderFn = () => Node | Node[];
 
@@ -76,6 +79,18 @@ let stampedScrollNodes: { node: Node; key: string }[] = [];
 /** The cursor state currently expected on the terminal. */
 let lastTerminalCursor: TerminalCursorState | null = { visible: false };
 
+function requiredAt<T>(
+  items: readonly T[],
+  index: number,
+  description: string,
+): T {
+  const item = items[index];
+  if (item === undefined) {
+    throw new Error(`Missing ${description} at index ${index}`);
+  }
+  return item;
+}
+
 function doRender(): void {
   renderScheduled = false;
   if (!renderFn || !terminal) return;
@@ -108,6 +123,8 @@ function doRender(): void {
     currentLayouts.push(layoutTree);
   }
 
+  syncLastFocusedIndex();
+
   // Stamp uncontrolled focus and scroll before painting
   stampUncontrolledFocus();
   stampUncontrolledScroll();
@@ -163,7 +180,9 @@ function getDesiredTerminalCursor(): TerminalCursorState {
 function findFocusedTextInputLayout(): LayoutNode | null {
   // Check controlled focus: scan all layers for TextInput with focused: true
   for (let i = currentLayouts.length - 1; i >= 0; i--) {
-    const found = findFocusedTIInTree(currentLayouts[i]!);
+    const found = findFocusedTIInTree(
+      requiredAt(currentLayouts, i, "layout root"),
+    );
     if (found) return found;
   }
   // Check uncontrolled focus
@@ -172,7 +191,11 @@ function findFocusedTextInputLayout(): LayoutNode | null {
     if (topLayer) {
       const focusables = collectFocusable(topLayer);
       if (frameworkFocusIndex < focusables.length) {
-        const target = focusables[frameworkFocusIndex]!;
+        const target = requiredAt(
+          focusables,
+          frameworkFocusIndex,
+          "focusable node",
+        );
         if (target.node.type === "textinput") return target;
       }
     }
@@ -189,13 +212,45 @@ function findFocusedTIInTree(ln: LayoutNode): LayoutNode | null {
   return null;
 }
 
+function syncLastFocusedIndex(): void {
+  const topLayer = currentLayouts[currentLayouts.length - 1];
+  if (!topLayer) return;
+
+  const focusables = collectFocusable(topLayer);
+  if (focusables.length === 0) return;
+
+  const controlled = findFocusedInTree(topLayer);
+  if (controlled) {
+    let idx = focusables.indexOf(controlled);
+    if (idx === -1) {
+      idx = focusables.findIndex(
+        (focusable) => focusable.node === controlled.node,
+      );
+    }
+    if (idx !== -1) {
+      lastFocusedIndex = idx;
+    }
+    return;
+  }
+
+  if (frameworkFocusIndex >= 0 && frameworkFocusIndex < focusables.length) {
+    lastFocusedIndex = frameworkFocusIndex;
+  }
+}
+
 // --- Input handling ---
 
 const BRACKETED_PASTE_START = "\x1b[200~";
 const BRACKETED_PASTE_END = "\x1b[201~";
 
 // Regex for a single SGR mouse event, anchored to the current parse position.
-const SGR_MOUSE_RE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/;
+// biome-ignore lint/complexity/useRegexLiterals: using RegExp here avoids control-character regex diagnostics.
+const SGR_MOUSE_RE = new RegExp(String.raw`^\x1b\[<(\d+);(\d+);(\d+)([Mm])`);
+// biome-ignore lint/complexity/useRegexLiterals: using RegExp here avoids control-character regex diagnostics.
+const TERMINAL_TITLE_CONTROL_CHARS_RE = new RegExp(
+  String.raw`[\x00-\x1f\x7f-\x9f]`,
+  "g",
+);
 
 // Trailing keyboard data that ended with an incomplete CSI sequence.
 let pendingKeyData = "";
@@ -216,6 +271,10 @@ let batchScrollOffsets: Map<object, number> | null = null;
 // keys in the same chunk must see the updated value/cursor immediately.
 let batchTextInputEdits: Map<TextInputProps, EditState> | null = null;
 
+function sanitizeTerminalTitle(title: string): string {
+  return title.replace(TERMINAL_TITLE_CONTROL_CHARS_RE, "");
+}
+
 function handleInput(data: string): void {
   batchTextInputEdits = new Map();
 
@@ -368,9 +427,16 @@ function readSgrMouseEvent(
  * Returns a MouseEvent for scroll and click events, null for unhandled buttons.
  */
 function parseSgrMatch(match: RegExpExecArray): MouseEvent | null {
-  const cb = parseInt(match[1]!, 10);
-  const x = parseInt(match[2]!, 10) - 1; // 1-indexed → 0-indexed
-  const y = parseInt(match[3]!, 10) - 1;
+  const cbMatch = match[1];
+  const xMatch = match[2];
+  const yMatch = match[3];
+  if (cbMatch === undefined || xMatch === undefined || yMatch === undefined) {
+    throw new Error("Incomplete SGR mouse match");
+  }
+
+  const cb = parseInt(cbMatch, 10);
+  const x = parseInt(xMatch, 10) - 1; // 1-indexed → 0-indexed
+  const y = parseInt(yMatch, 10) - 1;
   const isRelease = match[4] === "m";
 
   // Scroll up (cb=64) / scroll down (cb=65)
@@ -402,7 +468,9 @@ function isControlledFocus(ln: LayoutNode): boolean {
 function findFocusedElement(): LayoutNode | null {
   // Controlled: scan tree for focused: true
   for (let i = currentLayouts.length - 1; i >= 0; i--) {
-    const found = findFocusedInTree(currentLayouts[i]!);
+    const found = findFocusedInTree(
+      requiredAt(currentLayouts, i, "layout root"),
+    );
     if (found) return found;
   }
   // Uncontrolled: check framework-tracked index
@@ -411,7 +479,7 @@ function findFocusedElement(): LayoutNode | null {
     if (topLayer) {
       const focusables = collectFocusable(topLayer);
       if (frameworkFocusIndex < focusables.length) {
-        return focusables[frameworkFocusIndex]!;
+        return requiredAt(focusables, frameworkFocusIndex, "focusable node");
       }
     }
     // Index out of bounds (tree changed) — clear
@@ -432,7 +500,7 @@ function stampUncontrolledFocus(): void {
 
   // Don't stamp if a controlled element owns focus
   for (let i = currentLayouts.length - 1; i >= 0; i--) {
-    if (findFocusedInTree(currentLayouts[i]!)) {
+    if (findFocusedInTree(requiredAt(currentLayouts, i, "layout root"))) {
       frameworkFocusIndex = -1;
       return;
     }
@@ -445,14 +513,14 @@ function stampUncontrolledFocus(): void {
     frameworkFocusIndex = -1;
     return;
   }
-  const target = focusables[frameworkFocusIndex]!;
+  const target = requiredAt(focusables, frameworkFocusIndex, "focusable node");
   const node = target.node;
   if (
     node.type === "textinput" ||
     node.type === "vstack" ||
     node.type === "hstack"
   ) {
-    (node.props as any).focused = true;
+    node.props.focused = true;
     stampedNode = target;
   }
 }
@@ -470,7 +538,7 @@ function unstampUncontrolledFocus(): void {
     node.type === "vstack" ||
     node.type === "hstack"
   ) {
-    delete (node.props as any).focused;
+    delete node.props.focused;
   }
   stampedNode = null;
 }
@@ -482,7 +550,10 @@ function unstampUncontrolledFocus(): void {
 function computeTreePath(root: LayoutNode, target: LayoutNode): string | null {
   if (root === target) return "";
   for (let i = 0; i < root.children.length; i++) {
-    const sub = computeTreePath(root.children[i]!, target);
+    const sub = computeTreePath(
+      requiredAt(root.children, i, "layout child"),
+      target,
+    );
     if (sub !== null) return sub === "" ? String(i) : `${i}/${sub}`;
   }
   return null;
@@ -493,7 +564,10 @@ function computeTreePath(root: LayoutNode, target: LayoutNode): string | null {
  */
 function getScrollPathKey(target: LayoutNode): string | null {
   for (let i = 0; i < currentLayouts.length; i++) {
-    const path = computeTreePath(currentLayouts[i]!, target);
+    const path = computeTreePath(
+      requiredAt(currentLayouts, i, "layout root"),
+      target,
+    );
     if (path !== null) return `L${i}:${path}`;
   }
   return null;
@@ -507,7 +581,7 @@ function stampUncontrolledScroll(): void {
   stampedScrollNodes = [];
   if (uncontrolledScrollOffsets.size === 0) return;
   for (let i = 0; i < currentLayouts.length; i++) {
-    walkAndStampScroll(currentLayouts[i]!, `L${i}:`);
+    walkAndStampScroll(requiredAt(currentLayouts, i, "layout root"), `L${i}:`);
   }
 }
 
@@ -521,7 +595,7 @@ function walkAndStampScroll(ln: LayoutNode, pathKey: string): void {
     ) {
       const offset = uncontrolledScrollOffsets.get(pathKey);
       if (offset !== undefined && offset !== 0) {
-        (node.props as any).scrollOffset = offset;
+        node.props.scrollOffset = offset;
         stampedScrollNodes.push({ node, key: pathKey });
       }
     }
@@ -531,14 +605,14 @@ function walkAndStampScroll(ln: LayoutNode, pathKey: string): void {
     const childKey = pathKey.endsWith(":")
       ? `${pathKey}${i}`
       : `${pathKey}/${i}`;
-    walkAndStampScroll(ln.children[i]!, childKey);
+    walkAndStampScroll(requiredAt(ln.children, i, "layout child"), childKey);
   }
 }
 
 function unstampUncontrolledScroll(): void {
   for (const { node } of stampedScrollNodes) {
     if (node.type === "vstack" || node.type === "hstack") {
-      delete (node.props as any).scrollOffset;
+      delete node.props.scrollOffset;
     }
   }
   stampedScrollNodes = [];
@@ -608,8 +682,7 @@ function resolveScrollOffset(ln: import("./layout.js").LayoutNode): number {
   const node = ln.node;
   if (node.type === "text") return 0;
   const props = node.props;
-  if ((props as any).scrollOffset !== undefined)
-    return (props as any).scrollOffset;
+  if (props.scrollOffset !== undefined) return props.scrollOffset;
   // Check uncontrolled map
   const pathKey = getScrollPathKey(ln);
   if (pathKey !== null) {
@@ -621,7 +694,7 @@ function resolveScrollOffset(ln: import("./layout.js").LayoutNode): number {
 function handleMouseEvent(event: MouseEvent): void {
   // Hit test on topmost layer first
   for (let i = currentLayouts.length - 1; i >= 0; i--) {
-    const layoutRoot = currentLayouts[i]!;
+    const layoutRoot = requiredAt(currentLayouts, i, "layout root");
     const path = hitTest(layoutRoot, event.x, event.y, resolveScrollOffset);
     if (path.length === 0) continue;
 
@@ -654,9 +727,12 @@ function handleMouseEvent(event: MouseEvent): void {
           const clamped = Math.max(0, Math.min(maxOffset, current + delta));
           setTextInputScroll(tiProps, clamped);
           cel.render();
-        } else {
-          const props = target.node.type !== "text" ? target.node.props : null;
-          if (props && (props as any).overflow === "scroll") {
+        } else if (
+          target.node.type === "vstack" ||
+          target.node.type === "hstack"
+        ) {
+          const props = target.node.props;
+          if (props.overflow === "scroll") {
             if (props.onScroll) {
               // Controlled scroll: notify app.
               // Use batch accumulator if available (multiple events in one chunk),
@@ -665,9 +741,7 @@ function handleMouseEvent(event: MouseEvent): void {
               // applying the delta — otherwise Infinity + (-1) = Infinity
               // and scrolling up never unsticks.
               const rawBase =
-                batchScrollOffsets?.get(props) ??
-                (props as any).scrollOffset ??
-                0;
+                batchScrollOffsets?.get(props) ?? props.scrollOffset ?? 0;
               const baseOffset = Math.min(rawBase, maxOffset);
               const newOffset = Math.max(
                 0,
@@ -701,13 +775,14 @@ function handleMouseEvent(event: MouseEvent): void {
  */
 function findClickFocusTarget(path: LayoutNode[]): LayoutNode | null {
   for (let i = path.length - 1; i >= 0; i--) {
-    const node = path[i]!.node;
-    if (node.type === "textinput") return path[i]!;
+    const layoutNode = requiredAt(path, i, "hit path node");
+    const node = layoutNode.node;
+    if (node.type === "textinput") return layoutNode;
     if (node.type === "vstack" || node.type === "hstack") {
       const isFocusable =
         node.props.focusable === true ||
         (node.props.onClick != null && node.props.focusable !== false);
-      if (isFocusable) return path[i]!;
+      if (isFocusable) return layoutNode;
     }
   }
   return null;
@@ -747,6 +822,15 @@ function handleBracketedPaste(text: string): void {
   commitTextInputEdit(props, editState, nextState);
 }
 
+function blurFocusedElement(): boolean {
+  const current = findFocusedElement();
+  if (!current) return false;
+
+  changeFocus(null);
+  cel.render();
+  return true;
+}
+
 function handleKeyEvent(event: KeyInput): void {
   const { key, text } = event;
 
@@ -793,22 +877,12 @@ function handleKeyEvent(event: KeyInput): void {
             : (currentIdx - 1 + focusables.length) % focusables.length;
       }
 
-      changeFocus(focusables[nextIdx]!);
+      changeFocus(requiredAt(focusables, nextIdx, "focusable node"));
       cel.render();
       return;
     } // end: not a focused TextInput
   }
 
-  // Escape: unfocus current element
-  if (key === "escape") {
-    const current = findFocusedElement();
-    if (current) {
-      changeFocus(null);
-      cel.render();
-      return;
-    }
-  }
-
   // Enter: activate focused clickable container
   if (key === "enter") {
     const current = findFocusedElement();
@@ -850,12 +924,20 @@ function handleKeyEvent(event: KeyInput): void {
         case "delete":
           newState = deleteForward(editState);
           break;
+        case "ctrl+w":
+          newState = deleteWordBackward(editState);
+          break;
+        case "alt+d":
+          newState = deleteWordForward(editState);
+          break;
         case "left":
         case "right":
         case "up":
         case "down":
         case "home":
         case "end":
+        case "ctrl+a":
+        case "ctrl+e":
           {
             const tiPadX =
               (focusedInput.node as TextInputNode).props.padding?.x ?? 0;
@@ -863,13 +945,23 @@ function handleKeyEvent(event: KeyInput): void {
               0,
               focusedInput.rect.width - tiPadX * 2,
             );
+            const direction =
+              key === "ctrl+a" ? "home" : key === "ctrl+e" ? "end" : key;
             newState = moveCursor(
               editState,
-              key as "left" | "right" | "up" | "down" | "home" | "end",
+              direction as "left" | "right" | "up" | "down" | "home" | "end",
               contentWidth,
             );
           }
           break;
+        case "alt+b":
+        case "ctrl+left":
+          newState = moveCursorByWord(editState, "backward");
+          break;
+        case "alt+f":
+        case "ctrl+right":
+          newState = moveCursorByWord(editState, "forward");
+          break;
         case "enter":
         case "shift+enter":
           newState = insertChar(editState, "\n");
@@ -896,7 +988,10 @@ function handleKeyEvent(event: KeyInput): void {
   const focused = findFocusedElement();
   if (focused) {
     for (let i = currentLayouts.length - 1; i >= 0; i--) {
-      const path = findPathTo(currentLayouts[i]!, focused);
+      const path = findPathTo(
+        requiredAt(currentLayouts, i, "layout root"),
+        focused,
+      );
       if (path) {
         let handlers = collectKeyPressHandlers(path);
         // If a TextInput's onKeyPress was already called in the pre-editing
@@ -904,7 +999,7 @@ function handleKeyEvent(event: KeyInput): void {
         if (
           focusedInput &&
           handlers.length > 0 &&
-          handlers[0]!.layoutNode === focusedInput
+          requiredAt(handlers, 0, "key handler").layoutNode === focusedInput
         ) {
           handlers = handlers.slice(1);
         }
@@ -920,28 +1015,45 @@ function handleKeyEvent(event: KeyInput): void {
           }
           // Always return — the key was offered to every handler in the
           // focused element's path (including root). Even if all returned
-          // false, we don't retry via the unfocused fallback path.
-          if (consumed) cel.render();
+          // false, we don't retry via the top-layer fallback path.
+          if (consumed) {
+            cel.render();
+            return;
+          }
+          if (key === "escape" && blurFocusedElement()) return;
           return;
         }
       }
     }
   }
 
-  // No focused element — try root onKeyPress on topmost layer
-  for (let i = currentLayouts.length - 1; i >= 0; i--) {
-    const layoutRoot = currentLayouts[i]!;
-    const path = [layoutRoot];
-    const handlers = collectKeyPressHandlers(path);
-    if (handlers.length > 0) {
-      for (const h of handlers) {
-        const result = h.handler(key);
-        if (result !== false) break;
+  // Fallback: offer the key to the topmost layer's root when it was not
+  // already handled on the focused path.
+  const topLayer = currentLayouts[currentLayouts.length - 1];
+  if (!topLayer) {
+    if (key === "escape") blurFocusedElement();
+    return;
+  }
+
+  const handlers = collectKeyPressHandlers([topLayer]);
+  if (handlers.length > 0) {
+    let consumed = false;
+    for (const h of handlers) {
+      const result = h.handler(key);
+      if (result !== false) {
+        consumed = true;
+        break;
       }
+    }
+    if (consumed) {
       cel.render();
       return;
     }
   }
+
+  if (key === "escape" && blurFocusedElement()) return;
+  if (handlers.length === 0) return;
+  cel.render();
 }
 
 /**
@@ -1043,6 +1155,18 @@ export const cel = {
     process.nextTick(doRender);
   },
 
+  /**
+   * Set the terminal window or tab title.
+   *
+   * This is an imperative side effect, not part of the render tree.
+   * Control characters are stripped from the title before writing the
+   * terminal sequence. Best effort only — some hosts may ignore it.
+   */
+  setTitle(title: string): void {
+    if (!terminal) return;
+    terminal.write(`\x1b]2;${sanitizeTerminalTitle(title)}\x1b\\`);
+  },
+
   /**
    * Stop the framework and restore terminal state.
    *

package/src/cell-buffer.ts

@@ -94,7 +94,12 @@ export class CellBuffer {
     if (x < 0 || x >= this._width || y < 0 || y >= this._height) {
       return EMPTY_CELL;
     }
-    return this.cells[y * this._width + x]!;
+
+    const cell = this.cells[y * this._width + x];
+    if (cell === undefined) {
+      throw new Error(`Missing cell at (${x}, ${y})`);
+    }
+    return cell;
   }
 
   /**
@@ -159,7 +164,7 @@ export class CellBuffer {
     const copyH = Math.min(this._height, height);
     for (let y = 0; y < copyH; y++) {
       for (let x = 0; x < copyW; x++) {
-        newCells[y * width + x] = this.cells[y * this._width + x]!;
+        newCells[y * width + x] = this.get(x, y);
       }
     }
     this.cells = newCells;

package/src/emitter.ts

@@ -1,6 +1,5 @@
 import type { Color, Theme, ThemeValue } from "@cel-tui/types";
-import type { Cell } from "./cell-buffer.js";
-import { CellBuffer, EMPTY_CELL } from "./cell-buffer.js";
+import type { Cell, CellBuffer } from "./cell-buffer.js";
 
 // --- Default ANSI 16 theme ---
 

package/src/hit-test.ts

@@ -13,6 +13,18 @@ function pointInRect(x: number, y: number, rect: Rect): boolean {
   );
 }
 
+function requiredAt<T>(
+  items: readonly T[],
+  index: number,
+  description: string,
+): T {
+  const item = items[index];
+  if (item === undefined) {
+    throw new Error(`Missing ${description} at index ${index}`);
+  }
+  return item;
+}
+
 /**
  * Callback to resolve the current scroll offset for a scrollable container.
  * Used to adjust hit coordinates when testing children of scrolled containers.
@@ -21,8 +33,7 @@ type ScrollOffsetResolver = (ln: LayoutNode) => number;
 
 /** Default resolver: reads scrollOffset from props, defaults to 0. */
 function defaultScrollResolver(ln: LayoutNode): number {
-  const props = getProps(ln);
-  return (props as any)?.scrollOffset ?? 0;
+  return getProps(ln)?.scrollOffset ?? 0;
 }
 
 /**
@@ -82,7 +93,7 @@ export function hitTest(
     const testX = x + adjustX;
     const testY = y + adjustY;
     for (let i = current.children.length - 1; i >= 0; i--) {
-      const child = current.children[i]!;
+      const child = requiredAt(current.children, i, "layout child");
       if (pointInRect(testX, testY, child.rect)) {
         path.push(child);
         current = child;
@@ -114,9 +125,10 @@ export function findClickHandler(
   path: LayoutNode[],
 ): { layoutNode: LayoutNode; handler: () => void } | null {
   for (let i = path.length - 1; i >= 0; i--) {
-    const props = getProps(path[i]!);
+    const layoutNode = requiredAt(path, i, "hit path node");
+    const props = getProps(layoutNode);
     if (props?.onClick) {
-      return { layoutNode: path[i]!, handler: props.onClick };
+      return { layoutNode, handler: props.onClick };
     }
   }
   return null;
@@ -131,10 +143,11 @@ export function findClickHandler(
  */
 export function findScrollTarget(path: LayoutNode[]): LayoutNode | null {
   for (let i = path.length - 1; i >= 0; i--) {
-    const node = path[i]!.node;
-    if (node.type === "textinput") return path[i]!;
-    const props = getProps(path[i]!);
-    if (props?.overflow === "scroll") return path[i]!;
+    const layoutNode = requiredAt(path, i, "hit path node");
+    const node = layoutNode.node;
+    if (node.type === "textinput") return layoutNode;
+    const props = getProps(layoutNode);
+    if (props?.overflow === "scroll") return layoutNode;
   }
   return null;
 }
@@ -146,17 +159,19 @@ export function findScrollTarget(path: LayoutNode[]): LayoutNode | null {
  * @param path - Path from root to current node.
  * @returns Array of handlers ordered from deepest to root.
  */
-export function collectKeyPressHandlers(
-  path: LayoutNode[],
-): { layoutNode: LayoutNode; handler: (key: string) => boolean | void }[] {
+export function collectKeyPressHandlers(path: LayoutNode[]): {
+  layoutNode: LayoutNode;
+  handler: NonNullable<ContainerProps["onKeyPress"]>;
+}[] {
   const handlers: {
     layoutNode: LayoutNode;
-    handler: (key: string) => boolean | void;
+    handler: NonNullable<ContainerProps["onKeyPress"]>;
   }[] = [];
   for (let i = path.length - 1; i >= 0; i--) {
-    const props = getProps(path[i]!);
+    const layoutNode = requiredAt(path, i, "hit path node");
+    const props = getProps(layoutNode);
     if (props?.onKeyPress) {
-      handlers.push({ layoutNode: path[i]!, handler: props.onKeyPress });
+      handlers.push({ layoutNode, handler: props.onKeyPress });
     }
   }
   return handlers;