@dreamboard-games/sdk 0.5.0-alpha.2 → 0.5.0-alpha.20

package/dist/testing.d.ts

@@ -1,20 +1,281 @@
-import { G as SnapshotMatcherHandler, E as ExpectFn, o as ScenarioDefinitionGameLike, x as ScenarioReplayDefinition, h as ScenarioCheckpoint, k as ScenarioCommand } from './definitions-BgmV_GhC.js';
-export { A as AssertScenarioOptions, a as ExpectMatchers, I as InteractionAvailabilityLike, b as InteractionDescriptorLike, c as InteractionExplanationLike, R as RejectionExpectation, d as ReplayScenarioOptions, e as RuntimeParamsOfScenarioCommand, S as ScenarioActor, f as ScenarioAssertionContext, g as ScenarioAuthoring, i as ScenarioCheckpointId, j as ScenarioCheckpointSelector, l as ScenarioCommandOf, m as ScenarioCommandTraceEntry, n as ScenarioDefinition, p as ScenarioDefinitionValidationCode, q as ScenarioDefinitionValidationError, r as ScenarioDiagnostics, s as ScenarioFlowDiagnostics, t as ScenarioProbeAccepted, u as ScenarioProbeRejected, v as ScenarioProbeResult, w as ScenarioReplay, y as ScenarioReplayError, z as ScenarioReplayErrorOptions, B as ScenarioReplaySegment, C as ScenarioSchemaOutput, D as ScenarioSeatRef, F as ScenarioSetup, H as createScenarioAuthoring, J as resolveScenarioCheckpoint, K as toScenarioReplayDefinition } from './definitions-BgmV_GhC.js';
-import { R as ReducerDiagnosticEvent } from './diagnostics-DIi3ina7.js';
-import { g as ScenarioIdentity, f as PerspectiveSelector, e as InspectScenarioResult, P as PerspectiveRef, d as InspectNode, i as Sha256Digest, F as FlowDiagnostic, A as ActorRef, a as InspectEntropy, S as ScenarioDispatchTraceEntry } from './types-JWCYHmu7.js';
-export { I as InspectAction, b as InspectInteraction, c as InspectInteractionInput, j as assertScenario, p as probeScenarioCommand, r as replayScenario } from './types-JWCYHmu7.js';
-import { w as wire, a as ReducerBundleContract } from './index.d-DjzoK7zn.js';
-import { R as RuntimeJson } from './runtime-json-CQ9QbLZ5.js';
-import { B, y, z as z$1, v, E } from './protocol-dYgafTYY.js';
+import { aq as PhaseNamesOfDefinition, a4 as InteractionIdOfDefinitionPhase, ae as ManifestIdSchema, u as CollectorValueOf, aa as InteractionSpecByNameOfDefinitionPhase, N as GameStateOf, bq as ViewOfDefinition, aP as RuntimeJson, s as ClientParamsOfInteractionOfDefinition, aD as ReducerGameContractLike, A as AnyReducerGameDefinition, aI as ReducerSessionState, M as GameOutcome, K as GameInput, aL as ReducerValidationResult, aY as SeatProjectionBundle, ah as OptionsOfContract } from './extract-CwJWDrSD.js';
 import { z } from 'zod';
-import { r as BrowserInteractionIntentRequest, l as BrowserInteractionEffectRequest } from './types-DJj5MJkl.js';
-import { b as PluginTransport, P as PluginRuntimeClient } from './types-DR7DoB1x.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import react__default from 'react';
-export { S as StaleContractArtifactError, a as StaleContractArtifactErrorOptions, b as StaleContractArtifactKind, i as isStaleContractArtifactError } from './stale-contract-artifact-error-XLaweZtF.js';
-import './views-BpuWcOyN.js';
-import './runtime-RJ5orDJU.js';
-import './types.js';
+import { D as DispatchTraceSummaryEntry, b as ReducerDiagnosticEvent, a as ReducerBundleContract } from './diagnostics-ZAPEBlJP.js';
+import { i as SubmitResult, C as CommandSource, g as SourceSnapshot, a as ApplySource } from './types-BxXRINRF.js';
+import 'honeycomb-grid';
+import '@tanstack/store';
+
+type ScenarioDefinitionValidationCode = "INVALID_TYPE" | "UNKNOWN_FIELD" | "INVALID_VALUE" | "UNSAFE_INTEGER" | "OUT_OF_RANGE" | "UNKNOWN_INTERACTION" | "INVALID_COMMAND_PARAMS" | "NON_SERIALIZABLE";
+declare class ScenarioDefinitionValidationError extends Error {
+    readonly code: ScenarioDefinitionValidationCode;
+    readonly path: string;
+    constructor(options: {
+        readonly code: ScenarioDefinitionValidationCode;
+        readonly path: string;
+        readonly reason: string;
+    });
+}
+
+type InteractionDescriptorLike = {
+    interactionId?: string;
+    surface?: string;
+    kind?: string;
+    availability?: InteractionAvailabilityLike;
+} & Record<string, unknown>;
+type InteractionAvailabilityLike = {
+    status: "available";
+} | {
+    status: "notYourTurn";
+    reason: string;
+} | {
+    status: "blocked";
+    reason: string;
+    code?: string;
+};
+type InteractionExplanationLike = {
+    interactionId: string;
+    phase: string;
+    step: string | null;
+    availability: "available" | "notYourTurn" | "wrongPhase" | "wrongStep" | "blocked";
+    rules: ReadonlyArray<{
+        ruleId: string;
+        outcome: "passed" | "failed" | "notEvaluated";
+        errorCode?: string;
+        message?: string;
+    }>;
+    actor: {
+        required: readonly string[];
+        playerIsActor: boolean;
+    };
+    inputs: ReadonlyArray<{
+        key: string;
+        kind: string;
+        eligibleCount: number | "unknown";
+    }>;
+};
+type SnapshotMatcherHandler = (name: string | undefined, actual: unknown) => void;
+type RejectionExpectation = {
+    errorCode?: string;
+    message?: string | RegExp;
+};
+type ExpectMatchers = {
+    toBe: (expected: unknown) => void;
+    toEqual: (expected: unknown) => void;
+    toMatchObject: (expected: Record<string, unknown>) => void;
+    toBeDefined: () => void;
+    toBeUndefined: () => void;
+    toBeNull: () => void;
+    toContain: (expected: unknown) => void;
+    toContainEqual: (expected: unknown) => void;
+    toHaveLength: (expected: number) => void;
+    toBeGreaterThan: (expected: number) => void;
+    toBeGreaterThanOrEqual: (expected: number) => void;
+    toThrow: (predicate?: string | RegExp | ((error: Error) => boolean)) => void;
+    toMatchSnapshot: (filename?: string) => void;
+    toRejectWith: (expected: RejectionExpectation) => Promise<void>;
+    toHaveInteraction: (interactionId: string, opts?: Partial<InteractionDescriptorLike>) => void;
+    toBeGatedBy: (reason: string, opts?: {
+        interactionId?: string;
+    }) => void;
+    toBeAvailable: (explanation?: InteractionExplanationLike) => void;
+    not: {
+        toHaveInteraction: (interactionId: string) => void;
+    };
+};
+type ExpectFn = (actual: unknown) => ExpectMatchers;
+type ScenarioSeatRef = {
+    readonly seat: number;
+};
+type ScenarioActor = ScenarioSeatRef;
+type ScenarioSetup = {
+    readonly players: number;
+    readonly seed: number;
+    readonly options?: Readonly<Record<string, RuntimeJson>>;
+};
+type ScenarioTupleOutput<Items extends readonly z.core.SomeType[], Rest extends z.core.SomeType | null, Value> = Rest extends z.core.SomeType ? readonly [
+    ...{
+        [Index in keyof Items]: ScenarioSchemaOutput<Items[Index], Index extends keyof Value ? Value[Index] : z.output<Items[Index]>>;
+    },
+    ...ScenarioSchemaOutput<Rest>[]
+] : readonly [
+    ...{
+        [Index in keyof Items]: ScenarioSchemaOutput<Items[Index], Index extends keyof Value ? Value[Index] : z.output<Items[Index]>>;
+    }
+];
+type OptionalScenarioObjectKeys<Shape extends z.core.$ZodShape> = {
+    [Key in keyof Shape]: undefined extends z.output<Shape[Key]> ? Key : never;
+}[keyof Shape];
+type ScenarioObjectOutput<Shape extends z.core.$ZodShape, Value> = {
+    readonly [Key in Exclude<keyof Shape, OptionalScenarioObjectKeys<Shape>>]: ScenarioSchemaOutput<Shape[Key], Key extends keyof Value ? Value[Key] : z.output<Shape[Key]>>;
+} & {
+    readonly [Key in OptionalScenarioObjectKeys<Shape>]?: ScenarioSchemaOutput<Shape[Key], Key extends keyof Value ? Value[Key] : z.output<Shape[Key]>>;
+};
+/**
+ * Authoring projection of an input schema. Only semantic player-id leaves are
+ * replaced; ordinary strings retain their original type.
+ */
+type ScenarioSchemaOutput<Schema extends z.core.SomeType, Value = z.output<Schema>> = Schema extends ManifestIdSchema<unknown, "playerId"> ? ScenarioSeatRef : Schema extends z.ZodOptional<infer Inner> ? ScenarioSchemaOutput<Inner, Value> | undefined : Schema extends z.ZodExactOptional<infer Inner> ? ScenarioSchemaOutput<Inner, Value> | undefined : Schema extends z.ZodNullable<infer Inner> ? ScenarioSchemaOutput<Inner, Value> | null : Schema extends z.ZodDefault<infer Inner> ? ScenarioSchemaOutput<Inner, Value> : Schema extends z.ZodPrefault<infer Inner> ? ScenarioSchemaOutput<Inner, Value> : Schema extends z.ZodCatch<infer Inner> ? ScenarioSchemaOutput<Inner, Value> : Schema extends z.ZodReadonly<infer Inner> ? Readonly<ScenarioSchemaOutput<Inner, Value>> : Schema extends z.ZodNonOptional<infer Inner> ? Exclude<ScenarioSchemaOutput<Inner, Value>, undefined> : Schema extends z.ZodArray<infer Element> ? Value extends readonly (infer Item)[] ? readonly ScenarioSchemaOutput<Element, Item>[] : never : Schema extends z.ZodTuple<infer Items, infer Rest> ? ScenarioTupleOutput<Items, Rest, Value> : Schema extends z.ZodObject<infer Shape> ? ScenarioObjectOutput<Shape, Value & z.output<Schema>> : Schema extends z.ZodRecord<infer Key, infer Element> ? Key extends ManifestIdSchema<unknown, "playerId"> ? never : Readonly<Record<Extract<z.output<Key>, string | number | symbol>, ScenarioSchemaOutput<Element, Value extends Readonly<Record<string, infer Item>> ? Item : z.output<Element>>>> : Schema extends z.ZodIntersection<infer Left, infer Right> ? ScenarioSchemaOutput<Left, Value> & ScenarioSchemaOutput<Right, Value> : Schema extends z.ZodPipe<infer Input, z.ZodType> ? ScenarioSchemaOutput<Input> : Schema extends z.ZodLazy<infer Inner> ? ScenarioSchemaOutput<Inner, Value> : Schema extends z.ZodUnion<infer Options> ? ScenarioSchemaOutput<Options[number], Value> : Value & z.output<Schema>;
+type InputCollectorsOfInteraction<Interaction> = Interaction extends {
+    readonly steps: {
+        readonly collectors: infer Collectors extends Readonly<Record<string, unknown>>;
+    };
+} ? Collectors : Interaction extends {
+    readonly inputs?: infer Collectors;
+} ? NonNullable<Collectors> extends Readonly<Record<string, unknown>> ? NonNullable<Collectors> : Record<string, never> : Record<string, never>;
+type ScenarioParamsOfCollectors<Collectors extends Readonly<Record<string, unknown>>> = {
+    readonly [Key in keyof Collectors as Collectors[Key] extends {
+        readonly kind: "rng";
+    } ? never : Key]: Collectors[Key] extends {
+        readonly schema: infer Schema extends z.core.SomeType;
+    } ? ScenarioSchemaOutput<Schema, CollectorValueOf<Collectors[Key]>> : never;
+};
+type ScenarioStepParams<Params> = {
+    [Key in keyof Params]: Pick<Params, Key> & Partial<Record<Exclude<keyof Params, Key>, never>>;
+}[keyof Params];
+type ScenarioParamsOfInteraction<Interaction> = Interaction extends {
+    readonly steps: unknown;
+} ? ScenarioStepParams<ScenarioParamsOfCollectors<InputCollectorsOfInteraction<Interaction>>> : ScenarioParamsOfCollectors<InputCollectorsOfInteraction<Interaction>>;
+type ScenarioCommand<InteractionId extends string = string, Params = Record<string, unknown>> = {
+    readonly actor: ScenarioActor;
+    readonly interactionId: InteractionId;
+    readonly params: Params;
+};
+type ScenarioCommandForPhase<Game, Phase extends PhaseNamesOfDefinition<Game>> = {
+    [InteractionId in InteractionIdOfDefinitionPhase<Game, Phase>]: ScenarioCommand<InteractionId, ScenarioParamsOfInteraction<InteractionSpecByNameOfDefinitionPhase<Game, Phase, InteractionId>>>;
+}[InteractionIdOfDefinitionPhase<Game, Phase>];
+type ScenarioCommandOf<Game> = {
+    [Phase in PhaseNamesOfDefinition<Game>]: ScenarioCommandForPhase<Game, Phase>;
+}[PhaseNamesOfDefinition<Game>];
+/** Production params remain available for runtime implementors and diagnostics. */
+type RuntimeParamsOfScenarioCommand<Game, Phase extends PhaseNamesOfDefinition<Game>, InteractionId extends InteractionIdOfDefinitionPhase<Game, Phase>> = ClientParamsOfInteractionOfDefinition<Game, Phase, InteractionId>;
+type ScenarioReplayDefinition<Game> = {
+    readonly id: string;
+    readonly description?: string;
+    readonly setup: ScenarioSetup;
+    readonly given: readonly ScenarioCommandOf<Game>[];
+    readonly when: readonly ScenarioCommandOf<Game>[];
+};
+type DeepReadonly<Value> = Value extends string | number | boolean | bigint | symbol ? Value : Value extends (...args: never[]) => unknown ? Value : Value extends readonly (infer Item)[] ? readonly DeepReadonly<Item>[] : Value extends object ? {
+    readonly [Key in keyof Value]: DeepReadonly<Value[Key]>;
+} : Value;
+type ScenarioPlayerView<Game> = ViewOfDefinition<Game>;
+type ScenarioFlowDiagnostics = {
+    readonly currentPhase: string | null;
+    readonly activeSeats: readonly ScenarioSeatRef[];
+};
+type ScenarioDiagnostics = {
+    readonly events: readonly ReducerDiagnosticEvent[];
+    readonly lastDispatch: {
+        readonly submissionId: string;
+        readonly trace: readonly DispatchTraceSummaryEntry[];
+    } | null;
+    readonly flow: ScenarioFlowDiagnostics;
+};
+type ScenarioProbeAccepted<Game> = {
+    readonly kind: "accepted";
+    readonly command: ScenarioCommandOf<Game>;
+    readonly checkpointDigest: string;
+    readonly trace: readonly DispatchTraceSummaryEntry[];
+    toBeAccepted(): void;
+    toRejectWith(expected: RejectionExpectation): never;
+};
+type ScenarioProbeRejected<Game> = {
+    readonly kind: "rejected";
+    readonly command: ScenarioCommandOf<Game>;
+    readonly errorCode: string;
+    readonly message?: string;
+    readonly trace: readonly DispatchTraceSummaryEntry[];
+    toBeAccepted(): never;
+    toRejectWith(expected: RejectionExpectation): void;
+};
+type ScenarioProbeResult<Game> = ScenarioProbeAccepted<Game> | ScenarioProbeRejected<Game>;
+type ScenarioAssertionContext<Game> = {
+    readonly expect: ExpectFn;
+    state(): DeepReadonly<GameStateOf<Game>>;
+    view(seat: ScenarioSeatRef): DeepReadonly<ScenarioPlayerView<Game>>;
+    interactions(seat: ScenarioSeatRef): readonly InteractionDescriptorLike[];
+    explain(seat: ScenarioSeatRef, interactionId: string): InteractionExplanationLike;
+    readonly diagnostics: ScenarioDiagnostics;
+    probe(command: ScenarioCommandOf<Game>): Promise<ScenarioProbeResult<Game>>;
+};
+type ScenarioDefinition<Game> = ScenarioReplayDefinition<Game> & {
+    /** Named authored states for CLI, Workbench, demo, and test adapters. */
+    readonly checkpoints?: Readonly<Record<ScenarioCheckpointId, ScenarioCheckpoint>>;
+    readonly then: (context: ScenarioAssertionContext<Game>) => void | Promise<void>;
+};
+type ScenarioCheckpoint = {
+    readonly segment: "setup";
+    readonly completed: 0;
+} | {
+    readonly segment: "given";
+    readonly completed: number;
+} | {
+    readonly segment: "when";
+    readonly completed: number;
+};
+type ScenarioCheckpointId = string;
+type ScenarioCheckpointSelector = ScenarioCheckpoint | ScenarioCheckpointId;
+/** Resolve authored names while keeping replay DTOs structurally checkpointed. */
+declare function resolveScenarioCheckpoint<Game>(definition: Pick<ScenarioDefinition<Game>, "checkpoints" | "given" | "id" | "when">, selector: ScenarioCheckpointSelector): ScenarioCheckpoint;
+type ScenarioReplaySegment = "given" | "when";
+type ScenarioCommandTraceEntry<Game> = {
+    readonly segment: ScenarioReplaySegment;
+    readonly index: number;
+    readonly command: ScenarioCommandOf<Game>;
+    readonly trace: readonly DispatchTraceSummaryEntry[];
+};
+type ScenarioReplay<Game> = {
+    readonly scenarioId: string;
+    readonly checkpoint: ScenarioCheckpoint;
+    readonly checkpointDigest: string;
+    readonly complete: boolean;
+    readonly trace: readonly ScenarioCommandTraceEntry<Game>[];
+    state(): DeepReadonly<GameStateOf<Game>>;
+    view(seat: ScenarioSeatRef): DeepReadonly<ScenarioPlayerView<Game>>;
+    interactions(seat: ScenarioSeatRef): readonly InteractionDescriptorLike[];
+    explain(seat: ScenarioSeatRef, interactionId: string): InteractionExplanationLike;
+    readonly diagnostics: ScenarioDiagnostics;
+    clone(): ScenarioReplay<Game>;
+};
+type ReplayScenarioOptions<Game> = {
+    /** Exact production artifact to execute; omitted for ordinary authored replay. */
+    readonly bundle?: ReducerBundleContract;
+    readonly game: Game;
+    readonly scenario: ScenarioReplayDefinition<Game>;
+    readonly at?: ScenarioCheckpoint;
+};
+type AssertScenarioOptions<Game> = {
+    readonly replay: ScenarioReplay<Game>;
+    readonly assertion: ScenarioDefinition<Game>["then"];
+};
+type ScenarioReplayErrorOptions = {
+    readonly scenarioId: string;
+    readonly segment: ScenarioReplaySegment;
+    readonly index: number;
+    readonly interactionId: string;
+    readonly errorCode: string;
+    readonly reducerMessage?: string;
+    readonly trace?: readonly DispatchTraceSummaryEntry[];
+};
+declare class ScenarioReplayError extends Error {
+    readonly scenarioId: string;
+    readonly segment: ScenarioReplaySegment;
+    readonly index: number;
+    readonly interactionId: string;
+    readonly errorCode: string;
+    readonly reducerMessage?: string;
+    readonly trace: readonly DispatchTraceSummaryEntry[];
+    constructor(options: ScenarioReplayErrorOptions);
+}
+type NoExtraScenarioFields<Actual, Expected> = Record<Exclude<keyof Actual, keyof Expected>, never>;
+type ScenarioAuthoring<Game> = {
+    defineScenario<const Definition extends ScenarioDefinition<Game>>(definition: Definition & NoExtraScenarioFields<Definition, ScenarioDefinition<Game>>): Definition;
+};
+declare function createScenarioAuthoring<Contract extends ReducerGameContractLike, const Game extends AnyReducerGameDefinition<Contract>>(game: Game & {
+    readonly contract: Contract;
+}): ScenarioAuthoring<Game>;
+/** Select and clone the only serializable portion of a loaded scenario. */
+declare function toScenarioReplayDefinition<Game>(definition: ScenarioDefinition<Game>): ScenarioReplayDefinition<Game>;
 
 type CreateExpectApiOptions = {
     matchSnapshot?: SnapshotMatcherHandler;
@@ -30,7 +291,135 @@ declare class ScenarioAssertionError extends Error {
     constructor(message: string);
 }
 
-type InspectScenarioOptions<Game extends ScenarioDefinitionGameLike> = {
+declare function replayScenario<Contract extends ReducerGameContractLike, const Game extends AnyReducerGameDefinition<Contract>>(options: ReplayScenarioOptions<Game> & {
+    readonly game: {
+        readonly contract: Contract;
+    };
+}): Promise<ScenarioReplay<Game>>;
+type ScenarioRuntimeCheckpointMaterialization = {
+    readonly checkpoint: ScenarioCheckpoint;
+    readonly checkpointDigest: string;
+    readonly playerIds: readonly string[];
+    readonly state: ReducerSessionState;
+    readonly terminal: GameOutcome | null;
+};
+/**
+ * Trusted tool-side materialization for CLI, Workbench, and backend adapters.
+ * The returned reducer snapshot must never cross a player/browser boundary.
+ */
+declare function materializeScenarioRuntimeCheckpoint<Contract extends ReducerGameContractLike, const Game extends AnyReducerGameDefinition<Contract>>(options: ReplayScenarioOptions<Game> & {
+    readonly game: {
+        readonly contract: Contract;
+    };
+}): Promise<ScenarioRuntimeCheckpointMaterialization>;
+declare function assertScenario<Game>(options: AssertScenarioOptions<Game>): Promise<void>;
+declare function probeScenarioCommand<Game>(options: {
+    readonly replay: ScenarioReplay<Game>;
+    readonly command: ScenarioCommandOf<Game>;
+}): Promise<ScenarioProbeResult<Game>>;
+
+type Sha256Digest = `sha256:${string}`;
+type ScenarioIdentity = {
+    readonly id: string;
+    readonly path: string;
+    readonly sourceDigest: Sha256Digest;
+};
+type ActorRef = {
+    readonly seat: number;
+    readonly playerId: string;
+};
+type PerspectiveRef = {
+    readonly kind: "player";
+    readonly actor: ActorRef;
+} | {
+    readonly kind: "spectator";
+};
+type PerspectiveSelector = {
+    readonly kind: "player";
+    readonly seat: number;
+} | {
+    readonly kind: "spectator";
+};
+type FlowDiagnostic = {
+    readonly phase: string;
+    readonly step: string | null;
+    readonly activeActors: readonly ActorRef[];
+    readonly pendingActors: readonly ActorRef[];
+    readonly continuationWaiters: readonly ActorRef[];
+    readonly blockedBy: readonly {
+        readonly actor: ActorRef;
+        readonly blockers: readonly ActorRef[];
+        readonly source: "scheduler";
+    }[];
+};
+type InspectInteractionInput = {
+    readonly key: string;
+    readonly kind: string;
+    readonly eligibleCount: number | "unknown";
+};
+type InspectInteraction = {
+    readonly actor: ActorRef;
+    readonly interactionId: string;
+    readonly availability: {
+        readonly status: "available" | "notYourTurn" | "blocked";
+        readonly code?: string;
+        readonly reason?: string;
+    };
+    readonly inputs: readonly InspectInteractionInput[];
+    readonly explanation: InteractionExplanationLike;
+};
+type InspectAction = {
+    readonly actor: ActorRef;
+    readonly interactionId: string;
+    readonly inputs: readonly InspectInteractionInput[];
+    readonly explanation: InteractionExplanationLike;
+    readonly hasConcreteCommand: true;
+};
+type ScenarioDispatchTraceEntry = {
+    readonly kind: "acceptedCommand";
+    readonly actor: ActorRef;
+    readonly interactionId: string;
+} | {
+    readonly kind: "phaseEntered";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly kind: "entropyDraw";
+    readonly drawIndex: number;
+};
+type InspectEntropy = {
+    readonly seed: number;
+    readonly draws: readonly {
+        readonly index: number;
+        readonly cursorBefore: number;
+        readonly cursorAfter: number;
+        readonly operation: {
+            readonly kind: string;
+            readonly parameters: Readonly<Record<string, string | number | boolean>>;
+        };
+    }[];
+};
+type InspectNode = {
+    readonly checkpoint: ScenarioCheckpoint;
+    readonly checkpointDigest: Sha256Digest;
+    readonly setup: ScenarioSetup;
+    readonly flow: FlowDiagnostic;
+    readonly perspective: PerspectiveRef;
+    readonly publicState: unknown;
+    readonly view: unknown;
+    readonly interactions: readonly InspectInteraction[];
+    readonly actions: readonly InspectAction[];
+    readonly entropy: InspectEntropy;
+    readonly dispatchTrace: readonly ScenarioDispatchTraceEntry[];
+};
+type InspectScenarioResult = {
+    readonly schemaVersion: 1;
+    readonly scenario: ScenarioIdentity;
+    readonly node: InspectNode;
+    readonly seedSource: "scenario" | "override";
+};
+
+type InspectScenarioOptions<Game> = {
     readonly game: Game;
     readonly scenario: ScenarioReplayDefinition<Game>;
     readonly identity: ScenarioIdentity;
@@ -38,7 +427,11 @@ type InspectScenarioOptions<Game extends ScenarioDefinitionGameLike> = {
     readonly at?: ScenarioCheckpoint;
     readonly seed?: number;
 };
-declare function inspectScenario<const Game extends ScenarioDefinitionGameLike>(options: InspectScenarioOptions<Game>): Promise<InspectScenarioResult>;
+declare function inspectScenario<Contract extends ReducerGameContractLike, const Game extends AnyReducerGameDefinition<Contract>>(options: InspectScenarioOptions<Game> & {
+    readonly game: {
+        readonly contract: Contract;
+    };
+}): Promise<InspectScenarioResult>;
 
 type ExploreTransitionResult = {
     readonly schemaVersion: 1;
@@ -96,7 +489,7 @@ type ExploreSeedResult = {
             readonly actions: readonly {
                 readonly seat: number;
                 readonly interactionId: string;
-                readonly concreteOptionCount: number | "lazy";
+                readonly concreteOptionCount: number | "unknown";
             }[];
         };
         readonly rejection?: {
@@ -113,25 +506,28 @@ type SeedRange = {
     readonly start: number;
     readonly end: number;
 };
-type ExploreScenarioOptions<Game extends ScenarioDefinitionGameLike> = Omit<InspectScenarioOptions<Game>, "seed"> & {
+type ExploreScenarioOptions<Game> = Omit<InspectScenarioOptions<Game>, "seed"> & {
     readonly seed?: number;
     readonly seedRange?: SeedRange;
     readonly limit?: number;
     readonly maxEvaluations?: number;
     readonly cursor?: string;
 };
-declare function exploreScenario<const Game extends ScenarioDefinitionGameLike>(options: ExploreScenarioOptions<Game>): Promise<ExploreScenarioResult>;
+declare function exploreScenario<Contract extends ReducerGameContractLike, const Game extends AnyReducerGameDefinition<Contract>>(options: ExploreScenarioOptions<Game> & {
+    readonly game: {
+        readonly contract: Contract;
+    };
+}): Promise<ExploreScenarioResult>;
 
-type ReducerScenarioBundle = Pick<ReducerBundleContract, "project" | "dispatch" | "boardStatic">;
+type ReducerScenarioBundle = Pick<ReducerBundleContract, "project" | "dispatch">;
 interface ReducerScenarioViewer {
     readonly seatId: string;
     readonly playerId: string;
 }
 interface ReducerScenarioFrame {
     readonly id: string;
-    readonly reducerState: wire.ReducerSessionState;
-    readonly dynamicProjection: wire.SeatProjectionBundle;
-    readonly staticProjection?: wire.BoardStaticProjection | null;
+    readonly reducerState: ReducerSessionState;
+    readonly dynamicProjection: SeatProjectionBundle;
     readonly gameVersion: number;
     readonly actionSetVersion: string;
     readonly projectionDigest: string;
@@ -147,13 +543,13 @@ type ReducerScenarioExchange = {
     readonly id: string;
     readonly operation: "validate";
     readonly fromFrameId: string;
-    readonly input: wire.GameInput;
-    readonly result: wire.ReducerInputValidationResult;
+    readonly input: GameInput;
+    readonly result: ReducerValidationResult;
 } | {
     readonly id: string;
     readonly operation: "submit";
     readonly fromFrameId: string;
-    readonly input: wire.GameInput;
+    readonly input: GameInput;
     readonly result: {
         readonly kind: "accepted";
         readonly toFrameId: string;
@@ -169,16 +565,16 @@ interface ReducerScenarioDiagnostic {
 type ReducerScenarioOperation = {
     readonly id: string;
     readonly operation: "validate";
-    readonly input: wire.GameInput;
+    readonly input: GameInput;
 } | {
     readonly id: string;
     readonly operation: "submit";
-    readonly input: wire.GameInput;
+    readonly input: GameInput;
 };
 interface CreateReducerScenarioRunnerOptions {
     readonly scenarioId: string;
     readonly gameId: string;
-    readonly initialState: wire.ReducerSessionState;
+    readonly initialState: ReducerSessionState;
     readonly bundle: ReducerScenarioBundle;
     readonly viewer: ReducerScenarioViewer;
     readonly playerIds: readonly string[];
@@ -190,553 +586,117 @@ interface ReducerScenarioRunner {
 
 declare function createReducerScenarioRunner(options: CreateReducerScenarioRunnerOptions): ReducerScenarioRunner;
 
-declare const UI_SCENARIO_FIXTURE_SCHEMA_VERSION = 2;
-declare const UI_SCENARIO_FIXTURE_BUNDLE_SCHEMA_VERSION = 2;
-declare const UI_SCENARIO_FIXTURE_SUPPORTED_BROWSER_PROTOCOL_MAJOR = 3;
-declare const UI_SCENARIO_FIXTURE_PLUGIN_RUNTIME_PROTOCOL: 4;
-declare const uiFixtureFrameSchema: z.ZodObject<{
-    id: z.ZodString;
-    frame: z.ZodType<v<unknown, string, string, string>, unknown, z.core.$ZodTypeInternals<v<unknown, string, string, string>, unknown>>;
-    projectionDigest: z.ZodString;
-}, z.core.$strict>;
-declare const uiFixtureProtocolStepSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"host.frame">;
-    frameId: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodLiteral<"client.submit">;
-    fromFrameId: z.ZodString;
-    requestDigest: z.ZodString;
-    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"interaction.result">;
-        clientActionId: z.ZodString;
-        accepted: z.ZodLiteral<true>;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"interaction.result">;
-        clientActionId: z.ZodString;
-        accepted: z.ZodLiteral<false>;
-        errorCode: z.ZodString;
-        message: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>], "accepted">;
-}, z.core.$strict>], "kind">;
-declare const pluginProtocolTapeSchema: z.ZodType<B, unknown, z.core.$ZodTypeInternals<B, unknown>>;
-declare const uiReplayRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
-    surface: z.ZodString;
-    scopeId: z.ZodOptional<z.ZodString>;
-    interactionKey: z.ZodOptional<z.ZodString>;
-    interactionId: z.ZodOptional<z.ZodString>;
-    intent: z.ZodString;
-    inputKey: z.ZodOptional<z.ZodString>;
-    candidateValue: z.ZodOptional<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-    candidateValueKey: z.ZodOptional<z.ZodString>;
-    actuatorKind: z.ZodOptional<z.ZodEnum<{
-        fill: "fill";
-        pointer: "pointer";
-        keyboard: "keyboard";
-        click: "click";
-    }>>;
-    allowDisabled: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>, z.ZodObject<{
-    surface: z.ZodString;
-    scopeId: z.ZodOptional<z.ZodString>;
-    interactionKey: z.ZodOptional<z.ZodString>;
-    interactionId: z.ZodOptional<z.ZodString>;
-    effect: z.ZodObject<{
-        kind: z.ZodString;
-    }, z.core.$catchall<z.ZodPreprocess<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>>;
-    allowDisabled: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>]>;
-declare const uiReplayExecutionSchema: z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"activate">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"fill">;
-    value: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"drag">;
-    target: z.ZodObject<{
-        surface: z.ZodString;
-        scopeId: z.ZodOptional<z.ZodString>;
-        interactionKey: z.ZodOptional<z.ZodString>;
-        interactionId: z.ZodOptional<z.ZodString>;
-        effect: z.ZodObject<{
-            kind: z.ZodString;
-        }, z.core.$catchall<z.ZodPreprocess<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>>;
-        allowDisabled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>;
-}, z.core.$strict>]>;
-declare const uiStepExpectationSchema: z.ZodObject<{
-    frameId: z.ZodOptional<z.ZodString>;
-    projectionDigest: z.ZodOptional<z.ZodString>;
-    semanticDigest: z.ZodOptional<z.ZodString>;
-    draftDigest: z.ZodOptional<z.ZodString>;
-    submissionDigest: z.ZodOptional<z.ZodString>;
-    focusedInteractionKey: z.ZodOptional<z.ZodString>;
-    visibleInteractionKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-declare const uiResolvedReplayIdentitySchema: z.ZodObject<{
-    stepId: z.ZodString;
-    surface: z.ZodString;
-    scopeId: z.ZodString;
-    interactionKey: z.ZodString;
-    interactionId: z.ZodString;
-    actuatorId: z.ZodString;
-    descriptorDigest: z.ZodOptional<z.ZodString>;
-    draftDigest: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-declare const portableSemanticReplayStepSchema: z.ZodObject<{
-    stepId: z.ZodString;
-    requestDigest: z.ZodString;
-    resolve: z.ZodUnion<readonly [z.ZodObject<{
-        surface: z.ZodString;
-        scopeId: z.ZodOptional<z.ZodString>;
-        interactionKey: z.ZodOptional<z.ZodString>;
-        interactionId: z.ZodOptional<z.ZodString>;
-        intent: z.ZodString;
-        inputKey: z.ZodOptional<z.ZodString>;
-        candidateValue: z.ZodOptional<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-        candidateValueKey: z.ZodOptional<z.ZodString>;
-        actuatorKind: z.ZodOptional<z.ZodEnum<{
-            fill: "fill";
-            pointer: "pointer";
-            keyboard: "keyboard";
-            click: "click";
-        }>>;
-        allowDisabled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>, z.ZodObject<{
-        surface: z.ZodString;
-        scopeId: z.ZodOptional<z.ZodString>;
-        interactionKey: z.ZodOptional<z.ZodString>;
-        interactionId: z.ZodOptional<z.ZodString>;
-        effect: z.ZodObject<{
-            kind: z.ZodString;
-        }, z.core.$catchall<z.ZodPreprocess<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>>;
-        allowDisabled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>]>;
-    execute: z.ZodUnion<readonly [z.ZodObject<{
-        kind: z.ZodLiteral<"activate">;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"fill">;
-        value: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"drag">;
-        target: z.ZodObject<{
-            surface: z.ZodString;
-            scopeId: z.ZodOptional<z.ZodString>;
-            interactionKey: z.ZodOptional<z.ZodString>;
-            interactionId: z.ZodOptional<z.ZodString>;
-            effect: z.ZodObject<{
-                kind: z.ZodString;
-            }, z.core.$catchall<z.ZodPreprocess<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>>;
-            allowDisabled: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>;
-    }, z.core.$strict>]>;
-    expectedIdentity: z.ZodOptional<z.ZodObject<{
-        stepId: z.ZodString;
-        surface: z.ZodString;
-        scopeId: z.ZodString;
-        interactionKey: z.ZodString;
-        interactionId: z.ZodString;
-        actuatorId: z.ZodString;
-        descriptorDigest: z.ZodOptional<z.ZodString>;
-        draftDigest: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    expect: z.ZodObject<{
-        frameId: z.ZodOptional<z.ZodString>;
-        projectionDigest: z.ZodOptional<z.ZodString>;
-        semanticDigest: z.ZodOptional<z.ZodString>;
-        draftDigest: z.ZodOptional<z.ZodString>;
-        submissionDigest: z.ZodOptional<z.ZodString>;
-        focusedInteractionKey: z.ZodOptional<z.ZodString>;
-        visibleInteractionKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-declare const uiScenarioReplayStepSchema: z.ZodUnion<readonly [z.ZodObject<{
-    stepId: z.ZodString;
-    requestDigest: z.ZodString;
-    resolve: z.ZodUnion<readonly [z.ZodObject<{
-        surface: z.ZodString;
-        scopeId: z.ZodOptional<z.ZodString>;
-        interactionKey: z.ZodOptional<z.ZodString>;
-        interactionId: z.ZodOptional<z.ZodString>;
-        intent: z.ZodString;
-        inputKey: z.ZodOptional<z.ZodString>;
-        candidateValue: z.ZodOptional<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-        candidateValueKey: z.ZodOptional<z.ZodString>;
-        actuatorKind: z.ZodOptional<z.ZodEnum<{
-            fill: "fill";
-            pointer: "pointer";
-            keyboard: "keyboard";
-            click: "click";
-        }>>;
-        allowDisabled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>, z.ZodObject<{
-        surface: z.ZodString;
-        scopeId: z.ZodOptional<z.ZodString>;
-        interactionKey: z.ZodOptional<z.ZodString>;
-        interactionId: z.ZodOptional<z.ZodString>;
-        effect: z.ZodObject<{
-            kind: z.ZodString;
-        }, z.core.$catchall<z.ZodPreprocess<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>>;
-        allowDisabled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>]>;
-    execute: z.ZodUnion<readonly [z.ZodObject<{
-        kind: z.ZodLiteral<"activate">;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"fill">;
-        value: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"drag">;
-        target: z.ZodObject<{
-            surface: z.ZodString;
-            scopeId: z.ZodOptional<z.ZodString>;
-            interactionKey: z.ZodOptional<z.ZodString>;
-            interactionId: z.ZodOptional<z.ZodString>;
-            effect: z.ZodObject<{
-                kind: z.ZodString;
-            }, z.core.$catchall<z.ZodPreprocess<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>>;
-            allowDisabled: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>;
-    }, z.core.$strict>]>;
-    expectedIdentity: z.ZodOptional<z.ZodObject<{
-        stepId: z.ZodString;
-        surface: z.ZodString;
-        scopeId: z.ZodString;
-        interactionKey: z.ZodString;
-        interactionId: z.ZodString;
-        actuatorId: z.ZodString;
-        descriptorDigest: z.ZodOptional<z.ZodString>;
-        draftDigest: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    expect: z.ZodObject<{
-        frameId: z.ZodOptional<z.ZodString>;
-        projectionDigest: z.ZodOptional<z.ZodString>;
-        semanticDigest: z.ZodOptional<z.ZodString>;
-        draftDigest: z.ZodOptional<z.ZodString>;
-        submissionDigest: z.ZodOptional<z.ZodString>;
-        focusedInteractionKey: z.ZodOptional<z.ZodString>;
-        visibleInteractionKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
-}, z.core.$strict>, z.ZodObject<{
-    stepId: z.ZodString;
-    kind: z.ZodLiteral<"assert">;
-    expect: z.ZodObject<{
-        frameId: z.ZodOptional<z.ZodString>;
-        projectionDigest: z.ZodOptional<z.ZodString>;
-        semanticDigest: z.ZodOptional<z.ZodString>;
-        draftDigest: z.ZodOptional<z.ZodString>;
-        submissionDigest: z.ZodOptional<z.ZodString>;
-        focusedInteractionKey: z.ZodOptional<z.ZodString>;
-        visibleInteractionKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
-}, z.core.$strict>]>;
-declare const uiScenarioFixtureSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<2>;
-    browserInteractionProtocol: z.ZodLiteral<"3.0.0">;
-    pluginRuntimeProtocol: z.ZodLiteral<4>;
-    id: z.ZodString;
-    title: z.ZodString;
-    gameId: z.ZodString;
-    tags: z.ZodArray<z.ZodString>;
-    source: z.ZodObject<{
-        scenarioId: z.ZodString;
-        reducerFingerprint: z.ZodString;
-        uiContractFingerprint: z.ZodString;
-        renderModule: z.ZodString;
-        renderModuleDigest: z.ZodString;
-        sourceDigest: z.ZodString;
-        sourceFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
-    viewer: z.ZodObject<{
-        seatId: z.ZodString;
-        playerId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    environment: z.ZodObject<{
-        clockIso: z.ZodString;
-        randomSeed: z.ZodString;
-        locale: z.ZodLiteral<"en-US">;
-        timezone: z.ZodLiteral<"UTC">;
-        viewportTags: z.ZodArray<z.ZodEnum<{
-            touch: "touch";
-            desktop: "desktop";
-            tablet: "tablet";
-            phone: "phone";
-        }>>;
-    }, z.core.$strict>;
-    protocol: z.ZodType<B, unknown, z.core.$ZodTypeInternals<B, unknown>>;
-    replay: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        stepId: z.ZodString;
-        requestDigest: z.ZodString;
-        resolve: z.ZodUnion<readonly [z.ZodObject<{
-            surface: z.ZodString;
-            scopeId: z.ZodOptional<z.ZodString>;
-            interactionKey: z.ZodOptional<z.ZodString>;
-            interactionId: z.ZodOptional<z.ZodString>;
-            intent: z.ZodString;
-            inputKey: z.ZodOptional<z.ZodString>;
-            candidateValue: z.ZodOptional<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-            candidateValueKey: z.ZodOptional<z.ZodString>;
-            actuatorKind: z.ZodOptional<z.ZodEnum<{
-                fill: "fill";
-                pointer: "pointer";
-                keyboard: "keyboard";
-                click: "click";
-            }>>;
-            allowDisabled: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>, z.ZodObject<{
-            surface: z.ZodString;
-            scopeId: z.ZodOptional<z.ZodString>;
-            interactionKey: z.ZodOptional<z.ZodString>;
-            interactionId: z.ZodOptional<z.ZodString>;
-            effect: z.ZodObject<{
-                kind: z.ZodString;
-            }, z.core.$catchall<z.ZodPreprocess<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>>;
-            allowDisabled: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>]>;
-        execute: z.ZodUnion<readonly [z.ZodObject<{
-            kind: z.ZodLiteral<"activate">;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"fill">;
-            value: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"drag">;
-            target: z.ZodObject<{
-                surface: z.ZodString;
-                scopeId: z.ZodOptional<z.ZodString>;
-                interactionKey: z.ZodOptional<z.ZodString>;
-                interactionId: z.ZodOptional<z.ZodString>;
-                effect: z.ZodObject<{
-                    kind: z.ZodString;
-                }, z.core.$catchall<z.ZodPreprocess<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>>;
-                allowDisabled: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strict>;
-        }, z.core.$strict>]>;
-        expectedIdentity: z.ZodOptional<z.ZodObject<{
-            stepId: z.ZodString;
-            surface: z.ZodString;
-            scopeId: z.ZodString;
-            interactionKey: z.ZodString;
-            interactionId: z.ZodString;
-            actuatorId: z.ZodString;
-            descriptorDigest: z.ZodOptional<z.ZodString>;
-            draftDigest: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        expect: z.ZodObject<{
-            frameId: z.ZodOptional<z.ZodString>;
-            projectionDigest: z.ZodOptional<z.ZodString>;
-            semanticDigest: z.ZodOptional<z.ZodString>;
-            draftDigest: z.ZodOptional<z.ZodString>;
-            submissionDigest: z.ZodOptional<z.ZodString>;
-            focusedInteractionKey: z.ZodOptional<z.ZodString>;
-            visibleInteractionKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-    }, z.core.$strict>, z.ZodObject<{
-        stepId: z.ZodString;
-        kind: z.ZodLiteral<"assert">;
-        expect: z.ZodObject<{
-            frameId: z.ZodOptional<z.ZodString>;
-            projectionDigest: z.ZodOptional<z.ZodString>;
-            semanticDigest: z.ZodOptional<z.ZodString>;
-            draftDigest: z.ZodOptional<z.ZodString>;
-            submissionDigest: z.ZodOptional<z.ZodString>;
-            focusedInteractionKey: z.ZodOptional<z.ZodString>;
-            visibleInteractionKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-    }, z.core.$strict>]>>;
-    expected: z.ZodObject<{
-        initialProjectionDigest: z.ZodString;
-        finalProjectionDigest: z.ZodString;
-        finalSemanticDigest: z.ZodString;
-        submissionDigest: z.ZodString;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-declare const uiScenarioFixtureBundleIndexSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<2>;
-    bundleId: z.ZodString;
-    sdkCommit: z.ZodString;
-    pluginRuntimeProtocol: z.ZodLiteral<4>;
-    browserInteractionProtocol: z.ZodLiteral<"3.0.0">;
-    fixtures: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        file: z.ZodString;
-        sha256: z.ZodString;
-        renderModule: z.ZodString;
-        renderModuleSha256: z.ZodString;
-        components: z.ZodArray<z.ZodString>;
-        capabilities: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-type UIReplayRequest = BrowserInteractionIntentRequest | BrowserInteractionEffectRequest;
-type UIReplayExecution = z.infer<typeof uiReplayExecutionSchema>;
-type UIStepExpectation = z.infer<typeof uiStepExpectationSchema>;
-type UIResolvedReplayIdentity = z.infer<typeof uiResolvedReplayIdentitySchema>;
-type PortableSemanticReplayStep = z.infer<typeof portableSemanticReplayStepSchema>;
-type UIScenarioReplayStep = z.infer<typeof uiScenarioReplayStepSchema>;
-type UIFixtureFrame = y;
-type UIFixtureProtocolStep = z$1;
-type PluginProtocolTape = B;
-type UIScenarioFixture = Omit<z.infer<typeof uiScenarioFixtureSchema>, "protocol" | "replay"> & {
-    readonly protocol: PluginProtocolTape;
-    readonly replay: readonly UIScenarioReplayStep[];
-};
-type UIScenarioFixtureBundleIndex = z.infer<typeof uiScenarioFixtureBundleIndexSchema>;
-declare function parseUIScenarioFixture(value: unknown): UIScenarioFixture;
-declare function parseUIScenarioFixtureBundleIndex(value: unknown): UIScenarioFixtureBundleIndex;
-declare function assertSupportedBrowserInteractionProtocol(version: string): void;
-
-type UIScenarioAuthorityKind = "protocol" | "reducer";
-interface UIScenarioEnvironmentDefinition {
-    readonly viewport?: "desktop" | "tablet" | "phone";
-    readonly browsers?: readonly ("chromium" | "webkit")[];
-    readonly input?: readonly ("mouse" | "touch" | "keyboard")[];
-}
-interface ProtocolUIScenarioAuthority {
-    readonly kind: "protocol";
-    readonly tape: PluginProtocolTape;
+interface CapturedSubmission {
+    readonly operation: "submit" | "cancel";
+    readonly interactionId: string;
+    readonly params?: RuntimeJson;
+    resolve(result: SubmitResult): void;
 }
-interface ReducerUIScenarioAuthority {
-    readonly kind: "reducer";
-    readonly referenceGame: unknown;
-    readonly coverage: unknown;
-    readonly bundle: unknown;
-    readonly initialState: unknown;
-    readonly viewer: unknown;
-    readonly playerIds?: readonly string[];
-    readonly operations: readonly unknown[];
-}
-type UIScenarioAuthority = ProtocolUIScenarioAuthority | ReducerUIScenarioAuthority;
-interface UIScenarioDefinition {
-    readonly id: string;
-    readonly title?: string;
-    readonly contracts: readonly string[];
-    readonly capabilities: readonly string[];
-    readonly sourceFiles: readonly string[];
-    readonly environment?: UIScenarioEnvironmentDefinition;
-    readonly authority: UIScenarioAuthority;
-    readonly replay: readonly UIScenarioReplayStep[];
+interface TestSource extends CommandSource {
+    readonly submissions: readonly CapturedSubmission[];
+    emit(snapshot: SourceSnapshot): void;
+    recovering(): void;
+    fail(error: Error): void;
 }
+/** Test-owned transport control; all request/barrier behavior remains production code. */
+declare function createTestSource(initial: SourceSnapshot): TestSource;
 
-declare function defineUIScenario<const TScenario extends UIScenarioDefinition>(scenario: TScenario): Readonly<TScenario>;
-
-type CanonicalJson = null | boolean | number | string | readonly CanonicalJson[] | {
-    readonly [key: string]: CanonicalJson;
-};
-declare function isSha256Digest(value: string): boolean;
-declare function canonicalizeUIFixtureJson(value: unknown): CanonicalJson;
-declare function canonicalUIFixtureJson(value: unknown): string;
-declare function digestUIFixtureJson(value: unknown): string;
-declare function digestUIFixtureRequest(request: UIReplayRequest): string;
-declare function digestUIFixtureTransportRequest(request: {
-    readonly operation: "validate" | "submit";
-    readonly basis?: {
-        readonly version: number;
-        readonly actionSetVersion: string;
-        readonly perspectivePlayerId: string;
-    };
-    readonly interactionId?: string;
-    readonly payload?: unknown;
-}): string;
-declare function digestPluginProtocolTape(tape: PluginProtocolTape): string;
-declare function canonicalizeUIScenarioFixture(fixture: UIScenarioFixture): UIScenarioFixture;
-declare function serializeUIScenarioFixture(fixture: UIScenarioFixture): string;
-declare function digestUIScenarioFixture(fixture: UIScenarioFixture): string;
-
-interface FixtureHostEvent {
-    readonly sequence: number;
-    readonly atMs: number;
-    readonly kind: "frame-sent" | "submit-received" | "ack-received" | "ready-received" | "diagnostic";
-    readonly requestDigest?: string;
-    readonly frameId?: string;
-    readonly projectionDigest?: string;
-    readonly result?: "accepted" | "rejected";
-}
-interface FixtureHostHarness {
-    readonly transport: PluginTransport;
-    readonly tape: B;
-    reset(): void;
-    flush(): Promise<void>;
-    advanceHost(): Promise<void>;
-    getCurrentFrameId(): string;
-    getEvents(): readonly FixtureHostEvent[];
-    assertConsumed(): void;
+/** JSON round-trippable tooling checkpoint. Private state stays in testing. */
+interface LocalCheckpoint {
+    readonly state: ReducerSessionState;
+    readonly terminal: GameOutcome | null;
 }
-interface CreateFixtureHostHarnessOptions {
-    readonly tape: B;
-    readonly strict?: boolean;
-    readonly latencyMs?: number;
-    readonly channelId?: string;
-    readonly onEvent?: (event: FixtureHostEvent) => void;
-    readonly nowMs?: () => number;
+interface LocalSource<Game> extends CommandSource, ApplySource<ScenarioCommandOf<Game>, Promise<SubmitResult>> {
+    switchSeat(playerId: string): void;
+    checkpoint(): LocalCheckpoint;
+    /** Parses untrusted checkpoint JSON before replacing state. */
+    restore(checkpoint: unknown): void;
+    inspect(): SourceSnapshot;
+    explore(options: {
+        maxEvaluations: number;
+    }): Promise<readonly ScenarioCommandOf<Game>[]>;
 }
-declare function createFixtureHostHarness(options: CreateFixtureHostHarnessOptions): FixtureHostHarness;
 
-declare function FixturePluginRuntime({ harness, runtime, children, }: {
-    harness: FixtureHostHarness;
-    runtime?: PluginRuntimeClient;
-    children: react__default.ReactNode;
-}): react_jsx_runtime.JSX.Element;
+declare function localSource<Contract extends ReducerGameContractLike, const Game extends AnyReducerGameDefinition<Contract>>(game: Game & {
+    readonly contract: Contract;
+}, options: {
+    players: number;
+    seed: number;
+    as?: string;
+    options?: OptionsOfContract<Game["contract"]>;
+}): Promise<LocalSource<Game>>;
 
-interface CompilePluginProtocolTapeOptions {
-    readonly trace: ReducerScenarioTrace;
-    readonly session: E;
-}
-declare function compilePluginProtocolTape(options: CompilePluginProtocolTapeOptions): PluginProtocolTape;
+declare function scenarioSource<Contract extends ReducerGameContractLike, const Game extends AnyReducerGameDefinition<Contract>>(game: Game & {
+    readonly contract: Contract;
+}, scenario: ScenarioDefinition<Game>, options?: {
+    at?: ScenarioCheckpointSelector;
+    as?: string;
+}): Promise<LocalSource<Game>>;
 
-interface FixtureEnvironmentInit {
-    readonly clockIso: string;
-    readonly randomSeed: string;
-    readonly locale: "en-US";
-    readonly timezone: "UTC";
-    readonly reducedMotion: true;
-    readonly network: "blocked";
+interface FuzzResult<Game> {
+    readonly commands: readonly ScenarioCommandOf<Game>[];
+    readonly checkpoint: LocalCheckpoint;
+    readonly error?: Error;
 }
-declare const defaultFixtureEnvironmentInit: FixtureEnvironmentInit;
-type DeterministicIdFactory = () => string;
-declare function createDeterministicIdFactory(seed: string): DeterministicIdFactory;
-declare function fixtureEnvironmentInitFor(options: {
-    readonly clockIso: string;
-    readonly randomSeed: string;
-}): FixtureEnvironmentInit;
+/** Deterministic testing choice RNG is independent from the game's authoritative RNG. */
+declare function fuzz<Contract extends ReducerGameContractLike, const Game extends AnyReducerGameDefinition<Contract>>(game: Game & {
+    readonly contract: Contract;
+}, options: {
+    seed: number;
+    steps: number;
+    players?: number;
+    maxEvaluations?: number;
+}): Promise<FuzzResult<Game>>;
 
-interface CompileUIScenarioFixtureOptions {
+type CandidateVerificationScenario<Game> = ScenarioDefinition<Game>;
+type CandidateVerificationInput<Game> = {
+    /** The exact compiled production artifact under verification. */
+    readonly bundle: ReducerBundleContract;
+    /** Authored scenario schemas and inspection metadata; not execution authority. */
+    readonly reducer: Game;
+    readonly scenarios: Readonly<Record<string, CandidateVerificationScenario<Game>>> | readonly CandidateVerificationScenario<Game>[];
+    readonly maxScenarios?: number;
+    readonly maxStepsPerScenario?: number;
+};
+type CandidateVerificationReplayDiagnostic = {
+    readonly kind: "replay";
+    readonly message: string;
+    readonly scenarioId?: string;
+    readonly segment?: "given" | "when";
+    readonly index?: number;
+    readonly interactionId?: string;
+    readonly errorCode?: string;
+    readonly reducerMessage?: string;
+    readonly trace?: readonly DispatchTraceSummaryEntry[];
+};
+type CandidateVerificationAssertionDiagnostic = {
+    readonly kind: "assertion";
+    readonly message: string;
+};
+type CandidateVerificationLimitDiagnostic = {
+    readonly kind: "limit";
+    readonly message: string;
+    readonly actualSteps: number;
+    readonly maxStepsPerScenario: number;
+};
+type CandidateVerificationScenarioResult = {
     readonly id: string;
-    readonly title: string;
-    readonly gameId: string;
-    readonly tags?: readonly string[];
-    readonly source: UIScenarioFixture["source"];
-    readonly viewer: UIScenarioFixture["viewer"];
-    readonly environment: UIScenarioFixture["environment"];
-    readonly protocol: PluginProtocolTape;
-    readonly replay?: readonly UIScenarioReplayStep[];
-    readonly expected?: Partial<UIScenarioFixture["expected"]>;
-}
-type UIReplayIdentityCandidate = UIResolvedReplayIdentity;
-declare function compileUIScenarioFixture(options: CompileUIScenarioFixtureOptions): UIScenarioFixture;
-declare function assertDeterministicUIScenarioFixture(first: UIScenarioFixture, second: UIScenarioFixture): void;
-declare function assertUniqueReplayIdentity(step: Pick<PortableSemanticReplayStep, "stepId" | "expectedIdentity">, candidates: readonly UIReplayIdentityCandidate[]): UIReplayIdentityCandidate;
-declare function assertUIStepExpectationSatisfied(stepId: string, expected: UIStepExpectation, actual: UIStepExpectation): void;
-
-type ReplayRequest = PortableSemanticReplayStep["resolve"];
-type DragTarget = Extract<PortableSemanticReplayStep["execute"], {
-    kind: "drag";
-}>["target"];
-interface ReplayStepOptions {
-    readonly stepId: string;
-    readonly resolve: ReplayRequest;
-    readonly expect: UIStepExpectation;
-    readonly expectedIdentity?: UIResolvedReplayIdentity;
-}
-interface FillReplayStepOptions extends ReplayStepOptions {
-    readonly value: string;
-}
-interface DragReplayStepOptions extends ReplayStepOptions {
-    readonly target: DragTarget;
-}
-declare function activate(options: ReplayStepOptions): UIScenarioReplayStep;
-declare function fill(options: FillReplayStepOptions): UIScenarioReplayStep;
-declare function press(options: ReplayStepOptions): UIScenarioReplayStep;
-declare function drag(options: DragReplayStepOptions): UIScenarioReplayStep;
-declare function submit(options: ReplayStepOptions): UIScenarioReplayStep;
-declare function assertStep(stepId: string, expect: UIStepExpectation): UIScenarioReplayStep;
+    readonly status: "passed" | "failed";
+    readonly diagnostic?: CandidateVerificationReplayDiagnostic | CandidateVerificationAssertionDiagnostic | CandidateVerificationLimitDiagnostic;
+};
+type CandidateVerificationResult = {
+    readonly status: "passed" | "failed";
+    readonly scenarioSummary: {
+        readonly total: number;
+        readonly passed: number;
+        readonly failed: number;
+        readonly scenarios: readonly CandidateVerificationScenarioResult[];
+    };
+};
+declare function runCandidateVerification<Contract extends ReducerGameContractLike, const Game extends AnyReducerGameDefinition<Contract>>(input: CandidateVerificationInput<Game> & {
+    readonly reducer: {
+        readonly contract: Contract;
+    };
+}): Promise<CandidateVerificationResult>;
 
-export { ActorRef, type CompilePluginProtocolTapeOptions, type CompileUIScenarioFixtureOptions, type CreateFixtureHostHarnessOptions, type CreateReducerScenarioRunnerOptions, type DeterministicIdFactory, ExpectFn, type ExploreScenarioOptions, type ExploreScenarioResult, type ExploreSeedResult, type ExploreTransitionResult, type FixtureEnvironmentInit, type FixtureHostEvent, type FixtureHostHarness, FixturePluginRuntime, FlowDiagnostic, InspectEntropy, InspectNode, type InspectScenarioOptions, InspectScenarioResult, PerspectiveRef, PerspectiveSelector, type PluginProtocolTape, type PortableSemanticReplayStep, type ProtocolUIScenarioAuthority, type ReducerScenarioBundle, type ReducerScenarioDiagnostic, type ReducerScenarioExchange, type ReducerScenarioFrame, type ReducerScenarioOperation, type ReducerScenarioRunner, type ReducerScenarioTrace, type ReducerScenarioViewer, type ReducerUIScenarioAuthority, ScenarioAssertionError, ScenarioCheckpoint, ScenarioCommand, ScenarioDispatchTraceEntry, ScenarioIdentity, ScenarioReplayDefinition, Sha256Digest, SnapshotMatcherHandler, type UIFixtureFrame, type UIFixtureProtocolStep, type UIReplayExecution, type UIReplayIdentityCandidate, type UIReplayRequest, type UIResolvedReplayIdentity, type UIScenarioAuthority, type UIScenarioAuthorityKind, type UIScenarioDefinition, type UIScenarioEnvironmentDefinition, type UIScenarioFixture, type UIScenarioFixtureBundleIndex, type UIScenarioReplayStep, type UIStepExpectation, UI_SCENARIO_FIXTURE_BUNDLE_SCHEMA_VERSION, UI_SCENARIO_FIXTURE_PLUGIN_RUNTIME_PROTOCOL, UI_SCENARIO_FIXTURE_SCHEMA_VERSION, UI_SCENARIO_FIXTURE_SUPPORTED_BROWSER_PROTOCOL_MAJOR, activate, assertDeterministicUIScenarioFixture, assertStep, assertSupportedBrowserInteractionProtocol, assertUIStepExpectationSatisfied, assertUniqueReplayIdentity, canonicalUIFixtureJson, canonicalizeUIFixtureJson, canonicalizeUIScenarioFixture, compilePluginProtocolTape, compileUIScenarioFixture, createDeterministicIdFactory, createExpectApi, createFixtureHostHarness, createReducerScenarioRunner, defaultFixtureEnvironmentInit, defineUIScenario, digestPluginProtocolTape, digestUIFixtureJson, digestUIFixtureRequest, digestUIFixtureTransportRequest, digestUIScenarioFixture, drag, exploreScenario, fill, fixtureEnvironmentInitFor, inspectScenario, isSha256Digest, parseUIScenarioFixture, parseUIScenarioFixtureBundleIndex, pluginProtocolTapeSchema, portableSemanticReplayStepSchema, press, serializeUIScenarioFixture, submit, uiFixtureFrameSchema, uiFixtureProtocolStepSchema, uiReplayExecutionSchema, uiReplayRequestSchema, uiResolvedReplayIdentitySchema, uiScenarioFixtureBundleIndexSchema, uiScenarioFixtureSchema, uiScenarioReplayStepSchema, uiStepExpectationSchema };
+export { type ActorRef, type AssertScenarioOptions, type CandidateVerificationAssertionDiagnostic, type CandidateVerificationInput, type CandidateVerificationLimitDiagnostic, type CandidateVerificationReplayDiagnostic, type CandidateVerificationResult, type CandidateVerificationScenario, type CandidateVerificationScenarioResult, type CapturedSubmission, type CreateReducerScenarioRunnerOptions, type ExpectFn, type ExpectMatchers, type ExploreScenarioOptions, type ExploreScenarioResult, type ExploreSeedResult, type ExploreTransitionResult, type FlowDiagnostic, type FuzzResult, type InspectAction, type InspectEntropy, type InspectInteraction, type InspectInteractionInput, type InspectNode, type InspectScenarioOptions, type InspectScenarioResult, type InteractionAvailabilityLike, type InteractionDescriptorLike, type InteractionExplanationLike, type LocalCheckpoint, type LocalSource, type PerspectiveRef, type PerspectiveSelector, type ReducerScenarioBundle, type ReducerScenarioDiagnostic, type ReducerScenarioExchange, type ReducerScenarioFrame, type ReducerScenarioOperation, type ReducerScenarioRunner, type ReducerScenarioTrace, type ReducerScenarioViewer, type RejectionExpectation, type ReplayScenarioOptions, type RuntimeParamsOfScenarioCommand, type ScenarioActor, type ScenarioAssertionContext, ScenarioAssertionError, type ScenarioAuthoring, type ScenarioCheckpoint, type ScenarioCheckpointId, type ScenarioCheckpointSelector, type ScenarioCommand, type ScenarioCommandOf, type ScenarioCommandTraceEntry, type ScenarioDefinition, type ScenarioDefinitionValidationCode, ScenarioDefinitionValidationError, type ScenarioDiagnostics, type ScenarioDispatchTraceEntry, type ScenarioFlowDiagnostics, type ScenarioIdentity, type ScenarioProbeAccepted, type ScenarioProbeRejected, type ScenarioProbeResult, type ScenarioReplay, type ScenarioReplayDefinition, ScenarioReplayError, type ScenarioReplayErrorOptions, type ScenarioReplaySegment, type ScenarioRuntimeCheckpointMaterialization, type ScenarioSchemaOutput, type ScenarioSeatRef, type ScenarioSetup, type Sha256Digest, type SnapshotMatcherHandler, type TestSource, assertScenario, createExpectApi, createReducerScenarioRunner, createScenarioAuthoring, createTestSource, exploreScenario, fuzz, inspectScenario, localSource, materializeScenarioRuntimeCheckpoint, probeScenarioCommand, replayScenario, resolveScenarioCheckpoint, runCandidateVerification, scenarioSource, toScenarioReplayDefinition };