refactor(core): split createApp orchestration controllers

packages/core/src/app/__tests__/dirtyPlan.controller.test.ts

@@ -0,0 +1,46 @@
+import { assert, test } from "@rezi-ui/testkit";
+import {
+  DIRTY_LAYOUT,
+  DIRTY_RENDER,
+  DIRTY_VIEW,
+  buildWidgetRenderPlan,
+  createDirtyTracker,
+} from "../createApp/dirtyPlan.js";
+
+test("dirty tracker keeps dirty bits when a newer version supersedes the snapshot", () => {
+  const tracker = createDirtyTracker();
+
+  tracker.markDirty(DIRTY_VIEW);
+  const staleSnapshot = tracker.snapshotVersions();
+  tracker.markDirty(DIRTY_VIEW);
+  tracker.clearConsumedFlags(DIRTY_VIEW, staleSnapshot);
+
+  assert.equal(tracker.getFlags() & DIRTY_VIEW, DIRTY_VIEW);
+});
+
+test("dirty tracker clears only the matching dirty bits", () => {
+  const tracker = createDirtyTracker();
+
+  tracker.markDirty(DIRTY_VIEW | DIRTY_LAYOUT);
+  const snapshot = tracker.snapshotVersions();
+  tracker.markDirty(DIRTY_RENDER);
+  tracker.clearConsumedFlags(DIRTY_VIEW | DIRTY_LAYOUT, snapshot);
+
+  assert.equal(tracker.getFlags(), DIRTY_RENDER);
+});
+
+test("widget render plan derives commit/layout intent from dirty flags", () => {
+  assert.deepEqual(buildWidgetRenderPlan(DIRTY_VIEW, 12), {
+    commit: true,
+    layout: false,
+    checkLayoutStability: true,
+    nowMs: 12,
+  });
+
+  assert.deepEqual(buildWidgetRenderPlan(DIRTY_LAYOUT | DIRTY_RENDER, 27), {
+    commit: false,
+    layout: true,
+    checkLayoutStability: false,
+    nowMs: 27,
+  });
+});

packages/core/src/app/__tests__/focusDispatcher.controller.test.ts

@@ -0,0 +1,59 @@
+import { assert, test } from "@rezi-ui/testkit";
+import { createFocusDispatcher } from "../createApp/focusDispatcher.js";
+
+test("focus dispatcher emits only when the focused id changes", () => {
+  let focusedId: string | null = null;
+  const seen: Array<string | null> = [];
+  const dispatcher = createFocusDispatcher({
+    getFocusedId: () => focusedId,
+    getFocusInfo: () => ({ id: focusedId }),
+    initialFocusedId: null,
+    onHandlerError: () => {
+      throw new Error("unexpected handler error");
+    },
+  });
+
+  const unsubscribe = dispatcher.register((info) => {
+    seen.push(info.id);
+  });
+
+  assert.equal(dispatcher.emitIfChanged(), true);
+  assert.deepEqual(seen, []);
+
+  focusedId = "first";
+  assert.equal(dispatcher.emitIfChanged(), true);
+  assert.deepEqual(seen, ["first"]);
+
+  assert.equal(dispatcher.emitIfChanged(), true);
+  assert.deepEqual(seen, ["first"]);
+
+  unsubscribe();
+  focusedId = "second";
+  assert.equal(dispatcher.emitIfChanged(), true);
+  assert.deepEqual(seen, ["first"]);
+});
+
+test("focus dispatcher reports handler failures and stops further fan-out", () => {
+  const focusedId: string | null = "field";
+  const errors: unknown[] = [];
+  const seen: string[] = [];
+  const dispatcher = createFocusDispatcher({
+    getFocusedId: () => focusedId,
+    getFocusInfo: () => ({ id: focusedId ?? "none" }),
+    initialFocusedId: null,
+    onHandlerError: (error: unknown) => {
+      errors.push(error);
+    },
+  });
+
+  dispatcher.register(() => {
+    throw new Error("boom");
+  });
+  dispatcher.register((info) => {
+    seen.push(info.id);
+  });
+
+  assert.equal(dispatcher.emitIfChanged(), false);
+  assert.equal(errors.length, 1);
+  assert.deepEqual(seen, []);
+});

packages/core/src/app/__tests__/resilience.test.ts

@@ -426,6 +426,43 @@ test("app.run() resolves when app transitions to Faulted", async () => {
   }
 });
 
+test("app.run() detaches signal handlers when start throws synchronously", async () => {
+  class ThrowingStartBackend extends StubBackend {
+    override start(): Promise<void> {
+      this.startCalls++;
+      this.callLog.push("start");
+      throw new Error("start boom");
+    }
+  }
+
+  const backend = new ThrowingStartBackend();
+  const app = createApp({ backend, initialState: 0 });
+  app.draw((g) => g.clear());
+
+  const listeners = new Map<string, Set<(...args: unknown[]) => void>>();
+  const fakeProcess = {
+    on: (signal: string, handler: (...args: unknown[]) => void) => {
+      const set = listeners.get(signal) ?? new Set<(...args: unknown[]) => void>();
+      set.add(handler);
+      listeners.set(signal, set);
+    },
+    off: (signal: string, handler: (...args: unknown[]) => void) => {
+      listeners.get(signal)?.delete(handler);
+    },
+  };
+  const g = globalThis as { process?: unknown };
+  const prevProcess = g.process;
+  g.process = fakeProcess;
+  try {
+    assert.throws(() => app.run(), /backend.start threw: Error: start boom/);
+    assert.equal(listeners.get("SIGINT")?.size ?? 0, 0);
+    assert.equal(listeners.get("SIGTERM")?.size ?? 0, 0);
+    assert.equal(listeners.get("SIGHUP")?.size ?? 0, 0);
+  } finally {
+    g.process = prevProcess;
+  }
+});
+
 test("nested errorBoundary retry state remains isolated", async () => {
   const backend = new StubBackend();
   const app = createApp({

packages/core/src/app/__tests__/runSignals.controller.test.ts

@@ -0,0 +1,107 @@
+import { assert, test } from "@rezi-ui/testkit";
+import { createRunSignalController, readProcessLike } from "../createApp/runSignals.js";
+
+test("run signal controller detaches listeners and resolves after signal handling", async () => {
+  const listeners = new Map<string, Set<(...args: unknown[]) => void>>();
+  const proc = {
+    on: (signal: string, handler: (...args: unknown[]) => void) => {
+      const set = listeners.get(signal) ?? new Set<(...args: unknown[]) => void>();
+      set.add(handler);
+      listeners.set(signal, set);
+    },
+    off: (signal: string, handler: (...args: unknown[]) => void) => {
+      listeners.get(signal)?.delete(handler);
+    },
+  };
+  const events: string[] = [];
+
+  const controller = createRunSignalController({
+    onDetached: () => {
+      events.push("detached");
+    },
+    onSignal: async () => {
+      events.push("signal");
+    },
+    processLike: proc,
+    signals: ["SIGINT", "SIGTERM"],
+  });
+
+  assert.equal(controller.canRegisterSignals, true);
+  assert.equal(listeners.get("SIGINT")?.size ?? 0, 1);
+  assert.equal(listeners.get("SIGTERM")?.size ?? 0, 1);
+
+  for (const handler of listeners.get("SIGINT") ?? []) {
+    handler("SIGINT");
+  }
+  await controller.promise;
+
+  assert.deepEqual(events, ["detached", "signal"]);
+  assert.equal(listeners.get("SIGINT")?.size ?? 0, 0);
+  assert.equal(listeners.get("SIGTERM")?.size ?? 0, 0);
+});
+
+test("run signal controller settles cleanly without process hooks", async () => {
+  let detached = 0;
+  const controller = createRunSignalController({
+    onDetached: () => {
+      detached++;
+    },
+    onSignal: () => {
+      throw new Error("signal handler should not run without listeners");
+    },
+    processLike: null,
+  });
+
+  assert.equal(controller.canRegisterSignals, false);
+  controller.settle();
+  await controller.promise;
+  controller.detach();
+
+  assert.equal(detached, 1);
+});
+
+test("run signal controller resolves when onSignal throws synchronously", async () => {
+  const listeners = new Map<string, Set<(...args: unknown[]) => void>>();
+  const proc = {
+    on: (signal: string, handler: (...args: unknown[]) => void) => {
+      const set = listeners.get(signal) ?? new Set<(...args: unknown[]) => void>();
+      set.add(handler);
+      listeners.set(signal, set);
+    },
+    off: (signal: string, handler: (...args: unknown[]) => void) => {
+      listeners.get(signal)?.delete(handler);
+    },
+  };
+  const events: string[] = [];
+
+  const controller = createRunSignalController({
+    onDetached: () => {
+      events.push("detached");
+    },
+    onSignal: () => {
+      events.push("signal");
+      throw new Error("boom");
+    },
+    processLike: proc,
+    signals: ["SIGINT"],
+  });
+
+  for (const handler of listeners.get("SIGINT") ?? []) {
+    handler("SIGINT");
+  }
+  await controller.promise;
+
+  assert.deepEqual(events, ["detached", "signal"]);
+  assert.equal(listeners.get("SIGINT")?.size ?? 0, 0);
+});
+
+test("readProcessLike ignores non-object process globals", () => {
+  const g = globalThis as { process?: unknown };
+  const prevProcess = g.process;
+  try {
+    g.process = 123;
+    assert.equal(readProcessLike(), null);
+  } finally {
+    g.process = prevProcess;
+  }
+});

packages/core/src/app/__tests__/topLevelViewError.test.ts

@@ -0,0 +1,27 @@
+import { assert, test } from "@rezi-ui/testkit";
+import { ZR_MOD_CTRL, ZR_MOD_SHIFT } from "../../keybindings/keyCodes.js";
+import { isUnhandledCtrlCKeyEvent } from "../createApp/topLevelViewError.js";
+
+test("isUnhandledCtrlCKeyEvent matches plain Ctrl+C only", () => {
+  assert.equal(
+    isUnhandledCtrlCKeyEvent({
+      kind: "key",
+      timeMs: 1,
+      key: 67,
+      mods: ZR_MOD_CTRL,
+      action: "down",
+    }),
+    true,
+  );
+
+  assert.equal(
+    isUnhandledCtrlCKeyEvent({
+      kind: "key",
+      timeMs: 1,
+      key: 67,
+      mods: ZR_MOD_CTRL | ZR_MOD_SHIFT,
+      action: "down",
+    }),
+    false,
+  );
+});