@bitcobblers/wod-wiki-lang 0.43.2152 → 0.44.2155

package/dist/index.cjs

@@ -305,6 +305,125 @@ function computeColumnLabel(type) {
   const normalized = key.toLowerCase();
   return COLUMN_LABEL_MAP[normalized] ?? humanizeMetricKey(key);
 }
+function tagReferenceFor(tagIndex, slug) {
+  const resolved = resolveTagContributions(tagIndex, slug);
+  const sound = resolved.metrics.find(
+    (contribution) => contribution.type === wodWikiCore.MetricType.Sound && typeof contribution.value === "string"
+  );
+  return {
+    slug,
+    label: slug,
+    ...resolved.functions.length > 0 ? { functions: [...resolved.functions] } : {},
+    ...sound ? { soundProfileId: sound.value } : {}
+  };
+}
+function collectTagReferences(metrics, into = []) {
+  for (const metric of metrics) {
+    const reference = wodWikiCore.getTagReference(metric.metadata);
+    if (!reference) continue;
+    if (into.some((existing) => existing.slug === reference.slug)) continue;
+    into.push(reference);
+  }
+  return into;
+}
+var TAG_MARKER_PREFIX = "tag.";
+var MAX_TAG_CONTRIBUTION_DEPTH = 8;
+var EMPTY = { metrics: [], functions: [], tags: [] };
+function resolveTagContributions(tagIndex, slug) {
+  if (!tagIndex) return EMPTY;
+  const metrics = [];
+  const functions = [];
+  const tags2 = [];
+  const seenFunctions = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const walk = (currentSlug, depth) => {
+    if (depth > MAX_TAG_CONTRIBUTION_DEPTH) return;
+    if (visited.has(currentSlug)) return;
+    const definition = tagIndex.resolve(currentSlug);
+    if (!definition) return;
+    visited.add(currentSlug);
+    tags2.push(currentSlug);
+    for (const contribution of definition.contributions) {
+      if (contribution.kind === "metric") metrics.push(contribution);
+      else if (contribution.kind === "function") {
+        if (!seenFunctions.has(contribution.name)) {
+          seenFunctions.add(contribution.name);
+          functions.push(contribution.name);
+        }
+      }
+    }
+    for (const contribution of definition.contributions) {
+      if (contribution.kind === "tag") walk(contribution.slug, depth + 1);
+    }
+  };
+  walk(slug, 0);
+  return { metrics, functions, tags: tags2 };
+}
+function findTagContributionCycles(tagIndex) {
+  if (!tagIndex) return [];
+  const cycles = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (slug, path, onPath) => {
+    if (onPath.has(slug)) {
+      const start = path.indexOf(slug);
+      if (start >= 0) {
+        const cycle = [...path.slice(start), slug];
+        const key = cycleKey(cycle);
+        if (!seen.has(key)) {
+          seen.add(key);
+          cycles.push(cycle);
+        }
+      }
+      return;
+    }
+    const definition = tagIndex.resolve(slug);
+    if (!definition) return;
+    const nextPath = [...path, slug];
+    const nextOnPath = new Set(onPath);
+    nextOnPath.add(slug);
+    for (const contribution of definition.contributions) {
+      if (contribution.kind === "tag") walk(contribution.slug, nextPath, nextOnPath);
+    }
+  };
+  for (const definition of tagIndex.list()) {
+    walk(definition.slug, [], /* @__PURE__ */ new Set());
+  }
+  return cycles;
+}
+function cycleKey(cycle) {
+  const nodes = cycle.slice(0, -1);
+  if (nodes.length === 0) return "";
+  let smallest = 0;
+  for (let index = 1; index < nodes.length; index++) {
+    if (nodes[index] < nodes[smallest]) smallest = index;
+  }
+  return [...nodes.slice(smallest), ...nodes.slice(0, smallest)].join(">");
+}
+function tagMarkerType(slug) {
+  return `${TAG_MARKER_PREFIX}${slug}`;
+}
+function tagMarkerSlug(type) {
+  if (!type.startsWith(TAG_MARKER_PREFIX)) return void 0;
+  const slug = type.slice(TAG_MARKER_PREFIX.length);
+  return slug.length > 0 ? slug : void 0;
+}
+function tagMarkerSlugs(metrics) {
+  const slugs = [];
+  for (const metric of metrics) {
+    const slug = tagMarkerSlug(metric.type);
+    if (slug !== void 0 && !slugs.includes(slug)) slugs.push(slug);
+  }
+  return slugs;
+}
+function tagContributionMetrics(contributions, origin = "parser") {
+  return contributions.map((contribution) => ({
+    type: contribution.type,
+    value: contribution.value,
+    origin,
+    image: String(contribution.value),
+    ...contribution.unit ? { unit: contribution.unit } : {}
+  }));
+}
 
 // src/metrics/presentation/MetricPresentationPolicy.ts
 function isRestMetric(metric) {
@@ -368,6 +487,7 @@ function createPolicy() {
       }
       const t2 = metric.type;
       if ((t2 === wodWikiCore.MetricType.Sound || t2 === "sound") && surface !== "debug") return true;
+      if (t2.startsWith(TAG_MARKER_PREFIX) && surface !== "debug") return true;
       if (surface === "review-grid-column") {
         if (t2 === wodWikiCore.MetricType.Elapsed || t2 === "elapsed" || t2 === wodWikiCore.MetricType.Total || t2 === "total") return true;
         if (t2 === wodWikiCore.MetricType.System || t2 === "system") return true;
@@ -1505,15 +1625,16 @@ var TextMetric = class {
   origin = "parser";
   type = wodWikiCore.MetricType.Text;
 };
-
-// src/parser/semantic-classifier.ts
 var PROPERTY_KEY_TO_METRIC_TYPE = {
   rpe: wodWikiCore.MetricType.SessionRPE,
   rir: wodWikiCore.MetricType.RIR,
   intensity: wodWikiCore.MetricType.Intensity,
   load: wodWikiCore.MetricType.Load,
   volume: wodWikiCore.MetricType.Volume,
-  work: wodWikiCore.MetricType.Work
+  work: wodWikiCore.MetricType.Work,
+  // `sound: classic` names a sound profile, the same way a `#sound-classic`
+  // tag reference does.
+  sound: wodWikiCore.MetricType.Sound
 };
 var STRUCTURAL_EFFORT_WORDS = /* @__PURE__ */ new Set(["rest", "amrap", "emom", "tabata", "for time"]);
 var STANDARD_UNITS2 = UnitRegistry.standard();
@@ -1530,9 +1651,25 @@ function referenceMetadata(resolution) {
 function classifyStatements(facts, references) {
   return facts.statements.map((fact) => {
     const statement = new wodWikiCore.ParsedCodeStatement();
-    let metricPairs = [];
+    const slots = [];
     for (const primitive of fact.primitives) {
-      metricPairs.push(...classifyPrimitive(primitive));
+      slots.push(...classifySlots(primitive, references));
+    }
+    const explicitTypes = /* @__PURE__ */ new Set();
+    for (const slot of slots) {
+      if (slot.kind === "explicit") explicitTypes.add(slot.pair.metrics.type);
+    }
+    const contributedTypes = /* @__PURE__ */ new Set();
+    const metricPairs = [];
+    for (const slot of slots) {
+      if (slot.kind !== "contributed") {
+        metricPairs.push(slot.pair);
+        continue;
+      }
+      const type = slot.pair.metrics.type;
+      if (explicitTypes.has(type) || contributedTypes.has(type)) continue;
+      contributedTypes.add(type);
+      metricPairs.push(slot.pair);
     }
     const mergedPairs = mergeFragments(metricPairs);
     const finalPairs = references ? applyReferenceResolution(mergedPairs, fact, references) : mergedPairs;
@@ -1549,6 +1686,21 @@ function classifyStatements(facts, references) {
     return statement;
   });
 }
+function equipmentMeta(resolution, authored, meta2) {
+  if (resolution.matched !== "split" || !resolution.remaining) return meta2;
+  const prefixEnd = authored.trimEnd().length - resolution.remaining.length;
+  if (prefixEnd <= 0) return meta2;
+  const raw = meta2.raw.slice(0, prefixEnd).trimEnd();
+  const length = raw.length;
+  if (length <= 0) return meta2;
+  return {
+    ...meta2,
+    endOffset: meta2.startOffset + length,
+    length,
+    columnEnd: meta2.columnStart + length,
+    raw
+  };
+}
 function applyReferenceResolution(pairs, fact, references) {
   const { index, defaults } = references;
   const result = [];
@@ -1573,7 +1725,10 @@ function applyReferenceResolution(pairs, fact, references) {
             diagnostics: resolution.diagnostics
           }
         ),
-        meta: meta2
+        // 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)
       });
     }
   };
@@ -1703,14 +1858,7 @@ function classifyPrimitive(primitive) {
     case "effort":
       return [{ metrics: new EffortMetric(primitive.raw), meta: primitive.meta }];
     case "property": {
-      const metricType = PROPERTY_KEY_TO_METRIC_TYPE[primitive.key.toLowerCase()] ?? wodWikiCore.MetricType.Custom;
-      return [{
-        metrics: new PropertyMetric(primitive.key, primitive.value, {
-          type: metricType,
-          image: primitive.raw
-        }),
-        meta: primitive.meta
-      }];
+      return [propertyPair(primitive)];
     }
     case "metric_object": {
       const pairs = primitive.pairs;
@@ -1730,6 +1878,85 @@ function classifyPrimitive(primitive) {
       return [];
   }
 }
+function classifySlots(primitive, references) {
+  if (primitive.kind === "property" && primitive.tagRefs !== void 0) {
+    return propertyTagSlots(primitive, references);
+  }
+  if (primitive.kind === "tag_ref") {
+    return fragmentTagSlots(primitive, references);
+  }
+  return classifyPrimitive(primitive).map((pair) => ({ kind: "explicit", pair }));
+}
+function propertyTagSlots(primitive, references) {
+  const { slots, resolved } = referenceSlots(primitive.tagRefs ?? [], primitive.meta, references);
+  if (resolved) return slots;
+  return [{ kind: "explicit", pair: propertyPair(primitive) }];
+}
+function fragmentTagSlots(primitive, references) {
+  const { slots, resolved } = referenceSlots([primitive.slug], primitive.meta, references);
+  if (resolved) return slots;
+  return [{
+    kind: "explicit",
+    pair: {
+      metrics: {
+        type: wodWikiCore.MetricType.Custom,
+        value: primitive.raw,
+        origin: "parser",
+        image: primitive.raw
+      },
+      meta: primitive.meta
+    }
+  }];
+}
+function referenceSlots(slugs, meta2, references) {
+  const slots = [];
+  let resolved = false;
+  for (const slug of slugs) {
+    const contributions = resolveTagContributions(references?.tags, slug);
+    const reference = tagReferenceFor(references?.tags, slug);
+    const contributed = tagContributionMetrics(contributions.metrics);
+    if (contributed.length > 0) resolved = true;
+    for (const metric of contributed) {
+      slots.push({
+        kind: "contributed",
+        pair: { metrics: withTagReference(metric, reference), meta: meta2 }
+      });
+    }
+    for (const tag of contributions.tags) {
+      resolved = true;
+      const tagReference = tag === slug ? reference : tagReferenceFor(references?.tags, tag);
+      slots.push({
+        kind: "marker",
+        pair: {
+          metrics: withTagReference({
+            type: tagMarkerType(tag),
+            value: tag,
+            origin: "parser",
+            image: tag
+          }, tagReference),
+          meta: meta2
+        }
+      });
+    }
+  }
+  return { slots, resolved };
+}
+function withTagReference(metric, reference) {
+  return {
+    ...metric,
+    metadata: { ...metric.metadata ?? {}, [wodWikiCore.TAG_REFERENCE_METADATA_KEY]: reference }
+  };
+}
+function propertyPair(primitive) {
+  const metricType = PROPERTY_KEY_TO_METRIC_TYPE[primitive.key.toLowerCase()] ?? wodWikiCore.MetricType.Custom;
+  return {
+    metrics: new PropertyMetric(primitive.key, primitive.value, {
+      type: metricType,
+      image: primitive.raw
+    }),
+    meta: primitive.meta
+  };
+}
 function mergeFragments(pairs) {
   if (pairs.length < 2) return pairs;
   const result = [];
@@ -1809,33 +2036,34 @@ function mergeFragments(pairs) {
 }
 var parser = lr.LRParser.deserialize({
   version: 14,
-  states: "(WQVQPOOO!jQPO'#C}O#}QPO'#CcOOQO'#Cc'#CcOOQO'#Cf'#CfOOQO'#Cg'#CgOOQO'#Ce'#CeO%_QPO'#CeO%gQPO'#CiOOQO'#Ck'#CkOOQO'#C}'#C}OOQO'#Ct'#CtO%oQPO'#ClOOQO'#Cm'#CmOOQO'#Cn'#CnOOQO'#Cp'#CpOOQO'#Cq'#CqOOQO'#Co'#CoO%tQPO'#CoOOQO'#Cr'#CrOOQO'#Cs'#CsO&kQPO'#CuOOQO'#Cd'#CdOOQO'#Cz'#CzO(PQPO'#CbO&rQPO'#CbOOQO'#Cy'#CyQVQPOOO(WQPO,58xOOQO,59P,59PO(cQPO'#CjOOQO'#C{'#C{O(qQPO,59TOOQO-E6{-E6{O(|QPO,59WOOQO,59Z,59ZOOQO'#DO'#DOO)XQPO,59aOOQO,59a,59aOOQO-E6x-E6xOOQO,58|,58|O)`QPO,58|OOQO-E6w-E6wOOQO1G.d1G.dO)gQPO'#C|O)lQPO,59UOOQO-E6y-E6yOOQO1G.o1G.oO)zQPO1G.rOOQO-E6|-E6|OOQO1G.{1G.{OOQO1G.h1G.hOOQO,59h,59hOOQO-E6z-E6zOOQO7+$^7+$^",
-  stateData: "*u~OuOS~ORPOTaO[UOwQOxROySOzVO{TO|WO!OXO!PXO!Q[O!RYO!T]O!U^O!V_O!W`O!XcO!YdO!ZeO!^jO~OvlORqXTqX[qXwqXyqXzqX{qX|qX!OqX!PqX!QqX!RqX!TqX!UqX!VqX!WqX!XqX!YqX!ZqX!^qX~ORVXTVX[VXwVXyVXzVX{VX|VX!OVX!PVX!QVX!RVX!TVX!UVX!VVX!WVX!XVX!YVX!ZVX!^qX~O[mO{TO~ORoOTnO~OvrO~OTsO!W`O~ORtOStOTtOjtOktOltOvtO!RtO![tO~O!]vO~P%|ORYOTaO[UOwYOySOzVO{TO|WO!OXO!PXO!Q[O!RYO!T]O!U^O!V_O!W`O!XcO!YdO!ZeO~O!^xO~P&rOR{OS{OT{O~Ow|OR^XT^X}^X~ORoOTnO}!PO~ORYOwYO!RYO~O!]!SO~P%|O!^!TO~P&rOT!UO~Ow|OR^aT^a}^a~ORYOwYO!RYO!S!WO~O!T!U!O!P{[!Vyzv!X!Y!R!Z!]![jklRwxT!^u!R~",
-  goto: "$UsPPtPPPtx|!T![!cP!T!m!T!T!T!T!T!q!x!T!T!T!TPPP#S#Y#e#k#q$OTjOkTiOkZgOhikyZfOhikyZVOhikyYUOhikyRmVToWpZbOhikyYaOhikyRsbQkORzkShOkSwhyRyiQpWR!OpQ}nR!V}YZOhikyQq!QR!QrQueR!Ru",
-  nodeNames: "\u26A0 Program Property Identifier String Number Block Lap Fragment Duration Trend CollectibleTimer Timer Rounds Sequence RoundScheme Action Text Heading Quantity AtSign Question Slash Pipe Effort MetricObject True False Null",
-  maxTerm: 60,
+  states: "(dQVQPOOO!mQPO'#DPO$TQPO'#CdOOQO'#Cd'#CdOOQO'#Cg'#CgOOQO'#Ch'#ChOOQO'#Cf'#CfO%hQPO'#CfO%pQPO'#CjOOQO'#Cl'#ClOOQO'#DP'#DPOOQO'#Cu'#CuO%xQPO'#CmOOQO'#Cn'#CnOOQO'#Co'#CoOOQO'#Cq'#CqOOQO'#Cr'#CrOOQO'#Cp'#CpO%}QPO'#CpOOQO'#Cs'#CsOOQO'#Ct'#CtO&tQPO'#CvOOQO'#Ce'#CeOOQO'#C|'#C|O(]QPO'#CcO&{QPO'#CcOOQO'#Cz'#CzQVQPOOO(dQPO,58xOOQO,59Q,59QO(rQPO'#CkOOQO'#C}'#C}O)QQPO,59UOOQO-E6}-E6}O)]QPO,59XOOQO,59[,59[OOQO'#DQ'#DQO)hQPO,59bOOQO,59b,59bOOQO-E6z-E6zOOQO,58},58}O)oQPO,58}OOQO-E6x-E6xOOQO'#C{'#C{OOQO1G.d1G.dO)vQPO'#DOO){QPO,59VOOQO-E6{-E6{OOQO1G.p1G.pO*ZQPO1G.sOOQO-E7O-E7OOOQO1G.|1G.|OOQO1G.i1G.iPOQO-E6y-E6yOOQO,59j,59jOOQO-E6|-E6|OOQO7+$_7+$_",
+  stateData: "+V~OwOS~ORPOTaOUfO]UOyQOzRO{SO|VO}TO!OWO!QXO!RXO!S[O!TYO!V]O!W^O!X_O!Y`O!ZcO![dO!]eO!`jO~OxlORsXTsXUsX]sXysX{sX|sX}sX!OsX!QsX!RsX!SsX!TsX!VsX!WsX!XsX!YsX!ZsX![sX!]sX!`sX~ORWXTWXUWX]WXyWX{WX|WX}WX!OWX!QWX!RWX!SWX!TWX!VWX!WWX!XWX!YWX!ZWX![WX!]WX!`sX~O]mO}TO~ORoOTnO~OxrO~OTsO!Y`O~ORtOStOTtOktOltOmtOxtO!TtO!^tO~O!_vO~P&VORYOTaOUfO]UOyYO{SO|VO}TO!OWO!QXO!RXO!S[O!TYO!V]O!W^O!X_O!Y`O!ZcO![dO!]eO~O!`xO~P&{OR|OS|OT|OU{O~Oy}OR_XT_X!P_X~ORoOTnO!P!QO~ORYOyYO!TYO~O!_!TO~P&VO!`!UO~P&{OT!WO~Oy}OR_aT_a!P_a~ORYOyYO!TYO!U!YO~O!VU!W!Q!R}]!X{|x!Z![!T!]!_!^klmRyzT!`w!T~",
+  goto: "$ZuPPvPPPPvz!O!V!^!eP!V!o!V!V!V!V!V!s!z!V!V!V!VPPP#U#[#_#j#p#v$TTjOkTiOkZgOhikyZfOhikyZVOhikyYUOhikyRmVToWpZbOhikyYaOhikyRsbQkORzkR|lShOkSwhyRyiQpWR!PpQ!OnR!X!OYZOhikyQq!RR!RrQueR!Su",
+  nodeNames: "\u26A0 Program Property Identifier String Number TagRef Block Lap Fragment Duration Trend CollectibleTimer Timer Rounds Sequence RoundScheme Action Text Heading Quantity AtSign Question Slash Pipe Effort MetricObject True False Null",
+  maxTerm: 62,
   skippedNodes: [0],
-  repeatNodeCount: 6,
-  tokenData: "6k~RvXY#iYZ#z]^$Ppq#iqr$Vrs$}st'dtu$Vuv$Vvw$Vxy(Oyz(Tz{(Y{|)S|})X}!O*R!O!P*W!P!Q+Z!Q![+}![!].Q!_!`$V!a!b.j!b!c.o!c!}/i!}#O/w#O#P$V#P#Q/|#Q#R0R#T#Y/i#Y#Z0{#Z#b/i#b#c2|#c#h/i#h#i4l#i#o/i#o#p6[#p#q6a#q#r6f~#nSu~XY#iYZ#z]^$Ppq#i~$PO!^~~$SPYZ#z~$[Z!R~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!_!`$V!b!c$V#O#P$V#Q#R$V~%QXOY$}Z]$}^r$}rs%ms#O$}#O#P&_#P;'S$};'S;=`'^<%lO$}~%rXS~OY$}Z]$}^r$}rs%ms#O$}#O#P&_#P;'S$};'S;=`'^<%lO$}~&bRO;'S$};'S;=`&k;=`O$}~&nYOY$}Z]$}^r$}rs%ms#O$}#O#P&_#P;'S$};'S;=`'^;=`<%l$}<%lO$}~'aP;=`<%l$}~'iT!U~OY'dZ]'d^;'S'd;'S;=`'x<%lO'd~'{P;=`<%l'd~(TO|~~(YO}~~(aZz~!R~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!_!`$V!b!c$V#O#P$V#Q#R$V~)XOx~~)`Z!R~![~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!_!`$V!b!c$V#O#P$V#Q#R$V~*WOw~~*][!R~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!Q![+R!_!`$V!b!c$V#O#P$V#Q#R$V~+WPT~!Q![+R~+`P!X~!P!Q+c~+hT!T~OY+cZ]+c^;'S+c;'S;=`+w<%lO+c~+zP;=`<%l+c~,SUT~pq,f!O!P-Z!Q![+}![!]-a!z!{-r#l#m-r~,iRpq,f!z!{,r#l#m,r~,uPpq,x~,{Qpq,x!Q![-R~-WP!P~!Q![-R~-^P!Q![+R~-dP!Q![-g~-lQ[~!Q![-g![!]-a~-uP!Q![-x~-}P!O~!Q![-x~.VQv~!Q![.]!a!b.e~.bP[~!Q![.]~.jO{~~.oO!W~~.vZ!V~!R~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!_!`$V!b!c$V#O#P$V#Q#R$V~/nRR~!Q![/i!c!}/i#T#o/i~/|O!Q~~0RO!S~~0YZy~!R~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!_!`$V!b!c$V#O#P$V#Q#R$V~1QSR~!Q![/i!c!}/i#T#U1^#U#o/i~1cTR~!Q![/i!c!}/i#T#`/i#`#a1r#a#o/i~1wTR~!Q![/i!c!}/i#T#g/i#g#h2W#h#o/i~2]TR~!Q![/i!c!}/i#T#X/i#X#Y2l#Y#o/i~2sRk~R~!Q![/i!c!}/i#T#o/i~3RTR~!Q![/i!c!}/i#T#i/i#i#j3b#j#o/i~3gTR~!Q![/i!c!}/i#T#`/i#`#a3v#a#o/i~3{TR~!Q![/i!c!}/i#T#`/i#`#a4[#a#o/i~4cRl~R~!Q![/i!c!}/i#T#o/i~4qTR~!Q![/i!c!}/i#T#f/i#f#g5Q#g#o/i~5VTR~!Q![/i!c!}/i#T#i/i#i#j5f#j#o/i~5kTR~!Q![/i!c!}/i#T#X/i#X#Y5z#Y#o/i~6RRj~R~!Q![/i!c!}/i#T#o/i~6aO!Z~~6fO!Y~~6kO!]~",
+  repeatNodeCount: 7,
+  tokenData: "7o~RvXY#iYZ#z]^$Ppq#iqr$Vrs$}st'dtu$Vuv$Vvw$Vxy)Pyz)Uz{)Z{|*T|}*Y}!O+S!O!P+X!P!Q,[!Q![-R![!]/U!_!`$V!a!b/n!b!c/s!c!}0m!}#O0{#O#P$V#P#Q1Q#Q#R1V#T#Y0m#Y#Z2P#Z#b0m#b#c4Q#c#h0m#h#i5p#i#o0m#o#p7`#p#q7e#q#r7j~#nSw~XY#iYZ#z]^$Ppq#i~$PO!`~~$SPYZ#z~$[Z!T~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!_!`$V!b!c$V#O#P$V#Q#R$V~%QXOY$}Z]$}^r$}rs%ms#O$}#O#P&_#P;'S$};'S;=`'^<%lO$}~%rXS~OY$}Z]$}^r$}rs%ms#O$}#O#P&_#P;'S$};'S;=`'^<%lO$}~&bRO;'S$};'S;=`&k;=`O$}~&nYOY$}Z]$}^r$}rs%ms#O$}#O#P&_#P;'S$};'S;=`'^;=`<%l$}<%lO$}~'aP;=`<%l$}~'gXO!Q(S!Q![(n![!c(S!c!}(n!}#T(S#T#o(n#o;'S(S;'S;=`(h<%lO(S~(XT!W~OY(SZ](S^;'S(S;'S;=`(h<%lO(S~(kP;=`<%l(S~(sSU~}!O(n!Q![(n!c!}(n#T#o(n~)UO!O~~)ZO!P~~)bZ|~!T~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!_!`$V!b!c$V#O#P$V#Q#R$V~*YOz~~*aZ!T~!^~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!_!`$V!b!c$V#O#P$V#Q#R$V~+XOy~~+^[!T~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!Q![,S!_!`$V!b!c$V#O#P$V#Q#R$V~,XPT~!Q![,S~,aP!Z~!P!Q,d~,iU!V~OY,dZ],d^s,dt;'S,d;'S;=`,{<%lO,d~-OP;=`<%l,d~-WUT~pq-j!O!P._!Q![-R![!].e!z!{.v#l#m.v~-mRpq-j!z!{-v#l#m-v~-yPpq-|~.PQpq-|!Q![.V~.[P!R~!Q![.V~.bP!Q![,S~.hP!Q![.k~.pQ]~!Q![.k![!].e~.yP!Q![.|~/RP!Q~!Q![.|~/ZQx~!Q![/a!a!b/i~/fP]~!Q![/a~/nO}~~/sO!Y~~/zZ!X~!T~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!_!`$V!b!c$V#O#P$V#Q#R$V~0rRR~!Q![0m!c!}0m#T#o0m~1QO!S~~1VO!U~~1^Z{~!T~qr$Vtu$Vuv$Vvw$Vz{$V|}$V!O!P$V!_!`$V!b!c$V#O#P$V#Q#R$V~2USR~!Q![0m!c!}0m#T#U2b#U#o0m~2gTR~!Q![0m!c!}0m#T#`0m#`#a2v#a#o0m~2{TR~!Q![0m!c!}0m#T#g0m#g#h3[#h#o0m~3aTR~!Q![0m!c!}0m#T#X0m#X#Y3p#Y#o0m~3wRl~R~!Q![0m!c!}0m#T#o0m~4VTR~!Q![0m!c!}0m#T#i0m#i#j4f#j#o0m~4kTR~!Q![0m!c!}0m#T#`0m#`#a4z#a#o0m~5PTR~!Q![0m!c!}0m#T#`0m#`#a5`#a#o0m~5gRm~R~!Q![0m!c!}0m#T#o0m~5uTR~!Q![0m!c!}0m#T#f0m#f#g6U#g#o0m~6ZTR~!Q![0m!c!}0m#T#i0m#i#j6j#j#o0m~6oTR~!Q![0m!c!}0m#T#X0m#X#Y7O#Y#o0m~7VRk~R~!Q![0m!c!}0m#T#o0m~7eO!]~~7jO![~~7oO!_~",
   tokenizers: [0],
   topRules: { "Program": [0, 1] },
-  tokenPrec: 424
+  tokenPrec: 439
 });
 
 // src/grammar/parser.terms.ts
-var Lap = 7;
-var Fragment = 8;
-var Duration = 9;
-var Rounds = 13;
-var RoundScheme = 15;
-var Action = 16;
-var Text = 17;
-var Heading = 18;
-var Quantity = 19;
-var Slash = 22;
-var Pipe = 23;
-var Effort = 24;
-var MetricObject = 25;
+var TagRef = 6;
+var Lap = 8;
+var Fragment = 9;
+var Duration = 10;
+var Rounds = 14;
+var RoundScheme = 16;
+var Action = 17;
+var Text = 18;
+var Heading = 19;
+var Quantity = 20;
+var Slash = 23;
+var Pipe = 24;
+var Effort = 25;
+var MetricObject = 26;
 
 // src/parser/syntax-parser.ts
 function createLineLocator(source) {
@@ -1941,15 +2169,28 @@ function createPropertyPrimitive(locator, source, from, to) {
   const match = raw.match(/^\s*([A-Za-z][A-Za-z0-9]*)\s*:\s*(.*?)\s*$/);
   if (!match) return null;
   const [, key, rawValue] = match;
+  const tagRefs = parseTagRefs(rawValue);
   return {
     kind: "property",
     raw,
     meta: meta2,
     key,
     valueRaw: rawValue,
-    value: parsePropertyValue(rawValue)
+    value: tagRefs !== void 0 ? rawValue.trim() : parsePropertyValue(rawValue),
+    ...tagRefs !== void 0 ? { tagRefs } : {}
   };
 }
+function parseTagRefs(rawValue) {
+  const parts = rawValue.trim().split(/\s+/).filter((part) => part.length > 0);
+  if (parts.length === 0) return void 0;
+  const slugs = [];
+  for (const part of parts) {
+    const match = part.match(/^#([a-zA-Z0-9][a-zA-Z0-9-]*)$/);
+    if (!match) return void 0;
+    slugs.push(match[1]);
+  }
+  return slugs;
+}
 function parsePropertyValue(rawValue) {
   const trimmed = rawValue.trim();
   if (/^"(?:[^"\\]|\\.)*"$/.test(trimmed)) {
@@ -2049,6 +2290,17 @@ function mapFragmentToPrimitive(locator, source, node) {
       };
       return primitive;
     }
+    case TagRef: {
+      const match = raw.match(/^#([a-zA-Z0-9][a-zA-Z0-9-]*)$/);
+      if (!match) return null;
+      const primitive = {
+        kind: "tag_ref",
+        raw,
+        meta: meta2,
+        slug: match[1]
+      };
+      return primitive;
+    }
     case Slash: {
       const primitive = {
         kind: "effort",
@@ -2289,269 +2541,743 @@ var WhiteboardScript = class {
   }
 };
 
-// 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 ? { 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";
-    return new WhiteboardScript(inputText, [], [{ message: msg }]);
+// 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,
+  defaultThreshold: 2
+};
 
-// src/parser/md-timer.ts
-var MdTimerRuntime = class {
-  config;
-  constructor(config) {
-    this.config = config;
+// 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;
   }
-  /**
-   * 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 });
+  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 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 });
+  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;
   }
-};
-
-// src/parser/parserInstance.ts
-function createParser(config) {
-  return new MdTimerRuntime(config);
+  return prev[m];
 }
-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;
+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;
+    }
   }
-  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;
+  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);
   }
-  /**
-  Define a tag _modifier_, which is a function that, given a tag,
-  will return a tag that is a subtag of the original. Applying the
-  same modifier to a twice tag will return the same value (`m1(t1)
-  == m1(t1)`) and applying multiple modifiers will, regardless or
-  order, produce the same tag (`m1(m2(t1)) == m2(m1(t1))`).
-  
-  When multiple modifiers are applied to a given base tag, each
-  smaller set of modifiers is registered as a parent, so that for
-  example `m1(m2(m3(t1)))` is a subtype of `m1(m2(t1))`,
-  `m1(m3(t1)`, and so on.
-  */
-  static defineModifier(name2) {
-    let mod = new Modifier(name2);
-    return (tag) => {
-      if (tag.modified.indexOf(mod) > -1)
-        return tag;
-      return Modifier.get(tag.base || tag, tag.modified.concat(mod).sort((a, b) => a.id - b.id));
-    };
-  }
-};
-var nextModifierID = 0;
-var Modifier = class _Modifier {
-  constructor(name2) {
-    this.name = name2;
-    this.instances = [];
-    this.id = nextModifierID++;
-  }
-  static get(base, mods) {
-    if (!mods.length)
-      return base;
-    let exists = mods[0].instances.find((t2) => t2.base == base && sameArray(mods, t2.modified));
-    if (exists)
-      return exists;
-    let set = [], tag = new Tag(base.name, set, base, mods);
-    for (let m of mods)
-      m.instances.push(tag);
-    let configs = powerSet(mods);
-    for (let parent of base.set)
-      if (!parent.modified.length)
-        for (let config of configs)
-          set.push(_Modifier.get(parent, config));
-    return tag;
-  }
-};
-function sameArray(a, b) {
-  return a.length == b.length && a.every((x, i) => x == b[i]);
-}
-function powerSet(array) {
-  let sets = [[]];
-  for (let i = 0; i < array.length; i++) {
-    for (let j = 0, e = sets.length; j < e; j++) {
-      sets.push(sets[j].concat(array[i]));
+  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 sets.sort((a, b) => b.length - a.length);
+  return result;
 }
-function styleTags(spec) {
-  let byName = /* @__PURE__ */ Object.create(null);
-  for (let prop in spec) {
-    let tags2 = spec[prop];
-    if (!Array.isArray(tags2))
-      tags2 = [tags2];
-    for (let part of prop.split(" "))
-      if (part) {
-        let pieces = [], mode = 2, rest = part;
-        for (let pos = 0; ; ) {
-          if (rest == "..." && pos > 0 && pos + 3 == part.length) {
-            mode = 1;
-            break;
-          }
-          let m = /^"(?:[^"\\]|\\.)*?"|[^\/!]+/.exec(rest);
-          if (!m)
-            throw new RangeError("Invalid path: " + part);
-          pieces.push(m[0] == "*" ? "" : m[0][0] == '"' ? JSON.parse(m[0]) : m[0]);
-          pos += m[0].length;
-          if (pos == part.length)
-            break;
-          let next = part[pos++];
-          if (pos == part.length && next == "!") {
-            mode = 0;
-            break;
-          }
-          if (next != "/")
-            throw new RangeError("Invalid path: " + part);
-          rest = part.slice(pos);
+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)
         }
-        let last = pieces.length - 1, inner = pieces[last];
-        if (!inner)
-          throw new RangeError("Invalid path: " + part);
-        let rule = new Rule(tags2, mode, last > 0 ? pieces.slice(0, last) : null);
-        byName[inner] = rule.sort(byName[inner]);
+      };
+    }
+    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;
       }
-  }
-  return ruleNodeProp.add(byName);
-}
-var ruleNodeProp = new common.NodeProp({
-  combine(a, b) {
-    let cur, root, take;
-    while (a || b) {
-      if (!a || b && a.depth >= b.depth) {
-        take = b;
-        b = b.next;
+      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 {
-        take = a;
-        a = a.next;
+        diagnostics.push({
+          reason: "invalid-explicit",
+          message: `Unknown equipment "${value}".`,
+          token: value
+        });
       }
-      if (cur && cur.mode == take.mode && !take.context && !cur.context)
-        continue;
-      let copy = new Rule(take.tags, take.mode, take.context);
-      if (cur)
-        cur.next = copy;
-      else
-        root = copy;
-      cur = copy;
-    }
-    return root;
-  }
-});
-var Rule = class {
-  constructor(tags2, mode, context, next) {
-    this.tags = tags2;
-    this.mode = mode;
-    this.context = context;
-    this.next = next;
-  }
-  get opaque() {
-    return this.mode == 0;
-  }
-  get inherit() {
-    return this.mode == 1;
-  }
-  sort(other) {
-    if (!other || other.depth < this.depth) {
-      this.next = other;
-      return this;
     }
-    other.next = this.sort(other.next);
-    return other;
-  }
-  get depth() {
-    return this.context ? this.context.length : 0;
-  }
-};
-Rule.empty = new Rule([], 2, null);
-function tagHighlighter(tags2, options) {
-  let map = /* @__PURE__ */ Object.create(null);
-  for (let style of tags2) {
-    if (!Array.isArray(style.tag))
-      map[style.tag.id] = style.class;
-    else
-      for (let tag of style.tag)
-        map[tag.id] = style.class;
-  }
-  let { scope, all = null } = {};
-  return {
-    style: (tags3) => {
-      let cls = all;
-      for (let tag of tags3) {
-        for (let sub of tag.set) {
-          let tagClass = map[sub.id];
-          if (tagClass) {
-            cls = cls ? cls + " " + tagClass : tagClass;
-            break;
-          }
-        }
-      }
-      return cls;
-    },
-    scope
+    return { refs: dedupeRefs(refs), diagnostics };
   };
-}
-var t = Tag.define;
-var comment = t();
-var name = t();
-var typeName = t(name);
-var propertyName = t(name);
-var literal = t();
-var string = t(literal);
-var number = t(literal);
-var content = t();
-var heading = t(content);
-var keyword = t();
-var operator = t();
-var punctuation = t();
+  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;
+  }
+  /**
+  Define a tag _modifier_, which is a function that, given a tag,
+  will return a tag that is a subtag of the original. Applying the
+  same modifier to a twice tag will return the same value (`m1(t1)
+  == m1(t1)`) and applying multiple modifiers will, regardless or
+  order, produce the same tag (`m1(m2(t1)) == m2(m1(t1))`).
+  
+  When multiple modifiers are applied to a given base tag, each
+  smaller set of modifiers is registered as a parent, so that for
+  example `m1(m2(m3(t1)))` is a subtype of `m1(m2(t1))`,
+  `m1(m3(t1)`, and so on.
+  */
+  static defineModifier(name2) {
+    let mod = new Modifier(name2);
+    return (tag) => {
+      if (tag.modified.indexOf(mod) > -1)
+        return tag;
+      return Modifier.get(tag.base || tag, tag.modified.concat(mod).sort((a, b) => a.id - b.id));
+    };
+  }
+};
+var nextModifierID = 0;
+var Modifier = class _Modifier {
+  constructor(name2) {
+    this.name = name2;
+    this.instances = [];
+    this.id = nextModifierID++;
+  }
+  static get(base, mods) {
+    if (!mods.length)
+      return base;
+    let exists = mods[0].instances.find((t2) => t2.base == base && sameArray(mods, t2.modified));
+    if (exists)
+      return exists;
+    let set = [], tag = new Tag(base.name, set, base, mods);
+    for (let m of mods)
+      m.instances.push(tag);
+    let configs = powerSet(mods);
+    for (let parent of base.set)
+      if (!parent.modified.length)
+        for (let config of configs)
+          set.push(_Modifier.get(parent, config));
+    return tag;
+  }
+};
+function sameArray(a, b) {
+  return a.length == b.length && a.every((x, i) => x == b[i]);
+}
+function powerSet(array) {
+  let sets = [[]];
+  for (let i = 0; i < array.length; i++) {
+    for (let j = 0, e = sets.length; j < e; j++) {
+      sets.push(sets[j].concat(array[i]));
+    }
+  }
+  return sets.sort((a, b) => b.length - a.length);
+}
+function styleTags(spec) {
+  let byName = /* @__PURE__ */ Object.create(null);
+  for (let prop in spec) {
+    let tags2 = spec[prop];
+    if (!Array.isArray(tags2))
+      tags2 = [tags2];
+    for (let part of prop.split(" "))
+      if (part) {
+        let pieces = [], mode = 2, rest = part;
+        for (let pos = 0; ; ) {
+          if (rest == "..." && pos > 0 && pos + 3 == part.length) {
+            mode = 1;
+            break;
+          }
+          let m = /^"(?:[^"\\]|\\.)*?"|[^\/!]+/.exec(rest);
+          if (!m)
+            throw new RangeError("Invalid path: " + part);
+          pieces.push(m[0] == "*" ? "" : m[0][0] == '"' ? JSON.parse(m[0]) : m[0]);
+          pos += m[0].length;
+          if (pos == part.length)
+            break;
+          let next = part[pos++];
+          if (pos == part.length && next == "!") {
+            mode = 0;
+            break;
+          }
+          if (next != "/")
+            throw new RangeError("Invalid path: " + part);
+          rest = part.slice(pos);
+        }
+        let last = pieces.length - 1, inner = pieces[last];
+        if (!inner)
+          throw new RangeError("Invalid path: " + part);
+        let rule = new Rule(tags2, mode, last > 0 ? pieces.slice(0, last) : null);
+        byName[inner] = rule.sort(byName[inner]);
+      }
+  }
+  return ruleNodeProp.add(byName);
+}
+var ruleNodeProp = new common.NodeProp({
+  combine(a, b) {
+    let cur, root, take;
+    while (a || b) {
+      if (!a || b && a.depth >= b.depth) {
+        take = b;
+        b = b.next;
+      } else {
+        take = a;
+        a = a.next;
+      }
+      if (cur && cur.mode == take.mode && !take.context && !cur.context)
+        continue;
+      let copy = new Rule(take.tags, take.mode, take.context);
+      if (cur)
+        cur.next = copy;
+      else
+        root = copy;
+      cur = copy;
+    }
+    return root;
+  }
+});
+var Rule = class {
+  constructor(tags2, mode, context, next) {
+    this.tags = tags2;
+    this.mode = mode;
+    this.context = context;
+    this.next = next;
+  }
+  get opaque() {
+    return this.mode == 0;
+  }
+  get inherit() {
+    return this.mode == 1;
+  }
+  sort(other) {
+    if (!other || other.depth < this.depth) {
+      this.next = other;
+      return this;
+    }
+    other.next = this.sort(other.next);
+    return other;
+  }
+  get depth() {
+    return this.context ? this.context.length : 0;
+  }
+};
+Rule.empty = new Rule([], 2, null);
+function tagHighlighter(tags2, options) {
+  let map = /* @__PURE__ */ Object.create(null);
+  for (let style of tags2) {
+    if (!Array.isArray(style.tag))
+      map[style.tag.id] = style.class;
+    else
+      for (let tag of style.tag)
+        map[tag.id] = style.class;
+  }
+  let { scope, all = null } = {};
+  return {
+    style: (tags3) => {
+      let cls = all;
+      for (let tag of tags3) {
+        for (let sub of tag.set) {
+          let tagClass = map[sub.id];
+          if (tagClass) {
+            cls = cls ? cls + " " + tagClass : tagClass;
+            break;
+          }
+        }
+      }
+      return cls;
+    },
+    scope
+  };
+}
+var t = Tag.define;
+var comment = t();
+var name = t();
+var typeName = t(name);
+var propertyName = t(name);
+var literal = t();
+var string = t(literal);
+var number = t(literal);
+var content = t();
+var heading = t(content);
+var keyword = t();
+var operator = t();
+var punctuation = t();
 var bracket = t(punctuation);
 var meta = t();
 var tags = {
@@ -2996,50 +3722,6 @@ function whiteboardScript() {
   return new language.LanguageSupport(whiteboardScriptLanguage);
 }
 
-// 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,
-  defaultThreshold: 2
-};
-
 // src/effort-registry/disciplines.ts
 var EFFORT_DISCIPLINES = [
   "bodyweight",
@@ -3493,71 +4175,6 @@ function equipmentToDocument(equipment) {
   }
   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, "-");
 }
@@ -3770,162 +4387,64 @@ var fixtureUserOverride = {
   label: "Rowing (Calibrated)",
   aliases: ["row", "rower", "erg"],
   baseAttributes: { met: 8.5, discipline: "rowing", intensityTier: "high" },
-  registrySource: "user",
-  createdAt: "2024-02-01T08:00:00Z",
-  updatedAt: "2024-02-01T08:00:00Z"
-};
-var commonFixtureSet = [
-  fixtureRunning,
-  fixtureRowing,
-  fixtureBackSquat,
-  fixtureBurpee,
-  fixturePlank
-];
-var fullFixtureSet = [
-  ...commonFixtureSet,
-  fixtureUserCustom,
-  fixtureUserOverride
-];
-
-// src/effort-registry/data/bundled-efforts.ts
-var bundledEfforts = commonFixtureSet;
-var BUNDLED_EFFORT_COUNT = bundledEfforts.length;
-
-// src/effort-registry/InMemoryEffortRegistry.ts
-var InMemoryEffortRegistry = class {
-  efforts = /* @__PURE__ */ new Map();
-  sourceFilter = null;
-  initialized = false;
-  constructor(sourceFilter) {
-    this.sourceFilter = sourceFilter ?? null;
-  }
-  /** Seed with bundled efforts */
-  async loadBundled() {
-    for (const effort of bundledEfforts) {
-      if (!this.sourceFilter || effort.registrySource === this.sourceFilter) {
-        this.efforts.set(effort.slug, effort);
-      }
-    }
-    this.initialized = true;
-  }
-  isInitialized() {
-    return this.initialized;
-  }
-  /** Seed with arbitrary efforts (useful for tests) */
-  seed(efforts) {
-    for (const effort of efforts) {
-      this.efforts.set(effort.slug, effort);
-    }
-  }
-  /** Clear all efforts */
-  clear() {
-    this.efforts.clear();
-    this.initialized = false;
-  }
-  resolve(slug) {
-    return this.efforts.get(slug) ?? null;
-  }
-  resolveByAlias(label) {
-    const normalized = normalizeForFuzzy(label);
-    for (const effort of this.efforts.values()) {
-      if (normalizeForFuzzy(effort.label) === normalized) return effort;
-      for (const alias of effort.aliases) {
-        if (normalizeForFuzzy(alias) === normalized) return effort;
-      }
-    }
-    return null;
-  }
-  list() {
-    return Array.from(this.efforts.values());
-  }
-  listByOrigin(origin) {
-    return this.list().filter((e) => e.registrySource === origin);
-  }
-  async upsert(effort) {
-    if (effort.registrySource !== "user") {
-      throw new Error(
-        `InMemoryEffortRegistry.upsert: only user efforts can be written. Received registrySource="${effort.registrySource}"`
-      );
-    }
-    this.efforts.set(effort.slug, effort);
-  }
-  async delete(slug) {
-    const existing = this.efforts.get(slug);
-    if (existing && existing.registrySource !== "user") {
-      throw new Error(
-        `InMemoryEffortRegistry.delete: cannot delete non-user effort "${slug}"`
-      );
-    }
-    this.efforts.delete(slug);
-  }
-};
-
-// src/effort-registry/CompositeEffortRegistry.ts
-var CompositeEffortRegistry = class {
-  userEfforts = /* @__PURE__ */ new Map();
-  bundledEfforts = /* @__PURE__ */ new Map();
-  initialized = false;
-  initialBundled;
-  storage;
-  constructor(options) {
-    if (options) {
-      this.initialBundled = options.bundled;
-      this.storage = options.storage;
-    }
-  }
-  /**
-   * 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) {
-    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();
-        for (const effort of userEfforts) {
-          if (effort.registrySource === "user") {
-            this.userEfforts.set(effort.slug, effort);
-          }
-        }
-      } catch (err) {
-        console.warn("[CompositeEffortRegistry] Failed to load user efforts from storage adapter:", err);
+  registrySource: "user",
+  createdAt: "2024-02-01T08:00:00Z",
+  updatedAt: "2024-02-01T08:00:00Z"
+};
+var commonFixtureSet = [
+  fixtureRunning,
+  fixtureRowing,
+  fixtureBackSquat,
+  fixtureBurpee,
+  fixturePlank
+];
+var fullFixtureSet = [
+  ...commonFixtureSet,
+  fixtureUserCustom,
+  fixtureUserOverride
+];
+
+// src/effort-registry/data/bundled-efforts.ts
+var bundledEfforts = commonFixtureSet;
+var BUNDLED_EFFORT_COUNT = bundledEfforts.length;
+
+// src/effort-registry/InMemoryEffortRegistry.ts
+var InMemoryEffortRegistry = class {
+  efforts = /* @__PURE__ */ new Map();
+  sourceFilter = null;
+  initialized = false;
+  constructor(sourceFilter) {
+    this.sourceFilter = sourceFilter ?? null;
+  }
+  /** Seed with bundled efforts */
+  async loadBundled() {
+    for (const effort of bundledEfforts) {
+      if (!this.sourceFilter || effort.registrySource === this.sourceFilter) {
+        this.efforts.set(effort.slug, effort);
       }
     }
     this.initialized = true;
   }
-  /** True after loadBundled() has resolved */
   isInitialized() {
     return this.initialized;
   }
+  /** Seed with arbitrary efforts (useful for tests) */
+  seed(efforts) {
+    for (const effort of efforts) {
+      this.efforts.set(effort.slug, effort);
+    }
+  }
+  /** Clear all efforts */
+  clear() {
+    this.efforts.clear();
+    this.initialized = false;
+  }
   resolve(slug) {
-    return this.userEfforts.get(slug) ?? this.bundledEfforts.get(slug) ?? null;
+    return this.efforts.get(slug) ?? null;
   }
   resolveByAlias(label) {
     const normalized = normalizeForFuzzy(label);
-    for (const effort of this.userEfforts.values()) {
-      if (normalizeForFuzzy(effort.label) === normalized) return effort;
-      for (const alias of effort.aliases) {
-        if (normalizeForFuzzy(alias) === normalized) return effort;
-      }
-    }
-    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) {
+    for (const effort of this.efforts.values()) {
       if (normalizeForFuzzy(effort.label) === normalized) return effort;
       for (const alias of effort.aliases) {
         if (normalizeForFuzzy(alias) === normalized) return effort;
@@ -3934,456 +4453,193 @@ var CompositeEffortRegistry = class {
     return null;
   }
   list() {
-    const merged = new Map(this.bundledEfforts);
-    for (const [slug, effort] of this.userEfforts) {
-      merged.set(slug, effort);
-    }
-    return Array.from(merged.values());
+    return Array.from(this.efforts.values());
   }
   listByOrigin(origin) {
-    if (origin === "user") {
-      return Array.from(this.userEfforts.values());
-    }
-    if (origin === "bundled") {
-      return Array.from(this.bundledEfforts.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.userEfforts.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}"`
+        `InMemoryEffortRegistry.upsert: only user efforts can be written. Received registrySource="${effort.registrySource}"`
       );
     }
-    this.userEfforts.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`);
-  }
-  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: {}
-      }
-    };
-    await registry.upsert(userEffort);
-    return userEffort;
-  }
-  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);
-  }
-  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);
+    this.efforts.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
-        });
-      }
+  async delete(slug) {
+    const existing = this.efforts.get(slug);
+    if (existing && existing.registrySource !== "user") {
+      throw new Error(
+        `InMemoryEffortRegistry.delete: cannot delete non-user effort "${slug}"`
+      );
     }
-    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
-        };
+    this.efforts.delete(slug);
+  }
+};
+
+// src/effort-registry/CompositeEffortRegistry.ts
+var CompositeEffortRegistry = class {
+  userEfforts = /* @__PURE__ */ new Map();
+  bundledEfforts = /* @__PURE__ */ new Map();
+  initialized = false;
+  initialBundled;
+  storage;
+  constructor(options) {
+    if (options) {
+      this.initialBundled = options.bundled;
+      this.storage = options.storage;
+    }
+  }
+  /**
+   * 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) {
+    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);
       }
-      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
-                });
-              }
-            }
+    }
+    this.userEfforts.clear();
+    if (this.storage) {
+      try {
+        const userEfforts = await this.storage.load();
+        for (const effort of userEfforts) {
+          if (effort.registrySource === "user") {
+            this.userEfforts.set(effort.slug, effort);
           }
-          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
-          };
         }
+      } catch (err) {
+        console.warn("[CompositeEffortRegistry] Failed to load user efforts 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);
-        }
+    }
+    this.initialized = true;
+  }
+  /** True after loadBundled() has resolved */
+  isInitialized() {
+    return this.initialized;
+  }
+  resolve(slug) {
+    return this.userEfforts.get(slug) ?? this.bundledEfforts.get(slug) ?? null;
+  }
+  resolveByAlias(label) {
+    const normalized = normalizeForFuzzy(label);
+    for (const effort of this.userEfforts.values()) {
+      if (normalizeForFuzzy(effort.label) === normalized) return effort;
+      for (const alias of effort.aliases) {
+        if (normalizeForFuzzy(alias) === normalized) return effort;
       }
-      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);
+    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;
       }
     }
+    return null;
+  }
+  list() {
+    const merged = new Map(this.bundledEfforts);
+    for (const [slug, effort] of this.userEfforts) {
+      merged.set(slug, effort);
+    }
+    return Array.from(merged.values());
   }
-  return { efforts, equipment };
-}
-function slugifyRefLabel(label) {
-  return normalizeForFuzzy(label).replace(/\s+/g, "-");
+  listByOrigin(origin) {
+    if (origin === "user") {
+      return Array.from(this.userEfforts.values());
+    }
+    if (origin === "bundled") {
+      return Array.from(this.bundledEfforts.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.userEfforts.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.userEfforts.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`);
+  }
+  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: {}
+      }
+    };
+    await registry.upsert(userEffort);
+    return userEffort;
+  }
+  const updatedUserEffort = {
+    ...existing,
+    aliases: updatedAliases,
+    updatedAt: now
+  };
+  await registry.upsert(updatedUserEffort);
+  return updatedUserEffort;
 }
 
 // src/runtime/contracts/IRuntimeOptions.ts
@@ -6547,6 +6803,8 @@ var RuntimeBlock = class {
   blockType;
   context;
   sourceIds;
+  /** The tags this block's statements referenced, resolved at compile time. */
+  tagComposition;
   // List-based memory storage
   _memory = [];
   /**
@@ -6583,13 +6841,15 @@ var RuntimeBlock = class {
       key,
       blockType,
       label,
-      metrics
+      metrics,
+      tagComposition
     } = options;
     this._runtime = runtime;
     this.sourceIds = sourceIds;
     this.behaviors = behaviors;
     this.key = key ?? new wodWikiCore.BlockKey();
     this.blockType = blockType;
+    this.tagComposition = tagComposition;
     this.context = context ?? new BlockContext(runtime, this.key.toString());
     if (label) {
       this._memory.push(new MemoryLocation("metric:label", [{
@@ -8553,61 +8813,153 @@ var SoundMetric = class {
   image;
 };
 
-// src/runtime/behaviors/SoundCueBehavior.ts
-var SoundCueBehavior = class {
+// src/runtime/sound/SoundProfile.ts
+function parseSoundTrigger(notation) {
+  const trimmed = notation.trim();
+  if (trimmed.length === 0) return void 0;
+  let anchor;
+  let magnitude;
+  if (trimmed.startsWith("-")) {
+    anchor = "end";
+    magnitude = trimmed.slice(1);
+  } else {
+    anchor = "start";
+    magnitude = trimmed;
+  }
+  if (magnitude.startsWith(":")) magnitude = magnitude.slice(1);
+  const offsetMs = parseDurationMagnitude(magnitude);
+  if (offsetMs === void 0) return void 0;
+  return { anchor, offsetMs };
+}
+function parseDurationMagnitude(magnitude) {
+  const cleaned = magnitude.trim().replace(/^:/, "");
+  if (cleaned.length === 0) return 0;
+  if (!/^\d+(:\d+)*$/.test(cleaned)) return void 0;
+  const segments = cleaned.split(":").map(Number).reverse();
+  const [seconds = 0, minutes = 0, hours = 0, days = 0] = segments;
+  if (segments.length > 4) return void 0;
+  if (minutes > 59 || hours > 59) return void 0;
+  return ((days * 24 + hours) * 60 + minutes) * 6e4 + seconds * 1e3;
+}
+function formatSoundTrigger(trigger) {
+  const totalSeconds = Math.round(trigger.offsetMs / 1e3);
+  const seconds = totalSeconds % 60;
+  const minutes = Math.floor(totalSeconds / 60) % 60;
+  const hours = Math.floor(totalSeconds / 3600);
+  let magnitude;
+  if (hours > 0) {
+    magnitude = `${pad(hours)}:${pad(minutes)}:${pad(seconds)}`;
+  } else if (minutes > 0) {
+    magnitude = `${pad(minutes)}:${pad(seconds)}`;
+  } else {
+    magnitude = pad(seconds);
+  }
+  return `${trigger.anchor === "end" ? "-:" : ":"}${magnitude}`;
+}
+function pad(value) {
+  return value < 10 ? `0${value}` : String(value);
+}
+function resolveProfileRules(profile, durationMs) {
+  return profile.rules.filter((rule) => {
+    const { anchor, offsetMs } = rule.trigger;
+    if (anchor === "start") return true;
+    if (offsetMs === 0) return true;
+    if (durationMs === void 0) return false;
+    return offsetMs <= durationMs;
+  });
+}
+var DEFAULT_SOUND_PROFILE = {
+  id: "default",
+  name: "Default",
+  rules: [
+    { trigger: { anchor: "end", offsetMs: 3e3 }, sound: "countdown-beep" },
+    { trigger: { anchor: "end", offsetMs: 2e3 }, sound: "countdown-beep" },
+    { trigger: { anchor: "end", offsetMs: 1e3 }, sound: "countdown-beep" },
+    { trigger: { anchor: "end", offsetMs: 0 }, sound: "timer-complete" }
+  ]
+};
+
+// src/runtime/behaviors/SoundProfileBehavior.ts
+var SOUND_PLAY_EVENT = "sound:play";
+var SoundProfileBehavior = class {
   constructor(config) {
     this.config = config;
   }
   config;
+  rules = [];
+  /** Rule indices already fired, so each rule fires exactly once. */
+  fired = /* @__PURE__ */ new Set();
+  durationMs;
   onMount(ctx) {
-    for (const cue of this.config.cues) {
-      if (cue.trigger === "mount") {
-        ctx.emitOutput("system", [
-          new SoundMetric(cue.sound, "mount")
-        ], { label: `Sound: ${cue.sound}` });
-      }
-    }
-    const countdownCues = this.config.cues.filter((c) => c.trigger === "countdown");
-    if (countdownCues.length > 0) {
-      const playedSeconds = /* @__PURE__ */ new Set();
-      ctx.subscribe("tick", (_event, tickCtx) => {
-        const timer = readTimer(tickCtx);
-        if (!timer || timer.direction !== "down" || !timer.durationMs) return [];
-        const now = tickCtx.clock.currentDate.getTime();
-        let elapsed = 0;
-        for (const span of timer.spans) {
-          const end = span.ended ?? now;
-          elapsed += end - span.started;
-        }
-        const remainingMs = timer.durationMs - elapsed;
-        const remainingSeconds = Math.ceil(remainingMs / 1e3);
-        for (const cue of countdownCues) {
-          if (cue.atSeconds?.includes(remainingSeconds) && !playedSeconds.has(remainingSeconds)) {
-            playedSeconds.add(remainingSeconds);
-            tickCtx.emitOutput("system", [
-              new SoundMetric(cue.sound, "countdown", { atSecond: remainingSeconds })
-            ], { label: `Countdown: ${remainingSeconds}s` });
-          }
-        }
-        return [];
-      }, { scope: "bubble" });
-    }
+    const timer = readTimer(ctx);
+    this.durationMs = timer?.durationMs;
+    this.rules = resolveProfileRules(this.config.profile, this.durationMs);
+    this.fireDue(ctx, 0, this.durationMs);
+    ctx.subscribe("tick", (_event, tickCtx) => {
+      const elapsed = this.elapsedMs(tickCtx);
+      if (elapsed === void 0) return [];
+      this.fireDue(tickCtx, elapsed, this.durationMs);
+      return [];
+    }, { scope: "bubble" });
     return [];
   }
   onNext(_ctx) {
     return [];
   }
   onUnmount(ctx) {
-    for (const cue of this.config.cues) {
-      if (cue.trigger === "unmount" || cue.trigger === "complete") {
-        ctx.emitOutput("system", [
-          new SoundMetric(cue.sound, cue.trigger)
-        ], { label: `Sound: ${cue.sound}` });
-      }
-    }
+    this.fireDue(ctx, this.elapsedMs(ctx) ?? 0, this.durationMs, true);
     return [];
   }
   onDispose(_ctx) {
+    this.fired.clear();
+  }
+  /**
+   * Elapsed milliseconds for the block's own timer, or `undefined` when the
+   * block has no timer to measure against.
+   */
+  elapsedMs(ctx) {
+    const timer = readTimer(ctx);
+    if (!timer) return void 0;
+    return calculateElapsed(timer, ctx.clock.currentDate.getTime());
+  }
+  /**
+   * Fire every rule whose trigger point has been reached.
+   *
+   * @param elapsed milliseconds elapsed on the block's timer
+   * @param durationMs the block's total duration
+   * @param ending whether the block is ending — a rule anchored to the end
+   *   with no offset fires then, even when the block has no duration to
+   *   count down from
+   */
+  fireDue(ctx, elapsed, durationMs, ending = false) {
+    const remaining = durationMs === void 0 ? void 0 : Math.max(0, durationMs - elapsed);
+    this.rules.forEach((rule, index) => {
+      if (this.fired.has(index)) return;
+      const { anchor, offsetMs } = rule.trigger;
+      const due = anchor === "start" ? elapsed >= offsetMs : offsetMs === 0 ? ending || remaining !== void 0 && remaining <= 0 : remaining !== void 0 && remaining <= offsetMs;
+      if (!due) return;
+      this.fired.add(index);
+      this.play(ctx, rule, anchor, offsetMs);
+    });
+  }
+  /**
+   * Record the cue and command its playback.
+   */
+  play(ctx, rule, anchor, offsetMs) {
+    const trigger = anchor === "start" ? offsetMs === 0 ? "mount" : "countdown" : offsetMs === 0 ? "complete" : "countdown";
+    ctx.emitOutput("system", [
+      new SoundMetric(rule.sound, trigger, {
+        atSecond: offsetMs / 1e3
+      })
+    ], { label: `Sound: ${rule.sound}` });
+    ctx.emitEvent({
+      name: SOUND_PLAY_EVENT,
+      timestamp: ctx.clock.currentDate,
+      data: {
+        sound: rule.sound,
+        volume: 1
+      }
+    });
   }
 };
 var ButtonBehavior = class {
@@ -8737,6 +9089,34 @@ var WaitingToStartInjectorBehavior = class {
   onDispose(_ctx) {
   }
 };
+var SOUND_PROFILE_METRIC = wodWikiCore.MetricType.Sound;
+function resolveSoundProfile(statements, options) {
+  const blockProfileId = findBlockProfileId(statements);
+  if (blockProfileId) {
+    const match = findProfile(options?.profiles, blockProfileId);
+    if (match) return match;
+  }
+  if (options?.noteProfileId) {
+    const match = findProfile(options?.profiles, options.noteProfileId);
+    if (match) return match;
+  }
+  return DEFAULT_SOUND_PROFILE;
+}
+function findBlockProfileId(statements) {
+  for (const statement of statements) {
+    const metric = statement.metrics.find((m) => m.type === SOUND_PROFILE_METRIC);
+    if (!metric) continue;
+    const value = metric.value;
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function findProfile(profiles, id) {
+  if (!profiles) return void 0;
+  return profiles.find((profile) => profile.id === id);
+}
 
 // src/runtime/blocks/RestBlock.ts
 var RestBlock = class _RestBlock extends RuntimeBlock {
@@ -8747,7 +9127,7 @@ var RestBlock = class _RestBlock extends RuntimeBlock {
     const restLabel = config.label ?? "Rest";
     const blockKey = new wodWikiCore.BlockKey("rest");
     const context = new BlockContext(runtime, blockKey.toString(), "Rest");
-    const behaviors = _RestBlock.buildBehaviors(config);
+    const behaviors = _RestBlock.buildBehaviors(config, runtime.options?.soundOptions);
     super({
       runtime,
       sourceIds: [],
@@ -8762,7 +9142,7 @@ var RestBlock = class _RestBlock extends RuntimeBlock {
   /**
    * Builds the behavior list for a rest block.
    */
-  static buildBehaviors(config) {
+  static buildBehaviors(config, soundOptions) {
     const behaviors = [];
     const restLabel = config.label ?? "Rest";
     behaviors.push(new ReportOutputBehavior({ label: restLabel }));
@@ -8781,18 +9161,8 @@ var RestBlock = class _RestBlock extends RuntimeBlock {
       mode: "timer",
       label: restLabel
     }));
-    behaviors.push(new SoundCueBehavior({
-      cues: [
-        {
-          sound: "rest-over",
-          trigger: "complete"
-        },
-        {
-          sound: "countdown-beep",
-          trigger: "countdown",
-          atSeconds: [3, 2, 1]
-        }
-      ]
+    behaviors.push(new SoundProfileBehavior({
+      profile: resolveSoundProfile([], soundOptions)
     }));
     return behaviors;
   }
@@ -8823,6 +9193,8 @@ var BlockBuilder = class {
   blockType = "Block";
   metrics;
   sourceIds = [];
+  /** The tags the block's statements referenced, resolved at compile time. */
+  tagComposition = [];
   /** Pending round config stored by asRepeater(), consumed by asContainer() */
   pendingRoundConfig;
   /** Declared exit intent — resolved into a single ExitBehavior in build(). */
@@ -8922,6 +9294,11 @@ var BlockBuilder = class {
     this.sourceIds = ids;
     return this;
   }
+  /** The tags the block's statements referenced, and what each carried. */
+  setTagComposition(composition) {
+    this.tagComposition = composition;
+    return this;
+  }
   getLabel() {
     return this.label;
   }
@@ -9043,6 +9420,7 @@ var BlockBuilder = class {
     const block = new RuntimeBlock({
       runtime: this.runtime,
       sourceIds: this.sourceIds,
+      tagComposition: this.tagComposition,
       behaviors: Array.from(this.behaviors.values()),
       context: this.context,
       key: this.key,
@@ -9132,6 +9510,11 @@ var JitCompiler = class {
       return void 0;
     }
     const builder = new BlockBuilder(runtime);
+    const tagComposition = [];
+    for (const node of effectiveNodes) {
+      collectTagReferences(node.metrics, tagComposition);
+    }
+    builder.setTagComposition(tagComposition);
     for (const strategy of matchingStrategies) {
       strategy.apply(builder, effectiveNodes, runtime);
     }
@@ -10646,6 +11029,16 @@ var CalcEngine = class {
     const fenced = (d) => !d.fences || d.fences.includes(deps.dialect);
     this.segmentCalcs = registry.byScope("segment").filter(fenced);
     this.workoutCalcs = registry.byScope("workout").filter(fenced);
+    for (const tag of deps.tags?.list() ?? []) {
+      const resolved = resolveTagContributions(deps.tags, tag.slug);
+      for (const name2 of resolved.functions) {
+        const carriers = this.tagCarriedFunctions.get(name2);
+        if (carriers) carriers.add(tag.slug);
+        else this.tagCarriedFunctions.set(name2, /* @__PURE__ */ new Set([tag.slug]));
+      }
+    }
+    this.runTags = [...deps.activeTags ?? []];
+    for (const tag of this.runTags) this.activatedTags.add(tag);
   }
   registry;
   deps;
@@ -10659,6 +11052,43 @@ var CalcEngine = class {
    * calls (segments arrive in stream order, live and in replay).
    */
   lastSegmentEffort;
+  /**
+   * The tags that carry each function: function name → the tags that carry
+   * it. A function no tag carries runs everywhere, as it always did.
+   */
+  tagCarriedFunctions = /* @__PURE__ */ new Map();
+  /** The tags applied anywhere in the run so far. */
+  activatedTags = /* @__PURE__ */ new Set();
+  /** The tags the run activates — a note-level bundle of attachments. */
+  runTags;
+  /**
+   * Whether a calculation runs here.
+   *
+   * A function a tag carries runs only where one of the tags that carry it
+   * applies; every other function runs as it always did.
+   */
+  isActive(def, appliedTags) {
+    const carriers = this.tagCarriedFunctions.get(def.id);
+    if (!carriers) return true;
+    for (const slug of carriers) {
+      if (appliedTags.includes(slug)) return true;
+    }
+    return false;
+  }
+  /**
+   * The tags applied to a segment: the tags its statement marked, plus the
+   * tags the run activates — a note-level tag applies to every segment of
+   * the note it belongs to.
+   *
+   * The applied tags are recorded, so a workout-scope function the tag
+   * carries runs at the end of the workout.
+   */
+  appliedTags(output) {
+    const slugs = tagMarkerSlugs(output.metrics.rawMetrics);
+    for (const slug of slugs) this.activatedTags.add(slug);
+    if (this.runTags.length === 0) return slugs;
+    return [...slugs, ...this.runTags.filter((slug) => !slugs.includes(slug))];
+  }
   // ── Phase 1: segment scope ─────────────────────────────────────────────
   process(output) {
     if (output.outputType !== "segment" || !output.isLeaf) return output;
@@ -10674,11 +11104,13 @@ var CalcEngine = class {
       if (discipline) effortTags.effortDiscipline = discipline;
       if (intensityTier) effortTags.effortIntensityTier = intensityTier;
     }
-    const climbGrade = [...output.metrics.rawMetrics].find((m) => m.type === "climb-grade")?.value;
+    const climbGrade = output.metrics.rawMetrics.find((m) => m.type === "climb-grade")?.value;
     if (climbGrade && typeof climbGrade === "object" && "raw" in climbGrade) {
       effortTags.grade = String(climbGrade.raw);
     }
+    const appliedTags = this.appliedTags(output);
     for (const def of this.segmentCalcs) {
+      if (!this.isActive(def, appliedTags)) continue;
       const ctx = this.makeContext(atoms);
       if (!this.applicable(def.whenAst, ctx)) continue;
       const variant = this.selectVariant(def, ctx);
@@ -10720,7 +11152,15 @@ var CalcEngine = class {
   // ── Phase 2: workout scope ─────────────────────────────────────────────
   summarize(outputs) {
     const projections = [];
+    for (const output of outputs) {
+      if (output.outputType !== "segment") continue;
+      for (const slug of tagMarkerSlugs(output.metrics.rawMetrics)) {
+        this.activatedTags.add(slug);
+      }
+    }
+    const appliedTags = [...this.activatedTags];
     for (const def of this.workoutCalcs) {
+      if (!this.isActive(def, appliedTags)) continue;
       if (def.output?.isGrouped) {
         projections.push(...this.summarizeGrouped(def, outputs));
       } else {
@@ -11878,7 +12318,13 @@ function createCalcStack(options) {
 }
 function createCalcEngine(dialect, options) {
   const stack = createCalcStack(options);
-  return new CalcEngine(stack.registry, { dialect, lookups: stack.lookups, userProfile: options.userProfile });
+  return new CalcEngine(stack.registry, {
+    dialect,
+    lookups: stack.lookups,
+    userProfile: options.userProfile,
+    tags: options.tags,
+    activeTags: options.activeTags
+  });
 }
 
 // src/analytics/StandardAnalyticsProfile.ts
@@ -11893,7 +12339,9 @@ var StandardAnalyticsProfile = class {
       const calcEngine = createCalcEngine(context.dialect, {
         effortResolver: context.analyticsContext.effortResolver,
         userProfile: context.userProfile,
-        calcs: context.calcs
+        calcs: context.calcs,
+        tags: context.tags,
+        activeTags: context.activeTags
       });
       realtime.push(calcEngine);
       summary.push(calcEngine);
@@ -11945,7 +12393,9 @@ function createAnalyticsEngineForBlock(block, options) {
     scriptMetricTypes,
     analyticsContext,
     userProfile: options?.userProfile,
-    calcs: options?.calcs
+    calcs: options?.calcs,
+    tags: options?.tags,
+    activeTags: options?.activeTags
   };
   const profile = new StandardAnalyticsProfile();
   const { realtime, summary } = profile.build(context);
@@ -12322,13 +12772,6 @@ var AmrapLogicStrategy = class {
       mode: "countdown",
       label
     }));
-    builder.addBehavior(new SoundCueBehavior({
-      cues: [
-        { sound: "start-beep", trigger: "mount" },
-        { sound: "countdown-beep", trigger: "countdown", atSeconds: [3, 2, 1] },
-        { sound: "timer-complete", trigger: "complete" }
-      ]
-    }));
   }
 };
 var IntervalLogicStrategy = class {
@@ -12386,13 +12829,6 @@ var IntervalLogicStrategy = class {
       mode: "countdown",
       label
     }));
-    builder.addBehavior(new SoundCueBehavior({
-      cues: [
-        { sound: "interval-start", trigger: "mount" },
-        { sound: "countdown-beep", trigger: "countdown", atSeconds: [3, 2, 1] },
-        { sound: "interval-complete", trigger: "complete" }
-      ]
-    }));
     const hasResistance = statements.some((s) => s.metrics.some((m) => m.type === wodWikiCore.MetricType.Resistance));
     const hasDistance = statements.some((s) => s.metrics.some((m) => m.type === wodWikiCore.MetricType.Distance));
     const promotions = [
@@ -12585,14 +13021,6 @@ var GenericTimerStrategy = class {
     } else {
       builder.addBehavior(new ExitBehavior({ mode: "immediate", onNext: true }));
     }
-    if (isCountdown) {
-      builder.addBehavior(new SoundCueBehavior({
-        cues: [
-          { sound: "countdown-beep", trigger: "countdown", atSeconds: [3, 2, 1] },
-          { sound: "timer-complete", trigger: "complete" }
-        ]
-      }));
-    }
     builder.addBehavior(new LabelingBehavior({
       mode: durationMs ? "countdown" : "clock",
       label
@@ -12653,29 +13081,17 @@ var SoundStrategy = class {
   priority = 20;
   id = "sound";
   match(statements, _runtime) {
-    return statements && statements.length > 0;
+    return statements.length > 0;
   }
-  apply(builder, _statements, _runtime) {
-    if (builder.hasBehavior(SoundCueBehavior)) {
+  apply(builder, statements, runtime) {
+    if (builder.hasBehavior(SoundProfileBehavior)) {
       return;
     }
-    const countdown = builder.getBehavior(CountdownTimerBehavior);
-    if (countdown) {
-      builder.addBehavior(new SoundCueBehavior({
-        cues: [
-          { sound: "countdown-beep", trigger: "countdown", atSeconds: [3, 2, 1] },
-          { sound: "timer-complete", trigger: "complete" }
-        ]
-      }));
+    if (!builder.hasTimerBehavior()) {
       return;
     }
-    if (builder.hasBehavior(CountupTimerBehavior)) {
-      builder.addBehavior(new SoundCueBehavior({
-        cues: [
-          { sound: "start-beep", trigger: "mount" }
-        ]
-      }));
-    }
+    const profile = resolveSoundProfile(statements, runtime.options?.soundOptions);
+    builder.addBehavior(new SoundProfileBehavior({ profile }));
   }
 };
 
@@ -12708,20 +13124,6 @@ var NextEvent = class _NextEvent {
     };
   }
 };
-
-// src/runtime/models/SoundModels.ts
-var PREDEFINED_SOUNDS = {
-  /** Short single beep - good for countdown ticks */
-  BEEP: "beep",
-  /** Long buzz - good for timer completion */
-  BUZZER: "buzzer",
-  /** Pleasant chime - good for milestones */
-  CHIME: "chime",
-  /** Clock tick - good for second-by-second countdown */
-  TICK: "tick",
-  /** Ascending sequence - good for timer start */
-  START: "start"
-};
 function metricsToLabel(metrics) {
   if (metrics instanceof wodWikiCore.MetricContainer) {
     return metricsToLabel(metrics.toArray());
@@ -13002,40 +13404,6 @@ var UnregisterEventHandlerAction = class {
   }
 };
 
-// src/runtime/actions/audio/PlaySoundAction.ts
-var PlaySoundAction = class {
-  constructor(sound, volume = 1, cueId, now = wallClockNow) {
-    this.sound = sound;
-    this.volume = volume;
-    this.cueId = cueId;
-    this.now = now;
-    if (volume < 0 || volume > 1) {
-      throw new RangeError(`Volume must be between 0.0 and 1.0, got: ${volume}`);
-    }
-  }
-  sound;
-  volume;
-  cueId;
-  now;
-  type = "play-sound";
-  /**
-   * Executes the sound playback by emitting a 'sound:play' event.
-   * UI components should register handlers for this event to play audio.
-   */
-  do(runtime) {
-    const event = {
-      name: "sound:play",
-      timestamp: this.now.now(),
-      data: {
-        sound: this.sound,
-        volume: this.volume,
-        cueId: this.cueId
-      }
-    };
-    return runtime.eventBus.dispatch(event, runtime);
-  }
-};
-
 // src/runtime/utils/MemoryUtils.ts
 function searchStackMemory(runtime, criteria) {
   const results = [];
@@ -14878,6 +15246,7 @@ exports.CrossFitDialect = CrossFitDialect;
 exports.DAY = DAY;
 exports.DEFAULT_RESOLVER_OPTIONS = DEFAULT_RESOLVER_OPTIONS;
 exports.DEFAULT_RUNTIME_OPTIONS = DEFAULT_RUNTIME_OPTIONS;
+exports.DEFAULT_SOUND_PROFILE = DEFAULT_SOUND_PROFILE;
 exports.DEFAULT_UNRESOLVED_EFFORT_MET = DEFAULT_UNRESOLVED_EFFORT_MET;
 exports.DIM_COUNT = DIM_COUNT;
 exports.DIM_ENERGY = DIM_ENERGY;
@@ -14912,6 +15281,7 @@ exports.LabelingBehavior = LabelingBehavior;
 exports.LocalEventProvider = LocalEventProvider;
 exports.LocalRuntimeSubscription = LocalRuntimeSubscription;
 exports.LookupRegistry = LookupRegistry;
+exports.MAX_TAG_CONTRIBUTION_DEPTH = MAX_TAG_CONTRIBUTION_DEPTH;
 exports.MdTimerRuntime = MdTimerRuntime;
 exports.MemoryLocation = MemoryLocation;
 exports.MemoryTypeEnum = MemoryTypeEnum;
@@ -14921,9 +15291,7 @@ exports.NextAction = NextAction;
 exports.NextEvent = NextEvent;
 exports.NextEventHandler = NextEventHandler;
 exports.OutputEmitter = OutputEmitter;
-exports.PREDEFINED_SOUNDS = PREDEFINED_SOUNDS;
 exports.PRODUCTION_STRATEGIES = PRODUCTION_STRATEGIES;
-exports.PlaySoundAction = PlaySoundAction;
 exports.PopBlockAction = PopBlockAction;
 exports.PushBlockAction = PushBlockAction;
 exports.PushRestBlockAction = PushRestBlockAction;
@@ -14945,6 +15313,8 @@ exports.RuntimeLogger = RuntimeLogger;
 exports.RuntimeMemory = RuntimeMemory;
 exports.RuntimeObservers = RuntimeObservers;
 exports.RuntimeStack = RuntimeStack;
+exports.SOUND_PLAY_EVENT = SOUND_PLAY_EVENT;
+exports.SOUND_PROFILE_METRIC = SOUND_PROFILE_METRIC;
 exports.STANDARD_UNITS = STANDARD_UNITS;
 exports.STORE_CALCS = STORE_CALCS;
 exports.STREAM_ATOMS = STREAM_ATOMS;
@@ -14952,13 +15322,14 @@ exports.ScriptRuntime = ScriptRuntime;
 exports.SessionRootBlock = SessionRootBlock;
 exports.SessionRootStrategy = SessionRootStrategy;
 exports.SnapshotClock = SnapshotClock;
-exports.SoundCueBehavior = SoundCueBehavior;
+exports.SoundProfileBehavior = SoundProfileBehavior;
 exports.SoundStrategy = SoundStrategy;
 exports.SpanTrackingBehavior = SpanTrackingBehavior;
 exports.StandardAnalyticsProfile = StandardAnalyticsProfile;
 exports.StartSessionAction = StartSessionAction;
 exports.StartWorkoutAction = StartWorkoutAction;
 exports.SubscriptionManager = SubscriptionManager;
+exports.TAG_MARKER_PREFIX = TAG_MARKER_PREFIX;
 exports.ThrowError = ThrowError;
 exports.ThrowErrorAction = ThrowErrorAction;
 exports.TimeSpan = TimeSpan;
@@ -15035,6 +15406,7 @@ exports.extractStatementsRaw = extractStatementsRaw;
 exports.extractSyntaxFacts = extractSyntaxFacts;
 exports.filterTagsByVisibility = filterTagsByVisibility;
 exports.findBestFuzzyMatch = findBestFuzzyMatch;
+exports.findTagContributionCycles = findTagContributionCycles;
 exports.findUnresolvedChoices = findUnresolvedChoices;
 exports.fixtureBackSquat = fixtureBackSquat;
 exports.fixtureBurpee = fixtureBurpee;
@@ -15048,6 +15420,7 @@ exports.formatDuration = formatDuration;
 exports.formatRuntimeLogLine = formatRuntimeLogLine;
 exports.formatRuntimeLogRule = formatRuntimeLogRule;
 exports.formatRuntimeTimestamp = formatRuntimeTimestamp;
+exports.formatSoundTrigger = formatSoundTrigger;
 exports.fragmentsToLabel = metricsToLabel;
 exports.frozenNow = frozenNow;
 exports.fullFixtureSet = fullFixtureSet;
@@ -15087,6 +15460,7 @@ exports.parseEquipmentFile = parseEquipmentFile;
 exports.parseExpression = parseExpression;
 exports.parseMetricLine = parseMetricLine;
 exports.parseScript = parseScript;
+exports.parseSoundTrigger = parseSoundTrigger;
 exports.printCalculation = printCalculation;
 exports.readNestedSection = readNestedSection;
 exports.readTimer = readTimer;
@@ -15095,14 +15469,21 @@ exports.renderMetric = renderMetric;
 exports.resolveDominantOrigin = resolveDominantOrigin;
 exports.resolveEntityRank = resolveEntityRank;
 exports.resolveEntityTier = resolveEntityTier;
+exports.resolveProfileRules = resolveProfileRules;
+exports.resolveSoundProfile = resolveSoundProfile;
 exports.resolveSourceRank = resolveSourceRank;
 exports.resolveSourceTier = resolveSourceTier;
+exports.resolveTagContributions = resolveTagContributions;
 exports.slugifyRefLabel = slugifyRefLabel;
 exports.startSpan = startSpan;
 exports.str = str;
 exports.strategyRegistry = strategyRegistry;
 exports.subDim = subDim;
 exports.summaryProcessorRegistry = summaryProcessorRegistry;
+exports.tagContributionMetrics = tagContributionMetrics;
+exports.tagMarkerSlug = tagMarkerSlug;
+exports.tagMarkerSlugs = tagMarkerSlugs;
+exports.tagMarkerType = tagMarkerType;
 exports.toStoredOutputStatement = toStoredOutputStatement;
 exports.truthy = truthy;
 exports.validateOutputUnit = validateOutputUnit;