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

package/dist/obj/randart-data.js

@@ -14,32 +14,44 @@
  * L1332+) is a separate, later port.
  *
  * Faithful notes / approximations:
- * - The upstream file_putf(log_file, ...) logging is dropped throughout; it
- *   never affects any returned value (same convention as power.ts).
+ * - The upstream file_putf(log_file, ...) logging is PORTED (PORT_TODO 5.5),
+ *   through the randartLog sink in ./randart-log.js. It never affects any
+ *   returned value, so a run with no log open behaves identically.
  * - artifact_power (obj-randart.c L186) builds a "fake" object with
- *   make_fake_artifact (obj-make.c L728), which is object_prep(kind, 0,
- *   MAXIMISE) (obj-make.c L817) followed by copy_artifact_data (obj-make.c
- *   L520). artifactPower reproduces that field mapping directly into a
- *   PowerObject; the MAXIMISE and MINIMISE aspects it uses consume no RNG, so
- *   the two are inlined as pure rvMaximise/rvMinimise helpers and artifactPower
- *   needs no Rng.
+ *   make_fake_artifact (obj-make.c L728) and calls object_power on it. It calls
+ *   the REAL one: obj/artifact-fake.ts, the same builder the knowledge browser
+ *   and the spoiler dump use, which is object_prep(kind, 0, MAXIMISE)
+ *   (obj-make.c L817) followed by copy_artifact_data (obj-make.c L520).
+ *   This file used to carry its own hand-written copy of that field mapping,
+ *   flattened into a PowerObject because object_power reads only a few fields.
+ *   Two hand-written copies of one C function agree until they do not, and the
+ *   divergence would have been silent and total (artifact_power drives the
+ *   whole design loop). It also cost the object_desc log line, which needs the
+ *   whole object. Both are gone: one builder, one field mapping.
  * - The fake object's curse timeouts (copy_curses, obj-curse.c) are set from a
- *   RANDOMISE dice roll upstream. Timeouts never enter object_power (cursePower
- *   reads only curse power), so artifactPower maps curse powers with timeout 0
- *   and consumes no RNG. Standard artifacts carry no curses, so RNG order in
- *   storeBasePower is unaffected either way.
+ *   RANDOMISE roll upstream, and that roll DRAWS. The timeout never enters
+ *   object_power, so this file used to skip it and say no RNG was consumed;
+ *   that was measured on the standard artifact set (one curse in the whole
+ *   file) and was wrong during generation, where design_artifact re-powers an
+ *   artifact make_bad has just cursed. The rolls are made, in upstream's order,
+ *   by copyArtifactData itself now that the real builder does the work.
  * - Upstream mean()/variance() (z-util.c L1389/L1516) are exact-rational
  *   multi-precision routines; store_base_power calls them with a non-NULL frac,
  *   which is the "round the result down" path. Both are now ported for real in
  *   ../rational (saturation and all) and called through meanFloored /
  *   varianceFloored below, rather than reimplemented here.
  */
+import { randartLog, randartLogf } from "./randart-log.js";
+import { randartRegistry, seedRandart } from "./randart-registry.js";
 import { ELEM, KF, OBJ_MOD, OF, TV } from "../generated/index.js";
 import { ART_IDX } from "../generated/randart-properties.js";
-import { copyBrands, copySlays, tvalCanHaveCharges, tvalIsEdible, tvalIsFuel, tvalIsLauncher, tvalIsPotion, } from "./object.js";
+import { tvalFindName } from "./bind.js";
+import { makeFakeArtifact } from "./artifact-fake.js";
+import { ODESC, objectDesc } from "./desc.js";
+import { makeRuneEnv } from "./knowledge.js";
 import { mean, variance } from "../rational.js";
 import { objectPower } from "./power.js";
-import { ELEM_MAX, newOfFlags, OBJ_MOD_MAX, TV_MAX } from "./types.js";
+import { TV_MAX } from "./types.js";
 /** ART_IDX_TOTAL: number of learned-probability slots (obj-randart.h). */
 const ART_IDX_TOTAL = ART_IDX.TOTAL;
 /* ------------------------------------------------------------------ */
@@ -125,10 +137,6 @@ const artIdxArmor = [
 function rvMinimise(v) {
     return v.base + v.dice;
 }
-/** randcalc(v, 0, MAXIMISE): base + dice*sides + mBonus. */
-function rvMaximise(v) {
-    return v.base + v.dice * v.sides + v.mBonus;
-}
 /** Number of set entries in a 1-based boolean slay/brand array, or 0. */
 function countTrue(arr) {
     if (!arr)
@@ -162,122 +170,72 @@ function varianceFloored(nums) {
 /* ------------------------------------------------------------------ */
 /* artifact_power (obj-randart.c L186)                                 */
 /* ------------------------------------------------------------------ */
-/**
- * Build the "fake" object object_power evaluates for an artifact, reproducing
- * make_fake_artifact (obj-make.c L728) = object_prep(kind, 0, MAXIMISE)
- * followed by copy_artifact_data (obj-make.c L520). Returns null when the
- * artifact has no tval or no base kind (make_fake_artifact would return false).
- */
-function makeFakeArtifactPower(reg, art) {
-    if (!art.tval)
-        return null;
-    const kind = reg.lookupKind(art.tval, art.sval);
-    if (!kind)
-        return null;
-    /* Flags: object_prep copies base then kind flags (the second copy
-     * overwrites the first, upstream quirk kept in objectPrep), then
-     * copy_artifact_data clears the light-fuel flags and unions art flags. */
-    const flags = newOfFlags();
-    flags.copy(kind.base.flags);
-    flags.copy(kind.flags);
-    flags.off(OF.TAKES_FUEL);
-    flags.off(OF.BURNS_OUT);
-    flags.union(art.flags);
-    /* Modifiers: object_prep fills from the kind (MAXIMISE), then
-     * copy_artifact_data overwrites every entry with the artifact's. */
-    const modifiers = new Array(OBJ_MOD_MAX).fill(0);
-    for (let i = 0; i < OBJ_MOD_MAX; i++) {
-        modifiers[i] = art.modifiers[i] ?? 0;
-    }
-    /* pval: object_prep assigns charges then food/oil/launcher pval; the
-     * artifact copy does not touch pval. */
-    let pval = 0;
-    if (tvalCanHaveCharges(art.tval)) {
-        pval = rvMaximise(kind.charge);
-    }
-    if (tvalIsEdible(art.tval) ||
-        tvalIsPotion(art.tval) ||
-        tvalIsFuel(art.tval) ||
-        tvalIsLauncher(art.tval)) {
-        pval = rvMaximise(kind.pval);
-    }
-    /* Slays/brands: object_prep copies the kind's, copy_artifact_data unions
-     * the artifact's on top. */
-    let slays = copySlays(null, kind.slays, reg.slays);
-    slays = copySlays(slays, art.slays, reg.slays);
-    let brands = copyBrands(null, kind.brands, reg.brands);
-    brands = copyBrands(brands, art.brands, reg.brands);
-    /* Element info: object_prep sets res_level and flags from kind (+ base
-     * flags); copy_artifact_data overrides res_level with any non-zero
-     * artifact level and unions the artifact ignore flags. */
-    const elInfo = [];
-    for (let i = 0; i < ELEM_MAX; i++) {
-        const ke = kind.elInfo[i];
-        const be = kind.base.elInfo[i];
-        const ae = art.elInfo[i];
-        let resLevel = ke.resLevel;
-        let elFlags = ke.flags | be.flags;
-        if (ae.resLevel !== 0)
-            resLevel = ae.resLevel;
-        elFlags |= ae.flags;
-        elInfo.push({ resLevel, flags: elFlags });
-    }
-    /* Curses: copy_curses copies the kind's then the artifact's powers.
-     * Timeouts (a RANDOMISE roll upstream) never affect power, so they are
-     * left at 0 and no RNG is consumed. */
-    let curses = null;
-    if (kind.curses || art.curses) {
-        curses = [];
-        for (let i = 0; i < reg.curses.length; i++) {
-            curses.push({ power: 0, timeout: 0 });
-        }
-        if (kind.curses) {
-            for (let i = 0; i < reg.curses.length; i++) {
-                const power = kind.curses[i] ?? 0;
-                if (power)
-                    curses[i].power = power;
-            }
-        }
-        if (art.curses) {
-            for (let i = 0; i < reg.curses.length; i++) {
-                const power = art.curses[i] ?? 0;
-                if (power)
-                    curses[i].power = power;
-            }
-        }
-    }
-    /* Activation comes from the artifact or, failing that, the kind. */
-    const act = art.activation ?? kind.activation;
-    const activation = act ? { power: act.power } : null;
-    return {
-        tval: art.tval,
-        toH: art.toH,
-        toD: art.toD,
-        toA: art.toA,
-        ac: art.ac,
-        dd: art.dd,
-        ds: art.ds,
-        weight: art.weight,
-        pval,
-        modifiers,
-        brands,
-        slays,
-        flags,
-        elInfo,
-        curses,
-        activation,
-        kind: { power: kind.power, kindFlags: kind.kindFlags },
-        ego: null,
-    };
-}
 /**
  * artifact_power (obj-randart.c L186): the artifact's power, by generating a
  * fake object from the artifact and calling the common object_power.
  */
-export function artifactPower(reg, art) {
-    const obj = makeFakeArtifactPower(reg, art);
+export function artifactPower(reg, 
+/**
+ * object_prep's z_info / player constants, reached upstream as globals. Only
+ * the real make_fake_artifact needs them, which is why this argument appears
+ * here at all: the flattened builder that used to live in this file could
+ * skip object_prep, and skipping object_prep is what let the two copies of
+ * one C function drift.
+ */
+constants, art, 
+/**
+ * artifact_power's `reason` (obj-randart.c:186), which exists only to head
+ * the log block. REQUIRED rather than optional: upstream writes it out at
+ * every one of its four call sites, and a default here would silently label
+ * one evaluation as another in the log the argument exists to produce.
+ */
+reason, 
+/**
+ * make_fake_artifact's copy_curses rolls a timeout per cursed slot and those
+ * rolls DRAW. Required, because a default would hand back a private Rng and
+ * silently restore the divergence this argument exists to close.
+ */
+rng) {
+    randartLogf(() => `********** Evaluating ${reason} ********\n`);
+    randartLogf(() => `Artifact index is ${art.aidx}\n`);
+    const obj = makeFakeArtifact(reg, constants, art, rng);
     if (!obj)
         return 0;
+    /*
+     * object_desc of the fake artifact (obj-randart.c L205-L206), with
+     * ODESC_PREFIX | ODESC_FULL | ODESC_SPOIL and a NULL player - upstream's own
+     * argument, and the reason this needs no knowledge state. A null player is
+     * an omniscient observer: objectDesc uses the object as its own known shadow
+     * and every gate opens, so the RuneEnv below is never asked a knowledge
+     * question. It supplies the registries and nothing else, and slot_object is
+     * null for every slot because there is no player to have equipment.
+     *
+     * The KnownDesc is equally thin, and deliberately says the honest thing
+     * rather than the convenient one: isAware/isTried are FALSE, exactly as
+     * upstream's kind->aware at this point in birth. It does not matter -- SPOIL
+     * forces `aware` true a line later, and obj_desc_get_basename returns
+     * kind->name for an artifact regardless -- but a KnownDesc that lied here
+     * would be a claim about the player, and this code has no player.
+     *
+     * Its format string is "%s\n", which has no literal span for the census in
+     * randart-log.census.test.ts to match, so this line was carried there as
+     * UNWRITTEN_SPANLESS = 1 for as long as it went unwritten. That count is now
+     * zero, which is the only reason the reassuring EXPECTED_MISSING_RANDART = 0
+     * can be read as "nothing left".
+     */
+    randartLogf(() => {
+        const env = makeRuneEnv(() => null, (v) => rng.randcalcVaries(v), {
+            brands: reg.brands,
+            slays: reg.slays,
+            curses: reg.curses,
+            properties: reg.properties,
+            elementNames: (reg.projections ?? []).map((p) => p.name),
+        });
+        const deps = { isAware: () => false, isTried: () => false };
+        const name = objectDesc(obj, ODESC.PREFIX | ODESC.FULL | ODESC.SPOIL, null, env, deps);
+        return `${name}
+`;
+    });
     return objectPower(reg, obj);
 }
 /* ------------------------------------------------------------------ */
@@ -288,8 +246,8 @@ export function artifactPower(reg, art) {
  * ratings as a baseline, and capture the per-set and per-tval power statistics
  * and base-item info.
  */
-export function storeBasePower(reg, data) {
-    const aMax = reg.artifacts.length;
+export function storeBasePower(reg, constants, arts, data, rng) {
+    const aMax = arts.length;
     data.maxPower = 0;
     data.minPower = INHIBIT_POWER + 1;
     data.varPower = 0;
@@ -301,8 +259,10 @@ export function storeBasePower(reg, data) {
         data.maxTvPower[i] = 0;
     }
     for (let i = 0; i < aMax; i++) {
-        const art = reg.artifacts[i] ?? null;
-        const power = art ? artifactPower(reg, art) : 0;
+        const art = arts[i] ?? null;
+        const power = art
+            ? artifactPower(reg, constants, art, "for original power", rng)
+            : 0;
         data.basePower[i] = power;
         /* Capture power stats, ignoring cursed and uber arts. */
         if (power > data.maxPower && power < INHIBIT_POWER) {
@@ -341,48 +301,70 @@ export function storeBasePower(reg, data) {
             data.avgTvPower[i] = meanFloored(fakeTvPower[i]);
         }
     }
+    randartLogf(() => `Max power is ${String(data.maxPower)}, min is ${String(data.minPower)}\n`);
+    randartLogf(() => `Mean is ${String(data.avgPower)}, variance is ${String(data.varPower)}\n`);
+    for (let i = 0; i < TV_MAX; i++) {
+        if (data.avgTvPower[i]) {
+            randartLogf(() => `Power for tval ${tvalFindName(i)}: min ${String(data.minTvPower[i])}, max ${String(data.maxTvPower[i])}, avg ${String(data.avgTvPower[i])}\n`);
+        }
+    }
     /* Store the number of different types, for use later. */
     for (let i = 0; i < aMax; i++) {
-        const art = reg.artifacts[i] ?? null;
+        const art = arts[i] ?? null;
         const tval = art ? art.tval : TV.NULL;
-        switch (tval) {
-            case TV.SWORD:
-            case TV.POLEARM:
-            case TV.HAFTED:
-                data.meleeTotal++;
-                break;
-            case TV.BOW:
-                data.bowTotal++;
-                break;
-            case TV.SOFT_ARMOR:
-            case TV.HARD_ARMOR:
-            case TV.DRAG_ARMOR:
-                data.armorTotal++;
-                break;
-            case TV.SHIELD:
-                data.shieldTotal++;
-                break;
-            case TV.CLOAK:
-                data.cloakTotal++;
-                break;
-            case TV.HELM:
-            case TV.CROWN:
-                data.headgearTotal++;
-                break;
-            case TV.GLOVES:
-                data.gloveTotal++;
-                break;
-            case TV.BOOTS:
-                data.bootTotal++;
-                break;
-            case TV.NULL:
-                break;
-            default:
-                data.otherTotal++;
-        }
+        /* The upstream switch on tval is now the randart registry's `census`
+         * table. This is not bookkeeping: the totals feed the frequency table the
+         * design loop SPENDS, so a mod's item class landing in `otherTotal` skews
+         * what every randart in the game becomes. An unregistered tval counts
+         * toward `otherTotal`, which is upstream's own default arm. */
+        const bucket = randartRegistry().census.handlerFor(tval);
+        if (bucket)
+            bucket(data);
+        else
+            data.otherTotal++;
         data.total++;
     }
 }
+/* ------------------------------------------------------------------ *
+ * Core's item-class census buckets, lifted case by case.
+ * ------------------------------------------------------------------ */
+seedRandart((registry) => {
+    const bucket = (tvals, count) => {
+        for (const tval of tvals)
+            registry.census.set(tval, count);
+    };
+    bucket([TV.SWORD, TV.POLEARM, TV.HAFTED], (d) => {
+        d.meleeTotal++;
+    });
+    bucket([TV.BOW], (d) => {
+        d.bowTotal++;
+    });
+    bucket([TV.SOFT_ARMOR, TV.HARD_ARMOR, TV.DRAG_ARMOR], (d) => {
+        d.armorTotal++;
+    });
+    bucket([TV.SHIELD], (d) => {
+        d.shieldTotal++;
+    });
+    bucket([TV.CLOAK], (d) => {
+        d.cloakTotal++;
+    });
+    bucket([TV.HELM, TV.CROWN], (d) => {
+        d.headgearTotal++;
+    });
+    bucket([TV.GLOVES], (d) => {
+        d.gloveTotal++;
+    });
+    bucket([TV.BOOTS], (d) => {
+        d.bootTotal++;
+    });
+    /* An EMPTY artifact slot, registered explicitly rather than left to the
+     * default: upstream distinguishes "no artifact here" (counts toward nothing)
+     * from "an item class I have no bucket for" (counts toward otherTotal), and
+     * the default arm can only express the second. */
+    bucket([TV.NULL], () => {
+        /* deliberately nothing */
+    });
+});
 /* ------------------------------------------------------------------ */
 /* Ability counters (obj-randart.c L342-L1053)                         */
 /* ------------------------------------------------------------------ */
@@ -398,60 +380,89 @@ export function countWeaponAbilities(reg, art, data) {
     const minToA = rvMinimise(kind.toA);
     /* To-hit and to-dam. */
     let bonus = Math.trunc((art.toH - minToH - data.hitStartval) / data.hitIncrement);
+    if (bonus > 0) {
+        randartLogf(() => `Adding ${bonus} instances of extra to-hit bonus for weapon\n`);
+    }
+    else if (bonus < 0) {
+        randartLogf(() => `Subtracting ${bonus} instances of extra to-hit bonus for weapon\n`);
+    }
     data.artProbs[ART_IDX.WEAPON_HIT] += bonus;
     bonus = Math.trunc((art.toD - minToD - data.damStartval) / data.damIncrement);
+    /* Asymmetric with to-hit ON PURPOSE: the to-dam arm has no `< 0` test, so a
+     * bonus of exactly 0 logs "Subtracting 0" (obj-randart.c L359-363). */
+    if (bonus > 0) {
+        randartLogf(() => `Adding ${bonus} instances of extra to-dam bonus for weapon\n`);
+    }
+    else {
+        randartLogf(() => `Subtracting ${bonus} instances of extra to-dam bonus for weapon\n`);
+    }
     data.artProbs[ART_IDX.WEAPON_DAM] += bonus;
     /* Does this weapon have an unusual bonus to AC? */
     bonus = Math.trunc((art.toA - minToA) / data.acIncrement);
     if (art.toA > 20) {
+        randartLogf(() => `Adding ${bonus} for supercharged AC\n`);
         data.artProbs[ART_IDX.MELEE_AC_SUPER]++;
     }
     else if (bonus > 0) {
+        randartLogf(() => `Adding ${bonus} instances of extra AC bonus for weapon\n`);
         data.artProbs[ART_IDX.MELEE_AC] += bonus;
     }
     /* Check damage dice - are they more than normal? */
     if (art.dd > kind.dd) {
         if (art.dd - kind.dd > 2) {
+            randartLog(`Adding 1 for super-charged damage dice!\n`);
             data.artProbs[ART_IDX.MELEE_DICE_SUPER]++;
         }
         else {
+            randartLog(`Adding 1 for extra damage dice.\n`);
             data.artProbs[ART_IDX.MELEE_DICE]++;
         }
     }
     /* Check weight - is it different from normal? */
     if (art.weight !== kind.weight) {
+        randartLog(`Adding 1 for unusual weight.\n`);
         data.artProbs[ART_IDX.MELEE_WEIGHT]++;
     }
     /* Do we have 3 or more extra blows? */
     const blows = art.modifiers[OBJ_MOD.BLOWS] ?? 0;
     if (blows > 2) {
+        randartLog(`Adding 1 for supercharged blows (3 or more!)\n`);
         data.artProbs[ART_IDX.MELEE_BLOWS_SUPER]++;
     }
     else if (blows > 0) {
+        randartLog(`Adding 1 for extra blows\n`);
         data.artProbs[ART_IDX.MELEE_BLOWS]++;
     }
     /* Aggravation. */
     if (art.flags.has(OF.AGGRAVATE)) {
+        randartLog(`Adding 1 for aggravation - weapon\n`);
         data.artProbs[ART_IDX.WEAPON_AGGR]++;
     }
     /* Blessed weapon? */
     if (art.flags.has(OF.BLESSED)) {
+        randartLog(`Adding 1 for blessed weapon\n`);
         data.artProbs[ART_IDX.MELEE_BLESS]++;
     }
     /* See invisible? */
     if (art.flags.has(OF.SEE_INVIS)) {
+        randartLog(`Adding 1 for see invisible (weapon case)\n`);
         data.artProbs[ART_IDX.MELEE_SINV]++;
     }
     /* Tunnelling ability. */
     if ((art.modifiers[OBJ_MOD.TUNNEL] ?? 0) > 0) {
+        randartLog(`Adding 1 for tunnelling bonus.\n`);
         data.artProbs[ART_IDX.MELEE_TUNN]++;
     }
     /* Count brands and slays. */
     if (art.slays) {
-        data.artProbs[ART_IDX.MELEE_SLAY] += countTrue(art.slays);
+        const n = countTrue(art.slays);
+        data.artProbs[ART_IDX.MELEE_SLAY] += n;
+        randartLogf(() => `Adding ${n} for slays\n`);
     }
     if (art.brands) {
-        data.artProbs[ART_IDX.MELEE_BRAND] += countTrue(art.brands);
+        const n = countTrue(art.brands);
+        data.artProbs[ART_IDX.MELEE_BRAND] += n;
+        randartLogf(() => `Adding ${n} for brands\n`);
     }
 }
 /**
@@ -466,41 +477,66 @@ export function countBowAbilities(reg, art, data) {
     const minToA = rvMinimise(kind.toA);
     /* To-hit. */
     let bonus = Math.trunc((art.toH - minToH - data.hitStartval) / data.hitIncrement);
+    if (bonus > 0) {
+        randartLogf(() => `Adding ${bonus} instances of extra to-hit bonus for weapon\n`);
+    }
+    else if (bonus < 0) {
+        randartLogf(() => `Subtracting ${bonus} instances of extra to-hit bonus for weapon\n`);
+    }
     data.artProbs[ART_IDX.WEAPON_HIT] += bonus;
     /* To-dam. */
     bonus = Math.trunc((art.toD - minToD - data.damStartval) / data.damIncrement);
+    /* Plain `else`, as in count_weapon_abilities: the to-dam arm has no `< 0`
+     * test either here (obj-randart.c L461-466), so a bonus of exactly 0 logs
+     * "Subtracting 0". The to-hit arm above DOES have one. */
+    if (bonus > 0) {
+        randartLogf(() => `Adding ${bonus} instances of extra to-dam bonus for weapon\n`);
+    }
+    else {
+        randartLogf(() => `Subtracting ${bonus} instances of extra to-dam bonus for weapon\n`);
+    }
     data.artProbs[ART_IDX.WEAPON_DAM] += bonus;
     /* Armor class. */
     bonus = Math.trunc((art.toA - minToA - data.acStartval) / data.acIncrement);
     if (bonus > 0) {
+        randartLogf(() => `Adding ${bonus} for AC bonus - general\n`);
         data.artProbs[ART_IDX.GEN_AC] += bonus;
     }
     /* Aggravation. */
     if (art.flags.has(OF.AGGRAVATE)) {
+        randartLog(`Adding 1 for aggravation - weapon\n`);
         data.artProbs[ART_IDX.WEAPON_AGGR]++;
     }
     /* Do we have more than 1 extra shot? */
     const shots = art.modifiers[OBJ_MOD.SHOTS] ?? 0;
     if (shots > 10) {
+        randartLog(`Adding 1 for supercharged shots (more than 1!)\n`);
         data.artProbs[ART_IDX.BOW_SHOTS_SUPER]++;
     }
     else if (shots > 0) {
+        randartLog(`Adding 1 for extra shots\n`);
         data.artProbs[ART_IDX.BOW_SHOTS]++;
     }
     /* Do we have 3 or more extra might? */
     const might = art.modifiers[OBJ_MOD.MIGHT] ?? 0;
     if (might > 2) {
+        randartLog(`Adding 1 for supercharged might (3 or more!)\n`);
         data.artProbs[ART_IDX.BOW_MIGHT_SUPER]++;
     }
     else if (might > 0) {
+        randartLog(`Adding 1 for extra might\n`);
         data.artProbs[ART_IDX.BOW_MIGHT]++;
     }
     /* Count brands and slays. */
     if (art.slays) {
-        data.artProbs[ART_IDX.BOW_SLAY] += countTrue(art.slays);
+        const n = countTrue(art.slays);
+        data.artProbs[ART_IDX.BOW_SLAY] += n;
+        randartLogf(() => `Adding ${n} for slays\n`);
     }
     if (art.brands) {
-        data.artProbs[ART_IDX.BOW_BRAND] += countTrue(art.brands);
+        const n = countTrue(art.brands);
+        data.artProbs[ART_IDX.BOW_BRAND] += n;
+        randartLogf(() => `Adding ${n} for brands\n`);
     }
 }
 /**
@@ -518,29 +554,37 @@ export function countNonweaponAbilities(reg, art, data) {
     /* Armor class. */
     if (bonus > 0) {
         if (art.toA > 20) {
+            randartLogf(() => `Adding ${bonus} for supercharged AC\n`);
             data.artProbs[ART_IDX.GEN_AC_SUPER]++;
         }
         else if (art.tval === TV.BOOTS) {
+            randartLogf(() => `Adding ${bonus} for AC bonus - boots\n`);
             data.artProbs[ART_IDX.BOOT_AC] += bonus;
         }
         else if (art.tval === TV.GLOVES) {
+            randartLogf(() => `Adding ${bonus} for AC bonus - gloves\n`);
             data.artProbs[ART_IDX.GLOVE_AC] += bonus;
         }
         else if (art.tval === TV.HELM || art.tval === TV.CROWN) {
+            randartLogf(() => `Adding ${bonus} for AC bonus - hat\n`);
             data.artProbs[ART_IDX.HELM_AC] += bonus;
         }
         else if (art.tval === TV.SHIELD) {
+            randartLogf(() => `Adding ${bonus} for AC bonus - shield\n`);
             data.artProbs[ART_IDX.SHIELD_AC] += bonus;
         }
         else if (art.tval === TV.CLOAK) {
+            randartLogf(() => `Adding ${bonus} for AC bonus - cloak\n`);
             data.artProbs[ART_IDX.CLOAK_AC] += bonus;
         }
         else if (art.tval === TV.SOFT_ARMOR ||
             art.tval === TV.HARD_ARMOR ||
             art.tval === TV.DRAG_ARMOR) {
+            randartLogf(() => `Adding ${bonus} for AC bonus - body armor\n`);
             data.artProbs[ART_IDX.ARMOR_AC] += bonus;
         }
         else {
+            randartLogf(() => `Adding ${bonus} for AC bonus - general\n`);
             data.artProbs[ART_IDX.GEN_AC] += bonus;
         }
     }
@@ -549,9 +593,11 @@ export function countNonweaponAbilities(reg, art, data) {
         bonus = Math.trunc((toHit + toDam) / (data.hitIncrement + data.damIncrement));
         if (bonus > 0) {
             if (art.tval === TV.GLOVES) {
+                randartLogf(() => `Adding ${bonus} instances of extra to-hit and to-dam bonus for gloves\n`);
                 data.artProbs[ART_IDX.GLOVE_HIT_DAM] += bonus;
             }
             else {
+                randartLogf(() => `Adding ${bonus} instances of extra to-hit and to-dam bonus for non-weapon\n`);
                 data.artProbs[ART_IDX.NONWEAPON_HIT_DAM] += bonus;
             }
         }
@@ -559,40 +605,51 @@ export function countNonweaponAbilities(reg, art, data) {
     else if (toHit > 0) {
         bonus = Math.trunc(toHit / data.hitIncrement);
         if (bonus > 0) {
+            randartLogf(() => `Adding ${bonus} instances of extra to-hit bonus for non-weapon\n`);
             data.artProbs[ART_IDX.NONWEAPON_HIT] += bonus;
         }
     }
     else if (toDam > 0) {
         bonus = Math.trunc(toDam / data.damIncrement);
         if (bonus > 0) {
+            randartLogf(() => `Adding ${bonus} instances of extra to-dam bonus for non-weapon\n`);
             data.artProbs[ART_IDX.NONWEAPON_DAM] += bonus;
         }
     }
     /* Check weight - is it different from normal? */
     if (art.weight !== kind.weight) {
+        randartLog(`Adding 1 for unusual weight.\n`);
         data.artProbs[ART_IDX.ALLARMOR_WEIGHT]++;
     }
     /* Aggravation. */
     if (art.flags.has(OF.AGGRAVATE)) {
+        randartLog(`Adding 1 for aggravation - nonweapon\n`);
         data.artProbs[ART_IDX.NONWEAPON_AGGR]++;
     }
     /* Count brands and slays. */
     if (art.slays) {
-        data.artProbs[ART_IDX.NONWEAPON_SLAY] += countTrue(art.slays);
+        const n = countTrue(art.slays);
+        data.artProbs[ART_IDX.NONWEAPON_SLAY] += n;
+        randartLogf(() => `Adding ${n} for slays\n`);
     }
     if (art.brands) {
-        data.artProbs[ART_IDX.NONWEAPON_BRAND] += countTrue(art.brands);
+        const n = countTrue(art.brands);
+        data.artProbs[ART_IDX.NONWEAPON_BRAND] += n;
+        randartLogf(() => `Adding ${n} for brands\n`);
     }
     /* Blows. */
     if ((art.modifiers[OBJ_MOD.BLOWS] ?? 0) > 0) {
+        randartLog(`Adding 1 for extra blows on nonweapon\n`);
         data.artProbs[ART_IDX.NONWEAPON_BLOWS]++;
     }
     /* Shots. */
     if ((art.modifiers[OBJ_MOD.SHOTS] ?? 0) > 0) {
+        randartLog(`Adding 1 for extra shots on nonweapon\n`);
         data.artProbs[ART_IDX.NONWEAPON_SHOTS]++;
     }
     /* Tunnelling ability. */
     if ((art.modifiers[OBJ_MOD.TUNNEL] ?? 0) > 0) {
+        randartLog(`Adding 1 for tunnelling bonus - general.\n`);
         data.artProbs[ART_IDX.GEN_TUNN]++;
     }
 }
@@ -617,10 +674,12 @@ export function countModifiers(art, data) {
         ((art.modifiers[OBJ_MOD.WIS] ?? 0) > 0 ||
             (art.modifiers[OBJ_MOD.INT] ?? 0) > 0)) {
         if ((art.modifiers[OBJ_MOD.WIS] ?? 0) > 0) {
+            randartLog("Adding 1 for WIS bonus on headgear.\n");
             data.artProbs[ART_IDX.HELM_WIS]++;
             num--;
         }
         if ((art.modifiers[OBJ_MOD.INT] ?? 0) > 0) {
+            randartLog("Adding 1 for INT bonus on headgear.\n");
             data.artProbs[ART_IDX.HELM_INT]++;
             num--;
         }
@@ -629,52 +688,64 @@ export function countModifiers(art, data) {
         art.tval === TV.HARD_ARMOR ||
         art.tval === TV.DRAG_ARMOR) &&
         (art.modifiers[OBJ_MOD.CON] ?? 0) > 0) {
+        randartLog("Adding 1 for CON bonus on body armor.\n");
         data.artProbs[ART_IDX.ARMOR_CON]++;
         num--;
     }
     else if (art.tval === TV.GLOVES && (art.modifiers[OBJ_MOD.DEX] ?? 0) > 0) {
+        randartLog("Adding 1 for DEX bonus on gloves.\n");
         data.artProbs[ART_IDX.GLOVE_DEX]++;
         num--;
     }
     /* Now the general case. */
     if (num > 0) {
+        randartLogf(() => `Adding ${num} for stat bonuses - general.\n`);
         data.artProbs[ART_IDX.GEN_STAT] += num;
     }
     /* Handle stealth, including a couple of special cases. */
     if ((art.modifiers[OBJ_MOD.STEALTH] ?? 0) > 0) {
         if (art.tval === TV.BOOTS) {
+            randartLog("Adding 1 for stealth bonus on boots.\n");
             data.artProbs[ART_IDX.BOOT_STEALTH]++;
         }
         else if (art.tval === TV.CLOAK) {
+            randartLog("Adding 1 for stealth bonus on cloak.\n");
             data.artProbs[ART_IDX.CLOAK_STEALTH]++;
         }
         else if (art.tval === TV.SOFT_ARMOR ||
             art.tval === TV.HARD_ARMOR ||
             art.tval === TV.DRAG_ARMOR) {
+            randartLog("Adding 1 for stealth bonus on armor.\n");
             data.artProbs[ART_IDX.ARMOR_STEALTH]++;
         }
         else {
+            randartLog("Adding 1 for stealth bonus - general.\n");
             data.artProbs[ART_IDX.GEN_STEALTH]++;
         }
     }
     /* Searching bonus - fully generic. */
     if ((art.modifiers[OBJ_MOD.SEARCH] ?? 0) > 0) {
+        randartLog("Adding 1 for search bonus - general.\n");
         data.artProbs[ART_IDX.GEN_SEARCH]++;
     }
     /* Infravision bonus - fully generic. */
     if ((art.modifiers[OBJ_MOD.INFRA] ?? 0) > 0) {
+        randartLog("Adding 1 for infravision bonus - general.\n");
         data.artProbs[ART_IDX.GEN_INFRA]++;
     }
     /* Damage reduction bonus - fully generic. */
     if ((art.modifiers[OBJ_MOD.DAM_RED] ?? 0) > 0) {
+        randartLog("Adding 1 for damage reduction bonus - general.\n");
         data.artProbs[ART_IDX.GEN_DAM_RED]++;
     }
     /* Moves bonus. */
     if ((art.modifiers[OBJ_MOD.MOVES] ?? 0) > 0) {
         if (art.tval === TV.BOOTS) {
+            randartLog("Adding 1 for moves bonus on boots.\n");
             data.artProbs[ART_IDX.BOOT_MOVES]++;
         }
         else {
+            randartLog("Adding 1 for moves bonus - general.\n");
             data.artProbs[ART_IDX.GEN_MOVES]++;
         }
     }
@@ -682,17 +753,21 @@ export function countModifiers(art, data) {
     const speed = art.modifiers[OBJ_MOD.SPEED] ?? 0;
     if (speed > 0) {
         if (speed > 7) {
+            randartLog("Adding 1 for supercharged speed bonus!\n");
             data.artProbs[ART_IDX.GEN_SPEED_SUPER]++;
         }
         else if (art.tval === TV.BOOTS) {
+            randartLog("Adding 1 for normal speed bonus on boots.\n");
             data.artProbs[ART_IDX.BOOT_SPEED]++;
         }
         else {
+            randartLog("Adding 1 for normal speed bonus - general.\n");
             data.artProbs[ART_IDX.GEN_SPEED]++;
         }
     }
     /* Permanent light. */
     if ((art.modifiers[OBJ_MOD.LIGHT] ?? 0) > 0) {
+        randartLog("Adding 1 for light radius - general.\n");
         data.artProbs[ART_IDX.GEN_LIGHT]++;
     }
 }
@@ -710,6 +785,7 @@ export function countLowResists(art, data) {
         num++;
     if (art.elInfo[ELEM.COLD].resLevel === 3)
         num++;
+    randartLogf(() => `Adding ${num} for immunities.\n`);
     data.artProbs[ART_IDX.GEN_IMMUNE] += num;
     /* Count up low resists (not the type, just the number). */
     num = 0;
@@ -723,19 +799,23 @@ export function countLowResists(art, data) {
         num++;
     if (num) {
         if (art.tval === TV.SHIELD) {
+            randartLogf(() => `Adding ${num} for low resists on shield.\n`);
             data.artProbs[ART_IDX.SHIELD_LRES] += num;
         }
         else if (art.tval === TV.SOFT_ARMOR ||
             art.tval === TV.HARD_ARMOR ||
             art.tval === TV.DRAG_ARMOR) {
             if (num === 4) {
+                randartLog("Adding 1 for ALL LOW RESISTS on body armor.\n");
                 data.artProbs[ART_IDX.ARMOR_ALLRES]++;
             }
             else {
+                randartLogf(() => `Adding ${num} for low resists on body armor.\n`);
                 data.artProbs[ART_IDX.ARMOR_LRES] += num;
             }
         }
         else {
+            randartLogf(() => `Adding ${num} for low resists - general.\n`);
             data.artProbs[ART_IDX.GEN_LRES] += num;
         }
     }
@@ -775,51 +855,66 @@ export function countHighResists(art, data) {
             num++;
         if (art.flags.has(OF.PROT_STUN))
             num++;
+        randartLogf(() => `Adding ${num} for high resists on body armor.\n`);
         data.artProbs[ART_IDX.ARMOR_HRES] += num;
     }
     /* Now do the high resists individually. */
     if (art.elInfo[ELEM.POIS].resLevel === 1) {
+        randartLog("Adding 1 for resist poison - general.\n");
         data.artProbs[ART_IDX.GEN_RPOIS]++;
     }
     if (art.flags.has(OF.PROT_FEAR)) {
+        randartLog("Adding 1 for resist fear - general.\n");
         data.artProbs[ART_IDX.GEN_RFEAR]++;
     }
     if (art.elInfo[ELEM.LIGHT].resLevel === 1) {
+        randartLog("Adding 1 for resist light - general.\n");
         data.artProbs[ART_IDX.GEN_RLIGHT]++;
     }
     if (art.elInfo[ELEM.DARK].resLevel === 1) {
+        randartLog("Adding 1 for resist dark - general.\n");
         data.artProbs[ART_IDX.GEN_RDARK]++;
     }
     if (art.flags.has(OF.PROT_BLIND)) {
         if (art.tval === TV.HELM || art.tval === TV.CROWN) {
+            randartLog("Adding 1 for resist blindness - headgear.\n");
             data.artProbs[ART_IDX.HELM_RBLIND]++;
         }
         else {
+            randartLog("Adding 1 for resist blindness - general.\n");
             data.artProbs[ART_IDX.GEN_RBLIND]++;
         }
     }
     if (art.flags.has(OF.PROT_CONF)) {
+        randartLog("Adding 1 for resist confusion - general.\n");
         data.artProbs[ART_IDX.GEN_RCONF]++;
     }
     if (art.elInfo[ELEM.SOUND].resLevel === 1) {
+        randartLog("Adding 1 for resist sound - general.\n");
         data.artProbs[ART_IDX.GEN_RSOUND]++;
     }
     if (art.elInfo[ELEM.SHARD].resLevel === 1) {
+        randartLog("Adding 1 for resist shards - general.\n");
         data.artProbs[ART_IDX.GEN_RSHARD]++;
     }
     if (art.elInfo[ELEM.NEXUS].resLevel === 1) {
+        randartLog("Adding 1 for resist nexus - general.\n");
         data.artProbs[ART_IDX.GEN_RNEXUS]++;
     }
     if (art.elInfo[ELEM.NETHER].resLevel === 1) {
+        randartLog("Adding 1 for resist nether - general.\n");
         data.artProbs[ART_IDX.GEN_RNETHER]++;
     }
     if (art.elInfo[ELEM.CHAOS].resLevel === 1) {
+        randartLog("Adding 1 for resist chaos - general.\n");
         data.artProbs[ART_IDX.GEN_RCHAOS]++;
     }
     if (art.elInfo[ELEM.DISEN].resLevel === 1) {
+        randartLog("Adding 1 for resist disenchantment - general.\n");
         data.artProbs[ART_IDX.GEN_RDISEN]++;
     }
     if (art.flags.has(OF.PROT_STUN)) {
+        randartLog("Adding 1 for res_stun - general.\n");
         data.artProbs[ART_IDX.GEN_PSTUN]++;
     }
 }
@@ -846,14 +941,17 @@ export function countAbilities(reg, art, data) {
             num++;
         if (art.flags.has(OF.SUST_CON))
             num++;
+        randartLogf(() => `Adding ${num} for stat sustains.\n`);
         data.artProbs[ART_IDX.GEN_SUST] += num;
     }
     /* Free action - handle gloves separately. */
     if (art.flags.has(OF.FREE_ACT)) {
         if (art.tval === TV.GLOVES) {
+            randartLog("Adding 1 for free action on gloves.\n");
             data.artProbs[ART_IDX.GLOVE_FA]++;
         }
         else {
+            randartLog("Adding 1 for free action - general.\n");
             data.artProbs[ART_IDX.GEN_FA]++;
         }
     }
@@ -862,18 +960,22 @@ export function countAbilities(reg, art, data) {
         if (art.tval === TV.SOFT_ARMOR ||
             art.tval === TV.HARD_ARMOR ||
             art.tval === TV.DRAG_ARMOR) {
+            randartLog("Adding 1 for hold life on armor.\n");
             data.artProbs[ART_IDX.ARMOR_HLIFE]++;
         }
         else {
+            randartLog("Adding 1 for hold life - general.\n");
             data.artProbs[ART_IDX.GEN_HLIFE]++;
         }
     }
     /* Feather fall - handle boots separately. */
     if (art.flags.has(OF.FEATHER)) {
         if (art.tval === TV.BOOTS) {
+            randartLog("Adding 1 for feather fall on boots.\n");
             data.artProbs[ART_IDX.BOOT_FEATHER]++;
         }
         else {
+            randartLog("Adding 1 for feather fall - general.\n");
             data.artProbs[ART_IDX.GEN_FEATHER]++;
         }
     }
@@ -884,9 +986,11 @@ export function countAbilities(reg, art, data) {
             art.tval === TV.POLEARM ||
             art.tval === TV.SWORD)) {
             if (art.tval === TV.HELM || art.tval === TV.CROWN) {
+                randartLog("Adding 1 for see invisible - headgear.\n");
                 data.artProbs[ART_IDX.HELM_SINV]++;
             }
             else {
+                randartLog("Adding 1 for see invisible - general.\n");
                 data.artProbs[ART_IDX.GEN_SINV]++;
             }
         }
@@ -894,31 +998,38 @@ export function countAbilities(reg, art, data) {
     /* ESP - handle helms/crowns separately. */
     if (art.flags.has(OF.TELEPATHY)) {
         if (art.tval === TV.HELM || art.tval === TV.CROWN) {
+            randartLog("Adding 1 for ESP on headgear.\n");
             data.artProbs[ART_IDX.HELM_ESP]++;
         }
         else {
+            randartLog("Adding 1 for ESP - general.\n");
             data.artProbs[ART_IDX.GEN_ESP]++;
         }
     }
     /* Slow digestion - generic. */
     if (art.flags.has(OF.SLOW_DIGEST)) {
+        randartLog("Adding 1 for slow digestion - general.\n");
         data.artProbs[ART_IDX.GEN_SDIG]++;
     }
     /* Regeneration - generic. */
     if (art.flags.has(OF.REGEN)) {
+        randartLog("Adding 1 for regeneration - general.\n");
         data.artProbs[ART_IDX.GEN_REGEN]++;
     }
     /* Trap immunity - handle boots separately. */
     if (art.flags.has(OF.TRAP_IMMUNE)) {
         if (art.tval === TV.BOOTS) {
+            randartLog("Adding 1 for trap immunity on boots.\n");
             data.artProbs[ART_IDX.BOOT_TRAP_IMM]++;
         }
         else {
+            randartLog("Adding 1 for trap immunity - general.\n");
             data.artProbs[ART_IDX.GEN_TRAP_IMM]++;
         }
     }
     /* Activation. */
     if (art.activation || kind?.activation) {
+        randartLog("Adding 1 for activation.\n");
         data.artProbs[ART_IDX.GEN_ACTIV]++;
     }
 }
@@ -929,10 +1040,15 @@ export function countAbilities(reg, art, data) {
  * collect_artifact_data (obj-randart.c L1059): parse the standard artifacts and
  * count up the frequencies of the various abilities.
  */
-export function collectArtifactCounts(reg, data) {
-    const aMax = reg.artifacts.length;
+export function collectArtifactCounts(reg, arts, data) {
+    const aMax = arts.length;
     for (let i = 0; i < aMax; i++) {
-        const art = reg.artifacts[i] ?? null;
+        const art = arts[i] ?? null;
+        /* obj-randart.c:1066-1067 logs the index BEFORE any skip, so a cursed,
+         * tval-0 or absent entry still prints its line. Upstream reads a_info[i]
+         * out of a dense array and never has a null to guard, so the port's own
+         * null check has to come after this to keep the counts aligned. */
+        randartLogf(() => `Current artifact index is ${i}\n`);
         if (!art)
             continue;
         /* Don't parse cursed or null items. */
@@ -947,6 +1063,7 @@ export function collectArtifactCounts(reg, data) {
         }
         /* Add the base item tval to the tv_probs array. */
         data.tvProbs[kind.tval] = (data.tvProbs[kind.tval] ?? 0) + 1;
+        randartLogf(() => `Base item is ${kind.kidx}\n`);
         /* Count combat abilities broken up by type. */
         if (art.tval === TV.DIGGING ||
             art.tval === TV.HAFTED ||
@@ -1048,27 +1165,46 @@ export function adjustFreqs(data) {
  * frequencies of their abilities and base object kinds, building the dynamic
  * generation probabilities.
  */
-export function parseFrequencies(reg, data) {
+export function parseFrequencies(reg, arts, data) {
+    randartLog("\n****** BEGINNING GENERATION OF FREQUENCIES\n\n");
     /* Zero the frequencies for artifact attributes. */
     for (let i = 0; i < ART_IDX_TOTAL; i++)
         data.artProbs[i] = 0;
-    collectArtifactCounts(reg, data);
+    collectArtifactCounts(reg, arts, data);
     /* Big hack, reduce frequencies of sharp weapons. */
     for (let i = 0; i < TV_MAX; i++) {
         if (i === TV.SWORD || i === TV.POLEARM) {
             data.tvProbs[i] = Math.trunc((data.tvProbs[i] * 2) / 3);
         }
     }
+    /* "Print out some of the abilities, to make sure that everything's fine"
+     * (obj-randart.c:1295-1301). Both loops run to their FULL extent, before any
+     * rescaling - the pre- and post-rescale dumps are what make the log usable
+     * for comparing two runs. */
+    for (let i = 0; i < ART_IDX_TOTAL; i++) {
+        randartLogf(() => `Frequency of ability ${i}: ${data.artProbs[i]}\n`);
+    }
+    for (let i = 0; i < TV_MAX; i++) {
+        randartLogf(() => `Frequency of ${tvalFindName(i)}: ${data.tvProbs[i]}\n`);
+    }
     /* Rescale frequencies. */
     rescaleFreqs(data);
     /* Perform any additional rescaling and adjustment. */
     adjustFreqs(data);
+    /* "Log the final frequencies to check that everything's correct" (:1309). */
+    for (let i = 0; i < ART_IDX_TOTAL; i++) {
+        randartLogf(() => `Rescaled frequency of ability ${i}: ${data.artProbs[i]}\n`);
+    }
     /* Build a cumulative frequency table for tvals. */
     for (let i = 0; i < TV_MAX; i++) {
         for (let j = i; j < TV_MAX; j++) {
             data.tvFreq[j] = (data.tvFreq[j] ?? 0) + (data.tvProbs[i] ?? 0);
         }
     }
+    /* "Print out the frequency table, for verification" (:1319). */
+    for (let i = 0; i < TV_MAX; i++) {
+        randartLogf(() => `Cumulative frequency of ${tvalFindName(i)} is: ${data.tvFreq[i]}\n`);
+    }
 }
 /* ------------------------------------------------------------------ */
 /* Generation of a random artifact (header)                            */
@@ -1136,18 +1272,26 @@ export function artifactSetDataNew(reg) {
     };
 }
 /**
- * Allocate an ArtifactSetData and run the measurement pipeline over the
- * registry's standard artifacts: store_base_power, then parse_frequencies
- * (which runs collect_artifact_data, rescale_freqs and adjust_freqs). Returns
- * the populated data. `rng` is threaded through for parity with upstream
- * do_randart (store_base_power's fake-object build consumes no RNG for the
- * standard, curse-free artifact set).
+ * Allocate an ArtifactSetData and run the measurement pipeline over `arts`:
+ * store_base_power, then parse_frequencies (which runs collect_artifact_data,
+ * rescale_freqs and adjust_freqs). Returns the populated data. `rng` is drawn
+ * from, not merely threaded: store_base_power powers every artifact, and
+ * make_fake_artifact rolls a timeout per cursed slot (see
+ * makeFakeArtifactPower). Over the standard set that is a handful of draws;
+ * over a generated set it is one per curse the design loop added.
+ *
+ * WHICH SET is a parameter because do_randart measures TWICE (obj-randart.c
+ * L3175-L3186): once over the standard artifacts, and once more over the
+ * finished ones. Upstream can leave it implicit because create_artifact_set
+ * overwrites the a_info global in place, so "the artifacts" means a different
+ * set the second time round without anything being passed. This port generates
+ * into a fresh array and leaves reg.artifacts alone, so the set being measured
+ * has to be handed in.
  */
-export function collectArtifactData(reg, rng) {
-    void rng;
+export function collectArtifactData(reg, constants, arts, rng) {
     const data = artifactSetDataNew(reg);
-    storeBasePower(reg, data);
-    parseFrequencies(reg, data);
+    storeBasePower(reg, constants, arts, data, rng);
+    parseFrequencies(reg, arts, data);
     return data;
 }
 //# sourceMappingURL=randart-data.js.map