@archivist-gg/dnd5e 0.3.11 → 0.3.13

package/dist/types/equipment-grant.d.ts

@@ -1,7 +1,9 @@
 /** One thing a starting-equipment option grants. `item` is a BARE compendium
  *  slug (e.g. "chain-mail"); the seeder resolves it to the full edition slug.
  *  `category` is a player-picked class of item ("martial-weapon",
- *  "simple-weapon", "martial-melee-weapon", "any-armor", "shield", …) resolved
+ *  "simple-weapon", "martial-melee-weapon", "any-armor", "shield",
+ *  "musical-instrument", "artisan's-tools", "gaming-set", a tool `X-or-Y` union;
+ *  the vocabulary is `categoryToEntitySelect`'s in pc.decision-engine.ts) resolved
  *  by a nested select-entity. `gold` is gp folded into the bundle. */
 export type EquipmentGrant = 
 /** `contains_value` (COPPER; `1500` = 15 gp) is seeded as gold by the plugin's starting-equipment seeder
@@ -19,6 +21,21 @@ export type EquipmentGrant =
 } | {
     gold: number;
 };
+/** THE rule for which grant is a player-picked CATEGORY: an object whose `category` is a non-empty string. Shared by
+ *  the engine's nested-pick synthesis and the plugin's seeder, so the nth category grant of an option always
+ *  consumes the nth pick key and the two can never count a malformed grant differently. */
+export declare function isCategoryGrant(g: unknown): g is Extract<EquipmentGrant, {
+    category: string;
+}>;
+/** The persistence key of the nested pick for grant `k` of option `j` of starting-equipment entry `i`: the one
+ *  spelling the engine emits and the plugin reads. `k` indexes the option's WHOLE grant list, not its category
+ *  grants alone. */
+export declare const equipmentCategoryKey: (i: number, j: number, k: number) => string;
+/** The ORDERED pick keys of one option's category grants, the order `resolveGrants` consumes them in. */
+export declare const equipmentCategoryKeys: (grants: readonly unknown[], i: number, j: number) => string[];
+/** True for a starting-equipment decision key (`equipment-<i>` and its nested picks). The Equipment step owns
+ *  these; every other step's decision strip leaves them out. */
+export declare const isStartingEquipmentKey: (key: string) => boolean;
 /** One selectable option of a `kind:"choice"` starting-equipment entry. `label`
  *  is the human display string (the `.pc-cb-eqopt` text); `grants` is what seeds. */
 export interface EquipmentOption {

package/dist/types/equipment-grant.js

@@ -0,0 +1,12 @@
+import {
+  equipmentCategoryKey,
+  equipmentCategoryKeys,
+  isCategoryGrant,
+  isStartingEquipmentKey
+} from "../chunk-2LULMQTF.js";
+export {
+  equipmentCategoryKey,
+  equipmentCategoryKeys,
+  isCategoryGrant,
+  isStartingEquipmentKey
+};

package/dist/types/feature-effect.d.ts

@@ -1,5 +1,10 @@
 import type { Ability } from "./choice.js";
 export type SenseType = "darkvision" | "blindsight" | "tremorsense" | "truesight";
+/** A damage rider's weapon scope, the `damage-bonus` arm's structured `applies_to` words (ART-c1 Task 9b, controller
+ *  ruling 8): `melee` and `ranged` are the weapon's CATEGORY (a thrown melee weapon stays melee), `unarmed` the engine's
+ *  Unarmed Strike row, `finesse` and `thrown` the row's properties, and `weapon` every attack row (today's reach, the
+ *  Unarmed Strike row included). A list reaches a row when ANY word matches it. */
+export type WeaponScope = "weapon" | "melee" | "ranged" | "unarmed" | "finesse" | "thrown";
 /** Present on every arm: whose numbers the effect changes. Absent === "self". The engine's fold readers skip
  *  every effect whose subject is present and not "self" (`foldsOnSelf` in pc.feature-effects.ts). */
 type Subject = {
@@ -69,7 +74,7 @@ export type FeatureEffect = ({
     kind: "damage-bonus";
     damage_type: string;
     amount: string;
-    applies_to?: "weapon" | "spell" | "all";
+    applies_to?: "spell" | "all" | WeaponScope | WeaponScope[];
 } & Qualified) | ({
     kind: "proficiency";
     proficiency_type: "skill" | "tool" | "language" | "saving-throw" | "armor" | "weapon";

package/dist/types/optional-feature.types.d.ts

@@ -8,7 +8,7 @@ import type { AdditionalSpellsEntry, ProgressionEntry } from "../schemas/entity-
  * `feature_type` field is now an open string (see {@link OptionalFeatureEntity})
  * so homebrew categories parse; this union is kept purely as a reference list.
  */
-export type OptionalFeatureKind = "invocation" | "fighting_style" | "metamagic" | "maneuver" | "infusion";
+export type OptionalFeatureKind = "invocation" | "fighting_style" | "metamagic" | "maneuver" | "infusion" | "artificer_plan";
 /** A class/subclass named reference carried by a level prerequisite; mirrors namedRefSchema. */
 export type OptionalFeatureNamedRef = {
     name: string;
@@ -45,6 +45,76 @@ export type OptionalFeaturePrerequisite = {
     entry?: string;
     entry_summary?: string;
 };
+/** ART-a (spec §4.2). */
+export interface FilterSpec {
+    rarity: string[];
+    types?: string[];
+    exclude_types?: string[];
+    cursed?: false;
+}
+export interface OptionCreates {
+    item?: string;
+    variant?: {
+        candidates: string[];
+    };
+    filter?: FilterSpec;
+}
+export interface OptionRow {
+    key: string;
+    name: string;
+    min_level: number;
+    attunement?: boolean;
+    creates: OptionCreates;
+}
+export interface InfuseItem {
+    bonuses?: {
+        ac?: number;
+        weapon_attack?: number;
+        weapon_damage?: number;
+        spell_attack?: number;
+        saving_throws?: number;
+        speed?: {
+            walk?: number;
+            fly?: number;
+            swim?: number;
+            climb?: number;
+        };
+    };
+    resist?: string[];
+    charges?: {
+        max: number;
+        dice?: string;
+        recharge?: string;
+        recharge_amount?: string;
+    };
+    action?: ActionCost;
+    /** ART-c1 (R-3 a): the Actions row's range ("Self"); absent draws no range. */
+    range?: string;
+}
+export interface InfuseTarget {
+    kind: "armor" | "shield" | "weapon" | "gear";
+    category?: string[];
+    property?: string;
+    name_any?: string[];
+}
+export interface InfuseBlock {
+    targets: InfuseTarget[];
+    targets_label?: string;
+    new_object?: string;
+    rarity?: string;
+    attunement?: {
+        required: true;
+    };
+    choice?: {
+        kind: "damage-type";
+        options?: string[];
+    };
+    item?: InfuseItem;
+    scales_at?: Array<{
+        level: number;
+        item: InfuseItem;
+    }>;
+}
 export interface OptionalFeatureEntity {
     slug: string;
     name: string;
@@ -87,4 +157,12 @@ export interface OptionalFeatureEntity {
     optionalfeature_progression?: ProgressionEntry[];
     /** One wikilink, or an array of them for the multi-fluff-image emit. */
     image?: string | string[];
+    /** ART-a (spec §4.1): a pick is a COPY `<note slug>#<param>`; needs `options` and `item_choice`. */
+    repeatable?: true;
+    /** `learn`: the param is the item's FULL slug (TCE); `create`: the param is a row key, the item chosen at Create (EFA). */
+    item_choice?: "learn" | "create";
+    /** The table a copy's param must satisfy (spec §4.2). */
+    options?: OptionRow[];
+    /** This member infuses an existing object; its effect is an item-vocabulary overlay (spec §4.2). */
+    infuse?: InfuseBlock;
 }

package/dist/types/selection-pool.d.ts

@@ -1,3 +1,12 @@
+/** ART-a (spec §4.5): the at-once counter of an item-bound pool; its defaults are applied at read (`poolActiveWords`). */
+export interface PoolActive {
+    column: string;
+    label: string;
+    verb: string;
+    counter_label?: string;
+    create_label?: string;
+    create_verb?: string;
+}
 /** A (sub)class-declared selectable pool (e.g. Interdict Boons). The engine is
  *  generic: every game-specific string lives here in data, never in code. */
 export interface SelectionPool {
@@ -10,11 +19,17 @@ export interface SelectionPool {
             available_to: "self";
         };
     };
-    /** Pick count read from the owning class table column at the current level. */
+    /** Pick count read from the owning class table column at the current level. `label` is the known-counter word,
+     *  read through `poolCountLabel` (absent reads "Known", ART-a spec §4.5). */
     count: {
         column: string;
+        label?: string;
     };
     replaceable?: boolean;
+    /** ART-a (spec §4.5): the at-once counter (Infused Items, Magic Items). */
+    active?: PoolActive;
+    /** ART-a (spec §4.5): a resource id the tab head shows when the pool spends none of its own. */
+    head_resource?: string;
 }
 /** Subclass auto-grants that extend a named pool and do NOT count toward picks. */
 export interface PoolGrant {

package/dist/weapon/weapon.classify.d.ts

@@ -1,13 +1,15 @@
 import type { WeaponEntity } from "./weapon.types.js";
 /** The two attack modes a weapon supports, derived from data the SRD pipeline
- *  actually preserves. The SRD runtime data miscategorizes throwable MELEE
- *  weapons (dagger/spear/handaxe/javelin/light hammer/trident) as `*-ranged`,
- *  so the melee/ranged split is reconstructed here instead of trusted:
- *  a category-ranged weapon is PURE ranged only when it needs ammunition or
- *  loading, or is one of the two genuinely-ranged thrown weapons (dart, net —
- *  a closed SRD set; a homebrew weapon whose bare slug is exactly "dart"/"net"
- *  is force-classified pure ranged). Everything else category-ranged is a
- *  throwable melee weapon. `reach` is 5 ft, +5 with the reach property. */
+ *  actually preserves. Since dnd5e 0.3.13 the SRD data files the throwable
+ *  MELEE weapons (dagger/spear/handaxe/javelin/light hammer/trident) as
+ *  `*-melee`, but older SRD data, imported records and homebrew can still file
+ *  them as `*-ranged` (by their thrown range), so the melee/ranged split is
+ *  reconstructed here instead of trusted: a category-ranged weapon is PURE
+ *  ranged only when it needs ammunition or loading, or is one of the two
+ *  genuinely-ranged thrown weapons (dart, net: a closed SRD set; a homebrew
+ *  weapon whose bare slug is exactly "dart"/"net" is force-classified pure
+ *  ranged). Everything else category-ranged is a throwable melee weapon.
+ *  `reach` is 5 ft., +5 with the reach property. */
 export interface WeaponRangeModes {
     melee: {
         reach: number;

package/dist/weapon/weapon.classify.js

@@ -1,7 +1,7 @@
 import {
   classifyWeaponRange
-} from "../chunk-UIRMA5KM.js";
-import "../chunk-6X4KUDMU.js";
+} from "../chunk-YDGMBMYI.js";
+import "../chunk-ZCTUYGNV.js";
 export {
   classifyWeaponRange
 };

package/dist/weapon/weapon.codec.js

@@ -1,8 +1,8 @@
 import {
   weaponCodec
-} from "../chunk-LDDCNPHD.js";
-import "../chunk-HZA7OE7N.js";
-import "../chunk-2DFENQIJ.js";
+} from "../chunk-K5NJBTE2.js";
+import "../chunk-XCFC7LGF.js";
+import "../chunk-5GKJAUMX.js";
 import "../chunk-UA5KS2PL.js";
 export {
   weaponCodec

package/dist/weapon/weapon.parser.js

@@ -1,7 +1,7 @@
 import {
   parseWeapon
-} from "../chunk-HZA7OE7N.js";
-import "../chunk-2DFENQIJ.js";
+} from "../chunk-XCFC7LGF.js";
+import "../chunk-5GKJAUMX.js";
 import "../chunk-UA5KS2PL.js";
 export {
   parseWeapon

package/dist/weapon/weapon.schema.d.ts

@@ -31,6 +31,7 @@ export declare const weaponEntitySchema: z.ZodObject<{
     }>;
     entries: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
     rendering_hint: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
     has_fluff: z.ZodOptional<z.ZodBoolean>;
     has_fluff_images: z.ZodOptional<z.ZodBoolean>;
     image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;

package/dist/weapon/weapon.schema.js

@@ -1,6 +1,6 @@
 import {
   weaponEntitySchema
-} from "../chunk-2DFENQIJ.js";
+} from "../chunk-5GKJAUMX.js";
 import "../chunk-UA5KS2PL.js";
 export {
   weaponEntitySchema

package/dist/weapon/weapon.types.d.ts

@@ -36,6 +36,8 @@ export interface WeaponEntity {
     entries?: unknown[];
     /** Carried as the empty string on every converter weapon carrier today (98). */
     rendering_hint?: string;
+    /** The icon key (I3): a key of the renderer's icon set or a Lucide name. */
+    icon?: string;
     has_fluff?: boolean;
     has_fluff_images?: boolean;
     /** One wikilink, or an array for >= 2 fluff images (images-ON emit). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archivist-gg/dnd5e",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "license": "MIT AND CC-BY-4.0",
   "type": "module",
   "publishConfig": {

package/dist/chunk-O4SRD3J5.js

@@ -1,165 +0,0 @@
-import {
-  derivePoolLayout
-} from "./chunk-PP2UHLBA.js";
-import {
-  readTableColumn
-} from "./chunk-IUAAXXNO.js";
-import {
-  warnOnce
-} from "./chunk-LVQLWRCU.js";
-import {
-  bareEntitySlug,
-  wikilinkTailSlug
-} from "./chunk-6X4KUDMU.js";
-
-// src/pc/pc.pools.ts
-function levelPrereqMax(d) {
-  var _a;
-  return ((_a = d.prerequisites) != null ? _a : []).filter((p) => p.kind === "level").reduce((m, p) => Math.max(m, p.min), 0);
-}
-function resolvePool(rc, classIndex, pool, registry, index) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-  const entity = rc.entity;
-  const level = rc.level;
-  const ownerBare = bareEntitySlug(entity.slug);
-  const ownerPrefix = entity.slug.split("_")[0];
-  const col = pool.count.column;
-  const count = (_a = readTableColumn(entity.table, level, [col])) != null ? _a : 0;
-  let anchorLevel = 1;
-  let columnSeen = false;
-  for (let l = 1; l <= 20; l++) {
-    const c = readTableColumn(entity.table, l, [col]);
-    if (c != null) columnSeen = true;
-    if (c != null && c >= 1) {
-      anchorLevel = l;
-      break;
-    }
-  }
-  if (!columnSeen) {
-    warnOnce(
-      `pool-column:${pool.id}`,
-      `Archivist: pool "${pool.id}" declares count column "${col}", which "${entity.slug}"'s class table carries at no level; the pool resolves count 0 at anchor level 1`
-    );
-  }
-  const ft = pool.source.where.feature_type;
-  const all = registry.search("", "optional-feature", Number.POSITIVE_INFINITY).slice().sort((a, b) => a.name.localeCompare(b.name) || a.slug.localeCompare(b.slug));
-  const byBare = /* @__PURE__ */ new Map();
-  const candidates = /* @__PURE__ */ new Map();
-  for (const e of all) {
-    const d = e.data;
-    const entry = { slug: e.slug, entity: d, ...e.compendium ? { compendium: e.compendium } : {} };
-    const bare = bareEntitySlug(e.slug);
-    byBare.set(bare, entry);
-    if (d.feature_type !== ft) continue;
-    if (!((_b = d.available_to) != null ? _b : []).some((l) => wikilinkTailSlug(l) === ownerBare)) continue;
-    if (levelPrereqMax(d) > level) continue;
-    const group = candidates.get(bare);
-    if (group) group.push(entry);
-    else candidates.set(bare, [entry]);
-  }
-  const available = [];
-  for (const [bare, group] of candidates) {
-    if (group.length === 1) {
-      available.push(group[0]);
-      continue;
-    }
-    const owned = group.find((e) => e.slug.split("_")[0] === ownerPrefix);
-    if (!owned) {
-      warnOnce(
-        `pool-collapse:${bare}`,
-        `Archivist: pool "${pool.id}" holds ${group.length} cross-edition entries for "${bare}" and none shares the owner's compendium prefix "${ownerPrefix}"; keeping "${group[0].slug}"`
-      );
-    }
-    available.push(owned != null ? owned : group[0]);
-  }
-  const grantDecls = [
-    ...(_d = (_c = rc.entity) == null ? void 0 : _c.pool_grants) != null ? _d : [],
-    ...(_f = (_e = rc.subclass) == null ? void 0 : _e.pool_grants) != null ? _f : []
-  ];
-  const grantsRaw = grantDecls.filter((g) => g.pool === pool.id).flatMap((g) => g.grants).filter((g) => g.at_level <= level).map((g) => byBare.get(wikilinkTailSlug(g.feature))).filter((e) => e != null);
-  const grantedBare = /* @__PURE__ */ new Set();
-  const grants = grantsRaw.filter((e) => {
-    const key = bareEntitySlug(e.slug);
-    if (grantedBare.has(key)) return false;
-    grantedBare.add(key);
-    return true;
-  });
-  const bySlugAvailable = new Map(available.map((e) => [e.slug, e]));
-  const byBareAvailable = new Map(available.map((e) => [bareEntitySlug(e.slug), e]));
-  const resolveStored = (s) => {
-    const exact = bySlugAvailable.get(s);
-    if (exact) return exact;
-    const survivor = byBareAvailable.get(bareEntitySlug(s));
-    if (survivor) return survivor;
-    const full = registry.getByTypeAndSlug("optional-feature", s);
-    if (full) {
-      const d = full.data;
-      return { slug: full.slug, entity: d, ...full.compendium ? { compendium: full.compendium } : {} };
-    }
-    return byBare.get(bareEntitySlug(s));
-  };
-  const raw = (_g = rc.choices[anchorLevel]) == null ? void 0 : _g[pool.id];
-  const selectedSlugs = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
-  const selected = [];
-  const seenBare = /* @__PURE__ */ new Set();
-  for (const s of selectedSlugs) {
-    const entry = resolveStored(s);
-    if (!entry) continue;
-    const bare = bareEntitySlug(entry.slug);
-    if (grantedBare.has(bare) || seenBare.has(bare)) continue;
-    seenBare.add(bare);
-    selected.push(entry);
-  }
-  const members = [...available, ...grants];
-  const layout = derivePoolLayout(members);
-  const votes = /* @__PURE__ */ new Map();
-  for (const e of members) {
-    const id = (_h = e.entity.consumes) == null ? void 0 : _h.resource;
-    if (!id || !index.has(id)) continue;
-    votes.set(id, ((_i = votes.get(id)) != null ? _i : 0) + 1);
-  }
-  let resource;
-  let bestN = 0;
-  for (const [id, n] of votes) if (n > bestN) {
-    resource = id;
-    bestN = n;
-  }
-  return {
-    id: pool.id,
-    label: pool.label,
-    classIndex,
-    count,
-    anchorLevel,
-    selected,
-    available,
-    grants,
-    ...layout ? { layout } : {},
-    ...resource ? { resource } : {}
-  };
-}
-function resolveAllPools(resolved, registry, index) {
-  const out = [];
-  resolved.classes.forEach((rc, classIndex) => {
-    var _a, _b, _c;
-    if (!rc.entity) return;
-    const decls = [...(_a = rc.entity.selection_pools) != null ? _a : [], ...(_c = (_b = rc.subclass) == null ? void 0 : _b.selection_pools) != null ? _c : []];
-    const seen = /* @__PURE__ */ new Set();
-    for (const pool of decls) {
-      if (seen.has(pool.id)) continue;
-      seen.add(pool.id);
-      out.push(resolvePool(rc, classIndex, pool, registry, index));
-    }
-  });
-  return out;
-}
-function strandedPicks(pool) {
-  const inAvailable = new Set(pool.available.map((e) => e.slug));
-  return pool.selected.filter((e) => !inAvailable.has(e.slug));
-}
-
-export {
-  levelPrereqMax,
-  resolvePool,
-  resolveAllPools,
-  strandedPicks
-};

package/dist/chunk-WXWPK3LI.js

@@ -1,55 +0,0 @@
-import {
-  slugify
-} from "./chunk-6X4KUDMU.js";
-
-// src/entities/base-item-resolver.ts
-function unwrapWikilink(input) {
-  const m = /^\[\[([^\]]+)\]\]$/.exec(input.trim());
-  if (!m) return null;
-  const inner = m[1];
-  const pipe = inner.indexOf("|");
-  return pipe === -1 ? inner : inner.slice(0, pipe);
-}
-var FOLDER_TO_TYPE = {
-  Weapons: "weapon",
-  Armor: "armor",
-  "Magic Items": "item"
-};
-function vaultPathToSlug(target) {
-  const segments = target.split("/").map((s) => s.trim()).filter((s) => s.length > 0);
-  if (segments.length === 0) return "";
-  if (segments.length === 1) {
-    return slugify(segments[0]);
-  }
-  const compendiumName = segments[0];
-  const typeFolder = segments[segments.length - 2];
-  const basename = segments[segments.length - 1];
-  const prefix = slugify(compendiumName);
-  const nameSlug = slugify(basename);
-  if (!prefix || !nameSlug) return nameSlug;
-  const type = FOLDER_TO_TYPE[typeFolder];
-  return type ? `${prefix}_${type}_${nameSlug}` : `${prefix}_${nameSlug}`;
-}
-function resolveBaseItem(baseItem, registry) {
-  var _a, _b;
-  if (typeof baseItem !== "string" || baseItem.length === 0) return null;
-  const target = (_a = unwrapWikilink(baseItem)) != null ? _a : baseItem.trim();
-  if (target.length === 0) return null;
-  if (!target.includes("/")) {
-    const direct = registry.getBySlug(target);
-    if (direct) return direct;
-  }
-  const slug = vaultPathToSlug(target);
-  if (!slug) return null;
-  return (_b = registry.getBySlug(slug)) != null ? _b : null;
-}
-function resolveBaseItemOfType(baseItem, entityType, registry) {
-  const found = resolveBaseItem(baseItem, registry);
-  return found && found.entityType === entityType ? found : null;
-}
-
-export {
-  vaultPathToSlug,
-  resolveBaseItem,
-  resolveBaseItemOfType
-};