@bitcobblers/wod-wiki-lang 0.50.2187 → 0.50.2189

package/dist/index.cjs

@@ -551,6 +551,9 @@ var EffortMetric = class {
     this.effort = effort;
     this.value = options?.resolvedSlug ?? effort;
     this.image = effort;
+    if (options?.canonicalLabel) {
+      this.name = options.canonicalLabel;
+    }
     if (options?.references) {
       this.metadata = { [wodWikiCore.REFERENCE_METADATA_KEY]: options.references };
     }
@@ -558,6 +561,7 @@ var EffortMetric = class {
   effort;
   value;
   image;
+  name;
   origin = "parser";
   metadata;
   type = wodWikiCore.MetricType.Effort;
@@ -1571,11 +1575,12 @@ var EquipmentMetric = class {
   /** Canonical slugs, ordered and deduplicated. */
   value;
   image;
-  name = "equipment";
+  name;
   metadata;
   constructor(slugs, options) {
     this.value = [...new Set(slugs)];
     this.image = options?.source ?? this.value.join(" ");
+    this.name = options?.refs?.length ? options.refs.map((r) => r.label).join(", ") : "equipment";
     this.origin = options?.origin ?? "parser";
     const reference = {
       matched: options?.matched ?? "whole",
@@ -1719,9 +1724,14 @@ function classifyStatements(facts, references) {
       metricPairs.push(slot.pair);
     }
     const mergedPairs = mergeFragments(metricPairs);
-    const finalPairs = references ? applyReferenceResolution(mergedPairs, fact, references) : mergedPairs;
+    const finalPairs = references?.index ? applyReferenceResolution(mergedPairs, fact, references) : mergedPairs;
     statement.metrics = finalPairs.map((pair) => pair.metrics);
     statement.metricMeta = new Map(finalPairs.map((pair) => [pair.metrics, pair.meta]));
+    const effortMetric = finalPairs.find((p) => p.metrics.type === wodWikiCore.MetricType.Effort)?.metrics;
+    const effortRef = wodWikiCore.getReferenceMetadata(effortMetric?.metadata)?.refs?.find((r) => r.kind === "effort");
+    if (effortRef?.slug) {
+      statement.exerciseId = effortRef.slug;
+    }
     statement.id = fact.id;
     statement.line = fact.line;
     statement.text = fact.meta.raw;
@@ -1749,33 +1759,34 @@ function equipmentMeta(resolution, authored, meta2) {
   };
 }
 function applyReferenceResolution(pairs, fact, references) {
-  const { index, defaults } = references;
+  const index = references.index;
+  const { 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,
+          canonicalLabel: resolution.effortRef?.label,
           references: referenceMetadata(resolution)
         }),
         meta: meta2
       });
     }
     if (resolution.equipment.length > 0) {
+      const eqMeta = equipmentMeta(resolution, authored, meta2);
+      const eqSource = resolution.matched === "split" ? eqMeta.raw : resolution.matched === "explicit" ? resolution.equipment.map((ref) => ref.label).join(", ") : authored;
       result.push({
         metrics: new EquipmentMetric(
           resolution.equipment.map((ref) => ref.slug),
           {
             refs: resolution.equipment,
-            source: authored,
+            source: eqSource,
             matched: resolution.matched,
             diagnostics: resolution.diagnostics
           }
         ),
-        // The equipment is the prefix of the authored label; the effort is
-        // what follows. Marking the whole phrase for both would let one mark
-        // hide the other.
-        meta: equipmentMeta(resolution, authored, meta2)
+        meta: eqMeta
       });
     }
   };
@@ -1850,6 +1861,64 @@ function applyReferenceResolution(pairs, fact, references) {
   result.push(...malformedHints);
   return result;
 }
+function resolveFusedEffortReferences(statements, references) {
+  if (!references?.index) return;
+  const { index, defaults } = references;
+  for (const statement of statements) {
+    const current = statement.metrics.toArray();
+    if (!current.some((m) => m.type === wodWikiCore.MetricType.Effort && !m.metadata)) continue;
+    const nextMetrics = [];
+    const nextMeta = new Map(statement.metricMeta);
+    for (const metric of current) {
+      if (metric.type !== wodWikiCore.MetricType.Effort || metric.metadata) {
+        nextMetrics.push(metric);
+        continue;
+      }
+      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)) {
+        nextMetrics.push(metric);
+        continue;
+      }
+      const meta2 = statement.metricMeta?.get(metric);
+      const resolution = index.resolve(authored, defaults);
+      if (resolution.matched === "none" && resolution.diagnostics.length === 0) {
+        nextMetrics.push(metric);
+        continue;
+      }
+      nextMeta.delete(metric);
+      if (resolution.effortRef || resolution.matched !== "none" || resolution.diagnostics.length > 0) {
+        const resolvedEffort = new EffortMetric(authored, {
+          resolvedSlug: resolution.effortRef?.slug,
+          canonicalLabel: resolution.effortRef?.label,
+          references: referenceMetadata(resolution)
+        });
+        nextMetrics.push(resolvedEffort);
+        if (meta2) nextMeta.set(resolvedEffort, meta2);
+        if (resolution.effortRef?.slug) {
+          statement.exerciseId = resolution.effortRef.slug;
+        }
+      }
+      if (resolution.equipment.length > 0) {
+        const eqMeta = meta2 ? equipmentMeta(resolution, authored, meta2) : void 0;
+        const eqSource = resolution.matched === "split" && eqMeta ? eqMeta.raw : authored;
+        const eqMetric = new EquipmentMetric(
+          resolution.equipment.map((ref) => ref.slug),
+          {
+            refs: resolution.equipment,
+            source: eqSource,
+            matched: resolution.matched,
+            diagnostics: resolution.diagnostics
+          }
+        );
+        nextMetrics.push(eqMetric);
+        if (eqMeta) nextMeta.set(eqMetric, eqMeta);
+      }
+    }
+    statement.metrics.clear().add(...nextMetrics);
+    statement.metricMeta = nextMeta;
+  }
+}
 function classifyPrimitive(primitive) {
   switch (primitive.kind) {
     case "lap":
@@ -2467,6 +2536,7 @@ function extractStatements(sourceOrTree, sportOrTree, sportArg, references) {
   const facts = extractSyntaxFacts(resolved.source, resolved.tree);
   const statements = classifyStatements(facts, references);
   dialectStack.processAll(statements, sport);
+  resolveFusedEffortReferences(statements, references);
   return normalizeInlineRounds(statements);
 }
 function isInlineRoundsPrescription(stmt) {
@@ -2588,557 +2658,87 @@ var WhiteboardScript = class {
   }
 };
 
-// src/effort-registry/types.ts
-var EFFORT_REGISTRY_ORIGINS = ["bundled", "user"];
-var SEED_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 SEED_PRECEDENCE_RANK[resolveSourceTier(sourceIdOrMetaKey, explicitTier)];
-}
-function resolveEntityTier(entity) {
-  if (entity.registrySource === "user") return "user";
-  return resolveSourceTier(entity.sourceId);
-}
-function resolveEntityRank(entity) {
-  return SEED_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);
-    }
+// src/parser/parseScript.ts
+function parseScript(inputText, options = {}) {
+  if (!inputText || !inputText.trim()) {
+    return new WhiteboardScript(inputText, [], []);
+  }
+  try {
+    const doc = inputText.endsWith("\n") ? inputText : inputText + "\n";
+    const tree = parser.parse(doc);
+    const sport = options.sport ?? options.dialect;
+    const references = options.references || options.tags ? {
+      ...options.references ? { index: options.references } : {},
+      defaults: options.defaults,
+      tags: options.tags
+    } : 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";
+    return new WhiteboardScript(inputText, [], [{ message: msg }]);
   }
-  return Array.from(bySlug.values());
 }
-var INTENSITY_TIERS = ["low", "moderate", "high"];
-var DEFAULT_RESOLVER_OPTIONS = {
-  defaultMet: 5,
-  defaultThreshold: 2
-};
 
-// src/effort-registry/fuzzyMatch.ts
-function levenshteinDistance(a, b) {
-  if (a === b) return 0;
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-  if (a.length > b.length) {
-    const tmp = a;
-    a = b;
-    b = tmp;
+// src/parser/md-timer.ts
+var MdTimerRuntime = class {
+  config;
+  constructor(config) {
+    this.config = config;
   }
-  const m = a.length;
-  const n = b.length;
-  let prev = new Uint32Array(m + 1);
-  let curr = new Uint32Array(m + 1);
-  for (let i = 0; i <= m; i++) {
-    prev[i] = i;
+  /**
+   * Parse WhiteboardScript source into a {@link WhiteboardScript}, running the
+   * Dialect Stack on every statement.
+   *
+   * @param sport - The block's `:sport` fence suffix (` ```log:climbing `).
+   */
+  read(inputText, sport) {
+    return parseScript(inputText, { sport, ...this.config });
   }
-  for (let j = 1; j <= n; j++) {
-    curr[0] = j;
-    const bj = b.charCodeAt(j - 1);
-    for (let i = 1; i <= m; i++) {
-      const cost = a.charCodeAt(i - 1) === bj ? 0 : 1;
-      curr[i] = Math.min(
-        prev[i] + 1,
-        // deletion
-        curr[i - 1] + 1,
-        // insertion
-        prev[i - 1] + cost
-        // substitution
-      );
-    }
-    const swap = prev;
-    prev = curr;
-    curr = swap;
+  /**
+   * 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, ...this.config });
   }
-  return prev[m];
-}
-function normalizeForFuzzy(input) {
-  return input.toLowerCase().replace(/[^\p{L}\p{N}\s-]/gu, " ").replace(/[-_]+/g, " ").trim().replace(/\s+/g, " ");
-}
-function isWithinThreshold(a, b, threshold) {
-  const na = normalizeForFuzzy(a);
-  const nb = normalizeForFuzzy(b);
-  if (na === nb) return true;
-  if (Math.abs(na.length - nb.length) > threshold) return false;
-  return levenshteinDistance(na, nb) <= threshold;
+};
+
+// src/parser/parserInstance.ts
+function createParser(config) {
+  return new MdTimerRuntime(config);
 }
-function findBestFuzzyMatch(query, candidates, threshold) {
-  const nq = normalizeForFuzzy(query);
-  let best = null;
-  for (const candidate of candidates) {
-    const nc = normalizeForFuzzy(candidate);
-    if (Math.abs(nq.length - nc.length) > threshold) continue;
-    const distance = levenshteinDistance(nq, nc);
-    if (distance > threshold) continue;
-    if (!best || distance < best.distance) {
-      best = { target: candidate, distance };
-      if (distance === 0) break;
-    }
+var nextTagID = 0;
+var Tag = class _Tag {
+  /**
+  @internal
+  */
+  constructor(name2, set, base, modified) {
+    this.name = name2;
+    this.set = set;
+    this.base = base;
+    this.modified = modified;
+    this.id = nextTagID++;
   }
-  return best;
-}
-
-// src/effort-registry/reference-resolution.ts
-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);
+  toString() {
+    let { name: name2 } = this;
+    for (let mod of this.modified)
+      if (mod.name)
+        name2 = `${mod.name}(${name2})`;
+    return name2;
   }
-  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/parser/parseScript.ts
-function parseScript(inputText, options = {}) {
-  if (!inputText || !inputText.trim()) {
-    return new WhiteboardScript(inputText, [], []);
-  }
-  try {
-    const doc = inputText.endsWith("\n") ? inputText : inputText + "\n";
-    const tree = parser.parse(doc);
-    const sport = options.sport ?? options.dialect;
-    const references = options.references || options.tags ? {
-      index: options.references ?? createReferenceIndex({ efforts: [], equipment: [] }),
-      defaults: options.defaults,
-      tags: options.tags
-    } : 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";
-    return new WhiteboardScript(inputText, [], [{ message: msg }]);
-  }
-}
-
-// 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.
-   *
-   * @param sport - The block's `:sport` fence suffix (` ```log:climbing `).
-   */
-  read(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, ...this.config });
-  }
-};
-
-// src/parser/parserInstance.ts
-function createParser(config) {
-  return new MdTimerRuntime(config);
-}
-var nextTagID = 0;
-var Tag = class _Tag {
-  /**
-  @internal
-  */
-  constructor(name2, set, base, modified) {
-    this.name = name2;
-    this.set = set;
-    this.base = base;
-    this.modified = modified;
-    this.id = nextTagID++;
-  }
-  toString() {
-    let { name: name2 } = this;
-    for (let mod of this.modified)
-      if (mod.name)
-        name2 = `${mod.name}(${name2})`;
-    return name2;
-  }
-  static define(nameOrParent, parent) {
-    let name2 = typeof nameOrParent == "string" ? nameOrParent : "?";
-    if (nameOrParent instanceof _Tag)
-      parent = nameOrParent;
-    if (parent === null || parent === void 0 ? void 0 : parent.base)
-      throw new Error("Can not derive from a modified tag");
-    let tag = new _Tag(name2, [], null, []);
-    tag.set.push(tag);
-    if (parent)
-      for (let t2 of parent.set)
-        tag.set.push(t2);
-    return tag;
+  static define(nameOrParent, parent) {
+    let name2 = typeof nameOrParent == "string" ? nameOrParent : "?";
+    if (nameOrParent instanceof _Tag)
+      parent = nameOrParent;
+    if (parent === null || parent === void 0 ? void 0 : parent.base)
+      throw new Error("Can not derive from a modified tag");
+    let tag = new _Tag(name2, [], null, []);
+    tag.set.push(tag);
+    if (parent)
+      for (let t2 of parent.set)
+        tag.set.push(t2);
+    return tag;
   }
   /**
   Define a tag _modifier_, which is a function that, given a tag,
@@ -3851,17 +3451,16 @@ function structureKeywords() {
   }));
 }
 function toCompletions(values, detail, quoteValues = false) {
-  return values.map((value) => ({
-    label: value.label ?? value.value,
-    // `Property` values only lex as String | Number | Identifier, and
-    // Identifier is `[a-zA-Z][a-zA-Z0-9]*` — quote slugs it cannot represent
-    // (hyphens, spaces, leading digits) so they insert parse-valid text;
-    // `parsePropertyValue` unwraps the quotes when the property is consumed.
-    apply: quoteValues && !/^[A-Za-z][A-Za-z0-9]*$/.test(value.value) ? JSON.stringify(value.value) : value.value,
-    detail: value.detail ?? detail,
-    type: "text",
-    info: value.info
-  }));
+  return values.map((value) => {
+    const insertText = quoteValues ? !/^[A-Za-z][A-Za-z0-9]*$/.test(value.value) ? JSON.stringify(value.value) : value.value : value.label ?? value.value;
+    return {
+      label: value.label ?? value.value,
+      apply: insertText,
+      detail: value.detail ?? (value.label && value.label !== value.value ? value.value : detail),
+      type: "text",
+      info: value.info
+    };
+  });
 }
 function dialectWords(sport) {
   if (!sport) return [];
@@ -3944,7 +3543,13 @@ function whiteboardScriptCompletionSource(options = {}) {
       return null;
     }
     const efforts = options.efforts ? toCompletions(await options.efforts(), "effort") : [];
-    const effortOptions = [...keywords, ...efforts, ...sportWords];
+    const equipmentPrefixes = options.equipment ? (await options.equipment()).map((eq) => ({
+      label: eq.label ?? eq.value,
+      apply: `${eq.label ?? eq.value} `,
+      detail: eq.detail ?? "equipment",
+      type: "text"
+    })) : [];
+    const effortOptions = [...keywords, ...efforts, ...equipmentPrefixes, ...sportWords];
     if (/^[ \t]*[A-Za-z][A-Za-z0-9]*$/.test(before)) {
       const supplied = suppliedPropertyKeys(context);
       return {
@@ -3987,7 +3592,7 @@ function whiteboardScriptCompletionSource(options = {}) {
       const typed = context.state.doc.sliceString(first.from, pos).toLowerCase();
       const compatible = effortOptions.filter((option) => {
         const inserted = typeof option.apply === "string" ? option.apply : option.label;
-        return inserted.toLowerCase().startsWith(typed);
+        return inserted.toLowerCase().startsWith(typed) || option.label.toLowerCase().startsWith(typed);
       });
       return { from: first.from, options: compatible, validFor: /^[A-Za-z ]*$/ };
     }
@@ -4036,6 +3641,50 @@ function whiteboardScript(options) {
   return new language.LanguageSupport(whiteboardScriptLanguage, whiteboardScriptCompletion(options ?? {}));
 }
 
+// src/effort-registry/types.ts
+var EFFORT_REGISTRY_ORIGINS = ["bundled", "user"];
+var SEED_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 SEED_PRECEDENCE_RANK[resolveSourceTier(sourceIdOrMetaKey, explicitTier)];
+}
+function resolveEntityTier(entity) {
+  if (entity.registrySource === "user") return "user";
+  return resolveSourceTier(entity.sourceId);
+}
+function resolveEntityRank(entity) {
+  return SEED_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,
+  defaultThreshold: 2
+};
+
 // src/effort-registry/disciplines.ts
 var EFFORT_DISCIPLINES = [
   "bodyweight",
@@ -4641,6 +4290,71 @@ function tagCategoryToDocument(category) {
   }
   return lines.join("\n");
 }
+
+// src/effort-registry/fuzzyMatch.ts
+function levenshteinDistance(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  if (a.length > b.length) {
+    const tmp = a;
+    a = b;
+    b = tmp;
+  }
+  const m = a.length;
+  const n = b.length;
+  let prev = new Uint32Array(m + 1);
+  let curr = new Uint32Array(m + 1);
+  for (let i = 0; i <= m; i++) {
+    prev[i] = i;
+  }
+  for (let j = 1; j <= n; j++) {
+    curr[0] = j;
+    const bj = b.charCodeAt(j - 1);
+    for (let i = 1; i <= m; i++) {
+      const cost = a.charCodeAt(i - 1) === bj ? 0 : 1;
+      curr[i] = Math.min(
+        prev[i] + 1,
+        // deletion
+        curr[i - 1] + 1,
+        // insertion
+        prev[i - 1] + cost
+        // substitution
+      );
+    }
+    const swap = prev;
+    prev = curr;
+    curr = swap;
+  }
+  return prev[m];
+}
+function normalizeForFuzzy(input) {
+  return input.toLowerCase().replace(/[^\p{L}\p{N}\s-]/gu, " ").replace(/[-_]+/g, " ").trim().replace(/\s+/g, " ");
+}
+function isWithinThreshold(a, b, threshold) {
+  const na = normalizeForFuzzy(a);
+  const nb = normalizeForFuzzy(b);
+  if (na === nb) return true;
+  if (Math.abs(na.length - nb.length) > threshold) return false;
+  return levenshteinDistance(na, nb) <= threshold;
+}
+function findBestFuzzyMatch(query, candidates, threshold) {
+  const nq = normalizeForFuzzy(query);
+  let best = null;
+  for (const candidate of candidates) {
+    const nc = normalizeForFuzzy(candidate);
+    if (Math.abs(nq.length - nc.length) > threshold) continue;
+    const distance = levenshteinDistance(nq, nc);
+    if (distance > threshold) continue;
+    if (!best || distance < best.distance) {
+      best = { target: candidate, distance };
+      if (distance === 0) break;
+    }
+  }
+  return best;
+}
+
+// src/effort-registry/EffortResolver.ts
 function normalizeSlug(label) {
   return normalizeForFuzzy(label).replace(/\s+/g, "-");
 }
@@ -5002,148 +4716,519 @@ var CompositePropertyRegistry = class {
     for (const item of this.userItems.values()) merged.set(item.slug, item);
     return [...merged.values()];
   }
-  listByOrigin(origin) {
-    return origin === "user" ? [...this.userItems.values()] : [...this.bundledItems.values()];
+  listByOrigin(origin) {
+    return origin === "user" ? [...this.userItems.values()] : [...this.bundledItems.values()];
+  }
+  async upsert(item) {
+    if (item.registrySource !== "user") {
+      throw new Error(`Cannot upsert property with registrySource '${item.registrySource}'; clone it as 'user' first`);
+    }
+    this.userItems.set(item.slug, item);
+    if (this.storage) await this.storage.save(item);
+  }
+  async delete(slug) {
+    const item = this.userItems.get(slug);
+    if (!item) throw new Error(`Cannot delete '${slug}': not a user-owned record`);
+    this.userItems.delete(slug);
+    if (this.storage) await this.storage.delete(slug);
+  }
+};
+var CompositeEquipmentRegistry = class extends CompositePropertyRegistry {
+  constructor(options) {
+    super({ storage: options?.storage });
+  }
+};
+
+// src/effort-registry/CompositeEffortRegistry.ts
+var CompositeEffortRegistry = class extends CompositePropertyRegistry {
+  constructor(options) {
+    super({
+      bundled: options?.bundled,
+      storage: options?.storage
+    });
+  }
+  async loadBundled(customBundled) {
+    this.bundledItems.clear();
+    const source = customBundled ?? this.initialBundled ?? bundledEfforts;
+    for (const effort of source) {
+      const prior = this.bundledItems.get(effort.slug);
+      if (!prior || resolveEntityRank(effort) >= resolveEntityRank(prior)) {
+        this.bundledItems.set(effort.slug, effort);
+      }
+    }
+    this.userItems.clear();
+    if (this.storage) {
+      try {
+        const userEfforts = await this.storage.load();
+        for (const effort of userEfforts) {
+          if (effort.registrySource === "user") {
+            this.userItems.set(effort.slug, effort);
+          }
+        }
+      } catch (err) {
+        console.warn("[CompositeEffortRegistry] Failed to load user efforts from storage adapter:", err);
+      }
+    }
+    this.initialized = true;
+  }
+  /** True after loadBundled() has resolved */
+  isInitialized() {
+    return this.initialized;
+  }
+  listByOrigin(origin) {
+    if (origin === "user") {
+      return Array.from(this.userItems.values());
+    }
+    if (origin === "bundled") {
+      return Array.from(this.bundledItems.values());
+    }
+    return this.list().filter((e) => e.registrySource === origin);
+  }
+  async upsert(effort) {
+    if (effort.registrySource !== "user") {
+      throw new Error(
+        `CompositeEffortRegistry.upsert: only user efforts can be written. Received registrySource="${effort.registrySource}"`
+      );
+    }
+    this.userItems.set(effort.slug, effort);
+    if (this.storage) {
+      try {
+        await this.storage.save(effort);
+      } catch (err) {
+        console.warn("[CompositeEffortRegistry] Failed to persist effort to storage adapter:", err);
+      }
+    }
+  }
+  async delete(slug) {
+    const existing = this.resolve(slug);
+    if (existing && existing.registrySource !== "user") {
+      throw new Error(
+        `CompositeEffortRegistry.delete: cannot delete non-user effort "${slug}"`
+      );
+    }
+    this.userItems.delete(slug);
+    if (this.storage) {
+      try {
+        await this.storage.delete(slug);
+      } catch (err) {
+        console.warn("[CompositeEffortRegistry] Failed to delete effort from storage adapter:", err);
+      }
+    }
+  }
+};
+
+// src/effort-registry/aliasManagement.ts
+async function addAliasToEffort(registry, targetSlug, newAlias) {
+  const trimmed = newAlias.trim();
+  if (!trimmed) {
+    throw new Error("Alias cannot be empty");
+  }
+  const existing = registry.resolve(targetSlug);
+  if (!existing) {
+    throw new Error(`Effort "${targetSlug}" not found in registry`);
   }
-  async upsert(item) {
-    if (item.registrySource !== "user") {
-      throw new Error(`Cannot upsert property with registrySource '${item.registrySource}'; clone it as 'user' first`);
-    }
-    this.userItems.set(item.slug, item);
-    if (this.storage) await this.storage.save(item);
+  const normalizedNew = normalizeForFuzzy(trimmed);
+  const alreadyHas = normalizeForFuzzy(existing.label) === normalizedNew || existing.aliases.some((a) => normalizeForFuzzy(a) === normalizedNew);
+  if (alreadyHas) {
+    return existing;
   }
-  async delete(slug) {
-    const item = this.userItems.get(slug);
-    if (!item) throw new Error(`Cannot delete '${slug}': not a user-owned record`);
-    this.userItems.delete(slug);
-    if (this.storage) await this.storage.delete(slug);
+  const updatedAliases = [...existing.aliases, trimmed];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (existing.registrySource === "bundled") {
+    const id = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? `effort-user-${crypto.randomUUID()}` : `effort-user-${Date.now()}`;
+    const userEffort = {
+      ...existing,
+      id,
+      registrySource: "user",
+      aliases: updatedAliases,
+      updatedAt: now,
+      derivation: existing.derivation ?? {
+        parentSlug: existing.slug,
+        coefficients: {},
+        hardOverrides: {}
+      }
+    };
+    await registry.upsert(userEffort);
+    return userEffort;
   }
-};
-var CompositeEquipmentRegistry = class extends CompositePropertyRegistry {
-  constructor(options) {
-    super({ storage: options?.storage });
+  const updatedUserEffort = {
+    ...existing,
+    aliases: updatedAliases,
+    updatedAt: now
+  };
+  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);
   }
-};
-
-// src/effort-registry/CompositeEffortRegistry.ts
-var CompositeEffortRegistry = class extends CompositePropertyRegistry {
-  constructor(options) {
-    super({
-      bundled: options?.bundled,
-      storage: options?.storage
-    });
+  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);
   }
-  async loadBundled(customBundled) {
-    this.bundledItems.clear();
-    const source = customBundled ?? this.initialBundled ?? bundledEfforts;
-    for (const effort of source) {
-      const prior = this.bundledItems.get(effort.slug);
-      if (!prior || resolveEntityRank(effort) >= resolveEntityRank(prior)) {
-        this.bundledItems.set(effort.slug, effort);
+  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
+        });
       }
     }
-    this.userItems.clear();
-    if (this.storage) {
-      try {
-        const userEfforts = await this.storage.load();
-        for (const effort of userEfforts) {
-          if (effort.registrySource === "user") {
-            this.userItems.set(effort.slug, effort);
+    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
+          };
         }
-      } catch (err) {
-        console.warn("[CompositeEffortRegistry] Failed to load user efforts from storage adapter:", err);
       }
-    }
-    this.initialized = true;
-  }
-  /** True after loadBundled() has resolved */
-  isInitialized() {
-    return this.initialized;
-  }
-  listByOrigin(origin) {
-    if (origin === "user") {
-      return Array.from(this.userItems.values());
-    }
-    if (origin === "bundled") {
-      return Array.from(this.bundledItems.values());
-    }
-    return this.list().filter((e) => e.registrySource === origin);
-  }
-  async upsert(effort) {
-    if (effort.registrySource !== "user") {
-      throw new Error(
-        `CompositeEffortRegistry.upsert: only user efforts can be written. Received registrySource="${effort.registrySource}"`
-      );
-    }
-    this.userItems.set(effort.slug, effort);
-    if (this.storage) {
-      try {
-        await this.storage.save(effort);
-      } catch (err) {
-        console.warn("[CompositeEffortRegistry] Failed to persist effort to storage adapter:", err);
+      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;
+          const rawPrefix = source.slice(0, candidate.lower.length).trim();
+          equipmentRefs = [{
+            ...equipmentRef(equipmentFound.entity),
+            ...rawPrefix.toLowerCase() !== equipmentFound.entity.label.toLowerCase() ? { matchedAlias: rawPrefix } : {}
+          }];
+          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
+          };
+        }
       }
-    }
-  }
-  async delete(slug) {
-    const existing = this.resolve(slug);
-    if (existing && existing.registrySource !== "user") {
-      throw new Error(
-        `CompositeEffortRegistry.delete: cannot delete non-user effort "${slug}"`
-      );
-    }
-    this.userItems.delete(slug);
-    if (this.storage) {
-      try {
-        await this.storage.delete(slug);
-      } catch (err) {
-        console.warn("[CompositeEffortRegistry] Failed to delete effort from storage adapter:", err);
+      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();
+      const effortMatchText = matched === "split" ? remaining : source;
+      return {
+        matched,
+        label: source,
+        effort: effortEntity ? materializer(effortEntity) : null,
+        effortRef: effortEntity ? {
+          kind: "effort",
+          slug: effortEntity.slug,
+          label: effortEntity.label,
+          ...effortMatchText && effortMatchText.toLowerCase() !== effortEntity.label.toLowerCase() ? { matchedAlias: effortMatchText } : {}
+        } : null,
+        equipment: equipmentRefs,
+        remaining,
+        diagnostics
+      };
     }
-  }
-};
-
-// src/effort-registry/aliasManagement.ts
-async function addAliasToEffort(registry, targetSlug, newAlias) {
-  const trimmed = newAlias.trim();
-  if (!trimmed) {
-    throw new Error("Alias cannot be empty");
-  }
-  const existing = registry.resolve(targetSlug);
-  if (!existing) {
-    throw new Error(`Effort "${targetSlug}" not found in registry`);
-  }
-  const normalizedNew = normalizeForFuzzy(trimmed);
-  const alreadyHas = normalizeForFuzzy(existing.label) === normalizedNew || existing.aliases.some((a) => normalizeForFuzzy(a) === normalizedNew);
-  if (alreadyHas) {
-    return existing;
-  }
-  const updatedAliases = [...existing.aliases, trimmed];
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  if (existing.registrySource === "bundled") {
-    const id = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? `effort-user-${crypto.randomUUID()}` : `effort-user-${Date.now()}`;
-    const userEffort = {
-      ...existing,
-      id,
-      registrySource: "user",
-      aliases: updatedAliases,
-      updatedAt: now,
-      derivation: existing.derivation ?? {
-        parentSlug: existing.slug,
-        coefficients: {},
-        hardOverrides: {}
+  };
+  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);
       }
-    };
-    await registry.upsert(userEffort);
-    return userEffort;
+    }
   }
-  const updatedUserEffort = {
-    ...existing,
-    aliases: updatedAliases,
-    updatedAt: now
-  };
-  await registry.upsert(updatedUserEffort);
-  return updatedUserEffort;
+  return { efforts, equipment };
+}
+function slugifyRefLabel(label) {
+  return normalizeForFuzzy(label).replace(/\s+/g, "-");
 }
 
 // src/runtime/contracts/IRuntimeOptions.ts
@@ -10177,8 +10262,11 @@ function tryEnrichBlock(block, resolver, references, overwrite, debug, propertyS
   if (normalizedBlockType !== "effort" && normalizedBlockType !== "exercise") {
     return;
   }
-  const label = block.label;
-  if (!label) {
+  const statementEffortMetric = block.getAllMemory().flatMap((loc) => loc.metrics.toArray()).find((m) => m.type === wodWikiCore.MetricType.Effort);
+  const preResolvedMeta = wodWikiCore.getReferenceMetadata(statementEffortMetric?.metadata);
+  const preResolvedEffortRef = preResolvedMeta?.refs?.find((r) => r.kind === "effort");
+  const label = block.label || preResolvedMeta?.source || (typeof statementEffortMetric?.image === "string" ? statementEffortMetric.image : "");
+  if (!label && !preResolvedEffortRef && !block.context?.exerciseId) {
     if (debug) logTrace(`[EffortEnrichment] Skipping block with no label: ${block.key}`);
     return;
   }
@@ -10195,13 +10283,23 @@ function tryEnrichBlock(block, resolver, references, overwrite, debug, propertyS
     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;
+      const directSlug = preResolvedEffortRef?.slug || block.context?.exerciseId;
+      const directEntity = directSlug ? references.resolveEffort(directSlug) : null;
+      if (directEntity && preResolvedMeta) {
+        resolved = references.materialize(directEntity);
+        matchedKind = preResolvedMeta.matched;
+        equipmentRefs = preResolvedMeta.refs?.filter((r) => r.kind === "equipment") ?? [];
+        diagnostics = [...preResolvedMeta.diagnostics ?? []];
+      } else {
+        const resolution = references.resolve(label);
+        resolved = resolution.effort ?? void 0;
+        matchedKind = resolution.matched;
+        equipmentRefs = resolution.equipment;
+        diagnostics = resolution.diagnostics;
+      }
     } else {
-      resolved = resolver.resolveEffort(label);
+      const lookupKey = preResolvedEffortRef?.slug || block.context?.exerciseId || label;
+      resolved = resolver.resolveEffort(lookupKey) ?? (lookupKey !== label ? resolver.resolveEffort(label) : void 0);
     }
     if (!resolved) {
       if (diagnostics.length > 0) {
@@ -16209,6 +16307,7 @@ exports.renderMetric = renderMetric;
 exports.resolveDominantOrigin = resolveDominantOrigin;
 exports.resolveEntityRank = resolveEntityRank;
 exports.resolveEntityTier = resolveEntityTier;
+exports.resolveFusedEffortReferences = resolveFusedEffortReferences;
 exports.resolveProfileRules = resolveProfileRules;
 exports.resolveSoundProfile = resolveSoundProfile;
 exports.resolveSourceRank = resolveSourceRank;