@rpgm-tools/neo-angband-core 0.28.0 → 0.29.0

package/src/mod/record-keys.ts

@@ -28,7 +28,7 @@ export const CORE_RECORD_KEYS: Readonly<Record<string, readonly string[]>> = {
   "curse": ["combat", "conflict", "conflict-flags", "desc", "effect", "flags", "msg", "name", "time", "type", "values"],
   "dungeon_profile": ["alloc", "min-level", "name", "params", "room", "streamer", "tunnel"],
   "ego_item": ["alloc", "brand", "combat", "desc", "flags", "flags-off", "info", "item", "min-combat", "min-values", "name", "slay", "type", "values"],
-  "flavor": ["fixed", "flavor", "kind"],
+  "flavor": ["entries", "kind"],
   "hints": ["H"],
   "history": ["chart", "phrase"],
   "monster": ["armor-class", "base", "blow", "color", "color-cycle", "depth", "desc", "drop", "drop-base", "drop-order", "experience", "flags", "flags-off", "friends", "friends-base", "glyph", "hearing", "hit-points", "innate-freq", "light", "message-invis", "message-vis", "mimic", "name", "plural", "rarity", "shape", "sleepiness", "smell", "speed", "spell-freq", "spell-power", "spells"],
@@ -82,10 +82,9 @@ export const CORE_RECORD_KEYS: Readonly<Record<string, readonly string[]>> = {
  * `ext`, believe the patch worked, and never learn the real field went
  * untouched. The namespace is also what stops two mods coining the same word
  * from silently overwriting each other. The rule is enforced at composition
- * (mod-sdk fields.ts): the owning mod must DECLARE the field, and another pack
- * may write it only when it declares that owner as a dependency. This is the
- * same rule at the other end, so a record that reached core by some other route
- * cannot bypass it.
+ * (mod-sdk fields.ts), which additionally requires the owning mod to have
+ * DECLARED the field; this is the same rule at the other end, so a record that
+ * reached core by some other route cannot bypass it.
  */
 export function extensionData(
   file: string,

package/src/mod/save-blocks.ts

@@ -86,7 +86,19 @@ export interface SavePackRef {
   id: string;
   /** Semver version string, e.g. "1.2.0". */
   version: string;
-  /** Content hash of the pack that produced the save (optional). */
+  /**
+   * Content hash of the pack that produced the save (optional).
+   *
+   * ABSENT MEANS UNMEASURED, NEVER "UNCHANGED" - the same convention
+   * `InstalledModMeta.digests` and `SessionMod.digest` already use on the web
+   * side. Compared by `mismatchedNamespaces` (below) against the SAME
+   * namespace's current hash, when a caller has one: this is what lets a load
+   * tell "this pack patched a record instead of only adding one, and the
+   * patch is now different or gone" apart from an ordinary reload, which
+   * `orphanedNamespaces` alone cannot (issue #20) - a PATCHED core record
+   * still resolves under core's own, still-present namespace, so no entity is
+   * ever orphaned by the patch going away.
+   */
   hash?: string;
   /** Source (git URL + ref, or marketplace id) the pack was installed from. */
   source?: string;
@@ -269,6 +281,71 @@ export function orphanedNamespaces(
   return out;
 }
 
+/**
+ * Compare the pack set that produced a save against the packs present NOW,
+ * for the namespaces on BOTH sides - the sibling case `orphanedNamespaces`
+ * cannot see (issue #20). A pack that ADDS content and later goes away leaves
+ * an orphan behind (its own ids no longer resolve, so quarantine catches it);
+ * a pack that only PATCHES an existing record - a session mod re-pricing a
+ * core sword's damage, say - leaves nothing behind to orphan, because the
+ * record it touched still resolves under its own, still-present namespace.
+ * The composed value from save time is simply gone, silently, on the next
+ * load. This is that load's chance to notice: it returns the namespaces whose
+ * recorded hash and current hash are both known and disagree.
+ *
+ * "core" is never reported: core's own content changing between builds is an
+ * engine-version question (ENGINE_VERSION / SAVE_VERSION), not a mod-patch one.
+ *
+ * A namespace missing a hash on EITHER side is never reported - not measured
+ * is not the same claim as changed, and a false "this mod changed" alarm off
+ * a gap in the data would be worse than the silent gap this function exists
+ * to close. `currentPacks` need not cover every present namespace: a caller
+ * that cannot measure a pack's current content simply omits it, and that
+ * pack's own comparison is skipped rather than guessed at.
+ */
+export function mismatchedNamespaces(
+  manifest: SaveManifest,
+  currentPacks: readonly SavePackRef[],
+): string[] {
+  const current = new Map(currentPacks.map((p) => [p.id, p]));
+  const out: string[] = [];
+  for (const recorded of manifest.packs) {
+    if (recorded.id === "core") continue;
+    if (!recorded.hash) continue;
+    const now = current.get(recorded.id);
+    if (!now?.hash) continue;
+    if (now.hash !== recorded.hash) out.push(recorded.id);
+  }
+  return out;
+}
+
+/**
+ * Fold the packs present now into a manifest's pack list, for the NEXT save to
+ * carry forward: a namespace `currentPacks` supplies replaces whatever was
+ * recorded for it (so a changed hash/version is what the next
+ * `mismatchedNamespaces`/`orphanedNamespaces` call compares against); a
+ * namespace it does NOT supply keeps its old recorded entry untouched, rather
+ * than being dropped, so a pack this host cannot currently measure - or one
+ * that has gone away entirely - is still there for `orphanedNamespaces` to
+ * find missing later. Pure: neither argument is mutated.
+ */
+export function reconcilePackManifest(
+  manifest: SaveManifest,
+  currentPacks: readonly SavePackRef[],
+): SaveManifest {
+  const current = new Map(currentPacks.map((p) => [p.id, p]));
+  const seen = new Set<string>();
+  const packs: SavePackRef[] = [];
+  for (const recorded of manifest.packs) {
+    packs.push(current.get(recorded.id) ?? recorded);
+    seen.add(recorded.id);
+  }
+  for (const pack of currentPacks) {
+    if (!seen.has(pack.id)) packs.push(pack);
+  }
+  return { ...manifest, packs };
+}
+
 /** The version each pack was at when the save was written (for orphan keys). */
 function versionMap(manifest: SaveManifest): Map<string, string> {
   const m = new Map<string, string>();

package/src/obj/bind.ts

@@ -1486,12 +1486,35 @@ export class ObjRegistry {
     for (const rec of records) {
       const tval = tvalFindIdx(rec.kind.tval);
       if (tval <= 0) throw new Error(`flavor: unknown tval ${rec.kind.tval}`);
-      const bindEntry = (entry: {
-        index: number;
-        sval?: string;
-        attr: string;
-        desc?: string;
-      }): void => {
+      /*
+       * FILE ORDER, DIRECTLY. flavor.txt writes a record's `fixed:` lines
+       * above its `flavor:` lines (rings L18-30 before L32-73, amulets
+       * L90-101 before L104-117), and upstream's parser builds one list in
+       * the order the lines arrive - so this array has to be in that order
+       * too. It is not cosmetic: `flavorInit` walks this list BACKWARDS to
+       * reproduce C's prepend-into-a-linked-list (obj/flavor.ts,
+       * flavor_assign_random), so a flavour's position in it is what decides
+       * which kind it lands on.
+       *
+       * A binder that bound every `flavor:` line before every `fixed:` line
+       * was invisible in an ordinary game, because a fixed flavour keeps its
+       * own sval and `flavor_assign_random` skips it - the random ones kept
+       * their relative order and every potion looked right. Under
+       * `birth_randarts` it was not: `flavor_reset_fixed` scrubs every fixed
+       * sval but the One Ring's, which throws all eight ring and amulet
+       * `fixed:` entries into the random pool, and they landed at the wrong
+       * end of the list. Same number of RNG draws either way, so the stream
+       * never moved and nothing downstream diverged - it just handed out the
+       * wrong gems.
+       *
+       * `entries` (issue #2) is what makes this correct for ANY line order,
+       * not just the shipped fixed-then-flavor layout: the content compiler
+       * emits one list per record, already in file order, with `kind` naming
+       * which directive produced each entry - so a mod's flavor.txt that
+       * interleaves `fixed:` and `flavor:` binds in its own true order
+       * instead of always fixed-first.
+       */
+      for (const entry of rec.entries) {
         let sval = SV_UNKNOWN;
         if (entry.sval !== undefined) {
           sval = this.lookupSval(tval, entry.sval);
@@ -1504,34 +1527,7 @@ export class ObjRegistry {
           dChar: rec.kind.glyph,
           text: entry.desc ?? "",
         });
-      };
-      /*
-       * FIXED FIRST, WHICH IS FILE ORDER. flavor.txt writes a record's
-       * `fixed:` lines above its `flavor:` lines (rings L18-30 before L32-73,
-       * amulets L90-101 before L104-117), and the parser builds one list in
-       * the order the lines arrive - so this array has to be in that order too.
-       * It is not cosmetic: `flavorInit` walks this list BACKWARDS to reproduce
-       * C's prepend-into-a-linked-list (obj/flavor.ts, flavor_assign_random),
-       * so a flavour's position in it is what decides which kind it lands on.
-       *
-       * Binding `flavor:` first was invisible in an ordinary game, because a
-       * fixed flavour keeps its own sval and `flavor_assign_random` skips it -
-       * the random ones kept their relative order and every potion looked
-       * right. Under `birth_randarts` it was not: `flavor_reset_fixed` scrubs
-       * every fixed sval but the One Ring's, which throws all eight ring and
-       * amulet `fixed:` entries into the random pool, and they were at the
-       * wrong end of the list. Same number of RNG draws either way, so the
-       * stream never moved and nothing downstream diverged - it just handed
-       * out the wrong gems.
-       *
-       * The compiled record splits the two into separate arrays, so a record
-       * that INTERLEAVED them could not be reproduced from this shape at all.
-       * Nothing shipped does, and recovering it would mean the compiler
-       * emitting one ordered list; the entry `index` cannot stand in for it,
-       * since flavor.txt's own numbering is not the order it writes them in.
-       */
-      for (const entry of rec.fixed ?? []) bindEntry(entry);
-      for (const entry of rec.flavor ?? []) bindEntry(entry);
+      }
     }
   }
 

package/src/obj/types.ts

@@ -318,7 +318,14 @@ export interface ObjectPropertyRecordJson {
   bindui?: unknown;
 }
 
+/**
+ * One `flavor:` or `fixed:` line. `kind` tags which directive it came from -
+ * only a `fixed:` line carries `sval` - and its position in the record's
+ * `entries` array is the file's true line order (issue #2): flavor.txt's own
+ * `index` numbering is not that order, so it cannot stand in for it.
+ */
 export interface FlavorEntryJson {
+  kind: "flavor" | "fixed";
   index: number;
   sval?: string;
   attr: string;
@@ -327,8 +334,8 @@ export interface FlavorEntryJson {
 
 export interface FlavorRecordJson {
   kind: { tval: string; glyph: string };
-  flavor?: FlavorEntryJson[];
-  fixed?: FlavorEntryJson[];
+  /** `flavor:` and `fixed:` lines, ONE list, in the order flavor.txt writes them. */
+  entries: FlavorEntryJson[];
 }
 
 /** The full bundle of pack JSON record arrays the registry binds from. */

package/src/session/game.ts

@@ -337,10 +337,17 @@ import { migrateSave } from "./save-migrate.js";
 import { ContentIdResolver } from "../mod/ids.js";
 import {
   coreOnlyManifest,
+  mismatchedNamespaces,
   quarantineSave,
+  reconcilePackManifest,
   rehydrateSave,
 } from "../mod/save-blocks.js";
-import type { ModBag, OrphanStore, SaveManifest } from "../mod/save-blocks.js";
+import type {
+  ModBag,
+  OrphanStore,
+  SaveManifest,
+  SavePackRef,
+} from "../mod/save-blocks.js";
 
 /**
  * The getItem seam body (cmd_get_item's "tgtitem" fast path, cmd-core.c L1060):
@@ -518,6 +525,17 @@ export interface StartedGame {
   orphans: OrphanStore;
   /** decision-8: whether the one-time orphan keep/purge prompt has been shown. */
   orphansAcknowledged: boolean;
+  /**
+   * Namespaces present now whose recorded content hash no longer matches
+   * their current one (issue #20, save-blocks.ts mismatchedNamespaces): a
+   * pack that PATCHED a record - a session mod re-pricing a core sword,
+   * say - instead of only adding one, so nothing was orphaned when the patch
+   * changed or the pack went away. Empty on a core-only game, on a save
+   * written before this field, and whenever the loading host supplied no
+   * `currentPacks` (or none with a measurable hash) to compare against -
+   * absent evidence is not evidence of a match.
+   */
+  mismatchedPacks: readonly string[];
   /**
    * What loadGame had to convert to read this save (session/save-migrate.ts).
    * Absent on a new game and on a save already at SAVE_VERSION. `applied` is one
@@ -3792,6 +3810,7 @@ export function startGame(pack: GamePack, opts: StartGameOptions = {}): StartedG
     mods: {},
     orphans: {},
     orphansAcknowledged: false,
+    mismatchedPacks: [],
     options,
     randartSeed,
     changeLevel,
@@ -4211,6 +4230,19 @@ export interface LoadGameOptions {
    * entry (WP-14) passes this; a normal load leaves it false.
    */
   wizard?: boolean;
+  /**
+   * The content digest this host can measure RIGHT NOW for each present pack
+   * (issue #20) - one `SavePackRef` per namespace it can hash, with the pack's
+   * CURRENT id/version/hash, not the save's recorded one. Compared against
+   * the save's own recorded manifest (`mismatchedNamespaces`) to catch a
+   * pack that PATCHED a record rather than only adding one, then folded into
+   * the manifest this load returns (`reconcilePackManifest`) so the NEXT save
+   * carries today's hash forward. Omitting an entry for a present namespace
+   * is the honest "cannot measure this one yet" - it is compared against
+   * nothing and never flagged as a mismatch. Absent/empty: no pack is
+   * compared or updated, which is the behavior before this option existed.
+   */
+  currentPacks?: readonly SavePackRef[];
 }
 
 export function loadGame(
@@ -4276,9 +4308,23 @@ export function loadGame(
     modNoscore: saveIn.manifest?.modNoscore ?? false,
   };
   const isPresent = (ns: string): boolean => present.has(ns);
+
+  /* Issue #20's sibling check: a pack that PATCHED a record (rather than only
+   * adding one) leaves nothing for quarantine to catch when the patch changes
+   * or the pack goes away, because the record still resolves under its own,
+   * still-present namespace. Computed against the manifest AS RECORDED, before
+   * folding in what the host can measure now, so a genuinely different hash is
+   * what gets reported rather than something this call just overwrote.
+   * `reconcilePackManifest` then carries today's hash forward for the NEXT
+   * save - a namespace the host cannot measure keeps its old recorded entry,
+   * exactly as if this option had not been passed. */
+  const currentPacks = opts.currentPacks ?? [];
+  const mismatchedPacks = mismatchedNamespaces(manifest, currentPacks);
+  const reconciledManifest = reconcilePackManifest(manifest, currentPacks);
+
   const quarantine = quarantineSave(
     rehydrateSave(saveIn, isPresent),
-    manifest,
+    reconciledManifest,
     isPresent,
   );
   const save = quarantine.save;
@@ -4680,10 +4726,11 @@ export function loadGame(
     flavor: wired.flavor,
     everseen: wired.everseen,
     seedFlavor,
-    manifest,
+    manifest: reconciledManifest,
     mods: save.mods ?? {},
     orphans: quarantine.orphans,
     orphansAcknowledged: save.orphansAcknowledged ?? false,
+    mismatchedPacks,
     ...(migration.applied.length > 0 || migration.notes.length > 0
       ? { saveMigration: { applied: migration.applied, notes: migration.notes } }
       : {}),

package/src/version.ts

@@ -23,4 +23,4 @@ export const PARITY_BASELINE = "4.2.6";
  * released tag is iterated takes a MINOR bump, because a published tag is pinned
  * by digest in a catalogue and must never be moved.
  */
-export const ENGINE_VERSION = "0.28.0";
+export const ENGINE_VERSION = "0.29.0";