@dreamboard-games/sdk 0.4.0-alpha.1 → 0.4.0-alpha.2

package/dist/testing.d.ts

@@ -1,11 +1,14 @@
 import { R as ReducerDiagnosticEvent, D as DispatchTraceSummaryEntry } from './stale-contract-artifact-error-BelRiIDR.js';
 export { S as StaleContractArtifactError, b as StaleContractArtifactErrorOptions, c as StaleContractArtifactKind, i as isStaleContractArtifactError } from './stale-contract-artifact-error-BelRiIDR.js';
 import { w as wire, a as ReducerBundleContract } from './index.d-BL3bT5lt.js';
-import { d as PluginStateSnapshot$1, G as GameplaySnapshot$1, R as RuntimeAPI, c as PluginSessionState, V as ValidationResult } from './runtime-api-BXd70c2e.js';
+import { o, v, u, s, t } from './protocol-BP193lva.js';
+import { R as RuntimeAPI, V as ValidationResult } from './runtime-api-C6aWo9c0.js';
 import { R as RuntimeJson } from './runtime-json-CQ9QbLZ5.js';
 import { z } from 'zod';
-import { r as BrowserInteractionIntentRequest, l as BrowserInteractionEffectRequest } from './types-BqzHkNMA.js';
-import './hex-color-MhOyuY-o.js';
+import { r as BrowserInteractionIntentRequest, l as BrowserInteractionEffectRequest } from './types-DJj5MJkl.js';
+import { b as PluginTransport, P as PluginRuntimeClient } from './types-CYeN0wLK.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import react__default from 'react';
 
 type TestRunner = "reducer" | "remote" | "browser";
 type InteractionDescriptorLike = {
@@ -137,17 +140,6 @@ type CreateExpectApiOptions = {
 };
 declare function createExpectApi(options?: CreateExpectApiOptions): ExpectFn;
 
-type GameView = Record<string, unknown>;
-
-type PhaseName = string;
-
-type StageName = string;
-type InteractionId = string;
-type GameplaySnapshot = GameplaySnapshot$1<PhaseName, StageName, InteractionId>;
-type PluginStateSnapshot = Omit<PluginStateSnapshot$1<GameView, PhaseName, StageName, InteractionId>, "gameplay"> & {
-    gameplay: GameplaySnapshot;
-};
-
 type ReducerBundleLike = Pick<ReducerBundleContract, "projectSeatsDynamic" | "validateInput" | "dispatch"> & {
     explainInteraction?: (input: {
         state: wire.ReducerSessionState;
@@ -179,12 +171,9 @@ type CreateTestRuntimeOptions = {
     expectedBaseStateFingerprint?: string;
 };
 type CreatedTestRuntime = {
-    runtime: RuntimeAPI & {
-        getSnapshot(): PluginStateSnapshot;
-        subscribeToState(listener: (state: PluginStateSnapshot) => void): () => void;
-        _subscribeToSessionState(listener: (state: PluginSessionState) => void): () => void;
-    };
-    getSnapshot(): PluginStateSnapshot;
+    runtime: RuntimeAPI;
+    getFrame(): o;
+    getSessionDescriptor(): v;
     players(): readonly string[];
     seat(index: number): string;
     submit(playerId: string, interactionId: string, params?: unknown): Promise<void>;
@@ -198,79 +187,114 @@ type CreatedTestRuntime = {
         } | null;
         clear(): void;
     };
-    setControllingPlayer(playerId: string): void;
 };
 declare function createTestRuntime(options: CreateTestRuntimeOptions): CreatedTestRuntime;
 
-declare const UI_SCENARIO_FIXTURE_SCHEMA_VERSION = 1;
-declare const UI_SCENARIO_FIXTURE_BUNDLE_SCHEMA_VERSION = 1;
-declare const UI_SCENARIO_FIXTURE_SUPPORTED_BROWSER_PROTOCOL_MAJOR = 2;
-declare const uiFixturePluginStateSnapshotSchema: z.ZodObject<{
-    view: z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-    gameplay: z.ZodObject<{
-        currentPhase: z.ZodNullable<z.ZodString>;
-        currentStage: z.ZodNullable<z.ZodString>;
-        activePlayers: z.ZodArray<z.ZodString>;
-        simultaneousPhase: z.ZodOptional<z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>;
-        availableInteractions: z.ZodArray<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-        zones: z.ZodRecord<z.ZodString, z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-    }, z.core.$catchall<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>;
-    lobby: z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-    notifications: z.ZodArray<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-    session: z.ZodObject<{
-        sessionId: z.ZodString;
-        controllablePlayerIds: z.ZodArray<z.ZodString>;
-        controllingPlayerId: z.ZodNullable<z.ZodString>;
-        userId: z.ZodNullable<z.ZodString>;
-    }, z.core.$catchall<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>;
-    history: z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-    syncId: z.ZodNumber;
-}, z.core.$strict>;
+type ReducerScenarioBundle = Pick<ReducerBundleContract, "projectSeatsDynamic" | "validateInput" | "dispatch" | "projectStatic">;
+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 gameVersion: number;
+    readonly actionSetVersion: string;
+    readonly projectionDigest: string;
+}
+interface ReducerScenarioTrace {
+    readonly scenarioId: string;
+    readonly gameId: string;
+    readonly viewer: ReducerScenarioViewer;
+    readonly frames: readonly ReducerScenarioFrame[];
+    readonly exchanges: readonly ReducerScenarioExchange[];
+}
+type ReducerScenarioExchange = {
+    readonly id: string;
+    readonly operation: "validate";
+    readonly fromFrameId: string;
+    readonly input: wire.GameInput;
+    readonly result: wire.ReducerInputValidationResult;
+} | {
+    readonly id: string;
+    readonly operation: "submit";
+    readonly fromFrameId: string;
+    readonly input: wire.GameInput;
+    readonly result: {
+        readonly kind: "accepted";
+        readonly toFrameId: string;
+    } | {
+        readonly kind: "rejected";
+        readonly diagnostics: readonly ReducerScenarioDiagnostic[];
+    };
+};
+interface ReducerScenarioDiagnostic {
+    readonly code: string;
+    readonly message: string;
+}
+type ReducerScenarioOperation = {
+    readonly id: string;
+    readonly operation: "validate";
+    readonly input: wire.GameInput;
+} | {
+    readonly id: string;
+    readonly operation: "submit";
+    readonly input: wire.GameInput;
+};
+interface CreateReducerScenarioRunnerOptions {
+    readonly scenarioId: string;
+    readonly gameId: string;
+    readonly initialState: wire.ReducerSessionState;
+    readonly bundle: ReducerScenarioBundle;
+    readonly viewer: ReducerScenarioViewer;
+    readonly playerIds: readonly string[];
+    readonly initialGameVersion?: number;
+}
+interface ReducerScenarioRunner {
+    run(operations: readonly ReducerScenarioOperation[]): Promise<ReducerScenarioTrace>;
+}
+
+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: 3;
 declare const uiFixtureFrameSchema: z.ZodObject<{
     id: z.ZodString;
-    snapshot: z.ZodObject<{
-        view: z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-        gameplay: z.ZodObject<{
-            currentPhase: z.ZodNullable<z.ZodString>;
-            currentStage: z.ZodNullable<z.ZodString>;
-            activePlayers: z.ZodArray<z.ZodString>;
-            simultaneousPhase: z.ZodOptional<z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>;
-            availableInteractions: z.ZodArray<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-            zones: z.ZodRecord<z.ZodString, z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-        }, z.core.$catchall<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>;
-        lobby: z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-        notifications: z.ZodArray<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-        session: z.ZodObject<{
-            sessionId: z.ZodString;
-            controllablePlayerIds: z.ZodArray<z.ZodString>;
-            controllingPlayerId: z.ZodNullable<z.ZodString>;
-            userId: z.ZodNullable<z.ZodString>;
-        }, z.core.$catchall<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>;
-        history: z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-        syncId: z.ZodNumber;
-    }, z.core.$strict>;
+    frame: z.ZodType<o<unknown, string, string, string>, unknown, z.core.$ZodTypeInternals<o<unknown, string, string, string>, unknown>>;
     projectionDigest: z.ZodString;
 }, z.core.$strict>;
-declare const uiFixtureTransportExchangeSchema: z.ZodObject<{
+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.validate">;
     fromFrameId: z.ZodString;
-    operation: z.ZodEnum<{
-        validate: "validate";
-        submit: "submit";
-        refresh: "refresh";
-    }>;
     requestDigest: z.ZodString;
-    response: z.ZodUnion<readonly [z.ZodObject<{
-        kind: z.ZodLiteral<"accepted">;
-        nextFrameId: z.ZodString;
+    response: z.ZodObject<{
+        valid: z.ZodBoolean;
+        errorCode: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"client.submit">;
+    fromFrameId: z.ZodString;
+    requestDigest: z.ZodString;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        accepted: z.ZodLiteral<true>;
     }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"rejected">;
-        diagnostics: z.ZodArray<z.ZodObject<{
-            code: z.ZodString;
-            message: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>]>;
-}, z.core.$strict>;
+        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<u, unknown, z.core.$ZodTypeInternals<u, unknown>>;
 declare const uiReplayRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
     surface: z.ZodString;
     scopeId: z.ZodOptional<z.ZodString>;
@@ -481,8 +505,9 @@ declare const uiScenarioReplayStepSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>]>;
 declare const uiScenarioFixtureSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
-    browserInteractionProtocol: z.ZodLiteral<"2.0.0">;
+    schemaVersion: z.ZodLiteral<2>;
+    browserInteractionProtocol: z.ZodLiteral<"3.0.0">;
+    pluginRuntimeProtocol: z.ZodLiteral<3>;
     id: z.ZodString;
     title: z.ZodString;
     gameId: z.ZodString;
@@ -511,51 +536,7 @@ declare const uiScenarioFixtureSchema: z.ZodObject<{
             phone: "phone";
         }>>;
     }, z.core.$strict>;
-    frames: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        snapshot: z.ZodObject<{
-            view: z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-            gameplay: z.ZodObject<{
-                currentPhase: z.ZodNullable<z.ZodString>;
-                currentStage: z.ZodNullable<z.ZodString>;
-                activePlayers: z.ZodArray<z.ZodString>;
-                simultaneousPhase: z.ZodOptional<z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>;
-                availableInteractions: z.ZodArray<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-                zones: z.ZodRecord<z.ZodString, z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-            }, z.core.$catchall<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>;
-            lobby: z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-            notifications: z.ZodArray<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-            session: z.ZodObject<{
-                sessionId: z.ZodString;
-                controllablePlayerIds: z.ZodArray<z.ZodString>;
-                controllingPlayerId: z.ZodNullable<z.ZodString>;
-                userId: z.ZodNullable<z.ZodString>;
-            }, z.core.$catchall<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>>;
-            history: z.ZodNullable<z.ZodType<RuntimeJson, unknown, z.core.$ZodTypeInternals<RuntimeJson, unknown>>>;
-            syncId: z.ZodNumber;
-        }, z.core.$strict>;
-        projectionDigest: z.ZodString;
-    }, z.core.$strict>>;
-    transport: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        fromFrameId: z.ZodString;
-        operation: z.ZodEnum<{
-            validate: "validate";
-            submit: "submit";
-            refresh: "refresh";
-        }>;
-        requestDigest: z.ZodString;
-        response: z.ZodUnion<readonly [z.ZodObject<{
-            kind: z.ZodLiteral<"accepted">;
-            nextFrameId: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"rejected">;
-            diagnostics: z.ZodArray<z.ZodObject<{
-                code: z.ZodString;
-                message: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$strict>]>;
-    }, z.core.$strict>>;
+    protocol: z.ZodType<u, unknown, z.core.$ZodTypeInternals<u, unknown>>;
     replay: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         stepId: z.ZodString;
         requestDigest: z.ZodString;
@@ -643,10 +624,11 @@ declare const uiScenarioFixtureSchema: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>;
 declare const uiScenarioFixtureBundleIndexSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodLiteral<2>;
     bundleId: z.ZodString;
     sdkCommit: z.ZodString;
-    browserInteractionProtocol: z.ZodLiteral<"2.0.0">;
+    pluginRuntimeProtocol: z.ZodLiteral<3>;
+    browserInteractionProtocol: z.ZodLiteral<"3.0.0">;
     fixtures: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         file: z.ZodString;
@@ -663,12 +645,11 @@ 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 = Omit<z.infer<typeof uiFixtureFrameSchema>, "snapshot"> & {
-    readonly snapshot: PluginStateSnapshot$1;
-};
-type UIFixtureTransportExchange = z.infer<typeof uiFixtureTransportExchangeSchema>;
-type UIScenarioFixture = Omit<z.infer<typeof uiScenarioFixtureSchema>, "frames" | "replay"> & {
-    readonly frames: readonly UIFixtureFrame[];
+type UIFixtureFrame = s;
+type UIFixtureProtocolStep = t;
+type PluginProtocolTape = u;
+type UIScenarioFixture = Omit<z.infer<typeof uiScenarioFixtureSchema>, "protocol" | "replay"> & {
+    readonly protocol: PluginProtocolTape;
     readonly replay: readonly UIScenarioReplayStep[];
 };
 type UIScenarioFixtureBundleIndex = z.infer<typeof uiScenarioFixtureBundleIndexSchema>;
@@ -684,10 +665,144 @@ 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 gameVersion: number;
+        readonly actionSetVersion: string;
+        readonly perspectivePlayerId: string | null;
+    };
+    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 UIParityViewport {
+    readonly width: number;
+    readonly height: number;
+}
+interface UIParityObservationEnvironmentV1 {
+    readonly project: string;
+    readonly viewport: UIParityViewport;
+}
+interface UIParityDiagnosticV1 {
+    readonly code: string;
+    readonly message: string;
+}
+interface UIParityObservationCheckpointV1 {
+    readonly stepId: string;
+    readonly interactionKey?: string;
+    readonly interactionId?: string;
+    readonly actuatorId?: string;
+    readonly descriptorDigest?: string;
+    readonly draftDigest?: string;
+    readonly gameVersion: number;
+    readonly actionSetVersion: string;
+    readonly perspectivePlayerId: string | null;
+    readonly projectionDigest: string;
+    readonly semanticDigest: string;
+    readonly submissionDigest?: string;
+    readonly screenshot?: string;
+}
+interface UIParityObservationV1 {
+    readonly schemaVersion: 1;
+    readonly scenarioId: string;
+    readonly fixtureDigest: string;
+    readonly sdkCandidateDigest: string;
+    readonly pluginRuntimeProtocol: 3;
+    readonly browserInteractionProtocol: string;
+    readonly environment: UIParityObservationEnvironmentV1;
+    readonly checkpoints: readonly UIParityObservationCheckpointV1[];
+    readonly diagnostics: readonly UIParityDiagnosticV1[];
+}
+type UIParityFailureCode = "candidate-mismatch" | "fixture-source-mismatch" | "protocol-mismatch" | "interaction-resolution-mismatch" | "preparation-mismatch" | "draft-mismatch" | "submission-mismatch" | "projection-mismatch" | "semantic-snapshot-mismatch" | "visual-mismatch" | "host-setup-failure";
+interface UIParityComparisonFailure {
+    readonly code: UIParityFailureCode;
+    readonly message: string;
+    readonly path: string;
+    readonly expected: unknown;
+    readonly actual: unknown;
+    readonly checkpointIndex?: number;
+    readonly stepId?: string;
+}
+type UIParityComparisonResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly failure: UIParityComparisonFailure;
+};
+interface CreateUIParityObservationFromFixtureOptions {
+    readonly fixture: UIScenarioFixture;
+    readonly sdkCandidateDigest: string;
+    readonly environment: UIParityObservationEnvironmentV1;
+    readonly fixtureDigest?: string;
+    readonly screenshotsByStepId?: Readonly<Record<string, string>>;
+    readonly diagnostics?: readonly UIParityDiagnosticV1[];
+}
+declare function createUIParityObservationFromFixture({ fixture, sdkCandidateDigest, environment, fixtureDigest, screenshotsByStepId, diagnostics, }: CreateUIParityObservationFromFixtureOptions): UIParityObservationV1;
+declare function parseUIParityObservationV1(value: unknown): UIParityObservationV1;
+declare function compareUIParityObservations(expected: UIParityObservationV1, actual: UIParityObservationV1): UIParityComparisonResult;
+
+interface FixtureHostEvent {
+    readonly sequence: number;
+    readonly atMs: number;
+    readonly kind: "frame-sent" | "validate-received" | "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: u;
+    reset(): void;
+    flush(): Promise<void>;
+    advanceHost(): Promise<void>;
+    getCurrentFrameId(): string;
+    getEvents(): readonly FixtureHostEvent[];
+    assertConsumed(): void;
+}
+interface CreateFixtureHostHarnessOptions {
+    readonly tape: u;
+    readonly strict?: boolean;
+    readonly latencyMs?: number;
+    readonly channelId?: string;
+    readonly onEvent?: (event: FixtureHostEvent) => void;
+    readonly nowMs?: () => number;
+}
+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;
+
+interface CompilePluginProtocolTapeOptions {
+    readonly trace: ReducerScenarioTrace;
+    readonly session: v;
+}
+declare function compilePluginProtocolTape(options: CompilePluginProtocolTapeOptions): PluginProtocolTape;
+
+interface FixtureEnvironmentInit {
+    readonly clockIso: string;
+    readonly randomSeed: string;
+    readonly locale: "en-US";
+    readonly timezone: "UTC";
+    readonly reducedMotion: true;
+    readonly network: "blocked";
+}
+declare const defaultFixtureEnvironmentInit: FixtureEnvironmentInit;
+type DeterministicIdFactory = () => string;
+declare function createDeterministicIdFactory(seed: string): DeterministicIdFactory;
+declare function fixtureEnvironmentInitFor(options: {
+    readonly clockIso: string;
+    readonly randomSeed: string;
+}): FixtureEnvironmentInit;
+
 interface CompileUIScenarioFixtureOptions {
     readonly id: string;
     readonly title: string;
@@ -696,8 +811,7 @@ interface CompileUIScenarioFixtureOptions {
     readonly source: UIScenarioFixture["source"];
     readonly viewer: UIScenarioFixture["viewer"];
     readonly environment: UIScenarioFixture["environment"];
-    readonly frames: readonly UIFixtureFrame[];
-    readonly transport?: readonly UIFixtureTransportExchange[];
+    readonly protocol: PluginProtocolTape;
     readonly replay?: readonly UIScenarioReplayStep[];
     readonly expected?: Partial<UIScenarioFixture["expected"]>;
 }
@@ -707,4 +821,4 @@ declare function assertDeterministicUIScenarioFixture(first: UIScenarioFixture,
 declare function assertUniqueReplayIdentity(step: Pick<PortableSemanticReplayStep, "stepId" | "expectedIdentity">, candidates: readonly UIReplayIdentityCandidate[]): UIReplayIdentityCandidate;
 declare function assertUIStepExpectationSatisfied(stepId: string, expected: UIStepExpectation, actual: UIStepExpectation): void;
 
-export { type BaseContext, type BaseDefinition, type CompileUIScenarioFixtureOptions, type CreateTestRuntimeOptions, type CreatedTestRuntime, type ExpectFn, type ExpectMatchers, type InteractionAvailabilityLike, type InteractionDescriptorLike, type InteractionExplanationLike, type PortableSemanticReplayStep, type RejectionExpectation, type ScenarioDefinition, type SharedScenarioContext, type SnapshotMatcherHandler, type TestRunner, type UIFixtureFrame, type UIFixtureTransportExchange, type UIReplayExecution, type UIReplayIdentityCandidate, type UIReplayRequest, type UIResolvedReplayIdentity, type UIScenarioFixture, type UIScenarioFixtureBundleIndex, type UIScenarioReplayStep, type UIStepExpectation, UI_SCENARIO_FIXTURE_BUNDLE_SCHEMA_VERSION, UI_SCENARIO_FIXTURE_SCHEMA_VERSION, UI_SCENARIO_FIXTURE_SUPPORTED_BROWSER_PROTOCOL_MAJOR, assertDeterministicUIScenarioFixture, assertSupportedBrowserInteractionProtocol, assertUIStepExpectationSatisfied, assertUniqueReplayIdentity, canonicalUIFixtureJson, canonicalizeUIFixtureJson, canonicalizeUIScenarioFixture, compileUIScenarioFixture, createExpectApi, createTestRuntime, defineBase, defineScenario, digestUIFixtureJson, digestUIFixtureRequest, digestUIScenarioFixture, isSha256Digest, parseUIScenarioFixture, parseUIScenarioFixtureBundleIndex, portableSemanticReplayStepSchema, serializeUIScenarioFixture, uiFixtureFrameSchema, uiFixturePluginStateSnapshotSchema, uiFixtureTransportExchangeSchema, uiReplayExecutionSchema, uiReplayRequestSchema, uiResolvedReplayIdentitySchema, uiScenarioFixtureBundleIndexSchema, uiScenarioFixtureSchema, uiScenarioReplayStepSchema, uiStepExpectationSchema };
+export { type BaseContext, type BaseDefinition, type CompilePluginProtocolTapeOptions, type CompileUIScenarioFixtureOptions, type CreateFixtureHostHarnessOptions, type CreateReducerScenarioRunnerOptions, type CreateTestRuntimeOptions, type CreatedTestRuntime, type DeterministicIdFactory, type ExpectFn, type ExpectMatchers, type FixtureEnvironmentInit, type FixtureHostEvent, type FixtureHostHarness, FixturePluginRuntime, type InteractionAvailabilityLike, type InteractionDescriptorLike, type InteractionExplanationLike, type PluginProtocolTape, type PortableSemanticReplayStep, type ReducerScenarioBundle, type ReducerScenarioDiagnostic, type ReducerScenarioExchange, type ReducerScenarioFrame, type ReducerScenarioOperation, type ReducerScenarioRunner, type ReducerScenarioTrace, type ReducerScenarioViewer, type RejectionExpectation, type ScenarioDefinition, type SharedScenarioContext, type SnapshotMatcherHandler, type TestRunner, type UIFixtureFrame, type UIFixtureProtocolStep, type UIReplayExecution, type UIReplayIdentityCandidate, type UIReplayRequest, type UIResolvedReplayIdentity, 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, assertDeterministicUIScenarioFixture, assertSupportedBrowserInteractionProtocol, assertUIStepExpectationSatisfied, assertUniqueReplayIdentity, canonicalUIFixtureJson, canonicalizeUIFixtureJson, canonicalizeUIScenarioFixture, compareUIParityObservations, compilePluginProtocolTape, compileUIScenarioFixture, createDeterministicIdFactory, createExpectApi, createFixtureHostHarness, createReducerScenarioRunner, createTestRuntime, createUIParityObservationFromFixture, defaultFixtureEnvironmentInit, defineBase, defineScenario, digestPluginProtocolTape, digestUIFixtureJson, digestUIFixtureRequest, digestUIFixtureTransportRequest, digestUIScenarioFixture, fixtureEnvironmentInitFor, isSha256Digest, parseUIParityObservationV1, parseUIScenarioFixture, parseUIScenarioFixtureBundleIndex, pluginProtocolTapeSchema, portableSemanticReplayStepSchema, serializeUIScenarioFixture, uiFixtureFrameSchema, uiFixtureProtocolStepSchema, uiReplayExecutionSchema, uiReplayRequestSchema, uiResolvedReplayIdentitySchema, uiScenarioFixtureBundleIndexSchema, uiScenarioFixtureSchema, uiScenarioReplayStepSchema, uiStepExpectationSchema };