@table-games-engine/game-kit 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,593 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/exec.ts
+import { spawnSync } from "node:child_process";
+function runTool(cmd, args, cwd) {
+  const r = spawnSync(cmd, [...args], { cwd, stdio: "inherit", shell: process.platform === "win32" });
+  return r.status ?? 1;
+}
+var init_exec = __esm({
+  "src/exec.ts"() {
+    "use strict";
+  }
+});
+
+// schema/game.schema.json
+var game_schema_default;
+var init_game_schema = __esm({
+  "schema/game.schema.json"() {
+    game_schema_default = {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://github.com/Dmitry-Kucher/table-games-engine/game.schema.json",
+      title: "Store game metadata (game.json)",
+      type: "object",
+      definitions: {
+        localized: {
+          oneOf: [
+            { type: "string", minLength: 1 },
+            { type: "object", minProperties: 1, additionalProperties: { type: "string", minLength: 1 } }
+          ]
+        }
+      },
+      required: ["slug", "name", "version", "engine", "players", "locales", "description", "rules", "authors", "listed", "client"],
+      additionalProperties: false,
+      properties: {
+        $schema: { type: "string" },
+        slug: { type: "string", pattern: "^[a-z][a-z0-9-]{1,40}$" },
+        name: { $ref: "#/definitions/localized" },
+        version: { type: "string", pattern: "^\\d+\\.\\d+\\.\\d+$" },
+        engine: { type: "string", minLength: 1 },
+        players: {
+          type: "object",
+          required: ["min", "max"],
+          additionalProperties: false,
+          properties: { min: { type: "integer", minimum: 2 }, max: { type: "integer", minimum: 2 } }
+        },
+        locales: { type: "array", minItems: 1, uniqueItems: true, items: { type: "string", pattern: "^[a-z]{2}(-[A-Z]{2})?$" } },
+        description: { $ref: "#/definitions/localized" },
+        rules: { type: "object", minProperties: 1, additionalProperties: { type: "string", pattern: "\\.md$" } },
+        tags: { type: "array", items: { type: "string" } },
+        cover: { type: "string" },
+        authors: { type: "array", minItems: 1, items: { type: "string", minLength: 1 } },
+        credits: { type: "string" },
+        listed: { type: "boolean" },
+        client: {
+          type: "object",
+          required: ["kind", "entry"],
+          additionalProperties: false,
+          properties: { kind: { enum: ["iframe"] }, entry: { type: "string", minLength: 1 } }
+        },
+        presets: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "object",
+            required: ["id", "name", "config"],
+            additionalProperties: false,
+            properties: {
+              id: { type: "string", pattern: "^[a-z0-9-]+$" },
+              name: { $ref: "#/definitions/localized" },
+              config: { type: "object" }
+            }
+          }
+        },
+        simulation: {
+          type: "object",
+          additionalProperties: false,
+          properties: { maxSteps: { type: "integer", minimum: 1 } }
+        }
+      }
+    };
+  }
+});
+
+// src/game-json.ts
+import Ajv from "ajv";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+function validateGameJson(raw, dir) {
+  if (!validateSchema(raw)) {
+    return {
+      ok: false,
+      errors: (validateSchema.errors ?? []).map((e) => `${e.instancePath || "/"} ${e.message ?? "invalid"}`)
+    };
+  }
+  const game = raw;
+  const errors = [];
+  const coverage = (field, value) => {
+    if (typeof value === "string") return;
+    for (const l of game.locales) if (!value[l]) errors.push(`${field}: missing locale "${l}"`);
+  };
+  coverage("name", game.name);
+  coverage("description", game.description);
+  game.presets?.forEach((p, i) => coverage(`presets[${i}].name`, p.name));
+  for (const l of game.locales) {
+    const file = game.rules[l];
+    if (!file) errors.push(`rules: missing locale "${l}"`);
+    else if (!existsSync2(join2(dir, file))) errors.push(`rules.${l}: file "${file}" not found`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of game.presets ?? []) {
+    if (seen.has(p.id)) errors.push(`presets: duplicate id "${p.id}"`);
+    seen.add(p.id);
+  }
+  if (game.players.min > game.players.max) errors.push(`players: min (${game.players.min}) > max (${game.players.max})`);
+  return errors.length > 0 ? { ok: false, errors } : { ok: true, game };
+}
+var DEFAULT_MAX_STEPS, validateSchema;
+var init_game_json = __esm({
+  "src/game-json.ts"() {
+    "use strict";
+    init_game_schema();
+    DEFAULT_MAX_STEPS = 2e3;
+    validateSchema = new Ajv({ allErrors: true }).compile(game_schema_default);
+  }
+});
+
+// src/load-game.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import { pathToFileURL } from "node:url";
+import { tsImport } from "tsx/esm/api";
+async function loadGame(dir) {
+  const checked = validateGameJson(JSON.parse(readFileSync2(join3(dir, "game.json"), "utf8")), dir);
+  if (!checked.ok) throw new Error(`game.json is invalid:
+  ${checked.errors.join("\n  ")}`);
+  const mod = await tsImport(pathToFileURL(join3(dir, "logic/index.ts")).href, import.meta.url);
+  if (!mod.default) throw new Error("logic/index.ts must `export default` the GamePlugin");
+  return { game: checked.game, plugin: mod.default };
+}
+var init_load_game = __esm({
+  "src/load-game.ts"() {
+    "use strict";
+    init_game_json();
+  }
+});
+
+// src/preview.ts
+var preview_exports = {};
+__export(preview_exports, {
+  preview: () => preview
+});
+import { copyFileSync, mkdirSync } from "node:fs";
+import { join as join5 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { build as esbuild } from "esbuild";
+import { build as viteBuild, createServer, preview as vitePreview } from "vite";
+async function preview(dir, opts) {
+  const { game, plugin } = await loadGame(dir);
+  const preset = opts.preset ? game.presets?.find((p) => p.id === opts.preset) : game.presets?.[0];
+  if (opts.preset && !preset) throw new Error(`unknown preset "${opts.preset}"`);
+  const locale = opts.locale ?? game.locales[0];
+  if (!game.locales.includes(locale)) throw new Error(`locale "${locale}" is not in game.json locales`);
+  const work = join5(dir, ".game-kit");
+  mkdirSync(join5(work, "build"), { recursive: true });
+  await esbuild({
+    entryPoints: [join5(KIT, "nakama/init.ts")],
+    outfile: join5(work, "build/index.js"),
+    bundle: true,
+    platform: "neutral",
+    format: "cjs",
+    target: "es2017",
+    treeShaking: false,
+    external: ["better-sqlite3"],
+    alias: {
+      __game__: join5(dir, "logic/index.ts"),
+      "@table-games-engine/persistence": "@table-games-engine/persistence/core"
+    },
+    logLevel: "warning"
+  });
+  copyFileSync(join5(KIT, "nakama/docker-compose.yml"), join5(work, "docker-compose.yml"));
+  copyFileSync(join5(KIT, "nakama/local.yml"), join5(work, "local.yml"));
+  const project = `game-kit-${game.slug}`;
+  let stop;
+  const stopped = new Promise((resolve) => {
+    stop = resolve;
+  });
+  process.on("SIGINT", () => stop());
+  process.on("SIGTERM", () => stop());
+  let client;
+  let host;
+  const setup = async () => {
+    if (runTool("docker", ["compose", "-p", project, "up", "-d", "--wait"], work) !== 0) {
+      throw new Error("docker compose up failed \u2014 is Docker running and port 7350 free?");
+    }
+    await viteBuild({ root: join5(dir, "client"), logLevel: "warn", build: { outDir: "dist", emptyOutDir: true } });
+    const cs = await vitePreview({
+      root: join5(dir, "client"),
+      preview: { cors: true, host: "127.0.0.1", port: CLIENT_PORT, strictPort: true, headers: { "Content-Security-Policy": "connect-src 'none'" } }
+    });
+    client = { close: () => new Promise((r) => cs.httpServer.close(() => r())) };
+    const title = typeof game.name === "string" ? game.name : game.name[locale] ?? game.slug;
+    const hs = await createServer({
+      root: join5(KIT, "host"),
+      server: { host: "127.0.0.1", port: HOST_PORT, strictPort: true, fs: { allow: [KIT] } },
+      define: {
+        __GAME_KIT__: JSON.stringify({
+          gameId: String(plugin.id),
+          config: preset?.config ?? {},
+          locale,
+          clientUrl: `http://127.0.0.1:${CLIENT_PORT}/`,
+          title
+        })
+      }
+    });
+    host = hs;
+    await hs.listen();
+    console.log(`preview: http://127.0.0.1:${HOST_PORT}/  (preset=${preset?.id ?? "none"}, locale=${locale}) \u2014 Ctrl+C to stop`);
+  };
+  try {
+    const ready = setup();
+    ready.catch(() => {
+    });
+    await Promise.race([ready, stopped]);
+    await stopped;
+  } finally {
+    console.log("preview: tearing down\u2026");
+    await host?.close();
+    await client?.close();
+    runTool("docker", ["compose", "-p", project, "down", "-v"], work);
+  }
+}
+var KIT, HOST_PORT, CLIENT_PORT;
+var init_preview = __esm({
+  "src/preview.ts"() {
+    "use strict";
+    init_load_game();
+    init_exec();
+    KIT = fileURLToPath2(new URL("..", import.meta.url));
+    HOST_PORT = 5173;
+    CLIENT_PORT = 5174;
+  }
+});
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+
+// src/create.ts
+init_exec();
+import { cpSync, existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+var TEMPLATE = fileURLToPath(new URL("../template", import.meta.url));
+var FILLED = ["package.json", "game.json", "rules.md", "AGENTS.md", "logic/index.ts"];
+function createGame(cwd, slug, opts) {
+  if (!/^[a-z][a-z0-9-]{1,40}$/.test(slug)) {
+    throw new Error(`invalid slug "${slug}": use lowercase letters, digits and dashes (e.g. "dragon-duel")`);
+  }
+  const target = join(cwd, slug);
+  if (existsSync(target)) throw new Error(`${target} already exists`);
+  const template = opts.template ?? TEMPLATE;
+  cpSync(template, target, { recursive: true, filter: (src) => !relative(template, src).split(sep).includes("node_modules") });
+  renameSync(join(target, "gitignore"), join(target, ".gitignore"));
+  const name = slug.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
+  for (const f of FILLED) {
+    const p = join(target, f);
+    writeFileSync(p, readFileSync(p, "utf8").replaceAll("__SLUG__", slug).replaceAll("__NAME__", name));
+  }
+  if (opts.install && runTool("npm", ["install"], target) !== 0) throw new Error("npm install failed");
+  return target;
+}
+
+// src/check.ts
+init_game_json();
+init_load_game();
+import { readFileSync as readFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+import { build } from "vite";
+
+// src/lint.ts
+import { relative as relative2 } from "node:path";
+import { ESLint } from "eslint";
+import tseslint from "typescript-eslint";
+var ALLOWED = "may import only @table-games-engine/core and relative paths";
+var allowedImports = {
+  meta: { type: "problem", schema: [] },
+  create(context) {
+    const check = (node, source) => {
+      if (typeof source !== "string") return;
+      if (source === "@table-games-engine/core" || source.startsWith("./") || source.startsWith("../")) return;
+      context.report({ node, message: `Store game logic ${ALLOWED} (found "${source}").` });
+    };
+    return {
+      ImportDeclaration: (n) => check(n, n.source.value),
+      ExportNamedDeclaration: (n) => n.source && check(n, n.source.value),
+      ExportAllDeclaration: (n) => check(n, n.source.value),
+      ImportExpression: (n) => context.report({ node: n, message: `Dynamic import is not allowed; logic ${ALLOWED}.` })
+    };
+  }
+};
+var NONDETERMINISM = "is non-deterministic or environment-dependent; use ctx.random*/state instead";
+var logicLintConfig = [
+  {
+    files: ["logic/**/*.ts"],
+    languageOptions: { parser: tseslint.parser },
+    plugins: { "game-kit": { rules: { "allowed-imports": allowedImports } } },
+    rules: {
+      "game-kit/allowed-imports": "error",
+      "no-restricted-properties": ["error", { object: "Math", property: "random", message: `Math.random ${NONDETERMINISM}.` }],
+      "no-restricted-globals": [
+        "error",
+        ...["Date", "globalThis", "window", "process", "setTimeout", "setInterval", "fetch", "require"].map((name) => ({
+          name,
+          message: `'${name}' ${NONDETERMINISM}.`
+        }))
+      ],
+      "no-restricted-syntax": [
+        "error",
+        ...["let", "var"].flatMap((kind) => [
+          { selector: `Program > VariableDeclaration[kind='${kind}']`, message: `module-level '${kind}' is shared mutable state across matches.` },
+          { selector: `Program > ExportNamedDeclaration > VariableDeclaration[kind='${kind}']`, message: `module-level '${kind}' is shared mutable state across matches.` }
+        ])
+      ]
+    }
+  }
+];
+async function lintLogic(dir) {
+  const eslint = new ESLint({ cwd: dir, overrideConfigFile: true, overrideConfig: logicLintConfig });
+  const results = await eslint.lintFiles(["logic/**/*.ts"]);
+  const lines = results.flatMap(
+    (r) => r.messages.map((m) => `${relative2(dir, r.filePath)}:${m.line}:${m.column} ${m.message}`)
+  );
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+
+// src/simulate.ts
+import { createHash } from "node:crypto";
+import {
+  driveAction,
+  rulesFromPlugin,
+  setupMatch
+} from "@table-games-engine/core";
+var MOVE_WARN_LIMIT = 5e3;
+var DEFAULT_PRESET = { id: "default", name: "Default", config: {} };
+function runSimulation(plugin, opts) {
+  if (!plugin.legalMoves) {
+    return { ok: false, played: 0, warnings: [], failures: [{ preset: "-", players: 0, seed: opts.seed, step: 0, reason: "plugin has no legalMoves", lastMoves: [] }] };
+  }
+  const failures = [];
+  const warnings = /* @__PURE__ */ new Set();
+  let played = 0;
+  for (const preset of opts.presets.length > 0 ? opts.presets : [DEFAULT_PRESET]) {
+    for (const players of opts.players) {
+      for (let i = 0; i < opts.matches; i++) {
+        const seed = opts.seed + i;
+        const first = playMatch(plugin, preset, players, seed, opts, warnings);
+        played += 1;
+        if (first.failure) {
+          failures.push(first.failure);
+          continue;
+        }
+        const replay = playMatch(plugin, preset, players, seed, opts, warnings);
+        if (replay.failure || replay.hash !== first.hash) {
+          failures.push({
+            preset: preset.id,
+            players,
+            seed,
+            step: first.step,
+            reason: "non-deterministic: replaying the same seed produced a different final state",
+            lastMoves: first.moves.slice(-20)
+          });
+        }
+      }
+    }
+  }
+  return { ok: failures.length === 0, played, failures, warnings: [...warnings] };
+}
+function playMatch(plugin, preset, players, seed, opts, warnings) {
+  const moves = [];
+  const fail = (step, reason) => ({
+    failure: { preset: preset.id, players, seed, step, reason, lastMoves: moves.slice(-20) },
+    hash: "",
+    step,
+    moves
+  });
+  const playerIds = Array.from({ length: players }, (_, i) => `p${i + 1}`);
+  let state;
+  try {
+    state = setupMatch(plugin, { playerIds, config: preset.config, seed: `sim-${seed}` });
+  } catch (e) {
+    return fail(0, `setup threw: ${message(e)}`);
+  }
+  const rules = rulesFromPlugin(plugin);
+  const random = mulberry32(seed);
+  for (let step = 0; step < opts.maxSteps; step++) {
+    if (state.result) return { failure: null, hash: hashState(state), step, moves };
+    const actor = state.priority.holder ?? state.turn.activePlayer;
+    let options;
+    try {
+      options = plugin.legalMoves(state, actor);
+    } catch (e) {
+      return fail(step, `legalMoves threw: ${message(e)}`);
+    }
+    if (options.length === 0) return fail(step, `legalMoves is empty for ${String(actor)}, who must act`);
+    if (options.length > MOVE_WARN_LIMIT) {
+      warnings.add(`${preset.id}: legalMoves returned ${options.length} moves (> ${MOVE_WARN_LIMIT})`);
+    }
+    const move = options[Math.floor(random() * options.length)];
+    moves.push(move);
+    let driven;
+    try {
+      driven = driveAction(rules, state, { ...move, clientId: `sim-${step}`, stateVersion: state.version });
+    } catch (e) {
+      return fail(step, `game logic threw: ${message(e)}`);
+    }
+    if (!driven.ok) {
+      const why = driven.error.valid ? "unknown" : `${driven.error.error.code}: ${driven.error.error.message}`;
+      return fail(step, `legalMoves offered a move the engine rejected (${why})`);
+    }
+    state = driven.state;
+  }
+  return state.result ? { failure: null, hash: hashState(state), step: opts.maxSteps, moves } : fail(opts.maxSteps, `no result after maxSteps=${opts.maxSteps}`);
+}
+function formatReport(r) {
+  const lines = [`simulate: ${r.played} matches, ${r.failures.length} failed`];
+  for (const w of r.warnings) lines.push(`  warning: ${w}`);
+  for (const f of r.failures.slice(0, 5)) {
+    lines.push(`  FAIL preset=${f.preset} players=${f.players} seed=${f.seed} step=${f.step}: ${f.reason}`);
+    lines.push(`    replay: game-kit simulate --preset ${f.preset} --players ${f.players} --seed ${f.seed} -n 1`);
+    for (const m of f.lastMoves) lines.push(`    ${JSON.stringify(m)}`);
+  }
+  return lines.join("\n");
+}
+function hashState(s) {
+  return createHash("sha256").update(JSON.stringify(s)).digest("hex");
+}
+function message(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// src/check.ts
+init_exec();
+async function runCheck(dir, stages = defaultStages) {
+  for (const stage of stages) {
+    let failure;
+    try {
+      failure = await stage.run(dir);
+    } catch (e) {
+      failure = e instanceof Error ? e.message : String(e);
+    }
+    if (failure !== null) return { ok: false, failedStage: stage.name, message: failure };
+  }
+  return { ok: true };
+}
+var tool = (name, cmd, args) => ({
+  name,
+  run: async (dir) => runTool(cmd, args, dir) === 0 ? null : `${cmd} ${args.join(" ")} failed`
+});
+function simulateStage(opts) {
+  return {
+    name: "simulate",
+    run: async (dir) => {
+      const { game, plugin } = await loadGame(dir);
+      const presets = (game.presets ?? []).filter((p) => !opts.preset || p.id === opts.preset);
+      if (opts.preset && presets.length === 0) return `unknown preset "${opts.preset}"`;
+      const { min, max } = game.players;
+      if (opts.players !== void 0 && (opts.players < min || opts.players > max)) {
+        return `--players ${opts.players} is outside game.json players (${min}..${max})`;
+      }
+      const report = runSimulation(plugin, {
+        matches: opts.matches,
+        seed: opts.seed,
+        maxSteps: game.simulation?.maxSteps ?? DEFAULT_MAX_STEPS,
+        players: opts.players !== void 0 ? [opts.players] : Array.from({ length: max - min + 1 }, (_, i) => min + i),
+        presets
+      });
+      console.log(formatReport(report));
+      return report.ok ? null : "simulation failed (see above)";
+    }
+  };
+}
+var defaultStages = [
+  {
+    name: "game.json",
+    run: async (dir) => {
+      const r = validateGameJson(JSON.parse(readFileSync3(join4(dir, "game.json"), "utf8")), dir);
+      return r.ok ? null : r.errors.join("\n");
+    }
+  },
+  { name: "lint", run: lintLogic },
+  tool("typecheck", "npx", ["tsc", "--noEmit", "-p", "."]),
+  tool("test", "npx", ["vitest", "run"]),
+  simulateStage({ matches: 1e3, seed: 1 }),
+  {
+    name: "client-build",
+    run: async (dir) => {
+      await build({ root: join4(dir, "client"), logLevel: "warn", build: { outDir: "dist", emptyOutDir: true } });
+      return null;
+    }
+  }
+];
+
+// src/cli.ts
+init_exec();
+var USAGE = `game-kit <command>
+  create <slug> [--no-install]     scaffold a new store game
+  test                             run the game's tests
+  simulate [-n 1000] [--seed 1] [--preset id] [--players N]   (default: every count in game.json players)
+  check                            everything CI runs (game.json, lint, tsc, tests, simulate, client build)
+  preview [--preset id] [--locale xx]   play both seats locally (needs Docker)`;
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+  const { values, positionals } = parseArgs({
+    args: rest,
+    allowPositionals: true,
+    options: {
+      n: { type: "string", short: "n" },
+      seed: { type: "string" },
+      preset: { type: "string" },
+      players: { type: "string" },
+      locale: { type: "string" },
+      "no-install": { type: "boolean" }
+    }
+  });
+  const cwd = process.cwd();
+  switch (cmd) {
+    case "create": {
+      const slug = positionals[0];
+      if (!slug) break;
+      const dir = createGame(cwd, slug, { install: !values["no-install"] });
+      console.log(`created ${dir}
+next: cd ${slug} && npx game-kit check`);
+      return 0;
+    }
+    case "test":
+      return runTool("npx", ["vitest", "run"], cwd);
+    case "simulate": {
+      const matches = int(values.n ?? "1000", "-n", 1);
+      const seed = int(values.seed ?? "1", "--seed", 0);
+      const players = values.players === void 0 ? void 0 : int(values.players, "--players", 1);
+      if (matches === null || seed === null || players === null) return 1;
+      const stage = simulateStage({
+        matches,
+        seed,
+        ...values.preset ? { preset: values.preset } : {},
+        ...players !== void 0 ? { players } : {}
+      });
+      const r = await runCheck(cwd, [stage]);
+      if (!r.ok) console.error(r.message);
+      return r.ok ? 0 : 1;
+    }
+    case "check": {
+      const r = await runCheck(cwd, defaultStages);
+      console.log(r.ok ? "check: OK" : `check: FAILED at ${r.failedStage}
+${r.message}`);
+      return r.ok ? 0 : 1;
+    }
+    case "preview": {
+      const { preview: preview2 } = await Promise.resolve().then(() => (init_preview(), preview_exports));
+      await preview2(cwd, { ...values.preset ? { preset: values.preset } : {}, ...values.locale ? { locale: values.locale } : {} });
+      return 0;
+    }
+  }
+  console.log(USAGE);
+  return cmd ? 1 : 0;
+}
+function int(raw, flag, min) {
+  if (/^\d+$/.test(raw) && Number(raw) >= min) return Number(raw);
+  console.error(`${flag} must be an integer >= ${min}, got "${raw}"`);
+  return null;
+}
+main().then((code) => process.exit(code), (e) => {
+  console.error(e instanceof Error ? e.message : e);
+  process.exit(1);
+});

package/dist/create.d.ts

@@ -0,0 +1,4 @@
+export declare function createGame(cwd: string, slug: string, opts: {
+    install: boolean;
+    template?: string;
+}): string;

package/dist/exec.d.ts

@@ -0,0 +1 @@
+export declare function runTool(cmd: string, args: ReadonlyArray<string>, cwd: string): number;

package/dist/game-json.d.ts

@@ -0,0 +1,41 @@
+import type { JsonObject } from '@table-games-engine/core';
+export type Localized = string | Readonly<Record<string, string>>;
+export interface Preset {
+    readonly id: string;
+    readonly name: Localized;
+    readonly config: JsonObject;
+}
+export interface GameJson {
+    readonly slug: string;
+    readonly name: Localized;
+    readonly version: string;
+    readonly engine: string;
+    readonly players: {
+        readonly min: number;
+        readonly max: number;
+    };
+    readonly locales: ReadonlyArray<string>;
+    readonly description: Localized;
+    readonly rules: Readonly<Record<string, string>>;
+    readonly tags?: ReadonlyArray<string>;
+    readonly cover?: string;
+    readonly authors: ReadonlyArray<string>;
+    readonly credits?: string;
+    readonly listed: boolean;
+    readonly client: {
+        readonly kind: 'iframe';
+        readonly entry: string;
+    };
+    readonly presets?: ReadonlyArray<Preset>;
+    readonly simulation?: {
+        readonly maxSteps?: number;
+    };
+}
+export declare const DEFAULT_MAX_STEPS = 2000;
+export declare function validateGameJson(raw: unknown, dir: string): {
+    ok: true;
+    game: GameJson;
+} | {
+    ok: false;
+    errors: string[];
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { validateGameJson, DEFAULT_MAX_STEPS } from './game-json.js';
+export type { GameJson, Localized, Preset } from './game-json.js';
+export { loadGame } from './load-game.js';
+export { runSimulation, formatReport } from './simulate.js';
+export type { SimulateOptions, SimulateReport, MatchFailure } from './simulate.js';
+export { runCheck, defaultStages, simulateStage } from './check.js';
+export type { Stage } from './check.js';
+export { lintLogic } from './lint.js';