Add the engine core: path-addressed state, data-driven turns

The planning docs commit to one thing above all: adding content must never
require touching the engine. This lays the foundation that makes that true.

All game state is addressable by dotted path (money, skills.negotiation,
relationships.boss.likes_you, flags.took_loan), and conditions and effects are
generic operations over those paths. The schema in the planning docs had
`requires: { skill, min }` and `effects: { money, skills, relationships }`,
both of which hardcode the state shape into the engine; the first gate wanting
a relationship threshold or a flag would have meant an engine change.

There is deliberately no "random event" category. Every turn filters the whole
event pool by stage and conditions and draws by weight, so a routine turn, a
rare interruption and the hard-times branch differ only in their data.

Also here, neither in the planning docs but both cheap and load-bearing:

- A seeded, serializable RNG. Runs replay exactly from seed plus choices, which
  makes tests deterministic and playtest reports reproducible. The generator's
  position is one uint32 living in the save.
- A load-time content validator. Undeclared paths, unknown character ids, ids
  that cannot be path segments, events that can never fire and stages with no
  fallback event are all caught on load instead of forty turns into a game.

The turn loop is a pure function, so a saved game resumes into exactly the run
it left — covered by a test that plays thirty turns, plays the same thirty with
a JSON round trip in the middle, and deep-equals the two.

72 tests, no dependencies. Reasoning recorded in docs/DECISIONS.md.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VMSFHyVPitUoosW5wyEADj

test/validate.test.js

@@ -0,0 +1,121 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { validatePack, assertValidPack } from '../src/engine/validate.js';
+import { testPack } from './fixtures/test-pack.js';
+
+/** A copy of the fixture with one thing broken. */
+function broken(mutate) {
+  const pack = structuredClone(testPack);
+  mutate(pack);
+  return validatePack(pack);
+}
+
+const messages = (result) => result.errors.join('\n');
+
+test('the fixture pack is valid and warning-free', () => {
+  const result = validatePack(testPack);
+  assert.deepEqual(result.errors, []);
+  assert.deepEqual(result.warnings, []);
+});
+
+test('an effect writing an undeclared path is caught', () => {
+  const result = broken((pack) => {
+    pack.events[0].options[0].effects.push({ path: 'skills.wleding', op: 'add', value: 1 });
+  });
+  assert.match(messages(result), /skills\.wleding.*not declared/s);
+});
+
+test('a relationship effect naming a character who does not exist is caught', () => {
+  const result = broken((pack) => {
+    pack.events[0].options[0].effects.push({ path: 'relationships.dave.likes_you', op: 'add', value: 1 });
+  });
+  assert.match(messages(result), /relationships\.dave\.likes_you.*not declared/s);
+});
+
+test('a condition reading an undeclared path is caught', () => {
+  const result = broken((pack) => {
+    pack.events[0].options[1].requires = [{ path: 'skills.charisma', op: '>=', value: 1 }];
+  });
+  assert.match(messages(result), /skills\.charisma.*not declared/s);
+});
+
+test('content may read engine bookkeeping but not write it', () => {
+  const readsTurn = broken((pack) => {
+    // Not the floor event — see the fallback rule below.
+    pack.events.find((e) => e.id === 'audit').requires = [{ path: 'turn', op: '>=', value: 3 }];
+  });
+  assert.deepEqual(readsTurn.errors, []);
+
+  const writesTurn = broken((pack) => {
+    pack.events[0].options[0].effects.push({ path: 'turn', op: 'add', value: 5 });
+  });
+  assert.match(messages(writesTurn), /engine-owned state/);
+});
+
+test('declaring a reserved root as pack state is caught', () => {
+  const result = broken((pack) => { pack.state['history'] = { initial: [] }; });
+  assert.match(messages(result), /reserved root/);
+});
+
+test('unknown operators are caught before they reach the engine', () => {
+  const badCondition = broken((pack) => {
+    pack.events[0].options[0].requires = [{ path: 'money', op: 'exceeds', value: 1 }];
+  });
+  assert.match(messages(badCondition), /unknown condition operator/);
+
+  const badEffect = broken((pack) => {
+    pack.events[0].options[0].effects[0].op = 'multiply';
+  });
+  assert.match(messages(badEffect), /unknown effect operation/);
+});
+
+test('add with a non-numeric value is caught', () => {
+  const result = broken((pack) => { pack.events[0].options[0].effects[0].value = 'ten'; });
+  assert.match(messages(result), /non-numeric/);
+});
+
+test('duplicate ids are caught', () => {
+  assert.match(messages(broken((pack) => { pack.events[1].id = 'routine'; })), /duplicate id/);
+  assert.match(messages(broken((pack) => { pack.characters[1].id = 'chief'; })), /duplicate id/);
+  assert.match(messages(broken((pack) => { pack.events[0].options[1].id = 'work'; })), /duplicate id/);
+});
+
+test('an id that cannot be a path segment is caught, because ids become state paths', () => {
+  const result = broken((pack) => { pack.events[0].id = 'routine day'; });
+  assert.match(messages(result), /must match/);
+});
+
+test('an event with no options is caught', () => {
+  const result = broken((pack) => { pack.events[0].options = []; });
+  assert.match(messages(result), /no options/);
+});
+
+test('a zero weight is caught, since the event could never fire', () => {
+  const result = broken((pack) => { pack.events[0].weight = 0; });
+  assert.match(messages(result), /greater than zero/);
+});
+
+test('a stage with no unconditional event is caught, since the pool can run dry', () => {
+  const result = broken((pack) => {
+    pack.events[0].requires = [{ path: 'money', op: '>', value: 0 }];
+  });
+  assert.match(messages(result), /no unconditional event/);
+});
+
+test('a starting stage with no events at all is caught', () => {
+  const result = broken((pack) => { pack.startingStage = 'penthouse'; });
+  assert.match(messages(result), /startingStage "penthouse" has no events/);
+});
+
+test('a character with no role_type warns but still plays', () => {
+  const result = broken((pack) => { delete pack.characters[0].role_type; });
+  assert.deepEqual(result.errors, []);
+  assert.match(result.warnings.join('\n'), /role_type/);
+});
+
+test('assertValidPack throws with every error listed', () => {
+  const pack = structuredClone(testPack);
+  pack.events[0].options[0].effects.push({ path: 'nope', op: 'add', value: 1 });
+  assert.throws(() => assertValidPack(pack), /is invalid/);
+  assert.doesNotThrow(() => assertValidPack(testPack));
+});