@bitcobblers/wod-wiki-lang 0.43.2152 → 0.44.2155

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { IMetric, MetricContainer, MetricOrigin, MetricType, IDialect, ICodeStatement, DialectAnalysis, ParsedCodeStatement, IOutputStatement, OutputStatementType, BlockKey, ScriptBlock, FenceDialect, Segment, AnalyticsGroup, StoredOutputStatement, OutputStatement } from '@bitcobblers/wod-wiki-core';
+import { IMetric, MetricContainer, MetricOrigin, MetricType, IDialect, ICodeStatement, DialectAnalysis, TagIndex, ParsedCodeStatement, TagMetricContribution, IOutputStatement, OutputStatementType, BlockKey, TagReferenceMetadata, ScriptBlock, FenceDialect, Segment, AnalyticsGroup, StoredOutputStatement, OutputStatement } from '@bitcobblers/wod-wiki-core';
 export { ParseError } from '@bitcobblers/wod-wiki-core';
-import { R as ReferenceIndex, a as ReferenceResolutionDefaults, W as WhiteboardScript, I as IEquipment, b as IEffort, c as IEffortResolver, d as IEffortRegistry, E as EffortResolverOptions, e as EffortResolutionOptions, f as ResolvedEffort, g as EffortRegistrySource, h as EffortStorageAdapter, i as IRuntimeActionable, j as IEventBus, k as IRuntimeStack, l as IRuntimeClock, m as IJitCompiler, n as INowProvider, o as RuntimeStackOptions, p as RuntimeError, A as AnalyticsContext, q as IEvent, r as IRuntimeAction, O as OutputListener, U as Unsubscribe, s as IAnalyticsEngine, t as IRuntimeBlock, u as IBehaviorContext, B as BehaviorEventType, v as BehaviorEventListener, S as SubscribeOptions, w as Unsubscribe$1, x as OutputOptions, M as MemoryTag, y as IMemoryLocation, z as IRuntimeBehavior, C as IBlockContext, D as MetricVisibility, F as BlockLifecycleOptions, G as CompletionDecision, T as TimeSpan, H as IRuntimeMemory, J as TypedMemoryReference, K as MemorySearchCriteria, L as IMemoryReference, N as RuntimeStackLogger, P as StackObserver, Q as StackSnapshot, V as StackListener, X as MemoryTypeEnum, Y as IAnchorValue, Z as ButtonConfig, _ as IEventHandler, $ as HandlerScope, a0 as IScriptRuntime, a1 as TestableBlockConfig, a2 as IRuntimeOptions, a3 as ScriptRuntime, a4 as EventHandlerOptions, a5 as EventCallback, a6 as TimerState, a7 as IRealtimeProcessor, a8 as ISummaryProcessor, a9 as ProjectionResult } from './browserRuntimeNow-M4hQ_DTl.js';
-export { aa as ButtonVariant, ab as ButtonsState, ac as CATALOG_PRECEDENCE_RANK, ad as CatalogPrecedenceTier, ae as ChildrenStatusState, af as CompletionState, ag as DEFAULT_RESOLVER_OPTIONS, ah as DEFAULT_RUNTIME_OPTIONS, ai as DISCIPLINE_FACTORS, aj as DisplayState, ak as EFFORT_DISCIPLINES, al as EFFORT_REGISTRY_ORIGINS, am as EffortBaseAttributes, an as EffortDerivation, ao as EffortDiscipline, ap as EffortMaterializer, aq as EffortResolvedFrom, ar as EquipmentStorageAdapter, as as FenceDialect, at as FragmentDisplayState, au as FragmentState, av as IAnalyticsProcessorDescriptor, aw as IEquipmentRegistry, ax as INTENSITY_TIERS, ay as IScript, az as IntensityTier, aA as InterceptMode, aB as MemoryLocation, aC as MemoryType, aD as MemoryTypeMap, aE as MemoryValueOf, aF as ReferenceCatalog, aG as ResolvedReferences, aH as RoundState, aI as RuntimeState, aJ as ScriptRuntimeDependencies, aK as StackEvent, aL as TimerDirection, aM as VISIBILITY_ICONS, aN as VISIBILITY_LABELS, aO as createBrowserRuntimeNow, aP as createReferenceIndex, aQ as dedupeEntitiesByPrecedence, aR as disciplineFactorFor, aS as extractStatementRefs, aT as filterTagsByVisibility, aU as frozenNow, aV as getMetricVisibility, aW as getRuntimeNowMs, aX as isEffortDiscipline, aY as isFragmentTag, aZ as resolveEntityRank, a_ as resolveEntityTier, a$ as resolveSourceRank, b0 as resolveSourceTier, b1 as slugifyRefLabel, b2 as wallClockNow } from './browserRuntimeNow-M4hQ_DTl.js';
+import { R as ReferenceIndex, a as ReferenceResolutionDefaults, W as WhiteboardScript, I as IEquipment, b as IEffort, c as IEffortResolver, d as IEffortRegistry, E as EffortResolverOptions, e as EffortResolutionOptions, f as ResolvedEffort, g as EffortRegistrySource, h as EffortStorageAdapter, i as IRuntimeActionable, j as IEventBus, k as IRuntimeStack, l as IRuntimeClock, m as IJitCompiler, n as INowProvider, o as RuntimeStackOptions, p as RuntimeError, A as AnalyticsContext, q as IEvent, r as IRuntimeAction, O as OutputListener, U as Unsubscribe, s as IAnalyticsEngine, t as IRuntimeBlock, u as IBehaviorContext, B as BehaviorEventType, v as BehaviorEventListener, S as SubscribeOptions, w as Unsubscribe$1, x as OutputOptions, M as MemoryTag, y as IMemoryLocation, z as IRuntimeBehavior, C as IBlockContext, D as MetricVisibility, F as BlockLifecycleOptions, G as CompletionDecision, T as TimeSpan, H as IRuntimeMemory, J as TypedMemoryReference, K as MemorySearchCriteria, L as IMemoryReference, N as RuntimeStackLogger, P as StackObserver, Q as StackSnapshot, V as StackListener, X as MemoryTypeEnum, Y as IAnchorValue, Z as SoundProfile, _ as ButtonConfig, $ as IEventHandler, a0 as HandlerScope, a1 as IScriptRuntime, a2 as TestableBlockConfig, a3 as IRuntimeOptions, a4 as ScriptRuntime, a5 as EventHandlerOptions, a6 as EventCallback, a7 as TimerState, a8 as CalculationDefinition$1, a9 as IRealtimeProcessor, aa as ISummaryProcessor, ab as ProjectionResult, ac as DimVector, ad as CalcLine, ae as ExprNode, af as CalcScope } from './browserRuntimeNow-_zhhbzoE.js';
+export { ag as BinaryOp, ah as ButtonVariant, ai as ButtonsState, aj as CATALOG_PRECEDENCE_RANK, ak as CalcNode, al as CalcOrigin, am as CalcVariant, an as CatalogPrecedenceTier, ao as ChildrenStatusState, ap as CompletionState, aq as DEFAULT_RESOLVER_OPTIONS, ar as DEFAULT_RUNTIME_OPTIONS, as as DEFAULT_SOUND_PROFILE, at as DIM_COUNT, au as DIM_ENERGY, av as DIM_LENGTH, aw as DIM_MASS, ax as DIM_TIME, ay as DIM_ZERO, az as DISCIPLINE_FACTORS, aA as DisplayState, aB as EFFORT_DISCIPLINES, aC as EFFORT_REGISTRY_ORIGINS, aD as EffortBaseAttributes, aE as EffortDerivation, aF as EffortDiscipline, aG as EffortMaterializer, aH as EffortResolvedFrom, aI as EquipmentStorageAdapter, aJ as FenceDialect, aK as FragmentDisplayState, aL as FragmentState, aM as IAnalyticsProcessorDescriptor, aN as IEquipmentRegistry, aO as INTENSITY_TIERS, aP as IScript, aQ as IntensityTier, aR as InterceptMode, aS as MemoryLocation, aT as MemoryType, aU as MemoryTypeMap, aV as MemoryValueOf, aW as NAMED_COMPOUNDS, aX as ReferenceCatalog, aY as ResolvedReferences, aZ as RoundState, a_ as RuntimeState, a$ as ScriptRuntimeDependencies, b0 as SoundRule, b1 as SoundTriggerAnchor, b2 as SoundTriggerPoint, b3 as StackEvent, b4 as TimerDirection, b5 as VISIBILITY_ICONS, b6 as VISIBILITY_LABELS, b7 as addDim, b8 as compoundName, b9 as createBrowserRuntimeNow, ba as createReferenceIndex, bb as dedupeEntitiesByPrecedence, bc as dimEquals, bd as disciplineFactorFor, be as extractStatementRefs, bf as filterTagsByVisibility, bg as formatDim, bh as formatSoundTrigger, bi as frozenNow, bj as getMetricVisibility, bk as getRuntimeNowMs, bl as isDimensionless, bm as isEffortDiscipline, bn as isFragmentTag, bo as parseSoundTrigger, bp as resolveEntityRank, bq as resolveEntityTier, br as resolveProfileRules, bs as resolveSourceRank, bt as resolveSourceTier, bu as slugifyRefLabel, bv as subDim, bw as wallClockNow } from './browserRuntimeNow-_zhhbzoE.js';
 import { Tree } from '@lezer/common';
 import { LanguageSupport, LRLanguage } from '@codemirror/language';
 import { LRParser } from '@lezer/lr';
@@ -587,7 +587,7 @@ interface SyntaxMeta {
     raw: string;
 }
 interface BasePrimitive {
-    kind: 'lap' | 'duration' | 'rounds' | 'round_scheme' | 'action' | 'text' | 'heading' | 'quantity' | 'effort' | 'property' | 'metric_object';
+    kind: 'lap' | 'duration' | 'rounds' | 'round_scheme' | 'action' | 'text' | 'heading' | 'quantity' | 'effort' | 'property' | 'metric_object' | 'tag_ref';
     raw: string;
     meta: SyntaxMeta;
 }
@@ -653,8 +653,28 @@ interface PropertyPrimitive extends BasePrimitive {
     key: string;
     valueRaw: string;
     value: string | number | boolean | null;
+    /**
+     * The tag slugs when the value is one or more tag references
+     * (`#tag-slug`). Several can be stacked on one line.
+     *
+     * A tag reference names a tag rather than repeating what the tag means.
+     * The parser records the references; resolving them to metrics is the
+     * classifier's job, since only it knows the tag catalog.
+     */
+    tagRefs?: string[];
 }
-type SyntaxPrimitive = LapPrimitive | DurationPrimitive | RoundsPrimitive | RoundSchemePrimitive | ActionPrimitive | TextPrimitive | HeadingPrimitive | QuantityPrimitive | EffortPrimitive | PropertyPrimitive | MetricObjectPrimitive;
+/**
+ * A tag reference standing on its own — `5 reps @ 100 kg #heavy`.
+ *
+ * The reference names a tag rather than repeating what the tag means, so
+ * the tag applies to the line it sits on.
+ */
+interface TagRefPrimitive extends BasePrimitive {
+    kind: 'tag_ref';
+    /** The slug the reference names. */
+    slug: string;
+}
+type SyntaxPrimitive = LapPrimitive | DurationPrimitive | RoundsPrimitive | RoundSchemePrimitive | ActionPrimitive | TextPrimitive | HeadingPrimitive | QuantityPrimitive | EffortPrimitive | PropertyPrimitive | MetricObjectPrimitive | TagRefPrimitive;
 interface SyntaxStatement {
     id: number;
     line: number;
@@ -672,6 +692,8 @@ interface SyntaxFacts {
 interface ParseReferences {
     index: ReferenceIndex;
     defaults?: ReferenceResolutionDefaults;
+    /** Tags a script can reference with `#tag-slug`. */
+    tags?: TagIndex;
 }
 declare function classifyStatements(facts: SyntaxFacts, references?: ParseReferences): ParsedCodeStatement[];
 
@@ -732,6 +754,8 @@ interface ParseOptions {
     references?: ReferenceIndex;
     /** Note-level `metrics.*` defaults applied by the resolver. */
     defaults?: ReferenceResolutionDefaults;
+    /** Tags a script can reference with `#tag-slug`. */
+    tags?: TagIndex;
 }
 /**
  * Parses Whiteboard Script source directly into a WhiteboardScript AST
@@ -746,6 +770,8 @@ declare function parseScript(inputText: string, options?: ParseOptions): Whitebo
 interface ParserConfig {
     references?: ReferenceIndex;
     defaults?: ReferenceResolutionDefaults;
+    /** Tags a script can reference with `#tag-slug`. */
+    tags?: TagIndex;
 }
 /**
  * Headless parser facade using the Lezer parser with 0 DOM / EditorState overhead.
@@ -1040,6 +1066,69 @@ declare const BUNDLED_EFFORT_COUNT: number;
  */
 declare function addAliasToEffort(registry: IEffortRegistry, targetSlug: string, newAlias: string): Promise<IEffort>;
 
+/**
+ * Tag contributions — what a `#slug` reference resolves to.
+ *
+ * A tag contributes metrics (a typed value with a unit), other tags, and
+ * functions (named calculations). Resolving a reference flattens that
+ * structure: nested tags are walked, functions are collected by name, and
+ * metric contributions keep the order the tags declare them in.
+ *
+ * The resolver is defensive about cycles — a tag that applies itself, directly
+ * or through other tags, contributes nothing further rather than looping.
+ */
+
+/**
+ * The metric type prefix that marks a statement as carrying a tag.
+ *
+ * A marker is how tag activation survives into the runtime: the statement's
+ * metrics travel with the segment, so a marker on the statement is a marker
+ * on the segment — and on the stored log.
+ */
+declare const TAG_MARKER_PREFIX = "tag.";
+/** How deep nested tag references may go. */
+declare const MAX_TAG_CONTRIBUTION_DEPTH = 8;
+/** What a tag reference resolves to. */
+interface ResolvedTagContributions {
+    /** Metric contributions, in the order the tags declare them. */
+    readonly metrics: readonly TagMetricContribution[];
+    /** Names of the functions the tags carry, without duplicates. */
+    readonly functions: readonly string[];
+    /** Every tag involved — the referenced tag and the tags it applies. */
+    readonly tags: readonly string[];
+}
+/**
+ * Resolve what a tag reference contributes.
+ *
+ * A reference to a tag the catalogue does not know contributes nothing — the
+ * line keeps whatever else it says.
+ */
+declare function resolveTagContributions(tagIndex: TagIndex | undefined, slug: string): ResolvedTagContributions;
+/**
+ * The cycles in a catalogue's tag graph.
+ *
+ * Each cycle is the slugs that form it, with the entry slug repeated at the
+ * end. A catalogue with no cycles returns an empty list.
+ */
+declare function findTagContributionCycles(tagIndex: TagIndex | undefined): string[][];
+/**
+ * The metric type that marks a statement as carrying a tag.
+ */
+declare function tagMarkerType(slug: string): string;
+/**
+ * The tag slug a marker metric type refers to, or `undefined` when the type
+ * is not a marker.
+ */
+declare function tagMarkerSlug(type: string): string | undefined;
+/**
+ * The tag slugs a set of metrics marks.
+ */
+declare function tagMarkerSlugs(metrics: Iterable<IMetric>): string[];
+/**
+ * The metric a tag's metric contributions produce.
+ */
+declare function tagContributionMetrics(contributions: readonly TagMetricContribution[], origin?: MetricOrigin): IMetric[];
+
 /**
  * IRuntimeContext — what the execution world (actions, blocks, behaviors)
  * receives. The runtime's collaborators (the "bag") plus the verbs to enqueue
@@ -1376,6 +1465,8 @@ interface RuntimeBlockOptions {
     label?: string;
     /** Optional display metric groups, each stored as a `metric:display` location. */
     metrics?: MetricContainer[] | IMetric[][];
+    /** The tags this block's statements referenced, resolved at compile time. */
+    tagComposition?: readonly TagReferenceMetadata[];
 }
 /**
  * RuntimeBlock represents an executable unit in the workout runtime.
@@ -1397,6 +1488,8 @@ declare class RuntimeBlock implements IRuntimeBlock {
     readonly blockType?: string;
     readonly context: IBlockContext;
     readonly sourceIds: number[];
+    /** The tags this block's statements referenced, resolved at compile time. */
+    readonly tagComposition?: readonly TagReferenceMetadata[];
     private _memory;
     /**
      * Computed label derived from the block's Label metrics.
@@ -2350,59 +2443,65 @@ declare class ReportOutputBehavior implements IRuntimeBehavior {
 }
 
 /**
- * Trigger types for when a sound should play.
+ * The runtime event a sound cue is published on.
+ *
+ * Listeners (the app's audio layer) subscribe to this to play the sound.
+ * The event carries the sound's **name** — the profile decides the name,
+ * the app decides what it sounds like.
  */
-type SoundTrigger = 'mount' | 'unmount' | 'countdown' | 'complete';
-
-interface SoundCue$1 {
-    /** Sound identifier or URL */
-    sound: string;
-    /** When to play: 'mount' | 'unmount' | 'countdown' | 'complete' */
-    trigger: SoundTrigger;
-    /** Countdown seconds (only for trigger: 'countdown') */
-    atSeconds?: number[];
-}
-interface SoundCueConfig {
-    /** Sound cues to play */
-    cues: SoundCue$1[];
+declare const SOUND_PLAY_EVENT = "sound:play";
+interface SoundProfileBehaviorConfig {
+    /** The profile whose rules drive this block's cues. */
+    profile: SoundProfile;
 }
 /**
- * SoundCueBehavior emits sound cue outputs at specific lifecycle points.
- *
- * ## Aspect: Output (Audio)
- *
- * Emits 'system' outputs with SoundMetric that audio systems can observe.
- * Sound outputs are tracked as system events so they do not appear in the
- * user-facing review/logs page — only in the debug view.
- * This follows the principle that behaviors emit outputs, not events.
- *
- * ## Output Contract
- *
- * - **Mount**: Emits system output for 'mount' trigger sounds
- * - **Tick**: Emits system output for 'countdown' trigger sounds at specified seconds
- * - **Unmount**: Emits system output for 'unmount' and 'complete' trigger sounds
+ * SoundProfileBehavior — plays a profile's rules at their trigger points.
  *
- * ## Audio System Integration
+ * This is the generic replacement for the per-strategy hardcoded cues. Every
+ * profile rule is expressed as an offset relative to the block's own duration,
+ * so one profile applies to any block length:
  *
- * Audio systems should subscribe to outputs (via runtime output stream) and
- * filter for SoundMetric to play audio cues:
+ * - `anchor: 'start'`, offset 0 → fires on mount.
+ * - `anchor: 'end'`, offset 0 → fires on unmount.
+ * - `anchor: 'end'`, offset N → fires when N ms remain (a countdown).
+ * - `anchor: 'start'`, offset N → fires when N ms have elapsed.
  *
- * ```typescript
- * runtime.outputs$.subscribe(output => {
- *   const soundFragments = output.metrics.filter(f => f.metricType === MetricType.Sound);
- *   for (const sf of soundFragments) {
- *     audioPlayer.play(sf.value.sound);
- *   }
- * });
- * ```
+ * Each firing does two things: it records a {@link SoundMetric} output (so
+ * history and analytics know a sound happened) and it emits a
+ * {@link SOUND_PLAY_EVENT} event (so the app plays it). Recording and
+ * playing are deliberately separate — the metric is a fact, the event is a
+ * command.
  */
-declare class SoundCueBehavior implements IRuntimeBehavior {
+declare class SoundProfileBehavior implements IRuntimeBehavior {
     private config;
-    constructor(config: SoundCueConfig);
+    private rules;
+    /** Rule indices already fired, so each rule fires exactly once. */
+    private readonly fired;
+    private durationMs;
+    constructor(config: SoundProfileBehaviorConfig);
     onMount(ctx: IBehaviorContext): IRuntimeAction[];
     onNext(_ctx: IBehaviorContext): IRuntimeAction[];
     onUnmount(ctx: IBehaviorContext): IRuntimeAction[];
     onDispose(_ctx: IBehaviorContext): void;
+    /**
+     * Elapsed milliseconds for the block's own timer, or `undefined` when the
+     * block has no timer to measure against.
+     */
+    private elapsedMs;
+    /**
+     * 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
+     */
+    private fireDue;
+    /**
+     * Record the cue and command its playback.
+     */
+    private play;
 }
 
 interface ControlsConfig {
@@ -2514,6 +2613,8 @@ declare class BlockBuilder {
     private blockType;
     private metrics;
     private sourceIds;
+    /** The tags the block's statements referenced, resolved at compile time. */
+    private tagComposition;
     /** Pending round config stored by asRepeater(), consumed by asContainer() */
     private pendingRoundConfig;
     /** Declared exit intent — resolved into a single ExitBehavior in build(). */
@@ -2564,6 +2665,8 @@ declare class BlockBuilder {
     setBlockType(type: string): BlockBuilder;
     setFragments(metrics: IMetric[][] | MetricContainer[]): BlockBuilder;
     setSourceIds(ids: number[]): BlockBuilder;
+    /** The tags the block's statements referenced, and what each carried. */
+    setTagComposition(composition: readonly TagReferenceMetadata[]): BlockBuilder;
     getLabel(): string;
     getBlockType(): string;
     getFragments(): MetricContainer[] | undefined;
@@ -3101,56 +3204,6 @@ declare class UnregisterEventHandlerAction implements IRuntimeAction {
     do(runtime: IRuntimeContext): void;
 }
 
-/**
- * Action for playing sounds during workout execution.
- *
- * This action emits a 'sound:play' event that can be consumed by UI components
- * to trigger audio playback. The runtime itself does not handle audio playback
- * directly - it delegates to registered sound handlers.
- *
- * @example
- * ```typescript
- * // Play a predefined beep sound
- * return [new PlaySoundAction('beep')];
- *
- * // Play a sound at 50% volume
- * return [new PlaySoundAction('buzzer', 0.5)];
- *
- * // Play a custom sound URL
- * return [new PlaySoundAction('https://example.com/sound.mp3')];
- * ```
- */
-declare class PlaySoundAction implements IRuntimeAction {
-    /**
-     * Sound identifier. Can be:
-     * - Predefined sound name: 'beep', 'buzzer', 'chime', 'tick'
-     * - URL to audio file
-     */
-    readonly sound: string;
-    /** Volume level (0.0 to 1.0). Default is 1.0 */
-    readonly volume: number;
-    /** Optional cue ID for tracking which cue triggered this sound */
-    readonly cueId?: string | undefined;
-    private readonly now;
-    readonly type = "play-sound";
-    constructor(
-    /**
-     * Sound identifier. Can be:
-     * - Predefined sound name: 'beep', 'buzzer', 'chime', 'tick'
-     * - URL to audio file
-     */
-    sound: string, 
-    /** Volume level (0.0 to 1.0). Default is 1.0 */
-    volume?: number, 
-    /** Optional cue ID for tracking which cue triggered this sound */
-    cueId?: string | undefined, now?: INowProvider);
-    /**
-     * Executes the sound playback by emitting a 'sound:play' event.
-     * UI components should register handlers for this event to play audio.
-     */
-    do(runtime: IRuntimeContext): IRuntimeAction[];
-}
-
 /**
  * Action that registers a runtime error and transitions the workout to an error state.
  */
@@ -3789,19 +3842,25 @@ declare class ReportOutputStrategy implements IRuntimeBlockStrategy {
 }
 
 /**
- * SoundStrategy adds sound cues to timer-based blocks.
+ * SoundStrategy attaches the block's sound cues.
  *
- * Uses aspect-based behaviors:
- * - Output: SoundCueBehavior
+ * Unlike the strategies it replaces, this one carries no hardcoded cues. The
+ * cues come from a **sound profile** — a user-defined set of rules mapping
+ * trigger points to sounds — resolved here at compile time:
  *
- * This is a low-priority enhancement that adds sound cues
- * if not already added by a higher-priority strategy.
+ * 1. A `sound` metric on the block's own statements (the line-level
+ *    selection) wins.
+ * 2. Otherwise the note-level selection, passed in by the host.
+ * 3. Otherwise the default profile.
+ *
+ * The resolved profile's rules are handed to {@link SoundProfileBehavior},
+ * which fires them at their trigger points.
  */
 declare class SoundStrategy implements IRuntimeBlockStrategy {
     priority: number;
     readonly id = "sound";
     match(statements: ICodeStatement[], _runtime: IRuntimeContext): boolean;
-    apply(builder: BlockBuilder, _statements: ICodeStatement[], _runtime: IRuntimeContext): void;
+    apply(builder: BlockBuilder, statements: ICodeStatement[], runtime: IRuntimeContext): void;
 }
 
 declare class RoundsMetric implements IMetric {
@@ -3894,80 +3953,6 @@ interface RuntimeControls {
     displayMode?: 'timer' | 'clock';
 }
 
-/**
- * Sound-related type definitions for the runtime.
- */
-/**
- * Configuration for a single sound cue.
- * Sound cues are triggered when a timer reaches a specific threshold.
- */
-interface SoundCue {
-    /** Unique identifier for this cue */
-    id: string;
-    /**
-     * Time threshold in milliseconds when this cue should trigger.
-     * For countdown timers: triggers when remainingMs <= threshold
-     * For count-up timers: triggers when elapsedMs >= threshold
-     */
-    threshold: number;
-    /**
-     * Sound to play. Can be:
-     * - Predefined sound name: 'beep', 'buzzer', 'chime', 'tick'
-     * - URL to audio file
-     */
-    sound: string;
-    /** Volume level (0.0 to 1.0). Default is 1.0 */
-    volume?: number;
-}
-/**
- * State tracking for a single sound cue.
- * Used to prevent duplicate triggers.
- */
-interface SoundCueState {
-    /** Reference to the cue configuration ID */
-    cueId: string;
-    /** Whether this cue has been triggered */
-    triggered: boolean;
-    /** Timestamp when the cue was triggered (ms since epoch) */
-    triggeredAt?: number;
-}
-/**
- * Configuration for SoundBehavior.
- */
-interface SoundBehaviorConfig {
-    /** Direction of the timer ('up' for count-up, 'down' for countdown) */
-    direction: 'up' | 'down';
-    /** Total duration for countdown timers (required for 'down' direction) */
-    durationMs?: number;
-    /** Array of sound cues to trigger at specific time thresholds */
-    cues: SoundCue[];
-}
-/**
- * Runtime state for sound behavior stored in memory.
- */
-interface SoundState {
-    /** Block ID that owns this sound state */
-    blockId: string;
-    /** State of each configured cue */
-    cues: SoundCueState[];
-}
-/**
- * Predefined sound names that can be used in SoundCue.sound
- */
-declare const PREDEFINED_SOUNDS: {
-    /** Short single beep - good for countdown ticks */
-    readonly BEEP: "beep";
-    /** Long buzz - good for timer completion */
-    readonly BUZZER: "buzzer";
-    /** Pleasant chime - good for milestones */
-    readonly CHIME: "chime";
-    /** Clock tick - good for second-by-second countdown */
-    readonly TICK: "tick";
-    /** Ascending sequence - good for timer start */
-    readonly START: "start";
-};
-type PredefinedSoundName = typeof PREDEFINED_SOUNDS[keyof typeof PREDEFINED_SOUNDS];
-
 /**
  * Calculates **Elapsed** time from timer spans.
  *
@@ -4096,14 +4081,14 @@ interface RestBlockConfig {
  * - ReportOutputBehavior (output on mount/unmount)
  * - CountdownTimerBehavior (countdown timer + pause/resume + auto-complete)
  * - LabelingBehavior (show rest countdown)
- * - SoundCueBehavior (beep on unmount for rest-over signal)
+ * - SoundProfileBehavior (the block's sound profile)
  */
 declare class RestBlock extends RuntimeBlock {
     constructor(runtime: IRuntimeContext, config: RestBlockConfig);
     /**
      * Builds the behavior list for a rest block.
      */
-    static buildBehaviors(config: RestBlockConfig): IRuntimeBehavior[];
+    static buildBehaviors(config: RestBlockConfig, soundOptions?: RuntimeStackOptions['soundOptions']): IRuntimeBehavior[];
     mount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
     unmount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
     dispose(runtime: IRuntimeContext): void;
@@ -4141,6 +4126,32 @@ declare class WaitingToStartBlock extends RuntimeBlock {
     dispose(runtime: IRuntimeContext): void;
 }
 
+/**
+ * The metric type a block uses to name its own sound profile.
+ *
+ * A block-level selection is written as a `sound` metric — `sound: classic`
+ * in script content, or contributed by a `#sound-classic` tag reference.
+ */
+declare const SOUND_PROFILE_METRIC = MetricType.Sound;
+/**
+ * Resolve the sound profile for a block.
+ *
+ * Three levels, most specific wins:
+ *
+ * 1. **Block** — a `sound` metric on the block's own statements. This is the
+ *    line-level selection; it overrides everything below.
+ * 2. **Note** — the profile selected by a note-level `sound-{profile}` tag,
+ *    resolved by the host and passed in as `noteProfileId`.
+ * 3. **Default** — {@link DEFAULT_SOUND_PROFILE}, when nothing is selected.
+ *
+ * @param statements the block's statements, searched for a `sound` metric
+ * @param options the runtime's sound options
+ */
+declare function resolveSoundProfile(statements: readonly ICodeStatement[], options?: {
+    profiles?: readonly SoundProfile[];
+    noteProfileId?: string;
+}): SoundProfile;
+
 /**
  * Consumer-facing strategy registry, pre-seeded with the built-in strategies.
  *
@@ -4419,152 +4430,6 @@ declare class SubscriptionManager {
     dispose(): void;
 }
 
-/**
- * AST for the composed-calculation expression language (spec §2).
- *
- * One expression language across all three scopes; scope only changes how
- * atoms resolve. `wql` atoms are legal in store scope only (executed by
- * QueryService); stream aggregates (`sum(reps)`) are builtin calls resolved
- * by the engine, not by this core.
- */
-type BinaryOp = '+' | '-' | '*' | '/' | '==' | '!=' | '<' | '<=' | '>' | '>=' | 'and' | 'or';
-type ExprNode = {
-    kind: 'literal';
-    value: number;
-} | {
-    kind: 'period';
-    days: number;
-} | {
-    kind: 'string';
-    value: string;
-}
-/** Metric ref, context node (`session.duration`), or library node ref. */
- | {
-    kind: 'ref';
-    name: string;
-} | {
-    kind: 'call';
-    name: string;
-    args: ExprNode[];
-}
-/** Effort-exclusion filter argument: `without: rest|pause|rest-*`. */
- | {
-    kind: 'filter';
-    value: string;
-} | {
-    kind: 'unary';
-    op: '-' | 'not';
-    arg: ExprNode;
-} | {
-    kind: 'binary';
-    op: BinaryOp;
-    left: ExprNode;
-    right: ExprNode;
-}
-/** Store-scope WQL selection, e.g. `sum:sessionLoad{} by {day}`. */
- | {
-    kind: 'wql';
-    aggregator: string;
-    metric: string;
-    filters?: string;
-    groupBy?: string[];
-};
-/** A parsed calc line: `name = expr -> unit when predicate`. */
-interface CalcLine {
-    name: string;
-    expr: ExprNode;
-    unit?: string;
-    when?: ExprNode;
-}
-
-/**
- * Exponent-vector dimension model for the composed calculations layer.
- *
- * Dimensions are 5-element exponent vectors over base physical quantities:
- *   [L, M, T, C, E]  =  [length, mass, time, count(reps), energy(cal)]
- *
- * Algebra (docs/composed-calculations-spec.md §5.1):
- *   Dim(a * b) = Dim(a) + Dim(b)
- *   Dim(a / b) = Dim(a) − Dim(b)
- *   Dim(a ± b) requires Dim(a) = Dim(b)   (static registration failure otherwise)
- */
-type DimVector = readonly [number, number, number, number, number];
-declare const DIM_ZERO: DimVector;
-declare const DIM_LENGTH: DimVector;
-declare const DIM_MASS: DimVector;
-declare const DIM_TIME: DimVector;
-declare const DIM_COUNT: DimVector;
-declare const DIM_ENERGY: DimVector;
-declare function addDim(a: DimVector, b: DimVector): DimVector;
-declare function subDim(a: DimVector, b: DimVector): DimVector;
-declare function dimEquals(a: DimVector, b: DimVector): boolean;
-declare function isDimensionless(d: DimVector): boolean;
-/** Human-readable vector, e.g. "T·L⁻¹" for pace. */
-declare function formatDim(d: DimVector): string;
-/**
- * Named compound dimension registry (spec §5.2). Used for diagnostics and
- * dimension-filtered unit suggestions — not required for evaluation.
- */
-declare const NAMED_COMPOUNDS: Record<string, {
-    dim: DimVector;
-    preferredUnits: string[];
-}>;
-/** Reverse lookup: find the compound name for a vector, if one exists. */
-declare function compoundName(d: DimVector): string | undefined;
-
-/**
- * Canonical Node DAG records (spec §2.2) — the storage/registration form for
- * calculations. Seeds are TS object literals (#849); the line-form parser
- * (#863) must round-trip these losslessly.
- */
-
-type CalcOrigin = 'analyzed' | 'analyzed-estimated' | 'user';
-type CalcScope = 'segment' | 'workout' | 'store';
-interface CalcNode {
-    id: string;
-    kind: 'metric' | 'lookup' | 'builtin' | 'wql' | 'expr';
-    expression?: string;
-    ast?: ExprNode;
-    /**
-     * Declared node unit. Named zero-vector casts (AU, pts, MET-min, ratio)
-     * override the computed vector (§5.3 applied to intermediate nodes —
-     * required by TIS-shaped formulas that fold time into a score); any other
-     * unit must match the computed vector.
-     */
-    unit?: string;
-}
-interface CalcVariant {
-    id: string;
-    priority: number;
-    when?: string;
-    whenAst?: ExprNode;
-    origin: CalcOrigin;
-    nodes: Record<string, CalcNode>;
-    /** Node dimensions computed at registration (static check output). */
-    nodeDims?: Record<string, DimVector>;
-}
-interface CalculationDefinition$1 {
-    id: string;
-    kind: 'output' | 'library';
-    scope: CalcScope;
-    fences?: string[];
-    when?: string;
-    whenAst?: ExprNode;
-    variants: CalcVariant[];
-    output?: {
-        nodeId: string | string[];
-        key?: string;
-        emitType?: string;
-        unit?: string;
-        isGrouped?: boolean;
-        /** Group dimensions for grouped emission (e.g. ['effort']). */
-        groupBy?: string[];
-        publishMetadataNodes?: string[];
-        /** Display label for published facts (store-scope rollups). */
-        label?: string;
-    };
-}
-
 /**
  * Context used to select processors for a given workout.
  */
@@ -4590,6 +4455,16 @@ interface AnalyticsProfileContext {
      * they override same-id built-ins and evaluate at high priority.
      */
     calcs?: CalculationDefinition$1[];
+    /**
+     * The tag catalogue — the tags a script can reference and the functions
+     * they carry. A function a tag carries runs where that tag applies.
+     */
+    tags?: TagIndex;
+    /**
+     * Tags active for the whole run, whatever the segments say — the bundle a
+     * profile applies.
+     */
+    activeTags?: readonly string[];
 }
 /**
  * Profile that assembles the realtime and summary processor lists
@@ -4759,6 +4634,13 @@ interface CreateAnalyticsEngineOptions {
     };
     /** User-authored composed calcs (#880), registered after the built-ins. */
     calcs?: CalculationDefinition$1[];
+    /**
+     * The tag catalogue — the tags a script can reference and the functions
+     * they carry.
+     */
+    tags?: TagIndex;
+    /** Tags active for the whole run, whatever the segments say. */
+    activeTags?: readonly string[];
 }
 /**
  * Creates a fully-configured AnalyticsEngine for a workout block.
@@ -5261,6 +5143,14 @@ interface CalcEngineDeps {
     dialect: string;
     lookups: LookupRegistry;
     userProfile?: IProfileSource;
+    /**
+     * The tag catalogue. A function a tag carries runs where that tag applies —
+     * on the segments the tag marked, and at the end of the workout when the
+     * tag was applied anywhere in it.
+     */
+    tags?: TagIndex;
+    /** Tags active for the whole run, whatever the segments say. */
+    activeTags?: readonly string[];
 }
 declare class CalcEngine implements IRealtimeProcessor, ISummaryProcessor {
     private readonly registry;
@@ -5275,7 +5165,32 @@ declare class CalcEngine implements IRealtimeProcessor, ISummaryProcessor {
      * calls (segments arrive in stream order, live and in replay).
      */
     private 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.
+     */
+    private readonly tagCarriedFunctions;
+    /** The tags applied anywhere in the run so far. */
+    private readonly activatedTags;
+    /** The tags the run activates — a note-level bundle of attachments. */
+    private readonly runTags;
     constructor(registry: CalculationRegistry, deps: CalcEngineDeps);
+    /**
+     * 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.
+     */
+    private isActive;
+    /**
+     * 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.
+     */
+    private appliedTags;
     process(output: IOutputStatement): IOutputStatement;
     private appendAnnotation;
     /** A frozen prediction of this type already rides the segment (replay). */
@@ -5327,6 +5242,12 @@ interface CalcStackOptions {
     userProfile?: IProfileSource;
     /** Extra/override calcs (dialect, user) registered after the built-ins. */
     calcs?: CalculationDefinition$1[];
+    /**
+     * The tag catalogue. A function a tag carries runs where that tag applies.
+     */
+    tags?: TagIndex;
+    /** Tags active for the whole run, whatever the segments say. */
+    activeTags?: readonly string[];
 }
 interface CalcStack {
     lookups: LookupRegistry;
@@ -5474,4 +5395,4 @@ declare function diffStatement(expected: MetricLine[], actual: readonly IMetric[
  */
 declare function compareStatement(expectations: MetricLine[], actual: readonly IMetric[], mode: MatchMode): string[];
 
-export { ABSENT, AGGREGATE_BUILTINS, AUTHORITATIVE_CASTS, AbortSessionAction, type ActionDescriptor, type ActionPrimitive, AmrapLogicStrategy, AnalyticsContext, AnalyticsEngine, type AnalyticsProfileContext, type AnalyticsResult, AnalyticsTransformer, BUILTIN_CALCS, BUNDLED_EFFORT_COUNT, BehaviorContext, BehaviorEventListener, BehaviorEventType, type BinaryOp, BlockBuilder, BlockContext, BlockLifecycleOptions, ButtonBehavior, ButtonConfig, CONSUMED_HINTS, CONSUMED_HINT_KEYS, CONTEXT_ATOMS, type CalcAnalysis, type CalculationDefinition$1 as CalcDefinition, type CalcDiagnostic, CalcEngine, type CalcEngineDeps, CalcEvalError, type CalcLine, type CalcNode, type CalcOrigin, CalcParseError, CalcRegistrationError, type CalcScope, type CalcStack, type CalcStackOptions, type UnitDef as CalcUnitDef, CalcUnitError, type CalcVariant, type CalculationDefinition as CalculateBlockDefinition, type CalculateBlockParseError, type CalculateBlockParseResult, CalculateBlockProcessor, type CalculationDefinition$1 as CalculationDefinition, CalculationRegistry, CardioDialect, ChildSelectionBehavior, type ChildSelectionConfig, type ChildSelectionLoopCondition, ChildrenStrategy, ChoiceGroupMetric, ClearChildrenAction, ClimbDialect, type ClimbGradeMetricValue, type ClimbGradeSystem, ClimbMetricType, CompileAndPushBlockAction, type CompiledLineForm, CompletionDecision, CompletionTimestampBehavior, CompositeEffortRegistry, type CompositeEffortRegistryOptions, type ControlsConfig, type CountdownMode, CountdownTimerBehavior, type CountdownTimerConfig, CountupTimerBehavior, type CountupTimerConfig, type CreateAnalyticsEngineOptions, type CreateAnalyticsEngineResult, CrossFitDialect, DAY, DEFAULT_UNRESOLVED_EFFORT_MET, DIM_COUNT, DIM_ENERGY, DIM_LENGTH, DIM_MASS, DIM_TIME, DIM_ZERO, type DayRollup, DialectStack, type DimVector, type Dimension, type DurationPrimitive, EFFORT_DATA_METRIC_TYPE, EffortBlock, type EffortBlockConfig, EffortFallbackStrategy, type EffortPrimitive, EffortRegistrySource, EffortResolutionOptions, EffortResolver, EffortResolverOptions, EffortStorageAdapter, EmitEventAction, EmitSystemOutputAction, type EquipmentParseResult, ErrorAction, type EvalContext, EventBus, EventCallback, EventHandlerOptions, type EventHandlerRegistration, ExecutionContext, type ExecutionSnapshot, type ExecutionStatus, ExitBehavior, type ExitConfig, type ExprNode, FixtureSyntaxError, type FuzzyCandidate, GenericGroupStrategy, GenericLoopStrategy, GenericTimerStrategy, HabitsDialect, type HeadingPrimitive, IAnalyticsEngine, type IAnalyticsProfile, IAnchorValue, IBehaviorContext, IBlockContext, type ICastSubscription, IEffort, IEffortRegistry, IEffortResolver, IEquipment, IEvent, IEventBus, IEventHandler, IJitCompiler, type ILookupTable, IMemoryLocation, IMemoryReference, type IMetricPresentationPolicy, INowProvider, type IProfileSource, IRealtimeProcessor, IRuntimeAction, IRuntimeActionable, IRuntimeBehavior, IRuntimeBlock, type IRuntimeBlockStrategy, IRuntimeClock, type IRuntimeEventProvider, type IRuntimeFactory, IRuntimeMemory, IRuntimeStack, type IRuntimeSubscription, IScriptRuntime, ISummaryProcessor, InMemoryEffortRegistry, IntervalLogicStrategy, JitCompiler, LabelingBehavior, type LabelingConfig, type LapPrimitive, type LineFormScope, type LineLocator, type LiteralKind, LocalEventProvider, LocalRuntimeSubscription, type LogLevel, type LoggableOutput, type LookupFieldDef, type LookupLayer, LookupRegistry, type MatchMode, MdTimerRuntime, type MemoryEntry, MemoryTag, MemoryTypeEnum, type MetricLine, type MetricObjectPrimitive, type MetricPresentationSurface, type MetricPresentationToken, MetricPromotionBehavior, type MetricPromotionConfig, type MetricRenderKind, type MetricTone, MetricVisibility, type MockClock, NAMED_COMPOUNDS, NextAction, NextEvent, NextEventHandler, OutputEmitter, OutputListener, PREDEFINED_SOUNDS, PRODUCTION_STRATEGIES, type ParseOptions, type ParseReferences, type ParseResult, type ParserConfig, PlaySoundAction, PopBlockAction, type PredefinedSoundName, ProjectionResult, type PromotionRule, type PropertyPrimitive, PushBlockAction, PushRestBlockAction, type QuantityPrimitive, REST_EXCLUSION, RPE_LABELS, RUNTIME_LOG_SUBJECT_WIDTH, ReferenceIndex, ReferenceResolutionDefaults, RegisterEventHandlerAction, Registry, ReportOutputBehavior, type ReportOutputConfig, ReportOutputStrategy, ResolvedEffort, type ResolvedEffortData, RestBlock, type RestBlockConfig, type RoundSchemePrimitive, RoundsMetric, type RoundsPrimitive, RuntimeAdapter, RuntimeBlock, type RuntimeBlockOptions, RuntimeBuilder, type RuntimeButton, RuntimeClock, type RuntimeController, type RuntimeControls, RuntimeError, RuntimeFactory, type RuntimeLogEntry, RuntimeLogger, RuntimeMemory, type RuntimeMemoryLocation, RuntimeObservers, RuntimeStack, RuntimeStackOptions, STANDARD_UNITS, STORE_CALCS, STREAM_ATOMS, ScriptRuntime, type SegmentWithMetadata, SessionRootBlock, type SessionRootConfig, SessionRootStrategy, SnapshotClock, type SoundBehaviorConfig, type SoundCue, SoundCueBehavior, type SoundCueConfig, type SoundCueState, type SoundState, SoundStrategy, type SourceInput, type SpanList, SpanTrackingBehavior, StackListener, StackObserver, StackSnapshot, StandardAnalyticsProfile, StartSessionAction, type StartSessionOptions, StartWorkoutAction, type StartWorkoutOptions, type StatementMetricDiff, type StaticEnv, type StreamAtomDef, SubscribeOptions, SubscriptionManager, type SyntaxFacts, type SyntaxMeta, type SyntaxPrimitive, type SyntaxStatement, TestableBlockConfig, type TextPrimitive, ThrowError, ThrowErrorAction, TimeSpan, TimerState, TwoPassEffortResolutionProcess, TypedMemoryReference, UNITS, type UnitDef$1 as UnitDef, type UnitMatch, UnitRegistry, UnitSet, UnitsDialect, UnregisterEventHandlerAction, Unsubscribe, UpdateNextPreviewAction, type Val, WaitingToStartBlock, WaitingToStartInjectorBehavior, WhiteboardScript, WodDialect, YogaDialect, addAliasToEffort, addDim, buildStaticLookups, buildTooltip, bundledEfforts, calculateElapsed, canonicalizeType, checkCalcLine, classifyStatements, closeCurrentSpan, collapseUnresolvedChoices, commonFixtureSet, compareStatement, compileLineForm, composeDivUnit, composeMulUnit, compoundName, computeColumnLabel, computeLabel, computeWorkloadRollups, convertScalar, createAnalyticsEngineForBlock, createCalcEngine, createCalcStack, createCompiler, createDialectStack, createDisciplinesTable, createEffortTable, createLineLocator, createPolicy as createMetricPresentationPolicy, createMockClock, createParser, createProfileTable, createRpeLabelsTable, dailySessionLoads, dayBucket, dialectRegistry, dialectStack, diffStatement, dimEquals, documentToEffort, documentToEquipment, effortToDocument, equipmentToDocument, evaluate, evaluateCalculateDefinitions, extractEffortData, extractMetrics, extractStatements, extractStatementsRaw, extractSyntaxFacts, findBestFuzzyMatch, findUnresolvedChoices, fixtureBackSquat, fixtureBurpee, fixturePlank, fixtureRowing, fixtureRunning, fixtureUserCustom, fixtureUserOverride, formatDim, formatDuration, formatRuntimeLogLine, formatRuntimeLogRule, formatRuntimeTimestamp, metricsToLabel as fragmentsToLabel, fullFixtureSet, fuseUnits, fuseUnitsInMetrics, getAnalyticsFromLogs, getAnalyticsFromRuntime, getHints, getUnit, hasHint, hintMetric, hintsToContainer, inferDim, isCastSubscription, isChoiceResolved, isDimensionless, 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, startSpan, str, strategyRegistry, subDim, summaryProcessorRegistry, toStoredOutputStatement, truthy, validateOutputUnit, parser as whiteboardParser, whiteboardScript, whiteboardScriptLanguage, writeChoiceSelection };
+export { ABSENT, AGGREGATE_BUILTINS, AUTHORITATIVE_CASTS, AbortSessionAction, type ActionDescriptor, type ActionPrimitive, AmrapLogicStrategy, AnalyticsContext, AnalyticsEngine, type AnalyticsProfileContext, type AnalyticsResult, AnalyticsTransformer, BUILTIN_CALCS, BUNDLED_EFFORT_COUNT, BehaviorContext, BehaviorEventListener, BehaviorEventType, BlockBuilder, BlockContext, BlockLifecycleOptions, ButtonBehavior, ButtonConfig, CONSUMED_HINTS, CONSUMED_HINT_KEYS, CONTEXT_ATOMS, type CalcAnalysis, CalculationDefinition$1 as CalcDefinition, type CalcDiagnostic, CalcEngine, type CalcEngineDeps, CalcEvalError, CalcLine, CalcParseError, CalcRegistrationError, CalcScope, type CalcStack, type CalcStackOptions, type UnitDef as CalcUnitDef, CalcUnitError, type CalculationDefinition as CalculateBlockDefinition, type CalculateBlockParseError, type CalculateBlockParseResult, CalculateBlockProcessor, CalculationDefinition$1 as CalculationDefinition, CalculationRegistry, CardioDialect, ChildSelectionBehavior, type ChildSelectionConfig, type ChildSelectionLoopCondition, ChildrenStrategy, ChoiceGroupMetric, ClearChildrenAction, ClimbDialect, type ClimbGradeMetricValue, type ClimbGradeSystem, ClimbMetricType, CompileAndPushBlockAction, type CompiledLineForm, CompletionDecision, CompletionTimestampBehavior, CompositeEffortRegistry, type CompositeEffortRegistryOptions, type ControlsConfig, type CountdownMode, CountdownTimerBehavior, type CountdownTimerConfig, CountupTimerBehavior, type CountupTimerConfig, type CreateAnalyticsEngineOptions, type CreateAnalyticsEngineResult, CrossFitDialect, DAY, DEFAULT_UNRESOLVED_EFFORT_MET, type DayRollup, DialectStack, DimVector, type Dimension, type DurationPrimitive, EFFORT_DATA_METRIC_TYPE, EffortBlock, type EffortBlockConfig, EffortFallbackStrategy, type EffortPrimitive, EffortRegistrySource, EffortResolutionOptions, EffortResolver, EffortResolverOptions, EffortStorageAdapter, EmitEventAction, EmitSystemOutputAction, type EquipmentParseResult, ErrorAction, type EvalContext, EventBus, EventCallback, EventHandlerOptions, type EventHandlerRegistration, ExecutionContext, type ExecutionSnapshot, type ExecutionStatus, ExitBehavior, type ExitConfig, ExprNode, FixtureSyntaxError, type FuzzyCandidate, GenericGroupStrategy, GenericLoopStrategy, GenericTimerStrategy, HabitsDialect, type HeadingPrimitive, IAnalyticsEngine, type IAnalyticsProfile, IAnchorValue, IBehaviorContext, IBlockContext, type ICastSubscription, IEffort, IEffortRegistry, IEffortResolver, IEquipment, IEvent, IEventBus, IEventHandler, IJitCompiler, type ILookupTable, IMemoryLocation, IMemoryReference, type IMetricPresentationPolicy, INowProvider, type IProfileSource, IRealtimeProcessor, IRuntimeAction, IRuntimeActionable, IRuntimeBehavior, IRuntimeBlock, type IRuntimeBlockStrategy, IRuntimeClock, type IRuntimeEventProvider, type IRuntimeFactory, IRuntimeMemory, IRuntimeStack, type IRuntimeSubscription, IScriptRuntime, ISummaryProcessor, InMemoryEffortRegistry, IntervalLogicStrategy, JitCompiler, LabelingBehavior, type LabelingConfig, type LapPrimitive, type LineFormScope, type LineLocator, type LiteralKind, LocalEventProvider, LocalRuntimeSubscription, type LogLevel, type LoggableOutput, type LookupFieldDef, type LookupLayer, LookupRegistry, MAX_TAG_CONTRIBUTION_DEPTH, type MatchMode, MdTimerRuntime, type MemoryEntry, MemoryTag, MemoryTypeEnum, type MetricLine, type MetricObjectPrimitive, type MetricPresentationSurface, type MetricPresentationToken, MetricPromotionBehavior, type MetricPromotionConfig, type MetricRenderKind, type MetricTone, MetricVisibility, type MockClock, NextAction, NextEvent, NextEventHandler, OutputEmitter, OutputListener, PRODUCTION_STRATEGIES, type ParseOptions, type ParseReferences, type ParseResult, type ParserConfig, PopBlockAction, ProjectionResult, type PromotionRule, type PropertyPrimitive, PushBlockAction, PushRestBlockAction, type QuantityPrimitive, REST_EXCLUSION, RPE_LABELS, RUNTIME_LOG_SUBJECT_WIDTH, ReferenceIndex, ReferenceResolutionDefaults, RegisterEventHandlerAction, Registry, ReportOutputBehavior, type ReportOutputConfig, ReportOutputStrategy, ResolvedEffort, type ResolvedEffortData, type ResolvedTagContributions, RestBlock, type RestBlockConfig, type RoundSchemePrimitive, RoundsMetric, type RoundsPrimitive, RuntimeAdapter, RuntimeBlock, type RuntimeBlockOptions, RuntimeBuilder, type RuntimeButton, RuntimeClock, type RuntimeController, type RuntimeControls, RuntimeError, RuntimeFactory, type RuntimeLogEntry, RuntimeLogger, RuntimeMemory, type RuntimeMemoryLocation, RuntimeObservers, RuntimeStack, RuntimeStackOptions, SOUND_PLAY_EVENT, SOUND_PROFILE_METRIC, STANDARD_UNITS, STORE_CALCS, STREAM_ATOMS, ScriptRuntime, type SegmentWithMetadata, SessionRootBlock, type SessionRootConfig, SessionRootStrategy, SnapshotClock, SoundProfile, SoundProfileBehavior, type SoundProfileBehaviorConfig, SoundStrategy, type SourceInput, type SpanList, SpanTrackingBehavior, StackListener, StackObserver, StackSnapshot, StandardAnalyticsProfile, StartSessionAction, type StartSessionOptions, StartWorkoutAction, type StartWorkoutOptions, type StatementMetricDiff, type StaticEnv, type StreamAtomDef, SubscribeOptions, SubscriptionManager, type SyntaxFacts, type SyntaxMeta, type SyntaxPrimitive, type SyntaxStatement, TAG_MARKER_PREFIX, type TagRefPrimitive, TestableBlockConfig, type TextPrimitive, ThrowError, ThrowErrorAction, TimeSpan, TimerState, TwoPassEffortResolutionProcess, TypedMemoryReference, UNITS, type UnitDef$1 as UnitDef, type UnitMatch, UnitRegistry, UnitSet, UnitsDialect, UnregisterEventHandlerAction, Unsubscribe, UpdateNextPreviewAction, type Val, WaitingToStartBlock, WaitingToStartInjectorBehavior, WhiteboardScript, WodDialect, YogaDialect, addAliasToEffort, buildStaticLookups, buildTooltip, bundledEfforts, calculateElapsed, canonicalizeType, checkCalcLine, classifyStatements, closeCurrentSpan, collapseUnresolvedChoices, commonFixtureSet, compareStatement, compileLineForm, composeDivUnit, composeMulUnit, computeColumnLabel, computeLabel, computeWorkloadRollups, convertScalar, createAnalyticsEngineForBlock, createCalcEngine, createCalcStack, createCompiler, createDialectStack, createDisciplinesTable, createEffortTable, createLineLocator, createPolicy as createMetricPresentationPolicy, createMockClock, createParser, createProfileTable, createRpeLabelsTable, dailySessionLoads, dayBucket, dialectRegistry, dialectStack, diffStatement, documentToEffort, documentToEquipment, effortToDocument, equipmentToDocument, evaluate, evaluateCalculateDefinitions, extractEffortData, extractMetrics, extractStatements, extractStatementsRaw, extractSyntaxFacts, findBestFuzzyMatch, findTagContributionCycles, findUnresolvedChoices, fixtureBackSquat, fixtureBurpee, fixturePlank, fixtureRowing, fixtureRunning, fixtureUserCustom, fixtureUserOverride, formatDuration, formatRuntimeLogLine, formatRuntimeLogRule, formatRuntimeTimestamp, metricsToLabel as fragmentsToLabel, fullFixtureSet, fuseUnits, fuseUnitsInMetrics, getAnalyticsFromLogs, getAnalyticsFromRuntime, getHints, getUnit, hasHint, hintMetric, hintsToContainer, inferDim, isCastSubscription, isChoiceResolved, 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, resolveSoundProfile, resolveTagContributions, startSpan, str, strategyRegistry, summaryProcessorRegistry, tagContributionMetrics, tagMarkerSlug, tagMarkerSlugs, tagMarkerType, toStoredOutputStatement, truthy, validateOutputUnit, parser as whiteboardParser, whiteboardScript, whiteboardScriptLanguage, writeChoiceSelection };