@bitcobblers/wod-wiki-lang 0.43.2153 → 0.44.2156

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { wallClockNow, formatDurationSmart } from './chunk-PFQDVQQO.mjs';
 export { createBrowserRuntimeNow, frozenNow, getRuntimeNowMs, wallClockNow } from './chunk-PFQDVQQO.mjs';
-import { MetricType, MetricContainer, BlockKey, REFERENCE_METADATA_KEY, ParsedCodeStatement, getReferenceMetadata, OutputStatement, valueKindOf, normalizeFieldPath } from '@bitcobblers/wod-wiki-core';
+import { MetricType, MetricContainer, BlockKey, REFERENCE_METADATA_KEY, ParsedCodeStatement, TAG_REFERENCE_METADATA_KEY, getReferenceMetadata, OutputStatement, valueKindOf, normalizeFieldPath, getTagReference } from '@bitcobblers/wod-wiki-core';
 import { LRParser } from '@lezer/lr';
 import { LRLanguage, LanguageSupport } from '@codemirror/language';
 import { NodeProp } from '@lezer/common';
@@ -265,6 +265,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 === 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 = 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) {
@@ -328,6 +447,7 @@ function createPolicy() {
       }
       const t2 = metric.type;
       if ((t2 === 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 === MetricType.Elapsed || t2 === "elapsed" || t2 === MetricType.Total || t2 === "total") return true;
         if (t2 === MetricType.System || t2 === "system") return true;
@@ -1465,15 +1585,16 @@ var TextMetric = class {
   origin = "parser";
   type = MetricType.Text;
 };
-
-// src/parser/semantic-classifier.ts
 var PROPERTY_KEY_TO_METRIC_TYPE = {
   rpe: MetricType.SessionRPE,
   rir: MetricType.RIR,
   intensity: MetricType.Intensity,
   load: MetricType.Load,
   volume: MetricType.Volume,
-  work: MetricType.Work
+  work: MetricType.Work,
+  // `sound: classic` names a sound profile, the same way a `#sound-classic`
+  // tag reference does.
+  sound: MetricType.Sound
 };
 var STRUCTURAL_EFFORT_WORDS = /* @__PURE__ */ new Set(["rest", "amrap", "emom", "tabata", "for time"]);
 var STANDARD_UNITS2 = UnitRegistry.standard();
@@ -1490,9 +1611,25 @@ function referenceMetadata(resolution) {
 function classifyStatements(facts, references) {
   return facts.statements.map((fact) => {
     const statement = new 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;
@@ -1509,6 +1646,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 = [];
@@ -1533,7 +1685,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)
       });
     }
   };
@@ -1663,14 +1818,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()] ?? 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;
@@ -1690,6 +1838,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: 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 ?? {}, [TAG_REFERENCE_METADATA_KEY]: reference }
+  };
+}
+function propertyPair(primitive) {
+  const metricType = PROPERTY_KEY_TO_METRIC_TYPE[primitive.key.toLowerCase()] ?? 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 = [];
@@ -1769,33 +1996,34 @@ function mergeFragments(pairs) {
 }
 var parser = 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) {
@@ -1901,15 +2129,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)) {
@@ -2009,6 +2250,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",
@@ -2249,269 +2501,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 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 = 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 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 = {
@@ -2956,50 +3682,6 @@ function whiteboardScript() {
   return new 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",
@@ -3453,71 +4135,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, "-");
 }
@@ -3730,162 +4347,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;
@@ -3894,456 +4413,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 = 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
@@ -6498,6 +6754,8 @@ var RuntimeBlock = class {
   blockType;
   context;
   sourceIds;
+  /** The tags this block's statements referenced, resolved at compile time. */
+  tagComposition;
   // List-based memory storage
   _memory = [];
   /**
@@ -6534,13 +6792,15 @@ var RuntimeBlock = class {
       key,
       blockType,
       label,
-      metrics
+      metrics,
+      tagComposition
     } = options;
     this._runtime = runtime;
     this.sourceIds = sourceIds;
     this.behaviors = behaviors;
     this.key = key ?? new 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", [{
@@ -8481,61 +8741,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 {
@@ -8665,6 +9017,34 @@ var WaitingToStartInjectorBehavior = class {
   onDispose(_ctx) {
   }
 };
+var SOUND_PROFILE_METRIC = 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 {
@@ -8675,7 +9055,7 @@ var RestBlock = class _RestBlock extends RuntimeBlock {
     const restLabel = config.label ?? "Rest";
     const blockKey = new 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: [],
@@ -8690,7 +9070,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 }));
@@ -8709,18 +9089,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;
   }
@@ -8751,6 +9121,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(). */
@@ -8850,6 +9222,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;
   }
@@ -8971,6 +9348,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,
@@ -9060,6 +9438,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);
     }
@@ -10574,6 +10957,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;
@@ -10587,6 +10980,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;
@@ -10602,11 +11032,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);
@@ -10648,7 +11080,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 {
@@ -11806,7 +12246,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
@@ -11821,7 +12267,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);
@@ -11873,7 +12321,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);
@@ -12250,13 +12700,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 {
@@ -12314,13 +12757,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 === MetricType.Resistance));
     const hasDistance = statements.some((s) => s.metrics.some((m) => m.type === MetricType.Distance));
     const promotions = [
@@ -12513,14 +12949,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
@@ -12581,29 +13009,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 }));
   }
 };
 
@@ -12636,20 +13052,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 MetricContainer) {
     return metricsToLabel(metrics.toArray());
@@ -12930,40 +13332,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 = [];
@@ -14766,6 +15134,6 @@ function compareStatement(expectations, actual, mode) {
   return diffs;
 }
 
-export { ABSENT, AGGREGATE_BUILTINS, AUTHORITATIVE_CASTS, AbortSessionAction, AmrapLogicStrategy, AnalyticsEngine, AnalyticsTransformer, BUILTIN_CALCS, BUNDLED_EFFORT_COUNT, BehaviorContext, BlockBuilder, BlockContext, ButtonBehavior, CATALOG_PRECEDENCE_RANK, CONSUMED_HINTS, CONSUMED_HINT_KEYS, CONTEXT_ATOMS, CalcEngine, CalcEvalError, CalcParseError, CalcRegistrationError, CalcUnitError, CalculateBlockProcessor, CalculationRegistry, CardioDialect, ChildSelectionBehavior, ChildrenStrategy, ChoiceGroupMetric, ClearChildrenAction, ClimbDialect, ClimbMetricType, CompileAndPushBlockAction, CompletionTimestampBehavior, CompositeEffortRegistry, CountdownTimerBehavior, CountupTimerBehavior, CrossFitDialect, DAY, DEFAULT_RESOLVER_OPTIONS, DEFAULT_RUNTIME_OPTIONS, DEFAULT_UNRESOLVED_EFFORT_MET, DIM_COUNT, DIM_ENERGY, DIM_LENGTH, DIM_MASS, DIM_TIME, DIM_ZERO, DISCIPLINE_FACTORS, DialectStack, EFFORT_DATA_METRIC_TYPE, EFFORT_DISCIPLINES, EFFORT_REGISTRY_ORIGINS, EffortBlock, EffortFallbackStrategy, EffortResolver, EmitEventAction, EmitSystemOutputAction, ErrorAction, EventBus, ExecutionContext, ExitBehavior, FixtureSyntaxError, GenericGroupStrategy, GenericLoopStrategy, GenericTimerStrategy, HabitsDialect, INTENSITY_TIERS, InMemoryEffortRegistry, IntervalLogicStrategy, JitCompiler, LabelingBehavior, LocalEventProvider, LocalRuntimeSubscription, LookupRegistry, MdTimerRuntime, MemoryLocation, MemoryTypeEnum, MetricPromotionBehavior, NAMED_COMPOUNDS, NextAction, NextEvent, NextEventHandler, OutputEmitter, PREDEFINED_SOUNDS, PRODUCTION_STRATEGIES, PlaySoundAction, PopBlockAction, PushBlockAction, PushRestBlockAction, REST_EXCLUSION, RPE_LABELS, RUNTIME_LOG_SUBJECT_WIDTH, RegisterEventHandlerAction, Registry, ReportOutputBehavior, ReportOutputStrategy, RestBlock, RoundsMetric, RuntimeAdapter, RuntimeBlock, RuntimeBuilder, RuntimeClock, RuntimeFactory, RuntimeLogger, RuntimeMemory, RuntimeObservers, RuntimeStack, STANDARD_UNITS, STORE_CALCS, STREAM_ATOMS, ScriptRuntime, SessionRootBlock, SessionRootStrategy, SnapshotClock, SoundCueBehavior, SoundStrategy, SpanTrackingBehavior, StandardAnalyticsProfile, StartSessionAction, StartWorkoutAction, SubscriptionManager, ThrowError, ThrowErrorAction, TimeSpan, TwoPassEffortResolutionProcess, TypedMemoryReference, UNITS, UnitRegistry, UnitSet, UnitsDialect, UnregisterEventHandlerAction, UpdateNextPreviewAction, VISIBILITY_ICONS, VISIBILITY_LABELS, WaitingToStartBlock, WaitingToStartInjectorBehavior, WhiteboardScript, WodDialect, YogaDialect, addAliasToEffort, addDim, buildStaticLookups, buildTooltip, bundledEfforts, calculateElapsed, canonicalizeType, checkCalcLine, classifyStatements, closeCurrentSpan, collapseUnresolvedChoices, commonFixtureSet, compareStatement, compileLineForm, composeDivUnit, composeMulUnit, compoundName, computeColumnLabel, computeLabel, computeWorkloadRollups, convertScalar, createAnalyticsEngineForBlock, createCalcEngine, createCalcStack, createCompiler, createDialectStack, createDisciplinesTable, createEffortTable, createLineLocator, createPolicy as createMetricPresentationPolicy, createMockClock, createParser, createProfileTable, createReferenceIndex, createRpeLabelsTable, dailySessionLoads, dayBucket, dedupeEntitiesByPrecedence, dialectRegistry, dialectStack, diffStatement, dimEquals, disciplineFactorFor, documentToEffort, documentToEquipment, effortToDocument, equipmentToDocument, evaluate, evaluateCalculateDefinitions, extractEffortData, extractMetrics, extractStatementRefs, extractStatements, extractStatementsRaw, extractSyntaxFacts, filterTagsByVisibility, findBestFuzzyMatch, findUnresolvedChoices, fixtureBackSquat, fixtureBurpee, fixturePlank, fixtureRowing, fixtureRunning, fixtureUserCustom, fixtureUserOverride, formatDim, formatDuration, formatRuntimeLogLine, formatRuntimeLogRule, formatRuntimeTimestamp, metricsToLabel as fragmentsToLabel, fullFixtureSet, fuseUnits, fuseUnitsInMetrics, getAnalyticsFromLogs, getAnalyticsFromRuntime, getHints, getMetricVisibility, getUnit, hasHint, hintMetric, hintsToContainer, inferDim, isCastSubscription, isChoiceResolved, isDimensionless, isEffortDiscipline, isFragmentTag, isTimeLikeMetric, isWithinThreshold, levenshteinDistance, metricPresentation, mutateTimerSpans, normalizeForFuzzy, num, openSpan, outputNodeId, outputNodeIds, padRuntimeLogEvent, padRuntimeLogSubject, parseCalcLine, parseCalculateBlock, parseEffortFile, parseEquipmentFile, parseExpression, parseMetricLine, parseScript, printCalculation, readNestedSection, readTimer, realtimeProcessorRegistry, renderMetric, resolveDominantOrigin, resolveEntityRank, resolveEntityTier, resolveSourceRank, resolveSourceTier, slugifyRefLabel, startSpan, str, strategyRegistry, subDim, summaryProcessorRegistry, toStoredOutputStatement, truthy, validateOutputUnit, parser as whiteboardParser, whiteboardScript, whiteboardScriptLanguage, writeChoiceSelection };
+export { ABSENT, AGGREGATE_BUILTINS, AUTHORITATIVE_CASTS, AbortSessionAction, AmrapLogicStrategy, AnalyticsEngine, AnalyticsTransformer, BUILTIN_CALCS, BUNDLED_EFFORT_COUNT, BehaviorContext, BlockBuilder, BlockContext, ButtonBehavior, CATALOG_PRECEDENCE_RANK, CONSUMED_HINTS, CONSUMED_HINT_KEYS, CONTEXT_ATOMS, CalcEngine, CalcEvalError, CalcParseError, CalcRegistrationError, CalcUnitError, CalculateBlockProcessor, CalculationRegistry, CardioDialect, ChildSelectionBehavior, ChildrenStrategy, ChoiceGroupMetric, ClearChildrenAction, ClimbDialect, ClimbMetricType, CompileAndPushBlockAction, CompletionTimestampBehavior, CompositeEffortRegistry, CountdownTimerBehavior, CountupTimerBehavior, CrossFitDialect, DAY, DEFAULT_RESOLVER_OPTIONS, DEFAULT_RUNTIME_OPTIONS, DEFAULT_SOUND_PROFILE, DEFAULT_UNRESOLVED_EFFORT_MET, DIM_COUNT, DIM_ENERGY, DIM_LENGTH, DIM_MASS, DIM_TIME, DIM_ZERO, DISCIPLINE_FACTORS, DialectStack, EFFORT_DATA_METRIC_TYPE, EFFORT_DISCIPLINES, EFFORT_REGISTRY_ORIGINS, EffortBlock, EffortFallbackStrategy, EffortResolver, EmitEventAction, EmitSystemOutputAction, ErrorAction, EventBus, ExecutionContext, ExitBehavior, FixtureSyntaxError, GenericGroupStrategy, GenericLoopStrategy, GenericTimerStrategy, HabitsDialect, INTENSITY_TIERS, InMemoryEffortRegistry, IntervalLogicStrategy, JitCompiler, LabelingBehavior, LocalEventProvider, LocalRuntimeSubscription, LookupRegistry, MAX_TAG_CONTRIBUTION_DEPTH, MdTimerRuntime, MemoryLocation, MemoryTypeEnum, MetricPromotionBehavior, NAMED_COMPOUNDS, NextAction, NextEvent, NextEventHandler, OutputEmitter, PRODUCTION_STRATEGIES, PopBlockAction, PushBlockAction, PushRestBlockAction, REST_EXCLUSION, RPE_LABELS, RUNTIME_LOG_SUBJECT_WIDTH, RegisterEventHandlerAction, Registry, ReportOutputBehavior, ReportOutputStrategy, RestBlock, RoundsMetric, RuntimeAdapter, RuntimeBlock, RuntimeBuilder, RuntimeClock, RuntimeFactory, RuntimeLogger, RuntimeMemory, RuntimeObservers, RuntimeStack, SOUND_PLAY_EVENT, SOUND_PROFILE_METRIC, STANDARD_UNITS, STORE_CALCS, STREAM_ATOMS, ScriptRuntime, SessionRootBlock, SessionRootStrategy, SnapshotClock, SoundProfileBehavior, SoundStrategy, SpanTrackingBehavior, StandardAnalyticsProfile, StartSessionAction, StartWorkoutAction, SubscriptionManager, TAG_MARKER_PREFIX, ThrowError, ThrowErrorAction, TimeSpan, TwoPassEffortResolutionProcess, TypedMemoryReference, UNITS, UnitRegistry, UnitSet, UnitsDialect, UnregisterEventHandlerAction, UpdateNextPreviewAction, VISIBILITY_ICONS, VISIBILITY_LABELS, WaitingToStartBlock, WaitingToStartInjectorBehavior, WhiteboardScript, WodDialect, YogaDialect, addAliasToEffort, addDim, buildStaticLookups, buildTooltip, bundledEfforts, calculateElapsed, canonicalizeType, checkCalcLine, classifyStatements, closeCurrentSpan, collapseUnresolvedChoices, commonFixtureSet, compareStatement, compileLineForm, composeDivUnit, composeMulUnit, compoundName, computeColumnLabel, computeLabel, computeWorkloadRollups, convertScalar, createAnalyticsEngineForBlock, createCalcEngine, createCalcStack, createCompiler, createDialectStack, createDisciplinesTable, createEffortTable, createLineLocator, createPolicy as createMetricPresentationPolicy, createMockClock, createParser, createProfileTable, createReferenceIndex, createRpeLabelsTable, dailySessionLoads, dayBucket, dedupeEntitiesByPrecedence, dialectRegistry, dialectStack, diffStatement, dimEquals, disciplineFactorFor, documentToEffort, documentToEquipment, effortToDocument, equipmentToDocument, evaluate, evaluateCalculateDefinitions, extractEffortData, extractMetrics, extractStatementRefs, extractStatements, extractStatementsRaw, extractSyntaxFacts, filterTagsByVisibility, findBestFuzzyMatch, findTagContributionCycles, findUnresolvedChoices, fixtureBackSquat, fixtureBurpee, fixturePlank, fixtureRowing, fixtureRunning, fixtureUserCustom, fixtureUserOverride, formatDim, formatDuration, formatRuntimeLogLine, formatRuntimeLogRule, formatRuntimeTimestamp, formatSoundTrigger, metricsToLabel as fragmentsToLabel, fullFixtureSet, fuseUnits, fuseUnitsInMetrics, getAnalyticsFromLogs, getAnalyticsFromRuntime, getHints, getMetricVisibility, getUnit, hasHint, hintMetric, hintsToContainer, inferDim, isCastSubscription, isChoiceResolved, isDimensionless, isEffortDiscipline, isFragmentTag, isTimeLikeMetric, isWithinThreshold, levenshteinDistance, metricPresentation, mutateTimerSpans, normalizeForFuzzy, num, openSpan, outputNodeId, outputNodeIds, padRuntimeLogEvent, padRuntimeLogSubject, parseCalcLine, parseCalculateBlock, parseEffortFile, parseEquipmentFile, parseExpression, parseMetricLine, parseScript, parseSoundTrigger, printCalculation, readNestedSection, readTimer, realtimeProcessorRegistry, renderMetric, resolveDominantOrigin, resolveEntityRank, resolveEntityTier, resolveProfileRules, resolveSoundProfile, resolveSourceRank, resolveSourceTier, resolveTagContributions, slugifyRefLabel, startSpan, str, strategyRegistry, subDim, summaryProcessorRegistry, tagContributionMetrics, tagMarkerSlug, tagMarkerSlugs, tagMarkerType, toStoredOutputStatement, truthy, validateOutputUnit, parser as whiteboardParser, whiteboardScript, whiteboardScriptLanguage, writeChoiceSelection };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map