rovecode 0.4.1 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rovecode",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "license": "AGPL-3.0-only",
   "author": "9Code Labs",
   "repository": {

package/src/sextant/boot.ts

@@ -0,0 +1,74 @@
+/** The boot gate (#46): the cockpit stays in its reveal animation until every panel the layout asked
+ *  for has painted CLEAN at least once — then `ready` flips and the surface accepts submits. A panel
+ *  that keeps faulting can never lock the UI: the cap forces readiness and the toast already names the
+ *  fault (frame.ts safe()). Future surfaces/versions get the same discipline by constructing one of
+ *  these and asking it, instead of re-rolling boot timing by hand.
+ *
+ *  Wiring: the frame loop owns the gate → renderFrame's per-panel guard reports clean/fault into it →
+ *  the loop holds FRAME_MS pacing and swallows submits until `ready`. */
+
+import { REVEAL_STEP_MS } from "./frame.ts";
+
+/** panels the gate knows about; the loop re-declares the live set every frame (layout-dependent) */
+export const BOOT_PANELS = ["files", "code", "messages", "plan", "usage", "pet"] as const;
+
+/** the animation itself: six reveal steps at 90 ms + a beat to settle */
+export const BOOT_ANIM_MS = REVEAL_STEP_MS * 6;
+
+/** a faulting panel may delay readiness at most this long — then the gate opens anyway */
+export const BOOT_CAP_MS = 3000;
+
+export interface BootGate {
+  /** true once every live panel painted clean (and the animation finished) or the cap elapsed */
+  readonly ready: boolean;
+  /** 0..1 — animation progress for loaders; faults do not stall it (the cap guarantees 1) */
+  readonly progress: number;
+  /** names of live panels that have not painted clean yet */
+  readonly pending: readonly string[];
+}
+
+export interface Boot {
+  readonly gate: BootGate;
+  /** frame loop → gate: the clock, and which panels this layout actually shows */
+  tick(now: number, livePanels: readonly string[]): void;
+  /** renderFrame safe() → gate: a panel painted clean / threw */
+  clean(panel: string): void;
+  fault(panel: string): void;
+}
+
+export function createBoot(bootAt: number): Boot {
+  const cleanPanels = new Set<string>();
+  const faulted = new Set<string>();
+  let live: readonly string[] = [...BOOT_PANELS];
+  let now = bootAt;
+
+  const gate: BootGate = {
+    get ready(): boolean {
+      const animDone = now - bootAt >= BOOT_ANIM_MS;
+      if (now - bootAt >= BOOT_CAP_MS) return true;
+      if (!animDone) return false;
+      return live.every((p) => cleanPanels.has(p) || faulted.has(p));
+    },
+    get progress(): number {
+      return Math.min(1, (now - bootAt) / BOOT_ANIM_MS);
+    },
+    get pending(): readonly string[] {
+      return live.filter((p) => !cleanPanels.has(p) && !faulted.has(p));
+    },
+  };
+
+  return {
+    gate,
+    tick(n: number, livePanels: readonly string[]): void {
+      now = n;
+      live = livePanels;
+    },
+    clean(panel: string): void {
+      cleanPanels.add(panel);
+      faulted.delete(panel);
+    },
+    fault(panel: string): void {
+      faulted.add(panel); // faults count toward readiness — the cap + toast carry the story
+    },
+  };
+}

package/src/sextant/frame.ts

@@ -22,6 +22,9 @@ export interface FrameDeps {
   /** overrides per panel; a missing painter draws an empty titled box */
   painters?: Partial<Painters>;
   layoutOpts?: LayoutOptions;
+  /** #46 boot gate: the per-panel guard reports clean/fault into it so the surface can hold its
+   *  reveal until every live panel has painted once. Omit = no gating (tests, dumps). */
+  boot?: import("./boot.ts").Boot;
 }
 
 /** boot reveal (app.js render()): panels appear in 90 ms steps after bootAt */
@@ -76,9 +79,23 @@ export function renderFrame(scr: ScreenLike, s: SextantState, theme: Theme, now:
   // A painter that throws must never take the rest of the frame down with it — a blank panel with a
   // toast beats a half-drawn cockpit. The first failure per panel is recorded on the state so the
   // loop can surface it once instead of spamming every frame.
+  // the panels this layout actually shows — the gate waits on exactly these, no more
+  deps.boot?.tick(now, [
+    ...(L.files ? ["files"] : []),
+    "code",
+    "messages",
+    ...(L.plan ? ["plan"] : []),
+    ...(L.usage ? ["usage"] : []),
+    ...(L.pet ? ["pet"] : []),
+  ]);
   const safe = (name: keyof Painters, fn: () => void): void => {
-    try { fn(); if (s.painterError === name || s.painterError?.startsWith(name + ":")) s.painterError = undefined; } catch (e) {
+    try {
+      fn();
+      if (s.painterError === name || s.painterError?.startsWith(name + ":")) s.painterError = undefined;
+      deps.boot?.clean(name);
+    } catch (e) {
       const msg = `${name}: ${e instanceof Error ? e.message : String(e)}`;
+      deps.boot?.fault(name);
       if (s.painterError !== msg) {
         s.painterError = msg;
         pushToast(s, `panel fault — ${msg}`, now, "error");

package/src/sextant/sextant-frame-loop.ts

@@ -12,6 +12,7 @@ import { drawMessages, messagesScroll, promptCursor } from "./draw-messages.ts";
 import { drawPet, SWAY_MS } from "./draw-pet.ts";
 import { fuzzy, tokenize } from "./engine.ts";
 import { renderFrame } from "./frame.ts";
+import { createBoot, type Boot } from "./boot.ts";
 import { parseInput } from "./input.ts";
 import { handleInput, type KeyCtx } from "./keys.ts";
 import { layout as layoutFn } from "./layout.ts";
@@ -95,6 +96,11 @@ export class FrameLoop {
   private rows: TreeRow[] = [];
   /** frames painted (tests: "a render happened") */
   frames = 0;
+  /** #46: the cockpit opens for submits once every live panel painted clean (boot.ts) */
+  private boot: Boot | null = null;
+  private bootToastAt = 0;
+  /** Enter presses caught while the boot gate was closed; replayed in order when it opens */
+  private bootQueue: InputEvent[] = [];
 
   constructor(private readonly d: FrameLoopDeps) {
     const { cols, rows } = d.io.size();
@@ -191,6 +197,16 @@ export class FrameLoop {
   dispatch(ev: InputEvent): void {
     const now = this.d.clock();
     this.markDirty(); // and wake: the tick that follows this key (onTick: file reload) must come in one frame, not one sleep
+    // #46: while the boot reveal runs, Enter would submit into a half-loaded surface — QUEUE it and
+    // replay once the gate opens (typing still buffers into the editor live). Nothing is ever lost.
+    if (this.boot && !this.boot.gate.ready && ev.type === "key" && ev.name === "enter") {
+      this.bootQueue.push(ev);
+      if (now - this.bootToastAt > 2000) {
+        this.bootToastAt = now;
+        pushToast(this.d.state, "cockpit is loading — your input is queued", now, "info");
+      }
+      return;
+    }
     if (this.d.beforeInput?.(ev, now)) return;
     const kc = this.d.keyCtx();
     const ctx: KeyCtx = { layout: this.L, hooks: kc.hooks, local: kc.local, hits: this.hits, rows: this.rows, fuzzy, drag: this.drag };
@@ -202,6 +218,8 @@ export class FrameLoop {
    *  storms and effects, the boot reveal. These hold the loop at FRAME_MS. */
   moving(now: number): boolean {
     const s = this.d.state, P = this.d.pet.state;
+    // #46: the gate holds the loop hot until the surface is truly ready (not just REVEAL_MS elapsed)
+    if (this.boot && !this.boot.gate.ready) return true;
     return s.running || s.card !== null || s.files.touched.size > 0 || now - s.bootAt < REVEAL_MS
       || now < P.stormUntil || P.fx.some((f) => f.until > now);
   }
@@ -264,9 +282,11 @@ export class FrameLoop {
     scr.begin(theme.bg);
     this.rows = treeRows(s, now); // the same (version, now) key drawFiles uses → one build per frame (model.ts cache)
     const hits: HitZone[] = [];
+    if (!this.boot) this.boot = createBoot(s.bootAt);
     const L = renderFrame(scr, s, theme, now, {
       layout: layoutFn,
       layoutOpts: this.layoutOpts(),
+      boot: this.boot,
       painters: {
         code: (g, r, st, th, t) => drawCode(g, r, st, th, t, { tokenize }),
         messages: drawMessages,
@@ -274,6 +294,12 @@ export class FrameLoop {
       },
     });
     this.L = L;
+    // the gate just opened → flush queued submits through the normal path
+    if (this.boot.gate.ready && this.bootQueue.length > 0) {
+      const queued = this.bootQueue;
+      this.bootQueue = [];
+      for (const ev of queued) this.dispatch(ev);
+    }
     if (L.pet) hits.push({ rect: L.pet, onClick: () => pet.poke(this.d.clock()) });
     // the frame's border rows (frame-hits.ts): unread badge → notices, theme name → next theme, effort → /effort
     for (const z of frameHits(L.frame, s, theme, now)) hits.push(z);