@pygmalionjs/pygmalion 0.7.4 → 0.8.0

package/dist-lib/types/editor/scenarioCoverage.d.ts

@@ -1,5 +1,9 @@
-import type { RegistryPropValue } from './registry';
-import type { EditorStore } from './store';
+import type { InteractiveStates } from './interactiveStates.js';
+import type { RegistryPropValue } from './registry.js';
+import { type ScreenCards } from './screenCards.js';
+import { type ScreenLists } from './screenLists.js';
+import type { EditorStore } from './store.js';
+import type { ViewportPresets } from './viewportPresets.js';
 export type ScenarioCoverageClaim = {
     scenarioId: string;
     kind: 'frame';
@@ -85,9 +89,22 @@ export type ScenarioCoverageClaim = {
     kind: 'todo';
     reason: string;
 };
+/**
+ * What a diagnostic is about, as a value. `unknown-*` codes name a target
+ * the claim referenced that the context does not declare; `target` carries
+ * the referenced id so the host joins it back without parsing the message.
+ */
+export type ScenarioCoverageDiagnosticCode = 'unknown-scenario' | 'insufficient-reason' | 'unknown-screen' | 'not-a-state-group' | 'unknown-component' | 'unknown-prop' | 'unknown-value' | 'unknown-preset' | 'unknown-axis' | 'unknown-option' | 'base-option' | 'unknown-card' | 'unknown-slot' | 'unknown-list' | 'count-out-of-range' | 'duplicate-claim' | 'unclaimed';
 export interface ScenarioCoverageDiagnostic {
     severity: 'error' | 'warning';
+    code: ScenarioCoverageDiagnosticCode;
     scenarioId: string;
+    /** The claim's kind, when the diagnostic is about one claim. */
+    kind?: ScenarioCoverageClaim['kind'];
+    /** The screen the claim named, when it named one. */
+    screenId?: string;
+    /** The declaration the claim referenced and the context lacks. */
+    target?: string;
     message: string;
 }
 export interface ScenarioCoverageContext {
@@ -144,25 +161,40 @@ export interface ScenarioCoverageContext {
  * prop and value in the registry, preset among the host's declarations.
  */
 export declare function validateScenarioCoverage(claims: readonly ScenarioCoverageClaim[], context: ScenarioCoverageContext): ScenarioCoverageDiagnostic[];
+/**
+ * Counts by outcome, over the scenario inventory.
+ *
+ * A scenario is `covered` only when its one claim reproduces a reviewed
+ * state and validates clean. `behavior` and `todo` are visible in their own
+ * counts and never in `covered` — a todo is an admission, not a
+ * verification. A scenario whose claims carry an error (an unknown target,
+ * a duplicate) is `invalid`, again never `covered`. Claims naming scenarios
+ * the inventory lacks are listed under `unknownIds`; they are outside `total`.
+ */
+export interface ScenarioCoverageSummary {
+    total: number;
+    covered: number;
+    behavior: number;
+    todo: number;
+    invalid: number;
+    unclaimed: number;
+    behaviorIds: string[];
+    todoIds: string[];
+    invalidIds: string[];
+    unclaimedIds: string[];
+    unknownIds: string[];
+}
+export declare function summarizeScenarioCoverage(claims: readonly ScenarioCoverageClaim[], context: ScenarioCoverageContext): ScenarioCoverageSummary;
 export interface ApplyCoverageResult {
     status: 'applied' | 'pending-import' | 'failed';
     message?: string;
 }
-/**
- * Reproduces the reviewed state a claim describes, through the same actions
- * the panels use: frame/screen-state claims activate the frame (activation
- * reveals folded variants), viewport claims apply the preset resize, an
- * interactive-state claim flips the axis, card-slot and list-length claims
- * edit the imported tree, and component-state claims flip the registry prop
- * on the imported instance.
- */
-export declare function applyScenarioCoverageClaim(editor: EditorStore, claim: ScenarioCoverageClaim): ApplyCoverageResult;
-export declare function setScenarioCoverageClaims(claims: readonly ScenarioCoverageClaim[]): void;
-export declare function getScenarioCoverageClaims(): readonly ScenarioCoverageClaim[];
-/** Claims verified on one screen — the right panel's coverage section. */
-export declare function coverageClaimsForScreen(screenId: string): readonly ScenarioCoverageClaim[];
-/**
- * Scenario ids a component prop control demonstrates on the given screen —
- * rendered as chips beside the control so the panel shows WHY it exists.
- */
-export declare function coverageBadgesForComponentProp(screenId: string, componentName: string, prop: string): readonly string[];
+/** One editor's scenario coverage claims, validated against its other declarations. */
+export declare function createScenarioCoverage(deps: Pick<InteractiveStates, 'getInteractiveStates'> & Pick<ScreenCards, 'getScreenCards'> & Pick<ScreenLists, 'getScreenLists'> & Pick<ViewportPresets, 'getViewportPresets'>): {
+    applyScenarioCoverageClaim: (editor: EditorStore, claim: ScenarioCoverageClaim) => ApplyCoverageResult;
+    setScenarioCoverageClaims: (claims: readonly ScenarioCoverageClaim[]) => void;
+    getScenarioCoverageClaims: () => readonly ScenarioCoverageClaim[];
+    coverageClaimsForScreen: (screenId: string) => readonly ScenarioCoverageClaim[];
+    coverageBadgesForComponentProp: (screenId: string, componentName: string, prop: string) => readonly string[];
+};
+export type ScenarioCoverage = ReturnType<typeof createScenarioCoverage>;

package/dist-lib/types/editor/screenCards.d.ts

@@ -1,7 +1,7 @@
-import { type NodeSelector } from './nodeSelector';
-import type { ComponentBranch } from './screenDimensions';
-import type { RegistryPropValue } from './registry';
-import type { NodeModel, PageModel } from './store';
+import { type NodeSelector } from './nodeSelector.js';
+import type { ComponentBranch } from './screenDimensions.js';
+import type { RegistryPropValue } from './registry.js';
+import type { NodeModel, PageModel } from './store.js';
 export interface CardBadgeOption {
     id: string;
     /** Panel chip text, and the witness looked for in the product source. */
@@ -97,5 +97,9 @@ export declare function findSlotPlacement(card: NodeModel, slot: CardSlotDef): {
 } | null;
 /** Insertion point for an anchored badge, or the end of the slot. */
 export declare function badgeInsertIndex(container: NodeModel, option: CardBadgeOption): number;
-export declare function setScreenCards(defs: readonly ScreenCardDef[]): void;
-export declare function getScreenCards(): readonly ScreenCardDef[];
+/** One editor's declared screen cards. */
+export declare function createScreenCards(): {
+    setScreenCards: (defs: readonly ScreenCardDef[]) => void;
+    getScreenCards: () => readonly ScreenCardDef[];
+};
+export type ScreenCards = ReturnType<typeof createScreenCards>;

package/dist-lib/types/editor/screenDimensions.d.ts

@@ -1,6 +1,6 @@
-import { type NodeSelector } from './nodeSelector';
-import type { RegistryPropValue } from './registry';
-import type { NodeModel, PageModel } from './store';
+import { type NodeSelector } from './nodeSelector.js';
+import type { RegistryPropValue } from './registry.js';
+import type { NodeModel, PageModel } from './store.js';
 export interface ScreenDimensionOption {
     label: string;
     props: Readonly<Record<string, RegistryPropValue>>;
@@ -59,5 +59,9 @@ export declare function findDimensionNode(page: PageModel, dimension: ScreenDime
 export declare function dimensionPropsForValue(dimension: ScreenDimensionDef, value: string): Readonly<Record<string, RegistryPropValue>> | null;
 /** Current value of a dimension on a node, or null for the captured state. */
 export declare function dimensionValueOfNode(dimension: ScreenDimensionDef, node: NodeModel): string | null;
-export declare function setScreenDimensions(dimensions: readonly ScreenDimensionDef[]): void;
-export declare function getScreenDimensions(): readonly ScreenDimensionDef[];
+/** One editor's declared screen dimensions. */
+export declare function createScreenDimensions(): {
+    setScreenDimensions: (dimensions: readonly ScreenDimensionDef[]) => void;
+    getScreenDimensions: () => readonly ScreenDimensionDef[];
+};
+export type ScreenDimensions = ReturnType<typeof createScreenDimensions>;

package/dist-lib/types/editor/screenFlows.d.ts

@@ -1,4 +1,4 @@
-import type { DesignScreenInteraction, StoryboardEnvironment } from './designImport';
+import type { DesignScreenInteraction, StoryboardEnvironment } from './designImport.js';
 export interface ScreenFlowWaypoint {
     /** Catalog id of the screen this waypoint materializes (importPageId). */
     screenId: string;
@@ -43,7 +43,10 @@ export declare function validateScreenFlows(paths: readonly ScreenFlowPath[], sc
 export declare function orderFlowPaths<T extends {
     waypoints: readonly ScreenFlowWaypoint[];
 }>(paths: readonly T[], priorityScreenIds: ReadonlySet<string>): T[];
-export declare function setScreenFlows(paths: readonly ScreenFlowPath[]): void;
-export declare function getScreenFlows(): readonly ScreenFlowPath[];
-/** The path that delivers a screen, or null when no flow claims it. */
-export declare function flowPathForScreen(screenId: string): ScreenFlowPath | null;
+/** One editor's declared screen flows. */
+export declare function createScreenFlows(): {
+    setScreenFlows: (paths: readonly ScreenFlowPath[]) => void;
+    getScreenFlows: () => readonly ScreenFlowPath[];
+    flowPathForScreen: (screenId: string) => ScreenFlowPath | null;
+};
+export type ScreenFlows = ReturnType<typeof createScreenFlows>;

package/dist-lib/types/editor/screenInteractions.d.ts

@@ -1,4 +1,12 @@
-import type { DesignScreenInteraction, DesignScreenInteractionRunOptions, DesignScreenInteractionReport } from './designImport';
+import type { DesignScreenInteraction, DesignScreenInteractionRunOptions, DesignScreenInteractionReport } from './designImport.js';
+/**
+ * The pause after an action under the `live` settle policy: enough for the
+ * application's handlers and one paint, in place of the authored settle a
+ * capture would wait for.
+ */
+export declare const LIVE_ACTION_SETTLE_MS = 80;
+/** The most a timer-only wait keeps under the `live` settle policy. */
+export declare const LIVE_TIMER_WAIT_CAP_MS = 250;
 export declare function settleScreen(iframe: HTMLIFrameElement, settleMs: number): Promise<void>;
 export declare function elementVisible(element: Element): boolean;
 export declare function runScreenInteractions(iframe: HTMLIFrameElement, interactions: readonly DesignScreenInteraction[], options?: DesignScreenInteractionRunOptions): Promise<DesignScreenInteractionReport>;

package/dist-lib/types/editor/screenLists.d.ts

@@ -1,5 +1,5 @@
-import { type NodeSelector } from './nodeSelector';
-import type { NodeModel, PageModel } from './store';
+import { type NodeSelector } from './nodeSelector.js';
+import type { NodeModel, PageModel } from './store.js';
 export interface ScreenListDef {
     id: string;
     label: string;
@@ -36,5 +36,9 @@ export declare function rowAdvance(parent: NodeModel, item: NodeModel): number;
  * gains a scrollbar exactly while its content overflows.
  */
 export declare function applyListHeightDelta(root: NodeModel, itemParent: NodeModel, delta: number): void;
-export declare function setScreenLists(defs: readonly ScreenListDef[]): void;
-export declare function getScreenLists(): readonly ScreenListDef[];
+/** One editor's declared screen lists. */
+export declare function createScreenLists(): {
+    setScreenLists: (defs: readonly ScreenListDef[]) => void;
+    getScreenLists: () => readonly ScreenListDef[];
+};
+export type ScreenLists = ReturnType<typeof createScreenLists>;

package/dist-lib/types/editor/screenStateGroups.d.ts

@@ -29,7 +29,7 @@ export interface ScreenStateGroupDiagnostic {
  * Validates every declared screen-state group among the given pages. Only
  * pages that actually declare membership participate: a page without a
  * scenario has made no claim, and a page without a route is not a captured
- * screen (mirrors the FrameScreenStates gate). Diagnostics come back with
+ * screen (mirrors the variant panel's gate). Diagnostics come back with
  * warnings before infos, then ordered by scenario, so the first entry is
  * always the most actionable one.
  */

package/dist-lib/types/editor/sectionHeaders.d.ts

@@ -1,5 +1,5 @@
-import { lightenHex } from './bannerStyle';
-import type { PageModel } from './store';
+import { lightenHex } from './bannerStyle.js';
+import type { PageModel } from './store.js';
 export { lightenHex };
 /** Host-declared description of one canvas section. */
 export interface SectionHeaderDef {
@@ -111,7 +111,11 @@ export declare const SECTION_HEADER_RESERVE = 176;
  * measure a reader can take in at once and stops.
  */
 export declare const SECTION_HEADER_MAX_WIDTH = 1280;
-export declare function setSectionHeaders(defs: readonly SectionHeaderDef[], labels?: SectionHeaderLabels): void;
-export declare function getSectionHeaders(): readonly SectionHeaderDef[];
-export declare function getSectionHeaderLabels(): SectionHeaderLabels | undefined;
-export declare function sectionHeaderFor(section: string): SectionHeaderDef | null;
+/** One editor's declared section headers and their labels. */
+export declare function createSectionHeaders(): {
+    setSectionHeaders: (defs: readonly SectionHeaderDef[], labels?: SectionHeaderLabels) => void;
+    getSectionHeaders: () => readonly SectionHeaderDef[];
+    getSectionHeaderLabels: () => SectionHeaderLabels | undefined;
+    sectionHeaderFor: (section: string) => SectionHeaderDef | null;
+};
+export type SectionHeaders = ReturnType<typeof createSectionHeaders>;

package/dist-lib/types/editor/sessionPresets.d.ts

@@ -1,4 +1,5 @@
-import type { StoryboardEnvironment } from './designImport';
+import type { StoryboardEnvironment } from './designImport.js';
+import type { StoryboardEnvironmentState } from './storyboardEnvironment.js';
 /**
  * One runtime the whole catalog can be seen under.
  *
@@ -31,34 +32,13 @@ export interface SessionPresetDef {
     /** Tooltip text. */
     description?: string;
 }
-/**
- * Declares the preset list. A malformed entry throws here rather than producing
- * a button that silently captures the catalog under nothing — the host
- * configures this once at mount.
- */
-export declare function setSessionPresets(next: readonly SessionPresetDef[]): void;
-export declare function getSessionPresets(): SessionPresetDef[];
-export declare function getSelectedSessionPreset(): number | null;
-/**
- * Puts the catalog under one preset, or back under the product's default.
- *
- * The baseline is what every frame's identity is derived from, so changing it
- * is what makes the catalog re-resolve rather than keep showing what was
- * captured under the previous runtime — setting it already retires the frames
- * held from the runtime before.
- */
-export declare function selectSessionPreset(index: number | null): void;
-export declare function subscribeSessionPresets(listener: () => void): () => void;
-/**
- * Whether a screen belongs in the runtime currently selected.
- *
- * A screen that names no runtime exists in all of them — most do, and a product
- * that ships one build should not have to say so 75 times. Naming runtimes is
- * for the screens that only exist in some: an EMR-linked build has surfaces the
- * standalone one cannot reach at all, and showing them side by side reads as a
- * catalog of screens that do not exist.
- *
- * With no preset selected everything shows, because "the product's own default"
- * is not a claim about which runtime is running.
- */
-export declare function isInSelectedSessionPreset(runtimes: readonly string[] | undefined): boolean;
+/** One editor's declared session presets and the selected one, which sets the baseline environment. */
+export declare function createSessionPresets(deps: Pick<StoryboardEnvironmentState, 'setStoryboardBaselineEnvironment'>): {
+    setSessionPresets: (next: readonly SessionPresetDef[]) => void;
+    getSessionPresets: () => SessionPresetDef[];
+    getSelectedSessionPreset: () => number | null;
+    selectSessionPreset: (index: number | null) => void;
+    subscribeSessionPresets: (listener: () => void) => () => void;
+    isInSelectedSessionPreset: (runtimes: readonly string[] | undefined) => boolean;
+};
+export type SessionPresets = ReturnType<typeof createSessionPresets>;

package/dist-lib/types/editor/shadowPreview.d.ts

@@ -1,5 +1,4 @@
-import type { DesignScreenInteraction } from './designImport';
-import type { PreviewMotionMode } from './automaticMotion';
+import type { DesignScreenInteraction } from './designImport.js';
 export interface PreparedShadowPreview {
     bodyHtml: string;
     sharedCssText: string;
@@ -43,19 +42,17 @@ export interface ShadowPreviewHandle {
     refreshLinkedHeldPseudoCss(): void;
     /** Reapplies deterministic scroll endpoints after frozen layout settles. */
     restoreScrollInteractions(): readonly string[];
-    updateMotion(state: ShadowPreviewMotionState): void;
-    readMotionProgress(): number | null;
+    /**
+     * Holds every animation at its capture baseline: finite motion at its end,
+     * repeating motion at the start of its cycle. The frozen preview is a still
+     * image; a running screen is what a live frame is for.
+     */
+    settleMotion(): void;
     updateBodyHtml(bodyHtml: string, baseUrl?: string): void;
     updateOverrideCss(cssText: string): void;
     updateSharedCss(cssText: string): void;
     teardown(): void;
 }
-export interface ShadowPreviewMotionState {
-    mode: PreviewMotionMode;
-    progress: number;
-    seekRevision: number;
-    target?: Pick<import('./automaticMotion').AutomaticMotionTarget, 'selector' | 'index'>;
-}
 export interface ShadowDomMutation {
     key: string;
     selector: string;

package/dist-lib/types/editor/sharedSource.d.ts

@@ -1,4 +1,5 @@
-import type { NodeModel, PageModel } from './store';
+import type { SourceEditScope } from './inspect.js';
+import type { NodeModel, PageModel } from './store.js';
 /**
  * The smallest unit that connects DOMs rendered multiple times from one source.
  * - Within the registry component, importPath is used as scope.
@@ -10,7 +11,8 @@ import type { NodeModel, PageModel } from './store';
 export declare const SHARED_SOURCE_PATCH_KEYS: readonly ["type", "widthMode", "width", "heightMode", "height", "gap", "padding", "justify", "alignItems", "fill", "radius", "borderWidth", "borderColor", "opacity", "fontSize", "fontWeight", "color", "textAlign", "hidden", "text", "componentName", "componentProps", "childrenText", "domAttributes", "domStyle"];
 export type SharedSourcePatchKey = (typeof SHARED_SOURCE_PATCH_KEYS)[number];
 export type SharedSourcePatch = Partial<Pick<NodeModel, SharedSourcePatchKey>>;
-export type SharedSourceEditScope = 'shared' | 'instance';
+/** Where an edit to a shared component's instance is written; one vocabulary with the source operations. */
+export type SharedSourceEditScope = SourceEditScope;
 export interface SharedSourceFrameSummary {
     id: string;
     name: string;

package/dist-lib/types/editor/sourceChangeSummary.d.ts

@@ -1,4 +1,4 @@
-import type { InspectApplyPayload } from './inspect';
+import type { InspectApplyPayload } from './inspect.js';
 /** Number of concrete source mutations represented by an inspect payload. */
 export declare function sourceChangeCount(payload: InspectApplyPayload): number;
 /** Changes attributable to one inventory source file. */

package/dist-lib/types/editor/sourceJournal.d.ts

@@ -1,5 +1,5 @@
-import type { InspectApplyPayload, SourceEditScope, SourceIdentity } from './inspect';
-import type { NodeModel, PageModel } from './store';
+import type { InspectApplyPayload, SourceEditScope, SourceIdentity } from './inspect.js';
+import type { NodeModel, PageModel } from './store.js';
 type JournalNode = Pick<NodeModel, 'id' | 'type' | 'children' | 'domAttributes' | 'sourceStyle' | 'text' | 'gap' | 'padding' | 'justify' | 'alignItems' | 'fill' | 'radius' | 'borderWidth' | 'borderColor' | 'opacity' | 'fontSize' | 'fontWeight' | 'color' | 'textAlign' | 'domStyle' | 'sourceProps'>;
 type JournalPage = Pick<PageModel, 'id' | 'importPageId' | 'name' | 'root'>;
 type ParseSourceIdentity = (raw: string | null | undefined) => SourceIdentity | null;

package/dist-lib/types/editor/stateSwitchMetrics.d.ts

@@ -1,7 +1,5 @@
 export type StateSwitchPhase = 'boot' | 'replay' | 'settle' | 'stability' | 'serialize' | 'publish';
 type Clock = () => number;
-/** Test hook: replace the phase clock (pass null to restore the default). */
-export declare function setStateSwitchMetricsClock(next: Clock | null): void;
 interface WaypointTiming {
     screenId: string;
     replayMs: number | null;
@@ -59,92 +57,80 @@ export interface WalkRecord {
     };
     waypoints: WaypointTiming[];
 }
-/** Opens a walk trace; called once per walkPath invocation. */
-export declare function beginStateSwitchWalk(runner: string, pathId: string, reused: boolean): StateSwitchWalkTrace;
-/** Opens the next waypoint's timing slot and drops any stale phase mark. */
-export declare function beginStateSwitchWaypoint(trace: StateSwitchWalkTrace, screenId: string): void;
-/** Stamps the start of the next phase; recordStateSwitchPhase reads it. */
-export declare function markStateSwitchPhase(trace: StateSwitchWalkTrace): void;
 /**
- * Closes the phase opened by the last mark: attributes the elapsed time to
- * the walk (boot) or the current waypoint, and feeds the aggregates. Without
- * a preceding mark this records nothing.
+ * One editor's state-switch metrics: the walk aggregates per runner, the
+ * bounded walk history, and the route-preview producer counters, behind the
+ * clock a test can replace. Every runtime owns one; its preview cache and
+ * flow-session runners record into it.
  */
-export declare function recordStateSwitchPhase(trace: StateSwitchWalkTrace, phase: StateSwitchPhase): void;
-/**
- * Closes the walk: bumps the walk counters and pushes one record into the
- * bounded history. Safe to call once per trace only; later calls no-op.
- */
-export declare function endStateSwitchWalk(trace: StateSwitchWalkTrace, completed: boolean): void;
-/**
- * One producer-gate evaluation. The gate is a pure predicate evaluated per
- * frame render, so `allowed` is an upper bound on actual producer starts;
- * the byTrigger ratio is the signal (which condition keeps opening the gate).
- */
-export declare function recordRoutePreviewProducerDecision(input: {
-    endpointConfigured: boolean;
-    detailActive: boolean;
-    previewIntended: boolean;
-}): void;
-/**
- * Plain JSON-safe snapshot for the headless debug surface. `walks.recent` is
- * oldest-first and bounded to the last WALK_HISTORY_CAPACITY walks.
- */
-export declare function getStateSwitchMetricsSnapshot(): {
-    walks: {
-        byRunner: {
-            [k: string]: {
-                count: number;
-                completed: number;
-                coldBoots: number;
-                warmReuses: number;
-                stabilityTimeouts: number;
-                phases: Record<StateSwitchPhase, PhaseAggregate>;
+export declare function createStateSwitchMetrics(): {
+    setStateSwitchMetricsClock: (next: Clock | null) => void;
+    beginStateSwitchWalk: (runner: string, pathId: string, reused: boolean) => StateSwitchWalkTrace;
+    beginStateSwitchWaypoint: (trace: StateSwitchWalkTrace, screenId: string) => void;
+    markStateSwitchPhase: (trace: StateSwitchWalkTrace) => void;
+    recordStateSwitchPhase: (trace: StateSwitchWalkTrace, phase: StateSwitchPhase) => void;
+    endStateSwitchWalk: (trace: StateSwitchWalkTrace, completed: boolean) => void;
+    recordRoutePreviewProducerDecision: (input: {
+        endpointConfigured: boolean;
+        detailActive: boolean;
+        previewIntended: boolean;
+    }) => void;
+    getStateSwitchMetricsSnapshot: () => {
+        walks: {
+            byRunner: {
+                [k: string]: {
+                    count: number;
+                    completed: number;
+                    coldBoots: number;
+                    warmReuses: number;
+                    stabilityTimeouts: number;
+                    phases: Record<StateSwitchPhase, PhaseAggregate>;
+                };
             };
+            recent: {
+                totals: {
+                    replayMs: number;
+                    settleMs: number;
+                    stabilityMs: number;
+                    serializeMs: number;
+                    publishMs: number;
+                };
+                waypoints: {
+                    screenId: string;
+                    replayMs: number | null;
+                    settleMs: number | null;
+                    stabilityMs: number | null;
+                    stabilityTimedOut: boolean;
+                    serializeMs: number | null;
+                    publishMs: number | null;
+                }[];
+                runner: string;
+                pathId: string;
+                reused: boolean;
+                completed: boolean;
+                startedAtEpochMs: number;
+                totalMs: number;
+                bootMs: number | null;
+            }[];
+            count: number;
+            completed: number;
+            coldBoots: number;
+            warmReuses: number;
+            stabilityTimeouts: number;
+            phases: Record<StateSwitchPhase, PhaseAggregate>;
         };
-        recent: {
-            totals: {
-                replayMs: number;
-                settleMs: number;
-                stabilityMs: number;
-                serializeMs: number;
-                publishMs: number;
+        routePreviewProducer: {
+            evaluations: number;
+            allowed: number;
+            suppressed: number;
+            byTrigger: {
+                endpointNotConfigured: number;
+                detailActive: number;
+                previewIntended: number;
             };
-            waypoints: {
-                screenId: string;
-                replayMs: number | null;
-                settleMs: number | null;
-                stabilityMs: number | null;
-                stabilityTimedOut: boolean;
-                serializeMs: number | null;
-                publishMs: number | null;
-            }[];
-            runner: string;
-            pathId: string;
-            reused: boolean;
-            completed: boolean;
-            startedAtEpochMs: number;
-            totalMs: number;
-            bootMs: number | null;
-        }[];
-        count: number;
-        completed: number;
-        coldBoots: number;
-        warmReuses: number;
-        stabilityTimeouts: number;
-        phases: Record<StateSwitchPhase, PhaseAggregate>;
-    };
-    routePreviewProducer: {
-        evaluations: number;
-        allowed: number;
-        suppressed: number;
-        byTrigger: {
-            endpointNotConfigured: number;
-            detailActive: number;
-            previewIntended: number;
         };
     };
+    resetStateSwitchMetrics: () => void;
 };
-/** Drops every counter and the walk history; test and audit boundary hook. */
-export declare function resetStateSwitchMetrics(): void;
+export type StateSwitchMetrics = ReturnType<typeof createStateSwitchMetrics>;
 export {};