@rpgm-tools/neo-angband-core 0.34.2 → 1.0.0

package/src/mod/hooks.ts

@@ -71,6 +71,7 @@
  */
 
 import type { GameState } from "../game/context.js";
+import type { GameObject } from "../obj/object.js";
 import type { OptionStateData } from "../player/options.js";
 import type { Chunk } from "../world/chunk.js";
 
@@ -214,6 +215,57 @@ export interface ModHooks {
    */
   artifactCommit?: (aidx: number, alreadyCreated: boolean) => boolean;
 
+  /**
+   * A partial merge that would combine two uneven stacks, when the SOURCE
+   * stack `drained` is about to be shrunk to top up `receiving` (game/gear.ts,
+   * combinePack's call to objectAbsorbPartial - only the non-quiver branch,
+   * where the residual bug this seam exists for actually lives).
+   *
+   * Return false to refuse the merge; the two stacks are left exactly as they
+   * were, and combinePack moves on to the next candidate exactly as it would
+   * if invenCanStackPartial itself had refused. Faithful core performs the
+   * merge unconditionally - upstream's own inven_can_stack_partial has no such
+   * check, and neither does the port's line-for-line copy.
+   *
+   * READ-ONLY. Nothing about this seam invites a hook to edit `drained` or
+   * `receiving`; it decides only whether the merge proceeds, the same way
+   * artifactCommit decides only whether the commit proceeds.
+   *
+   * RNG-FREE: no rng is passed and none may be reached, matching every other
+   * seam inside the object pipeline.
+   *
+   * Serves: the bug-fixes mod's stack-charge-drift guard (#6355 residual,
+   * neostryder/neo-angband#115).
+   */
+  partialStackMerge?: (drained: GameObject, receiving: GameObject) => boolean;
+
+  /**
+   * Which handle pack_overflow should shed when its caller passed no explicit
+   * victim (game/obj-cmd.ts, packOverflow's `handle === 0` / upstream NULL
+   * branch - the safety net session/game.ts's overflowPack runs before every
+   * command, game-world.c:941-947).
+   *
+   * `departedQuiver` is the one handle GameState.gear.quiver held immediately
+   * before the recompute that just ran and no longer holds now - core's own
+   * computed fact, the same way historyAdd hands over `duplicate`. A note-only
+   * change (an inscription, say) can drop an item's preferred_quiver_slot match
+   * and displace it into the ordinary pack, turning a slot-weighted quiver
+   * stack into a full pack slot of its own and tipping an otherwise-steady pack
+   * into overflow; `departedQuiver` names that item. Null when nothing left the
+   * quiver on this recompute (an ordinary overflow from picking something up,
+   * say), in which case there is nothing to redirect toward.
+   *
+   * Return the handle to shed, or null to decline. Declining MUST be free of
+   * observable effect - core then sheds `state.gear.inven[length-1]` exactly as
+   * it would with no mod loaded, so asking a mod that declines costs nothing.
+   *
+   * RNG-FREE: no rng is passed and none may be reached.
+   *
+   * Serves: the bug-fixes mod's pack-overflow-victim correction
+   * (neostryder/neo-angband#116).
+   */
+  packOverflowVictim?: (state: GameState, departedQuiver: number | null) => number | null;
+
   /**
    * A character-history entry about to be written (session/game.ts and the
    * host's note command).
@@ -346,10 +398,11 @@ export interface ModHooks {
  * one obeys it too - see the note below for the two folds that look like
  * exceptions and are not.
  *
- *  - LAST-HANDLER hooks (walkBlockedByDiggable) are asked in REVERSE load order
- *    and stop at the first non-null, so the last mod to have an opinion is the
- *    one whose handling takes effect and no earlier mod can double-spend the
- *    energy it already paid out.
+ *  - LAST-HANDLER hooks (walkBlockedByDiggable, packOverflowVictim) are asked
+ *    in REVERSE load order and stop at the first non-null, so the last mod to
+ *    have an opinion is the one whose handling takes effect and no earlier mod
+ *    can double-spend the energy it already paid out (or, for
+ *    packOverflowVictim, second-guess a redirect an earlier mod already chose).
  *  - ORDERING hooks (objectListTiebreak) chain the same way round: the last
  *    mod's comparator is the primary key and earlier ones break the ties it
  *    leaves, which is a valid total order and is "later wins" for a comparator.
@@ -357,8 +410,8 @@ export interface ModHooks {
  *    load order, each seeing the previous one's output - so the last mod still
  *    speaks last and has the final say over the text that reaches the player,
  *    or over the radius the blast is built from.
- *  - VETO hooks (levelGenerated, artifactCommit, historyAdd) are conjunctive:
- *    every contributor runs and any refusal decides.
+ *  - VETO hooks (levelGenerated, artifactCommit, historyAdd, partialStackMerge)
+ *    are conjunctive: every contributor runs and any refusal decides.
  *  - ANY hooks (saveNoiseScent, shapeLearnObviousFlagsDirectly) are disjunctive:
  *    one mod asking for the data is enough, because the data is additive and a
  *    second mod cannot object.
@@ -416,6 +469,8 @@ export const MOD_HOOK_FOLDS: Readonly<Record<keyof ModHooks, ModHookFold>> = {
   projectionRadius: "chained",
   levelGenerated: "all-must-agree",
   artifactCommit: "all-must-agree",
+  partialStackMerge: "all-must-agree",
+  packOverflowVictim: "last-answer",
   historyAdd: "all-must-agree",
   historyDisplay: "chained",
   saveNoiseScent: "any-yes",
@@ -529,6 +584,26 @@ export function guardModHooks(
       guard("artifactCommit", () => artifact(aidx, alreadyCreated), true);
   }
 
+  const partialMerge = hooks.partialStackMerge;
+  if (partialMerge) {
+    /* PROCEED with the merge, which is what core does unconditionally without
+     * the hook. */
+    out.partialStackMerge = (drained, receiving): boolean =>
+      guard("partialStackMerge", () => partialMerge(drained, receiving), true);
+  }
+
+  const overflowVictim = hooks.packOverflowVictim;
+  if (overflowVictim) {
+    /* null is DECLINE, so core sheds the trailing inven[] entry as it would
+     * with no mod loaded. */
+    out.packOverflowVictim = (state, departedQuiver): number | null =>
+      guard(
+        "packOverflowVictim",
+        () => overflowVictim(state, departedQuiver),
+        null,
+      );
+  }
+
   const history = hooks.historyAdd;
   if (history) {
     /* WRITE the entry: faithful core writes every entry it reaches. Suppressing
@@ -656,6 +731,30 @@ export function composeModHooks(
     };
   }
 
+  const partialMerge = list.map((c) => c.partialStackMerge).filter(isFn);
+  if (partialMerge.length > 0) {
+    out.partialStackMerge = (drained, receiving): boolean => {
+      for (const fn of partialMerge) if (!fn(drained, receiving)) return false;
+      return true;
+    };
+  }
+
+  /* REVERSE load order, like walkBlockedByDiggable: the mod moved to the
+   * bottom of the list is asked first, so it is the one whose redirect wins. */
+  const overflowVictim = list
+    .map((c) => c.packOverflowVictim)
+    .filter(isFn)
+    .reverse();
+  if (overflowVictim.length > 0) {
+    out.packOverflowVictim = (state, departedQuiver): number | null => {
+      for (const fn of overflowVictim) {
+        const handle = fn(state, departedQuiver);
+        if (handle !== null) return handle;
+      }
+      return null;
+    };
+  }
+
   const history = list.map((c) => c.historyAdd).filter(isFn);
   if (history.length > 0) {
     out.historyAdd = (entry): boolean => {

package/src/mon/bind.ts

@@ -657,36 +657,94 @@ export class MonsterRegistry {
 
     this.races = [];
     this.racesByName = new Map();
+    /* Parallel to `this.races` - the raw record each bound race came from, kept
+     * for the second pass below, which needs `$from` and the ORIGINAL
+     * (unreversed) friends/shape lines to attribute a bad name to the right
+     * pack. Stays in lockstep with `this.races` because both are only pushed
+     * to on the same non-rejected path. */
+    const raceRecs: MonsterRecordJson[] = [];
     for (const rec of pack.monsters) {
       if (this.rejectDuplicateName(rec)) continue;
+      if (this.rejectMissingBase(rec)) continue;
       const race = this.bindRace(rec, maxSight, innate, breathOrInnate);
       /* Keys core does not read ride along instead of being dropped - the same
        * seam as ObjectKind.ext, for the same reason. */
       this.races.push(attachExt("monster", rec, race));
       this.racesByName.set(race.name.toLowerCase(), race);
+      raceRecs.push(rec);
     }
 
-    /* finish_parse_monster: resolve friends and shape names to races. */
-    for (const race of this.races) {
-      for (const f of race.friends) {
+    /*
+     * finish_parse_monster: resolve friends and shape names to races.
+     *
+     * `friends:` and `shape:` NAME OTHER RACES, from monster.json - the same
+     * mod-appendable list `base` (below) and monster_base.json's own entries
+     * come from - so a friend or shape a mod names can go missing exactly the
+     * way an ego's `item:` line does: mod A gives a monster a friend mod B
+     * defines, the player disables mod B. It used to throw `mon: could not
+     * find friend/shape named ...` out of `bindCore` for the whole game.
+     *
+     * ONE ENTRY LOST IS THE RIGHT SIZE, unlike `base` below: a race with one
+     * fewer scripted friend or shape still functions, the same reasoning the
+     * ego binder's `poss_items` uses. Iterated backwards so `splice` during
+     * the walk cannot skip the entry after the one just removed.
+     */
+    this.races.forEach((race, i) => {
+      const rec = raceRecs[i] as MonsterRecordJson;
+      const from = provenanceOf(rec);
+      const rawFriends = [...(rec.friends ?? [])].reverse();
+      for (let fi = race.friends.length - 1; fi >= 0; fi--) {
+        const f = race.friends[fi] as MonsterFriends;
         f.race =
           f.name.toLowerCase() === "same" ? race : this.raceByName(f.name);
-        if (!f.race) {
+        if (f.race) continue;
+        const owner = fieldOwner(from, "friends", rawFriends[fi]);
+        if (owner === null || from === undefined) {
           throw new Error(
             `mon: could not find friend named '${f.name}' for '${race.name}'`,
           );
         }
+        this.refused.push({
+          file: "monster",
+          record: race.name,
+          field: "friends",
+          id: owner,
+          why: refusalWhy(
+            race.name,
+            "friend dropped",
+            `could not find friend named '${f.name}'`,
+            from,
+          ),
+        });
+        race.friends.splice(fi, 1);
       }
-      for (const s of race.shapes) {
+      const rawShapes = [...(rec.shape ?? [])].reverse();
+      for (let si = race.shapes.length - 1; si >= 0; si--) {
+        const s = race.shapes[si] as MonsterShape;
         if (s.base) continue;
         s.race = this.raceByName(s.name);
-        if (!s.race) {
+        if (s.race) continue;
+        const owner = fieldOwner(from, "shape", rawShapes[si]);
+        if (owner === null || from === undefined) {
           throw new Error(
             `mon: could not find shape named '${s.name}' for '${race.name}'`,
           );
         }
+        this.refused.push({
+          file: "monster",
+          record: race.name,
+          field: "shape",
+          id: owner,
+          why: refusalWhy(
+            race.name,
+            "shape dropped",
+            `could not find shape named '${s.name}'`,
+            from,
+          ),
+        });
+        race.shapes.splice(si, 1);
       }
-    }
+    });
 
     this.summons = pack.summons.map((rec) => ({
       name: rec.name,
@@ -739,6 +797,39 @@ export class MonsterRegistry {
     return true;
   }
 
+  /**
+   * `base:` IS THE RACE, the same way an artifact's `base-object:` is the
+   * artifact: every field a race binds - the default glyph, the inherited
+   * flags - starts from the template it names, so a race whose base does not
+   * resolve is not a race at all. `base` names a MonsterBase, from
+   * monster_base.json, and that list is exactly as mod-appendable as
+   * monster.json itself - mod A gives a race a base mod B defines, the
+   * player disables mod B, and this used to throw `mon: race ... invalid
+   * base` out of `bindCore` for the whole game.
+   *
+   * DROPPING THE WHOLE RACE, not one field of it, is the artifact binder's
+   * answer applied here: `ridx` is assigned by push order same as `aidx`, and
+   * core's pack composes before any mod's, so a drop can only shift a mod's
+   * own races relative to each other - the same outcome as that mod being
+   * off.
+   */
+  private rejectMissingBase(rec: MonsterRecordJson): boolean {
+    if (this.bases.has(rec.base)) return false;
+    const from = provenanceOf(rec);
+    const owner = fieldOwner(from, "base", rec.base);
+    if (owner === null || from === undefined) {
+      throw new Error(`mon: race ${rec.name}: invalid base ${rec.base}`);
+    }
+    this.refused.push({
+      file: "monster",
+      record: rec.name,
+      field: "base",
+      id: owner,
+      why: refusalWhy(rec.name, "race dropped", `unknown base ${rec.base}`, from),
+    });
+    return true;
+  }
+
   /**
    * lookup_monster (mon-util.c): exact case-insensitive match first,
    * else the first race (lowest ridx) whose name contains the query as
@@ -764,6 +855,11 @@ export class MonsterRegistry {
     innate: FlagSet,
     breathOrInnate: FlagSet,
   ): MonsterRace {
+    /* SAFETY NET, not a live path: the constructor's `rejectMissingBase` has
+     * already refused or thrown on a race whose base does not resolve, so
+     * `bindRace` is only ever called with one that does. Kept and documented
+     * rather than cast away, so a future caller added without going through
+     * that guard fails loudly instead of reading `base` as `undefined`. */
     const base = this.bases.get(rec.base);
     if (!base) {
       throw new Error(`mon: race ${rec.name}: invalid base ${rec.base}`);
@@ -858,13 +954,36 @@ export class MonsterRegistry {
       });
     }
 
+    /* `friends-base:` names a MonsterBase - the same mod-appendable list
+     * `base:` above resolves against - so a mod's friends-base line can go
+     * missing exactly the way `base:` can, except one lost entry still
+     * leaves a working race (unlike `base:`, which the whole race needs).
+     * The store binder's pattern applies at this granularity: the entry is
+     * the unit of provenance and of loss. */
+    const from = provenanceOf(rec);
     const friendsBase: MonsterFriendsBase[] = [];
     for (const f of [...(rec["friends-base"] ?? [])].reverse()) {
       const fb = this.bases.get(f.name);
       if (!fb) {
-        throw new Error(
-          `mon: race ${rec.name}: invalid friends base ${f.name}`,
-        );
+        const owner = fieldOwner(from, "friends-base", f);
+        if (owner === null || from === undefined) {
+          throw new Error(
+            `mon: race ${rec.name}: invalid friends base ${f.name}`,
+          );
+        }
+        this.refused.push({
+          file: "monster",
+          record: rec.name,
+          field: "friends-base",
+          id: owner,
+          why: refusalWhy(
+            rec.name,
+            "friends-base entry dropped",
+            `unknown base ${f.name}`,
+            from,
+          ),
+        });
+        continue;
       }
       const num = parseNumberPair(f.number);
       friendsBase.push({

package/src/obj/bind.ts

@@ -824,13 +824,34 @@ export class ObjRegistry {
   private bindCurses(records: CurseRecordJson[]): void {
     for (let r = records.length - 1; r >= 0; r--) {
       const rec = records[r] as CurseRecordJson;
+      const from = provenanceOf(rec);
       const poss: boolean[] = new Array<boolean>(TV_MAX).fill(false);
       for (const tvalName of rec.type ?? []) {
         const tval = tvalFindIdx(tvalName);
-        if (tval < 0 || tval >= TV_MAX) {
+        if (tval >= 0 && tval < TV_MAX) {
+          poss[tval] = true;
+          continue;
+        }
+        /*
+         * `type:` NAMES A TVAL, from the same fixed table `object:`'s own
+         * `type:` line reads - not a record another pack could remove, but a
+         * mod can still misspell it on a curse it authors itself. Same
+         * whole-field granularity as the artifact `flags`/`values` fix above:
+         * one bad entry in the list is dropped, and whether it is core's
+         * mistake or a mod's is decided by whether anything touched `type` at
+         * all.
+         */
+        const owner = fieldOwner(from, "type", rec.type);
+        if (owner === null || from === undefined) {
           throw new Error(`curse: unknown tval ${tvalName}`);
         }
-        poss[tval] = true;
+        this.refused.push({
+          file: "curse",
+          record: rec.name,
+          field: "type",
+          id: owner,
+          why: refusalWhy(rec.name, "type entry dropped", `unknown tval ${tvalName}`, from),
+        });
       }
       const objFlags = newOfFlags();
       const elInfo = newElemInfo();
@@ -1262,11 +1283,21 @@ export class ObjRegistry {
        * situation as that mod not being installed, which is what the player just
        * asked for.
        *
-       * NOTE what is NOT covered: an invalid `flags`, `values` or `act` token on a
-       * mod's artifact still throws. Those are worth doing and are not this change,
-       * because each one needs its loop turned into something that can report
-       * instead of throw, inside a binder that is parity-sensitive. base-object is
-       * the field the tutorial teaches and the one a disabled dependency breaks.
+       * `flags` and `values` get the same treatment below, at the WHOLE-FIELD
+       * granularity `curseWeightConflict` established rather than per store's
+       * per-entry one: a `flags:` line can pack several tokens together
+       * ("SEE_INVIS | IGNORE_ACID"), so there is no single list entry to match
+       * against `was` the way a store's stock line or an ego's `item:` line
+       * has. What IS answerable is whether the field as a whole is core's
+       * untouched data or something a pack touched, and that is what decides
+       * throw-versus-drop; the offending TOKEN is still named in the report.
+       *
+       * `act` is deliberately NOT covered, and that is not an omission: findact
+       * (obj-init.c parse_artifact_act) never null-checks its own result either,
+       * so an artifact whose `act:` names nothing already gets a powerless
+       * activation upstream, silently, on core's own data. Refusing it here
+       * would make a mod's typo LOUDER than the same mistake in core's own
+       * artifact.txt, which is backwards.
        */
       const from = provenanceOf(rec);
       /* Restored on the refusal paths below: resolving an sval can APPEND a dummy
@@ -1305,7 +1336,18 @@ export class ObjRegistry {
       const flags = newOfFlags();
       for (const tok of tokens(rec.flags)) {
         const found = grabFlag(flags, OF, tok) || grabElementFlag(elInfo, tok);
-        if (!found) throw new Error(`artifact: invalid flag ${tok}`);
+        if (found) continue;
+        const owner = fieldOwner(from, "flags", rec.flags);
+        if (owner === null || from === undefined) {
+          throw new Error(`artifact: invalid flag ${tok}`);
+        }
+        this.refused.push({
+          file: "artifact",
+          record: rec.name,
+          field: "flags",
+          id: owner,
+          why: refusalWhy(rec.name, "flag dropped", `invalid flag ${tok}`, from),
+        });
       }
       const modifiers = new Array<number>(OBJ_MOD_MAX).fill(0);
       for (const tok of tokens(rec.values)) {
@@ -1316,7 +1358,19 @@ export class ObjRegistry {
           (elInfo[res.index] as ElementInfo).resLevel = res.value;
           found = true;
         }
-        if (!found) throw new Error(`artifact: invalid value ${tok}`);
+        if (!found) {
+          const owner = fieldOwner(from, "values", rec.values);
+          if (owner === null || from === undefined) {
+            throw new Error(`artifact: invalid value ${tok}`);
+          }
+          this.refused.push({
+            file: "artifact",
+            record: rec.name,
+            field: "values",
+            id: owner,
+            why: refusalWhy(rec.name, "value dropped", `invalid value ${tok}`, from),
+          });
+        }
       }
       const special = kind.kidx >= this.ordinaryKindCount;
       if (rec.graphics) {

package/src/rng.ts

@@ -395,7 +395,7 @@ export class Rng {
    * for setState() - which is the SAVEFILE path and deliberately forces quick
    * off (see its comment). A quick generator reseeded that way is handed an
    * all-zero WELL table, and an all-zero WELL state is a fixed point: it emits
-   * zero forever. The Borg's per-think reseed did exactly this, and the reason
+   * zero forever. Borg's per-think reseed did exactly this, and the reason
    * it went unnoticed for so long is that its test asserted two generators
    * produced the SAME sequence, which a generator stuck at zero satisfies
    * perfectly.

package/src/session/game.ts

@@ -987,12 +987,18 @@ function wireGame(
     rogueLike: state.options?.get("rogue_like_commands") ?? false,
     characterDungeon: true,
     ...(state.msg ? { msg: state.msg } : {}),
+    /* The partialStackMerge / packOverflowVictim seams (mod/hooks.ts). */
+    ...(state.modHooks ? { hooks: state.modHooks } : {}),
   });
   /* game-world.c:941-947: the C refreshes upkeep->inven[] before its
    * catch-all pack_overflow(NULL).  This closure has the same live
    * calc_inventory inputs used by pickup and command paths, preserving the
    * earlier_object order of the derived gear.inven view. */
   state.overflowPack = (): void => {
+    /* GameState.gear.quiver as it stood before this recompute, for the
+     * packOverflowVictim seam - the one point that catches an inscription (or
+     * any other note-only change) displacing an item out of the quiver. */
+    const previousQuiver = [...(state.gear.quiver ?? [])];
     const calcInv = liveCalcInv();
     /* notice_stuff()/handle_stuff() precede pack_overflow(NULL) at
      * game-world.c:941-947; materialize the current upkeep->inven[] analogue
@@ -1000,7 +1006,9 @@ function wireGame(
     calcInventory(state.gear, reg.constants, calcInv);
     packOverflow(state, 0, reg.constants, {
       calcInv,
+      previousQuiver,
       ...(state.msg ? { msg: state.msg } : {}),
+      ...(state.modHooks ? { hooks: state.modHooks } : {}),
     });
   };
   /* notice_stuff's PN_COMBINE branch (player-calcs.c L2546-2549). combine_pack

package/src/store/bind.ts

@@ -58,7 +58,7 @@ import type {
  * list; all three lose a single entry. `store` is the entrance feature, which
  * is a scalar and costs the whole shop.
  */
-export type StoreField = "normal" | "always" | "buy" | "store";
+export type StoreField = "normal" | "always" | "buy" | "store" | "owner";
 
 /**
  * The entrance feature of a store whose `store:` a mod pointed at a feature
@@ -111,6 +111,7 @@ function resolveKind(item: StoreItemJson, reg: ObjRegistry): StockResolution {
 function lostWhat(field: StoreField): string {
   if (field === "store") return "shop cannot be entered";
   if (field === "buy") return "buy list entry dropped";
+  if (field === "owner") return "owner list dropped";
   return `${field} stock line dropped`;
 }
 
@@ -159,12 +160,6 @@ export function bindStore(
   reg: ObjRegistry,
   refused?: RecordRefusal[],
 ): BoundStore {
-  const owners: StoreOwner[] = rec.owner.map((o, index) => ({
-    index,
-    name: o.name,
-    maxCost: o.purse,
-  }));
-
   const from = provenanceOf(rec);
   /** One refusal for this record, so four call sites cannot disagree. */
   const refusal = (
@@ -179,6 +174,43 @@ export function bindStore(
     id,
     why: refusalWhy(rec.store, lostWhat(field), why, prov),
   });
+
+  /*
+   * `owner:` IS A REQUIRED LIST, and unlike every other field this binder
+   * refuses, nothing inside it names another record - MOD_COMPATIBILITY.md
+   * already says as much: "the owner list resolves no names at all and so has
+   * nothing to refuse". What that line did not cover is the field going
+   * missing ENTIRELY. `replaces` on a record a mod owns can legitimately drop
+   * fields the replacing body means to remove - that is how a total
+   * conversion works, and composeContentPacks's own shape guard
+   * (mod-sdk/compose.ts, `unreadableShape`) deliberately does not restore a
+   * field that is simply ABSENT, because "gone" and "total conversion left it
+   * out on purpose" are indistinguishable from the composer's side. So a
+   * `replaces` body that forgets `owner:` on a record a mod owns reaches this
+   * line with `rec.owner` undefined, and `rec.owner.map` was a bare
+   * TypeError with no pack named - the same crash this file exists to close,
+   * one field up from a stock line.
+   *
+   * AN EMPTY OWNER LIST IS THE SIZE OF THE DROP: the store keeps functioning
+   * (turnover, stock, buy) with nobody to haggle against, which is a strictly
+   * smaller loss than the shop vanishing or the boot failing.
+   */
+  const ownerRecords = Array.isArray(rec.owner) ? rec.owner : null;
+  let owners: StoreOwner[];
+  if (ownerRecords) {
+    owners = ownerRecords.map((o, index) => ({
+      index,
+      name: o.name,
+      maxCost: o.purse,
+    }));
+  } else {
+    const owner = fieldOwner(from, "owner", rec.owner);
+    if (owner === null || from === undefined) {
+      throw new Error(`store: ${rec.store}: owner is missing or not a list`);
+    }
+    refused?.push(refusal("owner", "owner list missing or not a list", owner, from));
+    owners = [];
+  }
   /**
    * One stock line, or null when it resolved to nothing and was a mod's to get
    * wrong. A core-owned miss throws here with exactly the message it always

package/src/version.ts

@@ -13,14 +13,15 @@ export const PARITY_BASELINE = "4.2.6";
 /**
  * Port version, tracked independently of the baseline.
  *
- * Semver, and 0.x is the pre-release line: a feature release bumps the MINOR
- * number, so 0.9.0 is followed by 0.10.0 rather than by 1.0.0. That is worth
- * stating because the first reading of "0.9.0" is "nearly 1.0", and it is not -
- * 1.0.0 is reserved for the public release and the line can run as far as it needs
- * to before then.
+ * Standard Semantic Versioning as of 1.0.0, the public release: a breaking
+ * change to the API, save format, or mod interfaces is a MAJOR bump, a
+ * backward-compatible feature is MINOR, and a fix is PATCH. Before this,
+ * `0.x` was the pre-release line, where every feature release bumped the
+ * MINOR number instead (0.9.0 was followed by 0.10.0 rather than 1.0.0).
  *
  * Each mod carries its own version and moves on its own schedule; a mod whose
- * released tag is iterated takes a MINOR bump, because a published tag is pinned
- * by digest in a catalogue and must never be moved.
+ * released tag needs to be superseded takes whatever bump its actual change
+ * warrants, because a published tag is pinned by digest in a catalogue and
+ * must never be moved.
  */
-export const ENGINE_VERSION = "0.34.2";
+export const ENGINE_VERSION = "1.0.0";

package/src/world/feature.ts

@@ -10,7 +10,9 @@
 import { FlagSet } from "../bitflag.js";
 import { FEAT, RF, TERRAIN_ENTRIES, TERRAIN_FLAG_ENTRIES, TF } from "../generated/index.js";
 import type { ModExtensible } from "../mod/extension.js";
-import { attachExt } from "../mod/extension.js";
+import { attachExt, provenanceOf } from "../mod/extension.js";
+import { fieldOwner, refusalWhy } from "../mod/refusal.js";
+import type { RecordRefusal } from "../mod/refusal.js";
 
 /** Byte size of a terrain FlagSet (upstream TF_SIZE). */
 export const TF_SIZE = Math.ceil(TERRAIN_FLAG_ENTRIES.length / 8);
@@ -155,6 +157,12 @@ export class FeatureRegistry {
   /** fidx of each shop entrance, indexed by store number (shopnum - 1). */
   private shopFeatIdx: number[] = [];
 
+  /**
+   * Mod-owned terrain records whose `mimic:` named a feature that does not
+   * resolve. Empty for the shipped pack with no mods loaded.
+   */
+  readonly refused: RecordRefusal[] = [];
+
   constructor(records: TerrainRecordJson[]) {
     const featMap = FEAT as Record<string, number>;
     for (const rec of records) {
@@ -188,14 +196,44 @@ export class FeatureRegistry {
       this.byCode.set(rec.code, feature);
       this.byName.set(rec.name, feature);
     }
-    // Second pass: resolve mimic references by code.
+    /*
+     * Second pass: resolve mimic references by code.
+     *
+     * `mimic:` NAMES ANOTHER TERRAIN RECORD, and a mod's terrain.json entries
+     * are exactly the mod-appendable list `code:` and every other lookup here
+     * cannot be: FEAT codes are the fixed table list-terrain.h compiles, so a
+     * mod cannot invent a new one, but it CAN patch an existing feature's
+     * `mimic:` to point at a feature a sibling mod supplies - the same
+     * "mod A depends on mod B, player disables mod B" shape the store and ego
+     * binders already answer. This used to throw `terrain: mimic not found`
+     * out of `bindCore` for the whole game over one feature's display alias.
+     *
+     * LOSING THE MIMIC IS THE SIZE OF THE DROP, matching the store binder's
+     * entrance-feature case: `mimic` is a scalar (one feature, or none), so
+     * there is no smaller unit to drop than the field itself, and the record
+     * survives exactly as it would if `mimic:` had never been written -
+     * displayed with its own glyph rather than the target's.
+     */
     for (const rec of records) {
-      if (rec.mimic !== undefined) {
-        const f = this.byCode.get(rec.code) as Feature;
-        const target = this.byCode.get(rec.mimic);
-        if (!target) throw new Error(`terrain: mimic not found: ${rec.mimic}`);
+      if (rec.mimic === undefined) continue;
+      const f = this.byCode.get(rec.code) as Feature;
+      const target = this.byCode.get(rec.mimic);
+      if (target) {
         f.mimic = target.fidx;
+        continue;
+      }
+      const from = provenanceOf(rec);
+      const owner = fieldOwner(from, "mimic", rec.mimic);
+      if (owner === null || from === undefined) {
+        throw new Error(`terrain: mimic not found: ${rec.mimic}`);
       }
+      this.refused.push({
+        file: "terrain",
+        record: rec.code,
+        field: "mimic",
+        id: owner,
+        why: refusalWhy(rec.code, "mimic dropped", `mimic not found: ${rec.mimic}`, from),
+      });
     }
     /*
      * finish_parse_feat (init.c L2249-2257, L2275): "Assign shop index based