@maka/maka-cli 5.119.0 → 5.121.0

package/bundle/typescript/src/commands/game/sideQuest/models/item.js

@@ -1,8 +1,25 @@
 import { Size, Category, Rating } from '../types/shared/item-enum.js';
-import { PROGRAM_ATTR_MODS, findProgram, findSoft, getSoft } from '../utilities/programs.js';
-import { catalogHullFor } from '../utilities/catalog.js';
+import { PROGRAM_ATTR_MODS, findProgram, findSoft, getSoft, getProgram } from '../utilities/programs.js';
+import { catalogHullFor, catalogRowFor } from '../utilities/catalog.js';
+import { guessRangeClass } from '../utilities/range.js';
 import { v4 as uuidv4 } from 'uuid';
 import { AbstractItem } from '../types/shared/abstracts.js';
+/**
+ * What a running program adds to a Matrix attribute, from its catalog
+ * row's effects (v13). The program's key is the deck's word for it
+ * (utilities/programs.ts); the row is found by the program's name.
+ * PROGRAM_ATTR_MODS stands in when no row is loaded.
+ */
+export function programMatrixMod(key, attr) {
+    const program = getProgram(key);
+    const row = program ? catalogRowFor(`${program.name} Program`) ?? catalogRowFor(program.name) : undefined;
+    if (row?.effects) {
+        return row.effects.reduce((n, e) => n + (e.category === 'matrix' && e.property === attr ? e.value : 0), 0);
+    }
+    if (attr === 'damage')
+        return key === 'hammer' ? 2 : 0;
+    return PROGRAM_ATTR_MODS[key]?.[attr] ?? 0;
+}
 export class Item extends AbstractItem {
     _id;
     _owner;
@@ -191,26 +208,54 @@ export class Item extends AbstractItem {
     /**
      * STUN BY NATURE (SR5 p.170-171, p.424, RAG-checked 2026-09-02):
      * electricity damage is Stun, so a taser, a stun baton or shock gloves
-     * never deal Physical.
+     * never deal Physical. THE ROW SAYS SO (catalog v13: weapon.damageType
+     * / weapon.electric); the name regex is the fallback for generated gear.
      */
     isStunWeapon() {
+        const w = this.row?.weapon;
+        if (w)
+            return w.damageType === 'S' || w.electric === true;
         return /taser|stun (baton|gun)|shock glove|pulsar|defiance ex|stunner/.test(this.weaponHay);
     }
     /**
-     * STUN BY AMMUNITION (p.434): gel rounds deal Stun at AP +1; stick-n-shock
-     * deal electric Stun at DV -2, AP -5. Anything else is Physical.
+     * WHAT THE LOADED ROUND DOES TO THE LINE (p.433-434): the ammunition
+     * row's block -- gel Stun at AP +1, stick-n-shock electric Stun at DV
+     * -2 / AP -5, APDS AP -4, explosive DV +1 / AP -1, flechette DV +2 /
+     * AP +5. Regular rounds shift nothing. Generated ammunition with no
+     * row keeps the two Stun names the engine always knew.
      */
-    stunAmmo() {
-        const a = (this.loadedAmmo ?? '').toLowerCase();
+    loadedAmmoMods() {
+        if (!this.loadedAmmo)
+            return undefined;
+        const row = catalogRowFor(this.loadedAmmo);
+        if (row?.ammo)
+            return { ...row.ammo, kind: row.slug };
+        const a = this.loadedAmmo.toLowerCase();
         if (/gel/.test(a))
-            return { kind: 'gel', dvMod: 0, apMod: 1 };
+            return { kind: 'gel-rounds', dvMod: 0, apMod: 1, damageType: 'S' };
         if (/stick|shock/.test(a))
-            return { kind: 'stick-n-shock', dvMod: -2, apMod: -5 };
+            return { kind: 'stick-n-shock', dvMod: -2, apMod: -5, damageType: 'S', electric: true };
         return undefined;
     }
+    /**
+     * STUN BY AMMUNITION (p.434): the loaded round's block when it deals
+     * Stun. Kept as the pre-v13 shape for its callers (combat-exchange,
+     * the non-lethal tests): gel or stick-n-shock, with the DV/AP shift.
+     */
+    stunAmmo() {
+        const mods = this.loadedAmmoMods();
+        if (!mods || mods.damageType !== 'S')
+            return undefined;
+        return { kind: mods.electric ? 'stick-n-shock' : 'gel', dvMod: mods.dvMod, apMod: mods.apMod };
+    }
     /** Ammunition that would make this gun non-lethal (reload picks it under the non-lethal stance). */
     static isStunAmmo(item) {
-        return item.category === Category.Ammunition && /gel|stick|shock/i.test(item.name);
+        if (item.category !== Category.Ammunition)
+            return false;
+        const row = catalogRowFor(item.name);
+        if (row?.ammo)
+            return row.ammo.damageType === 'S';
+        return /gel|stick|shock/i.test(item.name);
     }
     get owner() {
         return this._owner;
@@ -224,8 +269,16 @@ export class Item extends AbstractItem {
     get transferable() {
         return this._transferable;
     }
+    /**
+     * "Nothing special happens" is honest for most props, but confusing for
+     * gear whose NAME implies a specific action that lives at a different
+     * verb -- a Lockpick Set at a pickable door (user, 2026-09-03). The
+     * row's `useHint` (catalog v13) names that verb; absent it, the generic
+     * line stands, which is correct for gear that really has nothing to say.
+     */
     use() {
-        return `You use the ${this.name}. Nothing special happens.`;
+        const hint = this.row?.useHint;
+        return hint ? `You turn the ${this.name} over. ${hint}` : `You use the ${this.name}. Nothing special happens.`;
     }
     /**
      * How much this item's quality tier is worth in game mechanics: extra
@@ -244,45 +297,120 @@ export class Item extends AbstractItem {
             default: return 0;
         }
     }
-    // ================= RAW weapon calibration (SR5e p.421-431) =================
-    // Class-blind flat damage made a holdout hit like a shotgun. The class
-    // is read off the item's name/description (the same duck-typing school
-    // as isFence/droneArmed -- generated gear works unmodified), and the
-    // numbers are the book's DV table compressed to engine scale: light
-    // pistols under heavy pistols under shotguns/rifles, blades trading
-    // reach for armor-piercing bite. Quality still rides on top -- gear
-    // tier stays the progression system.
+    // ================= THE ROW BEHIND THE ITEM (catalog v13) =================
+    // An Item knows its name, category, size and price tier -- never its
+    // stat block. Since v13 the catalog row carries that block (weapon,
+    // wearable, device, vehicle, mod, ammo) and the row's effects, and
+    // every getter below reads the row FIRST. The fallbacks that follow
+    // are for generated street gear with no row, and they are the book's
+    // own class values (p.421-431, p.436-437) rather than the compressed
+    // scale the engine used to run: a generated heavy pistol and the
+    // catalog's Predator now hit on the same scale, which is the whole
+    // point of moving to canon numbers (project owner, 2026-09-03).
+    /** The catalog row, by exact slug or name (strict: catalogRowFor). */
+    get row() {
+        return catalogRowFor(this.name);
+    }
+    /** The SR5 Rating / Force / Capacity this thing carries: the row's, or
+     *  the "(Rating N)" its name prints. Undefined for an unrated thing. */
+    get ratingValue() {
+        const fromRow = this.row?.ratingValue;
+        if (fromRow !== undefined)
+            return fromRow;
+        const m = /\((?:Rating|Force|Capacity|Level) (\d+)\)/i.exec(this.name);
+        return m ? Number(m[1]) : undefined;
+    }
     get weaponHay() {
         return `${this.name} ${this.description ?? ''}`.toLowerCase();
     }
-    /** Base ranged DV before quality (RAW: holdout 6P ... assault 11P, compressed). */
-    get rangedBase() {
-        const hay = this.weaponHay;
-        if (/hold-?out|derringer/.test(hay))
-            return 2;
-        if (/light\s?fire|light pistol|streetline|colt america|taser/.test(hay))
-            return 3;
-        if (/sniper|longarm|barret/.test(hay))
-            return 6;
-        if (/assault|ak-?\d|alpha|\brifle\b|carbine/.test(hay))
-            return 5;
-        if (/shotgun|roomsweeper|defiance|scattergun/.test(hay))
-            return 5;
-        if (/smg|machine pistol|submachine|uzi|ingram/.test(hay))
-            return 4;
-        // Heavy pistols (Predator, Ultra-Power...) and unrecognized iron.
-        return 4;
+    /** The p.185 range class: the row's, else read off the name (utilities/range.ts guessRangeClass). */
+    get rangeClass() {
+        return this.row?.weapon?.range ?? guessRangeClass(this.weaponHay, this.category === Category.MeleeWeapon);
     }
-    /** Base melee DV before STR/quality (RAW: knife STR+2, sword/katana/club STR+3). */
-    get meleeBase() {
-        const hay = this.weaponHay;
-        if (/knife|dagger|stiletto|shiv|razor/.test(hay))
-            return 2;
-        if (/katana|sword|axe|machete|claymore|blade/.test(hay))
-            return 3;
-        if (/club|bat\b|staff|pipe|crowbar|hammer|maul|mace/.test(hay))
-            return 3;
-        return 2;
+    /** The skill this weapon is used with: the row's, else the class's. */
+    get weaponSkill() {
+        const fromRow = this.row?.weapon?.skill;
+        if (fromRow)
+            return fromRow;
+        if (this.category === Category.MeleeWeapon) {
+            return /club|\bbat\b|baton|staff|hammer|\bpipe\b|wrench|\bsap\b|\bmace\b|crowbar|cudgel/i.test(`${this.name} ${this.shape}`) ? 'clubs' : 'blades';
+        }
+        switch (this.rangeClass) {
+            case 'machine-pistol':
+            case 'smg':
+            case 'assault-rifle': return 'automatics';
+            case 'shotgun':
+            case 'sniper': return 'longarms';
+            case 'lmg':
+            case 'mmg': return 'heavy-weapons';
+            case 'bow':
+            case 'light-crossbow':
+            case 'medium-crossbow':
+            case 'heavy-crossbow': return 'archery';
+            case 'thrown-knife':
+            case 'grenade': return 'throwing-weapons';
+            default: return 'pistols';
+        }
+    }
+    /**
+     * THE DV, the book's flat part (p.421-431): 8 for the Predator's "8P",
+     * 2 for a knife's "(STR+2)P" -- the Strength half is the wielder's and
+     * Player.getWeaponProfile adds it (dvAttribute says whether to). The
+     * fallback is the CLASS row of the same tables, un-compressed.
+     */
+    get weaponDv() {
+        const w = this.row?.weapon;
+        if (w)
+            return w.dv;
+        if (this.category === Category.MeleeWeapon) {
+            if (this.isStunWeapon())
+                return 8; // shock gloves / stun baton class
+            const hay = this.weaponHay;
+            if (/knife|dagger|stiletto|shiv|razor|sap|baton/.test(hay))
+                return 2; // (STR+2)
+            return 3; // sword, katana, club, staff: (STR+3)
+        }
+        switch (this.rangeClass) {
+            case 'taser': return 7;
+            case 'holdout': return 6;
+            case 'light-pistol': return 6;
+            case 'machine-pistol': return 6;
+            case 'smg': return 7;
+            case 'shotgun': return 10;
+            case 'assault-rifle': return 10;
+            case 'sniper': return 13;
+            case 'lmg': return 9;
+            case 'mmg': return 10;
+            case 'medium-crossbow':
+            case 'light-crossbow':
+            case 'heavy-crossbow': return 7;
+            case 'grenade': return 16;
+            case 'thrown-knife': return 1;
+            default: return 8; // heavy pistols and unrecognised iron
+        }
+    }
+    /** Which attribute the DV rides on: melee is (STR + dv) unless the row says otherwise. */
+    get dvAttribute() {
+        const w = this.row?.weapon;
+        if (w)
+            return w.dvAttribute;
+        if (this.category === Category.MeleeWeapon && !this.isStunWeapon())
+            return 'strength';
+        if (this.rangeClass === 'thrown-knife')
+            return 'strength';
+        return undefined;
+    }
+    /** Physical or Stun, before ammunition and stance have their say. */
+    get damageType() {
+        return this.row?.weapon?.damageType ?? (this.isStunWeapon() ? 'S' : 'P');
+    }
+    /** @deprecated v13 -- the DV is weaponDv; kept one release for its readers. */
+    get rangedBase() { return this.category === Category.MeleeWeapon ? 0 : this.weaponDv; }
+    /** @deprecated v13 -- the DV is weaponDv; kept one release for its readers. */
+    get meleeBase() { return this.category === Category.MeleeWeapon ? this.weaponDv : 0; }
+    /** Reach (p.421-423): the row's, else none. */
+    get reach() {
+        return this.row?.weapon?.reach ?? 0;
     }
     /**
      * ACCURACY -- the LIMIT on an attack made with this weapon (p.46-47,
@@ -291,41 +419,25 @@ export class Item extends AbstractItem {
      * inherent one, higher or lower (p.46-47), so this is not a floor or a
      * cap on the Physical limit -- it is the limit.
      *
-     * NOT COMPRESSED, unlike the DV values above. Damage was squeezed to
-     * engine scale because it is measured against soak dice this engine
-     * also scales; a limit is measured against HITS, which are the book's
-     * own units, and the Matrix brackets next door already spend the raw
-     * attribute ("whole, never halved"). Compressing here would make a
-     * sniper rifle and a holdout cap at the same place.
-     *
-     * The numbers are the book's tables (p.421-431), read through the same
-     * duck-typing school as rangedBase/armorPen so generated gear works
-     * unmodified. Class-based rather than per-weapon ON PURPOSE: the RAG
-     * could not produce standard-table rows for every gun this game ships
-     * (the shotgun table did not come back, and the one AK-97 figure it
-     * did return was off a Run Faster character sheet -- a MODIFIED
-     * weapon, not the table), so a per-weapon list would have meant
-     * inventing the gaps. Every value below is one the book gave up.
+     * THIS IS THE BARE NUMBER, NOT THE PARENTHETICAL. Tables write "Acc 5
+     * (7)": the 5 is the gun, and the 7 is the gun PLUS a shooter who owns
+     * a smartlink (p.433, +2 Accuracy with a smartgun system) -- see
+     * Player.smartlinkAccuracyBonus, which supplies the +2 in
+     * getAttackLimit. A laser sight's +1 rides the same way (fitted mods,
+     * Player.gearLimit), and never stacks with the smartlink (p.432).
      *
-     * THIS IS THE BARE NUMBER, NOT THE PARENTHETICAL, and that is now a
-     * division of labour rather than a gap. Tables write "Acc 5 (7)": the
-     * 5 is the gun, and the 7 is the gun PLUS a shooter who owns a
-     * smartlink (p.433, +2 Accuracy with a smartgun system). A gun sitting
-     * on a table has no idea who will pick it up, so the pairing is asked
-     * of the shooter -- see Player.smartlinkAccuracyBonus, which supplies
-     * the +2 in getAttackLimit. fxPHSuE4nrH3gAGiy.
+     * 0 means "no Accuracy of its own": the table's own word 'physical'
+     * (shock gloves, throwing knives, grenades) and everything that is not
+     * a weapon. Callers fall back to the Physical limit, which is what an
+     * improvised or bare-handed attack uses (p.168).
      *
-     * The laser-sight parenthetical (p.429 Enfield, "4 (5) with the
-     * built-in laser sight") is a DIFFERENT accessory and is still not
-     * modelled: the engine has no sight-fitting model, and inventing one
-     * to reuse the smartlink pairing would be guessing at a second rule.
-     *
-     * Note the wireless smartgun bonus is a DICE POOL bonus (+1/+2,
-     * p.433), NOT an Accuracy bonus -- getAttackPool already spends it as
-     * dice. Keeping those apart is the same discipline as the Matrix
-     * brackets: a limit is never a die, and a die is never a limit.
+     * The fallback ladder is the book's class values, read through the
+     * same duck-typing school as the DV so generated gear works.
      */
     get accuracy() {
+        const w = this.row?.weapon;
+        if (w)
+            return typeof w.accuracy === 'number' ? w.accuracy : 0;
         const hay = this.weaponHay;
         if (this.category === Category.MeleeWeapon) {
             if (/katana/.test(hay))
@@ -338,7 +450,9 @@ export class Item extends AbstractItem {
                 return 5;
             if (/sap|whip|garrote/.test(hay))
                 return 5;
-            if (/club|bat\b|baton|staff|pipe|crowbar|hammer|maul|mace|cudgel/.test(hay))
+            if (/staff/.test(hay))
+                return 6; // p.423
+            if (/club|bat\b|baton|pipe|crowbar|hammer|maul|mace|cudgel/.test(hay))
                 return 4;
             return 5;
         }
@@ -364,43 +478,263 @@ export class Item extends AbstractItem {
             // Heavy pistols (Predator, Ultra-Power) and unrecognized iron.
             return 5;
         }
-        // Not a weapon: no Accuracy of its own. Callers fall back to the
-        // Physical limit, which is what an improvised or bare-handed
-        // attack uses (p.168).
         return 0;
     }
     /**
-     * Armor penetration (<= 0): how much of the defender's ARMOR the hit
-     * ignores (RAW AP, compressed ~2:3 -- knife/katana -3 -> -2, heavy
-     * pistol -1 -> -1). Applied against armor dice only, never Body
-     * (combat-exchange.ts).
+     * Armor penetration: how much the hit shifts the defender's ARMOR
+     * (p.169) -- negative eats it, a "+" (gel, flechette) adds to it. The
+     * row's AP, else the class value from the same tables, un-compressed.
      */
     get armorPen() {
+        const w = this.row?.weapon;
+        if (w)
+            return w.ap;
         const hay = this.weaponHay;
         if (this.category === Category.MeleeWeapon) {
             if (/knife|dagger|stiletto|katana/.test(hay))
+                return -3;
+            if (/sword|axe|machete|claymore|blade|pole\s?arm/.test(hay))
                 return -2;
-            if (/sword|axe|machete|claymore|blade/.test(hay))
-                return -1;
-            if (/club|bat\b|staff|pipe|crowbar|hammer|maul|mace|sap/.test(hay))
+            if (/taser|stun|shock/.test(hay))
+                return -5;
+            if (/club|bat\b|staff|pipe|crowbar|hammer|maul|mace|sap|baton/.test(hay))
                 return 0;
             return -1;
         }
         if (this.category === Category.RangedWeapon || this.category === Category.Weapon) {
-            if (/sniper|longarm|barret/.test(hay))
-                return -2;
-            if (/assault|ak-?\d|alpha|\brifle\b|carbine|shotgun|roomsweeper|defiance/.test(hay))
-                return -1;
-            if (/hold-?out|derringer|light\s?fire|light pistol|streetline|colt america|taser|smg|machine pistol|submachine|uzi|ingram/.test(hay))
-                return 0;
-            return -1; // heavy pistols (RAW -1)
+            switch (this.rangeClass) {
+                case 'taser': return -5;
+                case 'sniper': return -4;
+                case 'assault-rifle': return -2;
+                case 'mmg': return -3;
+                case 'lmg': return -2;
+                case 'shotgun': return -1;
+                case 'holdout':
+                case 'light-pistol':
+                case 'machine-pistol':
+                case 'smg': return 0;
+                case 'medium-crossbow':
+                case 'light-crossbow':
+                case 'heavy-crossbow': return -2;
+                default: return -1; // heavy pistols (RAW -1)
+            }
         }
         return 0;
     }
-    /** Heavier armor classes soak harder (RAW: jacket 12 vs clothing 6). */
+    /** Heavier armor classes soak harder (RAW: jacket 12 vs clothing 6). Fallback only. */
     get isHeavyArmor() {
         return /jacket|full body|milspec|mil-spec|plate|riot|ballistic|hardened/.test(this.weaponHay);
     }
+    /**
+     * THE ARMOR RATING of a worn piece (p.436-437): the row's, else the
+     * class value -- jacket-class 12, a vest 9, armor clothing 6, plain
+     * clothing 0. Only the highest worn piece counts (Player.armorBreakdown).
+     */
+    get armorValue() {
+        const w = this.row?.wearable;
+        if (w?.armor !== undefined)
+            return w.armor;
+        if (w?.armorBonus !== undefined)
+            return 0;
+        switch (this.category) {
+            case Category.Armor:
+            case Category.BodyArmor:
+                return this.isHeavyArmor ? 12 : 9;
+            case Category.ArmorClothing:
+                return this.isHeavyArmor ? 9 : 6;
+            default:
+                return 0;
+        }
+    }
+    /** A "+" accessory's bonus (helmet +2, shield +6, p.437-438): the row's, else the class value. */
+    get armorBonus() {
+        const w = this.row?.wearable;
+        if (w?.armorBonus !== undefined)
+            return w.armorBonus;
+        if (w?.armor !== undefined)
+            return 0;
+        if (this.category === Category.Helmet)
+            return 2;
+        if (this.category === Category.Shield)
+            return 6;
+        return 0;
+    }
+    // ---- Effects and capabilities (catalog v13) ----
+    /**
+     * WHAT THIS THING DOES, in the engine's vocabulary: the row's effects
+     * plus everything fitted into it (a smartlink in the goggles, a laser
+     * sight on the gun). A fitted mod's effects apply whenever the host
+     * does, so they are re-tagged with the host's own `when`.
+     */
+    get effects() {
+        const own = this.row?.effects ?? [];
+        if (this.fitted.length === 0)
+            return own;
+        const hostWhen = this.defaultWhen;
+        const fromMods = this.fitted.flatMap(m => m.effects.map(e => e.when === 'fitted' ? { ...e, when: hostWhen } : e));
+        return [...own, ...fromMods];
+    }
+    /** When a row's effects apply by default: worn for a wearable, held for a weapon, carried otherwise. */
+    get defaultWhen() {
+        if (this.row?.weapon || this.category === Category.MeleeWeapon || this.isFirearm())
+            return 'held';
+        if (this.row?.wearable)
+            return 'worn';
+        return 'carried';
+    }
+    /** A flag the row (or a fitted mod) grants, by key; its value, or 0. */
+    capability(key) {
+        let total = 0;
+        for (const e of this.effects)
+            if (e.type === 'flag' && e.property === key)
+                total += e.value;
+        return total;
+    }
+    hasCapability(key) {
+        return this.capability(key) > 0;
+    }
+    // ---- Fitting (catalog v13; commands/fit.ts) ----
+    // Wearables hold mods by CAPACITY (goggles 4, helmet 6; a vision
+    // enhancement costs 1, p.443-445) and guns hold accessories by MOUNT
+    // (top / under / barrel, one accessory each, p.432). Built-in
+    // accessories occupy no mount. The fitted list rides the save.
+    fitted = [];
+    /** Capacity this thing offers to mods. */
+    get capacity() {
+        return this.row?.wearable?.capacity ?? this.row?.mod?.capacity ?? 0;
+    }
+    /** What kinds of mod it holds. */
+    get holds() {
+        const w = this.row?.wearable?.holds;
+        if (w)
+            return w;
+        return this.row?.mod?.capacity ? ['vision'] : [];
+    }
+    get capacityUsed() {
+        return this.fitted.reduce((n, m) => n + (m.row?.mod?.capacityCost ?? 0), 0);
+    }
+    /** The accessory seats a gun has: the row's, else the class rule (p.432). */
+    get mounts() {
+        const fromRow = this.row?.weapon?.mounts;
+        if (fromRow)
+            return fromRow;
+        if (!this.isFirearm())
+            return [];
+        switch (this.rangeClass) {
+            case 'holdout': return [];
+            case 'taser': return ['top'];
+            case 'light-pistol':
+            case 'heavy-pistol':
+            case 'machine-pistol':
+            case 'smg': return ['top', 'barrel'];
+            default: return ['top', 'under', 'barrel'];
+        }
+    }
+    /** Accessories the factory fitted (identifiers, see ICatalogWeapon.builtIn). */
+    get builtIn() {
+        return this.row?.weapon?.builtIn ?? [];
+    }
+    hasBuiltIn(id) {
+        return this.builtIn.includes(id);
+    }
+    /**
+     * A SMARTGUN (p.433): a smartgun system built in or fitted. Before v13
+     * every firearm in the engine counted as one; canon makes it an
+     * accessory. Generated gear with no row is a smartgun only when it
+     * says so.
+     */
+    get isSmartgun() {
+        if (!this.isFirearm())
+            return false;
+        if (this.row)
+            return this.hasBuiltIn('smartgun-internal') || this.fitted.some(m => m.hasCapability('smartgun'));
+        return /smartgun|smartlink/.test(this.weaponHay) || this.fitted.some(m => m.hasCapability('smartgun'));
+    }
+    /** Which mount a fitted accessory sits in: the first of its mounts still free when it was fitted. */
+    mountOf(mod) {
+        const taken = new Set();
+        for (const m of this.fitted) {
+            const wants = m.row?.mod?.mount ?? [];
+            const seat = wants.find(p => this.mounts.includes(p) && !taken.has(p));
+            if (seat)
+                taken.add(seat);
+            if (m === mod)
+                return seat;
+        }
+        return undefined;
+    }
+    /**
+     * Why a mod will not fit, or null when it will. The message is the
+     * player's line, so it names the rule that refused.
+     */
+    fitRefusal(mod) {
+        const spec = mod.row?.mod;
+        if (!spec)
+            return `${mod.name} is not something that fits into anything.`;
+        if (this.fitted.includes(mod))
+            return `${mod.name} is already fitted to ${this.name}.`;
+        if (spec.kind === 'weapon') {
+            if (!this.isFirearm())
+                return `${mod.name} mounts on a gun, and ${this.name} is not one.`;
+            const mounts = this.mounts;
+            if (mounts.length === 0)
+                return `${this.name} has no mounts -- nothing bolts onto it (p.432).`;
+            if (spec.excludes?.includes('shotgun') && this.rangeClass === 'shotgun')
+                return `${mod.name} will not fit a shotgun (p.432).`;
+            if (spec.excludes?.includes('revolver') && this.row?.weapon?.ammo?.feed === 'cy')
+                return `${mod.name} will not fit a revolver (p.432).`;
+            const taken = new Set(this.fitted.map(m => this.mountOf(m)).filter((p) => p !== undefined));
+            const free = (spec.mount ?? []).filter(p => mounts.includes(p) && !taken.has(p));
+            if (free.length === 0)
+                return `${this.name} has no free ${(spec.mount ?? []).join(' or ')} mount for ${mod.name}.`;
+            return null;
+        }
+        if (!this.holds.includes(spec.kind))
+            return `${this.name} does not take a ${spec.kind} enhancement.`;
+        const cost = spec.capacityCost ?? 0;
+        if (this.capacityUsed + cost > this.capacity)
+            return `${this.name} has ${this.capacity - this.capacityUsed} capacity left and ${mod.name} needs ${cost}.`;
+        return null;
+    }
+    /** Fits a mod; the refusal line, or null when it went in. */
+    fit(mod) {
+        const why = this.fitRefusal(mod);
+        if (why)
+            return why;
+        this.fitted.push(mod);
+        return null;
+    }
+    /** Takes a mod back out; false when it was not there. */
+    unfit(mod) {
+        const i = this.fitted.indexOf(mod);
+        if (i < 0)
+            return false;
+        this.fitted.splice(i, 1);
+        return true;
+    }
+    /** The drone's stat block, when it has one. */
+    get vehicle() {
+        return this.row?.vehicle;
+    }
+    /** Pilot rating (p.199): the row's, else the price-tier fallback the engine always used. */
+    get pilotRating() {
+        return this.vehicle?.pilot ?? 2 + this.qualityBonus;
+    }
+    /** A drone's hull armor (p.199): the row's, else the tier fallback. */
+    get droneArmor() {
+        return this.vehicle?.armor ?? 2 * this.qualityBonus;
+    }
+    /** A drone's Body (p.199): the row's, else the tier fallback. */
+    get droneBody() {
+        return this.vehicle?.body ?? 2 + this.qualityBonus;
+    }
+    /** Does the drone carry a weapon mount: the row's, else the name says. */
+    get hasWeaponMount() {
+        const v = this.vehicle;
+        if (v)
+            return v.mount !== undefined;
+        return /armed|combat|gun|roto|assault|sentry|weapon/i.test(this.weaponHay);
+    }
     // ================= Device condition monitor (cyberdecks) =================
     // Matrix combat damage lands on HARDWARE: the deck you jacked in with
     // (see combat-exchange.ts routing and Player.takeMatrixDamage). A full
@@ -411,9 +745,9 @@ export class Item extends AbstractItem {
     isCyberdeck() {
         return this.category === Category.Cyberdeck;
     }
-    /** Better decks have more board to burn through: 8 + 2 per quality step. */
+    /** The Matrix condition monitor (p.228): 8 + (Device Rating / 2), rounded up. */
     get maxDeckBoxes() {
-        return 8 + 2 * this.qualityBonus;
+        return 8 + Math.ceil(this.deviceRating / 2);
     }
     get deckDamage() {
         return this._deckDamage;
@@ -425,8 +759,12 @@ export class Item extends AbstractItem {
     // engine's quality tiers map onto the book's table exactly (Summit
     // DR1 = Common ... Cyber-5 DR5 = Legendary), so generated street
     // decks inherit real stats for free.
-    /** p.227: Summit 1, Chariot 2, Tsurugi 3, Cyber-5 5 (Excalibur-class 6). */
+    /** Device Rating, NUMERIC (catalog v13): the row's, else the tier ladder
+     *  (p.227: Summit 1, Chariot 2, Tsurugi 3, Cyber-5 5, Excalibur-class 6). */
     get deviceRating() {
+        const fromRow = this.row?.device?.deviceRating;
+        if (fromRow !== undefined)
+            return fromRow;
         switch (this.qualityBonus) {
             case 0: return 1;
             case 1: return 2;
@@ -435,8 +773,12 @@ export class Item extends AbstractItem {
             default: return 6;
         }
     }
-    /** The p.227 attribute array (highest first), by Device Rating. */
+    /** The p.227 attribute array (highest first): the row's four numbers, else by Device Rating. */
     get deckArray() {
+        const d = this.row?.device;
+        if (d && d.attack !== undefined && d.sleaze !== undefined && d.dataProcessing !== undefined && d.firewall !== undefined) {
+            return [d.attack, d.sleaze, d.dataProcessing, d.firewall];
+        }
         switch (this.deviceRating) {
             case 1: return [4, 3, 3, 1];
             case 2: return [5, 4, 4, 2];
@@ -445,9 +787,9 @@ export class Item extends AbstractItem {
             default: return [9, 8, 7, 6]; // Excalibur-class (canon-approximate)
         }
     }
-    /** How many programs run at once (p.227; storage is unlimited). */
+    /** How many programs run at once (p.227; storage is unlimited): the row's, else the Device Rating. */
     get programSlots() {
-        return Math.min(6, this.deviceRating);
+        return this.row?.device?.programs ?? Math.min(6, this.deviceRating);
     }
     // Which array value sits in which attribute: indexes into deckArray
     // for [attack, sleaze, dataProcessing, firewall]. Default boot config
@@ -520,7 +862,9 @@ export class Item extends AbstractItem {
     }
     attrValue(slot, key) {
         const base = this.deckArray[this._deckOrder[slot]];
-        const mods = this.loadedPrograms.reduce((sum, k) => sum + (PROGRAM_ATTR_MODS[k]?.[key] ?? 0), 0);
+        // What a RUNNING program adds (catalog v13: the program row's effects,
+        // `attribute`/`matrix`; PROGRAM_ATTR_MODS is the offline fallback).
+        const mods = this.loadedPrograms.reduce((sum, k) => sum + programMatrixMod(k, key), 0);
         return base + mods;
     }
     get attack() { return this.attrValue(0, 'attack'); }
@@ -573,7 +917,7 @@ export class Item extends AbstractItem {
     get matrixDamageBonus() {
         if (!this.isCyberdeck())
             return this.qualityBonus;
-        return Math.floor(this.attack / 2) + (this.hasProgram('hammer') ? 2 : 0);
+        return Math.floor(this.attack / 2) + this.loadedPrograms.reduce((sum, k) => sum + programMatrixMod(k, 'damage'), 0);
     }
     /** One-line stat readout: "A5 S4 D4 F2, DR2, 1/2 programs". */
     deckStatLine() {