@archivist-gg/dnd5e 0.3.1 → 0.3.5

package/dist/dnd/resource-formula.js

@@ -1,159 +1,14 @@
-// src/dnd/resource-formula.ts
-var IDENTS = /* @__PURE__ */ new Set([
-  "level",
-  "class_level",
-  "prof",
-  "str_mod",
-  "dex_mod",
-  "con_mod",
-  "int_mod",
-  "wis_mod",
-  "cha_mod"
-]);
-var FUNCS = /* @__PURE__ */ new Set(["ceil", "floor"]);
-function tokenize(input) {
-  input = input.trim();
-  const tokens = [];
-  const re = /\s*('[^']*'|\{[a-z_]+\}|[a-z_]+|\d+|[+\-*/()])/y;
-  let i = 0;
-  while (i < input.length) {
-    re.lastIndex = i;
-    const m = re.exec(input);
-    if (!m || m.index !== i) return null;
-    const raw = m[1];
-    i = re.lastIndex;
-    if (/^\d+$/.test(raw)) tokens.push({ kind: "num", value: parseInt(raw, 10) });
-    else if (raw.startsWith("'")) tokens.push({ kind: "str", value: raw.slice(1, -1) });
-    else if (raw === "(") tokens.push({ kind: "lparen" });
-    else if (raw === ")") tokens.push({ kind: "rparen" });
-    else if (raw === "+" || raw === "-" || raw === "*" || raw === "/") tokens.push({ kind: "op", op: raw });
-    else {
-      const braced = raw.startsWith("{");
-      const name = braced ? raw.slice(1, -1) : raw;
-      if (!braced && FUNCS.has(name)) tokens.push({ kind: "fn", name });
-      else if (!braced && name === "column") tokens.push({ kind: "col" });
-      else if (IDENTS.has(name)) tokens.push({ kind: "id", name });
-      else return null;
-    }
-  }
-  return tokens.length > 0 ? tokens : null;
-}
-function evalTokens(tokens, b) {
-  let pos = 0;
-  const peek = () => tokens[pos];
-  const factor = () => {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const t = peek();
-    if (!t) return null;
-    if (t.kind === "num") {
-      pos++;
-      return t.value;
-    }
-    if (t.kind === "id") {
-      const val = b[t.name];
-      if (val === void 0) return null;
-      pos++;
-      return val;
-    }
-    if (t.kind === "fn") {
-      pos++;
-      if (((_a = peek()) == null ? void 0 : _a.kind) !== "lparen") return null;
-      pos++;
-      const inner = expr();
-      if (inner === null) return null;
-      if (((_b = peek()) == null ? void 0 : _b.kind) !== "rparen") return null;
-      pos++;
-      return t.name === "ceil" ? Math.ceil(inner) : Math.floor(inner);
-    }
-    if (t.kind === "col") {
-      pos++;
-      if (((_c = peek()) == null ? void 0 : _c.kind) !== "lparen") return null;
-      pos++;
-      const s = peek();
-      if (!s || s.kind !== "str") return null;
-      pos++;
-      if (((_d = peek()) == null ? void 0 : _d.kind) !== "rparen") return null;
-      pos++;
-      return (_f = (_e = b.columns) == null ? void 0 : _e[s.value]) != null ? _f : 0;
-    }
-    if (t.kind === "lparen") {
-      pos++;
-      const inner = expr();
-      if (inner === null) return null;
-      if (((_g = peek()) == null ? void 0 : _g.kind) !== "rparen") return null;
-      pos++;
-      return inner;
-    }
-    return null;
-  };
-  const term = () => {
-    var _a;
-    let v = factor();
-    if (v === null) return null;
-    while (((_a = peek()) == null ? void 0 : _a.kind) === "op" && (peek().op === "*" || peek().op === "/")) {
-      const op = peek().op;
-      pos++;
-      const r = factor();
-      if (r === null) return null;
-      v = op === "*" ? v * r : v / r;
-    }
-    return v;
-  };
-  const expr = () => {
-    var _a;
-    let v = term();
-    if (v === null) return null;
-    while (((_a = peek()) == null ? void 0 : _a.kind) === "op" && (peek().op === "+" || peek().op === "-")) {
-      const op = peek().op;
-      pos++;
-      const r = term();
-      if (r === null) return null;
-      v = op === "+" ? v + r : v - r;
-    }
-    return v;
-  };
-  const result = expr();
-  if (result === null || pos !== tokens.length) return null;
-  return result;
-}
-var ZERO = {
-  level: 1,
-  class_level: 1,
-  prof: 2,
-  str_mod: 0,
-  dex_mod: 0,
-  con_mod: 0,
-  int_mod: 0,
-  wis_mod: 0,
-  cha_mod: 0,
-  columns: {}
-};
-function isValidMaxFormula(formula) {
-  const toks = tokenize(formula);
-  if (!toks) return false;
-  return evalTokens(toks, ZERO) !== null;
-}
-function evaluateMaxFormula(formula, bindings) {
-  const toks = tokenize(formula);
-  if (!toks) throw new Error(`invalid max_formula: ${JSON.stringify(formula)}`);
-  const v = evalTokens(toks, bindings);
-  if (v === null) throw new Error(`invalid max_formula: ${JSON.stringify(formula)}`);
-  return v;
-}
-function resolveMaxAt(totalLevel, resource) {
-  var _a;
-  let chosen = resource.max_formula;
-  let best = 0;
-  for (const step of (_a = resource.scales_at) != null ? _a : []) {
-    if (step.level <= totalLevel && step.level > best) {
-      best = step.level;
-      chosen = step.max;
-    }
-  }
-  return chosen;
-}
+import {
+  AT_WILL_MAX,
+  evaluateMaxFormula,
+  isValidMaxFormula,
+  resolveMaxAt,
+  resolveMaxCountAt
+} from "../chunk-EVMUJYUD.js";
 export {
+  AT_WILL_MAX,
   evaluateMaxFormula,
   isValidMaxFormula,
-  resolveMaxAt
+  resolveMaxAt,
+  resolveMaxCountAt
 };

package/dist/dnd/srd-tag-converter.js

@@ -2,9 +2,9 @@ import {
   STATIC_FALLBACK_CONTEXT,
   convertDescToTags,
   detectSpellcastingAbility
-} from "../chunk-RAWJTA45.js";
-import "../chunk-NAEPSZAM.js";
-import "../chunk-WP2CX2JO.js";
+} from "../chunk-DEEHHLAP.js";
+import "../chunk-PDJSUH24.js";
+import "../chunk-WELIKLZF.js";
 export {
   STATIC_FALLBACK_CONTEXT,
   convertDescToTags,

package/dist/dnd/tag-grammar.js

@@ -4,7 +4,7 @@ import {
 } from "../chunk-QYZV2MQA.js";
 import {
   ABILITY_KEYS
-} from "../chunk-WP2CX2JO.js";
+} from "../chunk-WELIKLZF.js";
 export {
   ABILITY_KEYS as ABILITIES,
   normalizeTagType,

package/dist/dnd/warn-once.d.ts

@@ -0,0 +1,2 @@
+export declare function warnOnce(key: string, msg: string): void;
+export declare function __resetWarnOnceForTests(): void;

package/dist/dnd/warn-once.js

@@ -0,0 +1,8 @@
+import {
+  __resetWarnOnceForTests,
+  warnOnce
+} from "../chunk-LVQLWRCU.js";
+export {
+  __resetWarnOnceForTests,
+  warnOnce
+};

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

@@ -2,8 +2,8 @@ import {
   resolveBaseItem,
   resolveBaseItemOfType,
   vaultPathToSlug
-} from "../chunk-4LZJXJJS.js";
-import "../chunk-LV4SNWZQ.js";
+} from "../chunk-WXWPK3LI.js";
+import "../chunk-6X4KUDMU.js";
 export {
   resolveBaseItem,
   resolveBaseItemOfType,

package/dist/entities/slug.d.ts

@@ -10,3 +10,16 @@ export declare function slugify(name: string): string;
  *  `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;
+/** "[[SRD 2024/Classes/Fighter]]" to "fighter" (tail segment, slugified).
+ *
+ *  The tail 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). Only ever call this on a human NAME tail, never on a full `<prefix>_<name>` slug, which slugify
+ *  would destroy: `pc.decision-engine.ts`'s `resolveEntityRef` is the function that strips a `[[wikilink]]`
+ *  WITHOUT slugifying, and it is the one to use for a STORED slug.
+ *
+ *  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, so its three plugin importers and its own test
+ *  are untouched. */
+export declare function wikilinkTailSlug(link: string): string;

package/dist/entities/slug.js

@@ -1,8 +1,10 @@
 import {
   bareEntitySlug,
-  slugify
-} from "../chunk-LV4SNWZQ.js";
+  slugify,
+  wikilinkTailSlug
+} from "../chunk-6X4KUDMU.js";
 export {
   bareEntitySlug,
-  slugify
+  slugify,
+  wikilinkTailSlug
 };

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

@@ -0,0 +1,3 @@
+/** 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

@@ -0,0 +1,10 @@
+// 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
+};

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

@@ -0,0 +1,32 @@
+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 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

@@ -0,0 +1,14 @@
+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
+};

package/dist/feat/feat.codec.js

@@ -1,10 +1,12 @@
 import {
   featCodec
-} from "../chunk-73HOFQQ5.js";
-import "../chunk-XTIQWSFM.js";
-import "../chunk-Q5K6LWBZ.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+} from "../chunk-Y4AGLCY6.js";
+import "../chunk-KADJZGZY.js";
+import "../chunk-RVXC6ZHY.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-IWRVOCT5.js";
+import "../chunk-X3D6LXUU.js";
+import "../chunk-UA5KS2PL.js";
 export {
   featCodec
 };

package/dist/feat/feat.parser.js

@@ -1,9 +1,11 @@
 import {
   parseFeat
-} from "../chunk-XTIQWSFM.js";
-import "../chunk-Q5K6LWBZ.js";
-import "../chunk-NXSWH3AE.js";
-import "../chunk-NXR3BD2V.js";
+} from "../chunk-KADJZGZY.js";
+import "../chunk-RVXC6ZHY.js";
+import "../chunk-YLL2QXY2.js";
+import "../chunk-IWRVOCT5.js";
+import "../chunk-X3D6LXUU.js";
+import "../chunk-UA5KS2PL.js";
 export {
   parseFeat
 };