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

package/dist/testing-compiler.d.ts

@@ -0,0 +1,36 @@
+import { h as ScenarioCheckpoint, m as ScenarioDefinitionGameLike, v as ScenarioReplayDefinition } from './definitions-0kjPV9wh.js';
+import 'zod';
+import './views-DE2eZxPz.js';
+import './runtime-B_w9AO2n.js';
+import './types.js';
+import './diagnostics-DIi3ina7.js';
+
+type CompiledScenarioReplay<Game extends ScenarioDefinitionGameLike = ScenarioDefinitionGameLike> = {
+    readonly schemaVersion: 1;
+    readonly scenario: {
+        readonly path: string;
+        /** Covers the local game/scenario module graph, including assertions. */
+        readonly sourceDigest: `sha256:${string}`;
+    };
+    /** Canonical serializable scenario projection; never contains `then`. */
+    readonly definition: ScenarioReplayDefinition<Game>;
+    readonly checkpoint: ScenarioCheckpoint;
+    readonly expected: {
+        readonly checkpointDigest: `sha256:${string}`;
+        readonly publicProjectionDigest: `sha256:${string}`;
+    };
+};
+type CompileScenarioReplayOptions = {
+    readonly scenarioPath: string;
+    readonly at?: ScenarioCheckpoint;
+};
+/**
+ * Compile one authored scenario into the trusted, serializable replay DTO used
+ * by dev-host, Workbench, demo, and performance adapters.
+ *
+ * The DTO may contain sealed/private command parameters. It must never cross a
+ * player, spectator, browser, ordinary-log, or public-receipt boundary.
+ */
+declare function compileScenarioReplay(options: CompileScenarioReplayOptions): Promise<CompiledScenarioReplay>;
+
+export { type CompileScenarioReplayOptions, type CompiledScenarioReplay, compileScenarioReplay };

package/dist/testing-compiler.js

@@ -0,0 +1,236 @@
+import {
+  compareReferenceGameCanonicalStrings
+} from "./chunk-UNVCT5Z7.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/testing/compile-scenario-replay.ts
+import { createHash } from "crypto";
+import {
+  lstat,
+  mkdtemp,
+  readFile,
+  realpath,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+import { pathToFileURL } from "url";
+import { build } from "esbuild";
+var scenarioSourceDigestVersion = "dreamboard-scenario-source-closure@1";
+var syntheticSourceFile = "__dreamboard_compile_scenario_replay__.ts";
+async function compileScenarioReplay(options) {
+  const source = await resolveScenarioSource(options.scenarioPath);
+  const syntheticSource = buildSyntheticSource(source);
+  const bundled = await build({
+    absWorkingDir: source.projectRoot,
+    stdin: {
+      contents: syntheticSource,
+      loader: "ts",
+      resolveDir: source.projectRoot,
+      sourcefile: syntheticSourceFile
+    },
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node24",
+    sourcemap: "inline",
+    metafile: true,
+    write: false,
+    logLevel: "silent"
+  });
+  const output = bundled.outputFiles?.[0];
+  if (!output || !bundled.metafile) {
+    throw new Error("Scenario replay compilation did not produce a bundle.");
+  }
+  const sourceDigest = await digestSourceClosure({
+    projectRoot: source.projectRoot,
+    inputPaths: Object.keys(bundled.metafile.inputs)
+  });
+  const tempRoot = await mkdtemp(
+    path.join(tmpdir(), "dreamboard-compiled-scenario-")
+  );
+  const outputPath = path.join(tempRoot, "compiled-scenario.mjs");
+  try {
+    await writeFile(outputPath, output.text);
+    const loaded = await import(`${pathToFileURL(outputPath).href}?source=${sourceDigest.slice(7, 19)}`);
+    if (typeof loaded.compile !== "function") {
+      throw new Error("Scenario replay bundle is missing compile().");
+    }
+    const materialized = await loaded.compile({
+      ...options.at === void 0 ? {} : { at: options.at },
+      scenarioPath: source.relativeScenarioPath,
+      sourceDigest
+    });
+    const compiled = {
+      schemaVersion: 1,
+      scenario: {
+        path: source.relativeScenarioPath,
+        sourceDigest
+      },
+      definition: materialized.definition,
+      checkpoint: materialized.checkpoint,
+      expected: materialized.expected
+    };
+    return assertSerializableCompiledReplay(compiled);
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}
+async function resolveScenarioSource(requestedPath) {
+  if (typeof requestedPath !== "string" || requestedPath.length === 0) {
+    throw new Error("scenarioPath must be a non-empty string.");
+  }
+  const requestedAbsolute = path.resolve(process.cwd(), requestedPath);
+  const requestedStats = await lstat(requestedAbsolute).catch((error) => {
+    if (isMissingPathError(error)) return null;
+    throw error;
+  });
+  if (!requestedStats?.isFile()) {
+    throw new Error(`Scenario path does not name a file: ${requestedPath}.`);
+  }
+  const scenarioPath = await realpath(requestedAbsolute);
+  const projectRoot = await findProjectRoot(path.dirname(scenarioPath));
+  const canonicalProjectRoot = await realpath(projectRoot);
+  const scenarioRoot = path.join(canonicalProjectRoot, "test", "scenarios");
+  const canonicalScenarioRoot = await realpath(scenarioRoot).catch((error) => {
+    if (isMissingPathError(error)) return null;
+    throw error;
+  });
+  if (canonicalScenarioRoot === null || !isWithinDirectory(canonicalScenarioRoot, scenarioPath) || !scenarioPath.endsWith(".scenario.ts")) {
+    throw new Error(
+      "scenarioPath must resolve to test/scenarios/**/*.scenario.ts inside one game package."
+    );
+  }
+  const gamePath = path.join(canonicalProjectRoot, "app", "game.ts");
+  if (!await isFile(gamePath)) {
+    throw new Error(`Game package is missing ${gamePath}.`);
+  }
+  return {
+    projectRoot: canonicalProjectRoot,
+    scenarioPath,
+    relativeScenarioPath: toPosix(
+      path.relative(canonicalProjectRoot, scenarioPath)
+    ),
+    gamePath
+  };
+}
+async function findProjectRoot(start) {
+  let current = path.resolve(start);
+  for (; ; ) {
+    if (await isFile(path.join(current, "package.json")) && await isFile(path.join(current, "app", "game.ts"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      throw new Error(
+        "Could not find a game package containing package.json and app/game.ts."
+      );
+    }
+    current = parent;
+  }
+}
+function buildSyntheticSource(source) {
+  const gameSpecifier = localImportSpecifier(
+    source.projectRoot,
+    source.gamePath
+  );
+  const scenarioSpecifier = localImportSpecifier(
+    source.projectRoot,
+    source.scenarioPath
+  );
+  return [
+    `import * as gameModule from ${JSON.stringify(gameSpecifier)};`,
+    `import * as scenarioModule from ${JSON.stringify(scenarioSpecifier)};`,
+    'import { inspectScenario, toScenarioReplayDefinition } from "@dreamboard-games/sdk/testing";',
+    'import { digestScenarioProjection, scenarioProjectionParityFromInspectNode } from "@dreamboard-games/sdk/testing-runtime";',
+    "const game = gameModule.game ?? gameModule.default;",
+    "const scenario = scenarioModule.scenario ?? scenarioModule.default;",
+    "export async function compile(options) {",
+    "  if (!game || !scenario) {",
+    '    throw new Error("Compiled scenario entry is missing game or scenario authority.");',
+    "  }",
+    "  const definition = toScenarioReplayDefinition(scenario);",
+    "  const inspected = await inspectScenario({",
+    "    game,",
+    "    scenario: definition,",
+    "    identity: {",
+    "      id: definition.id,",
+    "      path: options.scenarioPath,",
+    "      sourceDigest: options.sourceDigest,",
+    "    },",
+    '    perspective: { kind: "spectator" },',
+    "    ...(options.at === undefined ? {} : { at: options.at }),",
+    "  });",
+    "  return {",
+    "    definition,",
+    "    checkpoint: inspected.node.checkpoint,",
+    "    expected: {",
+    "      checkpointDigest: inspected.node.checkpointDigest,",
+    "      publicProjectionDigest: digestScenarioProjection(",
+    "        scenarioProjectionParityFromInspectNode(inspected.node),",
+    "      ),",
+    "    },",
+    "  };",
+    "}"
+  ].join("\n");
+}
+async function digestSourceClosure(options) {
+  const syntheticPath = path.resolve(options.projectRoot, syntheticSourceFile);
+  const localPaths = options.inputPaths.map(
+    (inputPath) => path.isAbsolute(inputPath) ? inputPath : path.resolve(options.projectRoot, inputPath)
+  ).filter(
+    (inputPath) => inputPath !== syntheticPath && isWithinDirectory(options.projectRoot, inputPath) && !toPosix(path.relative(options.projectRoot, inputPath)).split("/").includes("node_modules")
+  );
+  const inputs = await Promise.all(
+    [...new Set(localPaths)].map(async (inputPath) => {
+      const content = await readFile(inputPath);
+      return {
+        path: toPosix(path.relative(options.projectRoot, inputPath)),
+        sha256: createHash("sha256").update(content).digest("hex")
+      };
+    })
+  );
+  inputs.sort(
+    (left, right) => compareReferenceGameCanonicalStrings(left.path, right.path)
+  );
+  return `sha256:${createHash("sha256").update(
+    JSON.stringify({
+      digestVersion: scenarioSourceDigestVersion,
+      inputs
+    })
+  ).digest("hex")}`;
+}
+function assertSerializableCompiledReplay(value) {
+  const serialized = JSON.stringify(value);
+  const parsed = JSON.parse(serialized);
+  if (parsed.schemaVersion !== 1 || !/^sha256:[a-f0-9]{64}$/.test(parsed.scenario.sourceDigest) || !/^sha256:[a-f0-9]{64}$/.test(parsed.expected.checkpointDigest) || !/^sha256:[a-f0-9]{64}$/.test(parsed.expected.publicProjectionDigest)) {
+    throw new Error("Compiled scenario replay failed digest validation.");
+  }
+  return parsed;
+}
+function localImportSpecifier(projectRoot, filePath) {
+  const relative = toPosix(path.relative(projectRoot, filePath));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function isWithinDirectory(directory, filePath) {
+  const relative = path.relative(directory, filePath);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+async function isFile(filePath) {
+  return stat(filePath).then((value) => value.isFile()).catch((error) => {
+    if (isMissingPathError(error)) return false;
+    throw error;
+  });
+}
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function toPosix(value) {
+  return value.split(path.sep).join("/");
+}
+export {
+  compileScenarioReplay
+};
+//# sourceMappingURL=testing-compiler.js.map

package/dist/testing-compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/testing/compile-scenario-replay.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport {\n  lstat,\n  mkdtemp,\n  readFile,\n  realpath,\n  rm,\n  stat,\n  writeFile,\n} from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport path from \"node:path\";\nimport { compareReferenceGameCanonicalStrings } from \"../reference-games/canonical.js\";\nimport { pathToFileURL } from \"node:url\";\nimport { build } from \"esbuild\";\nimport type {\n  ScenarioCheckpoint,\n  ScenarioReplayDefinition,\n} from \"./definitions.js\";\nimport type { ScenarioDefinitionGameLike } from \"./scenario-definition-validation.js\";\n\nexport type CompiledScenarioReplay<\n  Game extends ScenarioDefinitionGameLike = ScenarioDefinitionGameLike,\n> = {\n  readonly schemaVersion: 1;\n  readonly scenario: {\n    readonly path: string;\n    /** Covers the local game/scenario module graph, including assertions. */\n    readonly sourceDigest: `sha256:${string}`;\n  };\n  /** Canonical serializable scenario projection; never contains `then`. */\n  readonly definition: ScenarioReplayDefinition<Game>;\n  readonly checkpoint: ScenarioCheckpoint;\n  readonly expected: {\n    readonly checkpointDigest: `sha256:${string}`;\n    readonly publicProjectionDigest: `sha256:${string}`;\n  };\n};\n\nexport type CompileScenarioReplayOptions = {\n  readonly scenarioPath: string;\n  readonly at?: ScenarioCheckpoint;\n};\n\ntype SyntheticCompileResult = Omit<\n  CompiledScenarioReplay,\n  \"schemaVersion\" | \"scenario\"\n>;\n\ntype SyntheticCompileModule = {\n  readonly compile: (options: {\n    readonly at?: ScenarioCheckpoint;\n    readonly scenarioPath: string;\n    readonly sourceDigest: `sha256:${string}`;\n  }) => Promise<SyntheticCompileResult>;\n};\n\ntype ScenarioSource = {\n  readonly projectRoot: string;\n  readonly scenarioPath: string;\n  readonly relativeScenarioPath: string;\n  readonly gamePath: string;\n};\n\nconst scenarioSourceDigestVersion = \"dreamboard-scenario-source-closure@1\";\nconst syntheticSourceFile = \"__dreamboard_compile_scenario_replay__.ts\";\n\n/**\n * Compile one authored scenario into the trusted, serializable replay DTO used\n * by dev-host, Workbench, demo, and performance adapters.\n *\n * The DTO may contain sealed/private command parameters. It must never cross a\n * player, spectator, browser, ordinary-log, or public-receipt boundary.\n */\nexport async function compileScenarioReplay(\n  options: CompileScenarioReplayOptions,\n): Promise<CompiledScenarioReplay> {\n  const source = await resolveScenarioSource(options.scenarioPath);\n  const syntheticSource = buildSyntheticSource(source);\n  const bundled = await build({\n    absWorkingDir: source.projectRoot,\n    stdin: {\n      contents: syntheticSource,\n      loader: \"ts\",\n      resolveDir: source.projectRoot,\n      sourcefile: syntheticSourceFile,\n    },\n    bundle: true,\n    format: \"esm\",\n    platform: \"node\",\n    target: \"node24\",\n    sourcemap: \"inline\",\n    metafile: true,\n    write: false,\n    logLevel: \"silent\",\n  });\n  const output = bundled.outputFiles?.[0];\n  if (!output || !bundled.metafile) {\n    throw new Error(\"Scenario replay compilation did not produce a bundle.\");\n  }\n  const sourceDigest = await digestSourceClosure({\n    projectRoot: source.projectRoot,\n    inputPaths: Object.keys(bundled.metafile.inputs),\n  });\n\n  const tempRoot = await mkdtemp(\n    path.join(tmpdir(), \"dreamboard-compiled-scenario-\"),\n  );\n  const outputPath = path.join(tempRoot, \"compiled-scenario.mjs\");\n  try {\n    await writeFile(outputPath, output.text);\n    const loaded = (await import(\n      `${pathToFileURL(outputPath).href}?source=${sourceDigest.slice(7, 19)}`\n    )) as SyntheticCompileModule;\n    if (typeof loaded.compile !== \"function\") {\n      throw new Error(\"Scenario replay bundle is missing compile().\");\n    }\n    const materialized = await loaded.compile({\n      ...(options.at === undefined ? {} : { at: options.at }),\n      scenarioPath: source.relativeScenarioPath,\n      sourceDigest,\n    });\n    const compiled = {\n      schemaVersion: 1,\n      scenario: {\n        path: source.relativeScenarioPath,\n        sourceDigest,\n      },\n      definition: materialized.definition,\n      checkpoint: materialized.checkpoint,\n      expected: materialized.expected,\n    } satisfies CompiledScenarioReplay;\n    return assertSerializableCompiledReplay(compiled);\n  } finally {\n    await rm(tempRoot, { recursive: true, force: true });\n  }\n}\n\nasync function resolveScenarioSource(\n  requestedPath: string,\n): Promise<ScenarioSource> {\n  if (typeof requestedPath !== \"string\" || requestedPath.length === 0) {\n    throw new Error(\"scenarioPath must be a non-empty string.\");\n  }\n  const requestedAbsolute = path.resolve(process.cwd(), requestedPath);\n  const requestedStats = await lstat(requestedAbsolute).catch((error) => {\n    if (isMissingPathError(error)) return null;\n    throw error;\n  });\n  if (!requestedStats?.isFile()) {\n    throw new Error(`Scenario path does not name a file: ${requestedPath}.`);\n  }\n  const scenarioPath = await realpath(requestedAbsolute);\n  const projectRoot = await findProjectRoot(path.dirname(scenarioPath));\n  const canonicalProjectRoot = await realpath(projectRoot);\n  const scenarioRoot = path.join(canonicalProjectRoot, \"test\", \"scenarios\");\n  const canonicalScenarioRoot = await realpath(scenarioRoot).catch((error) => {\n    if (isMissingPathError(error)) return null;\n    throw error;\n  });\n  if (\n    canonicalScenarioRoot === null ||\n    !isWithinDirectory(canonicalScenarioRoot, scenarioPath) ||\n    !scenarioPath.endsWith(\".scenario.ts\")\n  ) {\n    throw new Error(\n      \"scenarioPath must resolve to test/scenarios/**/*.scenario.ts inside one game package.\",\n    );\n  }\n  const gamePath = path.join(canonicalProjectRoot, \"app\", \"game.ts\");\n  if (!(await isFile(gamePath))) {\n    throw new Error(`Game package is missing ${gamePath}.`);\n  }\n  return {\n    projectRoot: canonicalProjectRoot,\n    scenarioPath,\n    relativeScenarioPath: toPosix(\n      path.relative(canonicalProjectRoot, scenarioPath),\n    ),\n    gamePath,\n  };\n}\n\nasync function findProjectRoot(start: string): Promise<string> {\n  let current = path.resolve(start);\n  for (;;) {\n    if (\n      (await isFile(path.join(current, \"package.json\"))) &&\n      (await isFile(path.join(current, \"app\", \"game.ts\")))\n    ) {\n      return current;\n    }\n    const parent = path.dirname(current);\n    if (parent === current) {\n      throw new Error(\n        \"Could not find a game package containing package.json and app/game.ts.\",\n      );\n    }\n    current = parent;\n  }\n}\n\nfunction buildSyntheticSource(source: ScenarioSource): string {\n  const gameSpecifier = localImportSpecifier(\n    source.projectRoot,\n    source.gamePath,\n  );\n  const scenarioSpecifier = localImportSpecifier(\n    source.projectRoot,\n    source.scenarioPath,\n  );\n  return [\n    `import * as gameModule from ${JSON.stringify(gameSpecifier)};`,\n    `import * as scenarioModule from ${JSON.stringify(scenarioSpecifier)};`,\n    'import { inspectScenario, toScenarioReplayDefinition } from \"@dreamboard-games/sdk/testing\";',\n    'import { digestScenarioProjection, scenarioProjectionParityFromInspectNode } from \"@dreamboard-games/sdk/testing-runtime\";',\n    \"const game = gameModule.game ?? gameModule.default;\",\n    \"const scenario = scenarioModule.scenario ?? scenarioModule.default;\",\n    \"export async function compile(options) {\",\n    \"  if (!game || !scenario) {\",\n    '    throw new Error(\"Compiled scenario entry is missing game or scenario authority.\");',\n    \"  }\",\n    \"  const definition = toScenarioReplayDefinition(scenario);\",\n    \"  const inspected = await inspectScenario({\",\n    \"    game,\",\n    \"    scenario: definition,\",\n    \"    identity: {\",\n    \"      id: definition.id,\",\n    \"      path: options.scenarioPath,\",\n    \"      sourceDigest: options.sourceDigest,\",\n    \"    },\",\n    '    perspective: { kind: \"spectator\" },',\n    \"    ...(options.at === undefined ? {} : { at: options.at }),\",\n    \"  });\",\n    \"  return {\",\n    \"    definition,\",\n    \"    checkpoint: inspected.node.checkpoint,\",\n    \"    expected: {\",\n    \"      checkpointDigest: inspected.node.checkpointDigest,\",\n    \"      publicProjectionDigest: digestScenarioProjection(\",\n    \"        scenarioProjectionParityFromInspectNode(inspected.node),\",\n    \"      ),\",\n    \"    },\",\n    \"  };\",\n    \"}\",\n  ].join(\"\\n\");\n}\n\nasync function digestSourceClosure(options: {\n  readonly projectRoot: string;\n  readonly inputPaths: readonly string[];\n}): Promise<`sha256:${string}`> {\n  const syntheticPath = path.resolve(options.projectRoot, syntheticSourceFile);\n  const localPaths = options.inputPaths\n    .map((inputPath) =>\n      path.isAbsolute(inputPath)\n        ? inputPath\n        : path.resolve(options.projectRoot, inputPath),\n    )\n    .filter(\n      (inputPath) =>\n        inputPath !== syntheticPath &&\n        isWithinDirectory(options.projectRoot, inputPath) &&\n        !toPosix(path.relative(options.projectRoot, inputPath))\n          .split(\"/\")\n          .includes(\"node_modules\"),\n    );\n  const inputs = await Promise.all(\n    [...new Set(localPaths)].map(async (inputPath) => {\n      const content = await readFile(inputPath);\n      return {\n        path: toPosix(path.relative(options.projectRoot, inputPath)),\n        sha256: createHash(\"sha256\").update(content).digest(\"hex\"),\n      };\n    }),\n  );\n  inputs.sort((left, right) =>\n    compareReferenceGameCanonicalStrings(left.path, right.path),\n  );\n  return `sha256:${createHash(\"sha256\")\n    .update(\n      JSON.stringify({\n        digestVersion: scenarioSourceDigestVersion,\n        inputs,\n      }),\n    )\n    .digest(\"hex\")}`;\n}\n\nfunction assertSerializableCompiledReplay(\n  value: CompiledScenarioReplay,\n): CompiledScenarioReplay {\n  const serialized = JSON.stringify(value);\n  const parsed = JSON.parse(serialized) as CompiledScenarioReplay;\n  if (\n    parsed.schemaVersion !== 1 ||\n    !/^sha256:[a-f0-9]{64}$/.test(parsed.scenario.sourceDigest) ||\n    !/^sha256:[a-f0-9]{64}$/.test(parsed.expected.checkpointDigest) ||\n    !/^sha256:[a-f0-9]{64}$/.test(parsed.expected.publicProjectionDigest)\n  ) {\n    throw new Error(\"Compiled scenario replay failed digest validation.\");\n  }\n  return parsed;\n}\n\nfunction localImportSpecifier(projectRoot: string, filePath: string): string {\n  const relative = toPosix(path.relative(projectRoot, filePath));\n  return relative.startsWith(\".\") ? relative : `./${relative}`;\n}\n\nfunction isWithinDirectory(directory: string, filePath: string): boolean {\n  const relative = path.relative(directory, filePath);\n  return (\n    relative !== \"\" &&\n    relative !== \"..\" &&\n    !relative.startsWith(`..${path.sep}`) &&\n    !path.isAbsolute(relative)\n  );\n}\n\nasync function isFile(filePath: string): Promise<boolean> {\n  return stat(filePath)\n    .then((value) => value.isFile())\n    .catch((error) => {\n      if (isMissingPathError(error)) return false;\n      throw error;\n    });\n}\n\nfunction isMissingPathError(error: unknown): boolean {\n  return (\n    typeof error === \"object\" &&\n    error !== null &&\n    \"code\" in error &&\n    (error as { readonly code?: unknown }).code === \"ENOENT\"\n  );\n}\n\nfunction toPosix(value: string): string {\n  return value.split(path.sep).join(\"/\");\n}\n"],"mappings":"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","names":[]}

package/dist/testing-runtime.d.ts

@@ -1,32 +1,108 @@
-import { w as wire } from './index.d-DMASeF6M.js';
-import { a as BaseDefinition, S as ScenarioDefinition, R as ReducerScenarioBundle } from './types-DcADVHe9.js';
+import { D as DispatchTraceSummaryEntry } from './diagnostics-DIi3ina7.js';
+import { m as ScenarioDefinitionGameLike, l as ScenarioDefinition } from './definitions-0kjPV9wh.js';
+import { i as Sha256Digest, d as InspectNode } from './types-Bvptkukh.js';
+export { h as ScenarioRuntimeCheckpointMaterialization, m as materializeScenarioRuntimeCheckpoint } from './types-Bvptkukh.js';
 import 'zod';
-import './diagnostics-1BWjRo6-.js';
+import './views-DE2eZxPz.js';
+import './runtime-B_w9AO2n.js';
+import './types.js';
+import './index.d-C7Ztirg6.js';
 
-type BaseStateArtifact = {
-    readonly snapshot: wire.ReducerSessionState;
-    readonly fingerprint: {
-        readonly players: number;
-        readonly contractFingerprint?: string;
+type GameLike = {
+    readonly phases: Readonly<Record<string, unknown>>;
+};
+declare function resolveScenarioCommandParams(options: {
+    readonly game: GameLike;
+    readonly phase: string;
+    readonly interactionId: string;
+    readonly params: unknown;
+    readonly playerIds: readonly string[];
+    readonly path: string;
+}): Record<string, unknown>;
+
+type ScenarioProjectionInteractionInput = {
+    readonly key: string;
+    readonly kind: string;
+    readonly domain: unknown;
+};
+/** Shared SDK normalization for inspect DTOs and backend parity projections. */
+declare function scenarioProjectionInputMetadata(input: ScenarioProjectionInteractionInput): {
+    readonly key: string;
+    readonly kind: string;
+    readonly eligibleCount: number | "lazy";
+};
+type ScenarioProjectionParity = {
+    readonly perspective: "spectator" | {
+        readonly seat: number;
+    };
+    readonly flow: {
+        readonly phase: string;
+        readonly step: string | null;
+        readonly activeSeats: readonly number[];
+        readonly pendingSeats: readonly number[];
+        readonly continuationWaiterSeats: readonly number[];
+        readonly blockedBy: readonly {
+            readonly actorSeat: number;
+            readonly blockerSeats: readonly number[];
+        }[];
     };
+    readonly view: unknown;
+    readonly interactions: readonly {
+        readonly actorSeat: number;
+        readonly interactionId: string;
+        readonly availability: {
+            readonly status: string;
+            readonly code?: string;
+            readonly reason?: string;
+        };
+        readonly inputs: readonly {
+            readonly key: string;
+            readonly kind: string;
+            readonly eligibleCount: number | "lazy";
+        }[];
+    }[];
 };
-type CandidateVerificationBase = BaseStateArtifact | (BaseDefinition & Partial<BaseStateArtifact>);
-type CandidateVerificationScenario = ScenarioDefinition;
-type CandidateVerificationInput = {
-    readonly manifest?: unknown;
-    readonly bases: Readonly<Record<string, CandidateVerificationBase>> | readonly CandidateVerificationBase[];
-    readonly scenarios: Readonly<Record<string, CandidateVerificationScenario>> | readonly CandidateVerificationScenario[];
-    readonly reducer: ReducerScenarioBundle;
+/**
+ * Canonical local/backend parity authority. It deliberately excludes raw
+ * reducer public/private state, interaction explanations, entropy, and trace:
+ * backend gameplay frames expose the selected projection, not reducer state.
+ */
+declare function scenarioProjectionParityFromInspectNode(node: InspectNode): ScenarioProjectionParity;
+declare function digestScenarioProjection(projection: ScenarioProjectionParity): Sha256Digest;
+
+type CandidateVerificationScenario<Game extends ScenarioDefinitionGameLike> = ScenarioDefinition<Game>;
+type CandidateVerificationInput<Game extends ScenarioDefinitionGameLike> = {
+    /** The authored reducer game definition used by production dispatch. */
+    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 status: "passed" | "failed";
-    readonly diagnostic?: {
-        readonly kind: "assertion";
-        readonly message: string;
-    };
+    readonly diagnostic?: CandidateVerificationReplayDiagnostic | CandidateVerificationAssertionDiagnostic | CandidateVerificationLimitDiagnostic;
 };
 type CandidateVerificationResult = {
     readonly status: "passed" | "failed";
@@ -37,6 +113,6 @@ type CandidateVerificationResult = {
         readonly scenarios: readonly CandidateVerificationScenarioResult[];
     };
 };
-declare function runCandidateVerification(input: CandidateVerificationInput): Promise<CandidateVerificationResult>;
+declare function runCandidateVerification<const Game extends ScenarioDefinitionGameLike>(input: CandidateVerificationInput<Game>): Promise<CandidateVerificationResult>;
 
-export { type CandidateVerificationBase, type CandidateVerificationInput, type CandidateVerificationResult, type CandidateVerificationScenario, type CandidateVerificationScenarioResult, runCandidateVerification };
+export { type CandidateVerificationAssertionDiagnostic, type CandidateVerificationInput, type CandidateVerificationLimitDiagnostic, type CandidateVerificationReplayDiagnostic, type CandidateVerificationResult, type CandidateVerificationScenario, type CandidateVerificationScenarioResult, type ScenarioProjectionInteractionInput, type ScenarioProjectionParity, digestScenarioProjection, resolveScenarioCommandParams, runCandidateVerification, scenarioProjectionInputMetadata, scenarioProjectionParityFromInspectNode };