@archivist-gg/dnd5e 0.3.10 → 0.3.13

package/dist/{chunk-V373TRJE.js → chunk-Q5XTEYHD.js}

@@ -1,34 +1,43 @@
 import {
   classifyWeaponRange
-} from "./chunk-UIRMA5KM.js";
-import {
-  defaultSlotForType,
-  effectiveArmor,
-  isItemEntity,
-  isWeaponEntity,
-  resolveEntityForEntry
-} from "./chunk-UBBKSYBY.js";
+} from "./chunk-YDGMBMYI.js";
 import {
   normKey
 } from "./chunk-RLGQ5PZZ.js";
+import {
+  WEAPON_DEFAULT_ACTION_COST,
+  resolveEntryEntity
+} from "./chunk-T5GZBKIQ.js";
+import {
+  resolveContainment
+} from "./chunk-EJP263OP.js";
 import {
   readNumericBonus
-} from "./chunk-LWFTHJIE.js";
+} from "./chunk-HHBD4SQ6.js";
+import {
+  defaultSlotForType,
+  effectiveArmor,
+  effectiveWeapon,
+  isItemEntity,
+  isShieldArmor,
+  isTwoHandedWeapon,
+  slotAcTerms
+} from "./chunk-LHZXYFBU.js";
 import {
   resolveBaseItem
-} from "./chunk-WXWPK3LI.js";
+} from "./chunk-CM5CWO4K.js";
 import {
   bareEntitySlug
-} from "./chunk-6X4KUDMU.js";
+} from "./chunk-ZCTUYGNV.js";
 
 // src/weapon/weapon-mastery.ts
 var MASTERY = {
   cleave: { label: "Cleave", description: "If you hit a creature with a melee attack roll using this weapon, you can make an attack roll with the weapon against a second creature within 5 feet of the first that is also within your reach. On a hit, the second creature takes the weapon's damage, but don't add your ability modifier to that damage unless it is negative. You can make this extra attack only once per turn.", gist: "hit a 2nd creature in reach" },
   graze: { label: "Graze", description: "If your attack roll with this weapon misses a creature, you can deal damage to that creature equal to the ability modifier you used to make the attack roll. This damage is the same type dealt by the weapon, and the damage can be increased only by increasing the ability modifier.", gist: "on miss: ability-mod damage" },
   nick: { label: "Nick", description: "When you make the extra attack of the Light property, you can make it as part of the Attack action instead of as a Bonus Action. You can make this extra attack only once per turn.", gist: "extra Light attack (no Bonus Action)" },
-  push: { label: "Push", description: "If you hit a creature with this weapon, you can push the creature up to 10 feet straight away from yourself if it is Large or smaller.", gist: "on hit: pushed 10 ft" },
+  push: { label: "Push", description: "If you hit a creature with this weapon, you can push the creature up to 10 feet straight away from yourself if it is Large or smaller.", gist: "on hit: pushed 10 ft." },
   sap: { label: "Sap", description: "If you hit a creature with this weapon, that creature has Disadvantage on its next attack roll before the start of your next turn.", gist: "on hit: target Disadvantage" },
-  slow: { label: "Slow", description: "If you hit a creature with this weapon and deal damage, you can reduce its Speed by 10 feet until the start of your next turn. If the creature is hit more than once by weapons that have this property, the Speed reduction doesn't exceed 10 feet.", gist: "on hit: -10 ft Speed" },
+  slow: { label: "Slow", description: "If you hit a creature with this weapon and deal damage, you can reduce its Speed by 10 feet until the start of your next turn. If the creature is hit more than once by weapons that have this property, the Speed reduction doesn't exceed 10 feet.", gist: "on hit: -10 ft. Speed" },
   topple: { label: "Topple", description: "If you hit a creature with this weapon, you can force the creature to make a Constitution saving throw (DC 8 plus the ability modifier used to make the attack roll and your Proficiency Bonus). On a failed save, the creature has the Prone condition.", gist: "on fail: Prone" },
   vex: { label: "Vex", description: "If you hit a creature with this weapon and deal damage, you have Advantage on your next attack roll against that creature before the end of your next turn.", gist: "on hit: you gain Advantage next" }
 };
@@ -75,13 +84,15 @@ function unwrapClassSlug(maybeWiki) {
   const m = /^\[\[([^\]]+)\]\]$/.exec(maybeWiki);
   return (m ? m[1] : maybeWiki).toLowerCase();
 }
-function buildConditionContext(resolved, equippedSlots) {
+function buildConditionContext(resolved, equippedSlots, registry) {
   var _a, _b;
   return {
     derived: { equippedSlots },
     classList: (_a = resolved.definition.class) != null ? _a : [],
     race: resolved.definition.race,
-    subclasses: ((_b = resolved.definition.class) != null ? _b : []).map((c) => c.subclass).filter((s) => typeof s === "string" && s.length > 0).map(unwrapClassSlug)
+    subclasses: ((_b = resolved.definition.class) != null ? _b : []).map((c) => c.subclass).filter((s) => typeof s === "string" && s.length > 0).map(unwrapClassSlug),
+    // H234 H2: `wielding_two_handed` reads a magic main-hand weapon's base through it.
+    registry
   };
 }
 function pushApply(outcome, field, source, pool, onApply) {
@@ -92,29 +103,30 @@ function pushApply(outcome, field, source, pool, onApply) {
   }
 }
 function computeAppliedBonuses(resolved, _profs, registry, warnings) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
   const out = emptyAppliedBonuses();
   const equipment = (_a = resolved.definition.equipment) != null ? _a : [];
-  const ctx = buildConditionContext(resolved, {});
-  for (const entry of equipment) {
-    const { entity, entityType } = resolveEntityForEntry(entry.item, registry);
+  const ctx = buildConditionContext(resolved, {}, registry);
+  for (let index = 0; index < equipment.length; index++) {
+    const entry = equipment[index];
+    const { entity, entityType } = resolveEntryEntity(entry, index, registry, resolved.infusions);
     if (!entity) {
       const slug = unwrapSlug(entry.item);
-      if (slug && entry.equipped) warnings.push(`Equipped item [[${slug}]] not found in compendium.`);
+      if (slug && entry.equipped && !((_b = resolved.infusions) == null ? void 0 : _b.views.has(index))) warnings.push(`Equipped item [[${slug}]] not found in compendium.`);
       continue;
     }
     if (!isAttunedActive(entry, entity)) continue;
     if (entityType !== "item") continue;
     const item = entity;
-    (_b = item.resist) == null ? void 0 : _b.forEach((s) => out.defenses.resistances.push(s));
-    (_c = item.immune) == null ? void 0 : _c.forEach((s) => out.defenses.immunities.push(s));
-    (_d = item.vulnerable) == null ? void 0 : _d.forEach((s) => out.defenses.vulnerabilities.push(s));
-    (_e = item.condition_immune) == null ? void 0 : _e.forEach((s) => out.defenses.condition_immunities.push(s));
-    (_g = (_f = entry.overrides) == null ? void 0 : _f.resist) == null ? void 0 : _g.forEach((s) => out.defenses.resistances.push(s));
-    (_i = (_h = entry.overrides) == null ? void 0 : _h.immune) == null ? void 0 : _i.forEach((s) => out.defenses.immunities.push(s));
-    (_k = (_j = entry.overrides) == null ? void 0 : _j.vulnerable) == null ? void 0 : _k.forEach((s) => out.defenses.vulnerabilities.push(s));
-    (_m = (_l = entry.overrides) == null ? void 0 : _l.condition_immune) == null ? void 0 : _m.forEach((s) => out.defenses.condition_immunities.push(s));
-    const gs = (_n = item.grants) == null ? void 0 : _n.senses;
+    (_c = item.resist) == null ? void 0 : _c.forEach((s) => out.defenses.resistances.push(s));
+    (_d = item.immune) == null ? void 0 : _d.forEach((s) => out.defenses.immunities.push(s));
+    (_e = item.vulnerable) == null ? void 0 : _e.forEach((s) => out.defenses.vulnerabilities.push(s));
+    (_f = item.condition_immune) == null ? void 0 : _f.forEach((s) => out.defenses.condition_immunities.push(s));
+    (_h = (_g = entry.overrides) == null ? void 0 : _g.resist) == null ? void 0 : _h.forEach((s) => out.defenses.resistances.push(s));
+    (_j = (_i = entry.overrides) == null ? void 0 : _i.immune) == null ? void 0 : _j.forEach((s) => out.defenses.immunities.push(s));
+    (_l = (_k = entry.overrides) == null ? void 0 : _k.vulnerable) == null ? void 0 : _l.forEach((s) => out.defenses.vulnerabilities.push(s));
+    (_n = (_m = entry.overrides) == null ? void 0 : _m.condition_immune) == null ? void 0 : _n.forEach((s) => out.defenses.condition_immunities.push(s));
+    const gs = (_o = item.grants) == null ? void 0 : _o.senses;
     if (gs) {
       if (typeof gs.darkvision === "number") out.senses.darkvision = Math.max(out.senses.darkvision, gs.darkvision);
       if (typeof gs.blindsight === "number") out.senses.blindsight = Math.max(out.senses.blindsight, gs.blindsight);
@@ -150,7 +162,7 @@ function computeAppliedBonuses(resolved, _profs, registry, warnings) {
         out.spell_save_dc += v;
       }
     );
-    if ((_o = b.ability_scores) == null ? void 0 : _o.bonus) {
+    if ((_p = b.ability_scores) == null ? void 0 : _p.bonus) {
       for (const [k, v] of Object.entries(b.ability_scores.bonus)) {
         if (!isAbilityKey(k)) continue;
         pushApply(
@@ -165,7 +177,7 @@ function computeAppliedBonuses(resolved, _profs, registry, warnings) {
         );
       }
     }
-    if ((_p = b.ability_scores) == null ? void 0 : _p.static) {
+    if ((_q = b.ability_scores) == null ? void 0 : _q.static) {
       for (const [k, n] of Object.entries(b.ability_scores.static)) {
         if (!isAbilityKey(k) || typeof n !== "number") continue;
         const prev = out.ability_statics[k];
@@ -227,28 +239,22 @@ function computeAppliedBonuses(resolved, _profs, registry, warnings) {
   }
   return out;
 }
-function isTwoHanded(weapon) {
-  return weapon.properties.some((p) => p === "two_handed");
-}
 function assignSlots(resolved, registry, warnings) {
-  var _a, _b;
+  var _a;
   const slots = {};
   const eq = (_a = resolved.definition.equipment) != null ? _a : [];
   for (let i = 0; i < eq.length; i++) {
     const entry = eq[i];
     if (!entry.equipped || !entry.slot) continue;
-    const { entity, entityType } = resolveEntityForEntry(entry.item, registry);
-    if (slots[entry.slot]) {
-      warnings.push(`${entry.slot} slot conflict: ${entry.item} ignored (already taken).`);
-      continue;
-    }
+    const { entity, entityType } = resolveEntryEntity(entry, i, registry, resolved.infusions);
+    if (slots[entry.slot]) continue;
     const placed = { index: i, entity, entityType, entry };
     slots[entry.slot] = placed;
   }
   for (let i = 0; i < eq.length; i++) {
     const entry = eq[i];
     if (!entry.equipped || entry.slot) continue;
-    const { entity, entityType } = resolveEntityForEntry(entry.item, registry);
+    const { entity, entityType } = resolveEntryEntity(entry, i, registry, resolved.infusions);
     if (!entity || !entityType) continue;
     const defaultSlot = defaultSlotForType(entityType, entity, registry);
     if (!defaultSlot) {
@@ -263,23 +269,45 @@ function assignSlots(resolved, registry, warnings) {
     if (defaultSlot === "mainhand") {
       if (!slots.mainhand) slots.mainhand = placed;
       else if (!slots.offhand) slots.offhand = placed;
-      else warnings.push(`No free hand for ${entry.item}; entry remains equipped without slot.`);
-    } else {
-      if (slots[defaultSlot]) {
-        warnings.push(`${defaultSlot} slot already filled; ${entry.item} ignored.`);
-      } else {
-        slots[defaultSlot] = placed;
-      }
+    } else if (!slots[defaultSlot]) {
+      slots[defaultSlot] = placed;
     }
   }
-  const main = (_b = slots.mainhand) == null ? void 0 : _b.entity;
-  if (main && isWeaponEntity(main) && isTwoHanded(main) && slots.shield) {
-    warnings.push(`Two-handed weapon equipped; shield ignored.`);
-  }
   return slots;
 }
+function pickShield(equippedSlots, equipment, registry, infusions) {
+  const slotted = equippedSlots.shield;
+  const slottedArmor = effectiveArmor(slotted == null ? void 0 : slotted.entity, registry);
+  if (slotted && slottedArmor && isShieldArmor(slottedArmor)) {
+    return { index: slotted.index, shield: slottedArmor, entity: slotted.entity, entry: slotted.entry };
+  }
+  for (let i = 0; i < equipment.length; i++) {
+    const entry = equipment[i];
+    if (!entry.equipped) continue;
+    const { entity } = resolveEntryEntity(entry, i, registry, infusions);
+    const armor = effectiveArmor(entity, registry);
+    if (armor && isShieldArmor(armor)) return { index: i, shield: armor, entity, entry };
+  }
+  return null;
+}
+function twoHandedShieldWarnings(equipment, registry, warnings, infusions) {
+  const equipped = equipment.flatMap((entry, i) => {
+    if (!entry.equipped) return [];
+    const { entity } = resolveEntryEntity(entry, i, registry, infusions);
+    return [{ entry, entity }];
+  });
+  const isShield = (e) => {
+    const armor = effectiveArmor(e.entity, registry);
+    return !!armor && isShieldArmor(armor);
+  };
+  for (const e of equipped) {
+    if (!e.entity || !isTwoHandedWeapon(e.entity, registry)) continue;
+    if (!equipped.some((other) => other !== e && isShield(other))) continue;
+    warnings.push(`${e.entity.name} is two-handed and a Shield is also equipped.`);
+  }
+}
 function computeAC(equippedSlots, resolved, mods, registry, warnings) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   const breakdown = [];
   const armorSlot = equippedSlots.armor;
   const armorEntity = (_a = armorSlot == null ? void 0 : armorSlot.entity) != null ? _a : null;
@@ -289,13 +317,25 @@ function computeAC(equippedSlots, resolved, mods, registry, warnings) {
       `Magic armor "${armorEntity.name}" base_item ${armorEntity.base_item} did not resolve to a base armor; AC not applied.`
     );
   }
+  const acCtx = buildConditionContext(resolved, equippedSlots, registry);
+  const skip = /* @__PURE__ */ new Set();
+  const slotBonus = (slot) => {
+    var _a2, _b2;
+    const view = slot ? (_a2 = resolved.infusions) == null ? void 0 : _a2.views.get(slot.index) : void 0;
+    if (!slot || !(view == null ? void 0 : view.entity) || !isItemEntity(view.entity) || !isAttunedActive(slot.entry, view.entity)) return 0;
+    const out = readNumericBonus((_b2 = view.entity.bonuses) == null ? void 0 : _b2.ac, acCtx);
+    if ((out == null ? void 0 : out.kind) !== "applied") return 0;
+    skip.add(slot.index);
+    return out.value;
+  };
+  const armorTerms = slotAcTerms(armor, armorSlot == null ? void 0 : armorSlot.entry);
   let ac = 10;
-  if (armor) {
-    const armorBase = armor.ac.base + ((_b = armor.ac.flat) != null ? _b : 0);
+  if (armor && armorTerms.armor !== null) {
+    const armorBase = armorTerms.armor + slotBonus(armorSlot);
     ac = armorBase;
-    breakdown.push({ source: (_c = armorEntity == null ? void 0 : armorEntity.name) != null ? _c : armor.name, amount: armorBase, kind: "armor" });
+    breakdown.push({ source: (_b = armorEntity == null ? void 0 : armorEntity.name) != null ? _b : armor.name, amount: armorBase, kind: "armor" });
     if (armor.ac.add_dex) {
-      const dexCap = (_d = armor.ac.dex_max) != null ? _d : Number.POSITIVE_INFINITY;
+      const dexCap = (_c = armor.ac.dex_max) != null ? _c : Number.POSITIVE_INFINITY;
       const dexAdd = Math.min(mods.dex, dexCap);
       ac += dexAdd;
       const capped = mods.dex > dexCap;
@@ -306,28 +346,34 @@ function computeAC(equippedSlots, resolved, mods, registry, warnings) {
     breakdown.push({ source: "Base", amount: 10, kind: "unarmored" });
     breakdown.push({ source: "DEX modifier", amount: mods.dex, kind: "dex" });
   }
-  const acBonus = (_e = armorSlot == null ? void 0 : armorSlot.entry.overrides) == null ? void 0 : _e.ac_bonus;
-  if (typeof acBonus === "number" && acBonus !== 0) {
+  const acBonus = armorTerms.override;
+  if (acBonus !== 0) {
     ac += acBonus;
-    breakdown.push({ source: `${(_f = armorEntity == null ? void 0 : armorEntity.name) != null ? _f : "Armor"} (override)`, amount: acBonus, kind: "override" });
+    breakdown.push({ source: `${(_d = armorEntity == null ? void 0 : armorEntity.name) != null ? _d : "Armor"} (override)`, amount: acBonus, kind: "override" });
   }
-  const main = (_g = equippedSlots.mainhand) == null ? void 0 : _g.entity;
-  const mainIsTwoHanded = main && isWeaponEntity(main) && isTwoHanded(main);
-  const shieldEntity = (_i = (_h = equippedSlots.shield) == null ? void 0 : _h.entity) != null ? _i : null;
-  const shield = effectiveArmor(shieldEntity, registry);
-  if (shield && !mainIsTwoHanded) {
-    const n = shield.ac.base + ((_j = shield.ac.flat) != null ? _j : 0);
+  const picked = pickShield(equippedSlots, (_e = resolved.definition.equipment) != null ? _e : [], registry, resolved.infusions);
+  if (picked) {
+    const { shield, entity: shieldEntity } = picked;
+    const shieldTerms = slotAcTerms(shield, picked.entry);
+    const n = shieldTerms.armor + slotBonus(picked);
     ac += n;
-    breakdown.push({ source: (_k = shieldEntity == null ? void 0 : shieldEntity.name) != null ? _k : shield.name, amount: n, kind: "shield" });
+    breakdown.push({ source: (_f = shieldEntity == null ? void 0 : shieldEntity.name) != null ? _f : shield.name, amount: n, kind: "shield" });
+    const shieldAcBonus = shieldTerms.override;
+    if (shieldAcBonus !== 0) {
+      ac += shieldAcBonus;
+      breakdown.push({ source: `${(_g = shieldEntity == null ? void 0 : shieldEntity.name) != null ? _g : shield.name} (override)`, amount: shieldAcBonus, kind: "shield" });
+    }
   }
   const acInformational = [];
-  const acCtx = buildConditionContext(resolved, equippedSlots);
-  for (const entry of (_l = resolved.definition.equipment) != null ? _l : []) {
-    const { entity, entityType } = resolveEntityForEntry(entry.item, registry);
+  const acEquipment = (_h = resolved.definition.equipment) != null ? _h : [];
+  for (let index = 0; index < acEquipment.length; index++) {
+    if (skip.has(index)) continue;
+    const entry = acEquipment[index];
+    const { entity, entityType } = resolveEntryEntity(entry, index, registry, resolved.infusions);
     if (!entity || entityType !== "item") continue;
     if (!isAttunedActive(entry, entity)) continue;
     const item = entity;
-    const out = readNumericBonus((_m = item.bonuses) == null ? void 0 : _m.ac, acCtx);
+    const out = readNumericBonus((_i = item.bonuses) == null ? void 0 : _i.ac, acCtx);
     if (!out) continue;
     if (out.kind === "applied") {
       ac += out.value;
@@ -373,9 +419,9 @@ function isWeaponSlugProficient(weapon, weaponSlug, profs) {
   }
   return false;
 }
-function magicBonusesForWeaponEntry(entry, registry, ctx) {
+function magicBonusesForWeaponEntry(entry, registry, ctx, index, infusions) {
   var _a;
-  const { entity } = resolveEntityForEntry(entry.item, registry);
+  const { entity } = resolveEntryEntity(entry, index, registry, infusions);
   const ovr = (_a = entry.overrides) != null ? _a : {};
   const entryAttack = typeof ovr.bonus === "number" ? ovr.bonus : 0;
   const entryDamage = typeof ovr.damage_bonus === "number" ? ovr.damage_bonus : 0;
@@ -440,8 +486,8 @@ function buildAttackRow(args) {
     { source: magicSource, amount: magic.dmg, kind: "item" }
   ];
   const modes = classifyWeaponRange(weapon);
-  const fmtRanged = (r) => `${r.normal}/${r.long} ft`;
-  const range = modes.melee ? `${modes.melee.reach} ft` : modes.ranged ? fmtRanged(modes.ranged) : void 0;
+  const fmtRanged = (r) => `${r.normal}/${r.long} ft.`;
+  const range = modes.melee ? `${modes.melee.reach} ft.` : modes.ranged ? fmtRanged(modes.ranged) : void 0;
   const thrownRange = modes.melee && modes.ranged ? fmtRanged(modes.ranged) : void 0;
   const stringProps = weapon.properties.filter(
     (p) => typeof p === "string"
@@ -455,14 +501,17 @@ function buildAttackRow(args) {
     toHit,
     damageDice,
     damageType: (_b = magic.damageTypeOverride) != null ? _b : weapon.damage.type,
-    // Riders: item damage_riders (Task 2) + the migrated manual override string.
+    // Riders: item damage_riders (Task 2) + the entry's overrides.extra_damage string. The override
+    // rider carries NO source: the player typed it on this very row, so the weapons table attributes it
+    // to nothing (no "(manual)" in a caption, no hover title on its chip).
     ...(() => {
       const riders = [
         ...magic.riders,
-        ...magic.extra ? [{ amount: magic.extra, source: "manual" }] : []
+        ...magic.extra ? [{ amount: magic.extra }] : []
       ];
       return riders.length ? { damageRiders: riders } : {};
     })(),
+    weaponCategory: modes.melee ? "melee" : "ranged",
     properties: finalProps,
     proficient,
     breakdown: { toHit: toHitBreakdown, damage: damageBreakdown },
@@ -496,7 +545,7 @@ function buildUnarmedRow(mods, proficiencyBonus, spec) {
     id: "unarmed-strike",
     name: "Unarmed Strike",
     unarmed: true,
-    range: "5 ft",
+    range: "5 ft.",
     toHit,
     damageDice,
     damageType: "bludgeoning",
@@ -507,8 +556,10 @@ function buildUnarmedRow(mods, proficiencyBonus, spec) {
         { source: label, amount: abilityMod, kind: "ability" },
         { source: "Proficiency bonus", amount: proficiencyBonus, kind: "ability" }
       ],
+      // T17 T-33: the base term is the one the total sums. With no die the strike deals 1 + mod, so the base is +1
+      // (it read +0 beside a total of 1 + mod); a die carries its own base, as a weapon's does, so it stays +0.
       damage: [
-        { source: "Base damage", amount: 0, kind: "ability" },
+        { source: "Base damage", amount: (spec == null ? void 0 : spec.dice) ? 0 : 1, kind: "ability" },
         { source: label, amount: abilityMod, kind: "ability" }
       ]
     },
@@ -528,45 +579,22 @@ function formatWeaponSubLabel(weapon, properties, modes) {
   if (properties.length > 0) parts.push(properties.map(humanizeWeaponToken).join(", "));
   return parts.join(" \xB7 ");
 }
-function computeAttacks(equippedSlots, mods, profs, registry, warnings, proficiencyBonus, ctx, weaponMasteries, weaponAbilities = []) {
-  var _a, _b, _c, _d, _e;
+function computeAttacks(equippedSlots, equipment, mods, profs, registry, warnings, proficiencyBonus, ctx, weaponMasteries, weaponAbilities = [], infusions) {
+  var _a, _b;
   const rows = [];
-  const handedSlots = [
-    { key: "mainhand", placed: equippedSlots.mainhand },
-    { key: "offhand", placed: equippedSlots.offhand }
-  ];
-  for (const { key, placed } of handedSlots) {
-    if (!placed) continue;
-    const { entity, entry } = placed;
-    if (!entity) continue;
-    let weapon = null;
-    if (isWeaponEntity(entity)) {
-      weapon = entity;
-    } else if (isItemEntity(entity) && typeof entity.base_item === "string") {
-      const baseSlug = entity.base_item;
-      const found = resolveBaseItem(baseSlug, registry);
-      if (found && found.entityType === "weapon" && isWeaponEntity(found.data)) {
-        weapon = found.data;
-      } else {
-        warnings.push(`Magic weapon ${entity.name} references missing base_item ${baseSlug}.`);
-        continue;
-      }
-    } else {
-      continue;
-    }
-    const slugFromEntry = (_a = unwrapSlug(entry.item)) != null ? _a : weapon.slug;
+  const rowFor = (index, entry, weapon, slotKey, versatileDice) => {
+    var _a2, _b2, _c, _d, _e;
+    const slugFromEntry = (_a2 = unwrapSlug(entry.item)) != null ? _a2 : weapon.slug;
     const proficient = isWeaponSlugProficient(weapon, slugFromEntry, profs) || isWeaponSlugProficient(weapon, weapon.slug, profs);
     if (!proficient) {
       warnings.push(`Character not proficient with ${weapon.name}; proficiency bonus excluded.`);
     }
     const ability = attackAbility(weapon, mods, weaponAbilities);
-    const magic = magicBonusesForWeaponEntry(entry, registry, ctx);
-    const ovr = (_b = entry.overrides) != null ? _b : {};
-    const displayName = (_d = (_c = ovr.name) != null ? _c : magic.itemName) != null ? _d : weapon.name;
-    const versatileDice = key === "mainhand" && hasProperty(weapon, "versatile") && typeof weapon.damage.versatile_dice === "string" && !equippedSlots.offhand ? weapon.damage.versatile_dice : void 0;
-    const baseRow = buildAttackRow({
-      id: `${placed.index}:standard`,
-      name: displayName,
+    const magic = magicBonusesForWeaponEntry(entry, registry, ctx, index, infusions);
+    const ovr = (_b2 = entry.overrides) != null ? _b2 : {};
+    return buildAttackRow({
+      id: `${index}:standard`,
+      name: (_d = (_c = ovr.name) != null ? _c : magic.itemName) != null ? _d : weapon.name,
       weapon,
       baseDice: weapon.damage.dice,
       ability,
@@ -574,13 +602,38 @@ function computeAttacks(equippedSlots, mods, profs, registry, warnings, proficie
       proficient,
       proficiencyBonus,
       magic,
-      slotKey: key,
-      actionCost: (_e = ovr.action) != null ? _e : "action",
+      slotKey,
+      actionCost: (_e = ovr.action) != null ? _e : WEAPON_DEFAULT_ACTION_COST,
       versatileDice,
       weaponMasteries
     });
-    rows.push(baseRow);
+  };
+  const handedSlots = [
+    { key: "mainhand", placed: equippedSlots.mainhand },
+    { key: "offhand", placed: equippedSlots.offhand }
+  ];
+  for (const { key, placed } of handedSlots) {
+    if (!placed) continue;
+    const { entity, entry } = placed;
+    if (!entity) continue;
+    const weapon = effectiveWeapon(entity, registry);
+    if (!weapon) {
+      if (isItemEntity(entity) && typeof entity.base_item === "string") {
+        warnings.push(`Magic weapon ${entity.name} references missing base_item ${entity.base_item}.`);
+      }
+      continue;
+    }
+    const versatileDice = key === "mainhand" && hasProperty(weapon, "versatile") && typeof weapon.damage.versatile_dice === "string" && !equippedSlots.offhand ? weapon.damage.versatile_dice : void 0;
+    rows.push(rowFor(placed.index, entry, weapon, key, versatileDice));
   }
+  const handIndex = /* @__PURE__ */ new Set([(_a = equippedSlots.mainhand) == null ? void 0 : _a.index, (_b = equippedSlots.offhand) == null ? void 0 : _b.index]);
+  equipment.forEach((entry, index) => {
+    if (!entry.equipped || handIndex.has(index)) return;
+    const { entity } = resolveEntryEntity(entry, index, registry, infusions);
+    const weapon = effectiveWeapon(entity, registry);
+    if (!weapon) return;
+    rows.push(rowFor(index, entry, weapon));
+  });
   return rows;
 }
 function coerceWeight(raw) {
@@ -593,25 +646,38 @@ function coerceWeight(raw) {
 }
 function computeCarriedWeight(resolved, registry) {
   var _a;
+  const equipment = (_a = resolved.definition.equipment) != null ? _a : [];
+  const view = resolveContainment(equipment, registry);
+  const weightlessContainer = equipment.map((entry) => {
+    var _a2, _b, _c;
+    const data = (_a2 = resolveBaseItem(entry.item, registry)) == null ? void 0 : _a2.data;
+    return ((_c = (_b = data == null ? void 0 : data.container) == null ? void 0 : _b.capacity) == null ? void 0 : _c.weightless) === true;
+  });
+  const exempt = (i) => {
+    for (let p = view.parentOf[i]; p !== null; p = view.parentOf[p]) if (weightlessContainer[p]) return true;
+    return false;
+  };
   let total = 0;
-  for (const entry of (_a = resolved.definition.equipment) != null ? _a : []) {
+  equipment.forEach((entry, i) => {
+    if (exempt(i)) return;
     const found = resolveBaseItem(entry.item, registry);
-    if (!found) continue;
+    if (!found) return;
     const entity = found.data;
     const w = coerceWeight(entity.weight);
-    if (w === 0) continue;
+    if (w === 0) return;
     const qty = typeof entry.qty === "number" && entry.qty >= 0 ? entry.qty : 1;
     total += w * qty;
-  }
+  });
   return total;
 }
 function computeSlotsAndAttacks(resolved, mods, profs, registry, warnings, proficiencyBonus, weaponAbilities = [], weaponMasteries = [], attunementFloor = 0) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d, _e;
   const equippedSlots = assignSlots(resolved, registry, warnings);
-  const overrides = (_a = resolved.definition.overrides) != null ? _a : {};
+  twoHandedShieldWarnings((_a = resolved.definition.equipment) != null ? _a : [], registry, warnings, resolved.infusions);
+  const overrides = (_b = resolved.definition.overrides) != null ? _b : {};
   const acOut = computeAC(equippedSlots, resolved, mods, registry, warnings);
-  const ctx = buildConditionContext(resolved, equippedSlots);
-  const attacks = computeAttacks(equippedSlots, mods, profs, registry, warnings, proficiencyBonus, ctx, weaponMasteries, weaponAbilities);
+  const ctx = buildConditionContext(resolved, equippedSlots, registry);
+  const attacks = computeAttacks(equippedSlots, (_c = resolved.definition.equipment) != null ? _c : [], mods, profs, registry, warnings, proficiencyBonus, ctx, weaponMasteries, weaponAbilities, resolved.infusions);
   return {
     ac: acOut.ac,
     acBreakdown: acOut.breakdown,
@@ -620,10 +686,10 @@ function computeSlotsAndAttacks(resolved, mods, profs, registry, warnings, profi
     equippedSlots,
     carriedWeight: computeCarriedWeight(resolved, registry),
     // Attunement is persistent: an attuned item still occupies a slot even when unequipped (SRD).
-    attunementUsed: ((_b = resolved.definition.equipment) != null ? _b : []).filter((e) => e.attuned).length,
+    attunementUsed: ((_d = resolved.definition.equipment) != null ? _d : []).filter((e) => e.attuned).length,
     // PRECEDENCE: an explicit character override wins outright (a number the player typed is intent);
     // otherwise the baseline 3 is raised — never lowered — by whatever features granted.
-    attunementLimit: (_c = overrides.attunement_limit) != null ? _c : Math.max(3, attunementFloor)
+    attunementLimit: (_e = overrides.attunement_limit) != null ? _e : Math.max(3, attunementFloor)
   };
 }
 

package/dist/{chunk-MAH6DCRI.js → chunk-Q6UOHCCT.js}

@@ -1,6 +1,6 @@
 import {
   parseBackground
-} from "./chunk-4DOMDEBZ.js";
+} from "./chunk-RQNJXADQ.js";
 
 // src/background/background.codec.ts
 import yaml from "js-yaml";