@dreamboard-games/sdk 0.4.0-alpha.12 → 0.4.0-alpha.13

package/dist/testing.js

@@ -872,9 +872,10 @@ var checkpointComparisons = [
   { path: "interactionId", code: "interaction-resolution-mismatch" },
   { path: "actuatorId", code: "interaction-resolution-mismatch" },
   { path: "descriptorDigest", code: "interaction-resolution-mismatch" },
-  { path: "gameVersion", code: "projection-mismatch" },
-  { path: "actionSetVersion", code: "projection-mismatch" },
-  { path: "perspectivePlayerId", code: "projection-mismatch" },
+  { path: "basis.generation", code: "projection-mismatch" },
+  { path: "basis.version", code: "projection-mismatch" },
+  { path: "basis.actionSetVersion", code: "projection-mismatch" },
+  { path: "basis.perspectivePlayerId", code: "projection-mismatch" },
   { path: "projectionDigest", code: "projection-mismatch" },
   { path: "semanticDigest", code: "semantic-snapshot-mismatch" },
   { path: "draftDigest", code: "draft-mismatch" },
@@ -923,9 +924,7 @@ function createUIParityObservationFromFixture({
       actuatorId: identity?.actuatorId,
       descriptorDigest: identity?.descriptorDigest,
       draftDigest: step.expect.draftDigest ?? identity?.draftDigest,
-      gameVersion: frame.frame.basis.version,
-      actionSetVersion: frame.frame.basis.actionSetVersion,
-      perspectivePlayerId: frame.frame.basis.perspectivePlayerId,
+      basis: frame.frame.basis,
       projectionDigest,
       semanticDigest,
       submissionDigest,
@@ -933,7 +932,7 @@ function createUIParityObservationFromFixture({
     };
   });
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     scenarioId: fixture.id,
     fixtureDigest,
     sdkCandidateDigest,
@@ -947,10 +946,10 @@ function createUIParityObservationFromFixture({
     diagnostics
   };
 }
-function parseUIParityObservationV1(value) {
+function parseUIParityObservation(value) {
   const observation = assertRecord(value, "observation");
-  if (observation.schemaVersion !== 1) {
-    throw new Error("UI parity observation schemaVersion must be 1.");
+  if (observation.schemaVersion !== 2) {
+    throw new Error("UI parity observation schemaVersion must be 2.");
   }
   assertString(observation.scenarioId, "scenarioId");
   assertString(observation.fixtureDigest, "fixtureDigest");
@@ -977,6 +976,9 @@ function parseUIParityObservationV1(value) {
     );
   }
   assertOptionalString(provenance.evidence, "observation.provenance.evidence");
+  if (typeof provenance.evidence === "string") {
+    assertPortablePath(provenance.evidence, "observation.provenance.evidence");
+  }
   const checkpoints = assertArray(observation.checkpoints, "checkpoints");
   for (let index = 0; index < checkpoints.length; index += 1) {
     const checkpoint = assertRecord(
@@ -1004,16 +1006,7 @@ function parseUIParityObservationV1(value) {
       checkpoint.draftDigest,
       `checkpoints[${index}].draftDigest`
     );
-    assertNumber(checkpoint.gameVersion, `checkpoints[${index}].gameVersion`);
-    assertString(
-      checkpoint.actionSetVersion,
-      `checkpoints[${index}].actionSetVersion`
-    );
-    if (checkpoint.perspectivePlayerId !== null && typeof checkpoint.perspectivePlayerId !== "string") {
-      throw new Error(
-        `checkpoints[${index}].perspectivePlayerId must be a string or null.`
-      );
-    }
+    parseGameplayBasis(checkpoint.basis, `checkpoints[${index}].basis`);
     assertString(
       checkpoint.projectionDigest,
       `checkpoints[${index}].projectionDigest`
@@ -1086,6 +1079,86 @@ function compareUIParityObservations(expected, actual) {
   }
   return { ok: true };
 }
+function parseUIParityRunInput(value) {
+  const input = assertRecord(value, "input");
+  if (input.schemaVersion !== 2) {
+    throw new Error("UI parity run input schemaVersion must be 2.");
+  }
+  const sdk = assertRecord(input.sdk, "input.sdk");
+  parseArtifactReference(sdk.tarball, "input.sdk.tarball");
+  parseArtifactReference(input.referenceBundle, "input.referenceBundle");
+  const fixtureBundle = assertRecord(
+    input.fixtureBundle,
+    "input.fixtureBundle"
+  );
+  parseArtifactReference(fixtureBundle.index, "input.fixtureBundle.index");
+  const scenarios = assertArray(
+    fixtureBundle.scenarios,
+    "input.fixtureBundle.scenarios"
+  );
+  if (scenarios.length === 0) {
+    throw new Error("input.fixtureBundle.scenarios must not be empty.");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (let index = 0; index < scenarios.length; index += 1) {
+    const path = `input.fixtureBundle.scenarios[${index}]`;
+    const scenario = assertRecord(scenarios[index], path);
+    assertString(scenario.id, `${path}.id`);
+    const id = scenario.id;
+    if (ids.has(id)) {
+      throw new Error(`${path}.id duplicates scenario '${id}'.`);
+    }
+    ids.add(id);
+    parseArtifactReference(scenario.fixture, `${path}.fixture`);
+    parseArtifactReference(scenario.renderModule, `${path}.renderModule`);
+    parseArtifactReference(scenario.expectation, `${path}.expectation`);
+    parseArtifactReference(scenario.source, `${path}.source`);
+  }
+  assertString(input.project, "input.project");
+  return input;
+}
+function parseUIParityRealHostReceipt(value) {
+  const receipt = assertRecord(value, "receipt");
+  if (receipt.schemaVersion !== 2) {
+    throw new Error("UI parity real-host receipt schemaVersion must be 2.");
+  }
+  if (receipt.kind !== "dreamboard-ui-real-host-parity" || receipt.mode !== "real-host-parity" || receipt.result !== "passed" || receipt.realHostExecutor !== true) {
+    throw new Error(
+      "UI parity real-host receipt must be a passing real-host proof."
+    );
+  }
+  parseArtifactReference(receipt.input, "receipt.input");
+  assertString(receipt.sdkTarballSha256, "receipt.sdkTarballSha256");
+  assertString(receipt.fixtureBundleSha256, "receipt.fixtureBundleSha256");
+  assertString(receipt.project, "receipt.project");
+  const scenarios = assertArray(receipt.scenarios, "receipt.scenarios");
+  if (scenarios.length === 0) {
+    throw new Error("receipt.scenarios must not be empty.");
+  }
+  for (let index = 0; index < scenarios.length; index += 1) {
+    const scenario = assertRecord(
+      scenarios[index],
+      `receipt.scenarios[${index}]`
+    );
+    assertString(scenario.id, `receipt.scenarios[${index}].id`);
+    assertString(
+      scenario.fixtureDigest,
+      `receipt.scenarios[${index}].fixtureDigest`
+    );
+  }
+  parseReceiptComparisonGroup(receipt.source, "receipt.source", false);
+  parseReceiptComparisonGroup(receipt.internal, "receipt.internal", true);
+  const host = assertRecord(receipt.host, "receipt.host");
+  assertString(host.route, "receipt.host.route");
+  assertString(host.webLogPath, "receipt.host.webLogPath");
+  assertPortablePath(host.webLogPath, "receipt.host.webLogPath");
+  if (host.pluginIframe !== true || host.pluginSessionGateway !== true || host.playwright !== "chromium") {
+    throw new Error(
+      "receipt.host must prove PluginIframe, PluginSessionGateway, and Chromium."
+    );
+  }
+  return receipt;
+}
 function comparePath(expected, actual, comparison, options = {}) {
   const expectedValue = getPath(expected, comparison.path);
   const actualValue = getPath(actual, comparison.path);
@@ -1125,6 +1198,70 @@ function getPath(value, path) {
     return current[key];
   }, value);
 }
+function parseGameplayBasis(value, path) {
+  const basis = assertRecord(value, path);
+  assertNonNegativeInteger(basis.generation, `${path}.generation`);
+  assertNonNegativeInteger(basis.version, `${path}.version`);
+  assertString(basis.actionSetVersion, `${path}.actionSetVersion`);
+  assertString(basis.perspectivePlayerId, `${path}.perspectivePlayerId`);
+  return basis;
+}
+function parseArtifactReference(value, path) {
+  const reference = assertRecord(value, path);
+  assertString(reference.path, `${path}.path`);
+  assertPortablePath(reference.path, `${path}.path`);
+  assertString(reference.sha256, `${path}.sha256`);
+  if (!reference.sha256.startsWith("sha256:")) {
+    throw new Error(`${path}.sha256 must be a sha256 digest.`);
+  }
+  return reference;
+}
+function parseReceiptComparisonGroup(value, path, internal) {
+  const group = assertRecord(value, path);
+  if (group.result !== "passed") {
+    throw new Error(`${path}.result must be passed.`);
+  }
+  const comparisons = assertArray(group.comparisons, `${path}.comparisons`);
+  for (let index = 0; index < comparisons.length; index += 1) {
+    const itemPath = `${path}.comparisons[${index}]`;
+    const comparison = assertRecord(comparisons[index], itemPath);
+    assertString(comparison.scenarioId, `${itemPath}.scenarioId`);
+    assertString(comparison.actual, `${itemPath}.actual`);
+    assertPortablePath(comparison.actual, `${itemPath}.actual`);
+    if (internal) {
+      assertString(
+        comparison.expectationComparison,
+        `${itemPath}.expectationComparison`
+      );
+      assertString(comparison.sourceComparison, `${itemPath}.sourceComparison`);
+      assertPortablePath(
+        comparison.expectationComparison,
+        `${itemPath}.expectationComparison`
+      );
+      assertPortablePath(
+        comparison.sourceComparison,
+        `${itemPath}.sourceComparison`
+      );
+    } else {
+      assertString(comparison.comparison, `${itemPath}.comparison`);
+      assertOptionalString(comparison.evidence, `${itemPath}.evidence`);
+      assertPortablePath(
+        comparison.comparison,
+        `${itemPath}.comparison`
+      );
+      if (typeof comparison.evidence === "string") {
+        assertPortablePath(comparison.evidence, `${itemPath}.evidence`);
+      }
+    }
+  }
+}
+function assertPortablePath(value, path) {
+  if (value.length === 0 || value.startsWith("/") || value.startsWith("\\") || /^[a-zA-Z]:[\\/]/.test(value) || value.split(/[\\/]+/).includes("..")) {
+    throw new Error(
+      `${path} must be a relative path within its portable bundle.`
+    );
+  }
+}
 function assertRecord(value, path) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error(`${path} must be an object.`);
@@ -1152,6 +1289,11 @@ function assertNumber(value, path) {
     throw new Error(`${path} must be a finite number.`);
   }
 }
+function assertNonNegativeInteger(value, path) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${path} must be a non-negative integer.`);
+  }
+}
 
 // src/testing/ui-fixture/create-fixture-host-harness.ts
 var DEFAULT_CHANNEL_ID = "fixture-channel";
@@ -1976,7 +2118,9 @@ export {
   inspectScenario,
   isSha256Digest,
   isStaleContractArtifactError,
-  parseUIParityObservationV1,
+  parseUIParityObservation,
+  parseUIParityRealHostReceipt,
+  parseUIParityRunInput,
   parseUIScenarioFixture,
   parseUIScenarioFixtureBundleIndex,
   pluginProtocolTapeSchema,