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

package/dist/obj/randart-registry.d.ts

@@ -0,0 +1,178 @@
+/**
+ * The RANDOM ARTIFACT registry: what an ability does, what an item class starts
+ * with, which bucket it counts toward, and whether an activation is redundant.
+ *
+ * WHY THIS IS A REGISTRY. `artifact.json` has always accepted a new record, so a
+ * mod could always ship a fixed artifact. What it could not do was reach the
+ * RANDOM artifact generator, which is a different thing entirely: four closed
+ * `switch` statements decided every property a randart can have, and each failed
+ * silently rather than loudly.
+ *
+ *   - `addAbilityAux` (randart-build.ts, keyed on the `ART_IDX` ability, 87
+ *     cases) - the largest dispatch in the port. A mod-coined ability index took
+ *     the default arm, which is `break`: the design loop spent power on it and
+ *     the artifact got NOTHING.
+ *   - `artifactPrep` (randart-build.ts, keyed on the base item's tval, 15) - the
+ *     starting to-hit / to-dam / AC an item class is given. An unlisted tval got
+ *     zero of each, so a mod's new item class produced randarts that started
+ *     blank and could never be told apart from a bug.
+ *   - the item-class census (randart-data.ts, keyed on tval, 14) - which
+ *     `data.*Total` bucket a standard artifact counts toward. That census feeds
+ *     the frequency table the design loop SPENDS, so a mod's item class landing
+ *     in `otherTotal` skews what every randart in the game becomes.
+ *   - the redundancy test (randart-build.ts, keyed on the `EFPROP` kind, 9) -
+ *     whether an activation only duplicates something the artifact already has.
+ *     An unknown kind takes upstream's conservative default (keep it), which is
+ *     right for core and useless to a mod that coined a new property kind.
+ *
+ * FOUR TABLES, THREE KEYS, kept separate because upstream's keys are: the
+ * ability index, the tval, and the EFPROP kind name three different things and
+ * collapsing them would force a mod to register the same behaviour twice.
+ *
+ * WHAT A HANDLER GETS, AND WHY IT IS NOT A PILE OF CALLBACKS. Every primitive
+ * core's own arms use - `addFlag`, `addMod`, `addResist`, `addBrand`, `addSlay`,
+ * `addToHit`, `addToDam`, `addToAC`, `addLowResist`, `addHighResist`,
+ * `addImmunity`, `addStat`, `addSustain`, `addDamageDice`, `addWeightMod`,
+ * `addActivation` - is exported and reachable through `ctx.core`. So the context
+ * carries STATE (the registry, the artifact, the base kind, the target power,
+ * the set data, the rng) and nothing else. A mod's handler is written exactly
+ * the way core's arms are written.
+ *
+ * That reachability was NOT free, and it is the trap this seam nearly shipped
+ * with. The helpers were exported from `randart-build.ts` but the module was
+ * never re-exported from core's index, so none of them were in `ctx.core` - a
+ * mod could register a handler and had no way to write its body. `index.ts` now
+ * exports `randart-build.js` and `randart-data.js` for exactly that reason. A
+ * seam whose primitives a mod cannot reach is a seam a mod cannot use.
+ *
+ * ORDER AND RNG. Core's handlers are the case bodies lifted unchanged, so the
+ * draw sequence is identical - which is what `randart-vectors.json` exists to
+ * prove, 834 vectors recorded before this file existed, the per-arm families
+ * carrying an RNG probe because a changed draw count is invisible in the
+ * artifact and diverges every artifact after it. A MOD's handler draws from the
+ * same `rng`, so it changes the stream from that ability onward. That is
+ * inherent in adding behaviour to generation and is why a modded game is not
+ * seed-compatible with an unmodded one.
+ *
+ * WHY MODULE-LEVEL. The same 2026-08-09 ruling that justified
+ * `EffectInfoRegistry`: disabling a mod always takes effect on the next RELOAD,
+ * so a module-level table cannot violate the mod default policy. A fresh page is
+ * a fresh module instance and the host installs each plugin at most once per
+ * realm, so a disabled mod's registrations are gone on the next boot because the
+ * table they lived in is. `resetRandartRegistry()` is the same restoration
+ * without a fresh realm; it has no production caller by design.
+ */
+import type { Rng } from "../rng.js";
+import type { ObjRegistry } from "./bind.js";
+import type { EffectObjectProperty } from "./randart-build.js";
+import type { ArtifactSetData } from "./randart-data.js";
+import type { Artifact, ObjectKind } from "./types.js";
+/** The state one `add_ability_aux` arm is given (obj-randart.c L2150). */
+export interface RandartAbilityContext {
+    /** The object registry, for the flag / brand / slay / element tables. */
+    readonly reg: ObjRegistry;
+    /** The artifact being built. Handlers mutate this. */
+    readonly art: Artifact;
+    /** The base item kind, or null when the tval/sval pair names none. */
+    readonly kind: ObjectKind | null;
+    /** The power the design loop is aiming at (gates AGGRAVATE, sizes ACTIV). */
+    readonly targetPower: number;
+    /** The measured profile of the standard set: increments, powers, frequencies. */
+    readonly data: ArtifactSetData;
+    /** The generation stream. Drawing from it moves every later artifact. */
+    readonly rng: Rng;
+}
+/**
+ * What one ability does to an artifact. Write it the way core's arms are
+ * written: call the exported `addFlag` / `addMod` / `addResist` / ... helpers,
+ * which handle the "already has it" case and the randart.log line.
+ */
+export type RandartAbilityHandler = (ctx: RandartAbilityContext) => void;
+/** The state one `artifact_prep` item-class arm is given. */
+export interface RandartPrepContext {
+    readonly reg: ObjRegistry;
+    /** The artifact, already given the base kind's own values. */
+    readonly art: Artifact;
+    /** The base item kind this artifact was built from. */
+    readonly kind: ObjectKind;
+    readonly data: ArtifactSetData;
+    readonly rng: Rng;
+}
+/**
+ * The basic stats an item class starts with. Upstream gives weapons to-hit and
+ * to-dam, armour to-AC, and everything else nothing at all - an unregistered
+ * tval takes that last arm, which is upstream's own default rather than a hole.
+ */
+export type RandartPrepHandler = (ctx: RandartPrepContext) => void;
+/**
+ * Which `data.*Total` bucket a standard artifact counts toward. This feeds the
+ * frequency table the design loop spends, so it is not bookkeeping: a class in
+ * the wrong bucket changes what every randart in the game becomes.
+ *
+ * `TV.NULL` is registered as an explicit no-op rather than left to the default,
+ * because upstream distinguishes "an empty artifact slot" from "an item class I
+ * have no bucket for" - the first counts toward nothing, the second toward
+ * `otherTotal`.
+ */
+export type RandartCensusHandler = (data: ArtifactSetData) => void;
+/** The state one redundancy arm is given (obj-randart.c L2420). */
+export interface RandartRedundancyContext {
+    readonly reg: ObjRegistry;
+    /** The artifact whose activation is on trial. */
+    readonly art: Artifact;
+    /** The summarized property this arm is judging. */
+    readonly prop: EffectObjectProperty;
+}
+/**
+ * Whether the activation is STILL redundant after considering this property.
+ * Return false the moment the activation does something the artifact does not
+ * already do - upstream stops at the first `false` and keeps the activation.
+ * An unregistered kind takes upstream's conservative default (not redundant),
+ * which is the safe direction: a kept activation is a weaker artifact than
+ * intended, a dropped one is a missing power.
+ */
+export type RandartRedundancyHandler = (ctx: RandartRedundancyContext) => boolean;
+/**
+ * One keyed table. Written once and used four times, because the four differ
+ * only in their key and handler types.
+ */
+export declare class RandartTable<K, H> {
+    private readonly table;
+    /** Install (or replace) the handler for one key. */
+    set(key: K, handler: H): void;
+    /**
+     * The handler installed for a key right now, or null. This is what a mod
+     * calls to WRAP core - keep the returned handler, install its own, and call
+     * through. Wrapping matters more here than almost anywhere else: an ability
+     * that draws a different NUMBER of random values changes every artifact
+     * generated after it, so a handler that reimplements core's from scratch and
+     * gets the draw count wrong is a whole-set divergence, not a local one.
+     */
+    handlerFor(key: K): H | null;
+    /** Whether anything handles this key. */
+    has(key: K): boolean;
+    /** Every key handled, in registration order (core's first). */
+    keys(): readonly K[];
+}
+/** Random artifact construction, in four tables under three keys. */
+export declare class RandartRegistry {
+    /** What an ability does, keyed on the ART_IDX index. */
+    readonly abilities: RandartTable<number, RandartAbilityHandler>;
+    /** An item class's starting stats, keyed on tval. */
+    readonly prep: RandartTable<number, RandartPrepHandler>;
+    /** The item-class census bucket, keyed on tval. */
+    readonly census: RandartTable<number, RandartCensusHandler>;
+    /** Activation redundancy, keyed on the EFPROP kind. */
+    readonly redundancy: RandartTable<number, RandartRedundancyHandler>;
+}
+/** Install a set of core arms, now and on every reset. A MOD never calls this. */
+export declare function seedRandart(seed: (reg: RandartRegistry) => void): void;
+/** The live registry. Module-level; see this file's header for why that is safe. */
+export declare function randartRegistry(): RandartRegistry;
+/**
+ * Back to core's arms alone, dropping every mod registration - the same state a
+ * reload produces, without needing a fresh realm. No production caller by
+ * design; see this file's header.
+ */
+export declare function resetRandartRegistry(): void;
+//# sourceMappingURL=randart-registry.d.ts.map

package/dist/obj/randart-registry.d.ts.map

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

package/dist/obj/randart-registry.js

@@ -0,0 +1,140 @@
+/**
+ * The RANDOM ARTIFACT registry: what an ability does, what an item class starts
+ * with, which bucket it counts toward, and whether an activation is redundant.
+ *
+ * WHY THIS IS A REGISTRY. `artifact.json` has always accepted a new record, so a
+ * mod could always ship a fixed artifact. What it could not do was reach the
+ * RANDOM artifact generator, which is a different thing entirely: four closed
+ * `switch` statements decided every property a randart can have, and each failed
+ * silently rather than loudly.
+ *
+ *   - `addAbilityAux` (randart-build.ts, keyed on the `ART_IDX` ability, 87
+ *     cases) - the largest dispatch in the port. A mod-coined ability index took
+ *     the default arm, which is `break`: the design loop spent power on it and
+ *     the artifact got NOTHING.
+ *   - `artifactPrep` (randart-build.ts, keyed on the base item's tval, 15) - the
+ *     starting to-hit / to-dam / AC an item class is given. An unlisted tval got
+ *     zero of each, so a mod's new item class produced randarts that started
+ *     blank and could never be told apart from a bug.
+ *   - the item-class census (randart-data.ts, keyed on tval, 14) - which
+ *     `data.*Total` bucket a standard artifact counts toward. That census feeds
+ *     the frequency table the design loop SPENDS, so a mod's item class landing
+ *     in `otherTotal` skews what every randart in the game becomes.
+ *   - the redundancy test (randart-build.ts, keyed on the `EFPROP` kind, 9) -
+ *     whether an activation only duplicates something the artifact already has.
+ *     An unknown kind takes upstream's conservative default (keep it), which is
+ *     right for core and useless to a mod that coined a new property kind.
+ *
+ * FOUR TABLES, THREE KEYS, kept separate because upstream's keys are: the
+ * ability index, the tval, and the EFPROP kind name three different things and
+ * collapsing them would force a mod to register the same behaviour twice.
+ *
+ * WHAT A HANDLER GETS, AND WHY IT IS NOT A PILE OF CALLBACKS. Every primitive
+ * core's own arms use - `addFlag`, `addMod`, `addResist`, `addBrand`, `addSlay`,
+ * `addToHit`, `addToDam`, `addToAC`, `addLowResist`, `addHighResist`,
+ * `addImmunity`, `addStat`, `addSustain`, `addDamageDice`, `addWeightMod`,
+ * `addActivation` - is exported and reachable through `ctx.core`. So the context
+ * carries STATE (the registry, the artifact, the base kind, the target power,
+ * the set data, the rng) and nothing else. A mod's handler is written exactly
+ * the way core's arms are written.
+ *
+ * That reachability was NOT free, and it is the trap this seam nearly shipped
+ * with. The helpers were exported from `randart-build.ts` but the module was
+ * never re-exported from core's index, so none of them were in `ctx.core` - a
+ * mod could register a handler and had no way to write its body. `index.ts` now
+ * exports `randart-build.js` and `randart-data.js` for exactly that reason. A
+ * seam whose primitives a mod cannot reach is a seam a mod cannot use.
+ *
+ * ORDER AND RNG. Core's handlers are the case bodies lifted unchanged, so the
+ * draw sequence is identical - which is what `randart-vectors.json` exists to
+ * prove, 834 vectors recorded before this file existed, the per-arm families
+ * carrying an RNG probe because a changed draw count is invisible in the
+ * artifact and diverges every artifact after it. A MOD's handler draws from the
+ * same `rng`, so it changes the stream from that ability onward. That is
+ * inherent in adding behaviour to generation and is why a modded game is not
+ * seed-compatible with an unmodded one.
+ *
+ * WHY MODULE-LEVEL. The same 2026-08-09 ruling that justified
+ * `EffectInfoRegistry`: disabling a mod always takes effect on the next RELOAD,
+ * so a module-level table cannot violate the mod default policy. A fresh page is
+ * a fresh module instance and the host installs each plugin at most once per
+ * realm, so a disabled mod's registrations are gone on the next boot because the
+ * table they lived in is. `resetRandartRegistry()` is the same restoration
+ * without a fresh realm; it has no production caller by design.
+ */
+/* ------------------------------------------------------------------ *
+ * The tables.
+ * ------------------------------------------------------------------ */
+/**
+ * One keyed table. Written once and used four times, because the four differ
+ * only in their key and handler types.
+ */
+export class RandartTable {
+    table = new Map();
+    /** Install (or replace) the handler for one key. */
+    set(key, handler) {
+        this.table.set(key, handler);
+    }
+    /**
+     * The handler installed for a key right now, or null. This is what a mod
+     * calls to WRAP core - keep the returned handler, install its own, and call
+     * through. Wrapping matters more here than almost anywhere else: an ability
+     * that draws a different NUMBER of random values changes every artifact
+     * generated after it, so a handler that reimplements core's from scratch and
+     * gets the draw count wrong is a whole-set divergence, not a local one.
+     */
+    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()];
+    }
+}
+/** Random artifact construction, in four tables under three keys. */
+export class RandartRegistry {
+    /** What an ability does, keyed on the ART_IDX index. */
+    abilities = new RandartTable();
+    /** An item class's starting stats, keyed on tval. */
+    prep = new RandartTable();
+    /** The item-class census bucket, keyed on tval. */
+    census = new RandartTable();
+    /** Activation redundancy, keyed on the EFPROP kind. */
+    redundancy = new RandartTable();
+}
+/* ------------------------------------------------------------------ *
+ * The live registry.
+ * ------------------------------------------------------------------ */
+/**
+ * Core's own seeders. The modules that OWN a table register their arms here at
+ * import time, and each is also the only module that READS its table - so "the
+ * module is loaded" and "core's arms are installed" cannot come apart. A seeder
+ * somebody has to remember to call is a seeder that gets forgotten on one path,
+ * and the failure mode here is silent: every randart comes out blank.
+ */
+const seeders = [];
+let live = new RandartRegistry();
+/** Install a set of core arms, now and on every reset. A MOD never calls this. */
+export function seedRandart(seed) {
+    seeders.push(seed);
+    seed(live);
+}
+/** The live registry. Module-level; see this file's header for why that is safe. */
+export function randartRegistry() {
+    return live;
+}
+/**
+ * Back to core's arms alone, dropping every mod registration - the same state a
+ * reload produces, without needing a fresh realm. No production caller by
+ * design; see this file's header.
+ */
+export function resetRandartRegistry() {
+    live = new RandartRegistry();
+    for (const seed of seeders)
+        seed(live);
+}
+//# sourceMappingURL=randart-registry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"randart-registry.js","sourceRoot":"","sources":["../../src/obj/randart-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAkGH;;wEAEwE;AAExE;;;GAGG;AACH,MAAM,OAAO,YAAY;IACN,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;;;;;;;OAOG;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,qEAAqE;AACrE,MAAM,OAAO,eAAe;IAC1B,wDAAwD;IAC/C,SAAS,GAAG,IAAI,YAAY,EAAiC,CAAC;IACvE,qDAAqD;IAC5C,IAAI,GAAG,IAAI,YAAY,EAA8B,CAAC;IAC/D,mDAAmD;IAC1C,MAAM,GAAG,IAAI,YAAY,EAAgC,CAAC;IACnE,uDAAuD;IAC9C,UAAU,GAAG,IAAI,YAAY,EAAoC,CAAC;CAC5E;AAED;;wEAEwE;AAExE;;;;;;GAMG;AACH,MAAM,OAAO,GAA0C,EAAE,CAAC;AAE1D,IAAI,IAAI,GAAG,IAAI,eAAe,EAAE,CAAC;AAEjC,kFAAkF;AAClF,MAAM,UAAU,WAAW,CAAC,IAAoC;IAC9D,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnB,IAAI,CAAC,IAAI,CAAC,CAAC;AACb,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,eAAe;IAC7B,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB;IAClC,IAAI,GAAG,IAAI,eAAe,EAAE,CAAC;IAC7B,KAAK,MAAM,IAAI,IAAI,OAAO;QAAE,IAAI,CAAC,IAAI,CAAC,CAAC;AACzC,CAAC"}

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

@@ -0,0 +1,97 @@
+/**
+ * Golden vectors for RANDOM ARTIFACT construction: MOD_REACH gap 14.
+ *
+ * WHY THIS EXISTS. Four closed `switch` statements build every random artifact
+ * in the game, and they are the largest dispatch left in the tree:
+ *
+ *   - `addAbilityAux`  (randart-build.ts, keyed on the `ART_IDX` ability, 87
+ *     cases) - what "add this ability" actually does to the artifact.
+ *   - `artifactPrep`   (randart-build.ts, keyed on the base item's tval, 15) -
+ *     the starting to-hit / to-dam / AC an item class is given.
+ *   - the item-class census (randart-data.ts, keyed on tval, 14) - which
+ *     `data.*Total` bucket a standard artifact counts toward, which feeds the
+ *     frequency table the design loop spends.
+ *   - the redundancy test (randart-build.ts, keyed on the `EFPROP` kind, 9) -
+ *     whether an activation only duplicates something the artifact already has.
+ *
+ * Converting them into keyed registries so a mod can define a NEW ability, or a
+ * new item class, is a refactor of the most RNG-dense code in the port. What has
+ * to be proven is not "the randart tests still pass" but "the same seed still
+ * produces the same artifacts, drawn in the same order".
+ *
+ * WHY THE EXISTING TESTS ARE NOT THAT. `randart.test.ts` asserts do_randart is
+ * deterministic by running it TWICE IN ONE PROCESS and comparing. That is a real
+ * property and it catches real bugs - but it cannot fail across a refactor,
+ * because a change that moves every artifact moves both runs identically.
+ * Agreement is symmetric; a fixture recorded on disk is not.
+ *
+ * THE PROBE IS THE POINT, AND IT NEEDED A SEAM TO EXIST. `doRandart` owns its
+ * Rng internally, so the whole-set family below has no probe: what defends it is
+ * that all ~130 artifacts come off ONE stream in sequence, so a changed draw
+ * count anywhere but after the final draw moves everything downstream of it. The
+ * blind spot that leaves - a draw added at the very end - is closed by the
+ * per-arm families, which drive `artifactPrep` and `addAbilityAux` with an Rng
+ * this module owns and probe it afterwards. That is also what makes those two
+ * families per-ARM coverage rather than aggregate: a vector per `ART_IDX` fails
+ * naming the ability that moved.
+ *
+ * Fixtures are INJECTED rather than loaded here, so this module pulls in no
+ * node:fs and no content pack, and can be imported from anywhere.
+ *
+ * Regenerate with `node packages/core/scripts/gen-randart-vectors.mjs` - which
+ * OVERWRITES the evidence, so only do it when artifact generation is
+ * deliberately changing, and say so in the commit.
+ */
+import type { Constants } from "../constants.js";
+import type { ObjRegistry } from "./bind.js";
+/** One recorded call. Flat and all-string so a diff names what moved. */
+export interface RandartVector {
+    /** Which family: "set" | "prep" | "ability" | "data". */
+    kind: string;
+    /** The artifact, the tval name, or the ART_IDX name. */
+    subject: string;
+    /** The inputs, spelled out. */
+    scenario: string;
+    /** What the code produced. */
+    out: string;
+    /**
+     * One draw taken from an Rng THIS MODULE owns, after the call - it can only
+     * match if the stream is at the same position. Absent for the whole-set
+     * family, whose Rng lives inside `doRandart`; see the module header for what
+     * defends that one instead.
+     */
+    probe?: number;
+}
+/** What the vectors need from the shipped pack. */
+export interface RandartVectorFixtures {
+    /** A registry with projections bound - `add_brand` cannot run without them. */
+    registry(): ObjRegistry;
+    /** z_info, which `artifact_power` reaches through `make_fake_artifact`. */
+    constants(): Constants;
+}
+/** The seeds the whole-set family runs. Three, because a set is expensive. */
+export declare const RANDART_VECTOR_SEEDS: readonly [1, 4242, 999999];
+/** The seeds the cheap per-arm families run, on both sides of a coin flip. */
+export declare const RANDART_ARM_SEEDS: readonly [7, 31337];
+/**
+ * The target powers the ability family runs at, and the second one is not
+ * decoration. `ART_IDX.WEAPON_AGGR` / `NONWEAPON_AGGR` only grant AGGRAVATE
+ * when `targetPower > AGGR_POWER` (300, obj-randart.h L47), so a family run at
+ * one low power records those two arms doing NOTHING - indistinguishable from
+ * the `*_SUPER` frequency-table indices that genuinely have no case. The first
+ * recording of these vectors had exactly that hole. This is the same failure
+ * the glyph work found the expensive way: a scenario grid that never reaches
+ * the arm it was written to defend.
+ */
+export declare const RANDART_TARGET_POWERS: readonly [100, 500];
+/** do_randart at each seed, one vector per generated artifact. */
+export declare function computeSetVectors(fixtures: RandartVectorFixtures): RandartVector[];
+/** artifact_prep per item class, with the RNG position afterwards. */
+export declare function computePrepVectors(fixtures: RandartVectorFixtures): RandartVector[];
+/** add_ability_aux per ART_IDX, with the RNG position afterwards. */
+export declare function computeAbilityVectors(fixtures: RandartVectorFixtures): RandartVector[];
+/** collect_artifact_data over the standard set: every scalar it produces. */
+export declare function computeDataVectors(fixtures: RandartVectorFixtures): RandartVector[];
+/** Every family, in a stable order. */
+export declare function computeRandartVectors(fixtures: RandartVectorFixtures): RandartVector[];
+//# sourceMappingURL=randart-vectors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"randart-vectors.d.ts","sourceRoot":"","sources":["../../src/obj/randart-vectors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAM7C,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,mDAAmD;AACnD,MAAM,WAAW,qBAAqB;IACpC,+EAA+E;IAC/E,QAAQ,IAAI,WAAW,CAAC;IACxB,2EAA2E;IAC3E,SAAS,IAAI,SAAS,CAAC;CACxB;AAED,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,4BAA6B,CAAC;AAE/D,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,qBAAsB,CAAC;AAErD;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,qBAAsB,CAAC;AA+FzD,kEAAkE;AAClE,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,qBAAqB,GAC9B,aAAa,EAAE,CAkBjB;AAkBD,sEAAsE;AACtE,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,qBAAqB,GAC9B,aAAa,EAAE,CAsBjB;AAED,qEAAqE;AACrE,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,qBAAqB,GAC9B,aAAa,EAAE,CA+BjB;AAMD,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,qBAAqB,GAC9B,aAAa,EAAE,CAqDjB;AAED,uCAAuC;AACvC,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,qBAAqB,GAC9B,aAAa,EAAE,CAOjB"}

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

@@ -0,0 +1,18 @@
+/**
+ * The registry and constants a randart vector is recorded against, built from
+ * the real shipped content pack.
+ *
+ * SEPARATE FILE, and it reads the disk: keeping node:fs out of
+ * `randart-vectors.ts` means that module stays importable from anywhere. ONE
+ * copy, shared by `randart-vectors.test.ts` and by
+ * `scripts/gen-randart-vectors.mjs`, so the test and the generator cannot
+ * disagree about what they are measuring.
+ *
+ * The projections are bound for a reason that is not decoration: `add_brand`
+ * (obj-randart.c:1951) compares the brand it picked against `projections[i].name`
+ * to grant the matching resist, so a registry without them cannot run
+ * `do_randart` at all.
+ */
+import type { RandartVectorFixtures } from "./randart-vectors.js";
+export declare function randartVectorFixtures(): RandartVectorFixtures;
+//# sourceMappingURL=randart-vectors.fixtures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"randart-vectors.fixtures.d.ts","sourceRoot":"","sources":["../../src/obj/randart-vectors.fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAQlE,wBAAgB,qBAAqB,IAAI,qBAAqB,CA6B7D"}

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

@@ -0,0 +1,50 @@
+/**
+ * The registry and constants a randart vector is recorded against, built from
+ * the real shipped content pack.
+ *
+ * SEPARATE FILE, and it reads the disk: keeping node:fs out of
+ * `randart-vectors.ts` means that module stays importable from anywhere. ONE
+ * copy, shared by `randart-vectors.test.ts` and by
+ * `scripts/gen-randart-vectors.mjs`, so the test and the generator cannot
+ * disagree about what they are measuring.
+ *
+ * The projections are bound for a reason that is not decoration: `add_brand`
+ * (obj-randart.c:1951) compares the brand it picked against `projections[i].name`
+ * to grant the matching resist, so a registry without them cannot run
+ * `do_randart` at all.
+ */
+import { readFileSync } from "node:fs";
+import { bindConstants } from "../constants.js";
+import { bindProjections } from "../world/projection.js";
+import { ObjRegistry } from "./bind.js";
+function loadJson(name) {
+    return JSON.parse(readFileSync(new URL(`../../../content/pack/${name}.json`, import.meta.url), "utf8"));
+}
+export function randartVectorFixtures() {
+    /* Parsed ONCE; a fresh ObjRegistry is built per call from the same records,
+     * because the whole-set family wants a registry no earlier seed has run
+     * against. */
+    const pack = {
+        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 projectionRecords = loadJson("projection").records;
+    const constants = bindConstants(loadJson("constants"));
+    return {
+        registry() {
+            const reg = new ObjRegistry(pack);
+            reg.projections = bindProjections(projectionRecords);
+            return reg;
+        },
+        constants: () => constants,
+    };
+}
+//# sourceMappingURL=randart-vectors.fixtures.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"randart-vectors.fixtures.js","sourceRoot":"","sources":["../../src/obj/randart-vectors.fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAIxC,SAAS,QAAQ,CAAI,IAAY;IAC/B,OAAO,IAAI,CAAC,KAAK,CACf,YAAY,CAAC,IAAI,GAAG,CAAC,yBAAyB,IAAI,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAChF,CAAC;AACT,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC;;kBAEc;IACd,MAAM,IAAI,GAAG;QACX,UAAU,EAAE,QAAQ,CAAC,aAAa,CAAC;QACnC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC;QAC1B,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC;QAC7B,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC;QAC9B,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC;QACxB,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC;QACxB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC;QACtB,UAAU,EAAE,QAAQ,CAAC,YAAY,CAAC;QAClC,cAAc,EAAE,QAAQ,CAAC,iBAAiB,CAAC;QAC3C,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC;KACZ,CAAC;IACjB,MAAM,iBAAiB,GAAG,QAAQ,CAChC,YAAY,CACb,CAAC,OAAO,CAAC;IACV,MAAM,SAAS,GAAG,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC;IAEvD,OAAO;QACL,QAAQ;YACN,MAAM,GAAG,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC;YAClC,GAAG,CAAC,WAAW,GAAG,eAAe,CAAC,iBAAiB,CAAC,CAAC;YACrD,OAAO,GAAG,CAAC;QACb,CAAC;QACD,SAAS,EAAE,GAAc,EAAE,CAAC,SAAS;KACtC,CAAC;AACJ,CAAC"}