@dreamboard-games/sdk 0.4.0-alpha.7 → 0.4.0-alpha.9

package/dist/testing.js

@@ -1,24 +1,26 @@
 import {
   PluginRuntimeBoundary,
   createPluginRuntimeClient
-} from "./chunk-3QIZKXJ2.js";
-import "./chunk-VLG4YST5.js";
-import {
-  BROWSER_INTERACTION_ACTUATOR_KINDS,
-  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
-  browserInteractionEffectSchema
-} from "./chunk-WHR5UW3F.js";
-import {
-  RuntimeJsonSchema
-} from "./chunk-PF7L4BMG.js";
+} from "./chunk-NGYFBNBP.js";
+import "./chunk-GMOBG7Y7.js";
 import {
+  ScenarioAssertionError,
+  ScenarioDefinitionValidationError,
+  ScenarioReplayError,
+  advanceScenarioReplay,
+  assertScenario,
+  compareCanonicalScenarioJson,
   createExpectApi,
-  createTestRuntime
-} from "./chunk-IU6KGPY7.js";
-import {
-  StaleContractArtifactError,
-  isStaleContractArtifactError
-} from "./chunk-3OZMHZK3.js";
+  createScenarioAuthoring,
+  digestScenarioJson,
+  enumerateScenarioInteractionParams,
+  inspectScenarioReplayAuthority,
+  probeScenarioCommand,
+  projectScenarioCommandParams,
+  replayScenario,
+  toScenarioReplayDefinition
+} from "./chunk-L3W2FPRQ.js";
+import "./chunk-5XTAQ4EQ.js";
 import {
   DREAMBOARD_PLUGIN_PROTOCOL,
   DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
@@ -26,21 +28,627 @@ import {
   PluginProtocolStepSchema,
   PluginProtocolTapeSchema,
   computePluginActionSetVersion,
+  digestPluginRuntimeJson,
   materializePluginGameplayFrame
-} from "./chunk-5IHU5CUK.js";
+} from "./chunk-QQNL4WTX.js";
+import {
+  BROWSER_INTERACTION_ACTUATOR_KINDS,
+  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
+  browserInteractionEffectSchema
+} from "./chunk-WHR5UW3F.js";
+import {
+  StaleContractArtifactError,
+  isStaleContractArtifactError
+} from "./chunk-XDGRC6OR.js";
+import "./chunk-YNW3KBDE.js";
+import {
+  RuntimeJsonSchema
+} from "./chunk-PF7L4BMG.js";
+import "./chunk-3PFDHTR7.js";
 import "./chunk-PZ5AY32C.js";
 
-// src/testing/definitions.ts
-function defineBase(definition) {
-  return definition;
+// src/testing/inspection/flow-diagnostic.ts
+function createFlowDiagnostic(options) {
+  const actor = (playerId) => {
+    const seat = options.playerIds.indexOf(playerId);
+    return seat < 0 ? null : { seat, playerId };
+  };
+  const actors = (playerIds) => [...new Set(playerIds)].flatMap((playerId) => {
+    const resolved = actor(playerId);
+    return resolved ? [resolved] : [];
+  }).sort((left, right) => left.seat - right.seat);
+  const blockedBy = (options.scheduler.continuationDependencies ?? []).flatMap((dependency) => {
+    const waiter = actor(dependency.waiterPlayerId);
+    const blockers = actors(dependency.blockerPlayerIds);
+    return waiter && blockers.length > 0 ? [
+      {
+        actor: waiter,
+        blockers,
+        source: "scheduler"
+      }
+    ] : [];
+  }).sort((left, right) => left.actor.seat - right.actor.seat);
+  return {
+    phase: options.scheduler.phase,
+    step: options.scheduler.step,
+    activeActors: actors(options.scheduler.activePlayerIds),
+    pendingActors: actors(options.scheduler.pendingPlayerIds),
+    continuationWaiters: actors(
+      blockedBy.map((dependency) => dependency.actor.playerId)
+    ),
+    blockedBy
+  };
+}
+
+// src/testing/inspection/inspect-scenario.ts
+var ScenarioInspectionError = class extends Error {
+  code;
+  context;
+  constructor(options) {
+    super(options.message);
+    this.name = "ScenarioInspectionError";
+    this.code = options.code;
+    this.context = options.context ?? {};
+  }
+};
+async function inspectScenario(options) {
+  assertScenarioIdentity(options.identity, options.scenario);
+  assertSeed(options.seed);
+  const selectedScenario = options.seed === void 0 ? options.scenario : {
+    ...options.scenario,
+    setup: { ...options.scenario.setup, seed: options.seed }
+  };
+  const checkpoint = options.at ?? {
+    segment: "given",
+    completed: selectedScenario.given.length
+  };
+  const replay = await replayScenario({
+    game: options.game,
+    scenario: selectedScenario,
+    at: checkpoint
+  });
+  const node = inspectScenarioReplayNode({
+    replay,
+    perspective: options.perspective
+  });
+  return {
+    schemaVersion: 1,
+    scenario: structuredClone(options.identity),
+    node,
+    seedSource: options.seed === void 0 ? "scenario" : "override"
+  };
+}
+function inspectScenarioReplayNode(options) {
+  const baseAuthority = inspectScenarioReplayAuthority({
+    replay: options.replay,
+    perspective: { kind: "spectator" }
+  });
+  const perspective = resolvePerspective(
+    options.perspective,
+    baseAuthority.scenario.setup.players,
+    baseAuthority.playerIds
+  );
+  const authority = inspectScenarioReplayAuthority({
+    replay: options.replay,
+    perspective: perspective.kind === "spectator" ? perspective : { kind: "player", seat: perspective.actor.seat }
+  });
+  const actor = perspective.kind === "player" ? perspective.actor : null;
+  const interactions = actor ? authority.interactions.map(
+    ({ descriptor, explanation }) => inspectInteraction(actor, descriptor, explanation)
+  ) : [];
+  const actions = actor ? authority.interactions.flatMap(
+    ({ explanation, actionability }) => {
+      if (!actionability.found || !actionability.visible || actionability.descriptor.availability.status !== "available" || actionability.inputSatisfiability?.status !== "yes") {
+        return [];
+      }
+      return [
+        {
+          actor,
+          interactionId: actionability.descriptor.interactionId,
+          inputs: explanation.inputs,
+          explanation,
+          hasConcreteCommand: true
+        }
+      ];
+    }
+  ) : [];
+  const node = {
+    checkpoint: authority.checkpoint,
+    checkpointDigest: authority.checkpointDigest,
+    setup: structuredClone(authority.scenario.setup),
+    flow: createFlowDiagnostic({
+      playerIds: authority.playerIds,
+      scheduler: authority.scheduler
+    }),
+    perspective,
+    publicState: authority.publicState,
+    view: authority.view,
+    interactions,
+    actions,
+    entropy: {
+      seed: authority.entropy.seed ?? authority.scenario.setup.seed,
+      draws: structuredClone(authority.entropy.draws)
+    },
+    dispatchTrace: projectDispatchTrace(
+      authority.commandTrace,
+      authority.playerIds,
+      perspective
+    )
+  };
+  return node;
+}
+function resolvePerspective(selector, playerCount, declaredPlayerIds) {
+  if (selector.kind === "spectator") return { kind: "spectator" };
+  const seat = selector.seat;
+  if (!Number.isSafeInteger(seat) || seat < 0 || seat >= playerCount) {
+    throw new ScenarioInspectionError({
+      code: "TEST_PERSPECTIVE_INVALID",
+      message: `Perspective seat ${String(seat)} is outside this ${playerCount}-player scenario.`,
+      context: {
+        requestedSeat: seat,
+        minimumSeat: 0,
+        maximumSeat: Math.max(0, playerCount - 1)
+      }
+    });
+  }
+  return {
+    kind: "player",
+    actor: {
+      seat,
+      playerId: declaredPlayerIds[seat] ?? `player-${seat + 1}`
+    }
+  };
+}
+function inspectInteraction(actor, descriptor, explanation) {
+  const availability = descriptor.availability ?? {
+    status: "blocked",
+    reason: "Interaction descriptor has no availability."
+  };
+  return {
+    actor,
+    interactionId: String(descriptor.interactionId ?? ""),
+    availability: {
+      status: availability.status,
+      ..."code" in availability && typeof availability.code === "string" ? { code: availability.code } : {},
+      ..."reason" in availability && typeof availability.reason === "string" ? { reason: availability.reason } : {}
+    },
+    inputs: explanation.inputs,
+    explanation
+  };
+}
+function projectDispatchTrace(commandTrace, playerIds, perspective) {
+  if (perspective.kind === "spectator") return [];
+  const selectedSeat = perspective.actor.seat;
+  return commandTrace.flatMap((entry) => {
+    if (entry.command.actor.seat !== selectedSeat) return [];
+    return entry.trace.flatMap((trace) => {
+      switch (trace.kind) {
+        case "acceptedClientInput": {
+          const seat = playerIds.indexOf(trace.playerId);
+          return seat < 0 ? [] : [
+            {
+              kind: "acceptedCommand",
+              actor: { seat, playerId: trace.playerId },
+              interactionId: trace.interactionId
+            }
+          ];
+        }
+        case "appliedInstruction":
+          return [
+            {
+              kind: "appliedInstruction",
+              instructionKind: trace.instruction
+            }
+          ];
+        case "rngConsumption":
+          return [{ kind: "entropyDraw", drawIndex: trace.drawIndex }];
+      }
+    });
+  });
+}
+function assertScenarioIdentity(identity, scenario) {
+  if (identity.id !== scenario.id) {
+    throw new ScenarioInspectionError({
+      code: "TEST_SCENARIO_INVALID",
+      message: "Scenario identity does not match the authored default export.",
+      context: { identityId: identity.id, scenarioId: scenario.id }
+    });
+  }
 }
-function defineScenario(definition) {
-  return definition;
+function assertSeed(seed) {
+  if (seed !== void 0 && !Number.isSafeInteger(seed)) {
+    throw new ScenarioInspectionError({
+      code: "TEST_SEED_RANGE_INVALID",
+      message: "Seed override must be a safe integer.",
+      context: { requestedSeed: seed }
+    });
+  }
+}
+
+// src/testing/exploration/cursor.ts
+import { Buffer } from "buffer";
+var CURSOR_VERSION = 1;
+var ExploreCursorError = class extends Error {
+  code = "TEST_EXPLORE_CURSOR_STALE";
+  scenarioSourceDigest;
+  checkpointDigest;
+  constructor(options) {
+    super("The exploration cursor no longer matches scenario authority.");
+    this.name = "ExploreCursorError";
+    this.scenarioSourceDigest = options.scenarioSourceDigest;
+    this.checkpointDigest = options.checkpointDigest;
+  }
+};
+function createExploreCursor(options) {
+  assertOrdinal(options.nextOrdinal);
+  const payload = {
+    version: CURSOR_VERSION,
+    scenarioSourceDigest: options.scenario.sourceDigest,
+    checkpointDigest: options.checkpointDigest,
+    perspective: options.perspective,
+    seedOverride: options.seedOverride ?? null,
+    nextOrdinal: options.nextOrdinal
+  };
+  const encoded = Buffer.from(JSON.stringify(payload), "utf8").toString(
+    "base64url"
+  );
+  const digest = digestPluginRuntimeJson(payload).slice("sha256:".length);
+  return `dbx1.${encoded}.${digest}`;
+}
+function readExploreCursor(options) {
+  const stale = () => {
+    throw new ExploreCursorError({
+      scenarioSourceDigest: options.scenario.sourceDigest,
+      checkpointDigest: options.checkpointDigest
+    });
+  };
+  const [prefix, encoded, digest, extra] = options.cursor.split(".");
+  if (prefix !== "dbx1" || !encoded || !digest || extra !== void 0) stale();
+  let payload;
+  try {
+    payload = JSON.parse(
+      Buffer.from(encoded, "base64url").toString("utf8")
+    );
+  } catch {
+    return stale();
+  }
+  if (digestPluginRuntimeJson(payload).slice("sha256:".length) !== digest || payload.version !== CURSOR_VERSION || payload.scenarioSourceDigest !== options.scenario.sourceDigest || payload.checkpointDigest !== options.checkpointDigest || payload.seedOverride !== (options.seedOverride ?? null) || JSON.stringify(payload.perspective) !== JSON.stringify(options.perspective)) {
+    return stale();
+  }
+  assertOrdinal(payload.nextOrdinal);
+  return payload.nextOrdinal;
+}
+function assertOrdinal(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(
+      "Explore cursor ordinal must be a non-negative safe integer."
+    );
+  }
+}
+
+// src/testing/exploration/explore-scenario.ts
+var DEFAULT_EXPLORE_LIMIT = 50;
+var MAX_EXPLORE_LIMIT = 200;
+var DEFAULT_EXPLORE_EVALUATIONS = 5e3;
+var MAX_EXPLORE_EVALUATIONS = 1e5;
+var MAX_EXPLORE_SEEDS = 64;
+var ScenarioExploreError = class extends Error {
+  code;
+  context;
+  constructor(options) {
+    super(options.message);
+    this.name = "ScenarioExploreError";
+    this.code = options.code;
+    this.context = options.context;
+  }
+};
+async function exploreScenario(options) {
+  if (options.seedRange) {
+    if (options.seed !== void 0 || options.cursor !== void 0 || options.limit !== void 0) {
+      throw new ScenarioExploreError({
+        code: "TEST_SEED_RANGE_INVALID",
+        message: "Seed-range exploration cannot be combined with a seed override, cursor, or transition-page limit.",
+        context: { start: options.seedRange.start, end: options.seedRange.end }
+      });
+    }
+    return exploreSeeds(options, options.seedRange);
+  }
+  return exploreTransitions(options);
+}
+async function exploreTransitions(options) {
+  const limit = options.limit ?? DEFAULT_EXPLORE_LIMIT;
+  const maxEvaluations = options.maxEvaluations ?? DEFAULT_EXPLORE_EVALUATIONS;
+  assertTransitionLimits(limit, maxEvaluations);
+  const selectedScenario = scenarioWithSeed(options.scenario, options.seed);
+  const checkpoint = defaultCheckpoint(selectedScenario, options.at);
+  const replay = await replayScenario({
+    game: options.game,
+    scenario: selectedScenario,
+    at: checkpoint
+  });
+  const node = inspectScenarioReplayNode({
+    replay,
+    perspective: options.perspective
+  });
+  const startOrdinal = options.cursor ? readExploreCursor({
+    cursor: options.cursor,
+    scenario: options.identity,
+    checkpointDigest: node.checkpointDigest,
+    perspective: node.perspective,
+    seedOverride: options.seed
+  }) : 0;
+  if (node.perspective.kind === "spectator") {
+    return {
+      schemaVersion: 1,
+      mode: "transitions",
+      scenario: options.identity,
+      perspective: node.perspective,
+      node,
+      candidates: [],
+      omissions: [],
+      page: {
+        limit,
+        evaluated: 0,
+        truncated: false,
+        nextCursor: null
+      }
+    };
+  }
+  const accepted = [];
+  const omissions = [];
+  let evaluated = 0;
+  for (const action of node.actions) {
+    const remaining = maxEvaluations - evaluated;
+    if (remaining <= 0) {
+      omissions.push({
+        actor: action.actor,
+        interactionId: action.interactionId,
+        code: "INPUT_DOMAIN_BUDGET"
+      });
+      continue;
+    }
+    const enumeration = enumerateScenarioInteractionParams({
+      replay,
+      seat: action.actor.seat,
+      interactionId: action.interactionId,
+      maxEvaluations: remaining
+    });
+    if (!enumeration.found || !enumeration.visible || !enumeration.enumeration) {
+      continue;
+    }
+    evaluated += enumeration.enumeration.evaluated;
+    if (enumeration.enumeration.status !== "enumerated") {
+      omissions.push({
+        actor: action.actor,
+        interactionId: action.interactionId,
+        code: enumeration.enumeration.status === "budget" ? "INPUT_DOMAIN_BUDGET" : "INPUT_DOMAIN_NOT_ENUMERABLE",
+        ...enumeration.enumeration.inputKey ? { inputKey: enumeration.enumeration.inputKey } : {}
+      });
+      continue;
+    }
+    const assignments = [...enumeration.enumeration.assignments].sort(
+      compareCanonicalScenarioJson
+    );
+    for (const assignment of assignments) {
+      const command = {
+        actor: { seat: action.actor.seat },
+        interactionId: action.interactionId,
+        params: projectScenarioCommandParams({
+          game: options.game,
+          phase: node.flow.phase,
+          interactionId: action.interactionId,
+          params: assignment,
+          playerIds: node.setup.players ? Array.from(
+            { length: node.setup.players },
+            (_, seat) => options.game.contract.manifest.literals.playerIds[seat] ?? `player-${seat + 1}`
+          ) : [],
+          path: `explore.${action.interactionId}`
+        })
+      };
+      const advanced = await advanceScenarioReplay({
+        replay,
+        command
+      });
+      if (advanced.kind !== "accepted") continue;
+      const afterNode = inspectScenarioReplayNode({
+        replay: advanced.replay,
+        perspective: options.perspective
+      });
+      accepted.push({
+        ordinal: accepted.length,
+        command,
+        after: {
+          checkpointDigest: afterNode.checkpointDigest,
+          flow: afterNode.flow,
+          publicStateDigest: digestScenarioJson(
+            afterNode.publicState
+          ),
+          viewDigest: digestScenarioJson(afterNode.view),
+          actions: afterNode.actions.map(({ actor, interactionId }) => ({
+            actor,
+            interactionId
+          })),
+          entropy: afterNode.entropy,
+          dispatchTrace: afterNode.dispatchTrace
+        }
+      });
+    }
+  }
+  const candidates = accepted.slice(startOrdinal, startOrdinal + limit);
+  const nextOrdinal = startOrdinal + candidates.length;
+  const truncated = nextOrdinal < accepted.length;
+  return {
+    schemaVersion: 1,
+    mode: "transitions",
+    scenario: structuredClone(options.identity),
+    perspective: node.perspective,
+    node,
+    candidates,
+    omissions,
+    page: {
+      limit,
+      evaluated,
+      truncated,
+      nextCursor: truncated ? createExploreCursor({
+        scenario: options.identity,
+        checkpointDigest: node.checkpointDigest,
+        perspective: node.perspective,
+        seedOverride: options.seed,
+        nextOrdinal
+      }) : null
+    }
+  };
+}
+async function exploreSeeds(options, range) {
+  assertSeedRange(range);
+  const checkpoint = defaultCheckpoint(options.scenario, options.at);
+  const variants = [];
+  for (let seed = range.start; seed <= range.end; seed += 1) {
+    try {
+      const inspected = await inspectScenario({
+        game: options.game,
+        scenario: options.scenario,
+        identity: options.identity,
+        perspective: options.perspective,
+        at: checkpoint,
+        seed
+      });
+      const replay = await replayScenario({
+        game: options.game,
+        scenario: scenarioWithSeed(options.scenario, seed),
+        at: checkpoint
+      });
+      const counts = await concreteOptionCounts({
+        replay,
+        node: inspected.node,
+        maxEvaluations: options.maxEvaluations ?? DEFAULT_EXPLORE_EVALUATIONS
+      });
+      variants.push({
+        seed,
+        status: "replayed",
+        checkpointDigest: inspected.node.checkpointDigest,
+        entropy: inspected.node.entropy,
+        observable: {
+          publicState: inspected.node.publicState,
+          view: inspected.node.view
+        },
+        signature: {
+          phase: inspected.node.flow.phase,
+          step: inspected.node.flow.step,
+          actions: inspected.node.actions.map(({ actor, interactionId }) => ({
+            seat: actor.seat,
+            interactionId,
+            concreteOptionCount: counts.get(`${actor.seat}:${interactionId}`) ?? "lazy"
+          }))
+        }
+      });
+    } catch (error) {
+      if (!(error instanceof ScenarioReplayError)) throw error;
+      variants.push({
+        seed,
+        status: "rejected",
+        rejection: {
+          segment: error.segment,
+          sourceIndex: error.index,
+          interactionId: error.interactionId,
+          errorCode: error.errorCode
+        }
+      });
+    }
+  }
+  return {
+    schemaVersion: 1,
+    mode: "seeds",
+    scenario: structuredClone(options.identity),
+    perspective: (await inspectSeedPerspective(options)).node.perspective,
+    checkpoint,
+    variants
+  };
+}
+async function inspectSeedPerspective(options) {
+  return inspectScenario({
+    game: options.game,
+    scenario: options.scenario,
+    identity: options.identity,
+    perspective: options.perspective,
+    at: { segment: "setup", completed: 0 }
+  });
+}
+async function concreteOptionCounts(options) {
+  assertTransitionLimits(DEFAULT_EXPLORE_LIMIT, options.maxEvaluations);
+  const counts = /* @__PURE__ */ new Map();
+  let evaluated = 0;
+  for (const action of options.node.actions) {
+    const remaining = options.maxEvaluations - evaluated;
+    if (remaining <= 0) {
+      counts.set(`${action.actor.seat}:${action.interactionId}`, "lazy");
+      continue;
+    }
+    const result = enumerateScenarioInteractionParams({
+      replay: options.replay,
+      seat: action.actor.seat,
+      interactionId: action.interactionId,
+      maxEvaluations: remaining
+    });
+    if (!result.found || !result.visible || !result.enumeration) continue;
+    evaluated += result.enumeration.evaluated;
+    counts.set(
+      `${action.actor.seat}:${action.interactionId}`,
+      result.enumeration.status === "enumerated" ? result.enumeration.assignments.length : "lazy"
+    );
+  }
+  return counts;
+}
+function scenarioWithSeed(scenario, seed) {
+  return seed === void 0 ? scenario : { ...scenario, setup: { ...scenario.setup, seed } };
+}
+function defaultCheckpoint(scenario, at) {
+  return at ?? {
+    segment: "given",
+    completed: scenario.given.length
+  };
+}
+function assertTransitionLimits(limit, maxEvaluations) {
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_EXPLORE_LIMIT) {
+    throw new ScenarioExploreError({
+      code: "TEST_EXPLORE_LIMIT_INVALID",
+      message: `Explore limit must be between 1 and ${MAX_EXPLORE_LIMIT}.`,
+      context: { requested: limit, minimum: 1, maximum: MAX_EXPLORE_LIMIT }
+    });
+  }
+  if (!Number.isSafeInteger(maxEvaluations) || maxEvaluations < 1 || maxEvaluations > MAX_EXPLORE_EVALUATIONS) {
+    throw new ScenarioExploreError({
+      code: "TEST_EXPLORE_LIMIT_INVALID",
+      message: `Explore max evaluations must be between 1 and ${MAX_EXPLORE_EVALUATIONS}.`,
+      context: {
+        requested: maxEvaluations,
+        minimum: 1,
+        maximum: MAX_EXPLORE_EVALUATIONS
+      }
+    });
+  }
+}
+function assertSeedRange(range) {
+  const width = range.end - range.start + 1;
+  if (!Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start > range.end || !Number.isSafeInteger(width) || width < 1 || width > MAX_EXPLORE_SEEDS) {
+    throw new ScenarioExploreError({
+      code: "TEST_SEED_RANGE_INVALID",
+      message: `Seed range must contain 1 through ${MAX_EXPLORE_SEEDS} inclusive safe-integer seeds.`,
+      context: {
+        start: range.start,
+        end: range.end,
+        maximumWidth: MAX_EXPLORE_SEEDS
+      }
+    });
+  }
 }
 
 // src/testing/ui-fixture/canonical.ts
 import { createHash } from "crypto";
 var sha256DigestPattern = /^sha256:[a-f0-9]{64}$/;
+function compareCanonicalStrings(left, right) {
+  return left === right ? 0 : left < right ? -1 : 1;
+}
 function isSha256Digest(value) {
   return sha256DigestPattern.test(value);
 }
@@ -66,7 +674,7 @@ function canonicalizeUIFixtureJson(value) {
       }
       const entries = Object.entries(value);
       return Object.fromEntries(
-        entries.filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalizeUIFixtureJson(item)])
+        entries.filter(([, item]) => item !== void 0).sort(([left], [right]) => compareCanonicalStrings(left, right)).map(([key, item]) => [key, canonicalizeUIFixtureJson(item)])
       );
     }
   }
@@ -1357,6 +1965,9 @@ function assertStep(stepId, expect) {
 }
 export {
   FixturePluginRuntime,
+  ScenarioAssertionError,
+  ScenarioDefinitionValidationError,
+  ScenarioReplayError,
   StaleContractArtifactError,
   UI_SCENARIO_FIXTURE_BUNDLE_SCHEMA_VERSION,
   UI_SCENARIO_FIXTURE_PLUGIN_RUNTIME_PROTOCOL,
@@ -1364,6 +1975,7 @@ export {
   UI_SCENARIO_FIXTURE_SUPPORTED_BROWSER_PROTOCOL_MAJOR,
   activate,
   assertDeterministicUIScenarioFixture,
+  assertScenario,
   assertStep,
   assertSupportedBrowserInteractionProtocol,
   assertUIStepExpectationSatisfied,
@@ -1378,11 +1990,9 @@ export {
   createExpectApi,
   createFixtureHostHarness,
   createReducerScenarioRunner,
-  createTestRuntime,
+  createScenarioAuthoring,
   createUIParityObservationFromFixture,
   defaultFixtureEnvironmentInit,
-  defineBase,
-  defineScenario,
   defineUIScenario,
   digestPluginProtocolTape,
   digestUIFixtureJson,
@@ -1390,8 +2000,10 @@ export {
   digestUIFixtureTransportRequest,
   digestUIScenarioFixture,
   drag,
+  exploreScenario,
   fill,
   fixtureEnvironmentInitFor,
+  inspectScenario,
   isSha256Digest,
   isStaleContractArtifactError,
   parseUIParityObservationV1,
@@ -1400,8 +2012,11 @@ export {
   pluginProtocolTapeSchema,
   portableSemanticReplayStepSchema,
   press,
+  probeScenarioCommand,
+  replayScenario,
   serializeUIScenarioFixture,
   submit,
+  toScenarioReplayDefinition,
   uiFixtureFrameSchema,
   uiFixtureProtocolStepSchema,
   uiReplayExecutionSchema,