@bitcobblers/wod-wiki-lang 0.37.2137 → 0.37.2140

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { wallClockNow, formatDurationSmart } from './chunk-PFQDVQQO.mjs';
 export { createBrowserRuntimeNow, frozenNow, getRuntimeNowMs, wallClockNow } from './chunk-PFQDVQQO.mjs';
-import { MetricType, MetricContainer, BlockKey, ParsedCodeStatement, OutputStatement, valueKindOf, normalizeFieldPath } from '@bitcobblers/wod-wiki-core';
+import { MetricType, MetricContainer, BlockKey, REFERENCE_METADATA_KEY, ParsedCodeStatement, getReferenceMetadata, OutputStatement, valueKindOf, normalizeFieldPath } from '@bitcobblers/wod-wiki-core';
 import { LRParser } from '@lezer/lr';
 import { LRLanguage, LanguageSupport } from '@codemirror/language';
 import { NodeProp } from '@lezer/common';
@@ -378,15 +378,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 = { [REFERENCE_METADATA_KEY]: options.references };
+    }
   }
   effort;
   value;
   image;
   origin = "parser";
+  metadata;
   type = MetricType.Effort;
 };
 var DistanceMetric = class {
@@ -1354,6 +1358,27 @@ var DurationMetric = class {
     return this.value > 0 ? "down" : "up";
   }
 };
+var EquipmentMetric = class {
+  type = 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 = { [REFERENCE_METADATA_KEY]: reference };
+  }
+};
 var GroupMetric = class {
   constructor(group, image) {
     this.group = group;
@@ -1450,16 +1475,29 @@ var PROPERTY_KEY_TO_METRIC_TYPE = {
   volume: MetricType.Volume,
   work: 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 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;
@@ -1471,6 +1509,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()] ?? 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 === MetricType.Custom && handledRawObjects.has(pair.meta.raw)) continue;
+    if (metric.type === 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 === MetricType.Duration) sawDurationMetric = true;
+    if (metric.type === MetricType.Rep || metric.type === MetricType.Rounds || metric.type === MetricType.Resistance || metric.type === 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":
@@ -1539,10 +1676,11 @@ function classifyPrimitive(primitive) {
       const pairs = primitive.pairs;
       return pairs.map((pair) => {
         const metricType = PROPERTY_KEY_TO_METRIC_TYPE[pair.key.toLowerCase()] ?? 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
         };
@@ -1580,6 +1718,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) {
@@ -1955,12 +2110,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") {
@@ -1971,7 +2126,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);
 }
@@ -2103,7 +2258,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";
@@ -2113,6 +2269,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.
@@ -2120,22 +2280,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 {
   /**
@@ -2799,6 +2958,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,
@@ -2838,6 +3033,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-${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-${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-${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-${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) {
@@ -3222,12 +3837,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();
@@ -3257,8 +3884,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;
@@ -3357,6 +3984,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 = 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 = {
@@ -6663,14 +7651,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;
@@ -6688,7 +7674,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: MetricType.Hint,
+          value: "reference.unresolved",
+          image: label,
+          origin: "compiler",
+          metadata: { [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);
@@ -6701,7 +7712,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: { [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(
@@ -6716,10 +7728,31 @@ function tryEnrichBlock(block, resolver, overwrite, debug) {
       const location = new MemoryLocation("metric:tracked", [effortDataMetric]);
       block.pushMemory(location);
     }
+    if (equipmentRefs.length > 0) {
+      pushPrivateMetrics(block, MetricType.Equipment, [
+        new EquipmentMetric(equipmentRefs.map((ref) => ref.slug), {
+          refs: equipmentRefs,
+          source: label,
+          origin: "compiler"
+        })
+      ], 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 {
@@ -6745,7 +7778,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)];
@@ -10771,7 +11805,8 @@ function createAnalyticsEngineForBlock(block, options) {
     effortResolver = new EffortResolver(registry);
   }
   const analyticsContext = {
-    effortResolver
+    effortResolver,
+    ...options?.references ? { references: options.references } : {}
   };
   const context = {
     dialect,
@@ -13671,6 +14706,6 @@ function compareStatement(expectations, actual, mode) {
   return diffs;
 }
 
-export { ABSENT, AGGREGATE_BUILTINS, AUTHORITATIVE_CASTS, AbortSessionAction, AmrapLogicStrategy, AnalyticsEngine, AnalyticsTransformer, BUILTIN_CALCS, BUNDLED_EFFORT_COUNT, BehaviorContext, BlockBuilder, BlockContext, ButtonBehavior, CONSUMED_HINTS, CONSUMED_HINT_KEYS, CONTEXT_ATOMS, CalcEngine, CalcEvalError, CalcParseError, CalcRegistrationError, CalcUnitError, CalculateBlockProcessor, CalculationRegistry, CardioDialect, ChildSelectionBehavior, ChildrenStrategy, ChoiceGroupMetric, ClearChildrenAction, ClimbDialect, ClimbMetricType, CompileAndPushBlockAction, CompletionTimestampBehavior, CompositeEffortRegistry, CountdownTimerBehavior, CountupTimerBehavior, CrossFitDialect, DAY, DEFAULT_RESOLVER_OPTIONS, DEFAULT_RUNTIME_OPTIONS, DEFAULT_UNRESOLVED_EFFORT_MET, DIM_COUNT, DIM_ENERGY, DIM_LENGTH, DIM_MASS, DIM_TIME, DIM_ZERO, DISCIPLINE_FACTORS, DialectStack, EFFORT_DATA_METRIC_TYPE, EFFORT_DISCIPLINES, EFFORT_REGISTRY_ORIGINS, EffortBlock, EffortFallbackStrategy, EffortResolver, EmitEventAction, EmitSystemOutputAction, ErrorAction, EventBus, ExecutionContext, ExitBehavior, FixtureSyntaxError, GenericGroupStrategy, GenericLoopStrategy, GenericTimerStrategy, HabitsDialect, INTENSITY_TIERS, InMemoryEffortRegistry, IntervalLogicStrategy, JitCompiler, LabelingBehavior, LocalEventProvider, LocalRuntimeSubscription, LookupRegistry, MdTimerRuntime, MemoryLocation, MemoryTypeEnum, MetricPromotionBehavior, NAMED_COMPOUNDS, NextAction, NextEvent, NextEventHandler, OutputEmitter, PREDEFINED_SOUNDS, PRODUCTION_STRATEGIES, PlaySoundAction, PopBlockAction, PushBlockAction, PushRestBlockAction, REST_EXCLUSION, RPE_LABELS, RegisterEventHandlerAction, Registry, ReportOutputBehavior, ReportOutputStrategy, RestBlock, RoundsMetric, RuntimeAdapter, RuntimeBlock, RuntimeBuilder, RuntimeClock, RuntimeFactory, RuntimeLogger, RuntimeMemory, RuntimeObservers, RuntimeStack, STANDARD_UNITS, STORE_CALCS, STREAM_ATOMS, ScriptRuntime, SessionRootBlock, SessionRootStrategy, SnapshotClock, SoundCueBehavior, SoundStrategy, SpanTrackingBehavior, StandardAnalyticsProfile, StartSessionAction, StartWorkoutAction, SubscriptionManager, ThrowError, ThrowErrorAction, TimeSpan, TwoPassEffortResolutionProcess, TypedMemoryReference, UNITS, UnitRegistry, UnitSet, UnitsDialect, UnregisterEventHandlerAction, UpdateNextPreviewAction, VISIBILITY_ICONS, VISIBILITY_LABELS, WaitingToStartBlock, WaitingToStartInjectorBehavior, WhiteboardScript, WodDialect, YogaDialect, addAliasToEffort, addDim, buildStaticLookups, buildTooltip, bundledEfforts, calculateElapsed, canonicalizeType, checkCalcLine, classifyStatements, closeCurrentSpan, collapseUnresolvedChoices, commonFixtureSet, compareStatement, compileLineForm, composeDivUnit, composeMulUnit, compoundName, computeColumnLabel, computeLabel, computeWorkloadRollups, convertScalar, createAnalyticsEngineForBlock, createCalcEngine, createCalcStack, createCompiler, createDialectStack, createDisciplinesTable, createEffortTable, createLineLocator, createPolicy as createMetricPresentationPolicy, createMockClock, createParser, createProfileTable, createRpeLabelsTable, dailySessionLoads, dayBucket, dialectRegistry, dialectStack, diffStatement, dimEquals, disciplineFactorFor, evaluate, evaluateCalculateDefinitions, extractEffortData, extractMetrics, extractStatements, extractStatementsRaw, extractSyntaxFacts, filterTagsByVisibility, findBestFuzzyMatch, findUnresolvedChoices, fixtureBackSquat, fixtureBurpee, fixturePlank, fixtureRowing, fixtureRunning, fixtureUserCustom, fixtureUserOverride, formatDim, formatDuration, metricsToLabel as fragmentsToLabel, fullFixtureSet, fuseUnits, fuseUnitsInMetrics, getAnalyticsFromLogs, getAnalyticsFromRuntime, getHints, getMetricVisibility, getUnit, hasHint, hintMetric, hintsToContainer, inferDim, isCastSubscription, isChoiceResolved, isDimensionless, isEffortDiscipline, isFragmentTag, isTimeLikeMetric, isWithinThreshold, levenshteinDistance, metricPresentation, mutateTimerSpans, normalizeForFuzzy, num, openSpan, outputNodeId, outputNodeIds, parseCalcLine, parseCalculateBlock, parseExpression, parseMetricLine, parseScript, printCalculation, readTimer, realtimeProcessorRegistry, renderMetric, resolveDominantOrigin, sharedParser, startSpan, str, strategyRegistry, subDim, summaryProcessorRegistry, toStoredOutputStatement, truthy, validateOutputUnit, parser as whiteboardParser, whiteboardScript, whiteboardScriptLanguage, writeChoiceSelection };
+export { ABSENT, AGGREGATE_BUILTINS, AUTHORITATIVE_CASTS, AbortSessionAction, AmrapLogicStrategy, AnalyticsEngine, AnalyticsTransformer, BUILTIN_CALCS, BUNDLED_EFFORT_COUNT, BehaviorContext, BlockBuilder, BlockContext, ButtonBehavior, CATALOG_PRECEDENCE_RANK, CONSUMED_HINTS, CONSUMED_HINT_KEYS, CONTEXT_ATOMS, CalcEngine, CalcEvalError, CalcParseError, CalcRegistrationError, CalcUnitError, CalculateBlockProcessor, CalculationRegistry, CardioDialect, ChildSelectionBehavior, ChildrenStrategy, ChoiceGroupMetric, ClearChildrenAction, ClimbDialect, ClimbMetricType, CompileAndPushBlockAction, CompletionTimestampBehavior, CompositeEffortRegistry, CountdownTimerBehavior, CountupTimerBehavior, CrossFitDialect, DAY, DEFAULT_RESOLVER_OPTIONS, DEFAULT_RUNTIME_OPTIONS, DEFAULT_UNRESOLVED_EFFORT_MET, DIM_COUNT, DIM_ENERGY, DIM_LENGTH, DIM_MASS, DIM_TIME, DIM_ZERO, DISCIPLINE_FACTORS, DialectStack, EFFORT_DATA_METRIC_TYPE, EFFORT_DISCIPLINES, EFFORT_REGISTRY_ORIGINS, EffortBlock, EffortFallbackStrategy, EffortResolver, EmitEventAction, EmitSystemOutputAction, ErrorAction, EventBus, ExecutionContext, ExitBehavior, FixtureSyntaxError, GenericGroupStrategy, GenericLoopStrategy, GenericTimerStrategy, HabitsDialect, INTENSITY_TIERS, InMemoryEffortRegistry, IntervalLogicStrategy, JitCompiler, LabelingBehavior, LocalEventProvider, LocalRuntimeSubscription, LookupRegistry, MdTimerRuntime, MemoryLocation, MemoryTypeEnum, MetricPromotionBehavior, NAMED_COMPOUNDS, NextAction, NextEvent, NextEventHandler, OutputEmitter, PREDEFINED_SOUNDS, PRODUCTION_STRATEGIES, PlaySoundAction, PopBlockAction, PushBlockAction, PushRestBlockAction, REST_EXCLUSION, RPE_LABELS, RegisterEventHandlerAction, Registry, ReportOutputBehavior, ReportOutputStrategy, RestBlock, RoundsMetric, RuntimeAdapter, RuntimeBlock, RuntimeBuilder, RuntimeClock, RuntimeFactory, RuntimeLogger, RuntimeMemory, RuntimeObservers, RuntimeStack, STANDARD_UNITS, STORE_CALCS, STREAM_ATOMS, ScriptRuntime, SessionRootBlock, SessionRootStrategy, SnapshotClock, SoundCueBehavior, SoundStrategy, SpanTrackingBehavior, StandardAnalyticsProfile, StartSessionAction, StartWorkoutAction, SubscriptionManager, ThrowError, ThrowErrorAction, TimeSpan, TwoPassEffortResolutionProcess, TypedMemoryReference, UNITS, UnitRegistry, UnitSet, UnitsDialect, UnregisterEventHandlerAction, UpdateNextPreviewAction, VISIBILITY_ICONS, VISIBILITY_LABELS, WaitingToStartBlock, WaitingToStartInjectorBehavior, WhiteboardScript, WodDialect, YogaDialect, addAliasToEffort, addDim, buildStaticLookups, buildTooltip, bundledEfforts, calculateElapsed, canonicalizeType, checkCalcLine, classifyStatements, closeCurrentSpan, collapseUnresolvedChoices, commonFixtureSet, compareStatement, compileLineForm, composeDivUnit, composeMulUnit, compoundName, computeColumnLabel, computeLabel, computeWorkloadRollups, convertScalar, createAnalyticsEngineForBlock, createCalcEngine, createCalcStack, createCompiler, createDialectStack, createDisciplinesTable, createEffortTable, createLineLocator, createPolicy as createMetricPresentationPolicy, createMockClock, createParser, createProfileTable, createReferenceIndex, createRpeLabelsTable, dailySessionLoads, dayBucket, dedupeEntitiesByPrecedence, dialectRegistry, dialectStack, diffStatement, dimEquals, disciplineFactorFor, documentToEffort, documentToEquipment, effortToDocument, equipmentToDocument, evaluate, evaluateCalculateDefinitions, extractEffortData, extractMetrics, extractStatementRefs, extractStatements, extractStatementsRaw, extractSyntaxFacts, filterTagsByVisibility, findBestFuzzyMatch, findUnresolvedChoices, fixtureBackSquat, fixtureBurpee, fixturePlank, fixtureRowing, fixtureRunning, fixtureUserCustom, fixtureUserOverride, formatDim, formatDuration, metricsToLabel as fragmentsToLabel, fullFixtureSet, fuseUnits, fuseUnitsInMetrics, getAnalyticsFromLogs, getAnalyticsFromRuntime, getHints, getMetricVisibility, getUnit, hasHint, hintMetric, hintsToContainer, inferDim, isCastSubscription, isChoiceResolved, isDimensionless, isEffortDiscipline, isFragmentTag, isTimeLikeMetric, isWithinThreshold, levenshteinDistance, metricPresentation, mutateTimerSpans, normalizeForFuzzy, num, openSpan, outputNodeId, outputNodeIds, parseCalcLine, parseCalculateBlock, parseEffortFile, parseEquipmentFile, parseExpression, parseMetricLine, parseScript, printCalculation, readNestedSection, readTimer, realtimeProcessorRegistry, renderMetric, resolveDominantOrigin, resolveEntityRank, resolveEntityTier, resolveSourceRank, resolveSourceTier, slugifyRefLabel, startSpan, str, strategyRegistry, subDim, summaryProcessorRegistry, toStoredOutputStatement, truthy, validateOutputUnit, parser as whiteboardParser, whiteboardScript, whiteboardScriptLanguage, writeChoiceSelection };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map