maze-test 0.1.0 → 0.3.0

package/dist/cli.cjs

@@ -0,0 +1,1591 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_process = __toESM(require("process"), 1);
+
+// src/coordinates.ts
+function cell(row, col) {
+  return { row, col };
+}
+function cellKey(value) {
+  return `${value.row},${value.col}`;
+}
+function sameCell(a, b) {
+  return a?.row === b?.row && a?.col === b?.col;
+}
+function columnLabel(col) {
+  if (!Number.isInteger(col) || col < 1) throw new Error(`Invalid column number: ${col}`);
+  let value = col;
+  let label = "";
+  while (value > 0) {
+    value -= 1;
+    label = String.fromCharCode(65 + value % 26) + label;
+    value = Math.floor(value / 26);
+  }
+  return label;
+}
+function letterNumberCoordinate(value) {
+  return `${columnLabel(value.col)}${value.row}`;
+}
+function neighbors(value, rows, cols) {
+  return [
+    cell(value.row - 1, value.col),
+    cell(value.row + 1, value.col),
+    cell(value.row, value.col - 1),
+    cell(value.row, value.col + 1)
+  ].filter((item) => item.row >= 1 && item.row <= rows && item.col >= 1 && item.col <= cols);
+}
+
+// src/mechanisms.ts
+var MATERIALS = ["copper", "silver", "gold"];
+var TREASURE_TYPES = ["treasure", "coin", "gem", "relic"];
+var POTION_KINDS = ["healing", "poison", "antidote", "haste", "slow"];
+function mechanismPreset(complexity) {
+  if (complexity === "basic") {
+    return {
+      complexity,
+      trapDamages: [1],
+      potionKinds: ["healing"],
+      keyMaterials: [],
+      treasureTypes: ["treasure"],
+      poisonDamage: 1,
+      poisonDuration: 3,
+      speedDuration: 4,
+      movementTime: { normal: 1, fast: 1, slow: 1 }
+    };
+  }
+  if (complexity === "intermediate") {
+    return {
+      complexity,
+      trapDamages: [1, 2, 3],
+      potionKinds: ["healing", "poison", "antidote"],
+      keyMaterials: [],
+      treasureTypes: ["coin", "gem", "relic"],
+      poisonDamage: 1,
+      poisonDuration: 3,
+      speedDuration: 4,
+      movementTime: { normal: 1, fast: 1, slow: 1 }
+    };
+  }
+  return {
+    complexity,
+    trapDamages: [1, 2, 3],
+    potionKinds: ["healing", "poison", "antidote", "haste", "slow"],
+    keyMaterials: ["copper", "silver", "gold"],
+    treasureTypes: ["coin", "gem", "relic"],
+    poisonDamage: 1,
+    poisonDuration: 3,
+    speedDuration: 4,
+    movementTime: { normal: 2, fast: 1, slow: 3 }
+  };
+}
+function resolveMechanisms(options) {
+  const complexity = options.complexity ?? "basic";
+  if (!isComplexity(complexity)) throw new Error(`Unknown complexity: ${String(complexity)}`);
+  const preset = mechanismPreset(complexity);
+  const trapDamages = options.trapDamages ?? preset.trapDamages;
+  const potionKinds = options.potionKinds ?? preset.potionKinds;
+  const keyMaterials = options.keyMaterials ?? preset.keyMaterials;
+  const treasureTypes = options.treasureTypes ?? preset.treasureTypes;
+  validatePositiveList(trapDamages, "trapDamages");
+  validateEnumList(potionKinds, POTION_KINDS, "potionKinds");
+  validateEnumList(keyMaterials, MATERIALS, "keyMaterials", true);
+  validateEnumList(treasureTypes, TREASURE_TYPES, "treasureTypes");
+  if (complexity !== "advanced" && potionKinds.some((kind) => kind === "haste" || kind === "slow")) {
+    throw new Error("Haste and slow potions require advanced complexity so their movement-time costs are defined.");
+  }
+  if (complexity === "advanced" && keyMaterials.length === 0) {
+    throw new Error("Advanced complexity requires at least one key material.");
+  }
+  return {
+    ...preset,
+    trapDamages: [...trapDamages],
+    potionKinds: [...potionKinds],
+    keyMaterials: [...keyMaterials],
+    treasureTypes: [...treasureTypes],
+    poisonDamage: positiveInteger(options.poisonDamage ?? preset.poisonDamage, "poisonDamage"),
+    poisonDuration: positiveInteger(
+      options.poisonDuration ?? preset.poisonDuration,
+      "poisonDuration"
+    ),
+    speedDuration: positiveInteger(options.speedDuration ?? preset.speedDuration, "speedDuration")
+  };
+}
+function defaultObjectCounts(complexity) {
+  if (complexity === "basic") return { doors: 1, chests: 2, traps: 2, potions: 2 };
+  if (complexity === "intermediate") return { doors: 2, chests: 3, traps: 3, potions: 3 };
+  return { doors: 3, chests: 3, traps: 3, potions: 5 };
+}
+function emptyMaterialCounts(values = {}) {
+  return {
+    copper: values.copper ?? 0,
+    silver: values.silver ?? 0,
+    gold: values.gold ?? 0
+  };
+}
+function emptyTreasureCounts(values = {}) {
+  return {
+    treasure: values.treasure ?? 0,
+    coin: values.coin ?? 0,
+    gem: values.gem ?? 0,
+    relic: values.relic ?? 0
+  };
+}
+function totalMaterialKeys(counts) {
+  return counts.copper + counts.silver + counts.gold;
+}
+function isComplexity(value) {
+  return value === "basic" || value === "intermediate" || value === "advanced";
+}
+function positiveInteger(value, name) {
+  if (!Number.isInteger(value) || value < 1) throw new Error(`${name} must be a positive integer.`);
+  return value;
+}
+function validatePositiveList(values, name) {
+  if (values.length === 0) throw new Error(`${name} must not be empty.`);
+  for (const value of values) positiveInteger(value, name);
+}
+function validateEnumList(values, allowed, name, allowEmpty = false) {
+  if (!allowEmpty && values.length === 0) throw new Error(`${name} must not be empty.`);
+  for (const value of values) {
+    if (!allowed.includes(value)) throw new Error(`Unknown ${name} value: ${value}`);
+  }
+}
+
+// src/maze.ts
+function generateSolidCellMaze(options = {}) {
+  const rows = oddDimension(options.rows ?? 15, "rows");
+  const cols = oddDimension(options.cols ?? 15, "cols");
+  const seed = integerOption(options.seed ?? 1, "seed", 0);
+  const requestedSeed = integerOption(options.requestedSeed ?? seed, "requestedSeed", 0);
+  const braid = numberOption(options.braid ?? 0, "braid", 0, 1);
+  const mechanisms = options.mechanisms ?? mechanismPreset("basic");
+  const rng = mulberry32(seed);
+  const grid = Array.from({ length: rows }, () => Array(cols).fill("#"));
+  const logicalCells = [];
+  for (let row = 1; row < rows - 1; row += 2) {
+    for (let col = 1; col < cols - 1; col += 2) logicalCells.push({ row, col });
+  }
+  const start = logicalCells[randomInt(rng, logicalCells.length)];
+  if (!start) throw new Error("The maze has no logical cells.");
+  const visited = /* @__PURE__ */ new Set([cellKey(start)]);
+  const stack = [start];
+  grid[start.row][start.col] = ".";
+  while (stack.length > 0) {
+    const current = stack.at(-1);
+    if (!current) break;
+    const choices = shuffle(
+      rng,
+      logicalNeighbors(current, rows, cols).filter((item) => !visited.has(cellKey(item)))
+    );
+    const next = choices[0];
+    if (!next) {
+      stack.pop();
+      continue;
+    }
+    grid[(current.row + next.row) / 2][(current.col + next.col) / 2] = ".";
+    grid[next.row][next.col] = ".";
+    visited.add(cellKey(next));
+    stack.push(next);
+  }
+  braidDeadEnds(grid, braid, rng);
+  const terrain = grid.map((row) => row.join(""));
+  const first = farthestFloor(cell(2, 2), terrain).cell;
+  const second = farthestFloor(first, terrain).cell;
+  const maze = {
+    schemaVersion: "solid-cell-maze-v4@1",
+    id: options.id ?? `solid-maze-${rows}x${cols}-${requestedSeed}`,
+    seed,
+    requestedSeed,
+    rows,
+    cols,
+    braid,
+    coordinateSystem: {
+      origin: "top-left",
+      columns: "letters-left-to-right",
+      rows: "numbers-top-to-bottom"
+    },
+    mechanisms: structuredClone(mechanisms),
+    terrain,
+    entry: first,
+    goal: second,
+    doors: [],
+    objects: [],
+    metrics: emptyMetrics(rows, cols)
+  };
+  maze.metrics = analyzeSolidCellMaze(maze);
+  return maze;
+}
+function decorateSolidCellMaze(maze, options = {}) {
+  const result = structuredClone(maze);
+  const mechanisms = options.mechanisms ?? maze.mechanisms ?? mechanismPreset("basic");
+  result.mechanisms = structuredClone(mechanisms);
+  const decorationSeed = integerOption(options.seed ?? maze.seed + 71311, "decoration seed", 0);
+  const rng = mulberry32(decorationSeed);
+  const mainPath = shortestPath(result, result.entry, result.goal);
+  const occupied = /* @__PURE__ */ new Set([cellKey(result.entry), cellKey(result.goal)]);
+  const doorCount = integerOption(
+    options.doorCount ?? Math.max(1, Math.floor(result.metrics.floorCells / 120)),
+    "doorCount",
+    0
+  );
+  const chestCount = integerOption(options.chestCount ?? 2, "chestCount", 0);
+  const trapCount = integerOption(options.trapCount ?? 2, "trapCount", 0);
+  const potionCount = integerOption(
+    options.potionCount ?? options.medicineCount ?? 2,
+    "potionCount",
+    0
+  );
+  const doorIndices = selectGatingDoorIndices(result, mainPath, doorCount);
+  result.doors = doorIndices.map((index, doorIndex) => {
+    const position = mainPath[index];
+    if (!position) throw new Error(`No path cell exists at door index ${index}.`);
+    occupied.add(cellKey(position));
+    const material = cyclicValue(mechanisms.keyMaterials, doorIndex + decorationSeed);
+    return {
+      id: `door-${doorIndex + 1}`,
+      position,
+      state: "closed",
+      ...material ? { material } : {}
+    };
+  });
+  const objects = [];
+  for (let index = 0; index < result.doors.length; index += 1) {
+    const doorIndex = doorIndices[index];
+    if (doorIndex === void 0) throw new Error("Door index mismatch.");
+    const preferredIndex = Math.max(1, Math.floor(doorIndex * 0.55));
+    const position = freePathCellBefore(mainPath, preferredIndex, occupied);
+    occupied.add(cellKey(position));
+    const door = result.doors[index];
+    const key = {
+      id: `key-${index + 1}`,
+      type: "key",
+      position,
+      ...door?.material ? { material: door.material } : {}
+    };
+    objects.push(key);
+  }
+  const degrees = degreeMap(result);
+  const deadEnds = shuffle(
+    rng,
+    floorCells(result).filter(
+      (item) => degrees.get(cellKey(item)) === 1 && !occupied.has(cellKey(item))
+    )
+  );
+  for (let index = 0; index < chestCount; index += 1) {
+    const position = takeFree(deadEnds, result, occupied, rng, "chest");
+    occupied.add(cellKey(position));
+    const treasureType = cyclicValue(mechanisms.treasureTypes, index + decorationSeed);
+    if (!treasureType) throw new Error("At least one treasure type is required.");
+    const count = 1 + index % 3;
+    const lockMaterial = cyclicValue(mechanisms.keyMaterials, index + decorationSeed + 1);
+    const chest = {
+      id: `chest-${index + 1}`,
+      type: "chest",
+      position,
+      treasures: count,
+      contents: [{ type: treasureType, count }],
+      ...lockMaterial ? { lockMaterial } : {}
+    };
+    objects.push(chest);
+  }
+  const trapCandidates = shuffle(rng, mainPath.slice(2, -2));
+  for (let index = 0; index < trapCount; index += 1) {
+    const position = takeFree(trapCandidates, result, occupied, rng, "trap");
+    occupied.add(cellKey(position));
+    const trap = {
+      id: `trap-${index + 1}`,
+      type: "trap",
+      position,
+      damage: mechanisms.trapDamages[index % mechanisms.trapDamages.length] ?? 1
+    };
+    objects.push(trap);
+  }
+  const potionCandidates = shuffle(rng, floorCells(result));
+  for (let index = 0; index < potionCount; index += 1) {
+    const position = takeFree(potionCandidates, result, occupied, rng, "potion");
+    occupied.add(cellKey(position));
+    if (mechanisms.complexity === "basic" && mechanisms.potionKinds.length === 1 && mechanisms.potionKinds[0] === "healing") {
+      const medicine = {
+        id: `medicine-${index + 1}`,
+        type: "medicine",
+        position,
+        recovery: 1
+      };
+      objects.push(medicine);
+      continue;
+    }
+    const kind = mechanisms.potionKinds[index % mechanisms.potionKinds.length];
+    if (!kind) throw new Error("At least one potion kind is required.");
+    const potion = {
+      id: `potion-${index + 1}`,
+      type: "potion",
+      position,
+      kind,
+      ...kind === "healing" ? { potency: 1 + index % 2 } : {},
+      ...kind === "poison" ? { potency: mechanisms.poisonDamage, duration: mechanisms.poisonDuration } : {},
+      ...kind === "haste" || kind === "slow" ? { duration: mechanisms.speedDuration } : {}
+    };
+    objects.push(potion);
+  }
+  result.objects = objects;
+  result.metrics = analyzeSolidCellMaze(result);
+  return result;
+}
+function analyzeSolidCellMaze(maze) {
+  assertShape(maze);
+  const floors = floorCells(maze);
+  const graph = adjacency(maze);
+  const distances = bfsDistances(maze.entry, graph);
+  const degreeValues = [...graph.values()].map((items) => items.length);
+  const edgeCount = degreeValues.reduce((sum, value) => sum + value, 0) / 2;
+  const mainPath = shortestPath(maze, maze.entry, maze.goal);
+  const objectCounts = {};
+  for (const object of maze.objects ?? []) {
+    objectCounts[object.type] = (objectCounts[object.type] ?? 0) + 1;
+  }
+  return {
+    totalCells: maze.rows * maze.cols,
+    wallCells: maze.rows * maze.cols - floors.length,
+    floorCells: floors.length,
+    connectedFloorCells: distances.size,
+    connected: distances.size === floors.length,
+    floorAdjacencyEdges: edgeCount,
+    independentCycles: edgeCount - floors.length + 1,
+    deadEnds: degreeValues.filter((value) => value === 1).length,
+    junctions: degreeValues.filter((value) => value >= 3).length,
+    entryGoalDistance: mainPath.length > 0 ? mainPath.length - 1 : null,
+    doorCount: maze.doors.length,
+    gatingDoorCount: maze.doors.filter(
+      (door) => shortestPath(maze, maze.entry, maze.goal, door.position).length === 0
+    ).length,
+    objectCounts
+  };
+}
+function validateSolidCellMaze(maze) {
+  const errors = [];
+  try {
+    assertShape(maze);
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [error instanceof Error ? error.message : String(error)],
+      metrics: null
+    };
+  }
+  for (let row = 1; row <= maze.rows; row += 1) {
+    for (let col = 1; col <= maze.cols; col += 1) {
+      const value = terrainAt(maze, cell(row, col));
+      if (value !== "#" && value !== ".") errors.push(`Invalid terrain at ${row},${col}: ${value}`);
+      if ((row === 1 || row === maze.rows || col === 1 || col === maze.cols) && value !== "#") {
+        errors.push(`The outer boundary is not a wall at ${row},${col}.`);
+      }
+    }
+  }
+  if (!isFloor(maze, maze.entry)) errors.push("The entry is not on a floor cell.");
+  if (!isFloor(maze, maze.goal)) errors.push("The goal is not on a floor cell.");
+  if (sameCell(maze.entry, maze.goal)) errors.push("The entry and goal overlap.");
+  const occupied = /* @__PURE__ */ new Set([cellKey(maze.entry), cellKey(maze.goal)]);
+  for (const door of maze.doors) {
+    if (!isFloor(maze, door.position)) errors.push(`${door.id} is not on a floor cell.`);
+    const key = cellKey(door.position);
+    if (occupied.has(key)) errors.push(`${door.id} overlaps another feature.`);
+    occupied.add(key);
+  }
+  for (const object of maze.objects) {
+    if (!isFloor(maze, object.position)) errors.push(`${object.id} is not on a floor cell.`);
+    const key = cellKey(object.position);
+    if (occupied.has(key)) errors.push(`${object.id} overlaps another feature.`);
+    occupied.add(key);
+  }
+  const metrics = analyzeSolidCellMaze(maze);
+  if (!metrics.connected) {
+    errors.push(`Floor cells are disconnected: ${metrics.connectedFloorCells}/${metrics.floorCells}.`);
+  }
+  if (metrics.deadEnds === 0) errors.push("The maze has no dead ends.");
+  if (metrics.junctions === 0) errors.push("The maze has no junctions.");
+  if (metrics.gatingDoorCount !== metrics.doorCount) {
+    errors.push(`${metrics.doorCount - metrics.gatingDoorCount} door(s) can be bypassed.`);
+  }
+  const path = shortestPath(maze, maze.entry, maze.goal);
+  const pathIndex = new Map(path.map((item, index) => [cellKey(item), index]));
+  for (let index = 0; index < maze.doors.length; index += 1) {
+    const door = maze.doors[index];
+    if (!door) continue;
+    const key = maze.objects.find((item) => item.id === `key-${index + 1}`);
+    const doorIndex = pathIndex.get(cellKey(door.position));
+    const keyIndex = key ? pathIndex.get(cellKey(key.position)) : void 0;
+    if (!key) errors.push(`Missing a key for ${door.id}.`);
+    else if (keyIndex === void 0 || doorIndex === void 0 || keyIndex >= doorIndex) {
+      errors.push(`${key.id} is not before ${door.id} on the main path.`);
+    } else if (door.material !== (key.type === "key" ? key.material : void 0)) {
+      errors.push(`${key.id} does not match the material of ${door.id}.`);
+    }
+  }
+  return { valid: errors.length === 0, errors, metrics };
+}
+function shortestPath(maze, start, goal, excludedCell = null) {
+  if (excludedCell && (sameCell(start, excludedCell) || sameCell(goal, excludedCell))) return [];
+  const graph = adjacency(maze, excludedCell);
+  const queue = [start];
+  const parent = /* @__PURE__ */ new Map([[cellKey(start), null]]);
+  const values = /* @__PURE__ */ new Map([[cellKey(start), start]]);
+  let queueIndex = 0;
+  while (queueIndex < queue.length) {
+    const current = queue[queueIndex];
+    queueIndex += 1;
+    if (!current) break;
+    if (sameCell(current, goal)) break;
+    for (const next of graph.get(cellKey(current)) ?? []) {
+      const key = cellKey(next);
+      if (parent.has(key)) continue;
+      parent.set(key, cellKey(current));
+      values.set(key, next);
+      queue.push(next);
+    }
+  }
+  if (!parent.has(cellKey(goal))) return [];
+  const path = [];
+  let cursor = cellKey(goal);
+  while (cursor !== null) {
+    const value = values.get(cursor);
+    if (!value) throw new Error(`Could not reconstruct path at ${cursor}.`);
+    path.push(value);
+    cursor = parent.get(cursor) ?? null;
+  }
+  return path.reverse();
+}
+function terrainAt(maze, value) {
+  if (value.row < 1 || value.row > maze.rows || value.col < 1 || value.col > maze.cols) {
+    return null;
+  }
+  return maze.terrain[value.row - 1]?.[value.col - 1] ?? null;
+}
+function isFloor(maze, value) {
+  return terrainAt(maze, value) === ".";
+}
+function braidDeadEnds(grid, braid, rng) {
+  if (braid <= 0) return;
+  const rows = grid.length;
+  const cols = grid[0]?.length ?? 0;
+  const logicalCells = [];
+  for (let row = 1; row < rows - 1; row += 2) {
+    for (let col = 1; col < cols - 1; col += 2) logicalCells.push({ row, col });
+  }
+  const deadEnds = shuffle(
+    rng,
+    logicalCells.filter((value) => openLogicalNeighbors(grid, value).length === 1)
+  );
+  for (const current of deadEnds) {
+    if (rng() > braid) continue;
+    const closed = shuffle(
+      rng,
+      logicalNeighbors(current, rows, cols).filter(
+        (next2) => grid[(current.row + next2.row) / 2]?.[(current.col + next2.col) / 2] === "#"
+      )
+    );
+    const next = closed[0];
+    if (!next) continue;
+    grid[(current.row + next.row) / 2][(current.col + next.col) / 2] = ".";
+  }
+}
+function openLogicalNeighbors(grid, current) {
+  return logicalNeighbors(current, grid.length, grid[0]?.length ?? 0).filter(
+    (next) => grid[(current.row + next.row) / 2]?.[(current.col + next.col) / 2] === "."
+  );
+}
+function logicalNeighbors(value, rows, cols) {
+  return [
+    { row: value.row - 2, col: value.col },
+    { row: value.row + 2, col: value.col },
+    { row: value.row, col: value.col - 2 },
+    { row: value.row, col: value.col + 2 }
+  ].filter((item) => item.row >= 1 && item.row < rows - 1 && item.col >= 1 && item.col < cols - 1);
+}
+function farthestFloor(start, terrain) {
+  const maze = { rows: terrain.length, cols: terrain[0]?.length ?? 0, terrain };
+  const graph = adjacency(maze);
+  const distances = bfsDistances(start, graph);
+  let farthest = start;
+  let distance = -1;
+  for (const [key, value] of distances) {
+    if (value <= distance) continue;
+    distance = value;
+    farthest = parseCellKey(key);
+  }
+  return { cell: farthest, distance };
+}
+function floorCells(maze) {
+  const values = [];
+  for (let row = 1; row <= maze.rows; row += 1) {
+    for (let col = 1; col <= maze.cols; col += 1) {
+      if (isFloor(maze, cell(row, col))) values.push(cell(row, col));
+    }
+  }
+  return values;
+}
+function adjacency(maze, excludedCell = null) {
+  const floors = floorCells(maze).filter((item) => !excludedCell || !sameCell(item, excludedCell));
+  const floorKeys = new Set(floors.map(cellKey));
+  return new Map(
+    floors.map((item) => [
+      cellKey(item),
+      neighbors(item, maze.rows, maze.cols).filter((next) => floorKeys.has(cellKey(next)))
+    ])
+  );
+}
+function bfsDistances(start, graph) {
+  const distances = /* @__PURE__ */ new Map([[cellKey(start), 0]]);
+  const queue = [start];
+  let queueIndex = 0;
+  while (queueIndex < queue.length) {
+    const current = queue[queueIndex];
+    queueIndex += 1;
+    if (!current) break;
+    const distance = distances.get(cellKey(current));
+    if (distance === void 0) continue;
+    for (const next of graph.get(cellKey(current)) ?? []) {
+      const key = cellKey(next);
+      if (distances.has(key)) continue;
+      distances.set(key, distance + 1);
+      queue.push(next);
+    }
+  }
+  return distances;
+}
+function degreeMap(maze) {
+  return new Map([...adjacency(maze)].map(([key, values]) => [key, values.length]));
+}
+function selectGatingDoorIndices(maze, mainPath, count) {
+  if (count === 0) return [];
+  const degrees = degreeMap(maze);
+  const candidates = [];
+  for (let index = 3; index < mainPath.length - 3; index += 1) {
+    const pathCell = mainPath[index];
+    if (!pathCell || (degrees.get(cellKey(pathCell)) ?? 0) !== 2) continue;
+    if (shortestPath(maze, maze.entry, maze.goal, pathCell).length === 0) candidates.push(index);
+  }
+  if (candidates.length < count) {
+    throw new Error(`Only ${candidates.length} non-bypassable path cells are available for ${count} doors.`);
+  }
+  const targets = spacedIndices(mainPath.length - 1, count, 0.28, 0.78);
+  const selected = [];
+  for (const target of targets) {
+    const available = candidates.filter((index) => !selected.includes(index));
+    available.sort(
+      (left, right) => Math.abs(left - target) - Math.abs(right - target) || left - right
+    );
+    const candidate = available[0];
+    if (candidate === void 0) throw new Error(`Could not place ${count} doors.`);
+    selected.push(candidate);
+  }
+  if (selected.length !== count) throw new Error(`Could not space ${count} doors along the main path.`);
+  return selected.sort((left, right) => left - right);
+}
+function freePathCellBefore(mainPath, preferredIndex, occupied) {
+  for (let distance = 0; distance < mainPath.length; distance += 1) {
+    for (const index of [preferredIndex - distance, preferredIndex + distance]) {
+      if (index <= 0 || index >= mainPath.length - 1) continue;
+      const candidate = mainPath[index];
+      if (candidate && !occupied.has(cellKey(candidate))) return candidate;
+    }
+  }
+  throw new Error("There is no free path cell on which to place a key.");
+}
+function takeFree(candidates, maze, occupied, rng, type) {
+  while (candidates.length > 0) {
+    const value = candidates.shift();
+    if (value && !occupied.has(cellKey(value))) return value;
+  }
+  const fallback = shuffle(rng, floorCells(maze)).find((item) => !occupied.has(cellKey(item)));
+  if (!fallback) throw new Error(`There are not enough free floor cells to place ${type}.`);
+  return fallback;
+}
+function spacedIndices(edgeCount, count, startRatio, endRatio) {
+  if (count === 0) return [];
+  const values = [];
+  for (let index = 0; index < count; index += 1) {
+    const ratio = count === 1 ? (startRatio + endRatio) / 2 : startRatio + (endRatio - startRatio) * index / (count - 1);
+    values.push(Math.max(2, Math.min(edgeCount - 2, Math.floor(edgeCount * ratio))));
+  }
+  return [...new Set(values)];
+}
+function parseCellKey(key) {
+  const [row, col] = key.split(",").map(Number);
+  if (row === void 0 || col === void 0) throw new Error(`Invalid cell key: ${key}`);
+  return cell(row, col);
+}
+function assertShape(maze) {
+  oddDimension(maze.rows, "rows");
+  oddDimension(maze.cols, "cols");
+  if (!Array.isArray(maze.terrain) || maze.terrain.length !== maze.rows) {
+    throw new Error("The terrain row count does not match rows.");
+  }
+  if (maze.terrain.some((row) => typeof row !== "string" || row.length !== maze.cols)) {
+    throw new Error("A terrain row does not match cols.");
+  }
+}
+function oddDimension(value, name) {
+  integerOption(value, name, 7);
+  if (value % 2 === 0) throw new Error(`${name} must be odd.`);
+  return value;
+}
+function integerOption(value, name, minimum) {
+  if (!Number.isInteger(value) || value < minimum) {
+    throw new Error(`${name} must be an integer greater than or equal to ${minimum}.`);
+  }
+  return value;
+}
+function numberOption(value, name, minimum, maximum) {
+  if (!Number.isFinite(value) || value < minimum || value > maximum) {
+    throw new Error(`${name} must be between ${minimum} and ${maximum}.`);
+  }
+  return value;
+}
+function randomInt(rng, maximum) {
+  return Math.floor(rng() * maximum);
+}
+function shuffle(rng, input) {
+  const values = [...input];
+  for (let index = values.length - 1; index > 0; index -= 1) {
+    const target = randomInt(rng, index + 1);
+    const prior = values[index];
+    const replacement = values[target];
+    if (prior === void 0 || replacement === void 0) continue;
+    values[index] = replacement;
+    values[target] = prior;
+  }
+  return values;
+}
+function cyclicValue(values, index) {
+  if (values.length === 0) return void 0;
+  return values[(index % values.length + values.length) % values.length];
+}
+function mulberry32(seed) {
+  let value = seed >>> 0;
+  return () => {
+    value += 1831565813;
+    let mixed = value;
+    mixed = Math.imul(mixed ^ mixed >>> 15, mixed | 1);
+    mixed ^= mixed + Math.imul(mixed ^ mixed >>> 7, mixed | 61);
+    return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+  };
+}
+function emptyMetrics(rows, cols) {
+  return {
+    totalCells: rows * cols,
+    wallCells: rows * cols,
+    floorCells: 0,
+    connectedFloorCells: 0,
+    connected: false,
+    floorAdjacencyEdges: 0,
+    independentCycles: 0,
+    deadEnds: 0,
+    junctions: 0,
+    entryGoalDistance: null,
+    doorCount: 0,
+    gatingDoorCount: 0,
+    objectCounts: {}
+  };
+}
+
+// src/simulator.ts
+var DELTAS = {
+  up: { row: -1, col: 0 },
+  down: { row: 1, col: 0 },
+  left: { row: 0, col: -1 },
+  right: { row: 0, col: 1 }
+};
+function simulateTrial(maze, actions, initial = {}) {
+  const mechanisms = maze.mechanisms ?? mechanismPreset("basic");
+  const health = initial.health ?? 5;
+  const state = {
+    position: structuredClone(maze.entry),
+    health,
+    healthMax: initial.healthMax ?? health,
+    keys: initial.keys ?? 0,
+    keysByMaterial: emptyMaterialCounts(initial.keysByMaterial),
+    treasures: initial.treasures ?? 0,
+    treasuresByType: emptyTreasureCounts(initial.treasuresByType),
+    elapsedTime: initial.elapsedTime ?? 0,
+    speed: initial.speed ?? "normal",
+    speedRemaining: initial.speedRemaining ?? 0,
+    poisonDamage: initial.poisonDamage ?? 0,
+    poisonRemaining: initial.poisonRemaining ?? 0,
+    alive: health > 0,
+    reachedGoal: false,
+    openedDoors: [],
+    collectedKeys: [],
+    openedChests: [],
+    triggeredTraps: [],
+    usedMedicines: [],
+    usedPotions: []
+  };
+  const trace = [];
+  for (let index = 0; index < actions.length; index += 1) {
+    const direction = actions[index];
+    if (!direction) continue;
+    const before = cloneState(state);
+    const events = [];
+    if (!state.alive) {
+      trace.push({ step: index + 1, direction, before, moved: false, reason: "dead", events, after: cloneState(state) });
+      continue;
+    }
+    const context = {
+      speedAtStart: state.speed,
+      speedRemainingAtStart: state.speedRemaining,
+      poisonDamageAtStart: state.poisonDamage,
+      poisonRemainingAtStart: state.poisonRemaining,
+      speedReplaced: false,
+      poisonReplaced: false
+    };
+    const timeCost = mechanisms.movementTime[context.speedAtStart];
+    state.elapsedTime += timeCost;
+    const delta = DELTAS[direction];
+    const target = cell(state.position.row + delta.row, state.position.col + delta.col);
+    let moved = false;
+    let reason = null;
+    if (terrainAt(maze, target) !== ".") {
+      reason = "wall-or-outside";
+    } else {
+      const door = maze.doors.find((item) => cellKey(item.position) === cellKey(target));
+      if (door && !state.openedDoors.includes(door.id)) {
+        if (door.material) {
+          if (state.keysByMaterial[door.material] < 1) {
+            reason = "closed-door-without-matching-key";
+          } else {
+            state.keysByMaterial[door.material] -= 1;
+            state.openedDoors.push(door.id);
+            events.push({ type: "open-door", id: door.id, material: door.material, keyCost: 1, timeCost });
+          }
+        } else if (state.keys < 1) {
+          reason = "closed-door-without-key";
+        } else {
+          state.keys -= 1;
+          state.openedDoors.push(door.id);
+          events.push({ type: "open-door", id: door.id, keyCost: 1, timeCost });
+        }
+      }
+      if (!reason) {
+        state.position = target;
+        moved = true;
+        applyCellObjects(maze, state, events, context);
+        if (cellKey(state.position) === cellKey(maze.goal) && !state.reachedGoal) {
+          state.reachedGoal = true;
+          events.push({ type: "reach-goal" });
+        }
+      }
+    }
+    finishStatuses(state, events, context);
+    trace.push({ step: index + 1, direction, before, moved, reason, events, after: cloneState(state) });
+  }
+  const blockedMoves = trace.filter((item) => !item.moved).length;
+  const blockedAfterDeath = trace.filter((item) => item.reason === "dead").length;
+  return {
+    state,
+    trace,
+    answers: {
+      finalPosition: letterNumberCoordinate(state.position),
+      keys: state.keys + totalMaterialKeys(state.keysByMaterial),
+      keysByMaterial: structuredClone(state.keysByMaterial),
+      treasures: state.treasures,
+      treasuresByType: structuredClone(state.treasuresByType),
+      health: state.health,
+      alive: state.alive,
+      reachedGoal: state.reachedGoal,
+      openedDoors: state.openedDoors.length,
+      openedChests: state.openedChests.length,
+      triggeredTraps: state.triggeredTraps.length,
+      usedMedicines: state.usedMedicines.length,
+      usedPotions: state.usedPotions.length,
+      elapsedTime: state.elapsedTime,
+      finalSpeed: state.speed,
+      speedRemaining: state.speedRemaining,
+      poisonDamage: state.poisonDamage,
+      poisonRemaining: state.poisonRemaining,
+      blockedMoves,
+      blockedAfterDeath
+    }
+  };
+}
+function applyCellObjects(maze, state, events, context) {
+  const object = maze.objects.find((item) => cellKey(item.position) === cellKey(state.position));
+  if (!object) return;
+  if (object.type === "key" && !state.collectedKeys.includes(object.id)) {
+    state.collectedKeys.push(object.id);
+    if (object.material) state.keysByMaterial[object.material] += 1;
+    else state.keys += 1;
+    events.push({
+      type: "collect-key",
+      id: object.id,
+      ...object.material ? { material: object.material } : {}
+    });
+    return;
+  }
+  if (object.type === "chest" && !state.openedChests.includes(object.id)) {
+    let canOpen = false;
+    if (object.lockMaterial) {
+      canOpen = state.keysByMaterial[object.lockMaterial] > 0;
+      if (canOpen) state.keysByMaterial[object.lockMaterial] -= 1;
+    } else {
+      canOpen = state.keys > 0;
+      if (canOpen) state.keys -= 1;
+    }
+    if (!canOpen) {
+      events.push({
+        type: "pass-closed-chest",
+        id: object.id,
+        ...object.lockMaterial ? { material: object.lockMaterial } : {}
+      });
+      return;
+    }
+    state.openedChests.push(object.id);
+    const contents = object.contents?.length > 0 ? object.contents : [{ type: "treasure", count: object.treasures }];
+    for (const content of contents) {
+      state.treasures += content.count;
+      state.treasuresByType[content.type] += content.count;
+    }
+    events.push({
+      type: "open-chest",
+      id: object.id,
+      ...object.lockMaterial ? { material: object.lockMaterial } : {},
+      keyCost: 1,
+      treasures: object.treasures,
+      contents: structuredClone(contents)
+    });
+    return;
+  }
+  if (object.type === "trap" && !state.triggeredTraps.includes(object.id)) {
+    state.triggeredTraps.push(object.id);
+    state.health = Math.max(0, state.health - object.damage);
+    events.push({ type: "trigger-trap", id: object.id, damage: object.damage });
+    return;
+  }
+  if (object.type === "medicine" && !state.usedMedicines.includes(object.id)) {
+    state.usedMedicines.push(object.id);
+    const before = state.health;
+    state.health = Math.min(state.healthMax, state.health + object.recovery);
+    events.push({ type: "use-medicine", id: object.id, recovery: state.health - before });
+    return;
+  }
+  if (object.type === "potion" && !state.usedPotions.includes(object.id)) {
+    state.usedPotions.push(object.id);
+    applyPotion(state, object, context);
+    const recovery = object.kind === "healing" ? object.potency ?? 1 : void 0;
+    const damage = object.kind === "poison" ? object.potency ?? maze.mechanisms.poisonDamage : void 0;
+    events.push({
+      type: "drink-potion",
+      id: object.id,
+      potionKind: object.kind,
+      ...recovery === void 0 ? {} : { recovery },
+      ...damage === void 0 ? {} : { damage },
+      ...object.duration === void 0 ? {} : { duration: object.duration }
+    });
+  }
+}
+function applyPotion(state, potion, context) {
+  if (potion.kind === "healing") {
+    state.health = Math.min(state.healthMax, state.health + (potion.potency ?? 1));
+  } else if (potion.kind === "poison") {
+    state.poisonDamage = potion.potency ?? 1;
+    state.poisonRemaining = potion.duration ?? 1;
+    context.poisonReplaced = true;
+  } else if (potion.kind === "antidote") {
+    state.poisonDamage = 0;
+    state.poisonRemaining = 0;
+    context.poisonReplaced = true;
+  } else if (potion.kind === "haste") {
+    state.speed = "fast";
+    state.speedRemaining = potion.duration ?? 1;
+    context.speedReplaced = true;
+  } else {
+    state.speed = "slow";
+    state.speedRemaining = potion.duration ?? 1;
+    context.speedReplaced = true;
+  }
+}
+function finishStatuses(state, events, context) {
+  if (!context.poisonReplaced && context.poisonRemainingAtStart > 0) {
+    state.health = Math.max(0, state.health - context.poisonDamageAtStart);
+    state.poisonRemaining = context.poisonRemainingAtStart - 1;
+    state.poisonDamage = state.poisonRemaining > 0 ? context.poisonDamageAtStart : 0;
+    events.push({ type: "poison-tick", damage: context.poisonDamageAtStart });
+  }
+  if (!context.speedReplaced && context.speedRemainingAtStart > 0) {
+    state.speedRemaining = context.speedRemainingAtStart - 1;
+    if (state.speedRemaining === 0) {
+      state.speed = "normal";
+      events.push({ type: "speed-expired" });
+    }
+  }
+  if (state.health <= 0 && state.alive) {
+    state.health = 0;
+    state.alive = false;
+    events.push({ type: "die" });
+  }
+}
+function cloneState(state) {
+  return structuredClone(state);
+}
+
+// src/trial.ts
+var DIRECTIONS = {
+  up: { en: "up", zh: "\u4E0A" },
+  down: { en: "down", zh: "\u4E0B" },
+  left: { en: "left", zh: "\u5DE6" },
+  right: { en: "right", zh: "\u53F3" }
+};
+var MATERIAL_NAMES = {
+  copper: { en: "copper", zh: "\u94DC" },
+  silver: { en: "silver", zh: "\u94F6" },
+  gold: { en: "gold", zh: "\u91D1" }
+};
+var TREASURE_NAMES = {
+  treasure: { en: "treasure", zh: "\u5B9D\u7269" },
+  coin: { en: "coin", zh: "\u94B1\u5E01" },
+  gem: { en: "gem", zh: "\u5B9D\u77F3" },
+  relic: { en: "relic", zh: "\u9057\u7269" }
+};
+var POTION_NAMES = {
+  healing: { en: "healing potion", zh: "\u6CBB\u7597\u836F\u6C34" },
+  poison: { en: "poison potion", zh: "\u6BD2\u836F" },
+  antidote: { en: "antidote potion", zh: "\u89E3\u6BD2\u836F\u6C34" },
+  haste: { en: "haste potion", zh: "\u52A0\u901F\u836F\u6C34" },
+  slow: { en: "slow potion", zh: "\u51CF\u901F\u836F\u6C34" }
+};
+var SPEED_NAMES = {
+  normal: { en: "normal", zh: "\u6B63\u5E38" },
+  fast: { en: "fast", zh: "\u52A0\u901F" },
+  slow: { en: "slow", zh: "\u51CF\u901F" }
+};
+function generateTrial(options = {}) {
+  const resolved = resolveTrialOptions(options);
+  const maze = selectMaze(resolved);
+  const plan = buildScenarioPlan(maze, resolved.scenario);
+  const result = simulateTrial(maze, plan.actions, plan.initialState);
+  verifyScenario(resolved.scenario, result.answers, maze);
+  const sections = {
+    map: renderMapDescription(maze, plan.initialState, resolved.language, resolved.style),
+    rules: renderRules(maze, resolved.language),
+    actions: renderActionDescription(plan.actions, resolved.language, resolved.style),
+    questions: renderQuestions(maze, resolved.language)
+  };
+  return {
+    schemaVersion: "maze-test-trial@2",
+    options: resolved,
+    maze,
+    initialState: plan.initialState,
+    actions: plan.actions,
+    sections,
+    question: renderQuestion(resolved, maze, sections),
+    answer: renderAnswer(resolved, maze, result.answers, plan.actions.length),
+    result
+  };
+}
+function resolveTrialOptions(options = {}) {
+  const scenario = options.scenario ?? "success";
+  const language = options.language ?? "en";
+  if (!["success", "treasure-and-leave", "death-and-stop", "mechanism-tour"].includes(scenario)) throw new Error(`Unknown scenario: ${scenario}`);
+  if (language !== "en" && language !== "zh") throw new Error(`Unknown language: ${language}`);
+  const mechanisms = resolveMechanisms(options);
+  const defaults = defaultObjectCounts(mechanisms.complexity);
+  const resolved = {
+    seed: integer(options.seed ?? 1, "seed", 0),
+    rows: oddInteger(options.rows ?? 15, "rows", 7),
+    cols: oddInteger(options.cols ?? 15, "cols", 7),
+    braid: finiteNumber(options.braid ?? 0, "braid", 0, 1),
+    doorCount: integer(options.doorCount ?? defaults.doors, "doorCount", 0),
+    chestCount: integer(options.chestCount ?? defaults.chests, "chestCount", 0),
+    trapCount: integer(options.trapCount ?? defaults.traps, "trapCount", 0),
+    potionCount: integer(options.potionCount ?? options.medicineCount ?? defaults.potions, "potionCount", 0),
+    mechanisms,
+    scenario,
+    language,
+    style: integer(options.style ?? 0, "style", 0),
+    minDistance: integer(options.minDistance ?? 0, "minDistance", 0),
+    maxAttempts: integer(options.maxAttempts ?? 500, "maxAttempts", 1)
+  };
+  validateScenarioOptions(resolved);
+  return resolved;
+}
+function validateScenarioOptions(options) {
+  if (options.scenario === "treasure-and-leave") {
+    if (options.chestCount < 1) throw new Error("The treasure-and-leave scenario requires at least one chest.");
+    if (!options.mechanisms.potionKinds.includes("healing")) throw new Error("The treasure-and-leave scenario requires healing in potionKinds.");
+    if (options.potionCount < 1) throw new Error("The treasure-and-leave scenario requires at least one potion.");
+  }
+  if (options.scenario === "death-and-stop" && options.trapCount < 1) throw new Error("The death-and-stop scenario requires at least one trap.");
+  if (options.scenario === "mechanism-tour") {
+    if (options.trapCount < options.mechanisms.trapDamages.length) throw new Error("The mechanism-tour scenario needs at least one trap for every configured trap damage.");
+    if (options.potionCount < options.mechanisms.potionKinds.length) throw new Error("The mechanism-tour scenario needs at least one potion for every configured potion kind.");
+    if (options.chestCount < options.mechanisms.treasureTypes.length) throw new Error("The mechanism-tour scenario needs at least one chest for every configured treasure type.");
+    if (options.doorCount < options.mechanisms.keyMaterials.length) throw new Error("The mechanism-tour scenario needs at least one door for every configured key material.");
+  }
+}
+function selectMaze(options) {
+  let lastError = null;
+  for (let offset = 0; offset < options.maxAttempts; offset += 1) {
+    const effectiveSeed = options.seed + offset;
+    try {
+      const base = generateSolidCellMaze({ rows: options.rows, cols: options.cols, braid: options.braid, seed: effectiveSeed, requestedSeed: options.seed, mechanisms: options.mechanisms, id: `maze-test-${options.rows}x${options.cols}-${options.seed}` });
+      const maze = decorateSolidCellMaze(base, { seed: effectiveSeed + 8e4, doorCount: options.doorCount, chestCount: options.chestCount, trapCount: options.trapCount, potionCount: options.potionCount, mechanisms: options.mechanisms });
+      const validation = validateSolidCellMaze(maze);
+      if (!validation.valid) throw new Error(validation.errors.join(" "));
+      if ((validation.metrics?.entryGoalDistance ?? 0) < options.minDistance) throw new Error(`The entry-goal distance is below ${options.minDistance}.`);
+      const plan = buildScenarioPlan(maze, options.scenario);
+      const result = simulateTrial(maze, plan.actions, plan.initialState);
+      verifyScenario(options.scenario, result.answers, maze);
+      return maze;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  const detail = lastError instanceof Error ? ` Last error: ${lastError.message}` : "";
+  throw new Error(`Could not generate a valid trial in ${options.maxAttempts} deterministic attempts.${detail}`);
+}
+function buildScenarioPlan(maze, scenario) {
+  const ample = ampleInitialState(maze);
+  if (scenario === "success") {
+    const damage = maze.objects.filter((item) => item.type === "trap").reduce((sum, item) => sum + item.damage, 0);
+    const poisonBudget = maze.mechanisms.potionKinds.includes("poison") ? maze.mechanisms.poisonDamage * maze.mechanisms.poisonDuration : 0;
+    const health = Math.max(5, damage + poisonBudget + 1);
+    return { initialState: { health, healthMax: health, keys: 0, treasures: 0 }, actions: pathToActions(shortestPath(maze, maze.entry, maze.goal)) };
+  }
+  if (scenario === "treasure-and-leave") {
+    const healing = maze.objects.find((item) => item.type === "medicine" || item.type === "potion" && item.kind === "healing");
+    const chest = maze.objects.find((item) => item.type === "chest");
+    if (!healing || !chest) throw new Error("This scenario requires a healing object and a chest.");
+    let actions = routeThrough(maze, [maze.entry, healing.position, chest.position, maze.goal]);
+    const leavePath = shortestPath(maze, maze.goal, chest.position).slice(0, 10);
+    actions.push(...pathToActions(leavePath));
+    const initialState = { ...ample, health: 50, healthMax: 100 };
+    const bump = wallDirection(maze, simulateTrial(maze, actions, initialState).state.position);
+    if (bump) actions.push(bump, bump);
+    return { initialState, actions };
+  }
+  if (scenario === "death-and-stop") {
+    const trap = maze.objects.find((item) => item.type === "trap");
+    if (!trap) throw new Error("This scenario requires a trap.");
+    const actions = [...pathToActions(shortestPath(maze, maze.entry, trap.position)), ...pathToActions(shortestPath(maze, trap.position, maze.goal).slice(0, 14))];
+    for (let health = 1; health <= 200; health += 1) {
+      const initialState = { ...ample, health, healthMax: health };
+      const result = simulateTrial(maze, actions, initialState);
+      if (result.trace.some((item) => item.events.some((event) => event.type === "trigger-trap" && event.id === trap.id) && item.events.some((event) => event.type === "die"))) return { initialState, actions };
+    }
+    throw new Error("Could not choose health that makes the death-and-stop scenario die on its target trap.");
+  }
+  return { initialState: { ...ample, health: 1e3, healthMax: 1e3 }, actions: routeThrough(maze, [maze.entry, ...maze.objects.map((item) => item.position), maze.goal]) };
+}
+function ampleInitialState(maze) {
+  const material = emptyMaterialCounts();
+  for (const door of maze.doors) if (door.material) material[door.material] += 1;
+  for (const object of maze.objects) if (object.type === "chest" && object.lockMaterial) material[object.lockMaterial] += 1;
+  return { health: 100, healthMax: 100, keys: maze.doors.filter((door) => !door.material).length + maze.objects.filter((item) => item.type === "chest" && !item.lockMaterial).length, keysByMaterial: material, treasures: 0 };
+}
+function verifyScenario(scenario, a, maze) {
+  if (scenario === "success" && (!a.reachedGoal || !a.alive || a.finalPosition !== letterNumberCoordinate(maze.goal))) throw new Error("The success scenario did not finish alive at the goal.");
+  if (scenario === "treasure-and-leave" && (!a.reachedGoal || a.finalPosition === letterNumberCoordinate(maze.goal) || a.openedChests < 1 || a.usedMedicines + a.usedPotions < 1 || a.blockedMoves < 2)) throw new Error("The treasure-and-leave scenario did not meet its invariants.");
+  if (scenario === "death-and-stop" && (a.alive || a.triggeredTraps < 1 || a.blockedAfterDeath < 5)) throw new Error("The death-and-stop scenario did not meet its invariants.");
+  if (scenario === "mechanism-tour") {
+    const count = (type) => maze.objects.filter((item) => item.type === type).length;
+    if (!a.alive || !a.reachedGoal || a.openedDoors !== maze.doors.length || a.openedChests !== count("chest") || a.triggeredTraps !== count("trap") || a.usedPotions !== count("potion") || a.usedMedicines !== count("medicine")) throw new Error("The mechanism-tour scenario did not exercise every generated mechanism object.");
+  }
+}
+function renderQuestion(options, maze, sections) {
+  const zh = options.language === "zh";
+  const labels = zh ? ["\u5730\u56FE\u63CF\u8FF0", "\u673A\u5236\u63CF\u8FF0", "\u884C\u52A8\u63CF\u8FF0", "\u95EE\u9898"] : ["Map", "Rules", "Actions", "Questions"];
+  const seedLine = maze.seed === options.seed ? `${zh ? "\u79CD\u5B50" : "Seed"}: ${options.seed}` : `${zh ? "\u79CD\u5B50" : "Seed"}: ${options.seed} (${zh ? "\u6709\u6548\u8FF7\u5BAB\u79CD\u5B50" : "effective maze seed"}: ${maze.seed})`;
+  return [`# ${zh ? "\u8FF7\u5BAB\u8BD5\u9898" : "Maze Trial"}`, "", seedLine, `${zh ? "\u673A\u5236\u590D\u6742\u5EA6" : "Mechanism complexity"}: ${options.mechanisms.complexity}`, "", `## 1. ${labels[0]}`, "", sections.map, "", `## 2. ${labels[1]}`, "", sections.rules, "", `## 3. ${labels[2]}`, "", sections.actions, "", `## 4. ${labels[3]}`, "", sections.questions, ""].join("\n");
+}
+function renderAnswer(options, maze, a, actionCount) {
+  const zh = options.language === "zh";
+  const rows = zh ? [["\u6700\u7EC8\u4F4D\u7F6E", a.finalPosition], ["\u6700\u7EC8\u94A5\u5319\u603B\u6570", a.keys], ["\u6700\u7EC8\u5B9D\u7269\u603B\u6570", a.treasures], ["\u6700\u7EC8\u5065\u5EB7\u503C", a.health], ["\u662F\u5426\u5B58\u6D3B", a.alive ? "\u662F" : "\u5426"], ["\u662F\u5426\u66FE\u5230\u8FBE\u7EC8\u70B9", a.reachedGoal ? "\u662F" : "\u5426"], ["\u6253\u5F00\u7684\u95E8", a.openedDoors], ["\u6253\u5F00\u7684\u5B9D\u7BB1", a.openedChests], ["\u89E6\u53D1\u7684\u9677\u9631", a.triggeredTraps]] : [["Final position", a.finalPosition], ["Keys remaining in total", a.keys], ["Treasures collected in total", a.treasures], ["Health remaining", a.health], ["Alive", a.alive ? "Yes" : "No"], ["Ever reached the goal", a.reachedGoal ? "Yes" : "No"], ["Doors opened", a.openedDoors], ["Chests opened", a.openedChests], ["Traps triggered", a.triggeredTraps]];
+  if (maze.objects.some((item) => item.type === "medicine")) rows.push([zh ? "\u4F7F\u7528\u7684\u836F\u54C1\u623F" : "Medicine rooms used", a.usedMedicines]);
+  if (maze.objects.some((item) => item.type === "potion")) rows.push([zh ? "\u996E\u7528\u7684\u836F\u6C34" : "Potions drunk", a.usedPotions]);
+  rows.push([zh ? "\u672A\u6539\u53D8\u4F4D\u7F6E\u7684\u539F\u5B50\u79FB\u52A8\u6307\u4EE4" : "Atomic movement instructions that did not change position", a.blockedMoves]);
+  for (const material of maze.mechanisms.keyMaterials) rows.push([zh ? `\u5269\u4F59${MATERIAL_NAMES[material].zh}\u94A5\u5319` : `${capitalize(MATERIAL_NAMES[material].en)} keys remaining`, a.keysByMaterial[material]]);
+  if (maze.mechanisms.treasureTypes.some((type) => type !== "treasure")) for (const type of maze.mechanisms.treasureTypes) rows.push([zh ? `${TREASURE_NAMES[type].zh}\u6570\u91CF` : `${capitalize(TREASURE_NAMES[type].en)}s collected`, a.treasuresByType[type]]);
+  if (maze.mechanisms.complexity === "advanced") rows.push([zh ? "\u7D2F\u8BA1\u8017\u65F6\uFF08\u65F6\u95F4\u5355\u4F4D\uFF09" : "Elapsed time (time units)", a.elapsedTime], [zh ? "\u6700\u7EC8\u901F\u5EA6\u72B6\u6001" : "Final speed state", SPEED_NAMES[a.finalSpeed][zh ? "zh" : "en"]], [zh ? "\u901F\u5EA6\u6548\u679C\u5269\u4F59\u6307\u4EE4\u6570" : "Speed-effect instructions remaining", a.speedRemaining], [zh ? "\u4E2D\u6BD2\u5269\u4F59\u6307\u4EE4\u6570" : "Poison instructions remaining", a.poisonRemaining]);
+  return [`# ${zh ? "\u6807\u51C6\u7B54\u6848" : "Answer Key"}`, "", `${zh ? "\u79CD\u5B50" : "Seed"}: ${options.seed}`, ...maze.seed === options.seed ? [] : [`${zh ? "\u6709\u6548\u8FF7\u5BAB\u79CD\u5B50" : "Effective maze seed"}: ${maze.seed}`], "", `| ${zh ? "\u95EE\u9898" : "Item"} | ${zh ? "\u7B54\u6848" : "Answer"} |`, "|---|---|", ...rows.map(([label, value]) => `| ${label} | ${String(value)} |`), "", `${zh ? "\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u6570" : "Atomic movement instruction count"}: ${actionCount}`, ""].join("\n");
+}
+function renderMapDescription(maze, initial, language, style) {
+  const terrain = renderTerrainDescription(maze, language, style);
+  const objects = renderObjectDescription(maze, language);
+  if (language === "zh") return [`\u8FD9\u662F\u4E00\u5EA7${maze.rows}\u884C${maze.cols}\u5217\u7684\u8FF7\u5BAB\u3002\u5DE6\u4E0A\u89D2\u4E3AA1\uFF0C\u5217\u4ECE\u5DE6\u5411\u53F3\u4F9D\u6B21\u6807\u4E3AA\u81F3${columnLabel(maze.cols)}\uFF0C\u884C\u4ECE\u4E0A\u5411\u4E0B\u7F16\u53F7\u4E3A1\u81F3${maze.rows}\u3002`, `\u5165\u53E3\u4F4D\u4E8E${letterNumberCoordinate(maze.entry)}\uFF0C\u7EC8\u70B9\u4F4D\u4E8E${letterNumberCoordinate(maze.goal)}\u3002`, "", terrain, "", "\u95E8\u548C\u5BF9\u8C61\u7684\u4F4D\u7F6E\u5982\u4E0B\uFF1B\u95E8\u4E0E\u5BF9\u8C61\u6240\u5728\u683C\u4ECD\u662F\u53EF\u4EE5\u8FDB\u5165\u7684\u901A\u8DEF\u683C\u3002", objects, "", `\u63A2\u9669\u8005\u4ECE\u5165\u53E3\u51FA\u53D1\uFF0C\u521D\u59CB\u5065\u5EB7\u503C\u4E3A${initial.health}\uFF0C\u5065\u5EB7\u4E0A\u9650\u4E3A${initial.healthMax}\uFF1B${initialPossessions(initial, language)}\uFF1B\u521D\u59CB\u672A\u4E2D\u6BD2\u3001\u901F\u5EA6\u4E3A\u6B63\u5E38\uFF1B\u201C\u66FE\u7ECF\u5230\u8FBE\u7EC8\u70B9\u201D\u8BB0\u5F55\u4E3A\u5047\u3002`].join("\n");
+  return [`This maze has ${maze.rows} rows and ${maze.cols} columns. The top-left cell is A1. Columns run left to right from A to ${columnLabel(maze.cols)}, and rows run top to bottom from 1 to ${maze.rows}.`, `The entry is at ${letterNumberCoordinate(maze.entry)}, and the goal is at ${letterNumberCoordinate(maze.goal)}.`, "", terrain, "", "Door and object locations follow. A cell containing a door or object is still a passage cell that may be entered, subject to the door rule.", objects, "", `The explorer starts at the entry with ${initial.health} health, a maximum health of ${initial.healthMax}, ${initialPossessions(initial, language)}, no poison, normal speed, and reached-goal set to false.`].join("\n");
+}
+function renderTerrainDescription(maze, language, style) {
+  const clauses = Array.from({ length: maze.rows }, (_, index) => index + 1).map((row) => {
+    const kinds = Array.from({ length: maze.cols }, (_, index) => terrainAt(maze, cell(row, index + 1)) === "." ? "floor" : "wall");
+    const label = language === "zh" ? [`\u7B2C${row}\u884C`, `${row}\u3001`, `\uFF08${row}\uFF09`][style % 3] : `Row ${row}: `;
+    return `${label ?? `\u7B2C${row}\u884C`}${describeTerrainLine(kinds, language)}`;
+  });
+  return language === "zh" ? ["\u6BCF\u884C\u5185\u90E8\u7684\u683C\u5B50\u5747\u4ECE\u5DE6\u5F80\u53F3\u8BA1\u6570\u3002\u4ECE\u4E0A\u5F80\u4E0B\uFF0C\u5404\u884C\u7684\u683C\u5B50\u60C5\u51B5\u5982\u4E0B\uFF1A", `${clauses.join("\uFF1B\n")}\u3002`].join("\n") : ["Within each row, cells are counted from left to right:", `${clauses.join(";\n")}.`].join("\n");
+}
+function describeTerrainLine(kinds, language) {
+  const walls = [];
+  const floors = [];
+  for (let index = 0; index < kinds.length; index += 1) (kinds[index] === "wall" ? walls : floors).push(index + 1);
+  if (language === "zh") {
+    if (walls.length === 0) return "\u90FD\u662F\u901A\u8DEF";
+    if (floors.length === 0) return "\u90FD\u662F\u5899\u58C1";
+    const limit2 = Math.floor(kinds.length / 3);
+    if (walls.length <= limit2) return `\u9664\u4E86${positionList(walls, language)}\u662F\u5899\u58C1\u4EE5\u5916\uFF0C\u5176\u4F59\u90FD\u662F\u901A\u8DEF`;
+    if (floors.length <= limit2) return `\u9664\u4E86${positionList(floors, language)}\u662F\u901A\u8DEF\u4EE5\u5916\uFF0C\u5176\u4F59\u90FD\u662F\u5899\u58C1`;
+    return `${positionList(walls, language)}\u662F\u5899\u58C1\uFF0C${positionList(floors, language)}\u662F\u901A\u8DEF`;
+  }
+  if (walls.length === 0) return "all cells are passages";
+  if (floors.length === 0) return "all cells are walls";
+  const limit = Math.floor(kinds.length / 3);
+  if (walls.length <= limit) return `all cells are passages except ${positionList(walls, language)}, which ${walls.length === 1 ? "is a wall" : "are walls"}`;
+  if (floors.length <= limit) return `all cells are walls except ${positionList(floors, language)}, which ${floors.length === 1 ? "is a passage" : "are passages"}`;
+  return `${positionList(walls, language)} ${walls.length === 1 ? "is a wall" : "are walls"}; ${positionList(floors, language)} ${floors.length === 1 ? "is a passage" : "are passages"}`;
+}
+function positionList(indices, language) {
+  const ranges = [];
+  let start = indices[0];
+  let end = indices[0];
+  if (start === void 0 || end === void 0) return "";
+  for (const value of indices.slice(1)) {
+    if (value === end + 1) {
+      end = value;
+      continue;
+    }
+    ranges.push([start, end]);
+    start = value;
+    end = value;
+  }
+  ranges.push([start, end]);
+  const parts = ranges.map(([from, to]) => language === "zh" ? from === to ? `\u7B2C${from}\u683C` : `\u7B2C${from}\u683C\u81F3\u7B2C${to}\u683C` : from === to ? `cell ${from}` : `cells ${from}-${to}`);
+  if (parts.length === 1) return parts[0] ?? "";
+  return language === "zh" ? `${parts.slice(0, -1).join("\u3001")}\u548C${parts.at(-1)}` : `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}`;
+}
+function renderObjectDescription(maze, language) {
+  const lines = [];
+  for (const door of maze.doors) {
+    const at = letterNumberCoordinate(door.position);
+    lines.push(language === "zh" ? `${at}\u6709\u4E00\u9053\u521D\u59CB\u5173\u95ED\u7684${door.material ? MATERIAL_NAMES[door.material].zh : "\u666E\u901A"}\u95E8\u3002` : `${at} contains an initially closed ${door.material ? `${MATERIAL_NAMES[door.material].en} ` : "ordinary "}door.`);
+  }
+  for (const object of maze.objects) {
+    const at = letterNumberCoordinate(object.position);
+    if (object.type === "key") lines.push(language === "zh" ? `${at}\u653E\u7740\u4E00\u628A${object.material ? MATERIAL_NAMES[object.material].zh : "\u666E\u901A"}\u94A5\u5319\u3002` : `${at} contains one ${object.material ? `${MATERIAL_NAMES[object.material].en} ` : "ordinary "}key.`);
+    else if (object.type === "chest") {
+      const contents = (object.contents ?? [{ type: "treasure", count: object.treasures }]).map((item) => language === "zh" ? `${item.count}${treasureUnit(item.type)}${TREASURE_NAMES[item.type].zh}` : `${item.count} ${TREASURE_NAMES[item.type].en}${plural(item.count)}`).join(language === "zh" ? "\u3001" : " and ");
+      const lock = object.lockMaterial ? `a ${MATERIAL_NAMES[object.lockMaterial].en} lock` : "an ordinary lock";
+      lines.push(language === "zh" ? `${at}\u6709\u4E00\u53EA\u521D\u59CB\u5173\u95ED\u7684${object.lockMaterial ? MATERIAL_NAMES[object.lockMaterial].zh : "\u666E\u901A"}\u9501\u5B9D\u7BB1\uFF0C\u5185\u6709${contents}\u3002` : `${at} contains an initially closed chest with ${lock}, containing ${contents}.`);
+    } else if (object.type === "trap") lines.push(language === "zh" ? `${at}\u6709\u4E00\u4E2A\u5C1A\u672A\u89E6\u53D1\u7684\u9677\u9631\uFF0C\u4F24\u5BB3\u4E3A${object.damage}\u70B9\u3002` : `${at} contains an untriggered trap that deals ${object.damage} damage.`);
+    else if (object.type === "medicine") lines.push(language === "zh" ? `${at}\u6709\u4E00\u4E2A\u5C1A\u672A\u4F7F\u7528\u7684\u836F\u54C1\u623F\uFF0C\u53EF\u6062\u590D${object.recovery}\u70B9\u5065\u5EB7\u503C\u3002` : `${at} contains an unused medicine room that restores ${object.recovery} health.`);
+    else {
+      const details = potionDetails(object.kind, object.potency, object.duration, language);
+      lines.push(language === "zh" ? `${at}\u6709\u4E00\u74F6\u5C1A\u672A\u996E\u7528\u7684${POTION_NAMES[object.kind].zh}${details}\u3002` : `${at} contains an unused ${POTION_NAMES[object.kind].en}${details}.`);
+    }
+  }
+  return lines.length > 0 ? lines.join("\n") : language === "zh" ? "\u6CA1\u6709\u95E8\u6216\u5176\u4ED6\u5BF9\u8C61\u3002" : "There are no doors or other objects.";
+}
+function potionDetails(kind, potency, duration, language) {
+  if (language === "zh") {
+    if (kind === "healing") return `\uFF0C\u6062\u590D${potency ?? 1}\u70B9\u5065\u5EB7\u503C\uFF0C\u4F46\u4E0D\u8D85\u8FC7\u5065\u5EB7\u4E0A\u9650`;
+    if (kind === "poison") return `\uFF0C\u4F7F\u996E\u7528\u8005\u5728\u4E4B\u540E${duration ?? 1}\u6761\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u5404\u635F\u5931${potency ?? 1}\u70B9\u5065\u5EB7\u503C`;
+    if (kind === "haste" || kind === "slow") return `\uFF0C\u6548\u679C\u6301\u7EED\u4E4B\u540E${duration ?? 1}\u6761\u539F\u5B50\u79FB\u52A8\u6307\u4EE4`;
+    return "\uFF0C\u53EF\u7ACB\u5373\u6E05\u9664\u4E2D\u6BD2\u72B6\u6001";
+  }
+  if (kind === "healing") return ` that restores ${potency ?? 1} health without exceeding maximum health`;
+  if (kind === "poison") return ` that causes ${potency ?? 1} damage after each of the next ${duration ?? 1} atomic movement instructions`;
+  if (kind === "haste" || kind === "slow") return ` whose effect lasts for the next ${duration ?? 1} atomic movement instructions`;
+  return " that immediately clears poison";
+}
+function renderRules(maze, language) {
+  const m = maze.mechanisms;
+  const usesPotionObjects = maze.objects.some((item) => item.type === "potion");
+  const usesPoison = usesPotionObjects && m.potionKinds.some((kind) => kind === "poison" || kind === "antidote");
+  const usesMaterials = m.keyMaterials.length > 0;
+  const doorRuleZh = usesMaterials ? "\u76EE\u6807\u683C\u662F\u5173\u95ED\u7684\u95E8\u65F6\uFF0C\u5FC5\u987B\u6D88\u8017\u4E00\u628A\u4E0E\u95E8\u6750\u8D28\u76F8\u540C\u7684\u94A5\u5319\uFF1B\u94A5\u5319\u4E0D\u8DB3\u6216\u6750\u8D28\u4E0D\u7B26\u65F6\u505C\u5728\u539F\u5730\u3002\u94A5\u5319\u5339\u914D\u65F6\uFF0C\u5728\u540C\u4E00\u6761\u6307\u4EE4\u4E2D\u5F00\u95E8\u5E76\u8FDB\u5165\u95E8\u683C\u3002\u95E8\u4E00\u7ECF\u6253\u5F00\u4FBF\u6C38\u4E45\u4FDD\u6301\u6253\u5F00\u3002" : "\u76EE\u6807\u683C\u662F\u5173\u95ED\u7684\u666E\u901A\u95E8\u65F6\uFF0C\u5FC5\u987B\u6D88\u8017\u4E00\u628A\u666E\u901A\u94A5\u5319\uFF1B\u6CA1\u6709\u666E\u901A\u94A5\u5319\u65F6\u505C\u5728\u539F\u5730\u3002\u6709\u94A5\u5319\u65F6\uFF0C\u5728\u540C\u4E00\u6761\u6307\u4EE4\u4E2D\u5F00\u95E8\u5E76\u8FDB\u5165\u95E8\u683C\u3002\u95E8\u4E00\u7ECF\u6253\u5F00\u4FBF\u6C38\u4E45\u4FDD\u6301\u6253\u5F00\u3002";
+  const doorRuleEn = usesMaterials ? "If the target cell contains a closed door, the explorer must spend one key whose material matches the door. Without a matching key, the explorer stays in place. With a matching key, the door opens and the explorer enters the door cell in the same instruction. Once opened, a door remains open." : "If the target cell contains a closed ordinary door, the explorer must spend one ordinary key. Without an ordinary key, the explorer stays in place. With one, the door opens and the explorer enters the door cell in the same instruction. Once opened, a door remains open.";
+  const chestRuleZh = usesMaterials ? "\u6BCF\u6B21\u8FDB\u5165\u542B\u6709\u5C1A\u672A\u6253\u5F00\u5B9D\u7BB1\u7684\u683C\u5B50\u65F6\uFF0C\u82E5\u6301\u6709\u4E0E\u9501\u6750\u8D28\u76F8\u540C\u7684\u94A5\u5319\uFF0C\u5219\u6D88\u8017\u4E00\u628A\u8BE5\u94A5\u5319\u3001\u6253\u5F00\u5B9D\u7BB1\u5E76\u53D6\u5F97\u7BB1\u4E2D\u5168\u90E8\u7269\u54C1\uFF1B\u5426\u5219\u5B9D\u7BB1\u4FDD\u6301\u5173\u95ED\u3002\u5B9D\u7BB1\u683C\u65E0\u8BBA\u662F\u5426\u6253\u5F00\u90FD\u53EF\u4EE5\u8FDB\u5165\u6216\u7ECF\u8FC7\u3002\u7BB1\u5185\u6BCF\u4E00\u679A\u94B1\u5E01\u3001\u6BCF\u4E00\u9897\u5B9D\u77F3\u6216\u6BCF\u4E00\u4EF6\u9057\u7269\u90FD\u5206\u522B\u8BA1\u4E3A\u4E00\u4EF6\u5B9D\u7269\u3002" : "\u6BCF\u6B21\u8FDB\u5165\u542B\u6709\u5C1A\u672A\u6253\u5F00\u666E\u901A\u9501\u5B9D\u7BB1\u7684\u683C\u5B50\u65F6\uFF0C\u82E5\u6301\u6709\u666E\u901A\u94A5\u5319\uFF0C\u5219\u6D88\u8017\u4E00\u628A\u666E\u901A\u94A5\u5319\u3001\u6253\u5F00\u5B9D\u7BB1\u5E76\u53D6\u5F97\u7BB1\u4E2D\u5168\u90E8\u7269\u54C1\uFF1B\u5426\u5219\u5B9D\u7BB1\u4FDD\u6301\u5173\u95ED\u3002\u5B9D\u7BB1\u683C\u65E0\u8BBA\u662F\u5426\u6253\u5F00\u90FD\u53EF\u4EE5\u8FDB\u5165\u6216\u7ECF\u8FC7\u3002\u7BB1\u5185\u6BCF\u4EF6\u7269\u54C1\u8BA1\u4E3A\u4E00\u4EF6\u5B9D\u7269\u3002";
+  const chestRuleEn = usesMaterials ? "Whenever the explorer enters a cell containing an unopened chest, if a key matching its lock is available, one such key is spent, the chest opens, and all its contents are collected; otherwise, the chest remains closed. A chest cell may be entered or crossed whether or not the chest is open. Each coin, gem, or relic counts as one treasure." : "Whenever the explorer enters a cell containing an unopened chest with an ordinary lock, if an ordinary key is available, one ordinary key is spent, the chest opens, and all its contents are collected; otherwise, the chest remains closed. A chest cell may be entered or crossed whether or not the chest is open. Each item inside counts as one treasure.";
+  const orderRuleZh = m.complexity === "advanced" ? "\u4E00\u6761\u6307\u4EE4\u4E2D\uFF0C\u4F9D\u6B21\u7ED3\u7B97\u8017\u65F6\u3001\u79FB\u52A8\u4E0E\u76EE\u6807\u683C\u6548\u679C\u3001\u5230\u8FBE\u7EC8\u70B9\u8BB0\u5F55\u3001\u8BE5\u6307\u4EE4\u5F00\u59CB\u65F6\u5DF2\u6709\u7684\u4E2D\u6BD2\u4E0E\u901F\u5EA6\u72B6\u6001\uFF0C\u6700\u540E\u5224\u65AD\u662F\u5426\u6B7B\u4EA1\u3002" : usesPoison ? "\u4E00\u6761\u6307\u4EE4\u4E2D\uFF0C\u4F9D\u6B21\u7ED3\u7B97\u79FB\u52A8\u4E0E\u76EE\u6807\u683C\u6548\u679C\u3001\u5230\u8FBE\u7EC8\u70B9\u8BB0\u5F55\u3001\u8BE5\u6307\u4EE4\u5F00\u59CB\u65F6\u5DF2\u6709\u7684\u4E2D\u6BD2\u72B6\u6001\uFF0C\u6700\u540E\u5224\u65AD\u662F\u5426\u6B7B\u4EA1\u3002" : "\u4E00\u6761\u6307\u4EE4\u4E2D\uFF0C\u4F9D\u6B21\u7ED3\u7B97\u79FB\u52A8\u4E0E\u76EE\u6807\u683C\u6548\u679C\u3001\u5230\u8FBE\u7EC8\u70B9\u8BB0\u5F55\uFF0C\u6700\u540E\u5224\u65AD\u662F\u5426\u6B7B\u4EA1\u3002";
+  const orderRuleEn = m.complexity === "advanced" ? "Within one instruction, resolve time cost first, then movement and target-cell effects, then the reached-goal record, then poison and speed states that were active at the instruction's start, and finally death." : usesPoison ? "Within one instruction, resolve movement and target-cell effects, then the reached-goal record, then poison that was active at the instruction's start, and finally death." : "Within one instruction, resolve movement and target-cell effects, then the reached-goal record, and finally death.";
+  const poisonRuleZh = "\u6BD2\u836F\u4ECE\u996E\u7528\u540E\u7684\u4E0B\u4E00\u6761\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u5F00\u59CB\u751F\u6548\u3002\u6BCF\u6761\u6307\u4EE4\uFF08\u5305\u62EC\u56E0\u5899\u3001\u5730\u56FE\u8FB9\u754C\u6216\u95E8\u800C\u672A\u79FB\u52A8\u7684\u6307\u4EE4\uFF09\u7ED3\u675F\u65F6\u6263\u9664\u6307\u5B9A\u5065\u5EB7\u503C\u5E76\u51CF\u5C11\u4E00\u6B21\u5269\u4F59\u6B21\u6570\u3002\u996E\u7528\u65B0\u7684\u6BD2\u836F\u4F1A\u8986\u76D6\u539F\u4E2D\u6BD2\u72B6\u6001\uFF1B\u996E\u7528\u6BD2\u836F\u6216\u89E3\u6BD2\u836F\u6C34\u7684\u5F53\u524D\u6307\u4EE4\u90FD\u4E0D\u4F1A\u89E6\u53D1\u539F\u6709\u6BD2\u7D20\u3002";
+  const poisonRuleEn = "Poison starts with the instruction after it is drunk. At the end of each such instruction\u2014including one blocked by a wall, map boundary, or door\u2014it deals the stated damage and consumes one remaining instruction. New poison replaces any previous poison; neither a poison potion nor an antidote potion lets the previous poison tick on the instruction in which it is drunk.";
+  const speedRuleZh = `\u6BCF\u6761\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u5728\u5F00\u59CB\u65F6\u6309\u5F53\u65F6\u901F\u5EA6\u8BA1\u5165\u65F6\u95F4\u5355\u4F4D\uFF1A\u6B63\u5E38${m.movementTime.normal}\u3001\u52A0\u901F${m.movementTime.fast}\u3001\u51CF\u901F${m.movementTime.slow}\u3002\u996E\u7528\u52A0\u901F\u836F\u6C34\u4F1A\u628A\u901F\u5EA6\u8BBE\u4E3A\u52A0\u901F\uFF0C\u996E\u7528\u51CF\u901F\u836F\u6C34\u4F1A\u628A\u901F\u5EA6\u8BBE\u4E3A\u51CF\u901F\uFF1B\u4E24\u79CD\u6548\u679C\u90FD\u4ECE\u996E\u7528\u540E\u7684\u4E0B\u4E00\u6761\u6307\u4EE4\u5F00\u59CB\uFF0C\u6301\u7EED\u6307\u5B9A\u6570\u91CF\u7684\u6307\u4EE4\u3002\u649E\u5899\u6216\u88AB\u95E8\u6321\u4F4F\u4E5F\u4F1A\u6D88\u8017\u4E00\u6B21\u6301\u7EED\u6B21\u6570\u3002\u996E\u7528\u901F\u5EA6\u836F\u6C34\u7684\u5F53\u524D\u6307\u4EE4\u6309\u996E\u7528\u524D\u7684\u901F\u5EA6\u8BA1\u65F6\uFF1B\u65B0\u901F\u5EA6\u836F\u6C34\u8986\u76D6\u65E7\u901F\u5EA6\u72B6\u6001\uFF0C\u5F53\u524D\u6307\u4EE4\u4E0D\u6D88\u8017\u65E7\u72B6\u6001\u6216\u65B0\u72B6\u6001\u7684\u6301\u7EED\u6B21\u6570\u3002\u6301\u7EED\u6B21\u6570\u8017\u5C3D\u540E\uFF0C\u901F\u5EA6\u6062\u590D\u4E3A\u6B63\u5E38\uFF0C\u5269\u4F59\u6307\u4EE4\u6570\u4E3A0\u3002`;
+  const speedRuleEn = `At the start of each atomic movement instruction, add time units according to the current speed: normal ${m.movementTime.normal}, fast ${m.movementTime.fast}, slow ${m.movementTime.slow}. A haste potion sets speed to fast, and a slow potion sets speed to slow; either effect starts with the instruction after it is drunk and lasts for its stated number of instructions. Blocked instructions also consume one duration. The instruction that drinks a speed potion uses the pre-drink speed for time. A new speed potion replaces the previous speed state, and that instruction consumes neither the old nor the new duration. When the duration is exhausted, speed returns to normal with 0 speed-effect instructions remaining.`;
+  const rules = language === "zh" ? [
+    "\u6BCF\u6761\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u53EA\u5C1D\u8BD5\u5411\u4E0A\u3001\u4E0B\u3001\u5DE6\u6216\u53F3\u76F8\u90BB\u7684\u4E00\u683C\u79FB\u52A8\u3002\u884C\u52A8\u63CF\u8FF0\u4E2D\u7684\u201C\u79FB\u52A8N\u683C\u201D\u8868\u793A\u8FDE\u7EED\u6267\u884CN\u6761\u540C\u65B9\u5411\u7684\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u3002\u521D\u59CB\u4F4D\u4E8E\u5165\u53E3\u4E0D\u89C6\u4E3A\u8FDB\u5165\u8BE5\u683C\uFF1B\u53EA\u6709\u6210\u529F\u79FB\u52A8\u8FDB\u5165\u76EE\u6807\u683C\u65F6\uFF0C\u624D\u7ED3\u7B97\u8BE5\u683C\u7684\u6548\u679C\u3002",
+    "\u82E5\u76EE\u6807\u683C\u662F\u5899\u683C\u6216\u5728\u5730\u56FE\u5916\uFF0C\u63A2\u9669\u8005\u505C\u5728\u539F\u5730\uFF0C\u4F46\u8BE5\u6307\u4EE4\u4ECD\u7B97\u4F5C\u4E00\u6761\u5DF2\u6267\u884C\u7684\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\uFF0C\u4E4B\u540E\u7684\u6307\u4EE4\u7EE7\u7EED\u6267\u884C\u3002",
+    doorRuleZh,
+    "\u7B2C\u4E00\u6B21\u8FDB\u5165\u94A5\u5319\u683C\u65F6\u53D6\u5F97\u8BE5\u94A5\u5319\uFF1B\u540C\u4E00\u628A\u94A5\u5319\u4E0D\u80FD\u91CD\u590D\u53D6\u5F97\u3002",
+    chestRuleZh,
+    "\u7B2C\u4E00\u6B21\u8FDB\u5165\u9677\u9631\u683C\u65F6\u53D7\u5230\u8BE5\u9677\u9631\u6807\u660E\u7684\u4F24\u5BB3\uFF1B\u540C\u4E00\u9677\u9631\u4EE5\u540E\u4E0D\u518D\u751F\u6548\u3002",
+    usesPotionObjects ? "\u836F\u6C34\u683C\u662F\u6307\u542B\u6709\u6CBB\u7597\u836F\u6C34\u3001\u6BD2\u836F\u3001\u89E3\u6BD2\u836F\u6C34\u3001\u52A0\u901F\u836F\u6C34\u6216\u51CF\u901F\u836F\u6C34\u7684\u683C\u5B50\u3002\u7B2C\u4E00\u6B21\u8FDB\u5165\u836F\u6C34\u683C\u65F6\u7ACB\u5373\u996E\u7528\u5176\u4E2D\u7684\u836F\u6C34\u5E76\u5E94\u7528\u5176\u6548\u679C\uFF1B\u540C\u4E00\u74F6\u836F\u6C34\u4E0D\u80FD\u91CD\u590D\u996E\u7528\u3002" : "\u7B2C\u4E00\u6B21\u8FDB\u5165\u836F\u54C1\u623F\u65F6\u6062\u590D\u5176\u6807\u660E\u7684\u5065\u5EB7\u503C\uFF0C\u4F46\u4E0D\u8D85\u8FC7\u5065\u5EB7\u4E0A\u9650\uFF1B\u540C\u4E00\u836F\u54C1\u623F\u4EE5\u540E\u4E0D\u518D\u751F\u6548\u3002",
+    orderRuleZh,
+    ...usesPoison ? [poisonRuleZh] : [],
+    ...m.complexity === "advanced" ? [speedRuleZh] : [],
+    "\u5065\u5EB7\u503C\u964D\u81F30\u6216\u4EE5\u4E0B\u65F6\uFF0C\u5C06\u5065\u5EB7\u503C\u8BB0\u4E3A0\uFF0C\u63A2\u9669\u8005\u6B7B\u4EA1\u3002\u6B7B\u4EA1\u540E\u5C1A\u672A\u6267\u884C\u7684\u6307\u4EE4\u4ECD\u88AB\u8BFB\u53D6\uFF0C\u4F46\u4E0D\u79FB\u52A8\u3001\u4E0D\u8017\u65F6\uFF0C\u4E5F\u4E0D\u6539\u53D8\u4EFB\u4F55\u72B6\u6001\u3002",
+    "\u4E00\u65E6\u8FDB\u5165\u7EC8\u70B9\u683C\uFF0C\u201C\u66FE\u7ECF\u5230\u8FBE\u7EC8\u70B9\u201D\u6C38\u4E45\u8BB0\u4E3A\u771F\uFF0C\u5373\u4F7F\u540E\u6765\u79BB\u5F00\u6216\u6B7B\u4EA1\u4E5F\u4E0D\u64A4\u9500\u3002"
+  ] : [
+    "Each atomic movement instruction attempts to move exactly one cell up, down, left, or right. A direction followed by N cells means N consecutive atomic movement instructions in that direction. Starting at the entry does not count as entering its cell; target-cell effects are resolved only after a successful movement into that cell.",
+    "If the target is a wall or outside the map, the explorer stays in place. The instruction still counts as executed, and later instructions continue.",
+    doorRuleEn,
+    "The first time the explorer enters a key cell, that key is collected. A key cannot be collected twice.",
+    chestRuleEn,
+    "The first time the explorer enters a trap cell, the trap reduces health by its stated amount. That trap has no effect afterward.",
+    usesPotionObjects ? "A potion cell contains a healing, poison, antidote, haste, or slow potion. The first time the explorer enters a potion cell, its potion is drunk immediately and its effect is applied. A potion cannot be drunk twice." : "The first time the explorer enters a medicine room, it restores the stated health without exceeding maximum health. It has no effect afterward.",
+    orderRuleEn,
+    ...usesPoison ? [poisonRuleEn] : [],
+    ...m.complexity === "advanced" ? [speedRuleEn] : [],
+    "If health becomes 0 or less, set it to 0 and the explorer dies. Remaining instructions are still read but cause no movement, consume no time, and change no state.",
+    "Once the explorer enters the goal, ever-reached-goal remains true even if the explorer later leaves or dies."
+  ];
+  return rules.map((rule, index) => `${index + 1}. ${rule}`).join("\n");
+}
+function renderQuestions(maze, language) {
+  const materialKeys = maze.mechanisms.keyMaterials.length > 0;
+  const questions = language === "zh" ? ["\u5168\u90E8\u6307\u4EE4\u5904\u7406\u5B8C\u6BD5\u540E\uFF0C\u63A2\u9669\u8005\u4F4D\u4E8E\u54EA\u4E00\u683C\uFF1F", materialKeys ? "\u6700\u540E\u6301\u6709\u7684\u94A5\u5319\u603B\u6570\uFF08\u6240\u6709\u6750\u8D28\u5408\u8BA1\uFF09\u662F\u591A\u5C11\uFF1F" : "\u6700\u540E\u6301\u6709\u51E0\u628A\u666E\u901A\u94A5\u5319\uFF1F", "\u6700\u540E\u53D6\u5F97\u7684\u5B9D\u7269\u603B\u6570\uFF08\u6240\u6709\u7C7B\u578B\u5408\u8BA1\uFF09\u662F\u591A\u5C11\uFF1F", "\u6700\u540E\u5269\u4F59\u591A\u5C11\u5065\u5EB7\u503C\uFF1F", "\u6700\u540E\u662F\u5426\u5B58\u6D3B\uFF1F", "\u662F\u5426\u66FE\u7ECF\u5230\u8FBE\u7EC8\u70B9\uFF1F", "\u5171\u6253\u5F00\u51E0\u9053\u95E8\uFF1F", "\u5171\u6253\u5F00\u51E0\u53EA\u5B9D\u7BB1\uFF1F", "\u5171\u89E6\u53D1\u51E0\u4E2A\u9677\u9631\uFF1F"] : ["Which cell contains the explorer after all instructions have been processed?", materialKeys ? "How many keys remain in total across all key materials?" : "How many ordinary keys remain?", "How many treasures were collected in total across all treasure types?", "How much health remains?", "Is the explorer alive at the end?", "Did the explorer ever reach the goal?", "How many doors were opened?", "How many chests were opened?", "How many traps were triggered?"];
+  if (maze.objects.some((item) => item.type === "medicine")) questions.push(language === "zh" ? "\u5171\u4F7F\u7528\u51E0\u4E2A\u836F\u54C1\u623F\uFF1F" : "How many medicine rooms were used?");
+  if (maze.objects.some((item) => item.type === "potion")) questions.push(language === "zh" ? "\u5171\u996E\u7528\u51E0\u74F6\u836F\u6C34\uFF1F" : "How many potions were drunk?");
+  questions.push(language === "zh" ? "\u6309\u5168\u90E8\u5217\u51FA\u7684\u539F\u5B50\u79FB\u52A8\u6307\u4EE4\u8BA1\u6570\uFF08\u5305\u62EC\u6B7B\u4EA1\u540E\u4ECD\u88AB\u8BFB\u53D6\u7684\u6307\u4EE4\uFF09\uFF0C\u5176\u4E2D\u591A\u5C11\u6761\u6CA1\u6709\u6539\u53D8\u63A2\u9669\u8005\u7684\u4F4D\u7F6E\uFF1F" : "Counting every listed atomic movement instruction, including instructions read after death, how many did not change the explorer's position?");
+  for (const material of maze.mechanisms.keyMaterials) questions.push(language === "zh" ? `\u6700\u540E\u5269\u4F59\u51E0\u628A${MATERIAL_NAMES[material].zh}\u94A5\u5319\uFF1F` : `How many ${MATERIAL_NAMES[material].en} keys remain?`);
+  if (maze.mechanisms.treasureTypes.some((type) => type !== "treasure")) for (const type of maze.mechanisms.treasureTypes) questions.push(language === "zh" ? `\u5171\u53D6\u5F97\u591A\u5C11${treasureUnit(type)}${TREASURE_NAMES[type].zh}\uFF1F` : `How many ${TREASURE_NAMES[type].en}s were collected?`);
+  if (maze.mechanisms.complexity === "advanced") questions.push(language === "zh" ? "\u7D2F\u8BA1\u8017\u65F6\u662F\u591A\u5C11\u4E2A\u65F6\u95F4\u5355\u4F4D\uFF1F" : "What is the total elapsed time in time units?", language === "zh" ? "\u6700\u7EC8\u901F\u5EA6\u72B6\u6001\uFF08\u6B63\u5E38\u3001\u52A0\u901F\u6216\u51CF\u901F\uFF09\u53CA\u901F\u5EA6\u6548\u679C\u5269\u4F59\u6307\u4EE4\u6570\u5206\u522B\u662F\u4EC0\u4E48\uFF1F" : "What are the final speed state (normal, fast, or slow) and the number of speed-effect instructions remaining?", language === "zh" ? "\u6700\u7EC8\u4E2D\u6BD2\u72B6\u6001\u8FD8\u5269\u51E0\u6761\u6307\u4EE4\uFF1F" : "How many poison instructions remain at the end?");
+  return questions.map((item, index) => `${index + 1}. ${item}`).join("\n");
+}
+function renderActionDescription(actions, language, style) {
+  const runs = compressActions(actions);
+  if (language === "zh") {
+    const connectors = ["\u968F\u540E", "\u63A5\u7740", "\u7136\u540E", "\u518D", "\u4E4B\u540E"];
+    return paragraphize(runs.map((run, index) => `${index === 0 ? "\u63A2\u9669\u8005\u5148" : connectors[(style + index) % connectors.length] ?? "\u7136\u540E"}\u5411${DIRECTIONS[run.direction].zh}\u79FB\u52A8${run.count}\u683C`), "\uFF0C", "\u3002");
+  }
+  return paragraphize(runs.map((run, index) => `${index === 0 ? "First, the explorer moves" : index % 4 === 0 ? "The explorer then moves" : "then moves"} ${DIRECTIONS[run.direction].en} ${run.count} cell${plural(run.count)}`), ", ", ".");
+}
+function paragraphize(clauses, separator, terminator) {
+  const sentences = [];
+  for (let index = 0; index < clauses.length; index += 4) sentences.push(`${clauses.slice(index, index + 4).join(separator)}${terminator}`);
+  return sentences.join("\n");
+}
+function compressActions(actions) {
+  const runs = [];
+  for (const direction of actions) {
+    const prior = runs.at(-1);
+    if (prior?.direction === direction) prior.count += 1;
+    else runs.push({ direction, count: 1 });
+  }
+  return runs;
+}
+function routeThrough(maze, points) {
+  const actions = [];
+  for (let index = 1; index < points.length; index += 1) {
+    const from = points[index - 1];
+    const to = points[index];
+    if (!from || !to) continue;
+    const path = shortestPath(maze, from, to);
+    if (path.length === 0) throw new Error("Could not connect scenario waypoints.");
+    actions.push(...pathToActions(path));
+  }
+  return actions;
+}
+function pathToActions(path) {
+  const actions = [];
+  for (let index = 1; index < path.length; index += 1) {
+    const current = path[index];
+    const prior = path[index - 1];
+    if (!current || !prior) continue;
+    const dr = current.row - prior.row;
+    const dc = current.col - prior.col;
+    actions.push(dr === -1 ? "up" : dr === 1 ? "down" : dc === -1 ? "left" : "right");
+  }
+  return actions;
+}
+function wallDirection(maze, position) {
+  const candidates = [["up", cell(position.row - 1, position.col)], ["down", cell(position.row + 1, position.col)], ["left", cell(position.row, position.col - 1)], ["right", cell(position.row, position.col + 1)]];
+  return candidates.find(([, target]) => terrainAt(maze, target) !== ".")?.[0] ?? null;
+}
+function initialPossessions(state, language) {
+  const materials = emptyMaterialCounts(state.keysByMaterial);
+  const parts = Object.keys(materials).filter((key) => materials[key] > 0).map((key) => language === "zh" ? `${materials[key]}\u628A${MATERIAL_NAMES[key].zh}\u94A5\u5319` : `${materials[key]} ${MATERIAL_NAMES[key].en} key${plural(materials[key])}`);
+  if (state.keys > 0) parts.unshift(language === "zh" ? `${state.keys}\u628A\u666E\u901A\u94A5\u5319` : `${state.keys} ordinary key${plural(state.keys)}`);
+  const keys = parts.length > 0 ? parts.join(language === "zh" ? "\u3001" : ", ") : language === "zh" ? "\u6CA1\u6709\u94A5\u5319" : "no keys";
+  const treasures = state.treasures > 0 ? language === "zh" ? `${state.treasures}\u4EF6\u5B9D\u7269` : `${state.treasures} treasure${plural(state.treasures)}` : language === "zh" ? "\u6CA1\u6709\u5B9D\u7269" : "no treasures";
+  return language === "zh" ? `\u6301\u6709${keys}\uFF0C${treasures}` : `${keys} and ${treasures}`;
+}
+function treasureUnit(type) {
+  return type === "coin" ? "\u679A" : type === "gem" ? "\u9897" : "\u4EF6";
+}
+function plural(value) {
+  return value === 1 ? "" : "s";
+}
+function capitalize(value) {
+  return `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}`;
+}
+function integer(value, name, minimum) {
+  if (!Number.isInteger(value) || value < minimum) throw new Error(`${name} must be an integer greater than or equal to ${minimum}.`);
+  return value;
+}
+function oddInteger(value, name, minimum) {
+  integer(value, name, minimum);
+  if (value % 2 === 0) throw new Error(`${name} must be odd.`);
+  return value;
+}
+function finiteNumber(value, name, minimum, maximum) {
+  if (!Number.isFinite(value) || value < minimum || value > maximum) throw new Error(`${name} must be between ${minimum} and ${maximum}.`);
+  return value;
+}
+
+// src/cli.ts
+var VERSION = "0.3.0";
+try {
+  const parsed = parseArguments(import_node_process.default.argv.slice(2));
+  if (parsed === "help") {
+    import_node_process.default.stdout.write(helpText());
+  } else if (parsed === "version") {
+    import_node_process.default.stdout.write(`${VERSION}
+`);
+  } else {
+    const trial = generateTrial(parsed.trial);
+    if (parsed.format === "text") {
+      import_node_process.default.stdout.write(parsed.command === "question" ? trial.question : trial.answer);
+    } else if (parsed.command === "question") {
+      import_node_process.default.stdout.write(
+        `${JSON.stringify(
+          {
+            schemaVersion: trial.schemaVersion,
+            kind: "question",
+            options: trial.options,
+            maze: {
+              id: trial.maze.id,
+              requestedSeed: trial.maze.requestedSeed,
+              effectiveSeed: trial.maze.seed,
+              metrics: trial.maze.metrics
+            },
+            sections: trial.sections,
+            question: trial.question
+          },
+          null,
+          2
+        )}
+`
+      );
+    } else {
+      import_node_process.default.stdout.write(
+        `${JSON.stringify(
+          {
+            schemaVersion: trial.schemaVersion,
+            kind: "answer",
+            options: trial.options,
+            maze: {
+              id: trial.maze.id,
+              requestedSeed: trial.maze.requestedSeed,
+              effectiveSeed: trial.maze.seed
+            },
+            answers: trial.result.answers,
+            actionCount: trial.actions.length,
+            answer: trial.answer
+          },
+          null,
+          2
+        )}
+`
+      );
+    }
+  }
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  import_node_process.default.stderr.write(`maze-test: ${message}
+Run "maze-test --help" for usage.
+`);
+  import_node_process.default.exitCode = 1;
+}
+function parseArguments(args) {
+  const values = [...args];
+  let command = "question";
+  const first = values[0];
+  if (first && !first.startsWith("-")) {
+    values.shift();
+    if (first === "question" || first === "q") command = "question";
+    else if (first === "answer" || first === "a") command = "answer";
+    else throw new Error(`Unknown command: ${first}`);
+  }
+  const trial = {};
+  let format = "text";
+  for (let index = 0; index < values.length; index += 1) {
+    const raw = values[index];
+    if (!raw) continue;
+    const equalIndex = raw.indexOf("=");
+    const flag = equalIndex >= 0 ? raw.slice(0, equalIndex) : raw;
+    const inline = equalIndex >= 0 ? raw.slice(equalIndex + 1) : void 0;
+    if (flag === "--help" || flag === "-h") return "help";
+    if (flag === "--version" || flag === "-v") return "version";
+    if (flag === "--json") {
+      format = "json";
+      continue;
+    }
+    const value = inline ?? values[++index];
+    if (value === void 0) throw new Error(`Missing value for ${flag}.`);
+    switch (flag) {
+      case "--seed":
+        trial.seed = parseInteger(value, flag);
+        break;
+      case "--rows":
+        trial.rows = parseInteger(value, flag);
+        break;
+      case "--cols":
+        trial.cols = parseInteger(value, flag);
+        break;
+      case "--braid":
+        trial.braid = parseNumber(value, flag);
+        break;
+      case "--doors":
+        trial.doorCount = parseInteger(value, flag);
+        break;
+      case "--chests":
+        trial.chestCount = parseInteger(value, flag);
+        break;
+      case "--traps":
+        trial.trapCount = parseInteger(value, flag);
+        break;
+      case "--medicines":
+        trial.medicineCount = parseInteger(value, flag);
+        break;
+      case "--potions":
+        trial.potionCount = parseInteger(value, flag);
+        break;
+      case "--complexity":
+        trial.complexity = value;
+        break;
+      case "--trap-damage":
+        trial.trapDamages = parseIntegerList(value, flag);
+        break;
+      case "--potion-kinds":
+        trial.potionKinds = parseList(value, flag);
+        break;
+      case "--key-materials":
+        trial.keyMaterials = parseList(value, flag);
+        break;
+      case "--treasure-types":
+        trial.treasureTypes = parseList(value, flag);
+        break;
+      case "--poison-damage":
+        trial.poisonDamage = parseInteger(value, flag);
+        break;
+      case "--poison-duration":
+        trial.poisonDuration = parseInteger(value, flag);
+        break;
+      case "--speed-duration":
+        trial.speedDuration = parseInteger(value, flag);
+        break;
+      case "--scenario":
+        trial.scenario = value;
+        break;
+      case "--lang":
+      case "--language":
+        trial.language = value;
+        break;
+      case "--style":
+        trial.style = parseInteger(value, flag);
+        break;
+      case "--min-distance":
+        trial.minDistance = parseInteger(value, flag);
+        break;
+      case "--max-attempts":
+        trial.maxAttempts = parseInteger(value, flag);
+        break;
+      case "--format":
+        if (value !== "text" && value !== "json") throw new Error(`Invalid format: ${value}`);
+        format = value;
+        break;
+      default:
+        throw new Error(`Unknown option: ${flag}`);
+    }
+  }
+  return { command, format, trial };
+}
+function parseInteger(value, flag) {
+  if (!/^-?\d+$/u.test(value)) throw new Error(`${flag} requires an integer.`);
+  return Number(value);
+}
+function parseNumber(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) throw new Error(`${flag} requires a number.`);
+  return parsed;
+}
+function parseList(value, flag) {
+  const values = value.split(",").map((item) => item.trim()).filter(Boolean);
+  if (values.length === 0) throw new Error(`${flag} requires a non-empty comma-separated list.`);
+  return values;
+}
+function parseIntegerList(value, flag) {
+  return parseList(value, flag).map((item) => parseInteger(item, flag));
+}
+function helpText() {
+  return `maze-test ${VERSION}
+
+Generate a deterministic maze question or its answer key.
+
+Usage:
+  maze-test [question] [options]
+  maze-test answer [options]
+
+Commands:
+  question, q              Generate the question (default)
+  answer, a                Generate the matching answer key
+
+Options:
+  --seed <integer>         Root seed (default: 1)
+  --rows <odd integer>     Number of rows (default: 15)
+  --cols <odd integer>     Number of columns (default: 15)
+  --braid <0..1>           Chance to remove a dead end (default: 0)
+  --complexity <level>     basic | intermediate | advanced (default: basic)
+  --doors <integer>        Number of doors and keys (preset-dependent)
+  --chests <integer>       Number of chests (preset-dependent)
+  --traps <integer>        Number of traps (preset-dependent)
+  --potions <integer>      Number of potions (preset-dependent)
+  --medicines <integer>    Legacy alias for --potions
+  --trap-damage <list>     Comma-separated positive damage values
+  --potion-kinds <list>    healing,poison,antidote,haste,slow
+  --key-materials <list>   copper,silver,gold
+  --treasure-types <list>  treasure,coin,gem,relic
+  --poison-damage <int>    Damage per poison tick
+  --poison-duration <int>  Poisoned instruction count
+  --speed-duration <int>   Fast/slow instruction count
+  --scenario <name>        success | treasure-and-leave | death-and-stop | mechanism-tour
+                           (default: success)
+  --lang <language>        en | zh (default: en)
+  --style <integer>        Deterministic wording variation (default: 0)
+  --min-distance <integer> Minimum entry-to-goal distance (default: 0)
+  --max-attempts <integer> Deterministic search limit (default: 500)
+  --format <format>        text | json (default: text)
+  --json                   Alias for --format json
+  -h, --help               Show help
+  -v, --version            Show version
+
+Examples:
+  npx maze-test question --seed 42 --rows 15 --cols 15
+  npx maze-test answer --seed 42 --rows 15 --cols 15
+  npx maze-test question --seed 42 --lang zh
+  npx maze-test question --seed 42 --complexity advanced --scenario mechanism-tour
+  npx maze-test answer --seed 42 --format json
+`;
+}
+//# sourceMappingURL=cli.cjs.map