tickmarkr 1.81.0 → 1.84.0

package/dist/tui/cockpit/run-cockpit.d.ts

@@ -1,9 +1,18 @@
 import { type ReactElement } from "react";
-import type { RunCockpitData } from "./derive.js";
-import { type RunInteractionState } from "./keys.js";
+import { type JournalRow } from "./components.js";
+import { type RunCockpitData } from "./derive.js";
+import { type KeybarEntry, type RunInteractionState, type RunKeyProjection } from "./keys.js";
+import { type RunViewId } from "./views.js";
+import { type FramePlan, type FrameRegion, type FrameState, type FrameCockpitLayout, type FrameView, type MeasuredSize, type PlannedFrame } from "./layout.js";
 export { deriveRunCockpitData } from "./derive.js";
 export type { RunCockpitData } from "./derive.js";
 export { PANEL_CHROME_ROWS } from "./components.js";
+/**
+ * The width focus and key routing resolve at, from a measured width — the form
+ * used before a plan exists. Once one does, `plannedKeyColumns` (pointer.ts)
+ * reads the same answer off the bands the plan actually drew.
+ */
+export declare function runKeyColumns(columns: number): number;
 /**
  * How many rows one line of body text occupies once the renderer wraps it into
  * `columns`. This mirrors the renderer's own word wrap — greedy, and breaking a
@@ -13,14 +22,92 @@ export { PANEL_CHROME_ROWS } from "./components.js";
 export declare function wrappedRows(text: string, columns: number): number;
 /** The rows a bordered panel occupies when its body wraps into `columns`. */
 export declare function panelRows(lines: readonly string[], columns: number): number;
-export declare function RunCockpitFrame({ data, columns, rows, interaction, }: {
+/**
+ * The selectable rows owned by one view. The overview's journal is a passive
+ * tail, not its item collection; tasks, gates and fleet remain honestly empty
+ * until their dedicated derivations land. Journal rows keep the source-record
+ * identities assigned by the production journal derivation.
+ */
+export declare function deriveRunViewRows(data: RunCockpitData, viewId: RunViewId, filterQuery?: string): readonly JournalRow[];
+/**
+ * The identities the body's rows carry in the order the body draws them — the
+ * same window `SizedJournalPanel` paints, so a hit on a body row resolves to
+ * the row an operator is looking at rather than to a position in a collection
+ * the frame scrolled past. A body that draws no selectable list (the overview,
+ * the journal tail, an open detail, the help overlay, the decisions tab) owns
+ * no rows here.
+ */
+export declare function drawnRunViewRowIds(data: RunCockpitData, interaction: RunInteractionState, bodyRows: number): readonly string[];
+/** What each drawn region draws: the resolved budgets its panels consume. */
+export type RegionContent = {
+    /**
+     * Where the body band's item rows are drawn and how many there are: the
+     * plan's own `items` region, carried here unmodified. This file subtracts no
+     * chrome to obtain it — planFrame plans it, the paint draws its list at it,
+     * and hit resolution (pointer.ts) reads the same region off the same plan.
+     */
+    readonly items: FrameRegion;
+    readonly journal: number;
+    readonly sideRails: boolean;
+    readonly stats: FrameCockpitLayout["stats"]["mode"] | "none";
+    readonly progressBar: boolean;
+    readonly progressCaption: boolean;
+    readonly approvedProgress: boolean;
+};
+export type PlannedRunCockpitFrame = {
+    readonly plan: FramePlan;
+    readonly columns: number;
+    readonly rows?: number;
+    /** What fills the drawn regions; absent on the unsized legacy surface. */
+    readonly content?: RegionContent;
+    /** The inputs planFrame planned from, so the guard can re-plan and refuse
+     * a span that moved after planning. */
+    readonly planning?: {
+        readonly size: MeasuredSize;
+        readonly view: FrameView;
+        readonly state: FrameState;
+    };
+    readonly interaction: RunInteractionState;
+    readonly keyEntries: readonly KeybarEntry[];
+};
+/** Resolve every draw-time input; the plan is planFrame's own return, consumed unmodified. */
+export declare function planRunCockpitFrame({ data, columns, rows, interaction, keyProjection, railColumns, }: {
     data: RunCockpitData;
     columns: number;
     rows?: number;
+    interaction?: RunInteractionState;
+    keyProjection?: RunKeyProjection;
     /**
-     * The run surface's interaction state. Omitted — or at its initial value —
-     * the frame is byte-identical to the pinned appearance; every transition a
-     * binding makes is drawn from it.
+     * The session's panel resize override, handed to planFrame as an input —
+     * never a bypass of it: the plan recomputes from the measured size plus this
+     * override and what is drawn is what the plan returns.
      */
+    railColumns?: number;
+}): PlannedRunCockpitFrame;
+/** The public surface always enters paint through one measured plan. */
+export declare function RunCockpitFrame({ data, columns, rows, interaction, keyProjection, onCommittedFrame, }: {
+    data: RunCockpitData;
+    columns: number;
+    rows?: number;
     interaction?: RunInteractionState;
+    keyProjection?: RunKeyProjection;
+    /**
+     * The renderer's commit seam: once this frame is committed, the exact plan
+     * and inputs it was drawn from are handed back, so an input surface can
+     * resolve its hits against the frame on the screen rather than against a
+     * plan it derived for itself. What nothing has painted yet has no geometry.
+     */
+    onCommittedFrame?: (planned: PlannedRunCockpitFrame, data: RunCockpitData) => void;
+}): ReactElement;
+/**
+ * Assert the plan's tiled extents, the bytes production paints, and — given
+ * the offsets read off the painted nodes — that every planned region was
+ * drawn where the plan puts it.
+ */
+export declare function assertFrameConformance(plan: PlannedFrame, drawnFrame: string, drawnRegions?: readonly FrameRegion[]): void;
+/** Production paint consumes only resolved plan inputs and fails closed with
+ * the same conformance assertion the acceptance suite runs. */
+export declare function RunCockpitFrameFromPlan({ data, plannedFrame, }: {
+    data: RunCockpitData;
+    plannedFrame: PlannedRunCockpitFrame;
 }): ReactElement;