@rpgm-tools/neo-angband-core 0.18.0 → 0.19.0

package/dist/obj/rune-registry.js

@@ -0,0 +1,161 @@
+/**
+ * The RUNE registry: every question core asks about a rune, plus the "You feel
+ * stronger!" line a modifier prints on wield.
+ *
+ * WHY THIS IS A REGISTRY, and why it is a harder closure than the four before
+ * it. A rune is the unit of object knowledge - what the player learns, what an
+ * item is found to carry, what the recall screen names and describes. Six
+ * places in `knowledge.ts` decided all of it, and five of them dispatched on
+ * `rune.variety`, which was a CLOSED TYPESCRIPT UNION of seven string literals.
+ *
+ * A union is closed in a way a switch is not. A switch has a `default` arm that
+ * a mod's key reaches and fails at, which is at least a place to stand; a union
+ * refuses the key at the type level, so a mod could not coin a variety at all
+ * and no arm was ever reached to fail. `tools/switch-census.json` saw none of
+ * this - it counts `switch` statements, all five of these are under its 8-case
+ * threshold, and it counts neither a union type's existence nor its size. The
+ * census recorded ONE row for this file, `modMessage`. That is the same lesson
+ * gap 28 charged for in a new shape: the census measures SYNTAX, a gap is about
+ * REACH.
+ *
+ * The six closed decisions, and what each cost a mod-coined rune:
+ *
+ *   - `runeDesc` - the recall line. No arm meant no description at all.
+ *   - `runeName` - the display decoration ("<x> brand", "slay <x>"). Upstream's
+ *     own `default` returns the bare name, so this one had a real fallback and
+ *     still does; it is the only one of the six that did.
+ *   - `playerKnowsRune` / `playerLearnRune` - the knowledge pair. A mod's rune
+ *     was unknowable AND unlearnable, which is worse than either alone: it
+ *     could never appear as learned, and `objectRunesKnown` therefore treated
+ *     any object carrying one as permanently un-assessed.
+ *   - `objectHasRune` - whether an item carries it. Always no.
+ *   - `modMessage` - the flavour line on noticing a modifier. The only OBJ_MOD
+ *     switch in the tree, out of 114 `OBJ_MOD.*` references. A mod-coined
+ *     modifier was learned in silence.
+ *
+ * WHERE A MOD'S RUNE KNOWLEDGE LIVES, which is the question that made this
+ * conversion different from the four before it. `playerKnowsRune` reads typed
+ * stores on `p.objKnown` - `modifiers[]`, `elInfo[]`, `flags` - all sized from
+ * core's fixed-arity enums, so there is no slot for a mod's rune and growing
+ * that arity is exactly what `mod/vocabulary.ts` was built to avoid (see its
+ * header for the W2.3 architecture decision). The answer is that this registry
+ * needs NO new store: `knows` and `learn` are handed the player, and a mod
+ * keeps its own per-entity values in its own `VocabularyRegistry`, which
+ * already persists into that mod's opaque save bag. So the seam stays a pure
+ * dispatch table and there is one mechanism for mod-owned per-entity state, not
+ * two.
+ *
+ * THE PRODUCER IS PART OF THE SEAM, not an extra. `buildRuneList` is what every
+ * consumer enumerates - the knowledge screens, `objectRunesKnown`, and
+ * EF_IDENTIFY's random unknown rune - so six handler tables with no way to get
+ * a rune INTO that list would be a seam its own callers walk past, which is the
+ * failure three of the five previous conversions each turned up in a different
+ * place. `contribute` is the door: core builds its list, then every contributor
+ * appends.
+ *
+ * RNG: `objectFindUnknownRune` draws `randint0(poss.length)` over the list, so
+ * a contributor that adds runes DOES move that draw - by design, since the mod
+ * is adding content and its rune is now genuinely a candidate. With no mod
+ * loaded the list is byte-identical to before, which is what the parity claim
+ * needs; `rune-vectors.json` holds all 99 rows.
+ *
+ * WHY MODULE-LEVEL. The same 2026-08-09 ruling behind `EffectInfoRegistry`,
+ * `RandartRegistry` and `TvalRegistry`: disabling a mod always takes effect on
+ * the next RELOAD, so a module-level table cannot violate the mod default
+ * policy. `resetRuneRegistry()` restores core's arms without a fresh realm and
+ * has no production caller by design.
+ */
+/* ------------------------------------------------------------------ *
+ * The tables.
+ * ------------------------------------------------------------------ */
+/**
+ * One keyed table. The same shape as `TvalTable` and for the same reason: six
+ * hand-copied blocks would be six places for a capability check to go missing.
+ */
+export class RuneTable {
+    table = new Map();
+    /** Install (or replace) the handler for one key. */
+    set(key, handler) {
+        this.table.set(key, handler);
+    }
+    /**
+     * The handler installed right now, or null. This is what a mod calls to WRAP
+     * core rather than shadow it - keep what is returned, install its own, call
+     * through.
+     */
+    handlerFor(key) {
+        return this.table.get(key) ?? null;
+    }
+    /** Whether anything handles this key. */
+    has(key) {
+        return this.table.has(key);
+    }
+    /** Every key handled, in registration order (core's first). */
+    keys() {
+        return [...this.table.keys()];
+    }
+}
+/** Everything core asks about a rune, in six tables plus one producer. */
+export class RuneRegistry {
+    /** `rune_desc`, keyed on variety. */
+    desc = new RuneTable();
+    /** `player_knows_rune`, keyed on variety. */
+    knows = new RuneTable();
+    /** `object_has_rune`, keyed on variety. */
+    objectHas = new RuneTable();
+    /** `player_learn_rune`, keyed on variety. */
+    learn = new RuneTable();
+    /** `rune_name`'s decoration, keyed on variety. Absent means the bare name. */
+    name = new RuneTable();
+    /** `mod_message`, keyed on the OBJ_MOD index. */
+    modMessage = new RuneTable();
+    /** Extra runes for `buildRuneList`, in registration order. */
+    contributors = [];
+    /** Add a source of runes to the list every consumer enumerates. */
+    contribute(source) {
+        this.contributors.push(source);
+    }
+    /** Every contributed rune, in registration order. Core's list comes first. */
+    contributed(env) {
+        const out = [];
+        for (const source of this.contributors)
+            out.push(...source(env));
+        return out;
+    }
+    /** How many contributors are installed (for tests and the conflict report). */
+    contributorCount() {
+        return this.contributors.length;
+    }
+}
+/* ------------------------------------------------------------------ *
+ * The live registry.
+ * ------------------------------------------------------------------ */
+/**
+ * Core's own seeders. `knowledge.ts` both OWNS these tables and is the only
+ * module that reads them, so "the module is loaded" and "core's arms are
+ * installed" cannot come apart - a seeder somebody has to remember to call is
+ * one that gets forgotten on a path, and the failure here would be silent and
+ * total: no rune knowable, nothing learnable, every object permanently
+ * un-assessed.
+ */
+const seeders = [];
+let live = new RuneRegistry();
+/** Install a set of core arms, now and on every reset. A MOD never calls this. */
+export function seedRune(seed) {
+    seeders.push(seed);
+    seed(live);
+}
+/** The live registry. Module-level; see this file's header for why that is safe. */
+export function runeRegistry() {
+    return live;
+}
+/**
+ * Back to core's arms alone, dropping every mod registration - the same state a
+ * reload produces, without a fresh realm. No production caller by design.
+ */
+export function resetRuneRegistry() {
+    live = new RuneRegistry();
+    for (const seed of seeders)
+        seed(live);
+}
+//# sourceMappingURL=rune-registry.js.map

package/dist/obj/rune-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rune-registry.js","sourceRoot":"","sources":["../../src/obj/rune-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AAiGH;;wEAEwE;AAExE;;;GAGG;AACH,MAAM,OAAO,SAAS;IACH,KAAK,GAAG,IAAI,GAAG,EAAQ,CAAC;IAEzC,oDAAoD;IACpD,GAAG,CAAC,GAAM,EAAE,OAAU;QACpB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC/B,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,GAAM;QACf,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC;IACrC,CAAC;IAED,yCAAyC;IACzC,GAAG,CAAC,GAAM;QACR,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7B,CAAC;IAED,+DAA+D;IAC/D,IAAI;QACF,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IAChC,CAAC;CACF;AAED,0EAA0E;AAC1E,MAAM,OAAO,YAAY;IACvB,qCAAqC;IAC5B,IAAI,GAAG,IAAI,SAAS,EAAgC,CAAC;IAC9D,6CAA6C;IACpC,KAAK,GAAG,IAAI,SAAS,EAAiC,CAAC;IAChE,2CAA2C;IAClC,SAAS,GAAG,IAAI,SAAS,EAAqC,CAAC;IACxE,6CAA6C;IACpC,KAAK,GAAG,IAAI,SAAS,EAAiC,CAAC;IAChE,8EAA8E;IACrE,IAAI,GAAG,IAAI,SAAS,EAAgC,CAAC;IAC9D,iDAAiD;IACxC,UAAU,GAAG,IAAI,SAAS,EAA6B,CAAC;IAEjE,8DAA8D;IAC7C,YAAY,GAAsB,EAAE,CAAC;IAEtD,mEAAmE;IACnE,UAAU,CAAC,MAAuB;QAChC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IAED,8EAA8E;IAC9E,WAAW,CAAC,GAAY;QACtB,MAAM,GAAG,GAAW,EAAE,CAAC;QACvB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,YAAY;YAAE,GAAG,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;QACjE,OAAO,GAAG,CAAC;IACb,CAAC;IAED,+EAA+E;IAC/E,gBAAgB;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;IAClC,CAAC;CACF;AAED;;wEAEwE;AAExE;;;;;;;GAOG;AACH,MAAM,OAAO,GAAuC,EAAE,CAAC;AAEvD,IAAI,IAAI,GAAG,IAAI,YAAY,EAAE,CAAC;AAE9B,kFAAkF;AAClF,MAAM,UAAU,QAAQ,CAAC,IAAiC;IACxD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnB,IAAI,CAAC,IAAI,CAAC,CAAC;AACb,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,YAAY;IAC1B,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB;IAC/B,IAAI,GAAG,IAAI,YAAY,EAAE,CAAC;IAC1B,KAAK,MAAM,IAAI,IAAI,OAAO;QAAE,IAAI,CAAC,IAAI,CAAC,CAAC;AACzC,CAAC"}

package/dist/obj/rune-vectors.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Golden vectors for the rune layer: what every rune in the shipped pack is
+ * CALLED, what it READS as, whether an object carries it, whether the player
+ * knows it, what learning it PRINTS, and the "You feel stronger!" line every
+ * modifier prints on wield.
+ *
+ * RECORDED BEFORE `RuneRegistry` EXISTED, which is the only reason they are
+ * evidence. A determinism test that runs the same function twice in one process
+ * cannot fail across a refactor - agreement is symmetric. These rows were
+ * produced by the six closed switches (`runeDesc`, `playerKnowsRune`,
+ * `objectHasRune`, `playerLearnRune`, `runeName`, `modMessage`) and replayed
+ * against whatever answers those questions afterwards.
+ *
+ * NO RNG ANYWHERE, measured rather than assumed: every value below is a string
+ * or a boolean derived from a pack record and a knowledge store. So the
+ * 2026-08-09 relaxation to gameplay parity buys this conversion nothing - there
+ * is no stream to move - and the grid can be exhaustive instead of sampled.
+ *
+ * WHAT THE GRID DELIBERATELY COVERS, because a rune grid has an easy way to
+ * look complete and measure nothing:
+ *
+ *   - EVERY rune `buildRuneList` produces, not a sample. The list de-duplicates
+ *     brands by name and slays by same-monsters group and skips five flag
+ *     subtypes, so its length is a fact about the pack that a hand-written list
+ *     would freeze wrongly.
+ *   - Learning each rune TWICE. The second call must return false; a dispatch
+ *     table that learned unconditionally would pass a once-only grid.
+ *   - `objectHasRune` against an object carrying EVERY rune and against a bare
+ *     one. One object answering `true` everywhere is not a test - the bare
+ *     object is what makes each `true` mean something.
+ *   - Both SIGNS of every modifier. `modMessage`'s arms differ by sign
+ *     ("stronger" / "weaker") and two of the eleven ignore sign entirely
+ *     (INFRA, LIGHT), which a positive-only grid could not tell apart.
+ */
+import type { GameObject } from "./object.js";
+import type { Player } from "../player/player.js";
+import type { RuneEnv } from "./knowledge.js";
+/** One rune's recorded answers. */
+export interface RuneVectorRow {
+    /** `runeKey` - the save-stable identity, `variety:name`. */
+    key: string;
+    variety: string;
+    index: number;
+    name: string;
+    /** `runeName` - the decorated display name. */
+    display: string;
+    /** `runeDesc` - the recall line. */
+    desc: string;
+    /** `playerKnowsRune` on a fresh character. */
+    knowsBefore: boolean;
+    /** `playerLearnRune(..., message: true)` - did it learn anything. */
+    learned: boolean;
+    /** What that learn printed. */
+    messages: string[];
+    /** `playerKnowsRune` after. */
+    knowsAfter: boolean;
+    /** Learning it a second time. False for every rune upstream. */
+    learnedAgain: boolean;
+    /** `objectHasRune` against an object carrying every rune in the list. */
+    hasOnLoaded: boolean;
+    /** `objectHasRune` against an untouched object of the same kind. */
+    hasOnBare: boolean;
+}
+/** One modifier's wield messages, by sign. */
+export interface ModMessageRow {
+    /** The OBJ_MOD index. */
+    mod: number;
+    /** The modifier's rune name in the pack, or "" when it has none. */
+    name: string;
+    /** What `objectLearnOnWield` printed for a +2 of this modifier. */
+    positive: string[];
+    /** ... and for a -2. */
+    negative: string[];
+}
+/** The whole recorded grid. */
+export interface RuneVectors {
+    runes: RuneVectorRow[];
+    modMessages: ModMessageRow[];
+}
+/** The fixture surface the producer needs (see `rune-vectors.fixtures.ts`). */
+export interface RuneVectorWorldLike {
+    env: RuneEnv;
+    player(): Player;
+    drain(): string[];
+    object(tval: number): GameObject;
+    blankObject(tval: number): GameObject;
+}
+/**
+ * Produce the grid. ONE implementation, called by both the generator and the
+ * test, so the recorded file and the replay cannot drift into measuring
+ * different things.
+ *
+ * `tval` picks the object every `objectHasRune` question is asked against. A
+ * RING is used because it is jewellery (so `objectHasStandardToH` has nothing
+ * to say about it) and carries no base plusses of its own, which keeps the bare
+ * row honestly negative.
+ */
+export declare function recordRuneVectors(world: RuneVectorWorldLike, tval: number): RuneVectors;
+//# sourceMappingURL=rune-vectors.d.ts.map

package/dist/obj/rune-vectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rune-vectors.d.ts","sourceRoot":"","sources":["../../src/obj/rune-vectors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAcH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,mCAAmC;AACnC,MAAM,WAAW,aAAa;IAC5B,4DAA4D;IAC5D,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,WAAW,EAAE,OAAO,CAAC;IACrB,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,+BAA+B;IAC/B,UAAU,EAAE,OAAO,CAAC;IACpB,gEAAgE;IAChE,YAAY,EAAE,OAAO,CAAC;IACtB,yEAAyE;IACzE,WAAW,EAAE,OAAO,CAAC;IACrB,oEAAoE;IACpE,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,8CAA8C;AAC9C,MAAM,WAAW,aAAa;IAC5B,yBAAyB;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,wBAAwB;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,+BAA+B;AAC/B,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,WAAW,EAAE,aAAa,EAAE,CAAC;CAC9B;AAED,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,IAAI,MAAM,CAAC;IACjB,KAAK,IAAI,MAAM,EAAE,CAAC;IAClB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IACjC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CACvC;AAoDD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE,MAAM,GACX,WAAW,CA4Db"}

package/dist/obj/rune-vectors.fixtures.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The world the rune vectors are recorded against, built from the real shipped
+ * content pack.
+ *
+ * SEPARATE FILE, and it reads the disk: keeping `node:fs` out of
+ * `rune-vectors.ts` means the row producer stays importable from anywhere. ONE
+ * copy, shared by `rune-vectors.test.ts` and by `scripts/gen-rune-vectors.mjs`,
+ * so the test and the generator cannot disagree about what they are measuring.
+ *
+ * THE REAL PACK rather than synthetic tables, on purpose. `buildRuneList`
+ * de-duplicates brands by name and slays by same-monsters group, and skips five
+ * flag subtypes - a hand-built table would be an assertion about what the pack
+ * producer emits, and an unchecked one. `elementNames` is derived the way
+ * `session/game.ts:741` derives it (projections, sliced to ELEM_MAX), not
+ * hand-listed: two nearby test fixtures hard-code four element names, which is
+ * enough for a targeted test and would silently shorten this grid by ten.
+ */
+import { ObjRegistry } from "./bind.js";
+import type { Player } from "../player/player.js";
+import type { GameObject } from "./object.js";
+import type { RuneEnv } from "./knowledge.js";
+/** Everything one rune vector run needs. */
+export interface RuneVectorWorld {
+    /** A fresh player with empty rune knowledge, marked as playing. */
+    player(): Player;
+    /** The env every rune call is made against; `msg` pushes into `messages`. */
+    env: RuneEnv;
+    /** Messages emitted since the last `drain()`. */
+    drain(): string[];
+    /** A freshly prepared object of the first ordinary kind of a given tval. */
+    object(tval: number): GameObject;
+    /** object_new: the same kind, zeroed, carrying nothing of its own. */
+    blankObject(tval: number): GameObject;
+}
+/**
+ * Build the fixture world. The registry binds every object table plus the
+ * projections `elementNames` is derived from; nothing here needs an RNG stream,
+ * so the one `Rng` exists only because `makeRuneEnv` wants a `randcalcVaries`
+ * and is seeded fixed.
+ */
+export declare function runeVectorWorld(): RuneVectorWorld & {
+    reg: ObjRegistry;
+};
+//# sourceMappingURL=rune-vectors.fixtures.d.ts.map

package/dist/obj/rune-vectors.fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rune-vectors.fixtures.d.ts","sourceRoot":"","sources":["../../src/obj/rune-vectors.fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AASxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAe9C,4CAA4C;AAC5C,MAAM,WAAW,eAAe;IAC9B,mEAAmE;IACnE,MAAM,IAAI,MAAM,CAAC;IACjB,6EAA6E;IAC7E,GAAG,EAAE,OAAO,CAAC;IACb,iDAAiD;IACjD,KAAK,IAAI,MAAM,EAAE,CAAC;IAClB,4EAA4E;IAC5E,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IACjC,sEAAsE;IACtE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CACvC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,IAAI,eAAe,GAAG;IAAE,GAAG,EAAE,WAAW,CAAA;CAAE,CAgGxE"}

package/dist/obj/rune-vectors.fixtures.js

@@ -0,0 +1,125 @@
+/**
+ * The world the rune vectors are recorded against, built from the real shipped
+ * content pack.
+ *
+ * SEPARATE FILE, and it reads the disk: keeping `node:fs` out of
+ * `rune-vectors.ts` means the row producer stays importable from anywhere. ONE
+ * copy, shared by `rune-vectors.test.ts` and by `scripts/gen-rune-vectors.mjs`,
+ * so the test and the generator cannot disagree about what they are measuring.
+ *
+ * THE REAL PACK rather than synthetic tables, on purpose. `buildRuneList`
+ * de-duplicates brands by name and slays by same-monsters group, and skips five
+ * flag subtypes - a hand-built table would be an assertion about what the pack
+ * producer emits, and an unchecked one. `elementNames` is derived the way
+ * `session/game.ts:741` derives it (projections, sliced to ELEM_MAX), not
+ * hand-listed: two nearby test fixtures hard-code four element names, which is
+ * enough for a targeted test and would silently shorten this grid by ten.
+ */
+import { readFileSync } from "node:fs";
+import { ELEM_MAX } from "./types.js";
+import { ObjRegistry } from "./bind.js";
+import { bindPlayer } from "../player/bind.js";
+import { blankPlayer } from "../player/player.js";
+import { makeRuneEnv } from "./knowledge.js";
+import { bindConstants } from "../constants.js";
+import { objectNew } from "./object.js";
+import { objectPrep } from "./make.js";
+import { Rng } from "../rng.js";
+function loadJson(name) {
+    return JSON.parse(readFileSync(new URL(`../../../content/pack/${name}.json`, import.meta.url), "utf8"));
+}
+function loadRecords(name) {
+    return loadJson(name).records;
+}
+/**
+ * Build the fixture world. The registry binds every object table plus the
+ * projections `elementNames` is derived from; nothing here needs an RNG stream,
+ * so the one `Rng` exists only because `makeRuneEnv` wants a `randcalcVaries`
+ * and is seeded fixed.
+ */
+export function runeVectorWorld() {
+    const reg = new ObjRegistry({
+        objectBase: loadJson("object_base"),
+        object: loadJson("object"),
+        egoItem: loadJson("ego_item"),
+        artifact: loadJson("artifact"),
+        curse: loadJson("curse"),
+        brand: loadJson("brand"),
+        slay: loadJson("slay"),
+        activation: loadJson("activation"),
+        objectProperty: loadJson("object_property"),
+        flavor: loadJson("flavor"),
+    });
+    const players = bindPlayer({
+        races: loadRecords("p_race"),
+        classes: loadRecords("class"),
+        properties: loadRecords("player_property"),
+        timed: loadRecords("player_timed"),
+        shapes: loadRecords("shape"),
+        bodies: loadRecords("body"),
+        history: loadRecords("history"),
+        realms: loadRecords("realm"),
+    });
+    /* session/game.ts:741 - projections sliced to ELEM_MAX, by name. */
+    const elementNames = loadRecords("projection")
+        .slice(0, ELEM_MAX)
+        .map((p) => p.name);
+    const constants = bindConstants(loadJson("constants"));
+    const messages = [];
+    const rng = new Rng(7);
+    const equipment = [];
+    const env = makeRuneEnv((slot) => equipment[slot] ?? null, (v) => rng.randcalcVaries(v), {
+        brands: reg.brands,
+        slays: reg.slays,
+        curses: reg.curses,
+        properties: reg.properties,
+        elementNames,
+        msg: (t) => messages.push(t),
+    });
+    const race = players.raceByName("Human");
+    const cls = players.classByName("Warrior");
+    const body = players.bodies[race.body];
+    return {
+        reg,
+        env,
+        player() {
+            const p = blankPlayer(race, cls, body);
+            /* modMessage is guarded by upkeep.playing (knowledge.ts:646): a wield
+             * during birth or level-feeling prints nothing. Recording with it off
+             * would produce a grid of empty message lists that could not disagree
+             * with a broken dispatch table. */
+            p.upkeep.playing = true;
+            return p;
+        },
+        drain() {
+            const out = [...messages];
+            messages.length = 0;
+            return out;
+        },
+        object(tval) {
+            /* object_prep, not object_new: object_new is a zeroed allocation whose
+             * tval is still 0, and the point of asking `objectHasRune` about a REAL
+             * item is that the item's own fields are filled in. The "maximise" aspect
+             * draws no entropy (randcalc takes the bound rather than a roll), so the
+             * grid stays RNG-free. */
+            return objectPrep(rng, reg, constants, kindOf(tval), 0, "maximise");
+        },
+        blankObject(tval) {
+            /* object_new, and the modifier-message rows need exactly this. A prepared
+             * ring of the first ordinary sval is a Ring of STRENGTH: it carries +STR
+             * and SUST_STR of its own, so wielding it learns those too and every one
+             * of the sixteen rows would carry the same four-line prefix. Four lines of
+             * constant noise in a six-line row is a grid that mostly measures the
+             * fixture. A zeroed object has exactly one modifier set - the one under
+             * test. */
+            return objectNew(kindOf(tval));
+        },
+    };
+    function kindOf(tval) {
+        const kind = reg.kinds.find((k) => k.tval === tval && k.kidx < reg.ordinaryKindCount);
+        if (!kind)
+            throw new Error(`no ordinary kind for tval ${tval}`);
+        return kind;
+    }
+}
+//# sourceMappingURL=rune-vectors.fixtures.js.map

package/dist/obj/rune-vectors.fixtures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rune-vectors.fixtures.js","sourceRoot":"","sources":["../../src/obj/rune-vectors.fixtures.ts"],"names":[],"mappings":"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"}

package/dist/obj/rune-vectors.js

@@ -0,0 +1,159 @@
+/**
+ * Golden vectors for the rune layer: what every rune in the shipped pack is
+ * CALLED, what it READS as, whether an object carries it, whether the player
+ * knows it, what learning it PRINTS, and the "You feel stronger!" line every
+ * modifier prints on wield.
+ *
+ * RECORDED BEFORE `RuneRegistry` EXISTED, which is the only reason they are
+ * evidence. A determinism test that runs the same function twice in one process
+ * cannot fail across a refactor - agreement is symmetric. These rows were
+ * produced by the six closed switches (`runeDesc`, `playerKnowsRune`,
+ * `objectHasRune`, `playerLearnRune`, `runeName`, `modMessage`) and replayed
+ * against whatever answers those questions afterwards.
+ *
+ * NO RNG ANYWHERE, measured rather than assumed: every value below is a string
+ * or a boolean derived from a pack record and a knowledge store. So the
+ * 2026-08-09 relaxation to gameplay parity buys this conversion nothing - there
+ * is no stream to move - and the grid can be exhaustive instead of sampled.
+ *
+ * WHAT THE GRID DELIBERATELY COVERS, because a rune grid has an easy way to
+ * look complete and measure nothing:
+ *
+ *   - EVERY rune `buildRuneList` produces, not a sample. The list de-duplicates
+ *     brands by name and slays by same-monsters group and skips five flag
+ *     subtypes, so its length is a fact about the pack that a hand-written list
+ *     would freeze wrongly.
+ *   - Learning each rune TWICE. The second call must return false; a dispatch
+ *     table that learned unconditionally would pass a once-only grid.
+ *   - `objectHasRune` against an object carrying EVERY rune and against a bare
+ *     one. One object answering `true` everywhere is not a test - the bare
+ *     object is what makes each `true` mean something.
+ *   - Both SIGNS of every modifier. `modMessage`'s arms differ by sign
+ *     ("stronger" / "weaker") and two of the eleven ignore sign entirely
+ *     (INFRA, LIGHT), which a positive-only grid could not tell apart.
+ */
+import { OBJ_MOD_MAX } from "./types.js";
+import { buildRuneList, objectHasRune, objectLearnOnWield, playerKnowsRune, playerLearnRune, runeDesc, runeKey, runeName, } from "./knowledge.js";
+/**
+ * Write one rune onto an object, so `objectHasRune` has something to find.
+ *
+ * This is the one place the grid encodes per-variety knowledge, and it is
+ * deliberately the WRITE side rather than the read side: `objectHasRune` is
+ * what is being measured, so the fixture must reach the object's fields
+ * directly instead of asking the function under test to describe itself.
+ */
+function applyRune(env, obj, rune) {
+    switch (rune.variety) {
+        case "combat":
+            if (rune.index === 0)
+                obj.toA = 1;
+            else if (rune.index === 1)
+                obj.toH = 1;
+            else
+                obj.toD = 1;
+            return;
+        case "mod":
+            obj.modifiers[rune.index] = 1;
+            return;
+        case "resist": {
+            const info = obj.elInfo[rune.index];
+            if (info)
+                info.resLevel = 1;
+            return;
+        }
+        case "brand": {
+            obj.brands ??= new Array(env.brands.length).fill(false);
+            obj.brands[rune.index] = true;
+            return;
+        }
+        case "slay": {
+            obj.slays ??= new Array(env.slays.length).fill(false);
+            obj.slays[rune.index] = true;
+            return;
+        }
+        case "curse": {
+            obj.curses ??= Array.from({ length: env.curses.length }, () => ({
+                power: 0,
+                timeout: 0,
+            }));
+            const c = obj.curses[rune.index];
+            if (c)
+                c.power = 1;
+            return;
+        }
+        case "flag":
+            obj.flags.on(rune.index);
+            return;
+        default:
+            return;
+    }
+}
+/**
+ * Produce the grid. ONE implementation, called by both the generator and the
+ * test, so the recorded file and the replay cannot drift into measuring
+ * different things.
+ *
+ * `tval` picks the object every `objectHasRune` question is asked against. A
+ * RING is used because it is jewellery (so `objectHasStandardToH` has nothing
+ * to say about it) and carries no base plusses of its own, which keeps the bare
+ * row honestly negative.
+ */
+export function recordRuneVectors(world, tval) {
+    const { env } = world;
+    const runes = buildRuneList(env);
+    const loaded = world.object(tval);
+    for (const rune of runes)
+        applyRune(env, loaded, rune);
+    const bare = world.object(tval);
+    const rows = runes.map((rune) => {
+        const p = world.player();
+        world.drain();
+        const knowsBefore = playerKnowsRune(p, rune);
+        const learned = playerLearnRune(p, env, rune, true);
+        const messages = world.drain();
+        const knowsAfter = playerKnowsRune(p, rune);
+        const learnedAgain = playerLearnRune(p, env, rune, true);
+        world.drain();
+        return {
+            key: runeKey(rune),
+            variety: rune.variety,
+            index: rune.index,
+            name: rune.name,
+            display: runeName(rune),
+            desc: runeDesc(env, rune),
+            knowsBefore,
+            learned,
+            messages,
+            knowsAfter,
+            learnedAgain,
+            hasOnLoaded: objectHasRune(env, loaded, rune),
+            hasOnBare: objectHasRune(env, bare, rune),
+        };
+    });
+    /* The modifier names, taken from the rune list rather than looked up a
+     * second way: two producers of the same string is two chances to disagree. */
+    const modNames = new Map();
+    for (const rune of runes) {
+        if (rune.variety === "mod")
+            modNames.set(rune.index, rune.name);
+    }
+    const modMessages = [];
+    for (let mod = 0; mod < OBJ_MOD_MAX; mod++) {
+        const sign = (value) => {
+            const p = world.player();
+            const obj = world.blankObject(tval);
+            obj.modifiers[mod] = value;
+            world.drain();
+            objectLearnOnWield(p, obj, env);
+            return world.drain();
+        };
+        modMessages.push({
+            mod,
+            name: modNames.get(mod) ?? "",
+            positive: sign(2),
+            negative: sign(-2),
+        });
+    }
+    return { runes: rows, modMessages };
+}
+//# sourceMappingURL=rune-vectors.js.map

package/dist/obj/rune-vectors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rune-vectors.js","sourceRoot":"","sources":["../../src/obj/rune-vectors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EACL,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,QAAQ,EACR,OAAO,EACP,QAAQ,GACT,MAAM,gBAAgB,CAAC;AA4DxB;;;;;;;GAOG;AACH,SAAS,SAAS,CAAC,GAAY,EAAE,GAAe,EAAE,IAAU;IAC1D,QAAQ,IAAI,CAAC,OAAO,EAAE,CAAC;QACrB,KAAK,QAAQ;YACX,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC;gBAAE,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;iBAC7B,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC;gBAAE,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;;gBAClC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;YACjB,OAAO;QACT,KAAK,KAAK;YACR,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC9B,OAAO;QACT,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACpC,IAAI,IAAI;gBAAE,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;YAC5B,OAAO;QACT,CAAC;QACD,KAAK,OAAO,CAAC,CAAC,CAAC;YACb,GAAG,CAAC,MAAM,KAAK,IAAI,KAAK,CAAU,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjE,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAC9B,OAAO;QACT,CAAC;QACD,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,GAAG,CAAC,KAAK,KAAK,IAAI,KAAK,CAAU,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC/D,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAC7B,OAAO;QACT,CAAC;QACD,KAAK,OAAO,CAAC,CAAC,CAAC;YACb,GAAG,CAAC,MAAM,KAAK,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;gBAC9D,KAAK,EAAE,CAAC;gBACR,OAAO,EAAE,CAAC;aACX,CAAC,CAAC,CAAC;YACJ,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjC,IAAI,CAAC;gBAAE,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;YACnB,OAAO;QACT,CAAC;QACD,KAAK,MAAM;YACT,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACzB,OAAO;QACT;YACE,OAAO;IACX,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAC/B,KAA0B,EAC1B,IAAY;IAEZ,MAAM,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;IACtB,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IAEjC,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAClC,KAAK,MAAM,IAAI,IAAI,KAAK;QAAE,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IACvD,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAEhC,MAAM,IAAI,GAAoB,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QAC/C,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QACzB,KAAK,CAAC,KAAK,EAAE,CAAC;QACd,MAAM,WAAW,GAAG,eAAe,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QAC7C,MAAM,OAAO,GAAG,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QACpD,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;QAC/B,MAAM,UAAU,GAAG,eAAe,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QAC5C,MAAM,YAAY,GAAG,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QACzD,KAAK,CAAC,KAAK,EAAE,CAAC;QACd,OAAO;YACL,GAAG,EAAE,OAAO,CAAC,IAAI,CAAC;YAClB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC;YACvB,IAAI,EAAE,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC;YACzB,WAAW;YACX,OAAO;YACP,QAAQ;YACR,UAAU;YACV,YAAY;YACZ,WAAW,EAAE,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC;YAC7C,SAAS,EAAE,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC;SAC1C,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH;kFAC8E;IAC9E,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC3C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,OAAO,KAAK,KAAK;YAAE,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAClE,CAAC;IAED,MAAM,WAAW,GAAoB,EAAE,CAAC;IACxC,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,WAAW,EAAE,GAAG,EAAE,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,CAAC,KAAa,EAAY,EAAE;YACvC,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;YACzB,MAAM,GAAG,GAAG,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YACpC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;YAC3B,KAAK,CAAC,KAAK,EAAE,CAAC;YACd,kBAAkB,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;YAChC,OAAO,KAAK,CAAC,KAAK,EAAE,CAAC;QACvB,CAAC,CAAC;QACF,WAAW,CAAC,IAAI,CAAC;YACf,GAAG;YACH,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE;YAC7B,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;YACjB,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;SACnB,CAAC,CAAC;IACL,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;AACtC,CAAC"}