@bitcobblers/wod-wiki-lang 0.37.2137 → 0.37.2140

package/dist/index.cjs

@@ -418,15 +418,19 @@ function createPolicy() {
 }
 var metricPresentation = createPolicy();
 var EffortMetric = class {
-  constructor(effort) {
+  constructor(effort, options) {
     this.effort = effort;
-    this.value = effort;
+    this.value = options?.resolvedSlug ?? effort;
     this.image = effort;
+    if (options?.references) {
+      this.metadata = { [wodWikiCore.REFERENCE_METADATA_KEY]: options.references };
+    }
   }
   effort;
   value;
   image;
   origin = "parser";
+  metadata;
   type = wodWikiCore.MetricType.Effort;
 };
 var DistanceMetric = class {
@@ -1394,6 +1398,27 @@ var DurationMetric = class {
     return this.value > 0 ? "down" : "up";
   }
 };
+var EquipmentMetric = class {
+  type = wodWikiCore.MetricType.Equipment;
+  origin;
+  /** Canonical slugs, ordered and deduplicated. */
+  value;
+  image;
+  name = "equipment";
+  metadata;
+  constructor(slugs, options) {
+    this.value = [...new Set(slugs)];
+    this.image = options?.source ?? this.value.join(" ");
+    this.origin = options?.origin ?? "parser";
+    const reference = {
+      matched: options?.matched ?? "whole",
+      source: options?.source ?? this.image,
+      ...options?.refs ? { refs: options.refs } : {},
+      ...options?.diagnostics?.length ? { diagnostics: options.diagnostics } : {}
+    };
+    this.metadata = { [wodWikiCore.REFERENCE_METADATA_KEY]: reference };
+  }
+};
 var GroupMetric = class {
   constructor(group, image) {
     this.group = group;
@@ -1490,16 +1515,29 @@ var PROPERTY_KEY_TO_METRIC_TYPE = {
   volume: wodWikiCore.MetricType.Volume,
   work: wodWikiCore.MetricType.Work
 };
-function classifyStatements(facts) {
+var STRUCTURAL_EFFORT_WORDS = /* @__PURE__ */ new Set(["rest", "amrap", "emom", "tabata", "for time"]);
+var STANDARD_UNITS2 = UnitRegistry.standard();
+var REFERENCE_PAIR_KEYS = /* @__PURE__ */ new Set(["effort", "equipment"]);
+function referenceMetadata(resolution) {
+  return {
+    matched: resolution.matched,
+    source: resolution.label,
+    ...resolution.effortRef || resolution.equipment.length > 0 ? { refs: [...resolution.effortRef ? [resolution.effortRef] : [], ...resolution.equipment] } : {},
+    ...resolution.remaining ? { remaining: resolution.remaining } : {},
+    ...resolution.diagnostics.length > 0 ? { diagnostics: resolution.diagnostics } : {}
+  };
+}
+function classifyStatements(facts, references) {
   return facts.statements.map((fact) => {
     const statement = new wodWikiCore.ParsedCodeStatement();
-    const metricPairs = [];
+    let metricPairs = [];
     for (const primitive of fact.primitives) {
       metricPairs.push(...classifyPrimitive(primitive));
     }
     const mergedPairs = mergeFragments(metricPairs);
-    statement.metrics = mergedPairs.map((pair) => pair.metrics);
-    statement.metricMeta = new Map(mergedPairs.map((pair) => [pair.metrics, pair.meta]));
+    const finalPairs = references ? applyReferenceResolution(mergedPairs, fact, references) : mergedPairs;
+    statement.metrics = finalPairs.map((pair) => pair.metrics);
+    statement.metricMeta = new Map(finalPairs.map((pair) => [pair.metrics, pair.meta]));
     statement.id = fact.id;
     statement.line = fact.line;
     statement.text = fact.meta.raw;
@@ -1511,6 +1549,105 @@ function classifyStatements(facts) {
     return statement;
   });
 }
+function applyReferenceResolution(pairs, fact, references) {
+  const { index, defaults } = references;
+  const result = [];
+  const emitResolution = (resolution, authored, meta2) => {
+    if (resolution.effortRef || resolution.matched !== "none" || resolution.diagnostics.length > 0) {
+      result.push({
+        metrics: new EffortMetric(authored, {
+          resolvedSlug: resolution.effortRef?.slug,
+          references: referenceMetadata(resolution)
+        }),
+        meta: meta2
+      });
+    }
+    if (resolution.equipment.length > 0) {
+      result.push({
+        metrics: new EquipmentMetric(
+          resolution.equipment.map((ref) => ref.slug),
+          {
+            refs: resolution.equipment,
+            source: authored,
+            matched: resolution.matched,
+            diagnostics: resolution.diagnostics
+          }
+        ),
+        meta: meta2
+      });
+    }
+  };
+  const handledRawObjects = /* @__PURE__ */ new Set();
+  const malformedHints = [];
+  for (const primitive of fact.primitives) {
+    if (primitive.kind !== "metric_object") continue;
+    if (handledRawObjects.has(primitive.raw)) continue;
+    handledRawObjects.add(primitive.raw);
+    if (primitive.pairs.length === 0) {
+      malformedHints.push({
+        metrics: {
+          ...hintMetric("reference.malformed_json", "parser"),
+          metadata: referenceMetadata(index.resolve(primitive.raw))
+        },
+        meta: primitive.meta
+      });
+      continue;
+    }
+    const hasReferenceKeys = primitive.pairs.some((pair) => REFERENCE_PAIR_KEYS.has(pair.key.toLowerCase()));
+    if (!hasReferenceKeys) continue;
+    const resolution = index.resolve(primitive.raw);
+    if (resolution.matched === "explicit") {
+      emitResolution(resolution, primitive.raw, primitive.meta);
+    }
+    for (const pair of primitive.pairs) {
+      if (REFERENCE_PAIR_KEYS.has(pair.key.toLowerCase())) continue;
+      const metricType = PROPERTY_KEY_TO_METRIC_TYPE[pair.key.toLowerCase()] ?? wodWikiCore.MetricType.Custom;
+      const rawValue = Array.isArray(pair.value) ? pair.value.join(", ") : pair.value;
+      result.push({
+        metrics: new PropertyMetric(pair.key, rawValue, { type: metricType, image: `${pair.key}: ${rawValue}` }),
+        meta: primitive.meta
+      });
+    }
+  }
+  let sawEffortMetric = false;
+  let sawDurationMetric = false;
+  let sawMovementQuantity = false;
+  let statementMeta;
+  for (const pair of pairs) {
+    const metric = pair.metrics;
+    if (metric.type === wodWikiCore.MetricType.Custom && handledRawObjects.has(pair.meta.raw)) continue;
+    if (metric.type === wodWikiCore.MetricType.Effort) {
+      const authored = metric instanceof EffortMetric ? metric.effort : String(metric.value ?? "");
+      const normalized = authored.trim().toLowerCase();
+      if (STRUCTURAL_EFFORT_WORDS.has(normalized) || STANDARD_UNITS2.has(normalized)) {
+        result.push(pair);
+        continue;
+      }
+      sawEffortMetric = true;
+      const resolution = index.resolve(authored, defaults);
+      if (resolution.matched === "none" && resolution.diagnostics.length === 0) {
+        result.push(pair);
+        continue;
+      }
+      emitResolution(resolution, authored, pair.meta);
+      continue;
+    }
+    if (metric.type === wodWikiCore.MetricType.Duration) sawDurationMetric = true;
+    if (metric.type === wodWikiCore.MetricType.Rep || metric.type === wodWikiCore.MetricType.Rounds || metric.type === wodWikiCore.MetricType.Resistance || metric.type === wodWikiCore.MetricType.Distance) {
+      sawMovementQuantity = true;
+    }
+    result.push(pair);
+    statementMeta ??= pair.meta;
+  }
+  if (defaults && !sawEffortMetric && fact.isLeaf && sawMovementQuantity && !sawDurationMetric) {
+    const resolution = index.resolve("", defaults);
+    if (resolution.effortRef) {
+      emitResolution(resolution, resolution.effortRef.label, statementMeta ?? fact.meta);
+    }
+  }
+  result.push(...malformedHints);
+  return result;
+}
 function classifyPrimitive(primitive) {
   switch (primitive.kind) {
     case "lap":
@@ -1579,10 +1716,11 @@ function classifyPrimitive(primitive) {
       const pairs = primitive.pairs;
       return pairs.map((pair) => {
         const metricType = PROPERTY_KEY_TO_METRIC_TYPE[pair.key.toLowerCase()] ?? wodWikiCore.MetricType.Custom;
+        const rawValue = Array.isArray(pair.value) ? pair.value.join(", ") : pair.value;
         return {
-          metrics: new PropertyMetric(pair.key, pair.value, {
+          metrics: new PropertyMetric(pair.key, rawValue, {
             type: metricType,
-            image: `${pair.key}: ${pair.value}`
+            image: `${pair.key}: ${rawValue}`
           }),
           meta: primitive.meta
         };
@@ -1620,6 +1758,23 @@ function mergeFragments(pairs) {
         continue;
       }
     }
+    if (current.metrics instanceof RepMetric && next.metrics instanceof EffortMetric && /^(reps?)$/i.test(next.metrics.effort)) {
+      const gap = next.meta.startOffset - current.meta.endOffset;
+      if (gap <= 1) {
+        const mergedMeta = {
+          ...current.meta,
+          endOffset: next.meta.endOffset,
+          columnEnd: next.meta.columnEnd,
+          length: next.meta.endOffset - current.meta.startOffset,
+          raw: current.meta.raw + (gap === 1 ? " " : "") + next.meta.raw
+        };
+        current = {
+          metrics: current.metrics,
+          meta: mergedMeta
+        };
+        continue;
+      }
+    }
     if (current.metrics instanceof RepMetric && (next.metrics instanceof ResistanceMetric || next.metrics instanceof DistanceMetric)) {
       const gap = next.meta.startOffset - current.meta.endOffset;
       if (gap <= 1) {
@@ -1995,12 +2150,12 @@ function resolveSourceInput(sourceOrTree, treeArg) {
   }
   return { source: "" };
 }
-function extractStatementsRaw(sourceOrTree, treeArg) {
+function extractStatementsRaw(sourceOrTree, treeArg, references) {
   const { source, tree } = resolveSourceInput(sourceOrTree, treeArg);
   const facts = extractSyntaxFacts(source, tree);
-  return normalizeInlineRounds(classifyStatements(facts));
+  return normalizeInlineRounds(classifyStatements(facts, references));
 }
-function extractStatements(sourceOrTree, sportOrTree, sportArg) {
+function extractStatements(sourceOrTree, sportOrTree, sportArg, references) {
   let sport;
   let tree;
   if (typeof sportOrTree === "string") {
@@ -2011,7 +2166,7 @@ function extractStatements(sourceOrTree, sportOrTree, sportArg) {
   }
   const resolved = resolveSourceInput(sourceOrTree, tree);
   const facts = extractSyntaxFacts(resolved.source, resolved.tree);
-  const statements = classifyStatements(facts);
+  const statements = classifyStatements(facts, references);
   dialectStack.processAll(statements, sport);
   return normalizeInlineRounds(statements);
 }
@@ -2143,7 +2298,8 @@ function parseScript(inputText, options = {}) {
     const doc = inputText.endsWith("\n") ? inputText : inputText + "\n";
     const tree = parser.parse(doc);
     const sport = options.sport ?? options.dialect;
-    const statements = options.withoutDialects ? extractStatementsRaw(inputText, tree) : extractStatements(inputText, tree, sport);
+    const references = options.references ? { index: options.references, defaults: options.defaults } : void 0;
+    const statements = options.withoutDialects ? extractStatementsRaw(inputText, tree, references) : extractStatements(inputText, tree, sport, references);
     return new WhiteboardScript(inputText, statements, []);
   } catch (error) {
     const msg = error instanceof Error ? error.message : "Unknown parse error";
@@ -2153,6 +2309,10 @@ function parseScript(inputText, options = {}) {
 
 // src/parser/md-timer.ts
 var MdTimerRuntime = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
   /**
    * Parse WhiteboardScript source into a {@link WhiteboardScript}, running the
    * Dialect Stack on every statement.
@@ -2160,22 +2320,21 @@ var MdTimerRuntime = class {
    * @param sport - The block's `:sport` fence suffix (` ```log:climbing `).
    */
   read(inputText, sport) {
-    return parseScript(inputText, { sport });
+    return parseScript(inputText, { sport, ...this.config });
   }
   /**
    * Parse without running the Dialect Stack. Used by the parser test harness
    * which applies its own Dialect set. Production consumers should use {@link read}.
    */
   readWithoutDialects(inputText) {
-    return parseScript(inputText, { withoutDialects: true });
+    return parseScript(inputText, { withoutDialects: true, ...this.config });
   }
 };
 
 // src/parser/parserInstance.ts
-function createParser() {
-  return new MdTimerRuntime();
+function createParser(config) {
+  return new MdTimerRuntime(config);
 }
-var sharedParser = /* @__PURE__ */ createParser();
 var nextTagID = 0;
 var Tag = class _Tag {
   /**
@@ -2839,6 +2998,42 @@ function whiteboardScript() {
 
 // src/effort-registry/types.ts
 var EFFORT_REGISTRY_ORIGINS = ["bundled", "user"];
+var CATALOG_PRECEDENCE_RANK = {
+  core: 0,
+  community: 1,
+  imported: 2,
+  user: 3
+};
+function resolveSourceTier(sourceIdOrMetaKey, explicitTier) {
+  if (explicitTier) return explicitTier;
+  if (!sourceIdOrMetaKey) return "core";
+  if (sourceIdOrMetaKey === "user") return "user";
+  const id = sourceIdOrMetaKey.startsWith("seed:") ? sourceIdOrMetaKey.slice(5) : sourceIdOrMetaKey;
+  if (id === "core" || id === "efforts" || id === "equipment") return "core";
+  if (id === "community" || id.startsWith("community-") || id === "common") return "community";
+  return "imported";
+}
+function resolveSourceRank(sourceIdOrMetaKey, explicitTier) {
+  return CATALOG_PRECEDENCE_RANK[resolveSourceTier(sourceIdOrMetaKey, explicitTier)];
+}
+function resolveEntityTier(entity) {
+  if (entity.registrySource === "user") return "user";
+  return resolveSourceTier(entity.sourceId);
+}
+function resolveEntityRank(entity) {
+  return CATALOG_PRECEDENCE_RANK[resolveEntityTier(entity)];
+}
+function dedupeEntitiesByPrecedence(entities) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    const key = entity.slug.toLowerCase();
+    const prior = bySlug.get(key);
+    if (!prior || resolveEntityRank(entity) >= resolveEntityRank(prior)) {
+      bySlug.set(key, entity);
+    }
+  }
+  return Array.from(bySlug.values());
+}
 var INTENSITY_TIERS = ["low", "moderate", "high"];
 var DEFAULT_RESOLVER_OPTIONS = {
   defaultMet: 5,
@@ -2878,6 +3073,426 @@ function disciplineFactorFor(discipline) {
   const key = discipline.toLowerCase();
   return isEffortDiscipline(key) ? DISCIPLINE_FACTORS[key] : 1;
 }
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+var SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function unquote(value) {
+  return value.replace(
+    /^(['"])(.*)\1$/,
+    (_match, quote, inner) => quote === '"' ? inner.replace(
+      /\\(["\\nrt])/g,
+      (_all, c) => c === "n" ? "\n" : c === "r" ? "\r" : c === "t" ? "	" : c
+    ) : inner
+  );
+}
+function quoteYaml(val) {
+  if (!val) return '""';
+  if (/[:"'\n#{}[\],&*?|\-<>=%!@`]/.test(val) || val !== val.trim()) {
+    return `"${val.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}"`;
+  }
+  return val;
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(FRONTMATTER_RE);
+  if (!match) return { meta: {}, body: raw };
+  const lines = match[1].split(/\r?\n/);
+  const meta2 = {};
+  for (let i = 0; i < lines.length; i++) {
+    const keyMatch = lines[i].match(/^([A-Za-z][\w.-]*)\s*:(.*)$/);
+    if (!keyMatch) continue;
+    const key = keyMatch[1];
+    const rawVal = keyMatch[2].trim();
+    if (rawVal === "") {
+      const items = [];
+      while (i + 1 < lines.length) {
+        const itemMatch = lines[i + 1].match(/^\s+-\s+(.+)$/);
+        if (!itemMatch) break;
+        items.push(unquote(itemMatch[1].trim()));
+        i++;
+      }
+      meta2[key] = items.length > 0 ? items : "";
+    } else {
+      const wasQuoted = /^(['"])(.*)\1$/.test(rawVal);
+      const value = unquote(rawVal);
+      const num2 = Number(value);
+      meta2[key] = !wasQuoted && value !== "" && !isNaN(num2) ? num2 : value;
+    }
+  }
+  return { meta: meta2, body: raw.slice(match[0].length) };
+}
+function getScalar(meta2, key) {
+  const value = meta2[key];
+  return typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function getListStrict(meta2, key) {
+  const value = meta2[key];
+  if (value === void 0) return [];
+  if (typeof value === "string" && value === "[]") return [];
+  return Array.isArray(value) ? value : void 0;
+}
+function coerceNestedScalar(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw !== "" && !Number.isNaN(Number(raw))) return Number(raw);
+  return unquote(raw);
+}
+function readNestedSection(lines, key) {
+  const start = lines.findIndex((l) => new RegExp(`^${key}:\\s*$`).test(l));
+  if (start === -1) return void 0;
+  const result = {};
+  let subKey = null;
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\S/.test(line)) break;
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const m = trimmed.match(/^([\w.-]+):\s*(.*)$/);
+    if (!m) continue;
+    const [, k, rawVal] = m;
+    if (indent === 2) {
+      if (rawVal === "") {
+        subKey = k;
+        result[k] = {};
+      } else {
+        subKey = null;
+        result[k] = coerceNestedScalar(rawVal);
+      }
+    } else if (indent >= 4 && subKey !== null) {
+      result[subKey][k] = coerceNestedScalar(rawVal);
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseDiscipline(val) {
+  if (!val) return void 0;
+  const normalized = unquote(val.trim()).toLowerCase();
+  if (isEffortDiscipline(normalized)) return normalized;
+  console.warn(`[definition-markdown] unknown discipline '${val}' \u2014 expected one of the canonical values; treating as unset`);
+  return void 0;
+}
+function identityProblems(slug, label) {
+  const problems = [];
+  const slugText = slug === void 0 ? "" : String(slug);
+  if (!slugText) problems.push("Missing required field: slug");
+  else if (!SLUG_RE.test(slugText)) problems.push("Invalid slug: must be lowercase letters, numbers, and hyphens only");
+  if (label === void 0 || !String(label).trim()) problems.push("Missing required field: label");
+  return problems;
+}
+function stringListProblems(values, kind) {
+  const problems = [];
+  for (const value of values) {
+    if (!value.trim()) problems.push(`Invalid ${kind}: blank entries are not allowed`);
+    else if (kind === "equipment" && !SLUG_RE.test(value)) {
+      problems.push(`Invalid ${kind}: '${value}' must be a canonical slug (lowercase letters, numbers, hyphens)`);
+    }
+  }
+  const duplicate = values.find((v, i) => values.indexOf(v) !== i);
+  if (duplicate !== void 0) problems.push(`Invalid ${kind}: duplicate entry '${duplicate}'`);
+  return problems;
+}
+function metProblem(value) {
+  if (value === void 0) return "Missing required field: baseAttributes.met";
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return "Invalid baseAttributes.met: must be a positive number";
+  }
+  return null;
+}
+function parseEffortFile(raw) {
+  const blockMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!blockMatch) return null;
+  const innerLines = blockMatch[1].split(/\r?\n/);
+  const { meta: meta2, body } = parseFrontmatter(raw);
+  const type = getScalar(meta2, "type");
+  if (type !== void 0 && type !== "effort") return null;
+  const id = getScalar(meta2, "id");
+  const slug = getScalar(meta2, "slug");
+  const label = getScalar(meta2, "label");
+  const aliases = getListStrict(meta2, "aliases");
+  const equipment = getListStrict(meta2, "equipment");
+  if (aliases === void 0 || equipment === void 0) return null;
+  if (identityProblems(slug, label).length > 0) return null;
+  if (stringListProblems(aliases, "aliases").length > 0) return null;
+  if (equipment.length > 0 && stringListProblems(equipment, "equipment").length > 0) return null;
+  const baseAttrs = readNestedSection(innerLines, "baseAttributes") ?? {};
+  if (metProblem(baseAttrs.met) !== null) return null;
+  const met = baseAttrs.met;
+  const discipline = parseDiscipline(
+    typeof baseAttrs.discipline === "string" ? baseAttrs.discipline : void 0
+  );
+  const intensityTier = baseAttrs.intensityTier;
+  const disciplineFactor = typeof baseAttrs.disciplineFactor === "number" && Number.isFinite(baseAttrs.disciplineFactor) ? baseAttrs.disciplineFactor : void 0;
+  const hints = readNestedSection(innerLines, "hints");
+  const derivation = readNestedSection(innerLines, "derivation");
+  const trimmedBody = body.trim();
+  return {
+    id: String(id ?? ""),
+    slug: String(slug),
+    label: String(label),
+    aliases,
+    baseAttributes: {
+      met,
+      ...discipline ? { discipline } : {},
+      ...disciplineFactor !== void 0 ? { disciplineFactor } : {},
+      ...intensityTier ? { intensityTier } : {}
+    },
+    registrySource: "bundled",
+    ...equipment.length > 0 ? { equipment } : {},
+    ...trimmedBody ? { body: trimmedBody } : {},
+    ...hints ? { hints } : {},
+    ...derivation ? { derivation } : {}
+  };
+}
+function parseEquipmentFile(raw) {
+  const { meta: meta2, body } = parseFrontmatter(raw);
+  if (getScalar(meta2, "type") !== "equipment") return null;
+  const id = getScalar(meta2, "id");
+  const slug = getScalar(meta2, "slug");
+  const label = getScalar(meta2, "label");
+  const aliases = getListStrict(meta2, "aliases");
+  if (id === void 0 || aliases === void 0) return null;
+  if (identityProblems(slug, label).length > 0) return null;
+  if (stringListProblems(aliases, "aliases").length > 0) return null;
+  const trimmedBody = body.trim();
+  return {
+    id: String(id),
+    slug: String(slug),
+    label: String(label),
+    aliases,
+    registrySource: "bundled",
+    ...trimmedBody ? { body: trimmedBody } : {}
+  };
+}
+function createDefaultEffort() {
+  return {
+    id: `effort-user-${uuid.v7()}`,
+    slug: "",
+    label: "",
+    aliases: [],
+    baseAttributes: { met: 5 },
+    registrySource: "user"
+  };
+}
+function documentToEffort(doc, baseEffort) {
+  const errors = [];
+  const blockMatch = doc.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!blockMatch) {
+    errors.push("Missing YAML frontmatter delimiters (---)");
+    return { effort: baseEffort ?? createDefaultEffort(), errors };
+  }
+  const innerLines = blockMatch[1].split(/\r?\n/);
+  const { meta: meta2, body } = parseFrontmatter(doc);
+  const bodyText = body.replace(/^\r?\n+/, "") || void 0;
+  const id = getScalar(meta2, "id");
+  const slug = getScalar(meta2, "slug");
+  const label = getScalar(meta2, "label");
+  const registrySource = getScalar(meta2, "registrySource");
+  const createdAt = getScalar(meta2, "createdAt");
+  const updatedAt = getScalar(meta2, "updatedAt");
+  const aliases = getListStrict(meta2, "aliases");
+  const equipmentRaw = meta2["equipment"];
+  const equipment = getListStrict(meta2, "equipment");
+  if (aliases === void 0) {
+    errors.push("Invalid aliases: must be a list (`aliases:` followed by `- item` lines)");
+  }
+  if (equipment === void 0) {
+    errors.push("Invalid equipment: must be a list (`equipment:` followed by `- slug` lines)");
+  }
+  const baseAttrs = readNestedSection(innerLines, "baseAttributes") ?? {};
+  const baseAttributes = {};
+  const metRaw = baseAttrs.met;
+  if (metRaw === void 0) {
+    const fallbackMet = baseEffort?.baseAttributes.met;
+    const fallbackProblem = fallbackMet === void 0 ? null : metProblem(fallbackMet);
+    if (fallbackProblem) errors.push(fallbackProblem);
+    else if (fallbackMet !== void 0) baseAttributes.met = fallbackMet;
+    else errors.push("Missing required field: baseAttributes.met");
+  } else {
+    const problem = metProblem(metRaw);
+    if (problem) errors.push(problem);
+    else baseAttributes.met = Number(metRaw);
+  }
+  if (getScalar(meta2, "met") !== void 0) {
+    errors.push(
+      "Invalid met placement: 'met' must be nested under baseAttributes (missing baseAttributes.met)"
+    );
+  }
+  const discipline = parseDiscipline(
+    typeof baseAttrs.discipline === "string" ? baseAttrs.discipline : void 0
+  );
+  if (discipline) baseAttributes.discipline = discipline;
+  if (typeof baseAttrs.disciplineFactor === "number" && Number.isFinite(baseAttrs.disciplineFactor)) {
+    baseAttributes.disciplineFactor = baseAttrs.disciplineFactor;
+  }
+  if (baseAttrs.intensityTier) baseAttributes.intensityTier = baseAttrs.intensityTier;
+  const hints = readNestedSection(innerLines, "hints") ?? baseEffort?.hints;
+  const derivation = readNestedSection(innerLines, "derivation");
+  errors.push(...identityProblems(slug, label));
+  if (aliases !== void 0) errors.push(...stringListProblems(aliases, "aliases"));
+  if (equipment !== void 0 && equipment.length > 0) {
+    errors.push(...stringListProblems(equipment, "equipment"));
+  }
+  const resolvedEquipment = equipmentRaw !== void 0 ? equipment ?? [] : baseEffort?.equipment?.length ? baseEffort.equipment : void 0;
+  const effort = {
+    id: String(id ?? "") || baseEffort?.id || `effort-user-${uuid.v7()}`,
+    slug: String(slug ?? ""),
+    label: String(label ?? ""),
+    aliases: aliases ?? [],
+    baseAttributes,
+    registrySource: registrySource || baseEffort?.registrySource || "user",
+    ...resolvedEquipment ? { equipment: resolvedEquipment } : {},
+    ...createdAt ? { createdAt: String(createdAt) } : {},
+    ...updatedAt ? { updatedAt: String(updatedAt) } : {},
+    ...bodyText ? { body: bodyText } : {},
+    ...hints && Object.keys(hints).length > 0 ? { hints } : {},
+    ...derivation ? { derivation } : {}
+  };
+  return { effort, errors };
+}
+function effortToDocument(effort) {
+  const lines = ["---"];
+  lines.push(`id: ${effort.id}`);
+  lines.push(`slug: ${effort.slug}`);
+  lines.push(`label: ${quoteYaml(effort.label)}`);
+  if (effort.aliases.length > 0) {
+    lines.push("aliases:");
+    for (const alias of effort.aliases) {
+      lines.push(`  - ${quoteYaml(alias)}`);
+    }
+  } else {
+    lines.push("aliases: []");
+  }
+  lines.push("baseAttributes:");
+  lines.push(`  met: ${effort.baseAttributes.met}`);
+  if (effort.baseAttributes.discipline) {
+    lines.push(`  discipline: ${effort.baseAttributes.discipline}`);
+  }
+  if (effort.baseAttributes.disciplineFactor !== void 0) {
+    lines.push(`  disciplineFactor: ${effort.baseAttributes.disciplineFactor}`);
+  }
+  if (effort.baseAttributes.intensityTier) {
+    lines.push(`  intensityTier: ${effort.baseAttributes.intensityTier}`);
+  }
+  lines.push(`registrySource: ${effort.registrySource}`);
+  if (effort.equipment && effort.equipment.length > 0) {
+    lines.push("equipment:");
+    for (const slug of effort.equipment) {
+      lines.push(`  - ${quoteYaml(slug)}`);
+    }
+  }
+  if (effort.derivation) {
+    lines.push("derivation:");
+    if (effort.derivation.parentSlug) {
+      lines.push(`  parentSlug: ${effort.derivation.parentSlug}`);
+    }
+    if (effort.derivation.coefficients && Object.keys(effort.derivation.coefficients).length > 0) {
+      lines.push("  coefficients:");
+      for (const [k, v] of Object.entries(effort.derivation.coefficients)) {
+        lines.push(`    ${k}: ${v}`);
+      }
+    }
+    if (effort.derivation.hardOverrides && Object.keys(effort.derivation.hardOverrides).length > 0) {
+      lines.push("  hardOverrides:");
+      for (const [k, v] of Object.entries(effort.derivation.hardOverrides)) {
+        lines.push(`    ${k}: ${JSON.stringify(v)}`);
+      }
+    }
+  }
+  if (effort.createdAt) {
+    lines.push(`createdAt: ${effort.createdAt}`);
+  }
+  if (effort.updatedAt) {
+    lines.push(`updatedAt: ${effort.updatedAt}`);
+  }
+  if (effort.hints && Object.keys(effort.hints).length > 0) {
+    lines.push("hints:");
+    for (const [k, v] of Object.entries(effort.hints)) {
+      lines.push(`  ${k}: ${v !== null && typeof v === "object" ? JSON.stringify(v) : String(v)}`);
+    }
+  }
+  lines.push("---");
+  if (effort.body) {
+    lines.push("");
+    lines.push(effort.body);
+  }
+  return lines.join("\n");
+}
+function createDefaultEquipment() {
+  return {
+    id: `equipment-user-${uuid.v7()}`,
+    slug: "",
+    label: "",
+    aliases: [],
+    registrySource: "user"
+  };
+}
+function documentToEquipment(doc, baseEquipment) {
+  const errors = [];
+  const blockMatch = doc.match(FRONTMATTER_RE);
+  if (!blockMatch) {
+    errors.push("Missing YAML frontmatter delimiters (---)");
+    return { equipment: baseEquipment ?? createDefaultEquipment(), errors };
+  }
+  const { meta: meta2, body } = parseFrontmatter(doc);
+  const bodyText = body.replace(/^\r?\n+/, "") || void 0;
+  const type = getScalar(meta2, "type");
+  const id = getScalar(meta2, "id");
+  const slug = getScalar(meta2, "slug");
+  const label = getScalar(meta2, "label");
+  const registrySource = getScalar(meta2, "registrySource");
+  const createdAt = getScalar(meta2, "createdAt");
+  const updatedAt = getScalar(meta2, "updatedAt");
+  const aliases = getListStrict(meta2, "aliases");
+  if (type !== "equipment") errors.push("Missing or invalid discriminator: frontmatter must declare `type: equipment`");
+  if (!slug || !SLUG_RE.test(String(slug))) errors.push("Invalid slug: must be a canonical slug (lowercase letters, numbers, hyphens)");
+  if (!label) errors.push("Missing required field: label");
+  if (aliases === void 0) {
+    errors.push("Invalid aliases: must be a list (`aliases:` followed by `- item` lines)");
+  } else {
+    errors.push(...stringListProblems(aliases, "aliases"));
+  }
+  if (registrySource !== void 0 && registrySource !== "bundled" && registrySource !== "user") {
+    errors.push("Invalid registrySource: must be 'bundled' or 'user'");
+  }
+  const equipment = {
+    id: String(id ?? "") || baseEquipment?.id || `equipment-user-${uuid.v7()}`,
+    slug: String(slug ?? ""),
+    label: String(label ?? ""),
+    aliases: aliases ?? [],
+    registrySource: registrySource || baseEquipment?.registrySource || "user",
+    ...createdAt ? { createdAt: String(createdAt) } : {},
+    ...updatedAt ? { updatedAt: String(updatedAt) } : {},
+    ...bodyText ? { body: bodyText } : {}
+  };
+  return { equipment, errors };
+}
+function equipmentToDocument(equipment) {
+  const lines = ["---"];
+  lines.push("type: equipment");
+  lines.push(`id: ${equipment.id}`);
+  lines.push(`slug: ${equipment.slug}`);
+  lines.push(`label: ${quoteYaml(equipment.label)}`);
+  if (equipment.aliases.length > 0) {
+    lines.push("aliases:");
+    for (const alias of equipment.aliases) {
+      lines.push(`  - ${quoteYaml(alias)}`);
+    }
+  } else {
+    lines.push("aliases: []");
+  }
+  lines.push(`registrySource: ${equipment.registrySource}`);
+  if (equipment.createdAt) {
+    lines.push(`createdAt: ${equipment.createdAt}`);
+  }
+  if (equipment.updatedAt) {
+    lines.push(`updatedAt: ${equipment.updatedAt}`);
+  }
+  lines.push("---");
+  if (equipment.body) {
+    lines.push("");
+    lines.push(equipment.body);
+  }
+  return lines.join("\n");
+}
 
 // src/effort-registry/fuzzyMatch.ts
 function levenshteinDistance(a, b) {
@@ -3262,12 +3877,24 @@ var CompositeEffortRegistry = class {
    * Initialize the registry:
    * 1. Load bundled efforts into memory
    * 2. Load user efforts from storage adapter into memory
+   *
+   * An explicit `customBundled` REPLACES the bundled tier — passing an empty
+   * set clears it — so a seed source removal never leaves stale bundled
+   * efforts cached. The no-argument call keeps the constructor/default set.
+   * Both tiers rebuild only AFTER a successful adapter load: a failed load
+   * propagates (readiness must never report over stale data), and deleted
+   * custom rows disappear because the user map is cleared too.
    */
   async loadBundled(customBundled) {
-    const seed = customBundled ?? this.initialBundled ?? bundledEfforts;
-    for (const effort of seed) {
-      this.bundledEfforts.set(effort.slug, effort);
+    this.bundledEfforts.clear();
+    const source = customBundled ?? this.initialBundled ?? bundledEfforts;
+    for (const effort of source) {
+      const prior = this.bundledEfforts.get(effort.slug);
+      if (!prior || resolveEntityRank(effort) >= resolveEntityRank(prior)) {
+        this.bundledEfforts.set(effort.slug, effort);
+      }
     }
+    this.userEfforts.clear();
     if (this.storage) {
       try {
         const userEfforts = await this.storage.load();
@@ -3297,8 +3924,8 @@ var CompositeEffortRegistry = class {
         if (normalizeForFuzzy(alias) === normalized) return effort;
       }
     }
-    for (const effort of this.bundledEfforts.values()) {
-      if (this.userEfforts.has(effort.slug)) continue;
+    const bundled = Array.from(this.bundledEfforts.values()).filter((effort) => !this.userEfforts.has(effort.slug)).sort((a, b) => resolveEntityRank(b) - resolveEntityRank(a));
+    for (const effort of bundled) {
       if (normalizeForFuzzy(effort.label) === normalized) return effort;
       for (const alias of effort.aliases) {
         if (normalizeForFuzzy(alias) === normalized) return effort;
@@ -3397,6 +4024,367 @@ async function addAliasToEffort(registry, targetSlug, newAlias) {
   await registry.upsert(updatedUserEffort);
   return updatedUserEffort;
 }
+function buildExactIndex(entities) {
+  const deduped = dedupeEntitiesByPrecedence(entities);
+  const byKey = /* @__PURE__ */ new Map();
+  const add = (key, entity) => {
+    if (!key) return;
+    const existing = byKey.get(key);
+    if (existing) {
+      if (!existing.includes(entity)) existing.push(entity);
+    } else {
+      byKey.set(key, [entity]);
+    }
+  };
+  for (const entity of deduped) {
+    add(entity.slug.toLowerCase(), entity);
+    add(normalizeForFuzzy(entity.label), entity);
+    for (const alias of entity.aliases) add(normalizeForFuzzy(alias), entity);
+  }
+  return {
+    byKey,
+    lookup(key) {
+      const direct = byKey.get(key) ?? byKey.get(normalizeForFuzzy(key));
+      if (!direct || direct.length === 0) return { entity: null, ambiguous: [] };
+      if (direct.length === 1) return { entity: direct[0], ambiguous: [] };
+      let maxRank = -1;
+      for (const candidate of direct) {
+        const rank = resolveEntityRank(candidate);
+        if (rank > maxRank) maxRank = rank;
+      }
+      const topTier = direct.filter((candidate) => resolveEntityRank(candidate) === maxRank);
+      if (topTier.length === 1) return { entity: topTier[0], ambiguous: [] };
+      return { entity: null, ambiguous: topTier };
+    }
+  };
+}
+function equipmentRef(entity) {
+  return { kind: "equipment", slug: entity.slug, label: entity.label };
+}
+function dedupeRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const ref of refs) {
+    const key = `${ref.kind}:${ref.slug}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(ref);
+  }
+  return result;
+}
+function createReferenceIndex(catalog, materialize) {
+  const dedupedEquipment = dedupeEntitiesByPrecedence(catalog.equipment ?? []);
+  const efforts = buildExactIndex(catalog.efforts ?? []);
+  const equipment = buildExactIndex(dedupedEquipment);
+  const prefixCandidates = dedupedEquipment.flatMap((entity) => [entity.label, ...entity.aliases].filter((name2) => !!name2 && !!name2.trim()).map((name2) => ({ lower: name2.trim().toLowerCase(), entity }))).sort((a, b) => b.lower.length - a.lower.length);
+  const materializer = materialize ?? ((effort) => ({
+    effort,
+    definition: effort,
+    slug: effort.slug,
+    label: effort.label,
+    met: effort.baseAttributes.met,
+    baseAttributes: effort.baseAttributes,
+    discipline: effort.baseAttributes.discipline,
+    disciplineFactor: effort.baseAttributes.disciplineFactor ?? 1,
+    intensityTier: effort.baseAttributes.intensityTier,
+    modifiers: {},
+    registrySource: effort.registrySource,
+    resolvedFrom: effort.registrySource === "user" ? "user" : effort.registrySource === "bundled" ? "bundled" : "default",
+    isEstimated: false
+  }));
+  const resolveEffortExact = (key) => {
+    const found = efforts.lookup(key.trim());
+    if (found.entity) return { entity: found.entity };
+    if (found.ambiguous.length > 0) {
+      return {
+        entity: null,
+        diagnostic: {
+          reason: "ambiguous-effort",
+          message: `"${key}" matches multiple efforts.`,
+          token: key,
+          candidates: found.ambiguous.map((e) => e.slug)
+        }
+      };
+    }
+    return {
+      entity: null,
+      diagnostic: { reason: "unknown-effort", message: `Unknown effort "${key}".`, token: key }
+    };
+  };
+  const resolveEquipmentValues = (values) => {
+    const refs = [];
+    const diagnostics = [];
+    for (const value of values) {
+      if (typeof value !== "string" || !value.trim()) {
+        diagnostics.push({
+          reason: "invalid-explicit",
+          message: `Equipment reference must be a slug string, got ${JSON.stringify(value) ?? "null"}.`,
+          token: String(value)
+        });
+        continue;
+      }
+      const found = equipment.lookup(value.trim());
+      if (found.entity) {
+        refs.push(equipmentRef(found.entity));
+      } else if (found.ambiguous.length > 0) {
+        diagnostics.push({
+          reason: "ambiguous-equipment",
+          message: `"${value}" matches multiple equipment entries.`,
+          token: value,
+          candidates: found.ambiguous.map((e) => e.slug)
+        });
+      } else {
+        diagnostics.push({
+          reason: "invalid-explicit",
+          message: `Unknown equipment "${value}".`,
+          token: value
+        });
+      }
+    }
+    return { refs: dedupeRefs(refs), diagnostics };
+  };
+  const index = {
+    resolveEffort(slugOrAlias) {
+      return efforts.lookup(slugOrAlias).entity;
+    },
+    resolveEquipment(slugOrAlias) {
+      return equipment.lookup(slugOrAlias).entity;
+    },
+    materialize(effort) {
+      return materializer(effort);
+    },
+    resolve(label, defaults) {
+      const source = (label ?? "").trim();
+      const diagnostics = [];
+      const push = (diagnostic) => {
+        if (diagnostic) diagnostics.push(diagnostic);
+      };
+      let matched = "none";
+      let effortEntity = null;
+      let remaining = "";
+      let equipmentRefs = [];
+      let equipmentAuthored = false;
+      const fillEquipment = () => {
+        if (equipmentRefs.length > 0 || equipmentAuthored) return;
+        if (effortEntity === null) return;
+        if (defaults?.equipment?.length) {
+          const resolvedDefaults = resolveEquipmentValues(defaults.equipment);
+          equipmentRefs = resolvedDefaults.refs;
+          for (const diagnostic of resolvedDefaults.diagnostics) {
+            push({ ...diagnostic, reason: "unknown-equipment" });
+          }
+          if (equipmentRefs.length > 0) return;
+        }
+        if (effortEntity.equipment?.length) {
+          const resolvedDefEquipment = resolveEquipmentValues(effortEntity.equipment);
+          equipmentRefs = resolvedDefEquipment.refs;
+          for (const diagnostic of resolvedDefEquipment.diagnostics) {
+            push({ ...diagnostic, reason: "unknown-equipment" });
+          }
+        }
+      };
+      if (!source) {
+        if (defaults?.effort) {
+          const found = resolveEffortExact(defaults.effort);
+          if (found.entity) {
+            effortEntity = found.entity;
+            matched = "default";
+          } else {
+            push({
+              reason: found.diagnostic?.reason === "ambiguous-effort" ? "ambiguous-effort" : "unknown-effort",
+              message: `Default effort "${defaults.effort}" is not in the catalog.`,
+              token: defaults.effort,
+              candidates: found.diagnostic?.candidates
+            });
+          }
+        }
+        fillEquipment();
+        return {
+          matched,
+          label: source,
+          effort: effortEntity ? materializer(effortEntity) : null,
+          effortRef: effortEntity ? { kind: "effort", slug: effortEntity.slug, label: effortEntity.label } : null,
+          equipment: equipmentRefs,
+          remaining: "",
+          diagnostics
+        };
+      }
+      if (source.startsWith("{")) {
+        let parsed;
+        try {
+          parsed = JSON.parse(source);
+        } catch {
+          return {
+            matched: "none",
+            label: source,
+            effort: null,
+            effortRef: null,
+            equipment: [],
+            remaining: "",
+            diagnostics: [{
+              reason: "malformed-json",
+              message: "Reference object is not valid JSON.",
+              token: source
+            }]
+          };
+        }
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && ("effort" in parsed || "equipment" in parsed)) {
+          matched = "explicit";
+          const obj = parsed;
+          if (obj.effort !== void 0) {
+            if (typeof obj.effort === "string" && obj.effort.trim()) {
+              const found = resolveEffortExact(obj.effort);
+              effortEntity = found.entity;
+              if (found.diagnostic) {
+                push(found.diagnostic.reason === "ambiguous-effort" ? found.diagnostic : { ...found.diagnostic, reason: "invalid-explicit", message: `Explicit effort "${obj.effort}" is not in the catalog.` });
+              }
+            } else {
+              push({
+                reason: "invalid-explicit",
+                message: 'Explicit "effort" must be a slug string.',
+                token: String(obj.effort)
+              });
+            }
+          }
+          if (obj.equipment !== void 0) {
+            equipmentAuthored = true;
+            const values = Array.isArray(obj.equipment) ? obj.equipment : [obj.equipment];
+            const resolvedEquipment = resolveEquipmentValues(values);
+            equipmentRefs = resolvedEquipment.refs;
+            diagnostics.push(...resolvedEquipment.diagnostics);
+            if (effortEntity?.equipment?.length) {
+              const definitionSlugs = new Set(effortEntity.equipment);
+              const authoredSlugs = equipmentRefs.map((ref) => ref.slug);
+              if (authoredSlugs.length > 0 && authoredSlugs.some((slug) => !definitionSlugs.has(slug))) {
+                push({
+                  reason: "conflict",
+                  message: `Explicit equipment [${authoredSlugs.join(", ")}] contradicts effort "${effortEntity.slug}" definition equipment [${effortEntity.equipment.join(", ")}].`,
+                  token: source
+                });
+              }
+            }
+          }
+          fillEquipment();
+          return {
+            matched,
+            label: source,
+            effort: effortEntity ? materializer(effortEntity) : null,
+            effortRef: effortEntity ? { kind: "effort", slug: effortEntity.slug, label: effortEntity.label } : null,
+            equipment: equipmentRefs,
+            remaining: "",
+            diagnostics
+          };
+        }
+      }
+      const lowerSource = source.toLowerCase();
+      for (const candidate of prefixCandidates) {
+        if (!lowerSource.startsWith(candidate.lower)) continue;
+        const after = source.slice(candidate.lower.length);
+        if (after && !/^\s/.test(after)) continue;
+        const candidateRemaining = after.trim();
+        if (!candidateRemaining) continue;
+        const equipmentFound = equipment.lookup(candidate.lower);
+        if (equipmentFound.ambiguous.length > 0) {
+          push({
+            reason: "ambiguous-equipment",
+            message: `"${candidate.lower}" matches multiple equipment entries.`,
+            token: source,
+            candidates: equipmentFound.ambiguous.map((e) => e.slug)
+          });
+          return {
+            matched: "none",
+            label: source,
+            effort: null,
+            effortRef: null,
+            equipment: [],
+            remaining: "",
+            diagnostics
+          };
+        }
+        if (!equipmentFound.entity) continue;
+        const effortFound = resolveEffortExact(candidateRemaining);
+        if (effortFound.entity) {
+          matched = "split";
+          effortEntity = effortFound.entity;
+          equipmentRefs = [equipmentRef(equipmentFound.entity)];
+          equipmentAuthored = true;
+          remaining = candidateRemaining;
+          break;
+        }
+        if (effortFound.diagnostic?.reason === "ambiguous-effort") {
+          push(effortFound.diagnostic);
+          return {
+            matched: "none",
+            label: source,
+            effort: null,
+            effortRef: null,
+            equipment: [],
+            remaining: "",
+            diagnostics
+          };
+        }
+      }
+      if (matched === "none") {
+        const found = resolveEffortExact(source);
+        if (found.entity) {
+          effortEntity = found.entity;
+          matched = "whole";
+        } else if (found.diagnostic?.reason === "ambiguous-effort") {
+          push(found.diagnostic);
+          return {
+            matched: "none",
+            label: source,
+            effort: null,
+            effortRef: null,
+            equipment: [],
+            remaining: "",
+            diagnostics
+          };
+        } else if (found.diagnostic) {
+          push(found.diagnostic);
+        }
+      }
+      fillEquipment();
+      return {
+        matched,
+        label: source,
+        effort: effortEntity ? materializer(effortEntity) : null,
+        effortRef: effortEntity ? { kind: "effort", slug: effortEntity.slug, label: effortEntity.label } : null,
+        equipment: equipmentRefs,
+        remaining,
+        diagnostics
+      };
+    }
+  };
+  return index;
+}
+function extractStatementRefs(statements) {
+  const efforts = [];
+  const equipment = [];
+  const seenEffort = /* @__PURE__ */ new Set();
+  const seenEquipment = /* @__PURE__ */ new Set();
+  const pushUnique = (list, seen, value) => {
+    if (!value) return;
+    if (seen.has(value)) return;
+    seen.add(value);
+    list.push(value);
+  };
+  for (const statement of statements ?? []) {
+    const metrics = Array.isArray(statement.metrics) ? statement.metrics : statement.metrics?.toArray?.() ?? [];
+    for (const metric of metrics) {
+      const refs = wodWikiCore.getReferenceMetadata(metric.metadata)?.refs;
+      if (!refs) continue;
+      for (const ref of refs) {
+        if (ref.kind === "effort") pushUnique(efforts, seenEffort, ref.slug);
+        if (ref.kind === "equipment") pushUnique(equipment, seenEquipment, ref.slug);
+      }
+    }
+  }
+  return { efforts, equipment };
+}
+function slugifyRefLabel(label) {
+  return normalizeForFuzzy(label).replace(/\s+/g, "-");
+}
 
 // src/runtime/contracts/IRuntimeOptions.ts
 var DEFAULT_RUNTIME_OPTIONS = {
@@ -6735,14 +7723,12 @@ function resolveDominantOrigin(origins) {
   if (origins.every((o) => o === "compiler")) return "compiler";
   return "analyzed";
 }
-
-// src/runtime/compiler/EffortEnrichmentPass.ts
 var logTrace = (message) => console.log(message);
 function applyEffortEnrichment(block, options) {
-  const { resolver, overwrite = false, debug = false } = options;
-  tryEnrichBlock(block, resolver, overwrite, debug);
+  const { resolver, references, overwrite = false, debug = false } = options;
+  tryEnrichBlock(block, resolver, references, overwrite, debug);
 }
-function tryEnrichBlock(block, resolver, overwrite, debug) {
+function tryEnrichBlock(block, resolver, references, overwrite, debug) {
   const normalizedBlockType = block.blockType?.toLowerCase();
   if (normalizedBlockType !== "effort" && normalizedBlockType !== "exercise") {
     return;
@@ -6760,7 +7746,32 @@ function tryEnrichBlock(block, resolver, overwrite, debug) {
     return;
   }
   try {
-    const resolved = resolver.resolveEffort(label);
+    let resolved;
+    let matchedKind = "none";
+    let equipmentRefs = [];
+    let diagnostics = [];
+    if (references) {
+      const resolution = references.resolve(label);
+      resolved = resolution.effort ?? void 0;
+      matchedKind = resolution.matched;
+      equipmentRefs = resolution.equipment;
+      diagnostics = resolution.diagnostics;
+    } else {
+      resolved = resolver.resolveEffort(label);
+    }
+    if (!resolved) {
+      if (diagnostics.length > 0) {
+        block.pushMemory(new MemoryLocation("metric:tracked", [{
+          type: wodWikiCore.MetricType.Hint,
+          value: "reference.unresolved",
+          image: label,
+          origin: "compiler",
+          metadata: { [wodWikiCore.REFERENCE_METADATA_KEY]: { matched: "none", source: label, diagnostics } }
+        }]));
+      }
+      if (debug) logTrace(`[EffortEnrichment] Unresolved effort: ${label}`);
+      return;
+    }
     const effortHints = resolved.effort.hints;
     if (effortHints && Object.keys(effortHints).length > 0) {
       block.mergeHints(effortHints);
@@ -6773,7 +7784,8 @@ function tryEnrichBlock(block, resolver, overwrite, debug) {
       image: resolved.label,
       value: resolved,
       origin: "compiler",
-      timestamp: /* @__PURE__ */ new Date()
+      timestamp: /* @__PURE__ */ new Date(),
+      ...equipmentRefs.length > 0 || diagnostics.length > 0 ? { metadata: { [wodWikiCore.REFERENCE_METADATA_KEY]: { matched: matchedKind, source: label, refs: [{ kind: "effort", slug: resolved.slug, label: resolved.label }, ...equipmentRefs], ...diagnostics.length > 0 ? { diagnostics } : {} } } } : {}
     };
     const privateMetrics = block.getMetricMemoryByVisibility("private");
     const existingLoc = privateMetrics.find(
@@ -6788,10 +7800,31 @@ function tryEnrichBlock(block, resolver, overwrite, debug) {
       const location = new MemoryLocation("metric:tracked", [effortDataMetric]);
       block.pushMemory(location);
     }
+    if (equipmentRefs.length > 0) {
+      pushPrivateMetrics(block, wodWikiCore.MetricType.Equipment, [
+        new EquipmentMetric(equipmentRefs.map((ref) => ref.slug), {
+          refs: equipmentRefs,
+          source: label,
+          origin: "compiler"
+        })
+      ], wodWikiCore.MetricType.Equipment, overwrite);
+    }
   } catch (err) {
     console.error(`[EffortEnrichment] Failed to resolve effort "${label}":`, err);
   }
 }
+function pushPrivateMetrics(block, markerType, metrics, replaceType, overwrite) {
+  const privateMetrics = block.getMetricMemoryByVisibility("private");
+  const existingLoc = privateMetrics.find(
+    (loc) => loc.metrics.toArray().some((m) => m.type === markerType)
+  );
+  if (existingLoc && overwrite) {
+    const filtered = existingLoc.metrics.toArray().filter((m) => m.type !== replaceType);
+    existingLoc.update([...filtered, ...metrics]);
+  } else if (!existingLoc) {
+    block.pushMemory(new MemoryLocation("metric:tracked", metrics));
+  }
+}
 
 // src/runtime/actions/stack/CompileAndPushBlockAction.ts
 var CompileAndPushBlockAction = class {
@@ -6817,7 +7850,8 @@ var CompileAndPushBlockAction = class {
       }
       if (runtime.analyticsContext?.effortResolver) {
         applyEffortEnrichment(compiledBlock, {
-          resolver: runtime.analyticsContext.effortResolver
+          resolver: runtime.analyticsContext.effortResolver,
+          references: runtime.analyticsContext.references
         });
       }
       return [new PushBlockAction(compiledBlock, this.options)];
@@ -10843,7 +11877,8 @@ function createAnalyticsEngineForBlock(block, options) {
     effortResolver = new EffortResolver(registry);
   }
   const analyticsContext = {
-    effortResolver
+    effortResolver,
+    ...options?.references ? { references: options.references } : {}
   };
   const context = {
     dialect,
@@ -13756,6 +14791,7 @@ exports.BehaviorContext = BehaviorContext;
 exports.BlockBuilder = BlockBuilder;
 exports.BlockContext = BlockContext;
 exports.ButtonBehavior = ButtonBehavior;
+exports.CATALOG_PRECEDENCE_RANK = CATALOG_PRECEDENCE_RANK;
 exports.CONSUMED_HINTS = CONSUMED_HINTS;
 exports.CONSUMED_HINT_KEYS = CONSUMED_HINT_KEYS;
 exports.CONTEXT_ATOMS = CONTEXT_ATOMS;
@@ -13914,18 +14950,25 @@ exports.createMetricPresentationPolicy = createPolicy;
 exports.createMockClock = createMockClock;
 exports.createParser = createParser;
 exports.createProfileTable = createProfileTable;
+exports.createReferenceIndex = createReferenceIndex;
 exports.createRpeLabelsTable = createRpeLabelsTable;
 exports.dailySessionLoads = dailySessionLoads;
 exports.dayBucket = dayBucket;
+exports.dedupeEntitiesByPrecedence = dedupeEntitiesByPrecedence;
 exports.dialectRegistry = dialectRegistry;
 exports.dialectStack = dialectStack;
 exports.diffStatement = diffStatement;
 exports.dimEquals = dimEquals;
 exports.disciplineFactorFor = disciplineFactorFor;
+exports.documentToEffort = documentToEffort;
+exports.documentToEquipment = documentToEquipment;
+exports.effortToDocument = effortToDocument;
+exports.equipmentToDocument = equipmentToDocument;
 exports.evaluate = evaluate;
 exports.evaluateCalculateDefinitions = evaluateCalculateDefinitions;
 exports.extractEffortData = extractEffortData;
 exports.extractMetrics = extractMetrics;
+exports.extractStatementRefs = extractStatementRefs;
 exports.extractStatements = extractStatements;
 exports.extractStatementsRaw = extractStatementsRaw;
 exports.extractSyntaxFacts = extractSyntaxFacts;
@@ -13973,15 +15016,22 @@ exports.outputNodeId = outputNodeId;
 exports.outputNodeIds = outputNodeIds;
 exports.parseCalcLine = parseCalcLine;
 exports.parseCalculateBlock = parseCalculateBlock;
+exports.parseEffortFile = parseEffortFile;
+exports.parseEquipmentFile = parseEquipmentFile;
 exports.parseExpression = parseExpression;
 exports.parseMetricLine = parseMetricLine;
 exports.parseScript = parseScript;
 exports.printCalculation = printCalculation;
+exports.readNestedSection = readNestedSection;
 exports.readTimer = readTimer;
 exports.realtimeProcessorRegistry = realtimeProcessorRegistry;
 exports.renderMetric = renderMetric;
 exports.resolveDominantOrigin = resolveDominantOrigin;
-exports.sharedParser = sharedParser;
+exports.resolveEntityRank = resolveEntityRank;
+exports.resolveEntityTier = resolveEntityTier;
+exports.resolveSourceRank = resolveSourceRank;
+exports.resolveSourceTier = resolveSourceTier;
+exports.slugifyRefLabel = slugifyRefLabel;
 exports.startSpan = startSpan;
 exports.str = str;
 exports.strategyRegistry = strategyRegistry;