@dreamboard-games/cli 0.1.30-alpha.1 → 0.1.30-alpha.2

package/dist/testing-KLSV6CPJ.js

@@ -1,674 +0,0 @@
-#!/usr/bin/env node
-import {
-  StaleContractArtifactError,
-  isStaleContractArtifactError
-} from "./chunk-7FOO4AJI.js";
-import "./chunk-2H7UOFLK.js";
-
-// ../../node_modules/.pnpm/@dreamboard-games+sdk@0.4.0-alpha.0_@types+react-dom@19.2.3_@types+react@19.2.17__@type_b74cbe125b074769500a56e94fa7f664/node_modules/@dreamboard-games/sdk/dist/testing.js
-import { isDeepStrictEqual } from "util";
-function defineBase(definition) {
-  return definition;
-}
-function defineScenario(definition) {
-  return definition;
-}
-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 mismatch = matchPartial(actualValue, expectedValue, `${path}.${key}`);
-    if (mismatch) {
-      return mismatch;
-    }
-  }
-  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 mismatch = matchPartial(descriptor, opts, "interaction");
-  if (mismatch) {
-    throw new Error(mismatch);
-  }
-}
-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 mismatch = matchPartial(actual, expected);
-      if (mismatch) {
-        throw new Error(mismatch);
-      }
-    },
-    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);
-}
-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 buildPluginSnapshot(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)]
-            )
-          )
-        }
-      ];
-    })
-  );
-  return {
-    view: seat?.view ?? null,
-    gameplay: {
-      currentPhase: flow.currentPhase,
-      currentStage: projection.currentStage ?? null,
-      activePlayers: flow.activePlayers,
-      simultaneousPhase: projection.simultaneousPhase ?? null,
-      availableInteractions: hydrateRefs(
-        seat?.availableInteractionRefs
-      ),
-      zones
-    },
-    lobby: null,
-    notifications: [],
-    session: {
-      sessionId: options.sessionId,
-      controllablePlayerIds: [...options.playerIds],
-      controllingPlayerId: options.playerId || null,
-      userId: options.userId
-    },
-    history: null,
-    syncId: options.version
-  };
-}
-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 userId = options.userId ?? "test-user";
-  const sessionId = options.sessionId ?? "test-session";
-  let version = 0;
-  let submissionCounter = 0;
-  let currentPlayerId = playerIds[0] ?? "";
-  const diagnosticEvents = [];
-  let lastDispatch = null;
-  const stateListeners = /* @__PURE__ */ new Set();
-  const sessionListeners = /* @__PURE__ */ new Set();
-  const toReadySessionState = (snapshot) => ({
-    ...snapshot.session,
-    status: "ready"
-  });
-  let lastPluginSnapshot;
-  let lastSessionState;
-  const applyCurrentState = () => {
-    const previousSession = lastSessionState;
-    version += 1;
-    lastPluginSnapshot = buildPluginSnapshot({
-      state: currentState,
-      bundle: options.bundle,
-      playerId: currentPlayerId,
-      playerIds,
-      userId,
-      sessionId,
-      version,
-      expectedPhase: version === 1 ? options.phase : void 0,
-      baseId: options.baseId
-    });
-    lastSessionState = toReadySessionState(lastPluginSnapshot);
-    for (const listener of stateListeners) {
-      listener(lastPluginSnapshot);
-    }
-    if (!previousSession || previousSession.controllingPlayerId !== lastSessionState.controllingPlayerId || previousSession.controllablePlayerIds.join("\0") !== lastSessionState.controllablePlayerIds.join("\0")) {
-      for (const listener of sessionListeners) {
-        listener(lastSessionState);
-      }
-    }
-  };
-  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 submit = 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 setControllingPlayer = (playerId) => {
-    if (!playerIds.includes(playerId)) {
-      throw new Error(`Unknown controlling player '${playerId}'.`);
-    }
-    currentPlayerId = playerId;
-    applyCurrentState();
-  };
-  const runtime = {
-    validateInteraction: validate,
-    submitInteraction: submit,
-    getSessionState: () => lastSessionState,
-    disconnect: () => void 0,
-    switchPlayer: (playerId) => {
-      setControllingPlayer(playerId);
-    },
-    getSnapshot: () => lastPluginSnapshot,
-    subscribeToState: (listener) => {
-      stateListeners.add(listener);
-      return () => {
-        stateListeners.delete(listener);
-      };
-    },
-    _subscribeToSessionState: (listener) => {
-      sessionListeners.add(listener);
-      return () => {
-        sessionListeners.delete(listener);
-      };
-    }
-  };
-  return {
-    runtime,
-    getSnapshot: () => lastPluginSnapshot,
-    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,
-    validate,
-    explain,
-    diagnostics: {
-      get events() {
-        return diagnosticEvents;
-      },
-      get lastDispatch() {
-        return lastDispatch;
-      },
-      clear() {
-        diagnosticEvents.length = 0;
-        lastDispatch = null;
-      }
-    },
-    setControllingPlayer
-  };
-}
-export {
-  StaleContractArtifactError,
-  createExpectApi,
-  createTestRuntime,
-  defineBase,
-  defineScenario,
-  isStaleContractArtifactError
-};
-//# sourceMappingURL=testing-KLSV6CPJ.js.map