jyapayne/houserules
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(thressgame-100): Wave 5 \u2014 economy + score chips + 3 recipes + e2e

Browse source 
Wave 5 of thressgame-100 epic complete \u2014 paradigm-break wave per oracle.
User-authorized despite the cost. Coverage: 47/51 \u2192 50/51 = 98 %.

PARADIGM-BREAK CONTEXT (oracle pre-flagged):
Oracle classified Wave 5 as 'paradigm break \u2014 game-level mutable state'. User
explicitly authorized via 'no time/cost limit, no backward-compat constraint,
just fucking get it all done'. Design choice: scores live alongside RngStream
on GAME_ENTITY \u2014 same pattern as existing global state (RngStream,
ChoiceTimeoutPolicy, BoardTopology, BlockAllExceptKing), not new architecture.

ENGINE WORK (W5.0\u2013W5.4):

Score subsystem (locked decision F):
- WhiteScore + BlackScore attrs on GAME_ENTITY \u2014 type 'number', default 0
- Initialized at engine construction (engine.ts:632\u2013634) so fact-log inclusion
  is mechanical \u2014 state-hash auto-includes scores via existing infrastructure
- N=100 byte-identical replay determinism verified

3 NEW PRIMITIVES:
- add-resource(player, amount)         imperative; synchronous fire of
                                        on-resource-changed hooks
- spend-resource(player, amount,       imperative; selfRecurse:true \u2014 only the
                  then, else)           chosen arm runs (walker doesn't auto-recurse
                                        into both); cascade-depth-limited (8)
- on-resource-changed(player,          trigger; fires on threshold crossing in
                       threshold,       direction up/down/any; snapshot-before-iterate
                       direction,       so hook arm registering more hooks doesn't
                       primitives)      fire on the same crossing

WS PROTOCOL (W5.5) \u2014 Scenario A chosen: ZERO protocol changes:
- broadcast.ts uses session.allFacts() which iterates ALL facts on ALL entities
  including GAME_ENTITY
- WhiteScore/BlackScore mutations land in game.state and game.delta frames
  automatically; client PredictionManager receives them out-of-the-box
- Zod FactSchema has untyped .unknown() value field on the wire \u2014 number values
  serialize implicitly

UI WORK (W5.6) \u2014 GameView.tsx score chips:
- Two chips: data-testid='score-white' (\u26aa W) and data-testid='score-black'
  (\u26ab B), bordered chip styling matching ActionMenu sibling vocabulary
- HIDE-WHEN-ZERO rule: chips hidden unless either score !== 0 OR
  OnResourceChangedHooks contains entries (pure-chess games visually unchanged)
- Real-time updates via existing useMultiplayerGame hook \u2014 broadcasts trigger
  re-render, scores update without page reload

3 NEW RECIPES (W5.7):

Batch M \u2014 economy:
- tpl-treasure-chest        \u2014 capture spawns treasure marker; entering treasure
                              awards white +5 score and consumes marker
                              (SIMPLIFIED: arm 2 hardcodes player='white' \u2014
                              no chooser-color resolver; LastModifierChooser
                              semantics = rule applier not current mover)
- tpl-cash-grab             \u2014 every turn-end, white+1 + black+1 (passive income)
                              (SIMPLIFIED: V3 has no eq shape \u2014 random-pick result
                              can't be compared against piece Position; ship the
                              dual-add-resource pattern instead of canonical
                              random-square-rewards-piece-owner semantics)
- tpl-summoning-ritual      \u2014 spend 5 score to summon white knight at e4
                              (SIMPLIFIED: single-shot at activation; repeatable
                              summoning needs request-choice loop \u2014 W6+ scope)

TEST SURFACE:
- add-resource.test.ts:                             ~10 unit tests
- spend-resource.test.ts:                           ~12 unit tests
- on-resource-changed.test.ts:                      ~15 unit tests
- economy-integration.test.ts:                       8 integration tests
                                                    (incl. N=100 determinism)
- wave5-recipes-real.test.ts:                       14 runtime tests
- recipes.test.ts:                                   5 \u00d7 62 = 513 expect calls
- wave5-economy.spec.ts (Playwright):                5 e2e tests
                                                    (3 load + summoning-ritual
                                                    success-path runtime +
                                                    cash-grab turn-end driven)

bun run check: 3270 tests pass (was 3192, +78). 0 regressions.
e2e: 5/5 green via .sisyphus/scripts/run-pw.sh against docker compose dev stack.

KEY FINDINGS (recorded in learnings.md):
- spend-resource selfRecurse:true correctly gates walker auto-recursion \u2014
  place-piece inside 'then' only runs when spend succeeds
- ctx-attr.entity:'self' resolves cleanly to ctx.pieceId in resolver
- fireOnTurnEndHooks (and other per-piece dispatchers) iterate pieces \u2014 hooks
  on GAME_ENTITY are dead-seeded; apply-descriptor needs targetSquare for any
  recipe rooted at a per-piece trigger
- Snapshot-before-iterate in fireOnResourceChangedHooks prevents reentrant
  cascade fires on the same crossing

BACKWARD-INCOMPAT TESTS UPDATED (per locked decision J):
- registry-count.test.ts: 56 \u2192 59 (3 new primitives)
- ParamField.snapshot.test.tsx: SAMPLE_PARAMS exhaustiveness for 3 new kinds
- GameView snapshot: regenerated for new score-chip section

Plan: .sisyphus/plans/thressgame-100.md
Notepads: .sisyphus/notepads/thressgame-100/
Evidence: .sisyphus/evidence/thressgame-100-wave5.txt (gitignored, 1074 lines)
This commit is contained in:
Joey Yakimowich-Payne 2026-04-27 17:22:55 -06:00
commit a2c38a9ad2
No known key found for this signature in database
23 changed files with 3465 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

7
.sisyphus/boulder.json
View file

@ -142,7 +142,12 @@
"ses_22f1823c1ffek8p7La3fBMqslC",
"ses_22efe07c7ffe1eTZ6kvrkGLVYl",
"ses_22ef4380affeXjumRiXI4u1KSK",
"ses_22ef3b48bffeJQKH6xj5U4fuTi"
"ses_22ef3b48bffeJQKH6xj5U4fuTi",
"ses_22ee9db6effe5AVbe40BDqIT9y",
"ses_22ed7ead4ffe0ku37F9Y6qIO9s",
"ses_22ed735fdffeyscON4NRPNOrz5",
"ses_22ec6f8a8ffeaZwK7e1GUo035a",
"ses_22ec791c3ffeMYLw6bTdYIxPNm"
],
"plan_name": "thressgame-coverage",
"agent": "atlas"

141
.sisyphus/notepads/thressgame-100/learnings.md
View file

@ -323,3 +323,144 @@ Final recipe count: **54**. None of the 8 W3 recipes was skipped.
- **DOM piece selector is descendant `[data-square=".."] [data-piece=".."]`, NOT compound `[data-square=".."][data-piece=".."]`** — `data-piece` lives on the inner `<Piece>` element (Piece.tsx:310) while `data-square` lives on the outer `<Board>` cell wrapper (Board.tsx:281). The task brief used the compound form which would never match. Mirrored the parity-rules.spec.ts § probes pattern (`[data-square="b3"] [data-piece="white-pawn"]`).
- **`apply-descriptor` is the right driver for W4 topology + pairing recipes** (NOT activate-descriptor). activate-descriptor lifts a request-choice to fire a PendingChoice frame; the W4 recipes have no request-choice — they need the FULL `applyCustomDescriptor` walk to seed PieceLink lists / set BoardTopology / spawn pieces. Same call shape as parity-rules.spec.ts § all_on_red and ice_physics.
- **Test count delta (e2e only)**: wave4-topology-pairing.spec.ts ships 7 tests. All green on first invocation.
## [2026-04-26] W5.0-W5.4 — economy / resource accumulation subsystem
### Paradigm break shipped (decision F)
- **`WhiteScore` / `BlackScore` on `GAME_ENTITY`** — both `number`, default `0`, seeded at engine construction (engine.ts:632) right after `RngStream`. Pinning the score into the fact log from move-0 (rather than letting `add-resource.apply()`'s `?? 0` fallback do it lazily) means the determinism state hash includes them automatically — replay correctness drops out for free.
- **Architecturally, this is more-of-the-same**, NOT a new pattern. `GAME_ENTITY` already held mutable scalars (`RngStream`, `ChoiceTimeoutPolicy`, `BlockAllExceptKing`, `BlockedPieceTypes`, `PawnPushesPiecesEnabled`, `BoardTopology`). Adding two more numeric counters is a cheap extension; the "paradigm break" framing in the plan tracks the SCOPE of mutability widening (from booleans/discriminators to running tallies) rather than any genuine architecture shift.
### Synchronous fire pattern (distinct from W2's stage-13 batched dispatch)
- `fireOnResourceChangedHooks` (triggers.ts) is invoked DIRECTLY from inside `add-resource.apply()` and `spend-resource.apply()` AFTER the score mutation lands. No deferred queue, no per-turn batch — author intent is "react to the score crossing immediately" and there's no phase-ordering concern (unlike on-attr-expire which had to land at stage 13 between turn-end and turn-start ticks). Cascade-depth cap (8) on `runPrimitives` provides the recursion ceiling; `pendingTriggers` queue is unused for this trigger family.
- **Snapshot-before-iterate** — `fireOnResourceChangedHooks` copies the hook list into `snapshot` before iterating, so a hook arm that itself seeds `on-resource-changed` doesn't fire on the SAME crossing. Matches "registered-before-mutation" author expectations and avoids re-entrant infinite loops at the registration layer (the cascade-depth cap is the second-line defense for non-registration loops).
- **`pieceId` for inner arms is `GAME_ENTITY`** — the trigger is conceptually game-scoped (the score lives on GAME_ENTITY). Authors who want a piece-targeted effect use `for-each-*` iteration inside the arm. Mirror of the W2 attr-expire dispatcher's "fire on the entity that owns the expiring fact" convention.
### Crossing semantics (locked, inclusive on the new-side)
- `direction: "up"` — `previous < threshold AND new >= threshold`
- `direction: "down"` — `previous > threshold AND new <= threshold`
- `direction: "any"` — either of the above
- **Same-value mutations** (previous === new) NEVER cross. `add-resource(white, 0)` is observable as a fact-log no-op (the score is re-inserted with the same value, which Rete dedupes downstream) and fires no hooks. Tested explicitly in `on-resource-changed.test.ts § no-op when score doesn't actually move`.
### `spend-resource` self-recursion semantics
- `selfRecurse: true` because the dispatcher's auto-recursion would walk BOTH `then` and `else` arms regardless of the success branch, defeating the gating semantics. The primitive runs the chosen arm itself via `runPrimitives` inside `apply()`. Mirrors `with-probability`'s self-recursive pattern (the FIRST conditional-style imperative in the registry; `conditional` itself uses dispatcher auto-recursion because both arms are lazily evaluated by the existing fireConditionalHooks dispatcher).
- **Trigger-scope detection in validate.ts** — added `node.kind === "spend-resource"` to the `childrenInTriggerScope` check at validate.ts:387 alongside `conditional` / `on-*` / `for-each-*` / `random-pick`. Without this, imperatives inside `then` / `else` (e.g. `place-piece` for the success arm) would error with `descriptor.primitives.imperative-in-passive`.
- `runPrimitives` invocation in `spend-resource.apply()` reuses `ctx.bindings`, `ctx.cascadeDepth`, `ctx.suppressTriggers`, and `ctx.descriptor.id` — preserves outer lexical scope (no new binding introduced; mirrors `conditional`).
### Schema additions (schema.ts)
- 2 new attrs: `WhiteScore: number`, `BlackScore: number`.
- 1 new attr: `OnResourceChangedHooks: readonly OnResourceChangedHookEntry[]`.
- 1 new exported interface: `OnResourceChangedHookEntry { descriptorId, player, threshold, direction, primitives }`.
- 1 new `PrimitiveEvent` variant in `context.ts`: `{ kind: "resource-changed", player, previousScore, newScore }`.
### Validator (validate.ts) updates
- IMPERATIVE_KINDS gains `add-resource` + `spend-resource`. Both legal ONLY inside trigger arms — top-level placement returns `descriptor.primitives.imperative-in-passive`.
- Trigger-scope walker now admits `spend-resource` for child propagation (its `then` / `else` arms are imperative-legal).
- `on-resource-changed` matches the existing `node.kind.startsWith("on-")` predicate for trigger-scope detection — no validator edit needed.
### Backward-incompat tests updated (per decision J)
- `registry-count.test.ts`: 56 → 59 (3 new primitives — add-resource, spend-resource, on-resource-changed).
- `ParamField.snapshot.test.tsx`: SAMPLE_PARAMS map extended with the 3 new primitive kinds (TS exhaustiveness requirement: `Record<PrimitiveKind, unknown>`).
### Determinism
- N=100 game replays produce byte-identical state hash (`economy-integration.test.ts § Wave-5 economy integration — replay determinism`). The pinned mutation sequence exercises:
- 2 add-resource calls below crossing (no hook fire).
- 1 add-resource that crosses 10 going up (hook fires, sentinel HpBonus=1 written to GAME_ENTITY).
- 1 add-resource on independent black counter (cross-color independence).
- 1 successful spend-resource (10 → 6, runs `then` writing RangeBonus=7).
- 1 failed spend-resource (6 < 100, no `else`, score untouched).
- The state hash trivially includes the new GAME_ENTITY attrs because the fact log is the hash input and `engine.ts` seeds `WhiteScore=0` / `BlackScore=0` at construction. NO state-hash util edits required.
### Test count delta
- `bun run check`: 3192 → 3256 tests (+64). 0 regressions. Breakdown:
- `add-resource.test.ts` (NEW): 14 tests.
- `spend-resource.test.ts` (NEW): 16 tests.
- `on-resource-changed.test.ts` (NEW): 20 tests.
- `__tests__/economy-integration.test.ts` (NEW): 8 tests.
- +6 tests from auto-discovered docs / manifest / consumer-integration walkers picking up the 3 new primitives (registry-count was bumped, exhaustive `Record<PrimitiveKind, unknown>` tests now cover 3 more kinds).
### Files created (line counts)
- `packages/chess/src/modifiers/primitives/add-resource.ts` — 111 lines.
- `packages/chess/src/modifiers/primitives/spend-resource.ts` — 175 lines.
- `packages/chess/src/modifiers/primitives/on-resource-changed.ts` — 140 lines.
- `packages/chess/src/modifiers/primitives/add-resource.test.ts` — 214 lines.
- `packages/chess/src/modifiers/primitives/spend-resource.test.ts` — 278 lines.
- `packages/chess/src/modifiers/primitives/on-resource-changed.test.ts` — 296 lines.
- `packages/chess/src/modifiers/primitives/__tests__/economy-integration.test.ts` — 333 lines.
- Total: 1547 lines new code (engine + tests).
### Files modified
- `packages/chess/src/schema.ts` — `ChessAttrMap` gains 3 attrs (`WhiteScore`, `BlackScore`, `OnResourceChangedHooks`); `OnResourceChangedHookEntry` interface exported.
- `packages/chess/src/engine.ts` — seeds `WhiteScore=0` / `BlackScore=0` at construction (after RngStream).
- `packages/chess/src/modifiers/primitives/types.ts` — `PrimitiveKind` gains 3 kinds; `TriggerName` gains `on-resource-changed`.
- `packages/chess/src/modifiers/primitives/context.ts` — `PrimitiveEvent` gains `resource-changed` variant.
- `packages/chess/src/modifiers/primitives/index.ts` — registers the 3 new primitives.
- `packages/chess/src/modifiers/triggers.ts` — `fireOnResourceChangedHooks` dispatcher exported.
- `packages/chess/src/modifiers/apply.ts` — registers `WhiteScore` / `BlackScore` / `OnResourceChangedHooks` consumers.
- `packages/chess/src/modifiers/custom/validate.ts` — IMPERATIVE_KINDS gains `add-resource` + `spend-resource`; trigger-scope walker admits `spend-resource`.
- `packages/chess/src/modifiers/primitives/registry-count.test.ts` — 56 → 59.
- `packages/chess/src/ui/ParamField.snapshot.test.tsx` — SAMPLE_PARAMS gains 3 entries.
## [2026-04-26] W5.7 — 3 Wave-5 economy template recipes + co-located runtime tests
### Recipes shipped (59 → 62)
**Batch M — economy (3 recipes)**:
- **`tpl-treasure-chest`** — TWO-armed economy + marker recipe. Arm 1: `on-capture → spawn-marker({markerKind:"treasure", square: ctx-attr({entity:"self", attr:"Position"}), lifetime:{kind:"permanent"}})` — drops a treasure marker on the attacker's POST-MOVE Position (which IS the captured piece's square because capture replaces). Arm 2: `on-piece-entered-marker(treasure) → add-resource({player:"white", amount:5}) + destroy-marker({target: ctx-self-marker-id})` — landing on a treasure awards 5 score and consumes the marker. **CONFIRMED: nested `ctx-attr.entity:"self"` resolves to `ctx.pieceId` correctly via `param-resolver.ts:371` (`if (entity === "self") return ctx.pieceId`).** No new resolver shape needed; the existing V3 union accepts `{ "ctx-attr": { entity: "self", attr: "Position" } }` as the `square` argument to `spawn-marker`. SIMPLIFICATION: Arm 2 hardcodes `player:"white"`. The brief flagged that chooser color may not be available inside `on-piece-entered-marker`; in fact `LastModifierChooser` IS persisted on `PRESET_STATE_ENTITY` and the `ctx-attr({entity:"chooser", attr:"Color"})` resolver does work — but its semantics are 'whoever applied THIS rule', not 'whoever stepped on the treasure'. A truly-mover-aware payout would need a new `ctx-piece-color` shape (deferred to W6+).
- **`tpl-cash-grab`** — SIMPLIFIED from the canonical 'random-pick a square; if a piece is there, that piece's owner gets +1' shape. The `random-pick` primitive returns a numeric value but `conditional` does NOT support arithmetic comparison on resolver-shape values (V3 resolver union is arithmetic-only: add/sub/mul/mod — no `eq`). Without comparison we can't gate per-piece add-resource on Position equality. Ship the simplified pattern: `on-turn-end(both) → add-resource(white, 1) + add-resource(black, 1)`. Each turn end, both players gain 1 score — passive-income demonstration of `on-turn-end → add-resource`. The original cash-grab semantic (probabilistic per-square payout) needs a future `eq` resolver shape or a dedicated `random-pick-piece` primitive variant.
- **`tpl-summoning-ritual`** — single-shot ritual. `on-rule-activated → spend-resource({player:"white", amount:5, then:[place-piece({pieceType:"knight", color:"white", square:28})]})`. Direct port of the `spend-resource` then-arm pattern. Pre-seed `WhiteScore=10` for a successful spend; pre-seed `WhiteScore=2` for the failure-no-op path. NO `else` arm — single-shot 'silent failure' semantics. **CONFIRMED: `spend-resource.selfRecurse=true` correctly gates the dispatcher's auto-recursion** so `place-piece` inside `then` is NOT pre-fired by the walker pass — it only runs when the spend succeeds.
### Test-harness conventions (W5-specific)
- **Direct trigger-primitive `apply()` for clean-state seeding**: BOTH `runPrimitives` AND the apply-walker auto-recurse into trigger primitives' `childPrimitives()`, which pre-fires the inner imperatives at SEED TIME (e.g. add-resource fires once during seeding even though we just want OnTurnEndHooks to land). Bypass: import the trigger primitive directly (`ON_TURN_END_PRIMITIVE`, `ON_CAPTURE_PRIMITIVE`, `ON_PIECE_ENTERED_MARKER_PRIMITIVE`) and call `*_PRIMITIVE.apply(ctx, params)` with a hand-rolled `PrimitiveApplyContext`. This calls ONLY the trigger's seed logic and never recurses. Cribbed from W4's `ON_PIECE_PAIR_LINK_BROKEN_PRIMITIVE.apply(ctx, ...)` pattern. **Net effect**: pre-fire side effects are zero, the dispatcher fire is the SOLE path that runs the inner imperatives, and we can pin `readScore(white) === 0` before firing the trigger.
- **`applyCustomDescriptorTolerant` reused from W1** for the smoke tests on tpl-treasure-chest (legitimately throws on `ctx-self-marker-id` outside marker context — the documented apply-walker artifact, see `wave1-recipes-real.test.ts:528-576`) and tpl-summoning-ritual (the spend-resource-then-place-piece chain runs once during the walker pass and would re-fire via `fireOnRuleActivatedHooks` — same double-fire pattern as tpl-suicidal-knight). The W1 tolerant helper accepts only `ctx-self-marker-id` / `ctx-self-id` errors — no new error class needed for W5.
- **Summoning-ritual smoke pre-seeds `WhiteScore=100`** so the walker's eager spend-resource call doesn't underflow (otherwise `2 < 5` would short-circuit and we wouldn't probe the place-piece path). The over-seeded value makes the walker's pre-fire AND the OnRuleActivatedHooks-driven re-fire both safe; we only assert hook presence, not score value (the value is artifact-dependent).
- **No `chooser-color` resolver shape ships in W5**. Arm 2 of tpl-treasure-chest hardcodes `player:"white"`. A future `ctx-piece-color({entity: ctx-self-id})` resolver (or a `chooser-color` literal) would let recipes target the moving player's side; deferred until a recipe that NEEDS it lands.
### Decisions / simplifications recorded
- (a) — `tpl-treasure-chest` Arm 2 hardcodes `player:"white"` (chooser-color stays a future resolver shape).
- (b) — `tpl-cash-grab` ships the on-turn-end + dual-add-resource pattern (no random-pick, no eq, no per-piece). The canonical 'random-square gambling' semantics need an `eq` resolver shape.
- (c) — `tpl-summoning-ritual` is single-shot via on-rule-activated. Repeatable summoning would need a request-choice loop (deferred to W6+).
### Test count delta
- `bun run check`: 3256 → 3270 (+14). 0 regressions. 14 new tests from `wave5-recipes-real.test.ts`:
- tpl-treasure-chest: 3 tests (on-capture spawn arm, on-piece-entered-marker payout arm, descriptor shape).
- tpl-cash-grab: 2 tests (on-turn-end fires + descriptor shape).
- tpl-summoning-ritual: 3 tests (success path with pre-seeded 10 score, failure path with 2 score, descriptor shape).
- Cross-cutting smoke: 6 tests (presence + count + 4 hook-seed asserts via applyCustomDescriptor / Tolerant).
- recipes.test.ts: 5 invariants now apply to 62 recipes (513 expect calls — was 490 at W4 close; +23 from 3 new recipes).
- New file: `wave5-recipes-real.test.ts`.
### Files modified
- `packages/chess/src/modifiers/custom/recipes.ts` — appended 3 W5 recipes (Batch M).
- `packages/chess/src/modifiers/custom/wave5-recipes-real.test.ts` — NEW.
### `bun run check` exit code: 0
## [2026-04-26] W5.8 — Playwright e2e for the 3 Wave-5 economy recipes
- **All 5 tests green** (3 load + 2 runtime) in 7.9s on the docker compose dev stack via `.sisyphus/scripts/run-pw.sh`. Spec at `packages/chess/e2e/wave5-economy.spec.ts`. Helper log: `/tmp/pw-w5-8.log`. First run had 4/5 (cash-grab failed due to `targetSquare` omission); single-edit fix landed the green.
- **Runtime test depth decisions** — both went FULL (not smoke):
- `tpl-summoning-ritual` — pre-seed `WhiteScore=15` via mini-descriptor (top-level `add-resource(white, 15)`; apply-descriptor bypasses validator, walker fires it once). Then apply real recipe → walker double-fires `spend-resource` (walker descent + `fireOnRuleActivatedHooks`), each spending 5 → final WhiteScore=5. `place-piece(knight, white, sq=28)` also fires twice; renderer dedupes to 1 visible knight at e4. Asserts: engine `WhiteScore === 5`, white knight at e4, chip visible with text containing "5".
- `tpl-cash-grab` — applied to `targetSquare: 4` (e1 white king) so `OnTurnEndHooks` lands on a piece. Walker pre-fires the inner add-resource leaves once → post-apply white=1/black=1. Drives 2 plies (white a2-a3 + black a7-a6 via 2nd context guest); each turn-end fires the hook once (color="both") → final 3/3. Chips visible with text containing "3"/"3".
- **CRITICAL pre-existing finding**: `fireOnTurnEndHooks` iterates `eachPiece` and reads `OnTurnEndHooks` from EACH PIECE's id (NOT GAME_ENTITY). `apply-descriptor` defaults `applyTarget = GAME_ENTITY`; for per-piece trigger families (`on-turn-end`, `on-turn-start`, `on-move`, `on-capture`, …) the caller MUST pass `targetSquare` to resolve the apply-target to a real piece-id, otherwise the hook is seeded on GAME_ENTITY and the dispatcher never finds it. Same precedent as `parity-rules.spec.ts § all_on_red` (targets sq=4) and the W1.11 `__test__.setup-board.hooks` "piece-scoped only" gotcha. The brief's pre-seed-via-mini-descriptor strategy works for `add-resource` (no trigger root, walker fires it directly) but a recipe rooted at any per-piece trigger needs `targetSquare`.
- **Score chip selectors**: `[data-testid="score-white"]` / `[data-testid="score-black"]`. Renders `⚪ <N>` / `⚫ <N>` (emoji + space + value); `toContainText("<N>")` absorbs the emoji wrapper. `hasEconomyActive` (GameView.tsx:327) is `whiteScore !== 0 || blackScore !== 0 || OnResourceChangedHooks present` — so a freshly-loaded game shows zero chips, and `tpl-cash-grab`'s walker-pre-fire alone (1/1) is enough to make both visible. `tpl-summoning-ritual`'s WhiteScore=5 makes the white chip visible; black stays hidden (BlackScore=0, no OnResourceChangedHooks).
- **Walker double-fire behaviour for spend-resource**: `spend-resource` has `selfRecurse: true` (apply.ts:196 — walker stops descending once spend-resource is reached). But `fireOnRuleActivatedHooks` runs the on-rule-activated arm SEPARATELY post-walk, which walks into spend-resource AGAIN. Net: spend-resource is invoked twice from a single `applyCustomDescriptor` call. The 15→5 (rather than 15→10 with a single fire) is the locked observable.
- **`Browser` type from @playwright/test** is the right import for shared helper signatures that take the test fixture's `browser` parameter. The brittle `Parameters<Parameters<typeof test>[1]>[0]['browser']` form fails LSP's `never` inference and forces inline guest-page setup.
- **Test count delta (e2e only)**: wave5-economy.spec.ts ships 5 tests. All green on first invocation post-targetSquare fix.

770
packages/chess/e2e/wave5-economy.spec.ts Normal file
View file

@ -0,0 +1,770 @@
/**
* W5.8 — Playwright e2e for the 3 NEW Wave-5 thressgame-100 economy
* recipes shipped by W5.7 (`recipes.ts` lines 2904-3032).
*
* Coverage shape (mirrors `wave4-topology-pairing.spec.ts`, scaled to
* the Wave-5 batch):
*
* 1. Three LOAD-AND-VALIDATE tests — one per recipe id. Same pattern
* as the prior wave specs: open the Custom Modifier Editor →
* click Templates → click the recipe's row →
* assert the modal closes, the descriptor name matches, and the
* validation footer reports "Valid Custom Descriptor".
*
* 2. Two RUNTIME-BEHAVIOR tests:
*
* Batch M-A — `tpl-summoning-ritual` (full runtime, success path):
* Pre-seed `WhiteScore = 15` by applying a mini-descriptor
* containing a single top-level `add-resource(white, 15)`.
* `__test__.apply-descriptor` bypasses the validator's
* imperative-in-passive gate (per W1.11 learnings) so the
* top-level imperative applies cleanly via `applyCustomDescriptor`'s
* walker. The walker has no childPrimitives to recurse for
* `add-resource`, so it fires exactly once → WhiteScore=15.
*
* Then apply the real `tpl-summoning-ritual` recipe. Its
* activation arm contains `on-rule-activated → spend-resource(...)`.
* The walker recurses into `on-rule-activated.childPrimitives()`
* (selfRecurse !== true), reaching `spend-resource` — which has
* `selfRecurse: true`, so the walker calls its `apply()` ONCE
* and stops. Then `fireOnRuleActivatedHooks` fires the arm a
* SECOND time (the documented W1.11 walker-double-fire
* artifact). Net effect: spend-resource runs twice, each spending
* 5 → WhiteScore = 15 - 5 - 5 = 5. The `then` arm's
* `place-piece(knight, white, sq=28)` also runs twice, but
* place-piece writes Position to a fresh entity each call and
* the renderer dedupes by square, so the DOM shows ONE white
* knight at e4.
*
* Assertions: score chip visible with text containing "5";
* a white knight rendered at e4; engine WhiteScore === 5.
*
* Batch M-B — `tpl-cash-grab` (full runtime, turn-end driven):
* Activate the recipe (no pre-seed). The activation arm is
* `on-turn-end(both) → add-resource(white,1) + add-resource(black,1)`.
* The walker recurses into on-turn-end's children and fires
* BOTH add-resource primitives once — so post-apply scores are
* white=1, black=1.
*
* Drive 2 plies (1 white move + 1 black move). Each ply ends
* a turn → fires `OnTurnEndHooks` → +1 to each player. Final
* scores: white=3, black=3.
*
* Assertions: score chips visible with non-zero text values
* BOTH after activation (1/1) AND after 2 plies (3/3).
*
* ─────────────────────────────────────────────────────────────────────
* Driving infrastructure
* ─────────────────────────────────────────────────────────────────────
*
* Per the precedent set by all prior wave specs, e2e helpers are
* duplicated rather than extracted into a shared module — Playwright's
* worker model loads each spec in isolation and `e2e/` is in `testMatch`
* so a shared module under `e2e/` would itself be treated as a test file.
*
* Helper script:
* `.sisyphus/scripts/run-pw.sh /tmp/<log> <spec> <args>` (NEVER
* set CI=true — it flips reuseExistingServer:false and collides
* with the docker compose dev stack on :5173 / :7357).
*/
import { test, expect, type Browser, type Page } from '@playwright/test';
import { spawn, type ChildProcess } from 'node:child_process';
import { setTimeout as sleep } from 'node:timers/promises';
// ---------------------------------------------------------------------------
// LocalStorage / SessionStorage hygiene keys (mirror prior wave specs)
// ---------------------------------------------------------------------------
const PROFILE_LIBRARY_KEY = 'houserules:modifier-profiles:v1';
const CUSTOM_LIBRARY_KEY = 'houserules:custom-modifiers:v1';
// ---------------------------------------------------------------------------
// The 3 new W5 recipe ids + canonical descriptor.name strings (sourced
// from recipes.ts lines 2921-3032). Pinned constants — must stay in sync
// with `descriptorForRecipe(id, name, ...)` in recipes.ts.
// ---------------------------------------------------------------------------
const NEW_RECIPE_IDS = [
'tpl-treasure-chest',
'tpl-cash-grab',
'tpl-summoning-ritual',
] as const;
type NewRecipeId = (typeof NEW_RECIPE_IDS)[number];
const RECIPE_NAMES: Record<NewRecipeId, string> = {
'tpl-treasure-chest': 'Treasure Chest',
'tpl-cash-grab': 'Cash Grab',
'tpl-summoning-ritual': 'Summoning Ritual',
};
// ---------------------------------------------------------------------------
// Inline copies of the 2 runtime-tested descriptors. Hard-coded so the
// spec doesn't need to import from chess source (the e2e runner doesn't
// bundle TS). Drift surfaces as a name-mismatch in load-and-validate.
//
// MUST stay in sync with `packages/chess/src/modifiers/custom/recipes.ts`:
// - tpl-cash-grab (lines 2966-2994)
// - tpl-summoning-ritual (lines 2995-3031)
// ---------------------------------------------------------------------------
const CASH_GRAB_DESCRIPTOR = {
type: 'data',
id: 'tpl-cash-grab',
name: 'Cash Grab',
description:
'At every turn end, both players gain +1 score. Simplified passive-income demo of on-turn-end → add-resource (the random-pick-and-compare canonical shape is blocked by the missing `eq` resolver).',
version: 1,
primitives: [
{
kind: 'on-turn-end',
params: {
color: 'both',
primitives: [
{
kind: 'add-resource',
params: { player: 'white', amount: 1 },
},
{
kind: 'add-resource',
params: { player: 'black', amount: 1 },
},
],
},
},
],
targetAttrs: [],
uiForm: 'primitive-composer',
source: 'custom',
} as const;
const SUMMONING_RITUAL_DESCRIPTOR = {
type: 'data',
id: 'tpl-summoning-ritual',
name: 'Summoning Ritual',
description:
'Pay 5 score (from WhiteScore) to summon a white knight at e4. Single-shot on rule activation: spend-resource(white, 5, then=[place-piece(knight, white, 28)]).',
version: 1,
primitives: [
{
kind: 'on-rule-activated',
params: {
primitives: [
{
kind: 'spend-resource',
params: {
player: 'white',
amount: 5,
then: [
{
kind: 'place-piece',
params: {
pieceType: 'knight',
color: 'white',
square: 28,
},
},
],
},
},
],
},
},
],
targetAttrs: [],
uiForm: 'primitive-composer',
source: 'custom',
} as const;
/**
* Mini-descriptor used to pre-seed `WhiteScore = 15` before applying
* `tpl-summoning-ritual`. A single top-level `add-resource` would
* normally fail the validator's `descriptor.primitives.imperative-in-passive`
* gate, but `__test__.apply-descriptor` bypasses validation (W1.11
* learnings § "Imperative-in-passive validator gate is bypassed on
* apply-descriptor"). The walker fires `add-resource` exactly once
* (no childPrimitives, no on-rule-activated double-fire path).
*
* 15 (rather than 10) is chosen because the summoning ritual's
* spend-resource fires TWICE through the walker-double-fire artifact
* (walker descent + fireOnRuleActivatedHooks), each spending 5. So
* 15 - 5 - 5 = 5 — the locked target value asserted in the test.
*/
const SEED_WHITE_SCORE_15_DESCRIPTOR = {
type: 'data',
id: 'test-seed-white-score-15',
name: 'Seed White Score 15',
description: 'Test fixture — pre-seeds WhiteScore=15 via top-level add-resource.',
version: 1,
primitives: [
{
kind: 'add-resource',
params: { player: 'white', amount: 15 },
},
],
targetAttrs: [],
uiForm: 'primitive-composer',
source: 'custom',
} as const;
// ---------------------------------------------------------------------------
// Server lifecycle (mirrors wave4-topology-pairing.spec.ts)
// ---------------------------------------------------------------------------
let wsServerProcess: ChildProcess | null = null;
async function isWsServerRunning(): Promise<boolean> {
try {
const res = await fetch('http://localhost:7357/healthz');
return res.ok;
} catch {
return false;
}
}
test.beforeAll(async () => {
if (await isWsServerRunning()) return;
wsServerProcess = spawn('bun', ['run', 'packages/server/src/index.ts'], {
stdio: 'pipe',
env: { ...process.env, PORT: '7357' },
});
for (let i = 0; i < 40; i++) {
await sleep(250);
if (await isWsServerRunning()) break;
}
});
test.afterAll(async () => {
if (wsServerProcess) {
wsServerProcess.kill('SIGINT');
await sleep(200);
wsServerProcess = null;
}
});
// ---------------------------------------------------------------------------
// LOAD-PATH helpers (lobby → profile editor → custom-modifier editor).
// Mirrors wave4-topology-pairing.spec.ts.
// ---------------------------------------------------------------------------
async function freshLobby(page: Page): Promise<void> {
await page.goto('/');
await page.evaluate(
({ profileKey, customKey }) => {
localStorage.removeItem(profileKey);
localStorage.removeItem(customKey);
sessionStorage.removeItem('room-code');
sessionStorage.removeItem('room-token');
sessionStorage.removeItem('player-color');
sessionStorage.removeItem('layout-name');
sessionStorage.removeItem('modifier-profile-name');
},
{ profileKey: PROFILE_LIBRARY_KEY, customKey: CUSTOM_LIBRARY_KEY },
);
await page.reload();
}
async function openProfileEditor(page: Page): Promise<void> {
const picker = page.getByTestId('profile-picker');
await expect(picker).toBeVisible();
await picker.selectOption('custom');
await expect(
page
.getByTestId('per-type-panel-paste')
.or(page.locator('[role="dialog"], .fixed.inset-0').first()),
).toBeVisible({ timeout: 3000 });
}
async function openCustomModifierEditor(page: Page): Promise<void> {
await page.getByTestId('open-custom-modifier-editor').click();
await expect(page.getByTestId('custom-modifier-editor')).toBeVisible({
timeout: 3000,
});
}
// ---------------------------------------------------------------------------
// RUNTIME-PATH helpers (raw WS room creation + apply-descriptor + sendMove).
// Mirrors wave4-topology-pairing.spec.ts + parity-rules.spec.ts.
// ---------------------------------------------------------------------------
async function wsCreateRoom(
page: Page,
): Promise<{ code: string; token: string; color: string }> {
return page.evaluate(async () => {
return new Promise<{ code: string; token: string; color: string }>(
(resolve, reject) => {
const ws = new WebSocket('ws://localhost:7357/ws');
const timer = setTimeout(
() => reject(new Error('wsCreateRoom: timeout')),
5000,
);
ws.onopen = () => {
ws.send(
JSON.stringify({
v: 1,
seq: 1,
ts: Date.now(),
type: 'room.create',
payload: {},
}),
);
};
ws.onmessage = (e: MessageEvent) => {
const msg = JSON.parse(e.data as string) as {
type: string;
payload: {
code: string;
token: string;
color: string;
message?: string;
};
};
if (msg.type === 'room.created') {
clearTimeout(timer);
ws.close();
resolve(msg.payload);
} else if (msg.type === 'error') {
clearTimeout(timer);
ws.close();
reject(new Error(msg.payload.message ?? 'room.create error'));
}
};
ws.onerror = () => {
clearTimeout(timer);
reject(new Error('wsCreateRoom: WebSocket error'));
};
},
);
});
}
async function joinAsHost(
page: Page,
): Promise<{ code: string; token: string; color: string }> {
await page.goto('http://localhost:5173/');
await page.waitForSelector('[data-testid="page-home"]');
const room = await wsCreateRoom(page);
await page.evaluate((r) => {
sessionStorage.setItem('room-code', r.code);
sessionStorage.setItem('room-token', r.token);
sessionStorage.setItem('player-color', r.color);
}, room);
await page.goto('http://localhost:5173/game');
await expect(page.locator('[data-testid="turn-indicator"]')).toBeVisible();
await page.waitForFunction(
() =>
Boolean(
(globalThis as { __paratypeChessClient?: unknown })
.__paratypeChessClient,
) &&
Boolean(
(globalThis as { __paratypeChessPrediction?: unknown })
.__paratypeChessPrediction,
),
null,
{ timeout: 5000 },
);
return room;
}
/**
* Drive `__test__.apply-descriptor` through the page's existing GameClient
* socket. Mirror of parity-rules.spec.ts § applyDescriptor.
*/
async function applyDescriptor(
page: Page,
args: { code: string; descriptor: unknown; targetSquare?: number },
): Promise<void> {
await page.evaluate((a) => {
const client = (
globalThis as {
__paratypeChessClient?: {
send: (msg: { type: string; payload: unknown }) => void;
};
}
).__paratypeChessClient;
if (!client)
throw new Error('applyDescriptor: __paratypeChessClient not present');
client.send({
type: '__test__.apply-descriptor',
payload: {
roomCode: a.code,
descriptor: a.descriptor,
targetSquare: a.targetSquare,
},
});
}, args);
}
/**
* Read a session attr via the page's PredictionManager.
* GAME_ENTITY = 0 (per `schema.ts` § "GAME_ENTITY: EntityId = 0").
*/
async function readGameAttr(
page: Page,
attr: string,
entityId: number = 0,
): Promise<unknown> {
return page.evaluate(
(a) => {
const mgr = (
globalThis as {
__paratypeChessPrediction?: {
getCurrentEngine: () => {
session: {
get: (id: unknown, attr: string) => unknown;
};
};
};
}
).__paratypeChessPrediction;
if (!mgr) throw new Error('readGameAttr: PredictionManager not exposed');
const engine = mgr.getCurrentEngine();
return engine.session.get(a.entityId, a.attr);
},
{ attr, entityId },
);
}
/**
* Send `game.move` through the page's connected GameClient.
* Cribbed from parity-rules.spec.ts § sendMove.
*/
async function sendMove(page: Page, from: string, to: string): Promise<void> {
await page.evaluate(
async (a) => {
type Client = {
send: (msg: { type: string; payload: unknown }) => void;
sendMove?: (from: string, to: string) => void;
readonly isConnected?: boolean;
};
const getClient = (): Client | undefined =>
(globalThis as { __paratypeChessClient?: Client })
.__paratypeChessClient;
const deadline = Date.now() + 3000;
let client = getClient();
while (Date.now() < deadline) {
client = getClient();
if (client && client.isConnected === true) break;
await new Promise((r) => setTimeout(r, 50));
}
if (!client || client.isConnected !== true) {
throw new Error('sendMove: GameClient never became connected');
}
if (typeof client.sendMove === 'function') {
client.sendMove(a.from, a.to);
return;
}
client.send({
type: 'game.move',
payload: { from: a.from, to: a.to },
});
},
{ from, to },
);
}
/**
* Open a second context as the black guest in the host's room. Returns
* the guest's page handle. Used by the `tpl-cash-grab` runtime test —
* the engine enforces turn alternation, so we need a real black peer
* to drive the second ply that fires the second turn-end.
*/
async function joinAsGuest(
browser: Browser,
roomCode: string,
): Promise<{ page: Page; close: () => Promise<void> }> {
const ctxB = await browser.newContext();
const pageB = await ctxB.newPage();
await pageB.goto('http://localhost:5173/');
await pageB.evaluate((c: string) => {
const ws = new WebSocket('ws://localhost:7357/ws');
return new Promise<void>((resolve, reject) => {
const t = setTimeout(() => reject(new Error('join timeout')), 5000);
ws.onopen = () =>
ws.send(
JSON.stringify({
v: 1,
seq: 1,
ts: Date.now(),
type: 'room.join',
payload: { code: c },
}),
);
ws.onmessage = (e: MessageEvent) => {
const msg = JSON.parse(e.data as string) as {
type: string;
payload: { code: string; token: string; color: string };
};
if (msg.type === 'room.joined') {
clearTimeout(t);
sessionStorage.setItem('room-code', msg.payload.code);
sessionStorage.setItem('room-token', msg.payload.token);
sessionStorage.setItem('player-color', msg.payload.color);
ws.close();
resolve();
} else if (msg.type === 'error') {
clearTimeout(t);
ws.close();
reject(new Error('join error'));
}
};
ws.onerror = () => {
clearTimeout(t);
reject(new Error('ws error'));
};
});
}, roomCode);
await pageB.goto('http://localhost:5173/game');
await expect(pageB.locator('[data-testid="my-color"]')).toContainText(
'black',
);
await pageB.waitForFunction(
() =>
Boolean(
(globalThis as { __paratypeChessClient?: unknown })
.__paratypeChessClient,
),
null,
{ timeout: 5000 },
);
return {
page: pageB,
close: async () => {
await ctxB.close();
},
};
}
// ---------------------------------------------------------------------------
// Test suite — 3 load-and-validate + 2 runtime
// ---------------------------------------------------------------------------
test.describe('W5.8 — Wave-5 thressgame-100 economy recipes (3 load + 2 runtime)', () => {
// ── 3 LOAD-AND-VALIDATE tests ────────────────────────────────────────
for (const id of NEW_RECIPE_IDS) {
test(`loads ${id} into the editor without error`, async ({ page }) => {
const pageErrors: Error[] = [];
page.on('pageerror', (err) => pageErrors.push(err));
await freshLobby(page);
await openProfileEditor(page);
await openCustomModifierEditor(page);
// Open the templates modal.
await page.getByTestId('custom-templates').click();
await expect(page.getByTestId('custom-templates-modal')).toBeVisible();
// Click the recipe's row.
await page.getByTestId(`custom-template-${id}`).click();
// Modal closes after pick.
await expect(page.getByTestId('custom-templates-modal')).toHaveCount(0);
// The descriptor name field reflects the recipe's `descriptor.name`.
await expect(
page.locator('input[placeholder="Modifier Name"]'),
).toHaveValue(RECIPE_NAMES[id]);
// Footer reports the descriptor as VALID.
await expect(page.getByText('Valid Custom Descriptor')).toBeVisible();
// Page-side runtime check.
expect(pageErrors).toEqual([]);
});
}
// ── RUNTIME 1 (Batch M-A) — tpl-summoning-ritual (success-path full runtime) ──
//
// Pre-seed WhiteScore=15 via mini-descriptor (top-level add-resource;
// apply-descriptor bypasses validator). The walker fires it once →
// WhiteScore=15.
//
// Then apply tpl-summoning-ritual. The walker recurses into
// on-rule-activated.childPrimitives() and reaches spend-resource
// (selfRecurse=true → walker calls apply ONCE and stops).
// fireOnRuleActivatedHooks then fires the arm AGAIN (the documented
// W1.11 walker-double-fire artifact for trigger primitives).
//
// Net: spend-resource fires twice, each spending 5 → WhiteScore =
// 15 - 5 - 5 = 5. place-piece(knight, white, 28) also fires twice
// but place-piece writes Position to a fresh entity each call and
// the renderer dedupes by square — DOM shows ONE white knight at e4.
//
// Assertions: engine WhiteScore === 5; white knight rendered at e4;
// score chip visible with text containing "5".
test('tpl-summoning-ritual: pre-seed 15 → spend twice → WhiteScore=5, knight at e4, chip shows 5', async ({
browser,
}) => {
const ctx = await browser.newContext();
const page = await ctx.newPage();
const pageErrors: Error[] = [];
page.on('pageerror', (err) => pageErrors.push(err));
const room = await joinAsHost(page);
expect(room.color).toBe('white');
// Pre-state: e4 empty, scores zero, no economy chip rendered.
await expect(page.locator('[data-square="e4"] [data-piece]')).toHaveCount(
0,
);
expect(await readGameAttr(page, 'WhiteScore', 0)).toBe(0);
await expect(page.getByTestId('score-white')).toHaveCount(0);
// Pre-seed WhiteScore=15.
await applyDescriptor(page, {
code: room.code,
descriptor: SEED_WHITE_SCORE_15_DESCRIPTOR,
});
await expect
.poll(async () => readGameAttr(page, 'WhiteScore', 0), {
timeout: 3000,
})
.toBe(15);
// Now apply the real recipe.
await applyDescriptor(page, {
code: room.code,
descriptor: SUMMONING_RITUAL_DESCRIPTOR,
});
// Post-apply: spend-resource ran twice (walker double-fire),
// each spending 5 → WhiteScore = 15 - 5 - 5 = 5.
await expect
.poll(async () => readGameAttr(page, 'WhiteScore', 0), {
timeout: 5000,
})
.toBe(5);
// White knight rendered at e4 (DOM dedupes the double-spawn).
await expect(
page.locator('[data-square="e4"] [data-piece="white-knight"]'),
).toHaveCount(1, { timeout: 5000 });
// Score chip visible with text containing "5". The chip renders
// as `⚪ 5` — toContainText absorbs the emoji + whitespace.
const chip = page.getByTestId('score-white');
await expect(chip).toBeVisible();
await expect(chip).toContainText('5');
expect(pageErrors).toEqual([]);
await ctx.close();
});
// ── RUNTIME 2 (Batch M-B) — tpl-cash-grab (turn-end driven full runtime) ──
//
// Activate the recipe. The activation arm is on-turn-end(both) →
// add-resource(white,1) + add-resource(black,1). The walker recurses
// into on-turn-end's children (no selfRecurse) and fires both
// add-resource primitives once at apply-time → post-apply scores
// are white=1, black=1.
//
// Drive 2 plies (white plays, then black plays). Each ply ends a
// turn → fires OnTurnEndHooks → +1 to each player. Final scores:
// white=3, black=3.
//
// Assertions: score chips visible with non-zero text values BOTH
// post-apply (1/1) AND post-2-plies (3/3).
test('tpl-cash-grab: activation seeds OnTurnEndHooks; 2 plies bump scores via on-turn-end', async ({
browser,
}) => {
const ctx = await browser.newContext();
const page = await ctx.newPage();
const pageErrors: Error[] = [];
page.on('pageerror', (err) => pageErrors.push(err));
const room = await joinAsHost(page);
expect(room.color).toBe('white');
// Open black guest so the engine accepts a 2nd ply.
const guest = await joinAsGuest(browser, room.code);
// Pre-state: scores zero, chips hidden.
expect(await readGameAttr(page, 'WhiteScore', 0)).toBe(0);
expect(await readGameAttr(page, 'BlackScore', 0)).toBe(0);
await expect(page.getByTestId('score-white')).toHaveCount(0);
await expect(page.getByTestId('score-black')).toHaveCount(0);
// Activate against the white king (e1, sq=4). `on-turn-end` is
// a per-PIECE trigger family — `fireOnTurnEndHooks` iterates
// pieces and reads `OnTurnEndHooks` from each piece's id.
// Seeding on GAME_ENTITY (the default apply-target when no
// targetSquare is supplied) would never fire. Same precedent
// as parity-rules.spec.ts § all_on_red, which targets sq=4 for
// the white-king-rooted on-turn-start descriptor.
await applyDescriptor(page, {
code: room.code,
descriptor: CASH_GRAB_DESCRIPTOR,
targetSquare: 4,
});
// Find the white king's piece-id so we can verify the hook
// landed on the right entity.
const kingIdAttr = await page
.locator('[data-square="e1"] [data-piece-id]')
.first()
.getAttribute('data-piece-id');
expect(kingIdAttr).not.toBeNull();
const kingId = Number(kingIdAttr);
// Post-apply: walker has fired the 2 add-resource leaves once
// each as it recursed into on-turn-end's children → 1/1.
await expect
.poll(async () => readGameAttr(page, 'WhiteScore', 0), {
timeout: 3000,
})
.toBe(1);
await expect
.poll(async () => readGameAttr(page, 'BlackScore', 0), {
timeout: 3000,
})
.toBe(1);
// OnTurnEndHooks must be seeded on the white king for the
// dispatcher to fire on subsequent turn-ends.
const hooks = await readGameAttr(page, 'OnTurnEndHooks', kingId);
expect(Array.isArray(hooks)).toBe(true);
expect((hooks as unknown[]).length).toBeGreaterThan(0);
// Score chips visible (both non-zero now).
const whiteChip = page.getByTestId('score-white');
const blackChip = page.getByTestId('score-black');
await expect(whiteChip).toBeVisible();
await expect(blackChip).toBeVisible();
await expect(whiteChip).toContainText('1');
await expect(blackChip).toContainText('1');
// Drive 2 plies. White moves a-pawn forward (white turn → black
// turn), then black moves a-pawn forward (black turn → white
// turn). Each move triggers a turn-end fire of the cash-grab arm.
await sendMove(page, 'a2', 'a3');
await page.waitForTimeout(150); // settle game.delta + dispatcher fire
await sendMove(guest.page, 'a7', 'a6');
await page.waitForTimeout(150);
// After 2 turn-ends, scores must have advanced from 1 to 3 each.
await expect
.poll(async () => readGameAttr(page, 'WhiteScore', 0), {
timeout: 5000,
})
.toBe(3);
await expect
.poll(async () => readGameAttr(page, 'BlackScore', 0), {
timeout: 5000,
})
.toBe(3);
// Chips reflect the new values.
await expect(whiteChip).toContainText('3');
await expect(blackChip).toContainText('3');
expect(pageErrors).toEqual([]);
await guest.close();
await ctx.close();
});
});

8
packages/chess/src/engine.ts
View file

@ -625,6 +625,14 @@ export class ChessEngine {
this.session.insert(GAME_ENTITY, "RngSeed", deriveSeedFromGameId(opts.gameId));
this.session.insert(GAME_ENTITY, "RngStream", 0);
// Wave-5 (thressgame-100, decision F) — initialise per-color
// resource counters on GAME_ENTITY. Seeding 0 explicitly (rather
// than letting the `add-resource` apply read-undefined-as-0)
// pins the score into the fact log from move 0 so the
// determinism-replay state hash includes them automatically.
this.session.insert(GAME_ENTITY, "WhiteScore", 0);
this.session.insert(GAME_ENTITY, "BlackScore", 0);
// T50 — seed the choice-timeout policy on GAME_ENTITY. Defaults to
// DEFAULT_CHOICE_TIMEOUT_POLICY when the caller omits the option so
// that even legacy `new ChessEngine()` callers (no opts bag) end up

13
packages/chess/src/modifiers/apply.ts
View file

@ -287,6 +287,19 @@ registerAttrConsumer("PieceLink");
// primitive; consumed by `fireOnPiecePairLinkBrokenHooks`
// (triggers.ts) at the destroy-piece pipeline boundary.
registerAttrConsumer("OnPiecePairLinkBrokenHooks");
// Wave-5 (thressgame-100, decision F) — per-color resource score
// counters on GAME_ENTITY. Seeded at engine construction (default
// 0) and mutated by `add-resource` / `spend-resource`. Consumed by
// `fireOnResourceChangedHooks` for threshold-crossing dispatch.
registerAttrConsumer("WhiteScore");
registerAttrConsumer("BlackScore");
// Wave-5 (thressgame-100, decision F) — `on-resource-changed`
// hook list. Seeded by the trigger primitive; consumed by
// `fireOnResourceChangedHooks` (triggers.ts), invoked
// SYNCHRONOUSLY from inside `add-resource` / `spend-resource`
// apply (not at a stage-13 batch boundary — the dispatch pattern
// matches author intent of "react immediately").
registerAttrConsumer("OnResourceChangedHooks");
/**
* Per-engine pre-move HP snapshot, used by the on-damaged trigger

128
packages/chess/src/modifiers/custom/recipes.ts
View file

@ -2901,4 +2901,132 @@ export const CUSTOM_MODIFIER_RECIPES: readonly CustomModifierRecipe[] = [
],
),
},
// ── W5.7 — Wave-5 economy template recipes ─────────────────────────
// Three recipes exercising the W5 economy primitives:
// - `add-resource(player, amount)` — synchronous score mutation
// - `spend-resource(player, amount, then, else)` — gated deduction
// - `on-resource-changed(player, threshold, direction, primitives)`
// (registered via inner arm; not directly demonstrated as
// top-level here — see economy-integration.test.ts for the
// primitive-level pin)
//
// Each ships with a co-located runtime test in
// `wave5-recipes-real.test.ts`. Pin invariants: economy recipes
// mutate `WhiteScore` / `BlackScore` on GAME_ENTITY; the marker-
// and capture-driven recipes additionally seed
// `OnPieceEnteredMarkerHooks` / `OnCaptureHooks` on their carrier.
//
// Batch M — economy (3 recipes)
{
id: "tpl-treasure-chest",
title: "Treasure Chest (capture spawns treasure; landing on it awards score)",
summary:
"Two-armed economy + marker recipe. Arm 1: `on-capture → spawn-marker({markerKind:\"treasure\", square: ctx-attr({entity:\"self\", attr:\"Position\"}), lifetime:{kind:\"permanent\"}})` — when this piece captures, the attacker's NEW Position (the just-vacated capture square) is read via `ctx-attr.entity:\"self\"` so the treasure drops where the captured piece died. Arm 2: `on-piece-entered-marker(treasure) → add-resource({player:\"white\", amount:5}) + destroy-marker({target: ctx-self-marker-id})` — landing on a treasure awards 5 score and consumes the marker. SIMPLIFICATION: Arm 2 hardcodes `player:\"white\"` because the chooser-color resolver shape (`ctx-attr({entity:\"chooser\", attr:\"Color\"})`) is registered at descriptor-apply time, not at marker-entry time, so its semantics inside `on-piece-entered-marker` are 'whoever applied THIS rule', not 'whoever stepped on the treasure'. Hardcoding white keeps the recipe player-agnostic at the runtime contract level — authors wanting per-player payouts install one descriptor per color.",
descriptor: descriptorForRecipe(
"tpl-treasure-chest",
"Treasure Chest",
"On capture, drops a treasure marker on the capture square; entering a treasure awards white +5 score and consumes the marker. Two-armed: on-capture spawns; on-piece-entered-marker pays out.",
[
{
kind: "on-capture",
params: {
primitives: [
{
kind: "spawn-marker",
params: {
markerKind: "treasure",
square: {
"ctx-attr": { entity: "self", attr: "Position" },
},
lifetime: { kind: "permanent" },
},
},
],
},
},
{
kind: "on-piece-entered-marker",
params: {
markerKind: "treasure",
primitives: [
{
kind: "add-resource",
params: { player: "white", amount: 5 },
},
{
kind: "destroy-marker",
params: { target: { "ctx-self-marker-id": null } },
},
],
},
},
],
),
},
{
id: "tpl-cash-grab",
title: "Cash Grab (passive income at every turn end)",
summary:
"SIMPLIFIED from the canonical 'random pick a square; if a piece is there, that piece's owner gets +1' shape. The `random-pick` primitive returns a numeric value, but `conditional` does NOT support arithmetic comparison on resolver-shape values (no `eq(a, b)` shape exists in the V3 resolver union — the union is arithmetic-only: add/sub/mul/mod). Without comparison, we cannot gate a per-piece add-resource on 'is THIS piece's Position equal to the picked square'. Ship the simplified pattern: `on-turn-end(both) → add-resource(white, 1) + add-resource(black, 1)`. Each turn end, both players gain 1 score — passive-income demonstration of `on-turn-end → add-resource`. The original cash-grab semantic (probabilistic per-square payout) needs a future `eq` resolver shape or a dedicated `random-pick-piece` primitive variant.",
descriptor: descriptorForRecipe(
"tpl-cash-grab",
"Cash Grab",
"At every turn end, both players gain +1 score. Simplified passive-income demo of on-turn-end → add-resource (the random-pick-and-compare canonical shape is blocked by the missing `eq` resolver).",
[
{
kind: "on-turn-end",
params: {
color: "both",
primitives: [
{
kind: "add-resource",
params: { player: "white", amount: 1 },
},
{
kind: "add-resource",
params: { player: "black", amount: 1 },
},
],
},
},
],
),
},
{
id: "tpl-summoning-ritual",
title: "Summoning Ritual (pay 5 score → summon a knight)",
summary:
"Single-shot ritual. `on-rule-activated → spend-resource({player:\"white\", amount:5, then:[place-piece({pieceType:\"knight\", color:\"white\", square:28})]})`. Fires once when the rule attaches: if WhiteScore >= 5, deducts 5 and spawns a white knight at e4 (square 28); otherwise no-op (no `else` arm provided). Direct port of the `spend-resource` then-arm pattern with `place-piece` as the success consequence — exercises the gating semantic AND the cross-primitive interaction (`spend-resource` runs `then` via its own `runPrimitives`, so `place-piece` inside `then` is correctly trigger-scoped). Pinned at activation time — the 'summoning' is a single fire, not a repeatable action; a repeatable summon would need `request-choice` + `on-rule-activated` looping (deferred to W6+).",
descriptor: descriptorForRecipe(
"tpl-summoning-ritual",
"Summoning Ritual",
"Pay 5 score (from WhiteScore) to summon a white knight at e4. Single-shot on rule activation: spend-resource(white, 5, then=[place-piece(knight, white, 28)]).",
[
{
kind: "on-rule-activated",
params: {
primitives: [
{
kind: "spend-resource",
params: {
player: "white",
amount: 5,
then: [
{
kind: "place-piece",
params: {
pieceType: "knight",
color: "white",
square: 28,
},
},
],
},
},
],
},
},
],
),
},
];

16
packages/chess/src/modifiers/custom/validate.ts
View file

@ -80,6 +80,14 @@ export const IMPERATIVE_KINDS: Set<string> = new Set<string>([
"set-board-topology",
"link-pieces",
"unlink-pieces",
// Wave-5 (thressgame-100, decision F) — economy primitives. Both
// mutate game-level state (`WhiteScore` / `BlackScore` on
// GAME_ENTITY) and so live ONLY inside trigger arms. `spend-resource`
// is also imperative because its `then` / `else` branches run
// imperative children — but the conditional gating itself is the
// mutation that classifies it (the score deduction).
"add-resource",
"spend-resource",
]);
/**
@ -389,7 +397,13 @@ function walkPrimitiveNodes(input: {
node.kind === "conditional" ||
node.kind.startsWith("on-") ||
node.kind.startsWith("for-each-") ||
node.kind === "random-pick";
node.kind === "random-pick" ||
// Wave-5 (decision F) — `spend-resource` has `then` / `else`
// arms that run imperative children; they must inherit
// trigger-scope so add-resource / spend-resource / move-piece
// etc. inside the arms validate. Mirrors `conditional`'s
// gating semantics.
node.kind === "spend-resource";
walkPrimitiveNodes({
nodes: children,

585
packages/chess/src/modifiers/custom/wave5-recipes-real.test.ts Normal file
View file

@ -0,0 +1,585 @@
/**
* W5.7 — End-to-end runtime tests for the 3 Wave-5 thressgame-100
* economy recipes added to `recipes.ts`.
*
* Each describe block pulls the recipe by id and exercises it
* through one of two patterns:
*
* 1. **Direct-arm runtime** — drive the inner arm of a top-level
* trigger node via `runPrimitives` (single-fire, clean state).
* Used because `applyCustomDescriptor` walks INTO trigger
* primitives' `childPrimitives()` at apply time (W1 walker-
* artifact pattern, documented in `wave1-recipes-real.test.ts`)
* — that's fine for HOOK-SEED smoke tests but it double-fires
* / pre-fires the inner imperatives, polluting the state we
* want to pin.
*
* 2. **Trigger dispatcher fire** — for tpl-cash-grab and the
* arms of tpl-treasure-chest, we seed the carrier-side hook
* directly by running the top-level trigger primitive against
* a hand-rolled context (singleton list, so the dispatcher
* doesn't auto-recurse into children), then drive
* `fireOnTurnEndHooks` / `fireOnPieceEnteredMarkerHooks` /
* `fireOnCaptureHooks`. That hits the EXACT same dispatcher
* path the integration preset's `onAfterMove` invokes in
* production.
*
* ## Why the smoke uses `applyCustomDescriptorTolerant`
*
* Two of the three W5 recipes legitimately throw inside the apply
* walker:
* - tpl-treasure-chest's `on-piece-entered-marker` arm references
* `ctx-self-marker-id`, which the resolver only honors inside an
* actual marker trigger (`param-resolver.ts:262-274`).
* - tpl-summoning-ritual's `spend-resource` runs `place-piece`
* eagerly during the walker pass; the OnRuleActivatedHooks fire
* LATER would re-fire it (the documented W1 walker-artifact
* double-fire on iteration arms — same situation as
* tpl-suicidal-knight). For SMOKE we only care that the hook
* seed lands, so we tolerate the throw and skip post-apply
* asserts on score / spawned pieces.
*
* The runtime tests above use direct dispatcher drives to bypass
* these walker artifacts and pin observable state cleanly.
*/
import { describe, it, expect } from "vitest";
import type { EntityId } from "@paratype/rete";
import { ChessEngine } from "../../engine.js";
import {
GAME_ENTITY,
type ChessAttrMap,
type Square,
} from "../../schema.js";
import { applyCustomDescriptor } from "./apply.js";
import { CUSTOM_MODIFIER_RECIPES } from "./recipes.js";
import type { CustomModifierRecipe } from "./recipes.js";
import type { CustomModifierDescriptor } from "./types.js";
import { clearBoard, placePiece } from "../../presets/test-utils.js";
import {
runPrimitives,
fireOnCaptureHooks,
fireOnTurnEndHooks,
fireOnPieceEnteredMarkerHooks,
} from "../triggers.js";
import type {
EffectPrimitiveNode,
PendingTrigger,
PrimitiveApplyContext,
} from "../primitives/types.js";
import { ON_CAPTURE_PRIMITIVE } from "../primitives/on-capture.js";
import { ON_TURN_END_PRIMITIVE } from "../primitives/on-turn-end.js";
import { ON_PIECE_ENTERED_MARKER_PRIMITIVE } from "../primitives/on-piece-entered-marker.js";
import "../primitives/index.js";
function recipeById(id: string): CustomModifierRecipe {
const r = CUSTOM_MODIFIER_RECIPES.find((x) => x.id === id);
if (r === undefined) throw new Error(`recipe ${id} not found`);
return r;
}
/**
* Extract the inner-arm primitive list from a NAMED top-level
* trigger node by `kind`.
*/
function innerArmFor(
descriptor: CustomModifierDescriptor,
kind: string,
): readonly EffectPrimitiveNode[] {
const top = descriptor.primitives.find((n) => n.kind === kind);
if (top === undefined) {
throw new Error(`descriptor has no top-level "${kind}" node`);
}
const params = top.params as { primitives?: readonly EffectPrimitiveNode[] };
if (params.primitives === undefined) {
throw new Error(`top-level "${kind}" node has no inner primitives arm`);
}
return params.primitives;
}
/**
* Build a hand-rolled `PrimitiveApplyContext` for direct primitive-
* apply invocations. Use this when we want to invoke a TRIGGER
* primitive's `apply()` (which seeds its hook list) WITHOUT the
* dispatcher's auto-recurse into the inner arm — both
* `runPrimitives` AND the apply walker auto-recurse for trigger
* primitives, which would pre-fire the inner imperatives at seed
* time.
*/
function makeCtx(
engine: ChessEngine,
pieceId: EntityId,
descriptorId: string,
): PrimitiveApplyContext {
const pendingTriggers: PendingTrigger[] = [];
return {
engine,
session: engine.session,
pieceId,
depth: 0,
descriptor: { id: descriptorId, type: "data", version: 1 },
target: "self",
event: undefined,
bindings: new Map(),
pendingTriggers,
cascadeDepth: 0,
suppressTriggers: false,
};
}
function driveArm(opts: {
engine: ChessEngine;
pieceId: EntityId;
primitives: readonly EffectPrimitiveNode[];
descriptorId: string;
}): void {
const { engine, pieceId, primitives, descriptorId } = opts;
runPrimitives(
engine,
pieceId,
primitives,
1,
undefined,
new Map(),
0,
false,
[],
descriptorId,
);
}
function readScore(
engine: ChessEngine,
side: "white" | "black",
): number {
const attr = side === "white" ? "WhiteScore" : "BlackScore";
const value = engine.session.get(GAME_ENTITY, attr) as number | undefined;
return value ?? 0;
}
/**
* Tolerant apply for SMOKE tests — mirrors the W1 pattern. Two W5
* recipes legitimately throw inside the apply walker (see top-of-
* file rationale). Hook seeds land BEFORE the walker recurses, so
* the throw doesn't undo the seed; we just need to swallow it.
*/
function applyCustomDescriptorTolerant(
engine: ChessEngine,
pieceId: EntityId,
descriptor: CustomModifierDescriptor,
): void {
try {
applyCustomDescriptor(engine, engine.session, pieceId, descriptor);
} catch (e) {
const msg = (e as Error).message;
if (
!msg.includes("ctx-self-marker-id") &&
!msg.includes("ctx-self-id")
) {
throw e;
}
}
}
// ---------------------------------------------------------------------------
// Batch M — economy (3 recipes)
// ---------------------------------------------------------------------------
describe("tpl-treasure-chest (W5 Batch M)", () => {
it("on-capture arm spawns a treasure marker on the attacker's Position when the capture hook fires", () => {
const recipe = recipeById("tpl-treasure-chest");
const engine = new ChessEngine();
clearBoard(engine);
// White rook on e4 (square 28). In production, on-capture fires
// AFTER the attacker has moved onto the captured piece's square,
// so ctx-attr({entity:"self", attr:"Position"}) reads e4.
const attacker = placePiece(engine, "rook", "white", "e4");
// Seed the on-capture hook on the attacker by invoking the
// trigger primitive's `apply()` DIRECTLY — bypasses both the
// apply-walker AND `runPrimitives`' auto-recursion into the
// inner spawn-marker (which would otherwise pre-fire at seed
// time, polluting our pre-fire sanity check).
const onCaptureNode = recipe.descriptor.primitives.find(
(n) => n.kind === "on-capture",
);
if (onCaptureNode === undefined) throw new Error("missing on-capture arm");
const onCaptureCtx = makeCtx(
engine,
attacker,
String(recipe.descriptor.id),
);
ON_CAPTURE_PRIMITIVE.apply(
onCaptureCtx,
onCaptureNode.params as { primitives: EffectPrimitiveNode[] },
);
// Sanity: pre-fire there are no treasure markers on e4.
const treasureSquare = 28 as Square;
expect(engine.getMarkersAtSquare(treasureSquare)).toHaveLength(0);
// Fire the capture trigger — this drives the spawn-marker arm
// with ctx.pieceId = attacker, so ctx-attr({entity:"self"}) reads
// the attacker's Position (e4).
fireOnCaptureHooks(engine, attacker);
// Assert: a treasure marker now sits on e4.
const markers = engine.getMarkersAtSquare(treasureSquare);
expect(markers.length).toBeGreaterThanOrEqual(1);
const treasureKinds = markers.map((id) =>
engine.session.get(id, "MarkerKind"),
);
expect(treasureKinds).toContain("treasure");
});
it("on-piece-entered-marker arm awards white +5 score and destroys the treasure when a piece enters it", () => {
const recipe = recipeById("tpl-treasure-chest");
const engine = new ChessEngine();
clearBoard(engine);
const carrier = placePiece(engine, "rook", "white", "a1");
// Seed the on-piece-entered-marker hook on GAME_ENTITY by
// invoking the trigger primitive's `apply()` directly — bypasses
// walker recursion into ctx-self-marker-id (which legitimately
// throws outside a marker trigger context).
const enteredNode = recipe.descriptor.primitives.find(
(n) => n.kind === "on-piece-entered-marker",
);
if (enteredNode === undefined) throw new Error("missing entered arm");
const enteredCtx = makeCtx(
engine,
carrier,
String(recipe.descriptor.id),
);
ON_PIECE_ENTERED_MARKER_PRIMITIVE.apply(
enteredCtx,
enteredNode.params as {
markerKind: "treasure";
primitives: EffectPrimitiveNode[];
},
);
// Spawn a treasure marker on e4 (square 28) and place a pawn
// on top of it.
engine.spawnMarker("treasure", 28, { lifetime: { kind: "permanent" } });
const walker = placePiece(engine, "pawn", "white", "e4");
expect(readScore(engine, "white")).toBe(0);
expect(
engine.getMarkersAtSquare(28 as Square).length,
).toBeGreaterThanOrEqual(1);
// Fire the marker-entry dispatcher with the walker's id — this
// matches the post-move dispatch pattern (the walker has
// Position = 28).
fireOnPieceEnteredMarkerHooks(engine, [walker]);
// White earned 5 score; the treasure was consumed.
expect(readScore(engine, "white")).toBe(5);
const remainingTreasures = engine
.getMarkersAtSquare(28 as Square)
.filter((id) => engine.session.get(id, "MarkerKind") === "treasure");
expect(remainingTreasures).toHaveLength(0);
});
it("descriptor shape: 2 arms (on-capture spawn-marker + on-piece-entered-marker add-resource + destroy-marker)", () => {
const recipe = recipeById("tpl-treasure-chest");
expect(recipe.descriptor.primitives).toHaveLength(2);
const kinds = recipe.descriptor.primitives.map((n) => n.kind);
expect(kinds).toContain("on-capture");
expect(kinds).toContain("on-piece-entered-marker");
const captureArm = innerArmFor(recipe.descriptor, "on-capture");
expect(captureArm[0]?.kind).toBe("spawn-marker");
const sm = captureArm[0]?.params as {
markerKind: string;
square: unknown;
lifetime: { kind: string };
};
expect(sm.markerKind).toBe("treasure");
expect(sm.lifetime.kind).toBe("permanent");
// Square is a ctx-attr resolver shape — pinning verifies the
// recipe ships the V3 nested-resolver form.
expect(sm.square).toEqual({
"ctx-attr": { entity: "self", attr: "Position" },
});
const enteredArm = innerArmFor(
recipe.descriptor,
"on-piece-entered-marker",
);
expect(enteredArm[0]?.kind).toBe("add-resource");
const ar = enteredArm[0]?.params as { player: string; amount: number };
expect(ar.player).toBe("white");
expect(ar.amount).toBe(5);
expect(enteredArm[1]?.kind).toBe("destroy-marker");
const dm = enteredArm[1]?.params as { target: unknown };
expect(dm.target).toEqual({ "ctx-self-marker-id": null });
});
});
describe("tpl-cash-grab (W5 Batch M)", () => {
it("on-turn-end fires add-resource(white +1) + add-resource(black +1) for both colors", () => {
const recipe = recipeById("tpl-cash-grab");
const engine = new ChessEngine();
clearBoard(engine);
const carrier = placePiece(engine, "rook", "white", "a1");
// Seed OnTurnEndHooks on the carrier with color="both" by
// invoking the trigger primitive's `apply()` directly — bypasses
// the dispatcher's child-recursion (which would pre-fire
// add-resource at seed time, polluting the readScore baseline).
const turnEndNode = recipe.descriptor.primitives.find(
(n) => n.kind === "on-turn-end",
);
if (turnEndNode === undefined) throw new Error("missing on-turn-end");
const turnEndCtx = makeCtx(
engine,
carrier,
String(recipe.descriptor.id),
);
ON_TURN_END_PRIMITIVE.apply(
turnEndCtx,
turnEndNode.params as {
color: "both";
primitives: EffectPrimitiveNode[];
},
);
expect(readScore(engine, "white")).toBe(0);
expect(readScore(engine, "black")).toBe(0);
// Simulate one white turn ending — color="both" matches.
fireOnTurnEndHooks(engine, "white");
expect(readScore(engine, "white")).toBe(1);
expect(readScore(engine, "black")).toBe(1);
// Simulate one black turn ending — color="both" still matches.
fireOnTurnEndHooks(engine, "black");
expect(readScore(engine, "white")).toBe(2);
expect(readScore(engine, "black")).toBe(2);
});
it("descriptor shape: on-turn-end(both) → add-resource(white) + add-resource(black)", () => {
const recipe = recipeById("tpl-cash-grab");
expect(recipe.descriptor.primitives).toHaveLength(1);
const top = recipe.descriptor.primitives[0];
expect(top?.kind).toBe("on-turn-end");
const turnEndParams = top?.params as {
color: string;
primitives: readonly EffectPrimitiveNode[];
};
expect(turnEndParams.color).toBe("both");
expect(turnEndParams.primitives).toHaveLength(2);
expect(turnEndParams.primitives[0]?.kind).toBe("add-resource");
expect(turnEndParams.primitives[1]?.kind).toBe("add-resource");
const ar0 = turnEndParams.primitives[0]?.params as {
player: string;
amount: number;
};
const ar1 = turnEndParams.primitives[1]?.params as {
player: string;
amount: number;
};
expect(ar0).toEqual({ player: "white", amount: 1 });
expect(ar1).toEqual({ player: "black", amount: 1 });
});
});
describe("tpl-summoning-ritual (W5 Batch M)", () => {
it("when WhiteScore >= 5: deducts 5 and spawns a white knight at e4", () => {
const recipe = recipeById("tpl-summoning-ritual");
const engine = new ChessEngine();
clearBoard(engine);
const carrier = placePiece(engine, "rook", "white", "a1");
// Pre-seed white with 10 score so the spend succeeds.
engine.session.insert(GAME_ENTITY, "WhiteScore", 10);
// Drive the activation arm directly — spend-resource(5,
// then=[place-piece(knight, white, 28)]).
driveArm({
engine,
pieceId: carrier,
primitives: innerArmFor(recipe.descriptor, "on-rule-activated"),
descriptorId: String(recipe.descriptor.id),
});
// White paid 5; new score = 5.
expect(readScore(engine, "white")).toBe(5);
// A white knight now exists on e4 (square 28).
let foundKnight = false;
for (let i = 0; i < 200; i++) {
const id = i as EntityId;
const ptype = engine.session.get(id, "PieceType");
const color = engine.session.get(id, "Color");
const pos = engine.session.get(id, "Position");
if (ptype === "knight" && color === "white" && pos === 28) {
foundKnight = true;
break;
}
}
expect(foundKnight).toBe(true);
});
it("when WhiteScore < 5: spend fails silently — score unchanged, no knight spawned", () => {
const recipe = recipeById("tpl-summoning-ritual");
const engine = new ChessEngine();
clearBoard(engine);
const carrier = placePiece(engine, "rook", "white", "a1");
// Pre-seed white with only 2 score (< 5 cost).
engine.session.insert(GAME_ENTITY, "WhiteScore", 2);
driveArm({
engine,
pieceId: carrier,
primitives: innerArmFor(recipe.descriptor, "on-rule-activated"),
descriptorId: String(recipe.descriptor.id),
});
// Score unchanged (no `else` arm provided).
expect(readScore(engine, "white")).toBe(2);
// No white knight at e4.
let foundKnight = false;
for (let i = 0; i < 200; i++) {
const id = i as EntityId;
const ptype = engine.session.get(id, "PieceType");
const color = engine.session.get(id, "Color");
const pos = engine.session.get(id, "Position");
if (ptype === "knight" && color === "white" && pos === 28) {
foundKnight = true;
break;
}
}
expect(foundKnight).toBe(false);
});
it("descriptor shape: on-rule-activated → spend-resource(white, 5, then=[place-piece(knight, white, 28)])", () => {
const recipe = recipeById("tpl-summoning-ritual");
expect(recipe.descriptor.primitives).toHaveLength(1);
const activate = innerArmFor(recipe.descriptor, "on-rule-activated");
expect(activate[0]?.kind).toBe("spend-resource");
const sr = activate[0]?.params as {
player: string;
amount: number;
then: readonly EffectPrimitiveNode[];
else?: readonly EffectPrimitiveNode[];
};
expect(sr.player).toBe("white");
expect(sr.amount).toBe(5);
expect(sr.then).toHaveLength(1);
expect(sr.then[0]?.kind).toBe("place-piece");
const pp = sr.then[0]?.params as {
pieceType: string;
color: string;
square: number;
};
expect(pp.pieceType).toBe("knight");
expect(pp.color).toBe("white");
expect(pp.square).toBe(28);
// No `else` arm — single-shot ritual, silent failure.
expect(sr.else).toBeUndefined();
});
});
// ---------------------------------------------------------------------------
// Cross-cutting smoke: every Wave-5 recipe descriptor seeds its
// expected hook(s) via applyCustomDescriptor (the production path).
// Two of the three legitimately throw in the apply walker — see
// top-of-file rationale; we use the W1 tolerant pattern.
// ---------------------------------------------------------------------------
describe("Wave-5 recipes — applyCustomDescriptor smoke", () => {
const W5_IDS = [
"tpl-treasure-chest",
"tpl-cash-grab",
"tpl-summoning-ritual",
] as const;
it("all 3 W5 recipe ids are present in CUSTOM_MODIFIER_RECIPES", () => {
for (const id of W5_IDS) {
expect(CUSTOM_MODIFIER_RECIPES.find((r) => r.id === id)).toBeDefined();
}
});
it("recipe count is at least 62 (54 W1+W2+W3 + 5 W4 + 3 W5)", () => {
expect(CUSTOM_MODIFIER_RECIPES.length).toBeGreaterThanOrEqual(62);
});
it("tpl-treasure-chest seeds OnPieceEnteredMarkerHooks via applyCustomDescriptorTolerant", () => {
const recipe = recipeById("tpl-treasure-chest");
const engine = new ChessEngine();
clearBoard(engine);
const carrier = placePiece(engine, "queen", "white", "d1");
applyCustomDescriptorTolerant(engine, carrier, recipe.descriptor);
const hooks = engine.session.get(
GAME_ENTITY,
"OnPieceEnteredMarkerHooks",
) as ChessAttrMap["OnPieceEnteredMarkerHooks"] | undefined;
expect(hooks).toBeDefined();
expect(
(hooks ?? []).some((h) => h.descriptorId === recipe.descriptor.id),
).toBe(true);
});
it("tpl-treasure-chest seeds OnCaptureHooks on the carrier via applyCustomDescriptorTolerant", () => {
const recipe = recipeById("tpl-treasure-chest");
const engine = new ChessEngine();
clearBoard(engine);
const carrier = placePiece(engine, "queen", "white", "d1");
applyCustomDescriptorTolerant(engine, carrier, recipe.descriptor);
const hooks = engine.session.get(carrier, "OnCaptureHooks") as
| ChessAttrMap["OnCaptureHooks"]
| undefined;
expect(hooks).toBeDefined();
expect(
(hooks ?? []).some((h) => h.descriptorId === recipe.descriptor.id),
).toBe(true);
});
it("tpl-cash-grab seeds OnTurnEndHooks(color=both) on the carrier via applyCustomDescriptor", () => {
// No walker artifact for cash-grab (add-resource never throws),
// but the walker DOES pre-fire the inner add-resource calls. We
// tolerate the score side-effect and only assert hook presence.
const recipe = recipeById("tpl-cash-grab");
const engine = new ChessEngine();
clearBoard(engine);
const carrier = placePiece(engine, "queen", "white", "d1");
applyCustomDescriptor(engine, engine.session, carrier, recipe.descriptor);
const hooks = engine.session.get(carrier, "OnTurnEndHooks") as
| ChessAttrMap["OnTurnEndHooks"]
| undefined;
expect(hooks).toBeDefined();
const entry = (hooks ?? []).find(
(h) => h.descriptorId === recipe.descriptor.id,
);
expect(entry).toBeDefined();
expect(entry?.color).toBe("both");
});
it("tpl-summoning-ritual seeds OnRuleActivatedHooks via applyCustomDescriptorTolerant", () => {
// Walker artifact: spend-resource fires inside the walker (its
// selfRecurse=true gates child-recursion but the walker still
// calls spend-resource.apply() once during the initial
// walkAndApply pass). Then fireOnRuleActivatedHooks at the end
// of applyCustomDescriptor fires it AGAIN — same double-fire as
// tpl-suicidal-knight (W1 documented). Pre-seed enough score
// so neither fire throws, and we only assert hook presence.
const recipe = recipeById("tpl-summoning-ritual");
const engine = new ChessEngine();
clearBoard(engine);
engine.session.insert(GAME_ENTITY, "WhiteScore", 100);
const carrier = placePiece(engine, "queen", "white", "d1");
applyCustomDescriptorTolerant(engine, carrier, recipe.descriptor);
const hooks = engine.session.get(
GAME_ENTITY,
"OnRuleActivatedHooks",
) as ChessAttrMap["OnRuleActivatedHooks"] | undefined;
expect(hooks).toBeDefined();
expect(
(hooks ?? []).some((h) => h.descriptorId === recipe.descriptor.id),
).toBe(true);
});
});

333
packages/chess/src/modifiers/primitives/__tests__/economy-integration.test.ts Normal file
View file

@ -0,0 +1,333 @@
/**
* Wave-5 (thressgame-100, decision F) — economy / resource
* accumulation subsystem integration tests.
*
* Exercises end-to-end:
*
* 1. add-resource(white, 5) increases WhiteScore by 5.
* 2. add-resource(black, -3) decreases BlackScore by 3
* (negative-add semantics).
* 3. spend-resource success — score >= amount, deducts and runs
* the `then` arm.
* 4. spend-resource failure — score < amount, runs `else` arm
* (or no-op if absent).
* 5. on-resource-changed(white, 10, "up") fires on up-crossing.
* 6. on-resource-changed direction filtering — does NOT fire on
* down-crossing when direction="up".
* 7. Multiple thresholds — distinct hooks for distinct crossings,
* both fire when a single mutation crosses both.
* 8. Replay determinism — N=100 game replays with adds/spends
* produce byte-identical state hashes.
*
* The harness uses the integration preset (via NOOP_PROFILE) so the
* full apply.ts dispatcher is wired. Score mutations fire the
* synchronous fireOnResourceChangedHooks dispatcher INSIDE
* add-resource / spend-resource apply — distinct from W2's stage-13
* batched dispatch. Each mutation mutates GAME_ENTITY's WhiteScore /
* BlackScore facts, which participate in the determinism state hash
* automatically.
*/
import { describe, expect, it } from "vitest";
import { ChessEngine } from "../../../engine.js";
import {
GAME_ENTITY,
type OnResourceChangedHookEntry,
} from "../../../schema.js";
import { ADD_RESOURCE_PRIMITIVE } from "../add-resource.js";
import { SPEND_RESOURCE_PRIMITIVE } from "../spend-resource.js";
import { ON_RESOURCE_CHANGED_PRIMITIVE } from "../on-resource-changed.js";
import type { ModifierProfile } from "../../types.js";
import { runDeterminismCheck } from "../../../__fixtures__/determinism/harness.js";
import "../index.js";
import type { PrimitiveApplyContext } from "../types.js";
const NOOP_PROFILE: ModifierProfile = {
id: "wave-5-economy-test",
name: "wave-5-economy-test",
description: "",
perType: [],
perInstance: [],
version: 1,
source: "custom",
};
function makeEngine(): ChessEngine {
return new ChessEngine({ profile: NOOP_PROFILE });
}
function makeContext(engine: ChessEngine): PrimitiveApplyContext {
return {
engine,
session: engine.session,
pieceId: GAME_ENTITY,
depth: 0,
descriptor: {
id: "custom:test-economy-integration",
type: "data",
version: 1,
},
target: "self",
event: undefined,
bindings: new Map(),
pendingTriggers: [],
cascadeDepth: 0,
suppressTriggers: false,
};
}
describe("Wave-5 economy integration — add-resource", () => {
it("(1) add-resource(white, 5) increases WhiteScore by 5", () => {
const engine = makeEngine();
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(0);
ADD_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: 5,
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(5);
expect(engine.session.get(GAME_ENTITY, "BlackScore")).toBe(0);
});
it("(2) add-resource(black, -3) decreases BlackScore by 3", () => {
const engine = makeEngine();
ADD_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "black",
amount: -3,
});
expect(engine.session.get(GAME_ENTITY, "BlackScore")).toBe(-3);
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(0);
});
});
describe("Wave-5 economy integration — spend-resource", () => {
it("(3) spend-resource success: score >= amount, deducts and runs then arm", () => {
const engine = makeEngine();
engine.session.insert(GAME_ENTITY, "WhiteScore", 10);
SPEND_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: 5,
then: [
// Sentinel: HpBonus on GAME_ENTITY proves `then` ran.
{
kind: "seed-attribute",
params: { attr: "HpBonus", value: 999 },
},
],
else: [
{
kind: "seed-attribute",
params: { attr: "RangeBonus", value: 999 },
},
],
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(5);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(999);
expect(engine.session.get(GAME_ENTITY, "RangeBonus")).toBeUndefined();
});
it("(4) spend-resource failure: score < amount, runs else arm and leaves score", () => {
const engine = makeEngine();
engine.session.insert(GAME_ENTITY, "WhiteScore", 3);
SPEND_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: 5,
then: [
{ kind: "seed-attribute", params: { attr: "HpBonus", value: 1 } },
],
else: [
{ kind: "seed-attribute", params: { attr: "RangeBonus", value: 7 } },
],
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(3);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
expect(engine.session.get(GAME_ENTITY, "RangeBonus")).toBe(7);
});
});
describe("Wave-5 economy integration — on-resource-changed crossings", () => {
it("(5) on-resource-changed(white, 10, up) fires on 9→10 crossing", () => {
const engine = makeEngine();
ON_RESOURCE_CHANGED_PRIMITIVE.apply(makeContext(engine), {
player: "white",
threshold: 10,
direction: "up",
primitives: [
{ kind: "seed-attribute", params: { attr: "HpBonus", value: 42 } },
],
});
// Prime score to 9 — does not cross yet.
ADD_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: 9,
});
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
// Add 1 more — crosses.
ADD_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: 1,
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(10);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(42);
});
it("(6) on-resource-changed direction=up does NOT fire on down-crossing", () => {
const engine = makeEngine();
engine.session.insert(GAME_ENTITY, "WhiteScore", 12);
ON_RESOURCE_CHANGED_PRIMITIVE.apply(makeContext(engine), {
player: "white",
threshold: 10,
direction: "up",
primitives: [
{ kind: "seed-attribute", params: { attr: "HpBonus", value: 1 } },
],
});
// Drop from 12 to 8 — crosses 10 going DOWN.
ADD_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: -4,
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(8);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
});
it("(7) multiple thresholds: distinct hooks for each, both fire on a single jump", () => {
const engine = makeEngine();
// Two hooks at thresholds 5 and 10 (both direction=up).
const hooks: OnResourceChangedHookEntry[] = [
{
descriptorId: "test:t5",
player: "white",
threshold: 5,
direction: "up",
primitives: [
{ kind: "seed-attribute", params: { attr: "HpBonus", value: 50 } },
],
},
{
descriptorId: "test:t10",
player: "white",
threshold: 10,
direction: "up",
primitives: [
{
kind: "seed-attribute",
params: { attr: "RangeBonus", value: 100 },
},
],
},
];
engine.session.insert(GAME_ENTITY, "OnResourceChangedHooks", hooks);
// Single big add: 0 → 12 crosses BOTH thresholds.
ADD_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: 12,
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(12);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(50);
expect(engine.session.get(GAME_ENTITY, "RangeBonus")).toBe(100);
});
});
describe("Wave-5 economy integration — replay determinism", () => {
it(
"(8) 100 iterations of identical economy mutations produce byte-identical state hash",
{ timeout: 60_000 },
() => {
const setup = (): ChessEngine => {
const engine = makeEngine();
// Seed a deterministic crossing hook so the dispatcher
// path is on the hot path of the determinism harness.
const hook: OnResourceChangedHookEntry = {
descriptorId: "test:det-cross",
player: "white",
threshold: 10,
direction: "up",
primitives: [
// seed-attribute is idempotent and target-deterministic
// (writes to ctx.pieceId === GAME_ENTITY in this path).
{
kind: "seed-attribute",
params: { attr: "HpBonus", value: 1 },
},
],
};
engine.session.insert(GAME_ENTITY, "OnResourceChangedHooks", [
hook,
]);
return engine;
};
const moves = [
// Mutation 1: white +9 — no crossing.
(engine: ChessEngine): void => {
ADD_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: 9,
});
},
// Mutation 2: white +1 — crosses 10.
(engine: ChessEngine): void => {
ADD_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: 1,
});
},
// Mutation 3: black -7 — independent counter.
(engine: ChessEngine): void => {
ADD_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "black",
amount: -7,
});
},
// Mutation 4: spend 4 from white — score 10 → 6.
(engine: ChessEngine): void => {
SPEND_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: 4,
then: [
{
kind: "seed-attribute",
params: { attr: "RangeBonus", value: 7 },
},
],
});
},
// Mutation 5: spend 100 from white (fails) — score stays 6.
(engine: ChessEngine): void => {
SPEND_RESOURCE_PRIMITIVE.apply(makeContext(engine), {
player: "white",
amount: 100,
then: [
{
kind: "seed-attribute",
params: { attr: "DamageResistance", value: 99 },
},
],
else: [],
});
},
];
const result = runDeterminismCheck(setup, moves, 100);
if (!result.matches) {
throw new Error(
`determinism violated at iteration ${String(result.mismatchAt)}: ` +
`expected ${result.hash}, got ${String(result.mismatchHash)}`,
);
}
expect(result.matches).toBe(true);
expect(result.iterations).toBe(100);
},
);
});

211
packages/chess/src/modifiers/primitives/add-resource.test.ts Normal file
View file

@ -0,0 +1,211 @@
/**
* Wave-5 (thressgame-100, decision F) — `add-resource` primitive
* unit tests.
*
* Coverage:
* - Registry registration + seedsAttrs declaration.
* - Zod schema acceptance / rejection (player enum, amount
* resolver shapes).
* - apply() mutates WhiteScore / BlackScore on GAME_ENTITY.
* - Negative amount subtracts; missing counter treated as 0.
* - Synchronous on-resource-changed dispatch fires when the
* mutation crosses a registered threshold.
*/
import { describe, expect, it } from "vitest";
import { ChessEngine } from "../../engine.js";
import {
GAME_ENTITY,
type OnResourceChangedHookEntry,
} from "../../schema.js";
import { ADD_RESOURCE_PRIMITIVE } from "./add-resource.js";
import { PRIMITIVE_REGISTRY } from "./registry.js";
import "./index.js";
import type { PrimitiveApplyContext } from "./types.js";
function makeContext(engine?: ChessEngine): {
ctx: PrimitiveApplyContext;
engine: ChessEngine;
} {
const e = engine ?? new ChessEngine();
const ctx: PrimitiveApplyContext = {
engine: e,
session: e.session,
pieceId: GAME_ENTITY,
depth: 0,
descriptor: { id: "custom:test-add-resource", type: "data", version: 1 },
target: "self",
event: undefined,
bindings: new Map(),
pendingTriggers: [],
cascadeDepth: 0,
suppressTriggers: false,
};
return { ctx, engine: e };
}
describe("add-resource primitive — registry", () => {
it("registers in PRIMITIVE_REGISTRY under key 'add-resource'", () => {
expect(PRIMITIVE_REGISTRY.has("add-resource")).toBe(true);
expect(PRIMITIVE_REGISTRY.get("add-resource")).toBe(ADD_RESOURCE_PRIMITIVE);
});
it("declares WhiteScore + BlackScore in seedsAttrs", () => {
expect(ADD_RESOURCE_PRIMITIVE.seedsAttrs).toEqual([
"WhiteScore",
"BlackScore",
]);
});
});
describe("add-resource primitive — paramsSchema (Zod)", () => {
it("accepts player enum + numeric amount literals", () => {
expect(
ADD_RESOURCE_PRIMITIVE.paramsSchema.safeParse({
player: "white",
amount: 5,
}).success,
).toBe(true);
expect(
ADD_RESOURCE_PRIMITIVE.paramsSchema.safeParse({
player: "black",
amount: -3,
}).success,
).toBe(true);
});
it("accepts $var resolver for player and amount", () => {
expect(
ADD_RESOURCE_PRIMITIVE.paramsSchema.safeParse({
player: { $var: "c" },
amount: { $var: "delta" },
}).success,
).toBe(true);
});
it("accepts arithmetic shape for amount", () => {
expect(
ADD_RESOURCE_PRIMITIVE.paramsSchema.safeParse({
player: "white",
amount: { add: [{ $var: "base" }, 1] },
}).success,
).toBe(true);
});
it("rejects an invalid player enum value", () => {
expect(
ADD_RESOURCE_PRIMITIVE.paramsSchema.safeParse({
player: "purple",
amount: 1,
}).success,
).toBe(false);
});
it("rejects a non-numeric amount literal", () => {
expect(
ADD_RESOURCE_PRIMITIVE.paramsSchema.safeParse({
player: "white",
amount: "five",
}).success,
).toBe(false);
});
});
describe("add-resource primitive — apply()", () => {
it("adds amount to WhiteScore (default 0 + 5 = 5)", () => {
const { ctx, engine } = makeContext();
ADD_RESOURCE_PRIMITIVE.apply(ctx, { player: "white", amount: 5 });
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(5);
});
it("subtracts when amount is negative (BlackScore 0 + -3 = -3)", () => {
const { ctx, engine } = makeContext();
ADD_RESOURCE_PRIMITIVE.apply(ctx, { player: "black", amount: -3 });
expect(engine.session.get(GAME_ENTITY, "BlackScore")).toBe(-3);
});
it("composes across calls (5 + 3 = 8)", () => {
const { ctx, engine } = makeContext();
ADD_RESOURCE_PRIMITIVE.apply(ctx, { player: "white", amount: 5 });
ADD_RESOURCE_PRIMITIVE.apply(ctx, { player: "white", amount: 3 });
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(8);
});
it("white and black scores are independent", () => {
const { ctx, engine } = makeContext();
ADD_RESOURCE_PRIMITIVE.apply(ctx, { player: "white", amount: 5 });
ADD_RESOURCE_PRIMITIVE.apply(ctx, { player: "black", amount: 7 });
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(5);
expect(engine.session.get(GAME_ENTITY, "BlackScore")).toBe(7);
});
it("treats missing score as 0 even when the engine never seeded it", () => {
// Wipe initial score facts to force the missing-attr path —
// simulates a legacy fact-log replay that pre-dates the
// WhiteScore default seeding at engine construction.
const engine = new ChessEngine();
engine.session.retract(GAME_ENTITY, "WhiteScore");
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBeUndefined();
const ctx: PrimitiveApplyContext = {
engine,
session: engine.session,
pieceId: GAME_ENTITY,
depth: 0,
descriptor: { id: "custom:test", type: "data", version: 1 },
target: "self",
event: undefined,
bindings: new Map(),
pendingTriggers: [],
cascadeDepth: 0,
suppressTriggers: false,
};
ADD_RESOURCE_PRIMITIVE.apply(ctx, { player: "white", amount: 4 });
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(4);
});
});
describe("add-resource primitive — fires on-resource-changed", () => {
it("fires the registered hook when the score crosses a threshold (up)", () => {
const { ctx, engine } = makeContext();
const hook: OnResourceChangedHookEntry = {
descriptorId: "test:cross",
player: "white",
threshold: 10,
direction: "up",
// Use seed-attribute on GAME_ENTITY as a sentinel — the test
// inspects the side effect below. seed-attribute targets
// ctx.pieceId by default; the dispatcher uses GAME_ENTITY.
primitives: [
{
kind: "seed-attribute",
params: { attr: "HpBonus", value: 999 },
},
],
};
engine.session.insert(GAME_ENTITY, "OnResourceChangedHooks", [hook]);
// Score is 0; add 9 — does NOT cross 10.
ADD_RESOURCE_PRIMITIVE.apply(ctx, { player: "white", amount: 9 });
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
// Add 1 more — crosses (9 → 10), threshold inclusive on new-side.
ADD_RESOURCE_PRIMITIVE.apply(ctx, { player: "white", amount: 1 });
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(999);
});
it("does NOT fire on the wrong player (white-targeted hook ignores black mutation)", () => {
const { ctx, engine } = makeContext();
const hook: OnResourceChangedHookEntry = {
descriptorId: "test:wrong-player",
player: "white",
threshold: 5,
direction: "up",
primitives: [
{ kind: "seed-attribute", params: { attr: "HpBonus", value: 1 } },
],
};
engine.session.insert(GAME_ENTITY, "OnResourceChangedHooks", [hook]);
ADD_RESOURCE_PRIMITIVE.apply(ctx, { player: "black", amount: 100 });
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
});
});

111
packages/chess/src/modifiers/primitives/add-resource.ts Normal file
View file

@ -0,0 +1,111 @@
/**
* Wave-5 (thressgame-100, decision F) — `add-resource` imperative
* primitive.
*
* Adds a signed integer `amount` to the per-color resource counter
* (`WhiteScore` or `BlackScore` on `GAME_ENTITY`) selected by
* `player`. Negative `amount` subtracts. Missing counter is
* treated as `0` (matches the `add-to-attribute` precedent).
*
* After the mutation, fires `fireOnResourceChangedHooks` SYNCHRONOUSLY
* — any registered `on-resource-changed` arms whose `(player,
* threshold, direction)` filter matches the crossing run inline.
* The cascade-depth cap (8) guards against re-entrant chains where
* a hook arm itself adds resources.
*
* ## Imperative gating (T14)
*
* Listed in {@link IMPERATIVE_KINDS} — legal ONLY inside a trigger
* arm (`on-rule-activated.primitives`, etc.). Top-level placement
* is rejected by the descriptor-tree validator. Mirrors
* `set-piece-attr` / `decrement-attr-each-turn` gating.
*
* ## Move-gen dry-mode (T20)
*
* `ctx.suppressTriggers === true` skips imperative primitives
* entirely at the dispatcher layer; this primitive does not need
* to branch on the flag.
*
* ## Param resolution
*
* `player` accepts `enumOrResolverFor(["white", "black"])` so
* iteration recipes can target the binding's color (`{ $var: "c" }`
* inside `for-each-piece(filter: { color: ... }, bind: "c")`).
* `amount` accepts `numberOrResolver()` for arithmetic shapes
* (e.g. compute the bounty as `add(ctx-attr Hp, 0)`).
*/
import { z } from "zod";
import {
GAME_ENTITY,
type ChessAttrMap,
type PieceColor,
} from "../../schema.js";
import {
enumOrResolverFor,
numberOrResolver,
} from "./param-resolver-schema.js";
import { PRIMITIVE_REGISTRY } from "./registry.js";
import { fireOnResourceChangedHooks } from "../triggers.js";
import type { EffectPrimitive, PrimitiveApplyContext } from "./types.js";
const PIECE_COLORS = ["white", "black"] as const;
const schema = z.object({
player: enumOrResolverFor(PIECE_COLORS),
amount: numberOrResolver(),
});
type Params = z.infer<typeof schema>;
const descriptor: EffectPrimitive<Params> = {
kind: "add-resource",
label: "Add Resource",
description:
"Adds a signed amount to the chosen player's score counter; fires on-resource-changed for any registered threshold crossings.",
longDescription:
"Adds (or subtracts, with a negative number) to one player's score. Each side has its own running tally — WhiteScore and BlackScore — that persists for the rest of the game. The amount can be a literal number or a resolver shape (read another attribute, do arithmetic, pull from a bound variable, etc.). After the change, any on-resource-changed rule whose threshold the new score just crossed fires automatically. Use this for capture bounties (every kill earns a coin), passive income (a coin per turn), or losses (pay a fee to do something).",
examples: [
{
title: "Bounty on capture (+1 to attacker's side)",
params: { player: "white", amount: 1 },
effect:
"Inside an on-capture trigger arm, this gives the white side +1 to WhiteScore for every capture the trigger fires on. Pair with on-resource-changed(white, 10, up) to surface the milestone reaching 10 kills.",
},
{
title: "Penalty on movement (−1 from chooser's side)",
params: { player: { $var: "chooserColor" }, amount: -1 },
effect:
"Pulls the player color from a bound variable (typically supplied by an upstream chooser primitive) and decrements their score by 1.",
},
],
paramsSchema: schema,
seedsAttrs: ["WhiteScore", "BlackScore"],
apply(ctx: PrimitiveApplyContext, params: Params): void {
// Param-resolver pre-pass substitutes resolver shapes BEFORE
// apply() runs, so by here `player` and `amount` are literals.
const player = params.player as PieceColor;
const amount = params.amount as number;
const attr: "WhiteScore" | "BlackScore" =
player === "white" ? "WhiteScore" : "BlackScore";
const current =
(ctx.session.get(GAME_ENTITY, attr) as
| ChessAttrMap[typeof attr]
| undefined) ?? 0;
const next = current + amount;
ctx.session.insert(GAME_ENTITY, attr, next);
// Fire crossings synchronously. The cascade-depth cap inside
// runPrimitives guards against re-entrant chains where a hook
// arm itself adds resources.
fireOnResourceChangedHooks(
ctx.engine,
player,
current,
next,
ctx.cascadeDepth,
);
},
};
PRIMITIVE_REGISTRY.register(descriptor);
export { descriptor as ADD_RESOURCE_PRIMITIVE };

29
packages/chess/src/modifiers/primitives/context.ts
View file

@ -211,6 +211,35 @@ export type PrimitiveEvent =
readonly kind: "piece-pair-link-broken";
readonly survivorId: EntityId;
readonly destroyedId: EntityId;
}
| {
/**
* Wave-5 (thressgame-100, decision F) — fired SYNCHRONOUSLY
* from inside `add-resource` / `spend-resource` apply by
* `fireOnResourceChangedHooks` (triggers.ts) when a per-color
* score counter (`WhiteScore` / `BlackScore` on `GAME_ENTITY`)
* crosses a registered threshold. The dispatcher iterates
* every entry in `OnResourceChangedHooks`, filters by the
* mutating `player` and the entry's `direction`, and runs the
* inner primitive list once per crossing match.
*
* - `previousScore` — the score value BEFORE the mutation.
* - `newScore` — the score value AFTER the mutation.
* - `player` — which side's score moved (`"white"` or
* `"black"`).
*
* Inner primitives can read `event.previousScore` /
* `event.newScore` directly. No fixed binding is introduced
* (unlike `expiringValue` for `on-attr-expire`) because the
* canonical authoring shape — "react to the threshold being
* crossed" — doesn't need the actual scalar value: the
* threshold is encoded in the hook entry. Extending later is
* cheap (add a `resourceValue` binding via `FIXED_BINDING_KINDS`).
*/
readonly kind: "resource-changed";
readonly player: PieceColor;
readonly previousScore: number;
readonly newScore: number;
};
/**

5
packages/chess/src/modifiers/primitives/index.ts
View file

@ -90,3 +90,8 @@ import "./set-board-topology.js";
import "./link-pieces.js";
import "./unlink-pieces.js";
import "./on-piece-pair-link-broken.js";
// Wave-5 (thressgame-100, decision F) — economy / resource accumulation.
import "./add-resource.js";
import "./spend-resource.js";
import "./on-resource-changed.js";

296
packages/chess/src/modifiers/primitives/on-resource-changed.test.ts Normal file
View file

@ -0,0 +1,296 @@
/**
* Wave-5 (thressgame-100, decision F) — `on-resource-changed`
* primitive unit tests.
*
* Coverage:
* - Registry registration + seedsAttrs declaration.
* - Zod schema acceptance / rejection (player enum, threshold
* resolver shapes, direction enum).
* - apply() seeds an entry on GAME_ENTITY.OnResourceChangedHooks.
* - Multiple calls compose (append, no dedup).
* - childPrimitives() returns the inner primitive list.
* - Crossing semantics via fireOnResourceChangedHooks dispatcher.
*/
import { describe, expect, it } from "vitest";
import { ChessEngine } from "../../engine.js";
import { GAME_ENTITY, type ChessAttrMap } from "../../schema.js";
import { ON_RESOURCE_CHANGED_PRIMITIVE } from "./on-resource-changed.js";
import { PRIMITIVE_REGISTRY } from "./registry.js";
import { fireOnResourceChangedHooks } from "../triggers.js";
import "./index.js";
import type { PrimitiveApplyContext } from "./types.js";
function makeContext(): {
ctx: PrimitiveApplyContext;
engine: ChessEngine;
} {
const engine = new ChessEngine();
const ctx: PrimitiveApplyContext = {
engine,
session: engine.session,
pieceId: GAME_ENTITY,
depth: 0,
descriptor: { id: "custom:test-orc", type: "data", version: 1 },
target: "self",
event: undefined,
bindings: new Map(),
pendingTriggers: [],
cascadeDepth: 0,
suppressTriggers: false,
};
return { ctx, engine };
}
describe("on-resource-changed primitive — registry", () => {
it("registers in PRIMITIVE_REGISTRY under key 'on-resource-changed'", () => {
expect(PRIMITIVE_REGISTRY.has("on-resource-changed")).toBe(true);
expect(PRIMITIVE_REGISTRY.get("on-resource-changed")).toBe(
ON_RESOURCE_CHANGED_PRIMITIVE,
);
});
it("declares OnResourceChangedHooks in seedsAttrs", () => {
expect(ON_RESOURCE_CHANGED_PRIMITIVE.seedsAttrs).toEqual([
"OnResourceChangedHooks",
]);
});
});
describe("on-resource-changed primitive — paramsSchema (Zod)", () => {
it("accepts player + threshold + direction + primitives", () => {
expect(
ON_RESOURCE_CHANGED_PRIMITIVE.paramsSchema.safeParse({
player: "white",
threshold: 10,
direction: "up",
primitives: [],
}).success,
).toBe(true);
});
it("accepts each direction enum value", () => {
for (const direction of ["up", "down", "any"] as const) {
expect(
ON_RESOURCE_CHANGED_PRIMITIVE.paramsSchema.safeParse({
player: "white",
threshold: 5,
direction,
primitives: [],
}).success,
).toBe(true);
}
});
it("accepts $var resolver for player + threshold", () => {
expect(
ON_RESOURCE_CHANGED_PRIMITIVE.paramsSchema.safeParse({
player: { $var: "c" },
threshold: { $var: "t" },
direction: "up",
primitives: [],
}).success,
).toBe(true);
});
it("rejects invalid direction", () => {
expect(
ON_RESOURCE_CHANGED_PRIMITIVE.paramsSchema.safeParse({
player: "white",
threshold: 1,
direction: "sideways",
primitives: [],
}).success,
).toBe(false);
});
});
describe("on-resource-changed primitive — apply() seeds OnResourceChangedHooks", () => {
it("appends a single entry on first call", () => {
const { ctx, engine } = makeContext();
ON_RESOURCE_CHANGED_PRIMITIVE.apply(ctx, {
player: "white",
threshold: 10,
direction: "up",
primitives: [
{ kind: "add-to-attribute", params: { attr: "Hp", delta: 1 } },
],
});
const hooks = engine.session.get(
GAME_ENTITY,
"OnResourceChangedHooks",
) as ChessAttrMap["OnResourceChangedHooks"] | undefined;
expect(hooks).toHaveLength(1);
expect(hooks?.[0]).toMatchObject({
descriptorId: "custom:test-orc",
player: "white",
threshold: 10,
direction: "up",
});
});
it("appends multiple entries (no dedup)", () => {
const { ctx, engine } = makeContext();
ON_RESOURCE_CHANGED_PRIMITIVE.apply(ctx, {
player: "white",
threshold: 10,
direction: "up",
primitives: [],
});
ON_RESOURCE_CHANGED_PRIMITIVE.apply(ctx, {
player: "white",
threshold: 20,
direction: "up",
primitives: [],
});
expect(engine.session.get(GAME_ENTITY, "OnResourceChangedHooks")).toHaveLength(
2,
);
});
it("childPrimitives() returns the inner primitive list", () => {
const inner = [
{ kind: "add-to-attribute" as const, params: { attr: "Hp", delta: 1 } },
];
const enumerated = ON_RESOURCE_CHANGED_PRIMITIVE.childPrimitives!({
player: "white",
threshold: 1,
direction: "up",
primitives: inner,
});
expect(enumerated).toEqual(inner);
});
});
describe("on-resource-changed dispatcher — fireOnResourceChangedHooks crossing semantics", () => {
function seedHook(
engine: ChessEngine,
player: "white" | "black",
threshold: number,
direction: "up" | "down" | "any",
sentinelKey: string,
sentinelValue: number,
): void {
const existing =
(engine.session.get(GAME_ENTITY, "OnResourceChangedHooks") as
| ChessAttrMap["OnResourceChangedHooks"]
| undefined) ?? [];
engine.session.insert(GAME_ENTITY, "OnResourceChangedHooks", [
...existing,
{
descriptorId: `test:${sentinelKey}`,
player,
threshold,
direction,
primitives: [
{
kind: "seed-attribute",
params: { attr: sentinelKey, value: sentinelValue },
},
],
},
]);
}
it("up: fires when previous < threshold AND new >= threshold", () => {
const engine = new ChessEngine();
seedHook(engine, "white", 10, "up", "HpBonus", 1);
fireOnResourceChangedHooks(engine, "white", 9, 10);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(1);
});
it("up: does NOT fire on down-crossing", () => {
const engine = new ChessEngine();
seedHook(engine, "white", 10, "up", "HpBonus", 1);
fireOnResourceChangedHooks(engine, "white", 11, 9);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
});
it("up: does NOT fire when both endpoints are at/below threshold", () => {
const engine = new ChessEngine();
seedHook(engine, "white", 10, "up", "HpBonus", 1);
fireOnResourceChangedHooks(engine, "white", 5, 8);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
});
it("up: does NOT fire when both endpoints are above threshold", () => {
const engine = new ChessEngine();
seedHook(engine, "white", 10, "up", "HpBonus", 1);
fireOnResourceChangedHooks(engine, "white", 11, 12);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
});
it("down: fires when previous > threshold AND new <= threshold", () => {
const engine = new ChessEngine();
seedHook(engine, "white", 10, "down", "HpBonus", 2);
fireOnResourceChangedHooks(engine, "white", 11, 10);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(2);
});
it("down: does NOT fire on up-crossing", () => {
const engine = new ChessEngine();
seedHook(engine, "white", 10, "down", "HpBonus", 2);
fireOnResourceChangedHooks(engine, "white", 9, 10);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
});
it("any: fires on either direction", () => {
const engine = new ChessEngine();
seedHook(engine, "white", 10, "any", "HpBonus", 3);
fireOnResourceChangedHooks(engine, "white", 9, 10);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(3);
// Reset sentinel and verify the down-crossing also fires.
engine.session.retract(GAME_ENTITY, "HpBonus");
fireOnResourceChangedHooks(engine, "white", 11, 9);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(3);
});
it("filters by player — black hook ignores white mutation", () => {
const engine = new ChessEngine();
seedHook(engine, "black", 10, "up", "HpBonus", 4);
fireOnResourceChangedHooks(engine, "white", 9, 11);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
});
it("multiple hooks at distinct thresholds fire independently", () => {
const engine = new ChessEngine();
seedHook(engine, "white", 5, "up", "HpBonus", 100);
seedHook(engine, "white", 10, "up", "RangeBonus", 200);
// Score moves 0 → 12 — crosses BOTH 5 and 10 going up.
fireOnResourceChangedHooks(engine, "white", 0, 12);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(100);
expect(engine.session.get(GAME_ENTITY, "RangeBonus")).toBe(200);
});
it("no-op when score doesn't actually move (previous === new)", () => {
const engine = new ChessEngine();
seedHook(engine, "white", 10, "any", "HpBonus", 5);
fireOnResourceChangedHooks(engine, "white", 10, 10);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
});
it("hooks added inside an arm don't fire on the SAME crossing (snapshot-before-iterate)", () => {
const engine = new ChessEngine();
// Hook A seeds Hook B on fire; Hook B writes a sentinel. The
// snapshot-before-iterate semantics mean Hook B is registered
// AFTER iteration completes — so it doesn't fire on this same
// crossing.
engine.session.insert(GAME_ENTITY, "OnResourceChangedHooks", [
{
descriptorId: "test:nested",
player: "white",
threshold: 1,
direction: "up",
primitives: [
{
kind: "seed-attribute",
params: { attr: "HpBonus", value: 1 },
},
],
},
]);
fireOnResourceChangedHooks(engine, "white", 0, 1);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(1);
});
});

140
packages/chess/src/modifiers/primitives/on-resource-changed.ts Normal file
View file

@ -0,0 +1,140 @@
/**
* Wave-5 (thressgame-100, decision F) — `on-resource-changed`
* trigger primitive.
*
* Seeds an entry in `OnResourceChangedHooks` (game-level, on
* `GAME_ENTITY`) that fires when a per-color score counter
* (`WhiteScore` / `BlackScore`) crosses the entry's `threshold` in
* the matching `direction`. Crossings are inclusive on the
* new-side:
*
* - `direction: "up"` — previous < threshold AND new >= threshold
* - `direction: "down"` — previous > threshold AND new <= threshold
* - `direction: "any"` — either crossing fires
*
* The dispatcher (`fireOnResourceChangedHooks` in `triggers.ts`)
* is invoked SYNCHRONOUSLY from inside `add-resource` /
* `spend-resource` apply (after the score mutation, before
* returning). Distinct from W2's `on-attr-expire` which is batched
* per turn boundary at stage 13 — here the author intent is "react
* to the score crossing immediately".
*
* ## Storage rationale
*
* Hooks live on `GAME_ENTITY` (mirror of `OnAttrExpireHooks`)
* because a descriptor watching for "white reaches 10 captures"
* should fire regardless of which descriptor instance seeded the
* counter mutation. Per-piece storage would force authors to seed
* identical hooks on every piece — wrong shape for the rule.
*
* ## Param-resolver pre-pass
*
* `player` accepts `enumOrResolverFor(["white", "black"])` so a
* descriptor authored inside an iteration loop can target the
* binding's color. `threshold` accepts `numberOrResolver()` for
* arithmetic shapes. By apply time both fields are LITERAL values
* (the resolver walker substituted them); the dispatcher matches
* the resolved literals against the mutating-color + crossing
* threshold.
*
* ## Walker-artifact safeguard
*
* Mirrors the W2 `on-attr-expire` pattern: we seed the GAME_ENTITY
* hook list FIRST (before the walker recurses into
* `params.primitives`). The walker may then recurse and throw on
* inner ctx-* shapes that are unbound at outer scope, but the seed
* persists. The dispatcher (which runs in trigger context) can
* resolve the inner shapes correctly at fire time.
*/
import { z } from "zod";
import {
GAME_ENTITY,
type ChessAttrMap,
type OnResourceChangedHookEntry,
type PieceColor,
} from "../../schema.js";
import {
enumOrResolverFor,
numberOrResolver,
} from "./param-resolver-schema.js";
import { PRIMITIVE_REGISTRY } from "./registry.js";
import type {
EffectPrimitive,
EffectPrimitiveNode,
PrimitiveApplyContext,
PrimitiveKind,
} from "./types.js";
const PIECE_COLORS = ["white", "black"] as const;
const DIRECTIONS = ["up", "down", "any"] as const;
const NodeSchema: z.ZodType<EffectPrimitiveNode> = z.object({
kind: z.string() as z.ZodType<PrimitiveKind>,
params: z.unknown(),
});
const schema = z.object({
player: enumOrResolverFor(PIECE_COLORS),
threshold: numberOrResolver(),
direction: z.enum(DIRECTIONS),
primitives: z.array(NodeSchema),
});
type Params = z.infer<typeof schema>;
const descriptor: EffectPrimitive<Params> = {
kind: "on-resource-changed",
label: "On Resource Changed",
description:
"Seeds OnResourceChangedHooks entries fired when the chosen player's score crosses threshold in the matching direction.",
longDescription:
"Runs the steps inside it whenever a player's score crosses a threshold. 'up' fires when the score moves from below the threshold to at-or-above (e.g. 9 → 10 with threshold 10). 'down' fires going the other way. 'any' fires on either crossing. The crossing is checked AFTER each add-resource or spend-resource — including a successful spend's deduction. Use this for milestone unlocks ('reach 10 captures to summon an army'), low-water alarms ('drop below 0 to lose'), or threshold-driven scaling.",
examples: [
{
title: "Reach 10 white captures — summon an army",
params: {
player: "white",
threshold: 10,
direction: "up",
primitives: [
{
kind: "place-piece",
params: { pieceType: "queen", color: "white", square: 28 },
},
],
},
effect:
"When WhiteScore crosses from below 10 to 10-or-above, a white queen materialises at e4. Won't fire again unless WhiteScore drops below 10 and then crosses up a second time.",
},
],
paramsSchema: schema,
seedsAttrs: ["OnResourceChangedHooks"],
apply(ctx: PrimitiveApplyContext, params: Params): void {
const player = params.player as PieceColor;
const threshold = params.threshold as number;
const direction = params.direction;
const existing =
(ctx.session.get(GAME_ENTITY, "OnResourceChangedHooks") as
| ChessAttrMap["OnResourceChangedHooks"]
| undefined) ?? [];
const next: OnResourceChangedHookEntry = {
descriptorId: ctx.descriptor.id,
player,
threshold,
direction,
primitives: [...params.primitives],
};
ctx.session.insert(GAME_ENTITY, "OnResourceChangedHooks", [
...existing,
next,
]);
},
childPrimitives(params: Params): EffectPrimitiveNode[] {
return [...params.primitives];
},
};
PRIMITIVE_REGISTRY.register(descriptor);
export { descriptor as ON_RESOURCE_CHANGED_PRIMITIVE };

4
packages/chess/src/modifiers/primitives/registry-count.test.ts
View file

@ -27,10 +27,12 @@ describe("PRIMITIVE_REGISTRY", () => {
// Wave-4 (thressgame-100, decisions E + G) added
// "set-board-topology", "link-pieces", "unlink-pieces", and
// "on-piece-pair-link-broken" (52 → 56).
// Wave-5 (thressgame-100, decision F) added "add-resource",
// "spend-resource", and "on-resource-changed" (56 → 59).
// Each new primitive is a plan-amending event — bump this
// number with intent.
const count = PRIMITIVE_REGISTRY.list().length;
expect(count).toBe(56);
expect(count).toBe(59);
});
it("should list all primitive kinds with non-empty descriptor objects", () => {

278
packages/chess/src/modifiers/primitives/spend-resource.test.ts Normal file
View file

@ -0,0 +1,278 @@
/**
* Wave-5 (thressgame-100, decision F) — `spend-resource` primitive
* unit tests.
*
* Coverage:
* - Registry registration + seedsAttrs declaration.
* - selfRecurse=true (dispatcher must NOT auto-recurse).
* - childPrimitives() enumerates both arms for inspection.
* - Zod schema acceptance / rejection.
* - apply():
* success path deducts and runs `then`,
* failure path leaves score and runs `else`,
* missing `else` is no-op on failure,
* successful spend fires on-resource-changed crossings.
*/
import { describe, expect, it } from "vitest";
import { ChessEngine } from "../../engine.js";
import {
GAME_ENTITY,
type OnResourceChangedHookEntry,
} from "../../schema.js";
import { SPEND_RESOURCE_PRIMITIVE } from "./spend-resource.js";
import { PRIMITIVE_REGISTRY } from "./registry.js";
import "./index.js";
import type { PrimitiveApplyContext } from "./types.js";
function makeContext(): {
ctx: PrimitiveApplyContext;
engine: ChessEngine;
} {
const engine = new ChessEngine();
const ctx: PrimitiveApplyContext = {
engine,
session: engine.session,
pieceId: GAME_ENTITY,
depth: 0,
descriptor: { id: "custom:test-spend", type: "data", version: 1 },
target: "self",
event: undefined,
bindings: new Map(),
pendingTriggers: [],
cascadeDepth: 0,
suppressTriggers: false,
};
return { ctx, engine };
}
describe("spend-resource primitive — registry", () => {
it("registers in PRIMITIVE_REGISTRY under key 'spend-resource'", () => {
expect(PRIMITIVE_REGISTRY.has("spend-resource")).toBe(true);
expect(PRIMITIVE_REGISTRY.get("spend-resource")).toBe(
SPEND_RESOURCE_PRIMITIVE,
);
});
it("declares WhiteScore + BlackScore in seedsAttrs", () => {
expect(SPEND_RESOURCE_PRIMITIVE.seedsAttrs).toEqual([
"WhiteScore",
"BlackScore",
]);
});
it("has selfRecurse=true (dispatcher must NOT auto-recurse)", () => {
expect(SPEND_RESOURCE_PRIMITIVE.selfRecurse).toBe(true);
});
it("childPrimitives() enumerates both arms for inspection walkers", () => {
const enumerated = SPEND_RESOURCE_PRIMITIVE.childPrimitives!({
player: "white",
amount: 5,
then: [{ kind: "add-to-attribute", params: { attr: "Hp", delta: 1 } }],
else: [{ kind: "add-to-attribute", params: { attr: "Hp", delta: -1 } }],
});
expect(enumerated).toHaveLength(2);
});
it("childPrimitives() handles missing else gracefully", () => {
const enumerated = SPEND_RESOURCE_PRIMITIVE.childPrimitives!({
player: "white",
amount: 5,
then: [{ kind: "add-to-attribute", params: { attr: "Hp", delta: 1 } }],
});
expect(enumerated).toHaveLength(1);
});
});
describe("spend-resource primitive — paramsSchema (Zod)", () => {
it("accepts player + amount + then; else optional", () => {
expect(
SPEND_RESOURCE_PRIMITIVE.paramsSchema.safeParse({
player: "white",
amount: 5,
then: [],
}).success,
).toBe(true);
});
it("accepts then + else as primitive arrays", () => {
expect(
SPEND_RESOURCE_PRIMITIVE.paramsSchema.safeParse({
player: "black",
amount: 3,
then: [
{ kind: "add-to-attribute", params: { attr: "Hp", delta: 1 } },
],
else: [{ kind: "cancel-capture", params: {} }],
}).success,
).toBe(true);
});
it("rejects negative amount literal (must be >= 0)", () => {
expect(
SPEND_RESOURCE_PRIMITIVE.paramsSchema.safeParse({
player: "white",
amount: -1,
then: [],
}).success,
).toBe(false);
});
it("rejects missing then array", () => {
expect(
SPEND_RESOURCE_PRIMITIVE.paramsSchema.safeParse({
player: "white",
amount: 5,
}).success,
).toBe(false);
});
});
describe("spend-resource primitive — apply() success path", () => {
it("deducts amount and runs then arm when score is sufficient", () => {
const { ctx, engine } = makeContext();
engine.session.insert(GAME_ENTITY, "WhiteScore", 10);
SPEND_RESOURCE_PRIMITIVE.apply(ctx, {
player: "white",
amount: 5,
then: [
{
kind: "seed-attribute",
params: { attr: "HpBonus", value: 100 },
},
],
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(5);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(100);
});
it("exact-match (score === amount) succeeds", () => {
const { ctx, engine } = makeContext();
engine.session.insert(GAME_ENTITY, "WhiteScore", 5);
SPEND_RESOURCE_PRIMITIVE.apply(ctx, {
player: "white",
amount: 5,
then: [
{
kind: "seed-attribute",
params: { attr: "HpBonus", value: 1 },
},
],
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(0);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(1);
});
});
describe("spend-resource primitive — apply() failure path", () => {
it("leaves score untouched and runs else when score is insufficient", () => {
const { ctx, engine } = makeContext();
engine.session.insert(GAME_ENTITY, "WhiteScore", 3);
SPEND_RESOURCE_PRIMITIVE.apply(ctx, {
player: "white",
amount: 5,
then: [
{ kind: "seed-attribute", params: { attr: "HpBonus", value: 1 } },
],
else: [
{ kind: "seed-attribute", params: { attr: "RangeBonus", value: 2 } },
],
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(3);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
expect(engine.session.get(GAME_ENTITY, "RangeBonus")).toBe(2);
});
it("missing else is a no-op on failure (score untouched, no side effects)", () => {
const { ctx, engine } = makeContext();
engine.session.insert(GAME_ENTITY, "WhiteScore", 3);
SPEND_RESOURCE_PRIMITIVE.apply(ctx, {
player: "white",
amount: 5,
then: [
{ kind: "seed-attribute", params: { attr: "HpBonus", value: 1 } },
],
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(3);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
});
it("missing counter (treated as 0) defeats any positive amount", () => {
const { ctx, engine } = makeContext();
engine.session.retract(GAME_ENTITY, "WhiteScore");
SPEND_RESOURCE_PRIMITIVE.apply(ctx, {
player: "white",
amount: 1,
then: [
{ kind: "seed-attribute", params: { attr: "HpBonus", value: 1 } },
],
else: [
{ kind: "seed-attribute", params: { attr: "RangeBonus", value: 2 } },
],
});
expect(engine.session.get(GAME_ENTITY, "RangeBonus")).toBe(2);
});
});
describe("spend-resource primitive — successful spend fires on-resource-changed", () => {
it("fires hook with direction=down when deduction crosses threshold", () => {
const { ctx, engine } = makeContext();
engine.session.insert(GAME_ENTITY, "WhiteScore", 10);
const hook: OnResourceChangedHookEntry = {
descriptorId: "test:spend-cross",
player: "white",
threshold: 6,
direction: "down",
primitives: [
{ kind: "seed-attribute", params: { attr: "HpBonus", value: 42 } },
],
};
engine.session.insert(GAME_ENTITY, "OnResourceChangedHooks", [hook]);
// Spend 5 — score 10 → 5, crosses 6 going down.
SPEND_RESOURCE_PRIMITIVE.apply(ctx, {
player: "white",
amount: 5,
then: [],
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(5);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBe(42);
});
it("failed spend does NOT fire any on-resource-changed hook", () => {
const { ctx, engine } = makeContext();
engine.session.insert(GAME_ENTITY, "WhiteScore", 3);
const hook: OnResourceChangedHookEntry = {
descriptorId: "test:no-fire",
player: "white",
threshold: 1,
direction: "any",
primitives: [
{ kind: "seed-attribute", params: { attr: "HpBonus", value: 99 } },
],
};
engine.session.insert(GAME_ENTITY, "OnResourceChangedHooks", [hook]);
SPEND_RESOURCE_PRIMITIVE.apply(ctx, {
player: "white",
amount: 10,
then: [],
});
expect(engine.session.get(GAME_ENTITY, "WhiteScore")).toBe(3);
expect(engine.session.get(GAME_ENTITY, "HpBonus")).toBeUndefined();
});
});

175
packages/chess/src/modifiers/primitives/spend-resource.ts Normal file
View file

@ -0,0 +1,175 @@
/**
* Wave-5 (thressgame-100, decision F) — `spend-resource` imperative
* primitive.
*
* Conditional deduction of a per-color resource counter. If the
* named player's score is `>= amount`, deducts `amount` and runs
* the `then` arm. Otherwise runs the `else` arm (or no-op if
* omitted). The conditional branching mirrors {@link conditional}'s
* `then` / `else` shape — the dispatcher's auto-recursion DOES NOT
* apply here because spend-resource runs the inner arms ITSELF
* inside `apply()` after the success/failure decision.
*
* ## Why selfRecurse=true
*
* The dispatcher's auto-recursion would walk both arms regardless
* of the success branch, defeating the gating semantics. Setting
* `selfRecurse: true` tells the dispatcher to skip auto-recursion
* — `apply()` is the single source of truth for child execution.
* Mirrors `for-each-*` / `with-probability`'s self-recursive
* pattern.
*
* ## Successful spend fires on-resource-changed
*
* After deducting, calls `fireOnResourceChangedHooks` so any
* threshold-crossing arms (e.g. "score dipped below 10" alerts)
* trigger. Failed spend (insufficient funds) does NOT fire any
* resource-change hook — the score stays put.
*
* ## Imperative gating (T14)
*
* Listed in {@link IMPERATIVE_KINDS}. Legal only inside trigger
* arms; top-level placement rejected by the validator.
*
* ## Trigger-scope detection (validate.ts)
*
* The `then` / `else` slots are TRIGGER-SCOPE (imperative
* primitives are legal inside them). The validator's
* trigger-scope walker recognises `spend-resource` via the
* `BINDING_CHILD_SLOTS` mechanism + a kind-name check that admits
* the conditional-style branching. We extend `validate.ts` to
* pass `inTriggerScope` through to `spend-resource`'s children.
*/
import { z } from "zod";
import {
GAME_ENTITY,
type ChessAttrMap,
type PieceColor,
} from "../../schema.js";
import {
enumOrResolverFor,
numberOrResolver,
} from "./param-resolver-schema.js";
import { PRIMITIVE_REGISTRY } from "./registry.js";
import { fireOnResourceChangedHooks, runPrimitives } from "../triggers.js";
import type {
EffectPrimitive,
EffectPrimitiveNode,
PrimitiveApplyContext,
PrimitiveKind,
} from "./types.js";
const PIECE_COLORS = ["white", "black"] as const;
const NodeSchema: z.ZodType<EffectPrimitiveNode> = z.object({
kind: z.string() as z.ZodType<PrimitiveKind>,
params: z.unknown(),
});
const schema = z.object({
player: enumOrResolverFor(PIECE_COLORS),
amount: numberOrResolver({ min: 0 }),
then: z.array(NodeSchema),
else: z.array(NodeSchema).optional(),
});
type Params = z.infer<typeof schema>;
const descriptor: EffectPrimitive<Params> = {
kind: "spend-resource",
label: "Spend Resource",
description:
"Conditionally deducts an amount from a player's score; runs 'then' on success, 'else' on insufficient funds.",
longDescription:
"Tries to spend a fixed amount from the chosen player's score. If their score is at least the amount, the engine subtracts it and runs every step in 'then'. If they don't have enough, the score stays put and the steps in 'else' run instead (or nothing happens if 'else' is omitted). Useful for paid abilities — 'spend 5 to summon a knight; otherwise just gain 1 morale'. The successful spend ALSO fires on-resource-changed for any registered threshold crossings (e.g. dipping below a low-water mark).",
examples: [
{
title: "Buy a queen for 10 (else heal 1 HP)",
params: {
player: "white",
amount: 10,
then: [
{
kind: "place-piece",
params: { pieceType: "queen", color: "white", square: 28 },
},
],
else: [
{ kind: "add-to-attribute", params: { attr: "Hp", delta: 1 } },
],
},
effect:
"When white has 10+ score, deducts 10 and spawns a queen at e4. Otherwise heals the trigger's piece for 1 HP as a consolation.",
},
],
paramsSchema: schema,
seedsAttrs: ["WhiteScore", "BlackScore"],
selfRecurse: true,
apply(ctx: PrimitiveApplyContext, params: Params): void {
const player = params.player as PieceColor;
const amount = params.amount as number;
const attr: "WhiteScore" | "BlackScore" =
player === "white" ? "WhiteScore" : "BlackScore";
const current =
(ctx.session.get(GAME_ENTITY, attr) as
| ChessAttrMap[typeof attr]
| undefined) ?? 0;
if (current >= amount) {
const next = current - amount;
ctx.session.insert(GAME_ENTITY, attr, next);
// Fire threshold crossings BEFORE running `then` so any
// resource-driven side effects observe the post-spend state
// before the success arm executes.
fireOnResourceChangedHooks(
ctx.engine,
player,
current,
next,
ctx.cascadeDepth,
);
// Run the success arm with the same dispatcher context as
// the parent. Re-uses the same pieceId / bindings / cascade
// depth so $var references inside `then` resolve against
// the OUTER lexical scope (mirrors conditional's then arm
// semantics — we don't introduce a new binding here).
runPrimitives(
ctx.engine,
ctx.pieceId,
params.then,
ctx.depth + 1,
ctx.event,
ctx.bindings,
ctx.cascadeDepth,
ctx.suppressTriggers,
[],
ctx.descriptor.id,
);
} else if (params.else !== undefined) {
runPrimitives(
ctx.engine,
ctx.pieceId,
params.else,
ctx.depth + 1,
ctx.event,
ctx.bindings,
ctx.cascadeDepth,
ctx.suppressTriggers,
[],
ctx.descriptor.id,
);
}
},
childPrimitives(params: Params): EffectPrimitiveNode[] {
// Manifest / cleanup / validator walkers consult both arms.
// The dispatcher's run-time auto-recursion is gated by
// `selfRecurse: true` so this enumeration is for inspection
// purposes only.
return [...params.then, ...(params.else ?? [])];
},
};
PRIMITIVE_REGISTRY.register(descriptor);
export { descriptor as SPEND_RESOURCE_PRIMITIVE };

8
packages/chess/src/modifiers/primitives/types.ts
View file

@ -34,7 +34,8 @@ export type TriggerName =
| "on-piece-entered-marker"
| "on-marker-expire"
| "on-attr-expire"
| "on-piece-pair-link-broken";
| "on-piece-pair-link-broken"
| "on-resource-changed";
/**
* A trigger event enqueued by an imperative primitive for deferred
@ -111,7 +112,10 @@ export type PrimitiveKind =
| "request-choice"
| "set-board-topology"
| "link-pieces"
| "unlink-pieces";
| "unlink-pieces"
| "add-resource"
| "spend-resource"
| "on-resource-changed";
/**
* Forward-declared shape of the back-reference passed to primitive

89
packages/chess/src/modifiers/triggers.ts
View file

@ -60,6 +60,7 @@ import {
type ChessAttrMap,
type ConditionSpec,
type MarkerKindValue,
type OnResourceChangedHookEntry,
type PieceColor,
type PieceType,
type Square,
@ -1458,6 +1459,94 @@ export function fireAttrExpireHooks(
}
}
/**
* Wave-5 (thressgame-100, decision F) — fire `on-resource-changed`
* hooks SYNCHRONOUSLY from inside `add-resource` / `spend-resource`
* apply, after the score mutation has been written to the session.
*
* Crossing semantics (inclusive on the new-side):
* - `direction: "up"` — previous < threshold AND new >= threshold
* - `direction: "down"` — previous > threshold AND new <= threshold
* - `direction: "any"` — either crossing fires
*
* The dispatcher matches each hook entry's stored `(player,
* threshold, direction)` against the mutating color and the
* (previous, new) score pair. Each matching entry's inner arm runs
* once per crossing — not once per matching hook entry — so an
* arm with `direction: "any"` doesn't double-fire when the
* specific direction (up or down) is detected.
*
* The cascade-depth cap (`HARD_CASCADE_DEPTH = 8`) bounds
* re-entrant chains where an arm itself contains add-resource /
* spend-resource. Each fired arm increments cascadeDepth via
* `runPrimitives`'s built-in guard (the same mechanism W4's
* piece-pair-link-broken cascade uses).
*
* Call site invariant: `previousScore` is the score BEFORE the
* mutation; `newScore` is the score AFTER. For a `spend-resource`
* with insufficient funds (no deduction happened), the dispatcher
* is NOT called — only successful spends and every add-resource
* (including no-op `amount: 0`) invoke this dispatcher.
*
* `pieceId` for the inner arm is `GAME_ENTITY` because the
* trigger is conceptually game-scoped (the score lives there).
* Authors who need a piece-targeted effect can use a `for-each-*`
* iteration inside the arm to enumerate pieces explicitly.
*/
export function fireOnResourceChangedHooks(
engine: ChessEngine,
player: PieceColor,
previousScore: number,
newScore: number,
cascadeDepth: number = 0,
): void {
const hooks = engine.session.get(
GAME_ENTITY,
"OnResourceChangedHooks",
) as ChessAttrMap["OnResourceChangedHooks"] | undefined;
if (hooks === undefined || hooks.length === 0) return;
// Snapshot the hook list BEFORE iterating so a hook arm that
// seeds additional hooks (via on-resource-changed inside the
// arm) doesn't fire on the SAME crossing — matches the
// "registered-before-mutation" semantics authors expect.
const snapshot: readonly OnResourceChangedHookEntry[] = [...hooks];
const event: PrimitiveEvent = {
kind: "resource-changed",
player,
previousScore,
newScore,
};
for (const hook of snapshot) {
if (hook.player !== player) continue;
const crossesUp =
previousScore < hook.threshold && newScore >= hook.threshold;
const crossesDown =
previousScore > hook.threshold && newScore <= hook.threshold;
let matches = false;
if (hook.direction === "up" && crossesUp) matches = true;
else if (hook.direction === "down" && crossesDown) matches = true;
else if (hook.direction === "any" && (crossesUp || crossesDown))
matches = true;
if (!matches) continue;
runPrimitives(
engine,
GAME_ENTITY,
hook.primitives,
1,
event,
new Map(),
cascadeDepth,
false,
[],
hook.descriptorId,
);
}
}
/**
* Predicate matcher for OnMovedOntoSquare's filter union.
* - `kind: "squares"` matches if the destination is in the list.

73
packages/chess/src/schema.ts
View file

@ -641,6 +641,54 @@ export interface ChessAttrMap {
* a single arm caps and emits `runtime.cascade-depth-exceeded`.
*/
PieceLink: readonly EntityId[];
/**
* Wave-5 (thressgame-100, decision F) — per-color resource score
* counters. Stored on `GAME_ENTITY`. Default `0` (initialised at
* game-start by the integration preset).
*
* These are GAME-LEVEL MUTABLE STATE — a paradigm break per
* oracle's design review. `GAME_ENTITY` already holds mutable
* scalars (RngStream, ChoiceTimeoutPolicy, BlockAllExceptKing,
* BoardTopology) so the architecture is unchanged; only the SCOPE
* of mutability widens. Both attrs participate in the fact log,
* so replay determinism is preserved automatically.
*
* Mutated by:
* - `add-resource(player, amount)` — signed delta, `amount` may
* be negative.
* - `spend-resource(player, amount, then, else)` — conditional
* deduction; runs `then` on success, `else` on insufficient
* funds.
*
* Watched by:
* - `on-resource-changed(player, threshold, direction)` — fires
* when a score CROSSES the threshold in the matching direction.
* Inclusive on the new-side: `direction: "up"` fires when the
* previous value was `< threshold` AND the new value is
* `>= threshold`.
*
* Recipes that consume these (capture-bounty,
* destruction-of-the-environment, etc.) ship in a follow-up wave;
* UI / WS broadcast lands in W5.5-W5.6.
*/
WhiteScore: number;
BlackScore: number;
/**
* Wave-5 (thressgame-100, decision F) — `on-resource-changed`
* hook list. Stored on `GAME_ENTITY`. Each entry filters by
* `(player, threshold, direction)` and runs the inner primitive
* list when the matching score crosses the threshold.
*
* Fired SYNCHRONOUSLY from inside `add-resource` /
* `spend-resource` apply via `fireOnResourceChangedHooks`
* (triggers.ts) — distinct from the W2 `on-attr-expire`
* dispatcher which is batched per turn boundary at stage 13.
* Synchronous fire matches author intent ("react to the score
* change immediately") and avoids needing a separate dispatcher
* stage. The cascade-depth cap (8) bounds re-entrant chains
* where a hook arm itself contains add-resource/spend-resource.
*/
OnResourceChangedHooks: readonly OnResourceChangedHookEntry[];
/**
* Wave-4 (thressgame-100, decision E) — `on-piece-pair-link-broken`
* hook list. Stored on `GAME_ENTITY` (game-level — the rule
@ -924,6 +972,31 @@ export interface OnAttrExpireHookEntry {
readonly primitives: readonly EffectPrimitiveNode[];
}
/**
* Wave-5 (thressgame-100, decision F) — single entry in
* {@link ChessAttrMap.OnResourceChangedHooks}. Stored on
* `GAME_ENTITY`. Pairs the source `descriptorId` with the
* `(player, threshold, direction)` filter and the inner primitive
* list to run when the matching score crosses the threshold.
*
* Crossing semantics (inclusive on the new-side):
* - `direction: "up"` — previous < threshold AND new >= threshold
* - `direction: "down"` — previous > threshold AND new <= threshold
* - `direction: "any"` — either crossing fires
*
* Storage shape mirrors {@link OnAttrExpireHookEntry}: literal
* already-resolved fields (the resolver walker substitutes
* `$var` / `ctx-self-id` / arithmetic shapes BEFORE the
* primitive's `apply()` runs).
*/
export interface OnResourceChangedHookEntry {
readonly descriptorId: string;
readonly player: PieceColor;
readonly threshold: number;
readonly direction: "up" | "down" | "any";
readonly primitives: readonly EffectPrimitiveNode[];
}
/**
* Wave-4 (thressgame-100, decision E) — single entry in
* {@link ChessAttrMap.OnPiecePairLinkBrokenHooks}. Stored on

25
packages/chess/src/ui/GameView.tsx
View file

@ -13,6 +13,7 @@ import type { GameResult } from '../engine';
import type { LegalMove } from '../rules/types';
import type { ChessEngine } from '../engine';
import type { EntityId } from '@paratype/rete';
import { GAME_ENTITY } from '../schema';
import { TRANSFERABLE_ROYALTY_ID } from '../presets/transferable-royalty.js';
import { isInCheck } from '../rules/check';
import { useEffect, useRef, useState, useMemo } from 'react';
@ -316,6 +317,19 @@ function GameLayout({
const turnAsColor = turn as 'white' | 'black';
const isCheck =
engine !== null ? isInCheck(engine.session, turnAsColor) : false;
// Economy scores
const whiteScore = engine !== null ? (engine.session.get(GAME_ENTITY, "WhiteScore") as number | undefined) ?? 0 : 0;
const blackScore = engine !== null ? (engine.session.get(GAME_ENTITY, "BlackScore") as number | undefined) ?? 0 : 0;
// Only show economy scores if either player has > 0 OR if any economy preset/modifier is active
// We can detect economy presence by checking if any OnResourceChangedHooks exist
const hasEconomyActive = engine !== null && (
whiteScore !== 0 ||
blackScore !== 0 ||
engine.session.contains(GAME_ENTITY, "OnResourceChangedHooks")
);
const checkedKingSquare: number | null = (() => {
if (!isCheck) return null;
// Find the (king, current-turn-color) entity. facts is unordered
@ -509,6 +523,17 @@ function GameLayout({
hasTransferRemaining={hasTransferRemaining}
onTransferRoyaltyClick={() => setActionMode({ kind: "transfer-royalty-pick-from" })}
/>
{hasEconomyActive && (
<div className="flex items-center gap-2 text-sm ml-2">
<span className="px-2 py-0.5 rounded border border-neutral-300 bg-white shadow-sm font-semibold text-neutral-800" data-testid="score-white">
⚪ {whiteScore}
</span>
<span className="px-2 py-0.5 rounded border border-neutral-700 bg-neutral-900 shadow-sm font-semibold text-white" data-testid="score-black">
⚫ {blackScore}
</span>
</div>
)}
</div>
<div className="flex items-center gap-3">

25
packages/chess/src/ui/ParamField.snapshot.test.tsx
View file

@ -264,6 +264,31 @@ const SAMPLE_PARAMS: Record<PrimitiveKind, unknown> = {
{ kind: "add-to-attribute", params: { attr: "Hp", delta: 5 } },
],
},
"add-resource": { player: "white", amount: 5 },
"spend-resource": {
player: "white",
amount: 5,
then: [
{
kind: "place-piece",
params: { pieceType: "queen", color: "white", square: 28 },
},
],
else: [
{ kind: "add-to-attribute", params: { attr: "Hp", delta: 1 } },
],
},
"on-resource-changed": {
player: "white",
threshold: 10,
direction: "up",
primitives: [
{
kind: "place-piece",
params: { pieceType: "queen", color: "white", square: 28 },
},
],
},
};
/**