@archivist-gg/dnd5e 0.1.0

package/dist/chunk-TJCNX6UZ.js

@@ -0,0 +1,521 @@
+import {
+  ALL_SKILL_SLUGS
+} from "./chunk-BH6AMZVY.js";
+import {
+  recognizeDecision
+} from "./chunk-JEYQU3JT.js";
+import {
+  ABILITY_KEYS
+} from "./chunk-WP2CX2JO.js";
+
+// src/pc/pc.decision-engine.ts
+var warnedDegradedEquipment = /* @__PURE__ */ new Set();
+function wikilinkTailSlug(link) {
+  var _a;
+  const inner = link.replace(/^\[\[/, "").replace(/\]\]$/, "");
+  const tail = (_a = inner.split("/").pop()) != null ? _a : inner;
+  return tail.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+function bareEntitySlug(slug) {
+  if (!slug) return "";
+  const i = slug.indexOf("_");
+  return i === -1 ? slug : slug.slice(i + 1);
+}
+function matchesFilter(e, where, ownerBare) {
+  var _a, _b, _c;
+  const d = e.data;
+  if (where.feature_type && d.feature_type !== where.feature_type) return false;
+  if (where.category && d.category !== where.category) return false;
+  if (where.weapon_category) {
+    const cat = ((_a = d.category) != null ? _a : "").toLowerCase();
+    if (!cat.startsWith(`${where.weapon_category}-`) && cat !== where.weapon_category) return false;
+  }
+  if (where.armor_category) {
+    if (((_b = d.category) != null ? _b : "").toLowerCase() !== where.armor_category) return false;
+  }
+  if (where.parent_class === "self") {
+    if (!d.parent_class || wikilinkTailSlug(d.parent_class) !== ownerBare) return false;
+  }
+  if (where.available_to === "self") {
+    const list = (_c = d.available_to) != null ? _c : [];
+    if (!list.some((l) => wikilinkTailSlug(l) === ownerBare)) return false;
+  }
+  return true;
+}
+var __matchesFilterForTest = matchesFilter;
+function categoryToEntitySelect(category, id) {
+  const c = category.toLowerCase();
+  if (c === "shield") {
+    return { kind: "select-entity", id, label: "Choose a shield", count: 1, entity_type: "armor", where: { armor_category: "shield" } };
+  }
+  if (c.includes("armor")) {
+    const klass = c.includes("light") ? "light" : c.includes("medium") ? "medium" : c.includes("heavy") ? "heavy" : null;
+    return klass ? { kind: "select-entity", id, label: `Choose ${klass} armor`, count: 1, entity_type: "armor", where: { armor_category: klass } } : { kind: "select-entity", id, label: "Choose armor", count: 1, entity_type: "armor" };
+  }
+  const wc = c.includes("martial") ? "martial" : "simple";
+  return { kind: "select-entity", id, label: `Choose a ${c.replace(/-/g, " ")}`, count: 1, entity_type: "weapon", where: { weapon_category: wc } };
+}
+function enumerateOptions(choice, ctx, ownerBare) {
+  var _a, _b;
+  switch (choice.kind) {
+    case "select-inline":
+      return choice.options.map((o) => ({ value: o.value, label: o.label, description: o.description }));
+    case "select-entity": {
+      if (choice.from) {
+        const byBare = /* @__PURE__ */ new Map();
+        for (const e of ctx.registry.search("", choice.entity_type, Number.POSITIVE_INFINITY)) {
+          byBare.set(bareEntitySlug(e.slug), e);
+        }
+        return choice.from.map((slug) => {
+          var _a2;
+          const e = (_a2 = ctx.registry.getByTypeAndSlug(choice.entity_type, slug)) != null ? _a2 : byBare.get(slug);
+          return e ? { value: e.slug, label: e.name, entity: e } : { value: slug, label: slug, missing: true };
+        });
+      }
+      const all = ctx.registry.search("", choice.entity_type, Number.POSITIVE_INFINITY);
+      const filtered = choice.where ? all.filter((e) => matchesFilter(e, choice.where, ownerBare)) : all;
+      return filtered.map((e) => ({ value: e.slug, label: e.name, entity: e }));
+    }
+    case "select-proficiency": {
+      const pool = (_a = choice.from) != null ? _a : choice.domain === "skill" ? [...ALL_SKILL_SLUGS] : [];
+      return pool.map((v) => ({ value: v, label: v.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()) }));
+    }
+    case "ability-points": {
+      const pool = (_b = choice.pool) != null ? _b : ["str", "dex", "con", "int", "wis", "cha"];
+      return pool.map((a) => ({ value: a, label: a.toUpperCase() }));
+    }
+  }
+}
+function selectionCount(choice, selected) {
+  if (selected === void 0) return 0;
+  if (choice.kind === "ability-points") {
+    if (typeof selected !== "object" || Array.isArray(selected)) return 0;
+    return Object.values(selected).reduce((s, v) => s + (typeof v === "number" ? v : 0), 0);
+  }
+  if (Array.isArray(selected)) return selected.length;
+  return typeof selected === "string" && selected.length > 0 ? 1 : 0;
+}
+function requiredCount(choice) {
+  var _a;
+  if (choice.kind === "ability-points") return choice.points;
+  if (choice.kind === "select-proficiency") return choice.count;
+  return (_a = choice.count) != null ? _a : 1;
+}
+function statusOf(choice, selected) {
+  const n = selectionCount(choice, selected);
+  const need = requiredCount(choice);
+  if (n === 0) return "unresolved";
+  return n >= need ? "resolved" : "partial";
+}
+function resolveEntityRef(ctx, entityType, value) {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  const raw = value.replace(/^\[\[/, "").replace(/\]\]$/, "");
+  const direct = ctx.registry.getByTypeAndSlug(entityType, raw);
+  if (direct) return direct;
+  for (const e of ctx.registry.search("", entityType, Number.POSITIVE_INFINITY)) {
+    if (e.slug === raw || bareEntitySlug(e.slug) === raw) return e;
+  }
+  return void 0;
+}
+function buildItem(choice, source, level, featureName, readValue, ctx, ownerBare, opts) {
+  var _a, _b, _c, _d;
+  const keyPrefix = (_a = opts == null ? void 0 : opts.keyPrefix) != null ? _a : "";
+  const expandFeatChildren = (_b = opts == null ? void 0 : opts.expandFeatChildren) != null ? _b : true;
+  const key = keyPrefix + choice.id;
+  const selected = readValue(key);
+  const item = {
+    key,
+    source,
+    level,
+    featureName,
+    choice,
+    description: opts == null ? void 0 : opts.description,
+    options: enumerateOptions(choice, ctx, ownerBare),
+    selected,
+    status: statusOf(choice, selected)
+  };
+  if (choice.kind === "select-inline" && typeof selected === "string") {
+    const branch = choice.options.find((o) => o.value === selected);
+    if ((_c = branch == null ? void 0 : branch.choices) == null ? void 0 : _c.length) {
+      item.children = branch.choices.map((c) => buildItem(c, source, level, featureName, readValue, ctx, ownerBare, { keyPrefix, expandFeatChildren }));
+      if (item.status === "resolved" && item.children.some((c) => c.status !== "resolved")) {
+        item.status = "partial";
+      }
+    }
+  }
+  if (choice.kind === "select-entity" && choice.entity_type === "feat" && expandFeatChildren && typeof selected === "string") {
+    const entity = resolveEntityRef(ctx, "feat", selected);
+    const rawChoices = (_d = entity == null ? void 0 : entity.data) == null ? void 0 : _d.choices;
+    const featChoices = Array.isArray(rawChoices) ? rawChoices : [];
+    if (featChoices.length) {
+      const childPrefix = `${keyPrefix}feat:`;
+      item.children = featChoices.map((c) => buildItem(
+        c,
+        source,
+        level,
+        featureName,
+        readValue,
+        ctx,
+        ownerBare,
+        { keyPrefix: childPrefix, expandFeatChildren: false }
+      ));
+      if (item.status === "resolved" && item.children.some((c) => c.status !== "resolved")) {
+        item.status = "partial";
+      }
+    }
+  }
+  return item;
+}
+function buildSubclassItem(choice, source, level, featureName, c, ctx, ownerBare, description) {
+  const selected = c.subclass ? c.subclass.slug : void 0;
+  return {
+    key: "subclass",
+    source,
+    level,
+    featureName,
+    description,
+    choice,
+    options: enumerateOptions(choice, ctx, ownerBare),
+    selected,
+    status: selected ? "resolved" : "unresolved"
+  };
+}
+function collectChosenProficiencies(resolved) {
+  var _a, _b;
+  const out = { skills: [], expertise: [], languages: [], tools: [] };
+  const apply = (choice, selected) => {
+    if (choice.kind !== "select-proficiency") return;
+    const vals = Array.isArray(selected) ? selected : typeof selected === "string" ? [selected] : [];
+    const pool = choice.from;
+    const valid = pool ? vals.filter((v) => pool.includes(v)) : vals;
+    const bucket = choice.domain === "skill" ? choice.expertise ? out.expertise : out.skills : choice.domain === "language" ? out.languages : choice.domain === "tool" ? out.tools : null;
+    if (bucket) {
+      for (const v of valid) if (!bucket.includes(v)) bucket.push(v);
+    }
+  };
+  const walk = (choices, read) => {
+    for (const ch of choices != null ? choices : []) {
+      apply(ch, read(ch.id));
+      if (ch.kind === "select-inline") {
+        const sel = read(ch.id);
+        const branch = typeof sel === "string" ? ch.options.find((o) => o.value === sel) : void 0;
+        if (branch == null ? void 0 : branch.choices) walk(branch.choices, read);
+      }
+    }
+  };
+  resolved.classes.forEach((c, i) => {
+    var _a2, _b2;
+    if (!c.entity) return;
+    const entity = c.entity;
+    const readAt = (lvl) => (id) => {
+      var _a3;
+      return (_a3 = c.choices[lvl]) == null ? void 0 : _a3[id];
+    };
+    if (i === 0 && ((_b2 = (_a2 = entity.skill_choices) == null ? void 0 : _a2.from) == null ? void 0 : _b2.length)) {
+      apply({
+        kind: "select-proficiency",
+        id: "skills",
+        count: entity.skill_choices.count,
+        domain: "skill",
+        from: entity.skill_choices.from
+      }, readAt(1)("skills"));
+    }
+    for (const rf of resolved.features) {
+      if (rf.source.kind !== "class" && rf.source.kind !== "subclass") continue;
+      const belongs = rf.source.kind === "class" ? rf.source.slug === entity.slug : c.subclass != null && rf.source.slug === c.subclass.slug;
+      if (!belongs) continue;
+      walk(rf.feature.choices, readAt(rf.source.level));
+    }
+  });
+  const oc = (_a = resolved.definition.origin_choices) != null ? _a : {};
+  const originRead = (ns) => (id) => oc[`${ns}:${id}`];
+  if (resolved.race) {
+    walk(resolved.race.choices, originRead("race"));
+    for (const t of (_b = resolved.race.traits) != null ? _b : []) walk(t.choices, originRead("race"));
+  }
+  if (resolved.background) {
+    walk(resolved.background.choices, originRead("background"));
+    if (resolved.background.feature) {
+      walk(resolved.background.feature.choices, originRead("background"));
+    }
+  }
+  return out;
+}
+function collectChosenAbilityPoints(resolved) {
+  var _a, _b, _c;
+  const oc = (_a = resolved.definition.origin_choices) != null ? _a : {};
+  const out = { race: {}, background: {} };
+  const fold = (ns, choices) => {
+    var _a2;
+    for (const ch of choices != null ? choices : []) {
+      if (ch.kind !== "ability-points") continue;
+      const raw = oc[`${ns}:${ch.id}`];
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+      let left = ch.points;
+      for (const ab of ABILITY_KEYS) {
+        if (ch.pool && !ch.pool.includes(ab)) continue;
+        const v = raw[ab];
+        if (typeof v !== "number" || v <= 0 || left <= 0) continue;
+        const take = Math.min(v, ch.max_per, left);
+        out[ns][ab] = ((_a2 = out[ns][ab]) != null ? _a2 : 0) + take;
+        left -= take;
+      }
+    }
+  };
+  const race = resolved.race;
+  if (race) {
+    fold("race", race.choices);
+    for (const t of (_b = race.traits) != null ? _b : []) fold("race", t.choices);
+  }
+  const bg = resolved.background;
+  if (bg) {
+    fold("background", bg.choices);
+    fold("background", (_c = bg.feature) == null ? void 0 : _c.choices);
+  }
+  return out;
+}
+function buildDecisionLedger(resolved, ctx) {
+  var _a, _b, _c, _d;
+  const classes = [];
+  resolved.classes.forEach((c, classIndex) => {
+    var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    if (!c.entity) return;
+    const entity = c.entity;
+    const ownerBare = bareEntitySlug(entity.slug);
+    const byLevel = /* @__PURE__ */ new Map();
+    const push = (lvl, item) => {
+      var _a3;
+      const arr = (_a3 = byLevel.get(lvl)) != null ? _a3 : [];
+      arr.push(item);
+      byLevel.set(lvl, arr);
+    };
+    const readAt = (lvl) => (id) => {
+      var _a3;
+      return (_a3 = c.choices[lvl]) == null ? void 0 : _a3[id];
+    };
+    if (classIndex === 0 && ((_b2 = (_a2 = entity.skill_choices) == null ? void 0 : _a2.from) == null ? void 0 : _b2.length)) {
+      const skillChoice = {
+        kind: "select-proficiency",
+        id: "skills",
+        label: "Skill Proficiencies",
+        count: entity.skill_choices.count,
+        domain: "skill",
+        from: entity.skill_choices.from
+      };
+      push(1, buildItem(
+        skillChoice,
+        { kind: "class", slug: entity.slug, level: 1 },
+        1,
+        "Proficiencies",
+        readAt(1),
+        ctx,
+        ownerBare
+      ));
+    }
+    if (classIndex === 0) {
+      ((_c2 = entity.starting_equipment) != null ? _c2 : []).forEach((eq, i) => {
+        var _a3;
+        if (eq.kind !== "choice") return;
+        const options = (_a3 = eq.options) != null ? _a3 : [];
+        let degraded = false;
+        const ch = {
+          kind: "select-inline",
+          id: `equipment-${i}`,
+          label: "Starting Equipment",
+          count: 1,
+          options: options.map((opt, j) => {
+            var _a4;
+            const label = typeof opt === "string" ? opt : (_a4 = opt == null ? void 0 : opt.label) != null ? _a4 : "";
+            const grants = opt && typeof opt === "object" && Array.isArray(opt.grants) ? opt.grants : [];
+            if (typeof opt === "string" || !(opt && typeof opt === "object" && Array.isArray(opt.grants))) {
+              degraded = true;
+            }
+            return {
+              value: `option-${j}`,
+              label,
+              choices: grants.flatMap((g, k) => g && typeof g === "object" && "category" in g && g.category ? [categoryToEntitySelect(g.category, `equipment-${i}-opt-${j}-cat-${k}`)] : [])
+            };
+          })
+        };
+        if (degraded && !warnedDegradedEquipment.has(entity.slug)) {
+          warnedDegradedEquipment.add(entity.slug);
+          console.warn(
+            `[archivist] Starting equipment for "${entity.slug}" is in an outdated/unstructured format; its nested picks and seeding are skipped. Re-sync the compendium (delete _compendium.md and reload) to fix.`
+          );
+        }
+        push(1, buildItem(
+          ch,
+          { kind: "class", slug: entity.slug, level: 1 },
+          1,
+          "Starting Equipment",
+          readAt(1),
+          ctx,
+          ownerBare
+        ));
+      });
+    }
+    let sawAuthoredSubclass = false;
+    for (const rf of resolved.features) {
+      const src = rf.source;
+      if (src.kind !== "class" && src.kind !== "subclass") continue;
+      const belongs = src.kind === "class" ? src.slug === entity.slug : c.subclass != null && src.slug === c.subclass.slug;
+      if (!belongs) continue;
+      const lvl = src.level;
+      let choices = rf.feature.choices;
+      if (!(choices == null ? void 0 : choices.length)) {
+        const recognized = recognizeDecision(rf.feature);
+        if (recognized === "informational") {
+          push(lvl, {
+            key: (_d2 = rf.feature.id) != null ? _d2 : rf.feature.name,
+            source: src,
+            level: lvl,
+            featureName: rf.feature.name,
+            description: (_f = rf.feature.description) != null ? _f : (_e = rf.feature.entries) == null ? void 0 : _e.join("\n\n"),
+            choice: { kind: "select-inline", id: (_g = rf.feature.id) != null ? _g : rf.feature.name, options: [{ value: "_", label: "_" }] },
+            options: [],
+            selected: void 0,
+            status: "informational"
+          });
+          continue;
+        }
+        choices = recognized != null ? recognized : void 0;
+      }
+      if (!(choices == null ? void 0 : choices.length)) {
+        if (rf.feature.description || ((_h = rf.feature.entries) == null ? void 0 : _h.length)) {
+          push(lvl, {
+            key: (_i = rf.feature.id) != null ? _i : rf.feature.name,
+            source: src,
+            level: lvl,
+            featureName: rf.feature.name,
+            description: (_k = rf.feature.description) != null ? _k : (_j = rf.feature.entries) == null ? void 0 : _j.join("\n\n"),
+            choice: { kind: "select-inline", id: (_l = rf.feature.id) != null ? _l : rf.feature.name, options: [{ value: "_", label: "_" }] },
+            options: [],
+            selected: void 0,
+            status: "informational"
+          });
+        }
+        continue;
+      }
+      for (const ch of choices) {
+        if (ch.kind === "select-entity" && ch.entity_type === "subclass") {
+          sawAuthoredSubclass = true;
+          push(lvl, buildSubclassItem(ch, src, lvl, rf.feature.name, c, ctx, ownerBare, rf.feature.description));
+          continue;
+        }
+        push(lvl, buildItem(
+          ch,
+          src,
+          lvl,
+          rf.feature.name,
+          readAt(lvl),
+          ctx,
+          ownerBare,
+          { description: rf.feature.description }
+        ));
+      }
+    }
+    const subclassLevel = (_m = entity.subclass_level) != null ? _m : null;
+    if (subclassLevel != null && subclassLevel <= c.level && !sawAuthoredSubclass) {
+      const featureName = (_n = entity.subclass_feature_name) != null ? _n : "Subclass";
+      const synthChoice = {
+        kind: "select-entity",
+        id: "subclass",
+        label: featureName,
+        count: 1,
+        entity_type: "subclass",
+        where: { parent_class: "self" }
+      };
+      push(subclassLevel, buildSubclassItem(
+        synthChoice,
+        { kind: "class", slug: entity.slug, level: subclassLevel },
+        subclassLevel,
+        featureName,
+        c,
+        ctx,
+        ownerBare
+      ));
+    }
+    for (const pool of resolved.pools) {
+      if (pool.classIndex !== classIndex || pool.count < 1) continue;
+      const synth = {
+        kind: "select-entity",
+        id: pool.id,
+        label: pool.label,
+        count: pool.count,
+        entity_type: "optional-feature",
+        from: pool.available.map((e) => e.slug)
+      };
+      push(pool.anchorLevel, buildItem(
+        synth,
+        { kind: "class", slug: entity.slug, level: pool.anchorLevel },
+        pool.anchorLevel,
+        pool.label,
+        readAt(pool.anchorLevel),
+        ctx,
+        ownerBare
+      ));
+    }
+    const levels = [...byLevel.entries()].sort(([a], [b]) => a - b).map(([level, items]) => ({ level, items }));
+    classes.push({ classIndex, levels });
+  });
+  const origin = [];
+  const oc = (_a = resolved.definition.origin_choices) != null ? _a : {};
+  const originRead = (ns) => (id) => oc[`${ns}:${id}`];
+  const pushOrigin = (choices, ns, source, featureName, ownerBare, description) => {
+    for (const ch of choices != null ? choices : []) {
+      origin.push(buildItem(ch, source, 0, featureName, originRead(ns), ctx, ownerBare, { description }));
+    }
+  };
+  if (resolved.race) {
+    const bare = bareEntitySlug(resolved.race.slug);
+    pushOrigin(
+      resolved.race.choices,
+      "race",
+      { kind: "race", slug: resolved.race.slug },
+      (_b = resolved.race.name) != null ? _b : "Race",
+      bare,
+      resolved.race.description
+    );
+    for (const t of (_c = resolved.race.traits) != null ? _c : []) {
+      pushOrigin(
+        t.choices,
+        "race",
+        { kind: "race", slug: resolved.race.slug },
+        t.name,
+        bare,
+        t.description
+      );
+    }
+  }
+  if (resolved.background) {
+    const bare = bareEntitySlug(resolved.background.slug);
+    pushOrigin(
+      resolved.background.choices,
+      "background",
+      { kind: "background", slug: resolved.background.slug },
+      (_d = resolved.background.name) != null ? _d : "Background",
+      bare,
+      resolved.background.description
+    );
+    if (resolved.background.feature) {
+      pushOrigin(
+        resolved.background.feature.choices,
+        "background",
+        { kind: "background", slug: resolved.background.slug },
+        resolved.background.feature.name,
+        bare,
+        resolved.background.feature.description
+      );
+    }
+  }
+  return { classes, origin };
+}
+
+export {
+  wikilinkTailSlug,
+  bareEntitySlug,
+  __matchesFilterForTest,
+  collectChosenProficiencies,
+  collectChosenAbilityPoints,
+  buildDecisionLedger
+};

package/dist/chunk-TZK36BU7.js

@@ -0,0 +1,38 @@
+// src/pc/conditions.constants.ts
+var CONDITION_SLUGS = [
+  "blinded",
+  "charmed",
+  "deafened",
+  "frightened",
+  "grappled",
+  "incapacitated",
+  "invisible",
+  "paralyzed",
+  "petrified",
+  "poisoned",
+  "prone",
+  "restrained",
+  "stunned",
+  "unconscious"
+];
+var CONDITION_DISPLAY_NAMES = {
+  blinded: "Blinded",
+  charmed: "Charmed",
+  deafened: "Deafened",
+  frightened: "Frightened",
+  grappled: "Grappled",
+  incapacitated: "Incapacitated",
+  invisible: "Invisible",
+  paralyzed: "Paralyzed",
+  petrified: "Petrified",
+  poisoned: "Poisoned",
+  prone: "Prone",
+  restrained: "Restrained",
+  stunned: "Stunned",
+  unconscious: "Unconscious"
+};
+
+export {
+  CONDITION_SLUGS,
+  CONDITION_DISPLAY_NAMES
+};

package/dist/chunk-UC4FE5X3.js

@@ -0,0 +1,65 @@
+import {
+  resolveBaseItem
+} from "./chunk-DC74TZNA.js";
+
+// src/pc/pc.slotting.ts
+function isItemEntity(e) {
+  return !!e && typeof e === "object" && "rarity" in e;
+}
+function isWeaponEntity(e) {
+  if (!e || typeof e !== "object") return false;
+  if (!("damage" in e) || !("category" in e)) return false;
+  const cat = e.category;
+  return typeof cat === "string" && /melee|ranged/.test(cat);
+}
+function isArmorEntity(e) {
+  return !!e && typeof e === "object" && "ac" in e && "category" in e && !("damage" in e);
+}
+function resolveEntityForEntry(item, registry) {
+  const found = resolveBaseItem(item, registry);
+  if (!found) return { entity: null, entityType: null };
+  return {
+    entity: found.data,
+    entityType: found.entityType
+  };
+}
+function isShieldArmor(armor) {
+  var _a, _b;
+  if (armor.category === "shield") return true;
+  const slug = ((_a = armor.slug) != null ? _a : "").toLowerCase();
+  if (slug === "shield" || slug.endsWith("_shield") || slug.endsWith("-shield")) return true;
+  return ((_b = armor.name) != null ? _b : "").trim().toLowerCase() === "shield";
+}
+function effectiveArmor(entity, registry) {
+  if (isArmorEntity(entity)) return entity;
+  if (isItemEntity(entity) && typeof entity.base_item === "string") {
+    const base = resolveBaseItem(entity.base_item, registry);
+    if ((base == null ? void 0 : base.entityType) === "armor") return base.data;
+  }
+  return null;
+}
+function defaultSlotForType(entityType, entity, registry) {
+  if (entityType === "weapon") return "mainhand";
+  if (entityType === "armor") {
+    return isArmorEntity(entity) && isShieldArmor(entity) ? "shield" : "armor";
+  }
+  if (entityType === "item" && isItemEntity(entity) && typeof entity.base_item === "string") {
+    const base = resolveBaseItem(entity.base_item, registry);
+    if ((base == null ? void 0 : base.entityType) === "weapon") return "mainhand";
+    if ((base == null ? void 0 : base.entityType) === "armor") {
+      const armorData = base.data;
+      return isShieldArmor(armorData) ? "shield" : "armor";
+    }
+  }
+  return null;
+}
+
+export {
+  isItemEntity,
+  isWeaponEntity,
+  isArmorEntity,
+  resolveEntityForEntry,
+  isShieldArmor,
+  effectiveArmor,
+  defaultSlotForType
+};