@joystyk/testing 0.0.0-stage → 0.2.0

package/dist/deep.js

@@ -0,0 +1,105 @@
+//#region src/deep.ts
+var describeValue = (value) => {
+	if (value === void 0) return "undefined";
+	if (typeof value === "number" && Object.is(value, -0)) return "-0";
+	if (typeof value === "function") return "a function";
+	try {
+		const text = JSON.stringify(value);
+		if (text === void 0) return String(value);
+		return text.length > 80 ? `${text.slice(0, 77)}...` : text;
+	} catch {
+		return String(value);
+	}
+};
+var isObject = (value) => typeof value === "object" && value !== null;
+var pathKey = (path, key) => /^[A-Za-z_$][\w$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+/**
+* The first place where `a` and `b` differ, as a readable path with both values, or null when
+* they are structurally equal. Numbers compare with `Object.is`, so `0` and `-0` differ, and
+* a missing key differs from a key holding `undefined`.
+*/
+var firstDifference = (a, b, path = "$") => {
+	if (Object.is(a, b)) return null;
+	if (!isObject(a) || !isObject(b)) return `${path}: ${describeValue(a)} vs ${describeValue(b)}`;
+	if (Array.isArray(a) !== Array.isArray(b)) return `${path}: ${describeValue(a)} vs ${describeValue(b)}`;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return `${path}.length: ${a.length} vs ${b.length}`;
+		for (let i = 0; i < a.length; i += 1) {
+			const d = firstDifference(a[i], b[i], `${path}[${i}]`);
+			if (d !== null) return d;
+		}
+		return null;
+	}
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	for (const key of keysA) if (!Object.hasOwn(b, key)) return `${pathKey(path, key)}: ${describeValue(a[key])} vs (missing)`;
+	for (const key of keysB) if (!Object.hasOwn(a, key)) return `${pathKey(path, key)}: (missing) vs ${describeValue(b[key])}`;
+	for (const key of keysA) {
+		const d = firstDifference(a[key], b[key], pathKey(path, key));
+		if (d !== null) return d;
+	}
+	return null;
+};
+/** True when `a` and `b` are structurally equal (see `firstDifference`). */
+var deepEqual = (a, b) => firstDifference(a, b) === null;
+/**
+* Freezes `value` and everything reachable from it, then returns it. The suites freeze every
+* state, command and input they hand to an engine, so an engine that mutates its input
+* throws instead of silently corrupting the game.
+*/
+var deepFreeze = (value) => {
+	if (isObject(value) && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const key of Object.keys(value)) deepFreeze(value[key]);
+	}
+	return value;
+};
+/**
+* Why `value` isn't JSON, with the path to the first offending part, or null when it is.
+* The contract's `isJson` answers yes or no; failure messages need the where and why.
+*/
+var jsonProblem = (value, path = "$", seen = /* @__PURE__ */ new Set()) => {
+	switch (typeof value) {
+		case "string":
+		case "boolean": return null;
+		case "number":
+			if (Object.is(value, -0)) return `-0 at ${path} (JSON turns it into 0)`;
+			return Number.isFinite(value) ? null : `${value} at ${path}`;
+		case "object": {
+			if (value === null) return null;
+			if (seen.has(value)) return `a cycle at ${path}`;
+			const proto = Object.getPrototypeOf(value);
+			if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) return `a ${value.constructor?.name ?? "class"} instance at ${path}`;
+			if (Object.getOwnPropertySymbols(value).length > 0) return `a symbol key at ${path}`;
+			seen.add(value);
+			try {
+				if (Array.isArray(value)) {
+					for (let i = 0; i < value.length; i += 1) {
+						if (!(i in value)) return `a hole at ${path}[${i}]`;
+						const problem = jsonProblem(value[i], `${path}[${i}]`, seen);
+						if (problem !== null) return problem;
+					}
+					return null;
+				}
+				for (const key of Object.keys(value)) {
+					const problem = jsonProblem(value[key], pathKey(path, key), seen);
+					if (problem !== null) return problem;
+				}
+				return null;
+			} finally {
+				seen.delete(value);
+			}
+		}
+		default: return `${value === void 0 ? "undefined" : typeof value} at ${path}`;
+	}
+};
+/** A JSON round trip: what a value looks like after a socket, a save or a replay file. */
+var jsonRoundTrip = (value) => JSON.parse(JSON.stringify(value));
+/** A short, single-line rendering of any value for failure messages. */
+var show = describeValue;
+/** The message of anything thrown. */
+var errorMessage = (error) => error instanceof Error ? `${error.name}: ${error.message}` : `thrown value ${describeValue(error)}`;
+//#endregion
+export { deepEqual, deepFreeze, errorMessage, firstDifference, jsonProblem, jsonRoundTrip, show };
+
+//# sourceMappingURL=deep.js.map

package/dist/deep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep.js","names":[],"sources":["../src/deep.ts"],"sourcesContent":["// Structural helpers for comparing and protecting values the suites pass around.\n\nconst describeValue = (value: unknown): string => {\n  if (value === undefined) return 'undefined';\n  if (typeof value === 'number' && Object.is(value, -0)) return '-0';\n  if (typeof value === 'function') return 'a function';\n  try {\n    const text = JSON.stringify(value);\n    if (text === undefined) return String(value);\n    return text.length > 80 ? `${text.slice(0, 77)}...` : text;\n  } catch {\n    return String(value);\n  }\n};\n\nconst isObject = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null;\n\nconst pathKey = (path: string, key: string): string =>\n  /^[A-Za-z_$][\\w$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;\n\n/**\n * The first place where `a` and `b` differ, as a readable path with both values, or null when\n * they are structurally equal. Numbers compare with `Object.is`, so `0` and `-0` differ, and\n * a missing key differs from a key holding `undefined`.\n */\nexport const firstDifference = (a: unknown, b: unknown, path = '$'): string | null => {\n  if (Object.is(a, b)) return null;\n  if (!isObject(a) || !isObject(b)) return `${path}: ${describeValue(a)} vs ${describeValue(b)}`;\n  if (Array.isArray(a) !== Array.isArray(b)) return `${path}: ${describeValue(a)} vs ${describeValue(b)}`;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return `${path}.length: ${a.length} vs ${b.length}`;\n    for (let i = 0; i < a.length; i += 1) {\n      const d = firstDifference(a[i], b[i], `${path}[${i}]`);\n      if (d !== null) return d;\n    }\n    return null;\n  }\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n  for (const key of keysA) {\n    if (!Object.hasOwn(b, key)) return `${pathKey(path, key)}: ${describeValue(a[key])} vs (missing)`;\n  }\n  for (const key of keysB) {\n    if (!Object.hasOwn(a, key)) return `${pathKey(path, key)}: (missing) vs ${describeValue(b[key])}`;\n  }\n  for (const key of keysA) {\n    const d = firstDifference(a[key], b[key], pathKey(path, key));\n    if (d !== null) return d;\n  }\n  return null;\n};\n\n/** True when `a` and `b` are structurally equal (see `firstDifference`). */\nexport const deepEqual = (a: unknown, b: unknown): boolean => firstDifference(a, b) === null;\n\n/**\n * Freezes `value` and everything reachable from it, then returns it. The suites freeze every\n * state, command and input they hand to an engine, so an engine that mutates its input\n * throws instead of silently corrupting the game.\n */\nexport const deepFreeze = <T>(value: T): T => {\n  if (isObject(value) && !Object.isFrozen(value)) {\n    Object.freeze(value);\n    for (const key of Object.keys(value)) deepFreeze(value[key]);\n  }\n  return value;\n};\n\n/**\n * Why `value` isn't JSON, with the path to the first offending part, or null when it is.\n * The contract's `isJson` answers yes or no; failure messages need the where and why.\n */\nexport const jsonProblem = (value: unknown, path = '$', seen: Set<object> = new Set()): string | null => {\n  switch (typeof value) {\n    case 'string':\n    case 'boolean':\n      return null;\n    case 'number':\n      if (Object.is(value, -0)) return `-0 at ${path} (JSON turns it into 0)`;\n      return Number.isFinite(value) ? null : `${value} at ${path}`;\n    case 'object': {\n      if (value === null) return null;\n      if (seen.has(value)) return `a cycle at ${path}`;\n      const proto: unknown = Object.getPrototypeOf(value);\n      if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) {\n        return `a ${(value as object).constructor?.name ?? 'class'} instance at ${path}`;\n      }\n      if (Object.getOwnPropertySymbols(value).length > 0) return `a symbol key at ${path}`;\n      seen.add(value);\n      try {\n        if (Array.isArray(value)) {\n          for (let i = 0; i < value.length; i += 1) {\n            if (!(i in value)) return `a hole at ${path}[${i}]`;\n            const problem = jsonProblem(value[i], `${path}[${i}]`, seen);\n            if (problem !== null) return problem;\n          }\n          return null;\n        }\n        for (const key of Object.keys(value)) {\n          const problem = jsonProblem((value as Record<string, unknown>)[key], pathKey(path, key), seen);\n          if (problem !== null) return problem;\n        }\n        return null;\n      } finally {\n        seen.delete(value);\n      }\n    }\n    default:\n      return `${value === undefined ? 'undefined' : typeof value} at ${path}`;\n  }\n};\n\n/** A JSON round trip: what a value looks like after a socket, a save or a replay file. */\nexport const jsonRoundTrip = <T>(value: T): T => JSON.parse(JSON.stringify(value)) as T;\n\n/** A short, single-line rendering of any value for failure messages. */\nexport const show = describeValue;\n\n/** The message of anything thrown. */\nexport const errorMessage = (error: unknown): string =>\n  error instanceof Error ? `${error.name}: ${error.message}` : `thrown value ${describeValue(error)}`;\n"],"mappings":"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"}

package/dist/engine-conformance.d.ts

@@ -0,0 +1,166 @@
+import { type DiscreteEngine, type EngineAssist, type EngineInput, type Json, type Migration, type Rng, type SeatId, type SeatInfo } from '@joystyk/contracts';
+import { type SaveFixture } from './builders.js';
+import { type ConformanceReport } from './report.js';
+/** One way to start a game: a config and the seats (a count, or explicit `SeatInfo`s). */
+export type EngineSetup<Config> = {
+    readonly config: Config;
+    readonly seats: number | readonly SeatInfo[];
+    readonly label?: string;
+};
+/**
+ * What an invariant hook returns: nothing or `true` when the state is fine; `false` or a
+ * message when it isn't. Throwing (for example from `expect`) also counts as a violation.
+ */
+export type InvariantResult = void | boolean | string;
+/** Save-related inputs for the `saves` check. */
+export type SaveOptions = {
+    /** The current save version (`GameVersions.save`). */
+    readonly version: number;
+    /** The oldest save version that was ever shipped. Default 1. */
+    readonly firstVersion?: number;
+    readonly migrations: readonly Migration[];
+    /** At least one stored state for every shipped save version, the current one included. */
+    readonly fixtures: readonly SaveFixture[];
+};
+/** Original successor snapshots: preserve what the viewer legitimately learns in them. */
+export type HiddenTransition<State, Command> = {
+    readonly input: EngineInput<Command>;
+    readonly states: readonly State[];
+};
+/** Options for `checkEngine` and `runEngineConformance`. */
+export type EngineConformanceOptions<State, Command, Config> = {
+    /** A name for reports and the vitest `describe` block. */
+    readonly name?: string;
+    /** The game id written into replays and saves. Default "test-game". */
+    readonly gameId?: string;
+    /** How to start games. Or give `configs` and `seatCounts`, and every pair is used. */
+    readonly setups?: readonly EngineSetup<Config>[];
+    readonly configs?: readonly Config[];
+    readonly seatCounts?: readonly number[];
+    /** Random games per setup. Default 12. */
+    readonly games?: number;
+    /** The base seed. Game `g` of setup `s` uses the seed string `${seed}/${s}/${g}`. Default "conformance". */
+    readonly seed?: string;
+    /** The most inputs one game may take. Default 400. */
+    readonly maxSteps?: number;
+    /** Fail a game that has no outcome after `maxSteps` inputs. Default true. */
+    readonly requireOutcome?: boolean;
+    /**
+     * Candidate commands for `seat` in `state`: every legal command, or a sample of them.
+     * Illegal candidates are fine; the engine's answer decides. Without it, the suite asks
+     * `engine.ai` for one command per pending seat.
+     */
+    readonly commands?: (state: State, seat: SeatId, rng: Rng) => readonly Command[];
+    /**
+     * Changes only what `viewer` may not see (other hands, the deck, a solution), usually with
+     * the kit's `perturbHidden`. Without it the no-leak check is skipped, which is right only
+     * for games whose state is entirely public.
+     */
+    readonly perturbHidden?: (state: State, viewer: SeatId | null, rng: Rng) => State;
+    /**
+     * Optional event-check retry: preserve the viewer's current and newly learned facts,
+     * including the input's required cards, while varying information that stays hidden.
+     * Separate from perturbHidden so legacy position helpers never receive transition work.
+     */
+    readonly perturbTransition?: (state: State, viewer: SeatId | null, rng: Rng, transition: HiddenTransition<State, Command>) => State;
+    /** Perturbations per viewer per position. Default 2. */
+    readonly perturbations?: number;
+    /** Called on every state the game reaches (after `init` and after every applied input). */
+    readonly invariants?: (state: State) => InvariantResult;
+    /**
+     * Which platform inputs the random games send. `resign` (default true) is accepted by every
+     * engine while the game is in progress; turn on `timeout` and `seatChanges` for engines
+     * that support clocks and seat hand-overs.
+     */
+    readonly platformInputs?: {
+        readonly resign?: boolean;
+        readonly timeout?: boolean;
+        readonly seatChanges?: boolean;
+    };
+    /** Fake job runners by job kind: they return the outcome's `value`. */
+    readonly jobs?: {
+        readonly [kind: string]: (payload: Json, rng: Rng) => Json;
+    };
+    /** How often a job fails instead (`{ ok: false }`). Default 0.1. */
+    readonly jobFailureRate?: number;
+    /**
+     * Which inputs the game's spec makes undo barriers. When given, every transition's
+     * `undoBarrier` must match it.
+     */
+    readonly undoBarrier?: (input: EngineInput<Command>, before: State, after: State) => boolean;
+    /**
+     * Which inputs the game's spec counts as assistance (a hint, a check, a reveal). When
+     * given, every transition's `assist` must match it.
+     */
+    readonly assist?: (input: EngineInput<Command>, before: State, after: State) => EngineAssist | null;
+    /** Save fixtures and migrations. Without them only the save round trip is checked. */
+    readonly saves?: SaveOptions;
+    /** Run only one game, to reproduce a reported failure. */
+    readonly only?: {
+        readonly setup: number;
+        readonly game: number;
+    };
+    /** Failures kept per check in the report. Default 3. */
+    readonly maxFailuresPerCheck?: number;
+};
+/** The checks this suite runs, in report order. */
+export declare const ENGINE_CHECKS: readonly [{
+    readonly id: "determinism";
+    readonly title: "Determinism: the same seed and inputs give the same states, beats, barriers and outcomes";
+}, {
+    readonly id: "replay";
+    readonly title: "Replay: the recorded log reproduces the final state";
+}, {
+    readonly id: "json";
+    readonly title: "JSON safety of configs, states, views, events, commands, jobs and decision keys";
+}, {
+    readonly id: "schemas";
+    readonly title: "Schema agreement: every value passes the engine's own schemas";
+}, {
+    readonly id: "no-leak";
+    readonly title: "No leaks: viewFor, eventFor and decisionKey ignore what the viewer may not see";
+}, {
+    readonly id: "rejections";
+    readonly title: "Rejected inputs change nothing: apply never throws or mutates, and rejects with a GameError";
+}, {
+    readonly id: "turns";
+    readonly title: "Turn discipline: only pending decisions and declared untimed side commands are allowed";
+}, {
+    readonly id: "resign";
+    readonly title: "Resignation is accepted from any seat, in turn or not, while the game is in progress";
+}, {
+    readonly id: "invariants";
+    readonly title: "Invariants hold on every state the game reaches";
+}, {
+    readonly id: "ai";
+    readonly title: "AI legality: ai.choose never returns a rejected command";
+}, {
+    readonly id: "saves";
+    readonly title: "Saves: round trip, restore and continue, and the migration chain from fixtures";
+}, {
+    readonly id: "jobs";
+    readonly title: "Job hygiene: job outcomes are accepted only while their job is awaited";
+}, {
+    readonly id: "stale";
+    readonly title: "Staleness: while a seat's decisionKey is unchanged, the commands it may send are unchanged";
+}, {
+    readonly id: "undo";
+    readonly title: "Undo by replay returns to the human's previous decision and never steps back past a barrier";
+}, {
+    readonly id: "assist";
+    readonly title: "Assistance: transitions flag hints, checks and reveals, and replay reproduces the flags";
+}, {
+    readonly id: "session-hooks";
+    readonly title: "Session hooks: startsClock is declared and set at most once a game, and worthSaving is pure";
+}, {
+    readonly id: "outcome";
+    readonly title: "Every game reaches a valid outcome in time, and a finished game rejects commands and resignations";
+}];
+/** The id of one engine check. */
+export type EngineCheckId = (typeof ENGINE_CHECKS)[number]['id'];
+/**
+ * Runs the Layer 2 conformance suite against `engine` and returns a report. It never throws
+ * for a failing check; it throws only for unusable options. Use `runEngineConformance` to get
+ * one vitest case per check instead.
+ */
+export declare const checkEngine: <State extends Json, Command extends Json, View extends Json, Event extends Json, Config extends Json>(engine: DiscreteEngine<State, Command, View, Event, Config>, options: EngineConformanceOptions<State, Command, Config>) => Promise<ConformanceReport>;