@dreamboard-games/sdk 0.4.0-alpha.6 → 0.4.0-alpha.8

package/dist/testing.js

@@ -1,11 +1,24 @@
+import {
+  PluginRuntimeBoundary,
+  createPluginRuntimeClient
+} from "./chunk-XV27IQHA.js";
+import "./chunk-ZYONCTZ2.js";
+import {
+  BROWSER_INTERACTION_ACTUATOR_KINDS,
+  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
+  browserInteractionEffectSchema
+} from "./chunk-WHR5UW3F.js";
+import {
+  RuntimeJsonSchema
+} from "./chunk-PF7L4BMG.js";
+import {
+  createExpectApi,
+  createTestRuntime
+} from "./chunk-5CQIJHGF.js";
 import {
   StaleContractArtifactError,
   isStaleContractArtifactError
 } from "./chunk-3OZMHZK3.js";
-import {
-  PluginRuntimeBoundary,
-  createPluginRuntimeClient
-} from "./chunk-PAPIAMYX.js";
 import {
   DREAMBOARD_PLUGIN_PROTOCOL,
   DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
@@ -14,15 +27,7 @@ import {
   PluginProtocolTapeSchema,
   computePluginActionSetVersion,
   materializePluginGameplayFrame
-} from "./chunk-UUQNOGZV.js";
-import {
-  BROWSER_INTERACTION_ACTUATOR_KINDS,
-  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
-  browserInteractionEffectSchema
-} from "./chunk-WHR5UW3F.js";
-import {
-  RuntimeJsonSchema
-} from "./chunk-PF7L4BMG.js";
+} from "./chunk-IYX5OO2K.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/testing/definitions.ts
@@ -33,629 +38,6 @@ function defineScenario(definition) {
   return definition;
 }
 
-// src/testing/create-expect-api.ts
-import { isDeepStrictEqual } from "util";
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function matchPartial(actual, expected, path = "value") {
-  if (!isRecord(expected)) {
-    return isDeepStrictEqual(actual, expected) ? null : `${path} does not match`;
-  }
-  if (!isRecord(actual)) {
-    return `${path} is not an object`;
-  }
-  for (const [key, expectedValue] of Object.entries(expected)) {
-    const actualValue = actual[key];
-    if (!(key in actual)) {
-      return `${path}.${key} is missing`;
-    }
-    const mismatch2 = matchPartial(actualValue, expectedValue, `${path}.${key}`);
-    if (mismatch2) {
-      return mismatch2;
-    }
-  }
-  return null;
-}
-function asDescriptorList(actual) {
-  if (!Array.isArray(actual)) {
-    throw new Error("Expected interaction descriptor array.");
-  }
-  return actual;
-}
-function findInteraction(descriptors, interactionId) {
-  return descriptors.find(
-    (descriptor) => descriptor.interactionId === interactionId
-  ) ?? null;
-}
-function assertDescriptorMatches(descriptor, opts) {
-  if (!opts) {
-    return;
-  }
-  const mismatch2 = matchPartial(descriptor, opts, "interaction");
-  if (mismatch2) {
-    throw new Error(mismatch2);
-  }
-}
-function createSubmissionErrorMatcher(actual, expected, options) {
-  const resolvePromise = () => {
-    if (typeof actual === "function") {
-      return Promise.resolve().then(() => actual());
-    }
-    return Promise.resolve(actual);
-  };
-  return resolvePromise().then(() => {
-    throw new Error("Expected promise to reject.");
-  }).catch((error) => {
-    if (!(error instanceof Error)) {
-      throw new Error("Expected rejection to be an Error.");
-    }
-    if (expected.errorCode !== void 0 && error.errorCode !== expected.errorCode) {
-      throw new Error(
-        `Expected rejection errorCode '${expected.errorCode}', received '${error.errorCode ?? "undefined"}'.${formatLastDiagnosticRejection(options)}`
-      );
-    }
-    if (typeof expected.message === "string" && error.message !== expected.message) {
-      throw new Error(
-        `Expected rejection message '${expected.message}', received '${error.message}'.${formatLastDiagnosticRejection(
-          options
-        )}`
-      );
-    }
-    if (expected.message instanceof RegExp && !expected.message.test(error.message)) {
-      throw new Error(
-        `Expected rejection message '${error.message}' to match ${String(
-          expected.message
-        )}.${formatLastDiagnosticRejection(options)}`
-      );
-    }
-  });
-}
-function formatLastDiagnosticRejection(options) {
-  const rejection = options.lastDiagnosticRejection?.();
-  if (!rejection) return "";
-  const rule = rejection.ruleId ? ` ruleId=${rejection.ruleId}` : "";
-  const message = rejection.message ? ` message=${rejection.message}` : "";
-  return `
-last rejection: errorCode=${rejection.errorCode}${rule}${message}`;
-}
-function assertLength(actual, expected) {
-  if (actual === null || actual === void 0 || typeof actual.length !== "number") {
-    throw new Error("toHaveLength expects a value with a numeric length.");
-  }
-  const length = actual.length;
-  if (length !== expected) {
-    throw new Error(`Expected length ${expected}, received ${length}.`);
-  }
-}
-function formatInteractionExplanation(explanation) {
-  if (!explanation) {
-    return "";
-  }
-  const lines = [
-    `availability: ${explanation.availability}`,
-    ...explanation.rules.map((rule) => {
-      const code = rule.errorCode ? ` (${rule.errorCode})` : "";
-      const message = rule.message ? `: ${rule.message}` : "";
-      return `rule ${rule.ruleId} ${rule.outcome}${code}${message}`;
-    }),
-    ...explanation.inputs.map(
-      (input) => `input ${input.key} eligibleCount=${input.eligibleCount}`
-    )
-  ];
-  return `
-${lines.join("\n")}`;
-}
-function assertThrown(actual, predicate) {
-  if (typeof actual !== "function") {
-    throw new Error("toThrow expects a function.");
-  }
-  try {
-    actual();
-  } catch (error) {
-    if (!(error instanceof Error)) {
-      throw new Error("Thrown value is not an Error.");
-    }
-    if (predicate === void 0) {
-      return;
-    }
-    if (typeof predicate === "string" && error.message !== predicate) {
-      throw new Error(
-        `Expected thrown message '${predicate}', received '${error.message}'.`
-      );
-    }
-    if (predicate instanceof RegExp && !predicate.test(error.message)) {
-      throw new Error(
-        `Expected thrown message '${error.message}' to match ${String(predicate)}.`
-      );
-    }
-    if (typeof predicate === "function" && !predicate(error)) {
-      throw new Error("Thrown error did not satisfy predicate.");
-    }
-    return;
-  }
-  throw new Error("Expected function to throw.");
-}
-function createExpectApi(options = {}) {
-  const buildMatchers = (actual) => ({
-    toBe: (expected) => {
-      if (actual !== expected) {
-        throw new Error(
-          `Expected '${String(actual)}' to be '${String(expected)}'.`
-        );
-      }
-    },
-    toEqual: (expected) => {
-      if (!isDeepStrictEqual(actual, expected)) {
-        throw new Error("Expected values to be deeply equal.");
-      }
-    },
-    toMatchObject: (expected) => {
-      const mismatch2 = matchPartial(actual, expected);
-      if (mismatch2) {
-        throw new Error(mismatch2);
-      }
-    },
-    toBeDefined: () => {
-      if (actual === void 0) {
-        throw new Error("Expected value to be defined.");
-      }
-    },
-    toBeUndefined: () => {
-      if (actual !== void 0) {
-        throw new Error(
-          `Expected value to be undefined, but received '${String(actual)}'.`
-        );
-      }
-    },
-    toBeNull: () => {
-      if (actual !== null) {
-        throw new Error(
-          `Expected value to be null, but received '${String(actual)}'.`
-        );
-      }
-    },
-    toContain: (expected) => {
-      if (Array.isArray(actual)) {
-        if (!actual.includes(expected)) {
-          throw new Error("Expected array to contain value.");
-        }
-        return;
-      }
-      if (typeof actual === "string") {
-        if (!actual.includes(String(expected))) {
-          throw new Error("Expected string to contain value.");
-        }
-        return;
-      }
-      throw new Error("toContain expects an array or string actual value.");
-    },
-    toContainEqual: (expected) => {
-      if (!Array.isArray(actual)) {
-        throw new Error("toContainEqual expects an array actual value.");
-      }
-      if (!actual.some((value) => isDeepStrictEqual(value, expected))) {
-        throw new Error("Expected array to contain an equal value.");
-      }
-    },
-    toHaveLength: (expected) => {
-      assertLength(actual, expected);
-    },
-    toBeGreaterThan: (expected) => {
-      if (typeof actual !== "number") {
-        throw new Error("toBeGreaterThan expects a number actual value.");
-      }
-      if (actual <= expected) {
-        throw new Error(`Expected ${actual} to be > ${expected}.`);
-      }
-    },
-    toBeGreaterThanOrEqual: (expected) => {
-      if (typeof actual !== "number") {
-        throw new Error(
-          "toBeGreaterThanOrEqual expects a number actual value."
-        );
-      }
-      if (actual < expected) {
-        throw new Error(`Expected ${actual} to be >= ${expected}.`);
-      }
-    },
-    toThrow: (predicate) => {
-      assertThrown(actual, predicate);
-    },
-    toMatchSnapshot: (filename) => {
-      if (!options.matchSnapshot) {
-        throw new Error(
-          "Snapshot matching is not configured for this expect API."
-        );
-      }
-      options.matchSnapshot(filename, actual);
-    },
-    toRejectWith: (expected) => createSubmissionErrorMatcher(actual, expected, options),
-    toHaveInteraction: (interactionId, opts) => {
-      const descriptors = asDescriptorList(actual);
-      const descriptor = findInteraction(descriptors, interactionId);
-      if (!descriptor) {
-        throw new Error(`Expected interaction '${interactionId}' to exist.`);
-      }
-      assertDescriptorMatches(descriptor, opts);
-    },
-    toBeGatedBy: (reason, opts) => {
-      const descriptor = Array.isArray(actual) ? (() => {
-        if (!opts?.interactionId) {
-          throw new Error(
-            "toBeGatedBy on a descriptor array requires opts.interactionId."
-          );
-        }
-        return findInteraction(
-          asDescriptorList(actual),
-          opts.interactionId
-        );
-      })() : actual;
-      if (!descriptor) {
-        throw new Error("Expected interaction descriptor to exist.");
-      }
-      if (descriptor.availability?.status === "available") {
-        throw new Error("Expected interaction to be unavailable.");
-      }
-      const actualReason = descriptor.availability?.status === "notYourTurn" || descriptor.availability?.status === "insufficientResources" || descriptor.availability?.status === "blocked" ? descriptor.availability.reason : void 0;
-      if (actualReason !== reason) {
-        throw new Error(
-          `Expected unavailable reason '${reason}', received '${actualReason ?? "undefined"}'.`
-        );
-      }
-    },
-    toBeAvailable: (explanation) => {
-      const descriptor = Array.isArray(actual) ? (() => {
-        if (!explanation?.interactionId) {
-          throw new Error(
-            "toBeAvailable on a descriptor array requires an explanation."
-          );
-        }
-        return findInteraction(
-          asDescriptorList(actual),
-          explanation.interactionId
-        );
-      })() : actual;
-      if (!descriptor) {
-        throw new Error(
-          `Expected interaction descriptor to exist.${formatInteractionExplanation(
-            explanation
-          )}`
-        );
-      }
-      if (descriptor.availability?.status !== "available") {
-        throw new Error(
-          `Expected interaction '${descriptor.interactionId ?? "unknown"}' to be available.${formatInteractionExplanation(
-            explanation
-          )}`
-        );
-      }
-    },
-    toBeActiveFor: (playerId, opts) => {
-      const descriptor = Array.isArray(actual) ? (() => {
-        if (!opts?.interactionId) {
-          throw new Error(
-            "toBeActiveFor on a descriptor array requires opts.interactionId."
-          );
-        }
-        return findInteraction(
-          asDescriptorList(actual),
-          opts.interactionId
-        );
-      })() : actual;
-      if (!descriptor) {
-        throw new Error("Expected interaction descriptor to exist.");
-      }
-      if (descriptor.context?.to !== playerId) {
-        throw new Error(
-          `Expected interaction to target '${playerId}', received '${descriptor.context?.to ?? "undefined"}'.`
-        );
-      }
-      if (descriptor.availability?.status !== "available") {
-        throw new Error("Expected interaction to be available.");
-      }
-    },
-    not: {
-      toHaveInteraction: (interactionId) => {
-        const descriptors = asDescriptorList(actual);
-        if (findInteraction(descriptors, interactionId)) {
-          throw new Error(
-            `Expected interaction '${interactionId}' to be absent.`
-          );
-        }
-      }
-    }
-  });
-  return (actual) => buildMatchers(actual);
-}
-
-// src/testing/create-test-runtime.ts
-function cloneState(value) {
-  return structuredClone(value);
-}
-function createSubmissionError(errorCode, message) {
-  const error = new Error(message ?? "Interaction rejected");
-  error.name = "SubmissionError";
-  error.errorCode = errorCode;
-  return error;
-}
-function summarizeWireTrace(trace) {
-  return (trace ?? []).flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null) return [];
-    const record = entry;
-    switch (record.kind) {
-      case "acceptedClientInput": {
-        const input = typeof record.input === "object" && record.input !== null ? record.input : {};
-        return [
-          {
-            kind: "acceptedClientInput",
-            interactionId: String(input.interactionId ?? ""),
-            playerId: String(input.playerId ?? "")
-          }
-        ];
-      }
-      case "appliedEffect": {
-        const effect = typeof record.effect === "object" && record.effect !== null ? record.effect : {};
-        return [
-          {
-            kind: "appliedInstruction",
-            instruction: String(effect.kind ?? effect.type ?? "effect")
-          }
-        ];
-      }
-      case "rngConsumption":
-        return [
-          {
-            kind: "rngConsumption",
-            operation: String(record.operation ?? ""),
-            traceEntry: String(record.traceEntry ?? "")
-          }
-        ];
-      default:
-        return [];
-    }
-  });
-}
-function readFlowState(state) {
-  const flow = state.domain?.flow ?? {};
-  return {
-    currentPhase: flow.currentPhase ?? null,
-    activePlayers: Array.isArray(flow.activePlayers) ? flow.activePlayers : []
-  };
-}
-function resolvePlayerIds(options) {
-  if (options.explicitPlayerIds && options.explicitPlayerIds.length > 0) {
-    return [...options.explicitPlayerIds];
-  }
-  return Array.from(
-    { length: options.baseState.fingerprint.players },
-    (_, index) => `player-${index + 1}`
-  );
-}
-function isWireZoneHandles(value) {
-  return typeof value === "object" && value !== null;
-}
-function buildPluginFrame(options) {
-  const projection = options.bundle.projectSeatsDynamic({
-    state: options.state,
-    playerIds: [options.playerId]
-  });
-  const flow = readFlowState(options.state);
-  if (options.expectedPhase && flow.currentPhase !== options.expectedPhase) {
-    throw new Error(
-      `Expected base '${options.baseId}' to be in phase '${options.expectedPhase}', received '${flow.currentPhase ?? "null"}'.`
-    );
-  }
-  const interactionsByRef = projection.interactionsByRef ?? {};
-  const hydrateRefs = (refs) => (refs ?? []).map((ref) => interactionsByRef[ref]).filter(
-    (descriptor) => Boolean(descriptor)
-  );
-  const seat = projection.seats?.[options.playerId];
-  const zones = Object.fromEntries(
-    Object.entries(
-      seat?.zones ?? {}
-    ).map(([zoneId, zoneValue]) => {
-      const zone = isWireZoneHandles(zoneValue) ? zoneValue : {};
-      return [
-        zoneId,
-        {
-          cardIds: [...zone.cardIds ?? []],
-          cardViewsById: { ...zone.cardViewsById ?? {} },
-          playableByCardId: Object.fromEntries(
-            Object.entries(zone.playableByCardId ?? {}).map(
-              ([cardId, refs]) => [cardId, hydrateRefs(refs)]
-            )
-          )
-        }
-      ];
-    })
-  );
-  const availableInteractions = hydrateRefs(
-    seat?.availableInteractionRefs
-  );
-  return {
-    gameVersion: options.version,
-    actionSetVersion: computePluginActionSetVersion({
-      gameVersion: options.version,
-      availableInteractions
-    }),
-    perspectivePlayerId: options.playerId || null,
-    view: seat?.view ?? null,
-    flow: {
-      currentPhase: flow.currentPhase,
-      currentStage: projection.currentStage ?? null,
-      activePlayers: flow.activePlayers,
-      simultaneousPhase: projection.simultaneousPhase ?? null
-    },
-    availableInteractions,
-    recentEvents: [],
-    zones
-  };
-}
-function createTestRuntime(options) {
-  const baseState = options.baseStates[options.baseId];
-  if (!baseState) {
-    throw new Error(`Unknown test base '${options.baseId}'.`);
-  }
-  const expectedBaseStateFingerprint = options.expectedBaseStateFingerprint ?? baseState.fingerprint.contractFingerprint;
-  if (options.contractFingerprint && expectedBaseStateFingerprint && options.contractFingerprint !== expectedBaseStateFingerprint) {
-    throw new StaleContractArtifactError({
-      artifact: "base-states",
-      expected: options.contractFingerprint,
-      found: expectedBaseStateFingerprint
-    });
-  }
-  let currentState = cloneState(baseState.snapshot);
-  const playerIds = resolvePlayerIds({
-    baseState,
-    explicitPlayerIds: options.playerIds
-  });
-  const sessionId = options.sessionId ?? "test-session";
-  const sessionDescriptor = {
-    sessionId,
-    players: playerIds.map((playerId) => ({
-      playerId,
-      displayName: options.displayNameByPlayerId?.[playerId] ?? playerId
-    }))
-  };
-  let version = 0;
-  let submissionCounter = 0;
-  const currentPlayerId = playerIds[0] ?? "";
-  const diagnosticEvents = [];
-  let lastDispatch = null;
-  const toReadySessionState = (frame) => ({
-    status: "ready",
-    sessionId,
-    controllingPlayerId: frame.perspectivePlayerId
-  });
-  let lastPluginFrame;
-  let lastSessionState;
-  const applyCurrentState = () => {
-    version += 1;
-    lastPluginFrame = buildPluginFrame({
-      state: currentState,
-      bundle: options.bundle,
-      playerId: currentPlayerId,
-      version,
-      expectedPhase: version === 1 ? options.phase : void 0,
-      baseId: options.baseId
-    });
-    lastSessionState = toReadySessionState(lastPluginFrame);
-  };
-  applyCurrentState();
-  const validate = async (playerId, interactionId, params = {}) => {
-    const result = await options.bundle.validateInput({
-      state: currentState,
-      input: {
-        kind: "interaction",
-        playerId,
-        interactionId,
-        params
-      }
-    });
-    return {
-      valid: result.valid,
-      errorCode: result.errorCode,
-      message: result.message
-    };
-  };
-  const submit2 = async (playerId, interactionId, params = {}) => {
-    submissionCounter += 1;
-    const submissionId = `sub-${submissionCounter}`;
-    diagnosticEvents.push({
-      type: "submitReceived",
-      submissionId,
-      playerId,
-      interactionId,
-      phase: readFlowState(currentState).currentPhase ?? ""
-    });
-    const validation = await validate(playerId, interactionId, params);
-    if (!validation.valid) {
-      diagnosticEvents.push({
-        type: "submitRejected",
-        submissionId,
-        errorCode: validation.errorCode ?? "invalid-action",
-        ...validation.message ? { message: validation.message } : {}
-      });
-      throw createSubmissionError(validation.errorCode, validation.message);
-    }
-    const result = await options.bundle.dispatch({
-      state: currentState,
-      input: {
-        kind: "interaction",
-        playerId,
-        interactionId,
-        params
-      }
-    });
-    if (result.kind === "reject") {
-      diagnosticEvents.push({
-        type: "submitRejected",
-        submissionId,
-        errorCode: result.errorCode,
-        ...result.message ? { message: result.message } : {}
-      });
-      throw createSubmissionError(result.errorCode, result.message);
-    }
-    const trace = summarizeWireTrace(result.trace);
-    lastDispatch = { submissionId, trace };
-    diagnosticEvents.push({
-      type: "submitAccepted",
-      submissionId,
-      trace
-    });
-    currentState = cloneState(result.state);
-    applyCurrentState();
-  };
-  const explain = (playerId, interactionId) => {
-    if (!options.bundle.explainInteraction) {
-      throw new Error(
-        "This reducer bundle does not expose explainInteraction()."
-      );
-    }
-    return options.bundle.explainInteraction({
-      state: currentState,
-      playerId,
-      interactionId
-    });
-  };
-  const runtime = {
-    validateInteraction: (interactionId, params) => validate(currentPlayerId, interactionId, params),
-    submitInteraction: (interactionId, params) => submit2(currentPlayerId, interactionId, params),
-    getSessionState: () => lastSessionState,
-    disconnect: () => void 0
-  };
-  return {
-    runtime,
-    getFrame: () => lastPluginFrame,
-    getSessionDescriptor: () => sessionDescriptor,
-    players: () => [...playerIds],
-    seat: (index) => {
-      if (!Number.isInteger(index) || index < 0 || index >= playerIds.length) {
-        throw new Error(
-          `seat(${index}) is out of range; base '${options.baseId}' has ${playerIds.length} player(s).`
-        );
-      }
-      return playerIds[index];
-    },
-    submit: submit2,
-    validate,
-    explain,
-    diagnostics: {
-      get events() {
-        return diagnosticEvents;
-      },
-      get lastDispatch() {
-        return lastDispatch;
-      },
-      clear() {
-        diagnosticEvents.length = 0;
-        lastDispatch = null;
-      }
-    }
-  };
-}
-
 // src/testing/ui-fixture/canonical.ts
 import { createHash } from "crypto";
 var sha256DigestPattern = /^sha256:[a-f0-9]{64}$/;
@@ -751,7 +133,7 @@ function createReducerScenarioRunner(options) {
           playerIds: [options.viewer.playerId]
         });
         const staticProjection = options.bundle.projectStatic?.() ?? null;
-        const flow = readFlowState2(state);
+        const flow = readFlowState(state);
         const materialized = materializePluginGameplayFrame({
           currentPhase: flow.currentPhase,
           activePlayers: flow.activePlayers,
@@ -851,7 +233,7 @@ function createReducerScenarioRunner(options) {
     }
   };
 }
-function readFlowState2(state) {
+function readFlowState(state) {
   return {
     currentPhase: state.domain?.flow?.currentPhase ?? null,
     activePlayers: [...state.domain?.flow?.activePlayers ?? []]
@@ -1525,7 +907,7 @@ function compilePluginProtocolTape(options) {
   };
 }
 function materializeTraceFrame(frame, perspectivePlayerId) {
-  const flow = readFlowState3(frame.reducerState);
+  const flow = readFlowState2(frame.reducerState);
   return {
     id: frame.id,
     frame: materializePluginGameplayFrame({
@@ -1552,7 +934,7 @@ function digestRuntimeCommand(exchange, frame) {
     payload: exchange.input.params
   });
 }
-function readFlowState3(state) {
+function readFlowState2(state) {
   return {
     currentPhase: state.domain?.flow?.currentPhase ?? null,
     activePlayers: [...state.domain?.flow?.activePlayers ?? []]