@archivist-gg/dnd5e 0.3.19 → 0.3.26

package/dist/entities/base-item-resolver.d.ts

@@ -1,30 +1,4 @@
 import type { EntityRegistry, RegisteredEntity } from "@archivist-gg/core";
-/**
- * Convert a vault-path target (e.g. `SRD 5e/Weapons/Longsword`) to a
- * registry-compatible slug (`srd-5e_weapon_longsword`). The middle Type folder
- * (`segments[length-2]`) supplies the entity-type token so the slug matches
- * the now type-namespaced registry key. For a bare basename without any `/`,
- * returns the slugified basename - which lets legacy wikilinks like
- * `[[longsword]]` continue to resolve when registered under that bare slug.
- */
 export declare function vaultPathToSlug(target: string): string;
-/**
- * Public: take a `base_item` string (vault-path wikilink, alias-form
- * wikilink, bare-slug wikilink, or bare slug) and return the matching
- * `RegisteredEntity` or null.
- *
- * - Empty / null / non-string input -> null
- * - String that doesn't unwrap to a slug -> null
- * - Slug not present in the registry -> null
- *
- * The lookup is type-agnostic: callers that need to narrow to a specific
- * `entityType` (e.g. "weapon" only) should branch on the result's
- * `entityType`. A type-narrowed convenience wrapper is also exported for the
- * common weapon/armor cases.
- */
 export declare function resolveBaseItem(baseItem: string | null | undefined, registry: EntityRegistry): RegisteredEntity | null;
-/**
- * Convenience: resolve and require a specific entityType. Returns null if
- * the entry resolves but is the wrong type.
- */
 export declare function resolveBaseItemOfType(baseItem: string | null | undefined, entityType: string, registry: EntityRegistry): RegisteredEntity | null;

package/dist/entities/base-item-resolver.js

@@ -1,11 +1 @@
-import {
-  resolveBaseItem,
-  resolveBaseItemOfType,
-  vaultPathToSlug
-} from "../chunk-CM5CWO4K.js";
-import "../chunk-ZCTUYGNV.js";
-export {
-  resolveBaseItem,
-  resolveBaseItemOfType,
-  vaultPathToSlug
-};
+import{resolveBaseItem,resolveBaseItemOfType,vaultPathToSlug}from"../chunk-PZ4L2EEG.js";import"../chunk-63YJPWTM.js";export{resolveBaseItem,resolveBaseItemOfType,vaultPathToSlug};

package/dist/entities/registry-revision.d.ts

@@ -1,25 +1,10 @@
-/**
- * A registry's change generation (PERF, Edgar 2026-09-28): a number that moves on every register, unregister and clear.
- * Core's `EntityRegistry` carries none; the plugin's registry does (`RevisionedEntityRegistry`). Registry-derived data
- * that does not depend on the character (an item index, a sorted bucket) is memoised per (registry, revision), so a
- * write that changes only the character reads the registry zero times.
- *
- * The rule is strict: a registry WITHOUT a numeric `revision` is never cached, so a mock, a plain core registry or any
- * other host always computes afresh and can never read stale data. (The older `registry.count()` memos in
- * `pc.spellcasting.ts` and `spell.access.ts` carry a known gap, an in-place re-registration; this key has none.)
- */
 export declare function registryRevision(registry: unknown): number | undefined;
-/** `compute()` once per (registry, revision), kept in `cache`; every call when the registry has no revision. */
 export declare function memoByRevision<T>(cache: WeakMap<object, {
     revision: number;
     value: T;
 }>, registry: object, compute: () => T): T;
-/** The registry surface a bucket read needs (structurally core's `EntityRegistry` and every narrower registry type). */
 interface BucketSource<T> {
     search(query: string, entityType: string, limit: number): T[];
 }
-/** `registry.search("", type, Infinity)`, the whole bucket in the registry's own order, read ONCE per registry state
- *  (every call when the registry has no revision). The array is SHARED by every caller until the revision moves: read
- *  it, never sort or splice it in place. */
 export declare function bucketOf<T>(registry: BucketSource<T>, type: string): readonly T[];
 export {};

package/dist/entities/registry-revision.js

@@ -1,10 +1 @@
-import {
-  bucketOf,
-  memoByRevision,
-  registryRevision
-} from "../chunk-4J6DS3EJ.js";
-export {
-  bucketOf,
-  memoByRevision,
-  registryRevision
-};
+import{bucketOf,memoByRevision,registryRevision}from"../chunk-QMEKQTUT.js";export{bucketOf,memoByRevision,registryRevision};

package/dist/entities/slug.d.ts

@@ -1,35 +1,5 @@
-/**
- * Converts a display name to a URL/file-safe kebab-case slug.
- * "Ancient Red Dragon" -> "ancient-red-dragon"
- */
 export declare function slugify(name: string): string;
-/** "srd-2024_fighter" → "fighter", "srd-2024_background_acolyte" → "acolyte".
- *  Arity-robust: strips a `<prefix>_<type>_<name>` (3-part) or legacy `<prefix>_<name>`
- *  (2-part) slug down to the bare NAME, and passes a bare slug through unchanged.
- *  Name-slugs never contain `_`, so for a 3-part-or-longer slug the name is
- *  `parts.slice(2).join("_")`. Tolerates a nullish slug (degrades to "") so a
- *  malformed entity can't hard-crash the builder; the resolver backfills real slugs. */
 export declare function bareEntitySlug(slug: string | null | undefined): string;
-/** Whether a link tail is a stored registry slug (`me_feat_wish-magic`) rather than a human name
- *  ("Wish Magic", "Magic Initiate (Cleric)"). The ONE slug-form rule: `wikilinkTailSlug` reads a tail by it,
- *  and a registry-free display surface uses it to name a slug-form link instead of printing the raw slug. */
 export declare function isStoredSlug(tail: string): boolean;
-/** A link's BARE name slug, the key `bareEntitySlug` gives an owner: "[[SRD 2024/Classes/Fighter]]" and
- *  "[[srd-2024_class_fighter]]" both give "fighter".
- *
- *  A link names an entity one of two ways, and the tail is read by its shape:
- *    - a human NAME tail (a path's file name, or a bare `[[fighter]]`) goes through the SAME `slugify` that mints
- *      registry slugs, so an apostrophe is DELETED rather than hyphenated ("Mage's Bane" to "mages-bane", where
- *      the old hand-rolled regex minted "mage-s-bane" and missed every time);
- *    - a STORED slug tail (`[[me_class_bard-captain-lugen-compatibility]]`, the form every PC note and the Me
- *      homebrew notes write) goes through `bareEntitySlug`. slugify DELETES the `_`, so it used to mint
- *      "meclassbard-captain-lugen-compatibility", no owner's bare slug: a Me subclass linking its class that way
- *      was never offered under it and the Builder's Class step called it an orphan (2026-09-25, Captain Lugen).
- *  The answer is the BARE slug, never the full one, so a lookup that needs the exact entity must not route a
- *  stored slug through here: `pc.decision-engine.ts`'s `resolveEntityRef` strips a `[[wikilink]]` WITHOUT this
- *  helper and looks the full slug up directly.
- *
- *  MOVED here from `pc.decision-engine.ts` in R4-G5 T1, beside `bareEntitySlug`, so `pc.pools.ts` can use it
- *  without importing the decision engine: the engine imports `pc.pools` for `strandedPicks`, and the old
- *  direction would be a cycle. The engine keeps a re-export for its plugin importer and its own test. */
 export declare function wikilinkTailSlug(link: string): string;
+export declare function twinKey(slug: string | null | undefined): string;

package/dist/entities/slug.js

@@ -1,12 +1 @@
-import {
-  bareEntitySlug,
-  isStoredSlug,
-  slugify,
-  wikilinkTailSlug
-} from "../chunk-ZCTUYGNV.js";
-export {
-  bareEntitySlug,
-  isStoredSlug,
-  slugify,
-  wikilinkTailSlug
-};
+import{bareEntitySlug,isStoredSlug,slugify,twinKey,wikilinkTailSlug}from"../chunk-63YJPWTM.js";export{bareEntitySlug,isStoredSlug,slugify,twinKey,wikilinkTailSlug};

package/dist/entities/wikilink-display.d.ts

@@ -1,3 +1 @@
-/** The human name of a wikilink target: `[[Player's Handbook (2024)/OptionalFeatures/Pact of the Blade]]` →
- *  "Pact of the Blade"; `[[path|Alias]]` → "Alias". The converter emits vault PATHS with no alias. */
 export declare function wikilinkDisplayName(link: string): string;

package/dist/entities/wikilink-display.js

@@ -1,10 +1 @@
-// src/entities/wikilink-display.ts
-function wikilinkDisplayName(link) {
-  const inner = link.trim().replace(/^\[\[/, "").replace(/\]\]$/, "");
-  const afterAlias = inner.includes("|") ? inner.slice(inner.lastIndexOf("|") + 1) : inner;
-  const afterSlash = afterAlias.includes("/") ? afterAlias.slice(afterAlias.lastIndexOf("/") + 1) : afterAlias;
-  return afterSlash.trim();
-}
-export {
-  wikilinkDisplayName
-};
+function wikilinkDisplayName(link){const inner=link.trim().replace(/^\[\[/,"").replace(/\]\]$/,"");const afterAlias=inner.includes("|")?inner.slice(inner.lastIndexOf("|")+1):inner;const afterSlash=afterAlias.includes("/")?afterAlias.slice(afterAlias.lastIndexOf("/")+1):afterAlias;return afterSlash.trim()}export{wikilinkDisplayName};

package/dist/feat/feat.category-codes.d.ts

@@ -1,32 +1,7 @@
 import type { FeatCategory } from "../types/choice.js";
-/** 5etools feat `category` codes, as DATA beside the schema (never a renderer switch). The converter emits the raw
- *  code on `exclusive-feat-category` and `feat-category` prerequisites (today only "D", on 14 documents; the G7
- *  handoff asks it for a name). `FS:P` and `FS:R` are the Paladin- and Ranger-scoped fighting-style categories.
- *  Measured in data/feats.json: G 80, EB 29, O 25, D 13, FS 10, DG 9, FS:P 1, FS:R 1. Unknown codes fall back to
- *  the code itself. */
 export declare const FEAT_CATEGORY_CODE_LABELS: Readonly<Record<string, string>>;
 export declare function featCategoryLabel(code: string): string;
-/** 5etools `feat_progression.category` codes to the ENGINE's `FeatCategory` vocabulary (R4-G5 §3.2.5,
- *  invariant 3): the DATA table the class-side progression reader maps through, beside the label table above.
- *  MEASURED over the converted corpus 2026-09-07: 18 `feat_progression` rows across 15 documents, codes
- *  {EB 13, FS 4, FS:P 1, FS:R 1, O 1}. The FS four are Fighter 2024 (level 1), Paladin 2024 and Ranger 2024
- *  (level 2, each carrying `["FS","FS:P"]` / `["FS","FS:R"]`) and the Champion 2024 SUBCLASS (level 7); the 13
- *  EB rows are the 12 PHB 2024 classes plus the Eberron Artificer, all at level 19. The single `O` row sits on
- *  an OPTIONAL FEATURE (Lessons of the First Ones) with a `"*"` progression key, outside the class walk, so `O`
- *  and `G` have zero live class-side carriers and are declared for completeness. `D` (Dragonmark) and `DG`
- *  (Dark Gift) map to NOTHING on purpose: they are not player-choosable feat categories in this vocabulary, and
- *  a row carrying only those emits no decision and warns once at the reader. G7 handoff (spec §11): the
- *  converter re-emits these codes in engine vocabulary and this table retires. */
 export declare const FEAT_PROGRESSION_CATEGORY: Readonly<Record<string, FeatCategory>>;
-/** The ONE `FeatCategory` to optional-feature `feature_type` pairing (R4-G5 §3.2.5). The shape-B suppression
- *  reads it to decide that a class carrying a fighting-style `feat_progression` row must NOT also be offered the
- *  recognizer's `fighting_style` optional-feature synthetic at that level. `Partial<Record<...>>` because three
- *  of the four categories pair with nothing, which is also what makes the lookup return `string | undefined`
- *  without an own-property guard. */
+export declare function featCategoryOf(value: string): string;
 export declare const FEATURE_TYPE_FOR_CATEGORY: Readonly<Partial<Record<FeatCategory, string>>>;
-/** Reduce a `feat_progression` entry's `category` ARRAY to ONE engine category: the FIRST code that maps wins, so
- *  the shipped `["FS","FS:P"]` (Paladin) and `["FS","FS:R"]` (Ranger) each yield exactly ONE decision instead of
- *  two. OWN-property guarded (invariant 3): the codes come from converter data, so `constructor` would otherwise
- *  index a FUNCTION through the prototype chain. Returns undefined when nothing maps (an all-`D` row); the
- *  CALLER warns, because this stays pure. */
 export declare function featProgressionCategory(codes: readonly string[] | undefined): FeatCategory | undefined;

package/dist/feat/feat.category-codes.js

@@ -1,14 +1 @@
-import {
-  FEATURE_TYPE_FOR_CATEGORY,
-  FEAT_CATEGORY_CODE_LABELS,
-  FEAT_PROGRESSION_CATEGORY,
-  featCategoryLabel,
-  featProgressionCategory
-} from "../chunk-YBLDE5CG.js";
-export {
-  FEATURE_TYPE_FOR_CATEGORY,
-  FEAT_CATEGORY_CODE_LABELS,
-  FEAT_PROGRESSION_CATEGORY,
-  featCategoryLabel,
-  featProgressionCategory
-};
+import{FEATURE_TYPE_FOR_CATEGORY,FEAT_CATEGORY_CODE_LABELS,FEAT_PROGRESSION_CATEGORY,featCategoryLabel,featCategoryOf,featProgressionCategory}from"../chunk-3QQOATV3.js";export{FEATURE_TYPE_FOR_CATEGORY,FEAT_CATEGORY_CODE_LABELS,FEAT_PROGRESSION_CATEGORY,featCategoryLabel,featCategoryOf,featProgressionCategory};

package/dist/feat/feat.codec.d.ts

@@ -1,9 +1,3 @@
 import type { DocCodec } from "@archivist-gg/core";
 import type { FeatEntity } from "./feat.types.js";
-/**
- * Normalizing codec (0c.1a). `parse` delegates to `parseFeat`, which seeds the
- * `edition: "2014"` default and validates against `featEntitySchema`.
- * `serialize` stays `yaml.dump` (the edit-save path uses obsidian's separate
- * serializer; gate (d) verifies `yaml.dump` round-trips through `parseFeat`).
- */
 export declare const featCodec: DocCodec<FeatEntity>;

package/dist/feat/feat.codec.js

@@ -1,12 +1 @@
-import {
-  featCodec
-} from "../chunk-ZOWKWMD2.js";
-import "../chunk-3SFGWFVQ.js";
-import "../chunk-FMYWORTP.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-OOL4KMG2.js";
-import "../chunk-JXWNXIIZ.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  featCodec
-};
+import{featCodec}from"../chunk-NU2Z7MTS.js";import"../chunk-OTRH62HY.js";import"../chunk-GIQLIBC7.js";import"../chunk-CCFIINBA.js";import"../chunk-LHH5XSEA.js";import"../chunk-ZVL5FXXO.js";import"../chunk-I26FHSI6.js";export{featCodec};

package/dist/feat/feat.parser.js

@@ -1,11 +1 @@
-import {
-  parseFeat
-} from "../chunk-3SFGWFVQ.js";
-import "../chunk-FMYWORTP.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-OOL4KMG2.js";
-import "../chunk-JXWNXIIZ.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  parseFeat
-};
+import{parseFeat}from"../chunk-OTRH62HY.js";import"../chunk-GIQLIBC7.js";import"../chunk-CCFIINBA.js";import"../chunk-LHH5XSEA.js";import"../chunk-ZVL5FXXO.js";import"../chunk-I26FHSI6.js";export{parseFeat};

package/dist/feat/feat.schema.d.ts

@@ -34,10 +34,10 @@ export declare const featEntitySchema: z.ZodObject<{
         kind: z.ZodLiteral<"proficiency">;
         proficiency_type: z.ZodEnum<{
             weapon: "weapon";
+            armor: "armor";
             skill: "skill";
             tool: "tool";
             "saving-throw": "saving-throw";
-            armor: "armor";
         }>;
         value: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
@@ -71,7 +71,8 @@ export declare const featEntitySchema: z.ZodObject<{
     benefits: z.ZodArray<z.ZodString>;
     effects: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"initiative-bonus">;
-        value: z.ZodNumber;
+        value: z.ZodOptional<z.ZodNumber>;
+        amount: z.ZodOptional<z.ZodString>;
         condition: z.ZodOptional<z.ZodString>;
         subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
@@ -146,12 +147,29 @@ export declare const featEntitySchema: z.ZodObject<{
             climb: "climb";
             burrow: "burrow";
         }>;
-        value: z.ZodNumber;
+        value: z.ZodOptional<z.ZodNumber>;
+        equal_to: z.ZodOptional<z.ZodLiteral<"walk">>;
         set: z.ZodOptional<z.ZodBoolean>;
         scales_at: z.ZodOptional<z.ZodArray<z.ZodObject<{
             level: z.ZodNumber;
             value: z.ZodNumber;
         }, z.core.$strip>>>;
+        inactive_while: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            "heavy-armor": "heavy-armor";
+            armor: "armor";
+            shield: "shield";
+        }>, z.ZodArray<z.ZodEnum<{
+            "heavy-armor": "heavy-armor";
+            armor: "armor";
+            shield: "shield";
+        }>>]>>;
+        condition: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"speed-rule">;
+        flag: z.ZodEnum<{
+            "ignore-armor-strength": "ignore-armor-strength";
+        }>;
         condition: z.ZodOptional<z.ZodString>;
         subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
@@ -198,6 +216,8 @@ export declare const featEntitySchema: z.ZodObject<{
             unarmed: "unarmed";
             finesse: "finesse";
             thrown: "thrown";
+            heavy: "heavy";
+            "pact-weapon": "pact-weapon";
         }>, z.ZodArray<z.ZodEnum<{
             weapon: "weapon";
             melee: "melee";
@@ -205,6 +225,8 @@ export declare const featEntitySchema: z.ZodObject<{
             unarmed: "unarmed";
             finesse: "finesse";
             thrown: "thrown";
+            heavy: "heavy";
+            "pact-weapon": "pact-weapon";
         }>>]>>;
         spell_scope: z.ZodOptional<z.ZodObject<{
             list: z.ZodOptional<z.ZodString>;
@@ -221,11 +243,11 @@ export declare const featEntitySchema: z.ZodObject<{
         kind: z.ZodLiteral<"proficiency">;
         proficiency_type: z.ZodEnum<{
             weapon: "weapon";
+            armor: "armor";
             skill: "skill";
             tool: "tool";
             language: "language";
             "saving-throw": "saving-throw";
-            armor: "armor";
         }>;
         value: z.ZodString;
         expertise: z.ZodOptional<z.ZodBoolean>;
@@ -303,6 +325,25 @@ export declare const featEntitySchema: z.ZodObject<{
             level: z.ZodNumber;
             count: z.ZodNumber;
         }, z.core.$strip>>>;
+        applies_to: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            weapon: "weapon";
+            melee: "melee";
+            ranged: "ranged";
+            unarmed: "unarmed";
+            finesse: "finesse";
+            thrown: "thrown";
+            heavy: "heavy";
+            "pact-weapon": "pact-weapon";
+        }>, z.ZodArray<z.ZodEnum<{
+            weapon: "weapon";
+            melee: "melee";
+            ranged: "ranged";
+            unarmed: "unarmed";
+            finesse: "finesse";
+            thrown: "thrown";
+            heavy: "heavy";
+            "pact-weapon": "pact-weapon";
+        }>>]>>;
         condition: z.ZodOptional<z.ZodString>;
         subject: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
@@ -469,6 +510,7 @@ export declare const featEntitySchema: z.ZodObject<{
             band: "band";
             tab: "tab";
         }>>;
+        equivalent_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
         recovery: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             name: z.ZodString;

package/dist/feat/feat.schema.js

@@ -1,10 +1 @@
-import {
-  featEntitySchema
-} from "../chunk-FMYWORTP.js";
-import "../chunk-ZJXSXVFP.js";
-import "../chunk-OOL4KMG2.js";
-import "../chunk-JXWNXIIZ.js";
-import "../chunk-UA5KS2PL.js";
-export {
-  featEntitySchema
-};
+import{featEntitySchema}from"../chunk-GIQLIBC7.js";import"../chunk-CCFIINBA.js";import"../chunk-LHH5XSEA.js";import"../chunk-ZVL5FXXO.js";import"../chunk-I26FHSI6.js";export{featEntitySchema};

package/dist/feat/feat.types.d.ts

@@ -61,18 +61,12 @@ export interface FeatEntity {
     repeatable: boolean;
     choices: Choice[];
     resources?: Resource[];
-    /** Converter/bundle extras declared by feat.schema.ts §2.4; all optional, none read today. */
     rendering_hint?: string;
     additional_spells?: AdditionalSpellsEntry[];
     has_fluff?: boolean;
     has_fluff_images?: boolean;
-    /** RAW 5etools passthrough: `unknown` mirrors the schema's `z.unknown()`. */
     trait_tags?: unknown;
     optionalfeature_progression?: ProgressionEntry[];
-    /** R-G1b-5: a TOP-LEVEL bundle key on `SRD 2024/Feats/Boon of the Night Spirit.md`.
-     *  MAPPED since R4-G3a §10.2.3: the resolver carries it onto the resolved feature's
-     *  `action`, so the feat note shows an Action line and the row files under that economy. */
     action_cost?: ActionCost;
-    /** One wikilink, or an array of them for the multi-fluff-image emit. */
     image?: string | string[];
 }