@bitcobblers/wod-wiki-lang 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4076 @@
+import { IMetric, MetricContainer, MetricOrigin, MetricType, IDialect, ICodeStatement, DialectAnalysis, ParsedCodeStatement, IOutputStatement, OutputStatementType, BlockKey, ScriptBlock, FenceDialect, Segment, AnalyticsGroup, StoredOutputStatement, OutputStatement } from '@bitcobblers/wod-wiki-core';
+export { ParseError } from '@bitcobblers/wod-wiki-core';
+import { Tree } from '@lezer/common';
+import { W as WhiteboardScript, I as IScript, a as IEffortResolver, b as IEffortRegistry, E as EffortResolverOptions, c as IEffort, d as EffortResolutionOptions, R as ResolvedEffort, e as EffortRegistrySource, f as IRuntimeActionable, g as IEventBus, h as IRuntimeStack, i as IRuntimeClock, j as IJitCompiler, k as INowProvider, l as RuntimeStackOptions, m as RuntimeError, A as AnalyticsContext, n as IEvent, o as IRuntimeAction, O as OutputListener, U as Unsubscribe, p as IAnalyticsEngine, q as IRuntimeBlock, r as IBehaviorContext, B as BehaviorEventType, s as BehaviorEventListener, S as SubscribeOptions, t as Unsubscribe$1, u as OutputOptions, M as MemoryTag, v as IMemoryLocation, w as IRuntimeBehavior, x as IBlockContext, y as MetricVisibility, z as BlockLifecycleOptions, C as CompletionDecision, T as TimeSpan, D as IRuntimeMemory, F as TypedMemoryReference, G as MemorySearchCriteria, H as IMemoryReference, J as StackObserver, K as StackSnapshot, L as StackListener, N as MemoryTypeEnum, P as IAnchorValue, Q as IEventHandler, V as HandlerScope, X as IScriptRuntime, Y as TestableBlockConfig, Z as IRuntimeOptions, _ as ScriptRuntime, $ as EventHandlerOptions, a0 as EventCallback, a1 as TimerState, a2 as IRealtimeProcessor, a3 as ISummaryProcessor, a4 as ProjectionResult } from './browserRuntimeNow-SxxdmtB7.js';
+export { a5 as ButtonConfig, a6 as ButtonVariant, a7 as ButtonsState, a8 as ChildrenStatusState, a9 as CompletionState, aa as DEFAULT_RESOLVER_OPTIONS, ab as DISCIPLINE_FACTORS, ac as DisplayState, ad as EFFORT_DISCIPLINES, ae as EFFORT_REGISTRY_ORIGINS, af as EffortBaseAttributes, ag as EffortDerivation, ah as EffortDiscipline, ai as EffortResolvedFrom, aj as FenceDialect, ak as FragmentDisplayState, al as FragmentState, am as IAnalyticsProcessorDescriptor, an as INTENSITY_TIERS, ao as IntensityTier, ap as MemoryLocation, aq as MemoryType, ar as MemoryTypeMap, as as MemoryValueOf, at as RoundState, au as RuntimeState, av as ScriptRuntimeDependencies, aw as TimerDirection, ax as VISIBILITY_ICONS, ay as VISIBILITY_LABELS, az as createBrowserRuntimeNow, aA as disciplineFactorFor, aB as filterTagsByVisibility, aC as frozenNow, aD as getMetricVisibility, aE as getRuntimeNowMs, aF as isEffortDiscipline, aG as isFragmentTag, aH as wallClockNow } from './browserRuntimeNow-SxxdmtB7.js';
+import { LanguageSupport, LRLanguage } from '@codemirror/language';
+import { LRParser } from '@lezer/lr';
+
+/**
+ * Registry — one registration story for every consumer-facing extension point.
+ *
+ * Used for dialects, compiler strategies, realtime analytics processors,
+ * and summary analytics processors. Replaces the previous hardcoded
+ * `createDialectStack(overrides)`, `PRODUCTION_STRATEGIES`, and
+ * `StandardAnalyticsProfile.allRealtime`/`allSummary` flat arrays with
+ * one shape: a priority-ordered map keyed by `id`, with consumer-facing
+ * `register` / `unregister` / `list` so a third party can extend the
+ * library without forking the repository.
+ *
+ * The constructor seeds the registry with the built-in defaults. Built-ins
+ * can still be overridden (or removed) by registering an entry with the
+ * same `id` (or calling `unregister(id)`).
+ *
+ * @typeParam T Items must expose an `id: string` and an optional
+ *           `priority: number`; `list()` returns them sorted by descending
+ *           priority, matching the contract strategies, dialects, and
+ *           processors already follow.
+ */
+declare class Registry<T extends {
+    id: string;
+    priority?: number;
+}> {
+    private items;
+    constructor(defaults?: readonly T[]);
+    /**
+     * Register an item. If an item with the same `id` already exists it is
+     * replaced (mirrors "last registration wins" already used for dialect
+     * metric merges).
+     *
+     * Use {@link unregister} first if you need strict rejection of duplicates.
+     */
+    register(item: T): void;
+    /** Remove the item registered under `id`. No-op if not present. */
+    unregister(id: string): void;
+    /** Whether an item is currently registered under `id`. */
+    has(id: string): boolean;
+    /**
+     * Get the item registered under `id`, or `undefined` if absent.
+     */
+    get(id: string): T | undefined;
+    /**
+     * Items in descending `priority` order (highest first). Items without
+     * an explicit priority are treated as priority 0.
+     */
+    list(): T[];
+    /** Number of currently registered items. */
+    get size(): number;
+}
+
+/**
+ * Hint helpers + canonical hint vocabulary contract.
+ *
+ * A "hint" is a dot-namespaced string (e.g. `workout.amrap`,
+ * `behavior.required_timer`) that dialects, effort markdown files, and the
+ * parser attach to a statement so that compiler strategies and the label
+ * composer can make decisions. Hints used to live in a parallel `Set<string>`
+ * channel on the statement; they now flow through the single metric channel
+ * as {@link MetricType.Hint} metrics.
+ *
+ * Hint metrics are deliberately excluded from display resolution
+ * (see ownership `legacyAdapters`) and from runtime block fragments
+ * (see `BlockBuilder.setFragments`), so they never surface as visible metrics.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * CANONICAL HINT VOCABULARY (Tier 3 §3.2)
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * A new dialect or effort author can self-serve the answer to "which
+ * hints are actually consumed by the runtime?" by reading
+ * {@link CONSUMED_HINTS}. Any other hint key is **analytics-only** today:
+ * it reaches the output stream and processors, but does not affect
+ * compilation, label generation, or exit ordering. There is no hidden
+ * "the strategy that consumes this hint" to discover.
+ *
+ * Categories:
+ *
+ * - **compiler-consumed** — `BEHAVIOR_REPEATING_INTERVAL`,
+ *   `BEHAVIOR_REQUIRED_TIMER`, `BEHAVIOR_INJECT_REST`. Setting one of these
+ *   from a dialect (or an effort — see Tier 3 §3.3) flips a strategy-level
+ *   decision at compile time (e.g. IntervalLogicStrategy matches on
+ *   `BEHAVIOR_REPEATING_INTERVAL`).
+ * - **label-consumed** — `LABEL_AMRAP`, `LABEL_EMOM`, `LABEL_TABATA`,
+ *   `LABEL_FOR_TIME`. These override the generated label in
+ *   `LabelComposer.getLogicKeyword` (the only consumer).
+ * - **analytics-only / sport-domain** — every other hint a sport dialect
+ *   emits (e.g. `workout.run`, `ClimbMetricType.Grade`, `domain.climb.*`)
+ *   is intentionally analytics-only: it surfaces on the output stream
+ *   for processors and review-grid consumers, and never affects
+ *   compilation. If you write a custom analytics processor, gate it via
+ *   `requiredMetrics` (see `IAnalyticsProcessorDescriptor`) — not by
+ *   inventing a new hint.
+ *
+ * If you need a new compiler-consumed or label-consumed hint, add it
+ * here and update the consumer(s) in the same PR. If you only need
+ * analytics-only data, emit a regular `MetricType.Metric` (or a
+ * domain-specific MetricType) — no new hint key required.
+ */
+/** Hint keys currently consumed by compiler strategies or the label composer. */
+declare const CONSUMED_HINTS: {
+    /** IntervalLogicStrategy: treats the block as an EMOM-style repeating interval. */
+    readonly REPEATING_INTERVAL: "behavior.repeating_interval";
+    /** GenericTimerStrategy: block cannot be skipped past until timer:complete fires. */
+    readonly REQUIRED_TIMER: "behavior.required_timer";
+    /** GenericTimerStrategy: injects a rest block between repeating intervals. */
+    readonly INJECT_REST: "behavior.inject_rest";
+    /** LabelComposer: overrides the generated label with a workout-type name. */
+    readonly LABEL_AMRAP: "workout.amrap";
+    readonly LABEL_EMOM: "workout.emom";
+    readonly LABEL_TABATA: "workout.tabata";
+    readonly LABEL_FOR_TIME: "workout.for_time";
+};
+/** Derived from CONSUMED_HINTS — useful for runtime validation ("is this hint consumed?"). */
+declare const CONSUMED_HINT_KEYS: readonly string[];
+/** A read surface that exposes metrics, via `rawMetrics` or a `metrics` field. */
+interface MetricBearing {
+    rawMetrics?: IMetric[];
+    metrics?: MetricContainer | IMetric[];
+}
+/** Create a single hint metric. */
+declare function hintMetric(hint: string, origin?: MetricOrigin): IMetric;
+/**
+ * Build (or extend) a {@link MetricContainer} of hint metrics from a list of
+ * hint strings. Duplicate hint strings are collapsed.
+ */
+declare function hintsToContainer(hints: readonly string[], existing?: MetricContainer, origin?: MetricOrigin): MetricContainer;
+/** All hint strings carried by a metric-bearing source. */
+declare function getHints(source: MetricBearing | undefined): string[];
+/** Whether a metric-bearing source carries a given hint. */
+declare function hasHint(source: MetricBearing | undefined, hint: string): boolean;
+
+/**
+ * Unit Registry — the core catalog of measurement units.
+ *
+ * Units are NOT a parser concept. The parser emits bare Number and Text; a
+ * {@link UnitSet} (imported by a Dialect) identifies which text tokens are units
+ * and what {@link Dimension} they measure. See CONTEXT.md → "Units of measurement".
+ *
+ * This module is pure data + lookup. It has no dependency on metric classes,
+ * the parser, or dialects — those import from here, never the reverse.
+ */
+/** The physical quantity a {@link UnitDef} measures. */
+type Dimension = 'length' | 'mass' | 'energy' | 'count' | 'time';
+/** A single recognized unit: its canonical spelling, dimension, and aliases. */
+interface UnitDef$1 {
+    /** Canonical, normalized spelling (e.g. `m`, `kg`, `cal`). */
+    readonly canonical: string;
+    /** What the unit measures. */
+    readonly dimension: Dimension;
+    /** Alternate spellings / acronyms (e.g. `lb` ← `lbs`, `pound`, `pounds`). */
+    readonly aliases: readonly string[];
+}
+/** Result of peeling a leading unit token off raw text. */
+interface UnitMatch {
+    /** The matched canonical unit definition. */
+    readonly unit: UnitDef$1;
+    /** The exact token as it appeared in the source (e.g. `miles`). */
+    readonly token: string;
+    /** Remaining text after the consumed unit token (whitespace-trimmed). */
+    readonly rest: string;
+}
+/**
+ * An importable, composable set of {@link UnitDef}s.
+ *
+ * Lookups are case-insensitive across canonical spellings and aliases. Sets
+ * compose with {@link extend}: on a token collision the later definition wins,
+ * which is how a Dialect overrides a base unit.
+ */
+declare class UnitSet {
+    /** Definitions in priority order (later entries override earlier on token collision). */
+    private readonly defs;
+    private readonly byToken;
+    constructor(defs?: readonly UnitDef$1[]);
+    /** Look up a unit by canonical spelling or alias (case-insensitive). */
+    get(token: string): UnitDef$1 | undefined;
+    /** Whether the token is a recognized unit (canonical or alias). */
+    has(token: string): boolean;
+    /**
+     * Peel a leading unit token off the front of `text`.
+     *
+     * Returns `null` when the first whitespace/letter-delimited word is not a
+     * recognized unit — this is what keeps `5 Burpees` from ever fusing while
+     * `4 mile Run` → `{ unit: mile, rest: "Run" }`.
+     */
+    consumeLeading(text: string): UnitMatch | null;
+    /**
+     * Compose into a new set. Later units override earlier ones on token
+     * collision — the mechanism a Dialect uses to add or redefine units.
+     */
+    extend(...units: UnitDef$1[]): UnitSet;
+    /** All definitions in priority order. */
+    toArray(): UnitDef$1[];
+}
+/**
+ * The base catalog applied at the bottom of the Dialect Stack. Sport and
+ * personal dialects extend or override these via {@link UnitSet.extend}.
+ */
+declare const STANDARD_UNITS: readonly UnitDef$1[];
+/**
+ * Factory for {@link UnitSet}s. `standard()` is the base catalog; `of()` builds
+ * a custom set a Dialect can stack on top.
+ */
+declare const UnitRegistry: {
+    /** The base catalog used by the base Units Dialect. */
+    standard(): UnitSet;
+    /** Build a set from arbitrary definitions. */
+    of(units: readonly UnitDef$1[]): UnitSet;
+};
+
+/**
+ * Named display surface — each has distinct visibility and formatting rules.
+ */
+type MetricPresentationSurface = 'runtime-badge' | 'timer-subtitle' | 'history-label' | 'review-grid-cell' | 'review-grid-column' | 'label-composer' | 'debug';
+type MetricRenderKind = 'badge' | 'comment' | 'plain-text' | 'column-heading' | 'hidden';
+type MetricTone = 'time' | 'rep' | 'effort' | 'distance' | 'rounds' | 'action' | 'resistance' | 'rest' | 'muted' | 'system' | 'unknown';
+interface MetricPresentationToken {
+    readonly metric: IMetric;
+    /** Computed display text (e.g., "3 Rounds", "1:30", "Pushups") */
+    readonly label: string;
+    /** Hover tooltip text */
+    readonly tooltip: string;
+    readonly renderKind: MetricRenderKind;
+    readonly tone: MetricTone;
+    /** Icon key (maps to getMetricIcon — null if no icon) */
+    readonly iconKey: string | null;
+    readonly visible: boolean;
+    /** True for group(+/-) and lap structural markers */
+    readonly structural: boolean;
+    /** True for effort metrics whose value is "Rest" */
+    readonly rest: boolean;
+    /** True for parser-origin text metrics (coach annotations) */
+    readonly comment: boolean;
+    /** True for user-origin metrics (user override in review grid) */
+    readonly userEntered: boolean;
+    /** Column label for review-grid-column surface */
+    readonly columnLabel?: string;
+}
+interface IMetricPresentationPolicy {
+    present(metric: IMetric, surface: MetricPresentationSurface): MetricPresentationToken;
+    presentGroup(metrics: readonly IMetric[], surface: MetricPresentationSurface): MetricPresentationToken[];
+    columnLabel(type: MetricType | string): string;
+    isStructural(metric: IMetric): boolean;
+    isHidden(metric: IMetric, surface: MetricPresentationSurface): boolean;
+}
+
+declare function createPolicy(): IMetricPresentationPolicy;
+/**
+ * Singleton policy instance for app code.
+ * Use `createMetricPresentationPolicy()` in tests for isolated instances.
+ */
+declare const metricPresentation: IMetricPresentationPolicy;
+
+declare function isTimeLikeMetric(type: MetricType | string): boolean;
+/**
+ * Compute the display label for a metric on a given surface.
+ * All per-type formatting rules live here — nowhere else.
+ */
+declare function computeLabel(metric: IMetric, _surface: MetricPresentationSurface): string;
+/**
+ * Build a tooltip string for a metric — identical to the existing buildTooltip
+ * in MetricPill so callers can migrate without losing fidelity.
+ */
+declare function buildTooltip(metric: IMetric): string;
+declare function computeColumnLabel(type: MetricType | string): string;
+
+/**
+ * Base Units Dialect — the bottom of the Dialect Stack.
+ *
+ * The parser is unit-agnostic: it emits bare Number and Text. This dialect's
+ * {@link transform} fuses adjacent Number + unit-word metrics into dimensioned
+ * metrics (Distance / Resistance / energy …) using the core {@link UnitRegistry}.
+ *
+ * It contributes no hints — units are a rewrite, not a marker — so {@link analyze}
+ * returns nothing. Sport dialects stack on top and may extend the unit set; a
+ * personal-overrides dialect can sit last. Because fusion is idempotent, this
+ * dialect is safe to run in both the parse pipeline and the compile-time stack.
+ */
+declare class UnitsDialect implements IDialect {
+    id: string;
+    name: string;
+    private readonly units;
+    /**
+     * @param units the unit set to recognize. Defaults to the standard catalog;
+     *   pass an extended set (e.g. `UnitRegistry.standard().extend(...)`) to add
+     *   or override units.
+     */
+    constructor(units?: UnitSet);
+    transform(statement: ICodeStatement): void;
+    analyze(_statement: ICodeStatement): DialectAnalysis;
+}
+
+/**
+ * CrossFit dialect for recognizing CrossFit-specific workout patterns.
+ *
+ * Recognizes:
+ * - AMRAP: "As Many Rounds As Possible" - time-bound workout
+ * - EMOM: "Every Minute On the Minute" - repeating interval workout
+ * - FOR TIME: Time-capped workout with completion goal
+ * - TABATA: High-intensity interval protocol (20s work / 10s rest)
+ */
+declare class CrossFitDialect implements IDialect {
+    id: string;
+    name: string;
+    /**
+     * Check if any Action or Effort metrics contains a keyword (case-insensitive)
+     */
+    private hasKeyword;
+    /**
+     * Check if statement has children (is a parent block)
+     */
+    private hasChildren;
+    analyze(statement: ICodeStatement): DialectAnalysis;
+}
+
+/**
+ * WOD (Workout of the Day) dialect for recognizing general structured workout patterns.
+ *
+ * Recognizes:
+ * - STRENGTH: Heavy barbell / loaded movement blocks
+ * - METCON: Metabolic conditioning blocks
+ * - SKILLS: Skill/technique practice blocks
+ * - WOD: Explicit "WOD" keyword
+ * - SUPERSET: Multiple exercises grouped with no rest
+ *
+ * Emitted hints (dot-namespaced):
+ *   domain.wod            - any statement processed by this dialect
+ *   workout.strength      - heavy loaded-movement block
+ *   workout.metcon        - metabolic conditioning block
+ *   workout.skills        - skill/technique block
+ *   workout.superset      - superset / paired-set block
+ *   behavior.load_bearing - statement involves significant external load
+ */
+declare class WodDialect implements IDialect {
+    id: string;
+    name: string;
+    /** Case-insensitive keyword check on Action/Effort metrics */
+    private hasKeyword;
+    analyze(statement: ICodeStatement): DialectAnalysis;
+}
+
+/**
+ * Cardio dialect for recognizing endurance/aerobic workout patterns.
+ *
+ * Recognizes:
+ * - RUN / JOG / SPRINT: Running activities
+ * - ROW: Rowing (erg, water)
+ * - BIKE / CYCLE: Cycling activities
+ * - SWIM: Swimming
+ * - WALK: Walking / recovery activity
+ * - Distance-only statements (e.g. "5km", "400m") without explicit activity
+ *
+ * Emitted hints (dot-namespaced):
+ *   domain.cardio              - any statement processed by this dialect
+ *   workout.run                - running activity
+ *   workout.row                - rowing activity
+ *   workout.bike               - cycling activity
+ *   workout.swim               - swimming activity
+ *   workout.walk               - walking activity
+ *   behavior.distance_based    - primary metric is distance
+ *   behavior.pace_based        - pacing / splits are relevant
+ *   behavior.aerobic           - sustained aerobic effort
+ */
+declare class CardioDialect implements IDialect {
+    id: string;
+    name: string;
+    private hasKeyword;
+    private hasDistance;
+    analyze(statement: ICodeStatement): DialectAnalysis;
+}
+
+/**
+ * Yoga dialect for recognizing yoga and mindfulness practice patterns.
+ *
+ * Recognizes:
+ * - Pose holds: duration-based single poses (e.g. "Warrior II :60")
+ * - Flows: sequences of poses (e.g. "Sun Salutation x5")
+ * - Breathing exercises: pranayama patterns
+ * - Meditation: seated/silent practice blocks
+ * - Explicit pose names (a curated vocabulary of common poses)
+ *
+ * Emitted hints (dot-namespaced):
+ *   domain.yoga          - any statement processed by this dialect
+ *   workout.pose         - single pose hold
+ *   workout.flow         - sequence / vinyasa flow
+ *   workout.breathing    - pranayama / breathing exercise
+ *   workout.meditation   - seated meditation block
+ *   behavior.hold        - timed static hold
+ *   behavior.mindful     - mindfulness / attention cue
+ */
+declare class YogaDialect implements IDialect {
+    id: string;
+    name: string;
+    /**
+     * Common yoga pose keywords.
+     * TODO: Expand this list as the dialect matures.
+     */
+    private static readonly POSE_KEYWORDS;
+    private static readonly FLOW_KEYWORDS;
+    private static readonly BREATHING_KEYWORDS;
+    private static readonly MEDITATION_KEYWORDS;
+    private hasAnyKeyword;
+    analyze(statement: ICodeStatement): DialectAnalysis;
+}
+
+/**
+ * Habits dialect for tracking daily/recurring habit completions.
+ *
+ * Recognizes:
+ * - Daily habits: single-completion items logged once per day
+ * - Recurring habits: timed or rep-counted recurring actions
+ * - Streaks: consecutive day tracking
+ * - Check-off items: boolean "did I do this?" entries
+ *
+ * Emitted hints (dot-namespaced):
+ *   domain.habits           - any statement processed by this dialect
+ *   behavior.daily          - once-a-day completion
+ *   behavior.completable    - boolean done/not-done state
+ *   behavior.streak         - streak-relevant (consecutive occurrences matter)
+ *   behavior.recurring      - repeats on a schedule
+ *   workout.habit_check     - single check-off habit
+ *   workout.habit_timed     - habit with a target duration (e.g. "Meditate :10:00")
+ *   workout.habit_rep       - habit with a target count (e.g. "10 Pushups daily")
+ */
+declare class HabitsDialect implements IDialect {
+    id: string;
+    name: string;
+    /**
+     * Keywords that indicate a habit/daily-tracking context.
+     * TODO: Expand as habit vocabulary is refined.
+     */
+    private static readonly HABIT_KEYWORDS;
+    private static readonly STREAK_KEYWORDS;
+    private hasAnyKeyword;
+    analyze(statement: ICodeStatement): DialectAnalysis;
+}
+
+declare const ClimbMetricType: {
+    readonly Discipline: "climb-discipline";
+    readonly Grade: "climb-grade";
+    readonly SendType: "climb-send-type";
+    readonly AttemptCount: "climb-attempt-count";
+    readonly RouteName: "climb-route-name";
+    readonly HighPoint: "climb-high-point";
+};
+type ClimbGradeSystem = 'v-scale' | 'font' | 'yds' | 'french' | 'uiaa' | 'ewbank' | 'british' | 'dankyu' | 'unknown';
+interface ClimbGradeMetricValue {
+    raw: string;
+    system: ClimbGradeSystem;
+    normalizedRank?: number;
+}
+/**
+ * Climbing dialect for recognizing route/problem logs and climbing training.
+ *
+ * Recognizes:
+ * - route/problem names from Action metrics
+ * - V-scale, YDS, Fontainebleau, and French-style grades
+ * - send type aliases such as OS, flash, RP, TR, and DNF
+ * - attempt counts from climb-only `@N` shorthand parsed as empty-unit resistance
+ * - high-point notes such as `bolt 6` and `move 9`
+ */
+declare class ClimbDialect implements IDialect {
+    id: string;
+    name: string;
+    analyze(statement: ICodeStatement): DialectAnalysis;
+    private findRouteName;
+    private findGrade;
+    private ydsRank;
+    private findSendType;
+    private findAttemptCount;
+    private findHighPoint;
+    private findDisciplines;
+}
+
+/**
+ * DialectStack — the single ordered place where the base Units Dialect and
+ * the sport/personal Dialects are composed and run.
+ *
+ * Replaces both:
+ * - The parse-time `baseUnits` singleton in `lezer-mapper.ts` (hardcoded to
+ *   one Dialect with no extension hook).
+ * - The empty compile-time `DialectRegistry` that was removed from `JitCompiler`
+ *   in S5a (no production path ever registered a Dialect).
+ *
+ * Ordering: base Units Dialect runs first (fuses bare Number + unit-word into
+ * dimensioned metrics); sport Dialects run after (they observe fused units);
+ * personal-overrides run last (a `CONTEXT.md` concept that was previously
+ * impossible). Later-wins metric merge and hint accumulation are handled by
+ * the per-statement `transform` + `analyze` + append loop.
+ */
+declare class DialectStack {
+    private readonly dialects?;
+    private readonly registry?;
+    /**
+     * Accepts either a frozen array (the `createDialectStack(overrides)` /
+     * test-fixture case) or a live `Registry<IDialect>` (the production
+     * singleton below). When constructed from a registry, every `process()`
+     * call re-reads `registry.list()`, so a `dialectRegistry.register(...)`
+     * made by a consumer after import is honored on the next parse — a
+     * frozen array snapshot taken once at module-load time would not see it.
+     */
+    constructor(dialects: readonly IDialect[] | Registry<IDialect>);
+    private get effectiveDialects();
+    /**
+     * Resolve the effective Dialect list for a block's `:sport` suffix.
+     *
+     * - No suffix → the full stack (a bare `time`/`log` block — unchanged).
+     * - Known suffix (registry id or {@link SPORT_ALIASES} entry) → the base
+     *   Units Dialect plus the named sport Dialect, in registration order.
+     * - Unknown suffix → warn once per suffix and fall back to the full stack.
+     */
+    dialectsFor(sport?: string): readonly IDialect[];
+    /**
+     * Process a single statement through the Dialects selected by `sport`
+     * (full stack when omitted). Each Dialect's `transform` runs before its
+     * `analyze`, and the emitted metrics (hint markers + domain values) are
+     * appended onto the statement.
+     */
+    process(statement: ICodeStatement, sport?: string): void;
+    /** Process a batch of statements through the Dialects selected by `sport`. */
+    processAll(statements: ICodeStatement[], sport?: string): void;
+    private applyDialects;
+    /** The ordered Dialect list (for inspection / testing). Live when registry-backed. */
+    get list(): readonly IDialect[];
+}
+/**
+ * Consumer-facing dialect registry, pre-seeded with the built-in dialects.
+ *
+ * Replaces the previous `createDialectStack(overrides)` parameter as the way
+ * to extend the dialect set. Consumer code can call
+ * `dialectRegistry.register(new MyDialect())` to add a personal-overrides
+ * dialect, and the production `dialectStack` below reads its ordered list
+ * from this registry.
+ *
+ * Built-ins can be removed or overridden by `id`.
+ */
+declare const dialectRegistry: Registry<IDialect>;
+/**
+ * Build a DialectStack from an explicit list — preserved signature for
+ * tests and the `personal-overrides` pattern. Production uses
+ * {@link dialectStack} (which reads the registry) via `extractStatements`.
+ */
+declare function createDialectStack(overrides?: IDialect[]): DialectStack;
+/**
+ * Module singleton — the default Dialect Stack used by the parse pipeline.
+ *
+ * Registry-backed (not a frozen array snapshot): every `process()`/`processAll()`
+ * call re-reads {@link dialectRegistry} live, so a consumer `dialectRegistry.register(...)`
+ * call is honored on the very next parse, no matter when it happens relative to
+ * module load. Equivalent to the old `const baseUnits = new UnitsDialect()` but
+ * with the full sport-Dialect set wired, and genuinely extensible.
+ */
+declare const dialectStack: DialectStack;
+
+/**
+ * Pure fusion over a metric array (no source metadata). Used by unit tests and
+ * any caller that doesn't track `metricMeta`.
+ *
+ *   Rep(100) + Effort("m Run")  → Distance(100, "m") + Effort("Run")
+ *   Rep(24)  + Effort("kg")     → Resistance(24, "kg")
+ *   Rep(5)   + Effort("Burpees")→ unchanged (not a unit)
+ */
+declare function fuseUnitsInMetrics(metrics: IMetric[], units: UnitSet): IMetric[];
+/**
+ * Rewrite a statement's metric list in place, fusing number + unit pairs and
+ * keeping `metricMeta` source locations in sync (the fused metric spans the
+ * number through the unit token; the residual effort keeps the remainder).
+ * No-op when nothing fuses. Safe to call repeatedly (idempotent).
+ */
+declare function fuseUnits(statement: ICodeStatement, units: UnitSet): void;
+
+interface SyntaxMeta {
+    line: number;
+    startOffset: number;
+    endOffset: number;
+    columnStart: number;
+    columnEnd: number;
+    length: number;
+    raw: string;
+}
+interface BasePrimitive {
+    kind: 'lap' | 'duration' | 'rounds' | 'action' | 'text' | 'heading' | 'quantity' | 'effort' | 'property' | 'metric_object';
+    raw: string;
+    meta: SyntaxMeta;
+}
+interface MetricObjectPrimitive extends BasePrimitive {
+    kind: 'metric_object';
+    pairs: Array<{
+        key: string;
+        value: string | number | boolean | null;
+    }>;
+}
+interface LapPrimitive extends BasePrimitive {
+    kind: 'lap';
+    lapType: 'round' | 'compose';
+}
+interface DurationPrimitive extends BasePrimitive {
+    kind: 'duration';
+    timerRaw?: string;
+    hasTrend: boolean;
+    isRequired: boolean;
+}
+interface RoundsPrimitive extends BasePrimitive {
+    kind: 'rounds';
+    sequence?: number[];
+    label?: string;
+}
+interface ActionPrimitive extends BasePrimitive {
+    kind: 'action';
+    hasColonPrefix: boolean;
+}
+interface TextPrimitive extends BasePrimitive {
+    kind: 'text';
+}
+interface HeadingPrimitive extends BasePrimitive {
+    kind: 'heading';
+}
+interface QuantityPrimitive extends BasePrimitive {
+    kind: 'quantity';
+    value?: number;
+    hasAtSign: boolean;
+}
+/**
+ * Effort primitive — emitted for any free text including the bare "/" and "|"
+ * separator tokens. Slash/Pipe were grammar-level primitives consumed only by
+ * fuseUnits; they now ride as `EffortPrimitive` with raw '/' or '|' and the
+ * dialect matches the raw string:
+ *   1/4 mile → 0.25 mile (slash converts to a single decimal)
+ *   Run | Walk → ChoiceGroupMetric([Effort('Run'), Effort('Walk')]) (pipe groups)
+ */
+interface EffortPrimitive extends BasePrimitive {
+    kind: 'effort';
+}
+interface PropertyPrimitive extends BasePrimitive {
+    kind: 'property';
+    key: string;
+    valueRaw: string;
+    value: string | number | boolean | null;
+}
+type SyntaxPrimitive = LapPrimitive | DurationPrimitive | RoundsPrimitive | ActionPrimitive | TextPrimitive | HeadingPrimitive | QuantityPrimitive | EffortPrimitive | PropertyPrimitive | MetricObjectPrimitive;
+interface SyntaxStatement {
+    id: number;
+    line: number;
+    meta: SyntaxMeta;
+    primitives: SyntaxPrimitive[];
+    children: number[][];
+    parentId?: number;
+    isLeaf: boolean;
+}
+interface SyntaxFacts {
+    statements: SyntaxStatement[];
+}
+
+declare function classifyStatements(facts: SyntaxFacts): ParsedCodeStatement[];
+
+/** Helper to compute line and column numbers from offset without EditorState */
+interface LineLocator {
+    (offset: number): {
+        lineNumber: number;
+        lineStart: number;
+    };
+}
+declare function createLineLocator(source: string): LineLocator;
+declare function extractSyntaxFacts(sourceOrState: string | {
+    doc: {
+        toString(): string;
+    };
+}, treeArg?: Tree): SyntaxFacts;
+
+type SourceInput = string | {
+    tree?: Tree;
+    source: string;
+    doc?: {
+        toString(): string;
+    };
+} | {
+    doc: {
+        toString(): string;
+    };
+};
+/**
+ * Extract statements WITHOUT running the Dialect Stack.
+ *
+ * Used by the parser test harness (which applies its own Dialect set) and by
+ * any consumer that needs the raw classified statements before Dialect
+ * processing. Production consumers should use {@link extractStatements}.
+ */
+declare function extractStatementsRaw(sourceOrTree: SourceInput, treeArg?: Tree): ICodeStatement[];
+/**
+ * Extracts WhiteboardScript statements from source or Lezer tree.
+ *
+ * The Dialect Stack (base Units + sport Dialects + personal-overrides) runs on
+ * every statement here, so every parse consumer gets fused units and sport
+ * hints uniformly. See `DialectStack.ts`.
+ *
+ * @param sport - The block's `:sport` fence suffix (` ```log:climbing `).
+ *   Omitted → the full registry stack runs. See {@link DialectStack.dialectsFor}.
+ */
+declare function extractStatements(sourceOrTree: SourceInput, sportOrTree?: string | Tree, sportArg?: string): ICodeStatement[];
+
+interface ParseOptions {
+    dialect?: string;
+    sport?: string;
+    strict?: boolean;
+    withoutDialects?: boolean;
+}
+/**
+ * Parses Whiteboard Script source directly into a WhiteboardScript AST
+ * with 0 DOM / EditorState dependencies.
+ *
+ * @param inputText Raw Whiteboard Script text.
+ * @param options Parse options including dialect/sport fence suffix and strictness.
+ */
+declare function parseScript(inputText: string, options?: ParseOptions): WhiteboardScript;
+
+/**
+ * Headless parser facade using the Lezer parser with 0 DOM / EditorState overhead.
+ */
+declare class MdTimerRuntime {
+    /**
+     * 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: string, sport?: string): IScript;
+    /**
+     * 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: string): IScript;
+}
+
+declare function createParser(): MdTimerRuntime;
+/**
+ * @deprecated Use createParser() instead.
+ */
+declare const sharedParser: MdTimerRuntime;
+
+declare const whiteboardScriptLanguage: LRLanguage;
+declare function whiteboardScript(): LanguageSupport;
+
+declare const parser: LRParser;
+
+/**
+ * Effort Resolver — Analytics Boundary
+ *
+ * Implements IEffortResolver with exact and fuzzy alias matching.
+ * Creates synthetic unresolved efforts for unmatched labels.
+ */
+
+declare class EffortResolver implements IEffortResolver {
+    private readonly registry;
+    private options;
+    constructor(registry: IEffortRegistry, options?: EffortResolverOptions);
+    resolveBySlug(slug: string): IEffort | null;
+    resolveByAlias(label: string): IEffort | null;
+    resolveFuzzy(label: string, options?: {
+        threshold?: number;
+    }): IEffort;
+    resolveEffort(label: string, options?: EffortResolutionOptions): ResolvedEffort;
+    resolveDefinition(effort: IEffort, options?: EffortResolutionOptions): ResolvedEffort;
+    list(): readonly IEffort[];
+    private materialize;
+    private shouldApplyCoefficient;
+    private resolveDisciplineFactor;
+    /**
+     * Create a synthetic unresolved effort for analytics continuity.
+     * Not persisted to the registry.
+     */
+    private createSyntheticEffort;
+}
+
+/**
+ * In-Memory Effort Registry
+ *
+ * Stores all efforts in a Map indexed by slug.
+ * Used for:
+ * - Unit tests (deterministic, no I/O)
+ * - Storybook / static builds (no IndexedDB)
+ * - Bundled seed fallback
+ */
+declare class InMemoryEffortRegistry implements IEffortRegistry {
+    private efforts;
+    private sourceFilter;
+    constructor(sourceFilter?: EffortRegistrySource);
+    /** Seed with bundled efforts */
+    loadBundled(): Promise<void>;
+    /** Seed with arbitrary efforts (useful for tests) */
+    seed(efforts: readonly IEffort[]): void;
+    /** Clear all efforts */
+    clear(): void;
+    resolve(slug: string): IEffort | null;
+    list(): readonly IEffort[];
+    listByOrigin(origin: EffortRegistrySource): readonly IEffort[];
+    upsert(effort: IEffort): Promise<void>;
+    delete(slug: string): Promise<void>;
+}
+
+/**
+ * Fuzzy Alias Matching — Levenshtein Distance
+ *
+ * Edit-distance based fuzzy matching for effort alias resolution.
+ * Default threshold: ≤ 2 (configurable per instance).
+ */
+/**
+ * Compute the Levenshtein edit distance between two strings.
+ * Time: O(m × n), Space: O(min(m, n))
+ */
+declare function levenshteinDistance(a: string, b: string): number;
+/**
+ * Normalise a string for fuzzy comparison:
+ * - lower-case
+ * - trim whitespace
+ * - strip punctuation
+ * - collapse multiple spaces
+ */
+declare function normalizeForFuzzy(input: string): string;
+/**
+ * Check whether two strings are within a given edit-distance threshold.
+ */
+declare function isWithinThreshold(a: string, b: string, threshold: number): boolean;
+/**
+ * Score a fuzzy match candidate. Lower is better (0 = exact).
+ */
+interface FuzzyCandidate {
+    readonly target: string;
+    readonly distance: number;
+}
+/**
+ * Find the best fuzzy match for `query` among `candidates`.
+ * Returns `null` if no candidate is within `threshold`.
+ */
+declare function findBestFuzzyMatch(query: string, candidates: readonly string[], threshold: number): FuzzyCandidate | null;
+
+/**
+ * Effort Registry — Test Fixtures
+ *
+ * Deterministic mock effort sets for unit and integration tests.
+ * Covers common test scenarios: running, strength, low MET, high MET,
+ * user-derived efforts, and synthetic unresolved.
+ */
+
+declare const fixtureRunning: IEffort;
+declare const fixtureRowing: IEffort;
+declare const fixtureBackSquat: IEffort;
+declare const fixtureBurpee: IEffort;
+declare const fixturePlank: IEffort;
+declare const fixtureUserCustom: IEffort;
+/** A user effort that overrides a bundled effort by slug collision */
+declare const fixtureUserOverride: IEffort;
+/** Common bundled fixture set — covers running, rowing, strength, bodyweight, low MET */
+declare const commonFixtureSet: readonly IEffort[];
+/** Full fixture set including user efforts */
+declare const fullFixtureSet: readonly IEffort[];
+
+/** All bundled efforts — seeded with common fixture set for headless/standalone runtime */
+declare const bundledEfforts: readonly IEffort[];
+/** Number of bundled efforts */
+declare const BUNDLED_EFFORT_COUNT: number;
+
+/**
+ * IRuntimeContext — what the execution world (actions, blocks, behaviors)
+ * receives. The runtime's collaborators (the "bag") plus the verbs to enqueue
+ * work and emit output — and nothing else.
+ *
+ * This is the named seam that replaces reaching the bag through the full
+ * {@link IScriptRuntime} god-interface. `handle` is included here because the
+ * execution world emits events via it (BehaviorContext.emitEvent); the remaining
+ * control verbs (`pushBlock`/`popBlock`/`dispose`) and the observation surface
+ * (`subscribeTo*`) stay on `IScriptRuntime` for external drivers.
+ *
+ * `IRuntimeContext extends IRuntimeActionable`, so it remains a valid narrowing
+ * of `IRuntimeAction.do` / `IRuntimeBlock.mount` (which declare the
+ * `IRuntimeActionable` primitive to break the `IRuntimeAction ↔ IScriptRuntime`
+ * cycle). Concrete actions/blocks narrow their parameter from `IScriptRuntime`
+ * to `IRuntimeContext` — bivariance allows it, same trick they use today.
+ *
+ * `ScriptRuntime` and `ExecutionContext` already satisfy this structurally, so
+ * narrowing an action's `do(runtime)` parameter type to `IRuntimeContext`
+ * compiles with no runtime change. See docs/adr/runtime-context-seam.md.
+ */
+interface IRuntimeContext extends IRuntimeActionable {
+    /** The parsed script being executed. */
+    script: WhiteboardScript;
+    /** The event bus (subscribe/emit within the execution world). */
+    eventBus: IEventBus;
+    /** The block execution stack. */
+    stack: IRuntimeStack;
+    /** The time source (frozen within a turn by `ExecutionContext`). */
+    clock: IRuntimeClock;
+    /** The JIT compiler (statement → block). */
+    jit: IJitCompiler;
+    /** Wall-clock provider. */
+    nowProvider: INowProvider;
+    /** Runtime options (hooks, tracker, wrapper, logger). */
+    options: RuntimeStackOptions;
+    /** Errors collected during execution. */
+    errors?: RuntimeError[];
+    /** Optional analytics context for compile-time effort enrichment. */
+    analyticsContext?: AnalyticsContext;
+    /**
+     * Add an output statement and notify subscribers. Used by `BehaviorContext`,
+     * `RuntimeBlock`, and `EmitSystemOutputAction` to emit outputs at any
+     * lifecycle point. (Phase 2 of the seam renames this to `ctx.output.add`.)
+     */
+    addOutput(output: IOutputStatement): void;
+    /**
+     * Route an event back through the runtime's dispatch flow. Included because
+     * behaviors emit events via `BehaviorContext.emitEvent` → `runtime.handle`.
+     * (The remaining control verbs — pushBlock/popBlock/dispose — stay on
+     * `IScriptRuntime` for external drivers.)
+     */
+    handle(event: IEvent): void;
+}
+
+/**
+ * Action for pushing errors to the runtime error list.
+ *
+ * This action provides centralized error handling by collecting errors
+ * in the runtime instead of using EventHandlerResponse.abort flags.
+ *
+ * Actions can check `runtime.errors.length > 0` to abort processing.
+ *
+ * @example
+ * ```typescript
+ * // Push an error during event handling
+ * try {
+ *   // ... some operation
+ * } catch (error) {
+ *   return [new ErrorAction(error as Error, 'TimerBehavior')];
+ * }
+ *
+ * // Check for errors before proceeding
+ * if (runtime.errors && runtime.errors.length > 0) {
+ *   return []; // Abort further processing
+ * }
+ * ```
+ */
+declare class ErrorAction implements IRuntimeAction {
+    /** The error that occurred */
+    readonly error: Error;
+    /** Source of the error (block ID, handler ID, etc.) */
+    readonly source: string;
+    /** Additional context about the error */
+    readonly context?: unknown | undefined;
+    readonly type = "error";
+    constructor(
+    /** The error that occurred */
+    error: Error, 
+    /** Source of the error (block ID, handler ID, etc.) */
+    source: string, 
+    /** Additional context about the error */
+    context?: unknown | undefined);
+    do(runtime: IRuntimeContext): void;
+}
+
+/**
+ * OutputEmitter — the single module responsible for everything that flows into
+ * the output log: buffering, subscriber notification, analytics enrichment,
+ * and all runtime emission helpers.
+ *
+ * ## Why this exists
+ *
+ * Previously ScriptRuntime owned the output buffer, 5 private emission methods,
+ * analytics integration, and subscriber management — 8 separate emission sites
+ * scattered across the runtime. OutputEmitter concentrates all of that behind a
+ * narrow interface so that:
+ *
+ * - **Locality**: every output invariant (GC guard for system outputs, analytics
+ *   enrichment, listener error isolation) lives in one place.
+ * - **Leverage**: callers call `add()` and the whole policy runs automatically.
+ * - **Testability**: the output pipeline can be tested without constructing a
+ *   full ScriptRuntime.
+ *
+ * ## Interface
+ *
+ * ```
+ * add(output)                 — buffer + notify (called by runtime, behaviors, blocks)
+ * subscribe(listener)         — reactive subscription with deferred catch-up
+ * getAll()                    — snapshot of accumulated statements
+ * setAnalyticsEngine(engine)  — attach enrichment pipeline
+ * finalizeAnalytics()         — flush summary statements after workout ends
+ * dispose()                   — release buffer and listeners
+ * ```
+ *
+ * ## Emission helpers
+ *
+ * The five helpers that were private methods of ScriptRuntime are now methods
+ * here. They read their clock/stack/script from {@link OutputEmitter.attach}
+ * (wired once by ScriptRuntime) rather than taking runtime-shaped args at every
+ * call — closing the "carve-out moved code without moving the bugs" defect.
+ *
+ * - emitLoad()
+ * - emitStackEvent(event)
+ * - emitSegmentFromResultMemory(block, stackDepth)
+ * - emitRuntimeEvent(event)
+ * - emitCompilerBlock(block)
+ */
+declare class OutputEmitter {
+    private _outputStatements;
+    private _outputListeners;
+    private _analyticsEngine;
+    /** Session-scoped latch: summary outputs are appended once per session. */
+    private _analyticsFinalized;
+    /**
+     * Ephemeral Tier-2 (running-total) snapshot — display-only. Replaced
+     * wholesale on each segment; NEVER buffered into _outputStatements, so it
+     * never reaches the persisted log. Only finalizeAnalytics() materializes
+     * the final values into the records.
+     */
+    private _liveAnalytics;
+    private _clock;
+    private _stack;
+    private _script;
+    /**
+     * Wire the runtime dependencies the emission helpers read. Called once by
+     * ScriptRuntime's constructor after its own stack/clock/script are set.
+     * Replaces the per-call clock/stack/script parameters the helpers used to take.
+     */
+    attach(deps: {
+        clock: IRuntimeClock;
+        stack: IRuntimeStack;
+        script: WhiteboardScript;
+    }): void;
+    private _requireClock;
+    /**
+     * Add an output statement, run it through analytics enrichment, buffer it,
+     * and notify all subscribers.
+     *
+     * GC guard: system-typed outputs are skipped entirely when no listener is
+     * present to prevent object allocation pressure during high-iteration
+     * workloads (e.g. 10 000-round performance tests).
+     */
+    add(output: IOutputStatement): void;
+    /**
+     * Subscribe to output statements.
+     *
+     * New subscribers receive a deferred catch-up of all statements emitted so
+     * far (setTimeout 0) to avoid synchronous React render warnings.
+     */
+    subscribe(listener: OutputListener): Unsubscribe;
+    /** Returns a copy of all output statements accumulated so far. */
+    getAll(): IOutputStatement[];
+    /** Returns true when at least one subscriber is listening. */
+    hasListeners(): boolean;
+    setAnalyticsEngine(engine: IAnalyticsEngine): void;
+    /**
+     * Flush the analytics engine's final summary outputs after a workout ends.
+     * Summary statements bypass the enrichment chain (already fully processed)
+     * and are the ONLY Tier-2 outputs that reach the persisted buffer — live
+     * running-total snapshots stay ephemeral ({@link emitLiveAnalytics}).
+     */
+    finalizeAnalytics(): IOutputStatement[];
+    /**
+     * Replace the ephemeral live-analytics snapshot and notify subscribers,
+     * WITHOUT buffering into the persisted output stream. Live Tier-2 totals
+     * (running totals per segment) are display-only; only {@link finalizeAnalytics}
+     * writes the final values into the records.
+     *
+     * Each projection output is still fanned out to listeners individually so
+     * reactive consumers (session store, cast bridge) update per-segment.
+     */
+    private emitLiveAnalytics;
+    /** Ephemeral Tier-2 (running-total) snapshot for live display; never persisted. */
+    getLiveAnalytics(): IOutputStatement[];
+    dispose(): void;
+    /**
+     * Emit a `'load'` output for every statement in the script.
+     * Called once during ScriptRuntime construction. Reads the attached script
+     * and clock (see {@link attach}); no runtime-shaped args cross the seam.
+     */
+    emitLoad(): void;
+    /**
+     * Emit a `'system'` output for a push or pop stack event.
+     * Reads the attached clock and stack blocks; only the event (which carries
+     * the affected block + depth) crosses the seam.
+     */
+    emitStackEvent(event: {
+        type: 'push' | 'pop';
+        block: IRuntimeBlock;
+        depth: number;
+    }): void;
+    /**
+     * Emit `'segment'` outputs from a block's `metric:result` memory.
+     * Called when a block is popped from the stack. `stackDepth` is the
+     * event-specific depth at pop time; clock is read from the attached deps.
+     */
+    emitSegmentFromResultMemory(block: IRuntimeBlock, stackDepth: number): void;
+    /**
+     * Emit an `'event'` output for a dispatched runtime event.
+     * Reads the attached clock and stack; only the event crosses the seam.
+     */
+    emitRuntimeEvent(event: IEvent): void;
+    /**
+     * Emit a `'compiler'` output recording the behaviors attached to a block.
+     * Reads the attached clock and stack count; only the block crosses the seam.
+     */
+    emitCompilerBlock(block: IRuntimeBlock): void;
+}
+
+/**
+ * BehaviorContext is the concrete implementation of IBehaviorContext.
+ *
+ * It is created by RuntimeBlock when a block is mounted and provides
+ * behaviors with a unified API for:
+ * - Subscribing to events (tick, next, etc.)
+ * - Emitting events (for coordination)
+ * - Emitting output statements (for reporting)
+ * - Reading and writing block memory
+ * - Marking the block as complete
+ *
+ * ## Lifecycle
+ *
+ * 1. Created during block.mount()
+ * 2. Passed to behavior.onMount(ctx)
+ * 3. Same context passed to behavior.onNext(ctx)
+ * 4. Same context passed to behavior.onUnmount(ctx)
+ * 5. dispose() called during block.unmount() to clean up subscriptions
+ */
+declare class BehaviorContext implements IBehaviorContext {
+    readonly block: IRuntimeBlock;
+    readonly clock: IRuntimeClock;
+    readonly stackLevel: number;
+    private runtime;
+    private subscriptions;
+    /**
+     * Capabilities registered on this context (or shared from the persistent
+     * per-block context if one was injected).
+     *
+     * Capability state is block-scoped, not call-scoped: the `inspectNext`
+     * path in `RuntimeBlock` constructs a fresh `BehaviorContext` per
+     * invocation so it can run the onNext chain without side effects, but
+     * capabilities declared during `onMount` must still be visible to
+     * peer behaviors in any subsequent call.  We therefore let an external
+     * owner (the persistent `_behaviorContext` on `RuntimeBlock`) inject
+     * the shared Set so all contexts for the same block observe the same
+     * capabilities.
+     */
+    private _capabilities;
+    constructor(block: IRuntimeBlock, clock: IRuntimeClock, stackLevel: number, runtime: IRuntimeContext, sharedCapabilities?: Set<string>);
+    subscribe(eventType: BehaviorEventType, listener: BehaviorEventListener, options?: SubscribeOptions): Unsubscribe$1;
+    emitEvent(event: IEvent): void;
+    emitOutput(type: OutputStatementType, metrics: MetricContainer | IMetric[], _options?: OutputOptions): void;
+    /**
+     * Add output to the runtime's collection and notify subscribers.
+     */
+    private addOutputToRuntime;
+    pushMemory(tag: MemoryTag, metrics: MetricContainer | IMetric[]): IMemoryLocation;
+    getMemoryByTag(tag: MemoryTag): IMemoryLocation[];
+    updateMemory(tag: MemoryTag, metrics: MetricContainer | IMetric[]): void;
+    declareCapability(cap: string): void;
+    hasCapability(cap: string): boolean;
+    /**
+     * Returns the Set used to store declared capabilities.  Internal callers
+     * (e.g. `RuntimeBlock.inspectNext`) pass this back to a fresh
+     * `BehaviorContext` so that all contexts for the same block observe the
+     * same capabilities without coupling the inspection context to a
+     * specific owner.
+     */
+    getCapabilities(): Set<string>;
+    markComplete(reason?: string): void;
+    /**
+     * Dispose of all subscriptions.
+     * Called by RuntimeBlock during unmount.
+     */
+    dispose(): void;
+}
+
+/**
+ * Options for constructing a {@link RuntimeBlock}.
+ *
+ * Construction goes through a single options object — there is no positional
+ * overload. The sanctioned way to build a block is {@link BlockBuilder.build},
+ * and the four block subclasses (RestBlock, EffortBlock, SessionRootBlock,
+ * WaitingToStartBlock) forward their own config into this shape.
+ */
+interface RuntimeBlockOptions {
+    /** The owning runtime. */
+    runtime: IRuntimeContext;
+    /** Source statement ids this block was compiled from. Defaults to `[]`. */
+    sourceIds?: number[];
+    /** Behaviors composed onto this block. Defaults to `[]`. */
+    behaviors?: IRuntimeBehavior[];
+    /** Block context. A {@link BlockContext} is created from the key when omitted. */
+    context?: IBlockContext;
+    /** Block key. A fresh {@link BlockKey} is created when omitted. */
+    key?: BlockKey;
+    /** Stable type tag (e.g. 'Rest', 'SessionRoot'). */
+    blockType?: string;
+    /** Optional label, stored as a `metric:label` memory location. */
+    label?: string;
+    /** Optional display metric groups, each stored as a `metric:display` location. */
+    metrics?: MetricContainer[] | IMetric[][];
+}
+/**
+ * RuntimeBlock represents an executable unit in the workout runtime.
+ *
+ * Blocks are composed of behaviors that handle specific aspects (time, iteration, completion, etc.)
+ * Behaviors receive an IBehaviorContext that provides access to memory, events, and output emission.
+ *
+ * ## Lifecycle
+ *
+ * 1. Block is created by a strategy with behaviors attached
+ * 2. mount() is called when pushed onto stack - behaviors receive onMount(ctx)
+ * 3. next() is called when child completes or user advances - behaviors receive onNext(ctx)
+ * 4. unmount() is called when popped from stack - behaviors receive onUnmount(ctx)
+ * 5. dispose() is called for cleanup - behaviors receive onDispose(ctx)
+ */
+declare class RuntimeBlock implements IRuntimeBlock {
+    readonly behaviors: IRuntimeBehavior[];
+    readonly key: BlockKey;
+    readonly blockType?: string;
+    readonly context: IBlockContext;
+    readonly sourceIds: number[];
+    private _memory;
+    /**
+     * Computed label derived from the block's Label metrics.
+     * Priority: Label metric in memory → blockType → 'Block'
+     */
+    get label(): string;
+    protected _behaviorContext?: BehaviorContext;
+    readonly executionTiming: {
+        startTime?: Date;
+        endTime?: Date;
+    };
+    private _isComplete;
+    private _completionReason?;
+    private _eventUnsubscribers;
+    protected _runtime?: IRuntimeContext;
+    constructor(options: RuntimeBlockOptions);
+    /**
+     * Push a new memory location onto the block's memory list.
+     * Multiple locations with the same tag can coexist.
+     */
+    pushMemory(location: IMemoryLocation): void;
+    /**
+     * Merge a set of compiler hints (e.g. from an effort markdown file) into
+     * a `metric:hint` memory location. Hints are surfaced to strategies
+     * exactly the same way dialect-emitted hints are. Duplicate keys are
+     * overwritten (the effort hint wins, matching the doc's
+     * "more specific wins" precedence).
+     */
+    mergeHints(hints: Readonly<Record<string, unknown>>): void;
+    /**
+     * Get all memory locations matching the given tag.
+     * Returns an empty array if no locations match.
+     */
+    getMemoryByTag(tag: MemoryTag): IMemoryLocation[];
+    /**
+     * Get all memory locations owned by this block.
+     * Returns the full memory list in insertion order.
+     */
+    getAllMemory(): IMemoryLocation[];
+    /**
+     * Get all metrics memory locations matching a given visibility tier.
+     *
+     * @param visibility The visibility tier: 'display' | 'promote' | 'private'
+     * @returns Memory locations whose tags belong to the requested tier
+     */
+    getMetricMemoryByVisibility(visibility: MetricVisibility): IMemoryLocation[];
+    /**
+     * Register default event handlers for block-level events.
+     *
+     * Note: 'next' events are handled globally by NextEventHandler
+     * registered in ScriptRuntime. Per-block 'next' handlers are not
+     * needed and were removed to avoid unnecessary handler registrations.
+     */
+    protected registerDefaultHandler(): void;
+    /**
+     * Called when this block is pushed onto the runtime stack.
+     */
+    mount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    /**
+     * Inspect what the next() call would do, WITHOUT dispatching.
+     *
+     * PURE READ for completion state. Runs the behavior onNext chain against
+     * a temporary BehaviorContext, captures the decision, and restores the
+     * block's completion flag so the caller can inspect without side effects.
+     *
+     * The decision is DETERMINISTIC given the same runtime state: the same
+     * behaviors, the same block memory, and the same clock always produce
+     * the exact same decision (behaviors are assumed to be pure functions
+     * of their context).
+     *
+     * @param runtime The script runtime context
+     * @param options Lifecycle options including optional clock for timing consistency
+     */
+    inspectNext(runtime: IRuntimeContext, options?: BlockLifecycleOptions): CompletionDecision;
+    /**
+     * Called when a child block completes or user advances.
+     *
+     * @param runtime The script runtime context
+     * @param options Lifecycle options including optional clock for timing consistency
+     */
+    next(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    /**
+     * Called when this block is popped from the runtime stack.
+     *
+     * @param runtime The script runtime context
+     * @param options Lifecycle options including optional clock for timing consistency
+     */
+    unmount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    /**
+     * Called for final cleanup.
+     */
+    dispose(runtime: IRuntimeContext): void;
+    get isComplete(): boolean;
+    get completionReason(): string | undefined;
+    markComplete(reason?: string): void;
+    /**
+     * Gets a specific behavior by type from the behaviors array.
+     */
+    getBehavior<T extends IRuntimeBehavior>(behaviorType: new (...args: any[]) => T): T | undefined;
+    /**
+     * Emit a system output for next lifecycle event.
+     * Called directly from next() to ensure accurate timing.
+     */
+    private emitNextSystemOutput;
+}
+
+/**
+ * SnapshotClock wraps an IRuntimeClock and freezes `currentDate` at a specific timestamp.
+ * Used to ensure consistent timing during execution chains (pop → next → push).
+ *
+ * All other properties and methods delegate to the underlying clock.
+ *
+ * @example
+ * ```typescript
+ * // Freeze time at completion moment
+ * const createdAt = new Date();
+ * const snapshot = SnapshotClock.at(runtime.clock, createdAt);
+ *
+ * // All operations see the same frozen time
+ * parent.next(runtime, { clock: snapshot });
+ * // child pushed with startTime = snapshot.currentDate = createdAt
+ * ```
+ */
+declare class SnapshotClock implements IRuntimeClock {
+    private readonly _underlying;
+    private readonly _frozenTime;
+    constructor(_underlying: IRuntimeClock, _frozenTime: Date);
+    /** Always returns the frozen timestamp */
+    get currentDate(): Date;
+    now(): Date;
+    nowMs(): number;
+    /** Delegate to underlying clock */
+    get elapsed(): number;
+    get isRunning(): boolean;
+    get spans(): ReadonlyArray<TimeSpan>;
+    start(): Date;
+    stop(): Date;
+    /**
+     * Factory method for cleaner creation.
+     *
+     * @param clock The underlying clock to wrap
+     * @param time The frozen timestamp to return from `currentDate`
+     */
+    static at(clock: IRuntimeClock, time: Date): SnapshotClock;
+    /**
+     * Create a snapshot at the clock's current time.
+     * Useful for freezing `currentDate` before starting an execution chain.
+     *
+     * @param clock The clock to snapshot
+     */
+    static now(clock: IRuntimeClock): SnapshotClock;
+}
+/**
+ * RuntimeClock tracks time using spans created by start/stop calls.
+ *
+ * Provides:
+ * - `now`: Current wall-clock time as a Date
+ * - `elapsed`: Total milliseconds of running time (sum of all spans)
+ * - `start()`/`stop()`: Control methods that return timestamps for event creation
+ */
+declare class RuntimeClock implements IRuntimeClock {
+    private _spans;
+    /**
+     * Current wall-clock time as a Date.
+     */
+    get currentDate(): Date;
+    now(): Date;
+    nowMs(): number;
+    /**
+     * Whether the clock is currently running (has an open span without a stop time).
+     */
+    get isRunning(): boolean;
+    /**
+     * All time spans tracked by this clock.
+     */
+    get spans(): ReadonlyArray<TimeSpan>;
+    /**
+     * Total elapsed milliseconds while running.
+     * Sums all completed spans plus the current running span (if any).
+     */
+    get elapsed(): number;
+    /**
+     * Start the clock. Creates a new span with the current time.
+     * Returns the start timestamp for event creation.
+     *
+     * If the clock is already running, returns the current span's start time.
+     */
+    start(): Date;
+    /**
+     * Stop the clock. Closes the current span with the current time.
+     * Returns the stop timestamp for event creation.
+     *
+     * If the clock is not running, returns the current time.
+     */
+    stop(): Date;
+    /**
+     * Reset the clock. Clears all spans.
+     */
+    reset(): void;
+}
+/**
+ * Type for the mock clock returned by createMockClock.
+ */
+type MockClock = IRuntimeClock & {
+    /** Advance the mock time by the specified milliseconds */
+    advance: (ms: number) => void;
+    /** Set the mock time to a specific Date */
+    setTime: (time: Date) => void;
+};
+/**
+ * Creates a mock clock for testing with controllable time.
+ */
+declare function createMockClock(initialTime?: Date): MockClock;
+
+/**
+ * RuntimeController — stable object passed via context to let bridge components
+ * trigger runtime lifecycle without storing React hook closures in Zustand.
+ */
+interface RuntimeController {
+    initialize(block: ScriptBlock): void;
+    dispose(): void;
+}
+
+/**
+ * RuntimeLogger - Centralized debug logging for the runtime engine.
+ *
+ * Enable/disable via:
+ * - `RuntimeLogger.enable()` / `RuntimeLogger.disable()`
+ * - `window.__WOD_DEBUG__ = true` in browser console
+ *
+ * Logs:
+ * - Block push/pop with behaviors
+ * - `next()` calls
+ * - Events that produce actions
+ * - Memory updates
+ */
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface RuntimeLogEntry {
+    timestamp: Date;
+    level: LogLevel;
+    category: string;
+    message: string;
+    data?: Record<string, unknown>;
+}
+declare class RuntimeLoggerImpl {
+    private _enabled;
+    private _history;
+    private _maxHistory;
+    private readonly STYLES;
+    constructor();
+    get enabled(): boolean;
+    enable(): void;
+    disable(): void;
+    getHistory(): RuntimeLogEntry[];
+    clearHistory(): void;
+    /**
+     * Log when a block is pushed onto the stack
+     */
+    logPush(block: IRuntimeBlock, parentKey?: string): void;
+    /**
+     * Log when a block is popped from the stack
+     */
+    logPop(block: IRuntimeBlock, reason?: string): void;
+    /**
+     * Log when next() is called on a block
+     */
+    logNext(block: IRuntimeBlock, actions: IRuntimeAction[]): void;
+    /**
+     * Log when an event produces actions
+     */
+    logEvent(event: IEvent, actions: IRuntimeAction[]): void;
+    /**
+     * Log when memory is updated on a block
+     */
+    logMemoryUpdate(blockKey: string, memoryType: string, value: unknown): void;
+    /**
+     * Log action execution (verbose, under a group)
+     */
+    logAction(action: IRuntimeAction, depth: number): void;
+    private getBehaviorNames;
+    private summarizeObject;
+    private addToHistory;
+}
+declare const RuntimeLogger: RuntimeLoggerImpl;
+
+type RuntimeMemoryLocation = {
+    ref: IMemoryReference;
+    data: unknown;
+};
+/**
+ * RuntimeMemory is a pure storage system for runtime state.
+ *
+ * Note: This class does not dispatch events. Memory events (allocate, set, release)
+ * are dispatched by BlockContext, which wraps memory operations and dispatches
+ * events to the EventBus. This keeps RuntimeMemory decoupled from the event system.
+ */
+declare class RuntimeMemory implements IRuntimeMemory {
+    private _references;
+    allocate<T>(type: string, ownerId: string, initialValue?: T, visibility?: 'public' | 'private' | 'inherited'): TypedMemoryReference<T>;
+    get<T>(reference: TypedMemoryReference<T>): T | undefined;
+    set<T>(reference: TypedMemoryReference<T>, value: T): void;
+    search(criteria: MemorySearchCriteria): IMemoryReference[];
+    release(reference: IMemoryReference): void;
+}
+
+/**
+ * RuntimeObservers — the shared observer collaborator for IScriptRuntime adapters.
+ *
+ * Owns the **subscriber side** of the stack-snapshot reactive seam
+ * (`IScriptRuntime.subscribeToStack`). Both `ScriptRuntime` and
+ * `ChromecastProxyRuntime` compose one of these.
+ *
+ * ## Post-mount contract
+ *
+ * Stack snapshots emitted via `emitStack` reflect **post-mount state** —
+ * the calling adapter is responsible for invoking `emitStack` only with
+ * snapshots taken from a stack where every visible block has completed
+ * `onMount`. `ScriptRuntime` enforces this by calling `emitStack` from
+ * two points only:
+ *
+ *   1. The bridge from `IRuntimeStack` push/pop events (post-mount because
+ *      `RuntimeStack.push` mounts the block before notifying listeners).
+ *   2. The post-turn settle re-emit in `do()` (post-mount by construction —
+ *      the turn completed, so every action including `onMount` has run).
+ *
+ * The collaborator itself does not check this invariant; the **adapter's
+ * emit sites** are the contract. The regression test
+ * `tests/runtime-compliance/post-mount-snapshot-invariant.compliance.test.ts`
+ * pins the outcome.
+ *
+ * ## What this collaborator is NOT
+ *
+ * - Not a producer of snapshots. The adapter decides *when* to call
+ *   `emitStack(snapshot)`. The collaborator only fans out.
+ * - Not a replacement for `OutputEmitter` (output buffer, analytics
+ *   enrichment, GC guard, deferred catch-up). Output emission semantics
+ *   live there.
+ */
+
+/**
+ * Subscriber collaborator for stack snapshots. (The former tracker-listener
+ * seam was removed when session-totals moved to the live 'analytics' output
+ * stream — see AnalyticsEngine.setLiveOutputEmitter.)
+ */
+declare class RuntimeObservers {
+    private readonly _stackObservers;
+    /**
+     * Subscribe to stack snapshots. The collaborator does NOT emit an
+     * `'initial'` snapshot automatically — the calling adapter is
+     * responsible for constructing the snapshot and calling `emitStack`
+     * right after subscribe, so the adapter owns its own initial-snapshot
+     * timing (ScriptRuntime defers via setTimeout to dodge React render
+     * warnings; the Chromecast proxy fires synchronously per its existing
+     * contract — see `ChromecastProxyRuntime.test.ts`).
+     */
+    subscribeToStack(observer: StackObserver): Unsubscribe;
+    /**
+     * Fan-out a stack snapshot to all subscribers. Errors are isolated
+     * per-observer so a misbehaving listener cannot stop the others.
+     */
+    emitStack(snapshot: StackSnapshot): void;
+    /**
+     * Membership check used by adapters that defer their initial-snapshot
+     * emit (e.g. ScriptRuntime via setTimeout) and need to drop the
+     * emit if the observer unsubscribed in the meantime.
+     */
+    hasStackObserver(observer: StackObserver): boolean;
+    /**
+     * Build the `initial`-type snapshot the collaborator itself cannot
+     * build (it doesn't know the adapter's stack). Used by the settle
+     * path in `ScriptRuntime.do()`'s `finally` to re-emit a
+     * post-mount snapshot after the turn completes.
+     */
+    emitSettled(blocks: readonly IRuntimeBlock[], depth: number, clockTime: Date): void;
+    /**
+     * Drop all subscribers. After `dispose`, `emit*` calls become no-ops
+     * (empty Set checks), and any subscription returned previously
+     * continues to function as an unsubscribe.
+     */
+    dispose(): void;
+    /** Introspection (testing / diagnostics). */
+    get stackObserverCount(): number;
+}
+
+/**
+ * Lightweight runtime stack that only maintains state.
+ * All complex logic (lifecycles, wrapping, hooks) has been moved to ScriptRuntime.
+ * Stack events are dispatched via the EventBus in ScriptRuntime and via
+ * independent subscribers on this stack.
+ */
+declare class RuntimeStack implements IRuntimeStack {
+    private readonly _blocks;
+    private readonly _listeners;
+    /** Top-first view of blocks (copy) */
+    get blocks(): readonly IRuntimeBlock[];
+    get count(): number;
+    get current(): IRuntimeBlock | undefined;
+    get keys(): BlockKey[];
+    push(block: IRuntimeBlock): void;
+    pop(): IRuntimeBlock | undefined;
+    clear(): void;
+    /**
+     * Subscribe to stack changes.
+     * New subscribers will immediately receive an 'initial' event with the current stack state.
+     */
+    subscribe(listener: StackListener): () => void;
+    private notify;
+}
+
+/**
+ * BlockContext implementation for runtime block memory management.
+ *
+ * Responsibilities:
+ * - Allocate and track memory references for a single block
+ * - Provide type-safe access to allocated memory
+ * - Clean up all memory on release
+ *
+ * Lifecycle:
+ * 1. Created by strategy with runtime and ownerId
+ * 2. Strategy allocates memory via allocate()
+ * 3. Memory references injected into behaviors
+ * 4. Consumer calls release() after block disposal
+ *
+ * @example
+ * ```typescript
+ * const context = new BlockContext(runtime, 'block-123');
+ * const ref = context.allocate<number>('counter', 0, 'private');
+ * // ... use ref in behaviors ...
+ * context.release(); // Clean up
+ * ```
+ */
+declare class BlockContext implements IBlockContext {
+    private readonly runtime;
+    readonly ownerId: string;
+    readonly exerciseId: string;
+    private _references;
+    private _released;
+    private _memory;
+    constructor(runtime: IRuntimeContext, ownerId: string, exerciseId?: string, initialReferences?: IMemoryReference[], memory?: IRuntimeMemory);
+    get references(): ReadonlyArray<IMemoryReference>;
+    allocate<T>(type: MemoryTypeEnum | string, initialValue?: T, visibility?: 'public' | 'private' | 'inherited'): TypedMemoryReference<T>;
+    get<T>(type: MemoryTypeEnum | string): TypedMemoryReference<T> | undefined;
+    getAll<T>(type: MemoryTypeEnum | string): TypedMemoryReference<T>[];
+    set<T>(reference: TypedMemoryReference<T>, value: T): void;
+    release(): void;
+    isReleased(): boolean;
+    getOrCreateAnchor(anchorId: string): TypedMemoryReference<IAnchorValue>;
+}
+
+declare class NextAction implements IRuntimeAction {
+    private readonly options?;
+    private readonly now;
+    readonly type = "next";
+    /**
+     * @param options Optional lifecycle options to pass to the block's next() method.
+     *   When provided (e.g., from PopBlockAction carrying createdAt), these options
+     *   are merged with a snapshot clock. When omitted (e.g., user-triggered next),
+     *   a fresh snapshot clock is created.
+     */
+    constructor(options?: BlockLifecycleOptions | undefined, now?: INowProvider);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+    private validateRuntimeState;
+}
+
+type ChildSelectionLoopCondition = 'always' | 'timer-active' | 'rounds-remaining';
+interface ChildSelectionConfig {
+    /** Groups of statement indices to compile and dispatch */
+    childGroups: number[][];
+    /** Enable looping when all children complete */
+    loop?: boolean | {
+        /** Loop condition: always, while timer running, or while rounds remain */
+        condition?: ChildSelectionLoopCondition;
+    };
+    /** Inject rest blocks between loop iterations */
+    injectRest?: boolean;
+    /** Skip first child dispatch on mount (e.g., for deferred start) */
+    skipOnMount?: boolean;
+    /**
+     * If set, initializes round state on mount (absorbs ReEntryBehavior).
+     * Use 1 for the first round. When provided, round memory is written
+     * at mount time so display and loop logic can read it immediately.
+     */
+    startRound?: number;
+    /**
+     * Total rounds for completion checking (undefined = unbounded).
+     * Only used when startRound is also provided.
+     */
+    totalRounds?: number;
+}
+
+/** Legacy timer config shape — kept for call-site backward compatibility */
+interface TimerConfig {
+    direction: 'up' | 'down';
+    durationMs?: number;
+    label?: string;
+    role?: 'primary' | 'secondary' | 'hidden' | 'auto';
+}
+interface TimerCompletionConfig {
+    completesBlock?: boolean;
+}
+/** Round configuration stored by asRepeater() and forwarded by asContainer() */
+interface RepeaterConfig {
+    totalRounds?: number;
+    startRound?: number;
+    addCompletion?: boolean;
+}
+
+declare class BlockBuilder {
+    private runtime;
+    private behaviors;
+    private context;
+    private key;
+    private label;
+    private blockType;
+    private metrics;
+    private sourceIds;
+    /** Pending round config stored by asRepeater(), consumed by asContainer() */
+    private pendingRoundConfig;
+    /** Declared exit intent — resolved into a single ExitBehavior in build(). */
+    private declaredExitMode;
+    constructor(runtime: IRuntimeContext);
+    addBehavior(behavior: IRuntimeBehavior): BlockBuilder;
+    /**
+     * Adds a behavior only if one of that type doesn't already exist.
+     */
+    addBehaviorIfMissing(behavior: IRuntimeBehavior): BlockBuilder;
+    /**
+     * Remove a behavior by its constructor type.
+     *
+     * Private: this is a mechanic `build()` uses to resolve a declared exit
+     * intent (see `declareExit`) into exactly one `ExitBehavior`. Strategies
+     * declare intent instead of calling this directly — see §2.3 of
+     * docs/architectural-cleanup-tier-2-consolidations.md for why strategies
+     * used to mutate each other's contributions this way, and why that
+     * coupling was removed.
+     */
+    private removeBehavior;
+    /**
+     * Move an already-added behavior to the LAST position in the behavior list.
+     *
+     * Behavior order = Map insertion order = RuntimeBlock.onNext execution order.
+     *
+     * Private: `build()` calls this once to canonicalize ordering (e.g.
+     * MetricPromotionBehavior must run after ChildSelectionBehavior so it sees
+     * the round ChildSelectionBehavior just advanced). No-op when the behavior
+     * is not present (or already last). Strategies no longer call this
+     * directly — see §2.3 of docs/architectural-cleanup-tier-2-consolidations.md.
+     */
+    private moveBehaviorLast;
+    hasBehavior<T extends IRuntimeBehavior>(type: new (...args: any[]) => T): boolean;
+    /**
+     * Declare the block's exit intent. Strategies call this instead of adding
+     * or removing ExitBehavior across each other. 'deferred' supersedes
+     * 'immediate' (a container strategy overrides a leaf strategy's
+     * immediate-exit guess). Resolved into a single ExitBehavior in build().
+     */
+    declareExit(mode: 'immediate' | 'deferred'): BlockBuilder;
+    /** The declared exit intent (resolved into a single ExitBehavior in build). */
+    get exitMode(): 'immediate' | 'deferred' | undefined;
+    getBehavior<T extends IRuntimeBehavior>(type: new (...args: any[]) => T): T | undefined;
+    setContext(context: IBlockContext): BlockBuilder;
+    setKey(key: BlockKey): BlockBuilder;
+    setLabel(label: string): BlockBuilder;
+    setBlockType(type: string): BlockBuilder;
+    setFragments(metrics: IMetric[][] | MetricContainer[]): BlockBuilder;
+    setSourceIds(ids: number[]): BlockBuilder;
+    getLabel(): string;
+    getBlockType(): string;
+    getFragments(): MetricContainer[] | undefined;
+    getSourceIds(): number[];
+    getContext(): IBlockContext | undefined;
+    getKey(): BlockKey | undefined;
+    /**
+     * Timer Aspect Composer — assigns exactly ONE self-contained timer behavior.
+     *
+     * - `direction: 'down'` + `durationMs` → `CountdownTimerBehavior`
+     *   (subscribes to tick, fires timer:complete, handles pause/resume)
+     * - `direction: 'up'` or no duration → `CountupTimerBehavior`
+     *   (tracks elapsed via spans, handles pause/resume, no completion signal)
+     *
+     * @param config Timer configuration
+     * @returns This builder for chaining
+     */
+    asTimer(config: TimerConfig & {
+        addCompletion?: boolean;
+        completionConfig?: TimerCompletionConfig;
+        injectRest?: boolean;
+        required?: boolean;
+    }): BlockBuilder;
+    /**
+     * Returns true if round config was stored via asRepeater().
+     * Use this guard in strategies that must skip their iteration logic when rounds are already set.
+     */
+    hasRoundConfig(): boolean;
+    /**
+     * Returns true if any timer behavior (countdown, countup, or span-only) is present.
+     * Use this guard in strategies that must skip their timer logic when timer is already set.
+     */
+    hasTimerBehavior(): boolean;
+    /**
+     * Repeater Aspect Composer — stores round/iteration config to be forwarded
+     * when asContainer() is called.
+     *
+     * Previously created ReEntryBehavior + RoundsEndBehavior directly; now the
+     * config is absorbed into ChildSelectionBehavior via asContainer(), which
+     * owns round state initialization and the overflow safety net.
+     *
+     * @param config Round configuration
+     * @returns This builder for chaining
+     */
+    asRepeater(config: RepeaterConfig): BlockBuilder;
+    /**
+     * Container Aspect Composer — adds ChildSelectionBehavior, incorporating any
+     * round config stored by a prior asRepeater() call.
+     *
+     * @param config Container configuration
+     * @returns This builder for chaining
+     */
+    asContainer(config: ChildSelectionConfig & {
+        addLoop?: boolean;
+        loopConfig?: {
+            condition?: ChildSelectionLoopCondition;
+        };
+    }): BlockBuilder;
+    build(): IRuntimeBlock;
+}
+
+/**
+ * Contract for a JIT compiler strategy.
+ *
+ * Each strategy must carry a stable `id` (used by the consumer-facing
+ * {@link strategyRegistry}) and a `priority` (ordering). `id` is the lookup
+ * key for `register(id)` / override; `priority` is the registration-order
+ * tiebreaker (higher runs first).
+ */
+interface IRuntimeBlockStrategy {
+    /** Stable, unique identifier (used by strategyRegistry for registration). */
+    readonly id: string;
+    /**
+     * Execution priority. Higher values run first.
+     * Suggested ranges:
+     * - Logic/Drivers: 90-100 (e.g. Interval, AMRAP)
+     * - Components: 50-80 (e.g. Timer, Loop)
+     * - Enhancements: 20-40 (e.g. Sound, History)
+     * - Fallback: 0 (e.g. Effort)
+     */
+    priority: number;
+    /**
+     * Checks if this strategy applies to the given statement.
+     */
+    match(statements: ICodeStatement[], runtime: IRuntimeContext): boolean;
+    /**
+     * Applies this strategy to the block builder.
+     * Note: This replaces `compile`. The builder accumulates state.
+     */
+    apply(builder: BlockBuilder, statements: ICodeStatement[], runtime: IRuntimeContext): void;
+}
+
+/**
+ * Action that pushes a compiled block onto the runtime stack.
+ * Used by behaviors to add child blocks for execution.
+ */
+declare class PushBlockAction implements IRuntimeAction {
+    readonly block: IRuntimeBlock;
+    private readonly options;
+    private _type;
+    constructor(block: IRuntimeBlock, options?: BlockLifecycleOptions);
+    get type(): string;
+    set type(_value: string);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * Action that pops the current block from the runtime stack.
+ * Handles the full lifecycle: unmount, pop, dispose, emit output.
+ *
+ * Returns unmount actions followed by a NextAction for the parent,
+ * decoupling the pop and next phases into distinct actions processed
+ * by the ExecutionContext.
+ */
+declare class PopBlockAction implements IRuntimeAction {
+    private readonly options;
+    readonly type = "pop-block";
+    constructor(options?: BlockLifecycleOptions);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * Action that aborts the current session by force-popping all blocks from the stack.
+ *
+ * Unlike PopBlockAction (which pops one block and calls parent.next()), AbortSessionAction
+ * drains the entire stack without triggering parent advancement or pushing new children.
+ *
+ * Each block receives the full lifecycle:
+ *  1. markComplete('user-abort') — marks the block as intentionally terminated
+ *  2. unmount() — runs behaviors (e.g. ReportOutputBehavior) which write result memory
+ *  3. stack.pop() — triggers emitSegmentFromResultMemory in ScriptRuntime, the sole
+ *     site that turns a pop into a 'segment' OutputStatement
+ *  4. dispose() — releases block resources
+ *
+ * This ensures every aborted block still gets a well-formed 'segment' output
+ * (checked by assertPairedOutputs() in tests).
+ */
+declare class AbortSessionAction implements IRuntimeAction {
+    readonly type = "abort-session";
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * ClearChildrenAction pops all blocks above a target block on the stack.
+ *
+ * Used when a parent timer expires (AMRAP/EMOM) and active children must
+ * be force-completed and removed. Each child is popped via PopBlockAction
+ * so the full lifecycle runs:
+ *
+ * 1. PopBlockAction checks isComplete → marks 'forced-pop' if not yet complete
+ * 2. Unmount fires → ReportOutputBehavior writes result memory (elapsed/spans),
+ *    then the pop emits a single 'segment' output carrying those fragments
+ * 3. Block is disposed and cleaned up
+ *
+ * After all children are cleared, a NextAction is queued so the parent
+ * block (now on top) receives its next() call, where the container's
+ * ExitBehavior (deferred) can pop it cleanly.
+ *
+ * ## Example: AMRAP timer expires mid-exercise
+ *
+ * Stack: [Session, AMRAP, Pullups]
+ * Timer fires → ClearChildrenAction(AMRAP.key)
+ * → PopBlockAction pops Pullups (forced-pop, fragments reported)
+ * → NextAction on AMRAP → ExitBehavior (deferred) → PopBlockAction
+ * → Session receives next(), advances to review
+ */
+declare class ClearChildrenAction implements IRuntimeAction {
+    private readonly targetBlockKey;
+    readonly type = "clear-children";
+    constructor(targetBlockKey: string);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * UpdateNextPreviewAction resolves the next child statement(s) and stores
+ * their metrics in the block's `metric:next` memory location.
+ *
+ * ## Purpose
+ *
+ * Behaviors (ChildRunnerBehavior) cannot access `runtime.script` directly —
+ * it's only available in `IRuntimeAction.do(runtime)`. This action bridges
+ * the gap: the behavior returns this action with statement IDs, and the
+ * action looks up the metrics and pushes them into block memory.
+ *
+ * ## Memory Contract
+ *
+ * - Tag: `metric:next`
+ * - Value: `MetricContainer` from the next statement(s) to be compiled
+ * - When `nextStatementIds` is empty, any existing `metric:next` memory
+ *   is cleared (updated to empty metric) to signal "no more children".
+ *
+ * ## Consumed By
+ *
+ * - `useNextPreview` hook → `LookaheadView` component
+ * - The UI walks the stack leaf-to-root and shows the deepest block's
+ *   `metric:next` as the "Up Next" preview.
+ */
+declare class UpdateNextPreviewAction implements IRuntimeAction {
+    private readonly blockKey;
+    private readonly nextStatementIds;
+    readonly type = "update-next-preview";
+    readonly target?: string;
+    readonly payload?: unknown;
+    constructor(blockKey: string, nextStatementIds: number[]);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * Configuration for starting a workout.
+ */
+interface StartWorkoutOptions {
+    /** Display label for the session */
+    label?: string;
+    /** Total rounds for the workout (default: 1) */
+    totalRounds?: number;
+    /** Optional lifecycle options for the root block */
+    lifecycle?: BlockLifecycleOptions;
+}
+/**
+ * Action that initializes a workout by wrapping the script's statements
+ * in a root block and pushing it onto the stack.
+ *
+ * This action:
+ * 1. Reads all top-level statements from runtime.script
+ * 2. Creates child groups (each top-level statement in its own group)
+ * 3. Builds a SessionRootBlock using SessionRootStrategy
+ * 4. Pushes the root block to start the workout
+ *
+ * @example
+ * ```typescript
+ * runtime.do(new StartWorkoutAction());
+ * runtime.do(new StartWorkoutAction({ label: 'Grace', totalRounds: 3 }));
+ * ```
+ */
+declare class StartWorkoutAction implements IRuntimeAction {
+    private readonly options;
+    readonly type = "start-workout";
+    constructor(options?: StartWorkoutOptions);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * Configuration for starting a session-based workout.
+ */
+interface StartSessionOptions {
+    /** Display label for the session (e.g., "Grace", "Cindy") */
+    label?: string;
+    /** Total rounds for the session (default: 1) */
+    totalRounds?: number;
+    /** Optional lifecycle options for the root block */
+    lifecycle?: BlockLifecycleOptions;
+}
+/**
+ * Action that initializes a workout using the SessionRootBlock.
+ *
+ * Uses SessionRootStrategy to create a SessionRootBlock with proper behavior composition:
+ *
+ * - ReportOutputBehavior (emits segment/completion outputs — source of truth for history)
+ * - CountupTimerBehavior (countup for total elapsed time)
+ * - ChildSelectionBehavior (sequences WaitingToStart + children)
+ *
+ * History persistence is the responsibility of the workbench layer,
+ * which subscribes to the output stream.
+ *
+ * @see SessionRootStrategy
+ * @see SessionRootBlock
+ */
+declare class StartSessionAction implements IRuntimeAction {
+    private readonly options;
+    readonly type = "start-session";
+    constructor(options?: StartSessionOptions);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * Action that compiles a set of statement IDs and pushes the resulting block.
+ * Allows behaviors to request JIT compilation without holding a reference to the runtime/JIT compiler.
+ */
+declare class CompileAndPushBlockAction implements IRuntimeAction {
+    readonly statementIds: number[];
+    readonly options: BlockLifecycleOptions;
+    readonly type = "compile-and-push-block";
+    constructor(statementIds: number[], options?: BlockLifecycleOptions);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * Action that constructs a RestBlock with the given duration and pushes it
+ * onto the runtime stack.
+ *
+ * Previously a private class inside ChildSelectionBehavior. Elevated to a
+ * named action so any behavior or strategy that needs to inject a rest period
+ * can do so without re-implementing the RestBlock construction pattern.
+ *
+ * @example
+ * ```typescript
+ * // Inside a behavior that needs a rest break between intervals
+ * return [new PushRestBlockAction(remainingMs, 'Rest')];
+ * ```
+ */
+declare class PushRestBlockAction implements IRuntimeAction {
+    readonly durationMs: number;
+    readonly label: string;
+    readonly type = "push-rest-block";
+    constructor(durationMs: number, label?: string);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * Action that emits a system-level output statement for lifecycle tracing.
+ *
+ * System outputs are diagnostic records emitted on block push/pop/next
+ * and when event handlers produce actions. They flow through the normal
+ * output pipeline (runtime.addOutput) and appear alongside segment/completion
+ * outputs in the output log.
+ *
+ * Consumers that don't want system output can filter:
+ *   outputs.filter(o => o.outputType !== 'system')
+ *
+ * ## Fragment Encoding
+ *
+ * Each system output carries a single metrics:
+ * - metricType: MetricType.System
+ * - type: 'lifecycle' | 'event-action'
+ * - image: human-readable message
+ * - value: SystemOutputValue with structured data
+ * - origin: 'runtime'
+ */
+declare class EmitSystemOutputAction implements IRuntimeAction {
+    private readonly message;
+    private readonly event;
+    private readonly blockKey;
+    private readonly blockLabel?;
+    private readonly stackLevel?;
+    private readonly extra?;
+    readonly type = "emit-system-output";
+    /**
+     * @param message Human-readable description (becomes metrics.image)
+     * @param event   Which lifecycle event triggered this output
+     * @param blockKey The block key involved
+     * @param blockLabel Optional human-readable block label
+     * @param stackLevel Stack depth at time of emission
+     * @param extra Additional key-value data to include in the metrics value
+     */
+    constructor(message: string, event: 'push' | 'pop' | 'next' | 'event-action', blockKey: string, blockLabel?: string | undefined, stackLevel?: number | undefined, extra?: Record<string, unknown> | undefined);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * ActionDescriptor - Describes a user-facing action/button in the workout UI.
+ *
+ * Used by both the runtime hooks layer (useActiveControls) and UI components
+ * (TimerStackView) to represent interactive buttons.
+ */
+interface ActionDescriptor {
+    id: string;
+    name: string;
+    eventName: string;
+    ownerId: string;
+    sourceId?: string;
+    raw?: string;
+    displayLabel?: string;
+    payload?: Record<string, unknown>;
+    isPinned?: boolean;
+}
+
+/**
+ * Action for declarative event emission from behaviors.
+ *
+ * This action allows behaviors to emit events through the action system
+ * using eventBus.emit(), maintaining declarative patterns.
+ *
+ * @example
+ * ```typescript
+ * // Emit a timer start event
+ * return [new EmitEventAction('timer:started')];
+ *
+ * // Emit event with custom data
+ * return [new EmitEventAction('rounds:completed', { round: 5 })];
+ *
+ * // Emit event with custom timestamp
+ * return [new EmitEventAction('workout:finished', undefined, new Date())];
+ * ```
+ */
+declare class EmitEventAction implements IRuntimeAction {
+    /** Name of the event to emit */
+    readonly eventName: string;
+    /** Optional data to include with the event */
+    readonly data?: unknown | undefined;
+    readonly type = "emit-event";
+    readonly timestamp: Date;
+    constructor(
+    /** Name of the event to emit */
+    eventName: string, 
+    /** Optional data to include with the event */
+    data?: unknown | undefined, 
+    /** Optional timestamp (defaults to now) */
+    timestamp?: Date, now?: INowProvider);
+    do(runtime: IRuntimeContext): IRuntimeAction[];
+}
+
+/**
+ * Action for declaratively registering an event handler.
+ *
+ * This action manages event handler registration by storing the handler
+ * in runtime memory, making it available for event processing.
+ *
+ * @example
+ * ```typescript
+ * // Register a handler for block completion (default 'active' scope)
+ * const handler = new BlockCompleteEventHandler(blockId);
+ * return [new RegisterEventHandlerAction(handler, blockId)];
+ *
+ * // Register a handler that listens to child events ('bubble' scope)
+ * return [new RegisterEventHandlerAction(handler, blockId, 'bubble')];
+ * ```
+ */
+declare class RegisterEventHandlerAction implements IRuntimeAction {
+    /** The event handler to register */
+    readonly handler: IEventHandler;
+    /** The block ID that owns this handler (for cleanup) */
+    readonly ownerId: string;
+    /** Handler scope. Default: 'active' (only fires when owner is current block) */
+    readonly scope: HandlerScope;
+    readonly type = "register-event-handler";
+    constructor(
+    /** The event handler to register */
+    handler: IEventHandler, 
+    /** The block ID that owns this handler (for cleanup) */
+    ownerId: string, 
+    /** Handler scope. Default: 'active' (only fires when owner is current block) */
+    scope?: HandlerScope);
+    do(runtime: IRuntimeContext): void;
+}
+
+/**
+ * Action for declaratively unregistering an event handler.
+ *
+ * This action manages event handler cleanup by removing the handler
+ * from runtime memory, preventing further event processing.
+ *
+ * @example
+ * ```typescript
+ * // Unregister a handler during block disposal
+ * return [new UnregisterEventHandlerAction(handlerId)];
+ * ```
+ */
+declare class UnregisterEventHandlerAction implements IRuntimeAction {
+    /** The ID of the handler to unregister */
+    readonly handlerId: string;
+    readonly type = "unregister-event-handler";
+    constructor(
+    /** The ID of the handler to unregister */
+    handlerId: string);
+    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.
+ */
+declare class ThrowErrorAction implements IRuntimeAction {
+    private readonly error;
+    private readonly source;
+    readonly type = "throw-error";
+    constructor(error: Error, source: string);
+    do(runtime: IRuntimeContext): void;
+}
+/**
+ * Factory function to create a ThrowErrorAction.
+ */
+declare function ThrowError(error: Error, source: string): IRuntimeAction;
+
+/**
+ * ExecutionContext manages a "turn" of execution.
+ *
+ * It wraps a runtime and ensures that all actions pushed during the turn
+ * see a consistent frozen clock and share an execution depth limit.
+ *
+ * This class declares only the narrow {@link IRuntimeContext} surface — the
+ * collaborators and verbs the execution world (actions, blocks, behaviors)
+ * actually uses mid-turn. The wide `IScriptRuntime` members (subscribeTo*,
+ * finalizeAnalytics, setAnalyticsEngine, pushBlock/popBlock, dispose) stay on
+ * `ScriptRuntime` for external drivers; they are NOT re-declared here, so
+ * adding a member to `IScriptRuntime` no longer forces a matching pass-through.
+ *
+ * ## Stack Semantics (LIFO)
+ *
+ * Actions are processed using a **stack** (Last-In-First-Out). When an action
+ * produces child actions via `runtime.do()`, those children are pushed onto the
+ * stack and executed **before** returning to any remaining sibling actions.
+ *
+ * This ensures that nested operations (e.g., a pop that triggers a parent.next()
+ * which pushes a new child) complete their full depth before processing continues
+ * at the parent level — mirroring the natural call-stack behavior of block
+ * lifecycle operations.
+ *
+ * ## Lifecycle
+ *
+ * 1. Created by `ScriptRuntime.do()` or `ScriptRuntime.handle()` when no active context exists
+ * 2. Clock is frozen at creation time (SnapshotClock)
+ * 3. Actions are executed from the stack until empty
+ * 4. Context is discarded — all actions in the turn shared the same frozen timestamp
+ */
+declare class ExecutionContext implements IRuntimeContext {
+    private readonly _runtime;
+    private _workList;
+    private _iteration;
+    private readonly _maxIterations;
+    private readonly _snapshotClock;
+    constructor(_runtime: IScriptRuntime, maxIterations?: number);
+    get script(): WhiteboardScript;
+    get eventBus(): IEventBus;
+    get stack(): IRuntimeStack;
+    get options(): RuntimeStackOptions;
+    get jit(): IJitCompiler;
+    get errors(): RuntimeError[] | undefined;
+    get analyticsContext(): AnalyticsContext | undefined;
+    get clock(): SnapshotClock;
+    get nowProvider(): INowProvider;
+    addOutput(output: IOutputStatement): void;
+    /**
+     * Pushes an action onto the execution work list to be processed in this turn.
+     * Actions pushed during another action's execution land on top of the stack
+     * (LIFO / Depth-First semantics).
+     */
+    do(action: IRuntimeAction): void;
+    /**
+     * Pushes multiple actions onto the work list. Land on top of the stack
+     * in the order provided (first element on very top).
+     */
+    doAll(actions: IRuntimeAction[]): void;
+    /**
+     * Dispatches an event and pushes all resulting actions onto the work list.
+     */
+    handle(event: IEvent): void;
+    /**
+     * Executes an initial action and then all subsequent actions on the work list until empty.
+     *
+     * Uses an 'Ordered Stack' model:
+     * 1. **Queued actions (do)** are appended to the back (FIFO).
+     * 2. **Returned actions (children)** are prepended to the front (Depth-First).
+     * 3. **Execution** always takes from the front.
+     *
+     * This ensures that nested operations (e.g., a pop that triggers a parent.next())
+     * complete their full depth before processing continues at the sibling level,
+     * while explicitly queued side-effects run in the order they were triggered.
+     *
+     * @throws Error if max iterations reached
+     */
+    execute(initialAction: IRuntimeAction): void;
+}
+
+/**
+ * IPromotionResolver — the seam that extracts parent-block promotion
+ * logic from `JitCompiler`.
+ *
+ * Phase D of plan-candidates-2-3-4-5 removes a layer violation in
+ * `JitCompiler.compile()` where the compiler reaches into
+ * `parentBlock.getMetricMemoryByVisibility('promote')` and
+ * `behavior.getPromotedFragments(runtime, parentBlock)`.  That code is
+ * a runtime concern (it inspects live block state); it does not belong
+ * in a `Statement[] → Block` transform.
+ *
+ * The resolver owns the parent-side projection and returns the metrics
+ * that should be injected into the child block's statements.  The
+ * `JitCompiler` is left with a one-liner call to `resolvePromotions`.
+ */
+
+interface PromotionResolution {
+    /**
+     * Promoted metrics derived from the parent block's memory and any
+     * `IMetricPromoter` behaviors attached to it.  Empty when the parent
+     * has nothing to promote.
+     */
+    readonly promotedFragments: readonly IMetric[];
+    /**
+     * `true` when the resolver computed a non-empty promotion set; the
+     * compiler uses this bit to invalidate its strategy-match cache.
+     */
+    readonly hasPromotions: boolean;
+}
+interface IPromotionResolver {
+    /**
+     * Inspect the parent block (if any) on the runtime stack and return
+     * the metrics it wants to inject into the child being compiled.
+     */
+    resolvePromotions(parentBlock: IRuntimeBlock | undefined, runtime: IRuntimeContext): PromotionResolution;
+}
+
+/**
+ * Just-In-Time Compiler for Runtime Blocks.
+ * Coordinates strategy application to build composed RuntimeBlocks.
+ */
+declare class JitCompiler implements IJitCompiler {
+    private strategies;
+    private _promotionResolver;
+    constructor(strategies?: IRuntimeBlockStrategy[], promotionResolver?: IPromotionResolver);
+    registerStrategy(strategy: IRuntimeBlockStrategy): void;
+    compile(nodes: ICodeStatement[], runtime: IRuntimeContext): IRuntimeBlock | undefined;
+}
+
+/**
+ * RuntimeFactory - Service for creating ScriptRuntime instances
+ *
+ * This factory encapsulates the runtime creation logic, decoupling it from
+ * UI components like WorkbenchContext. It handles:
+ * - WhiteboardScript creation from block content
+ * - ScriptRuntime instantiation with JIT compiler
+ * - Root block compilation and mounting
+ * - Optional debug mode enabling
+ *
+ * @example
+ * ```typescript
+ * const factory = new RuntimeFactory(createCompiler());
+ * const runtime = factory.createRuntime(scriptBlock);
+ *
+ * // With debug mode
+ * const debugRuntime = factory.createRuntime(scriptBlock, { debugMode: true });
+ * ```
+ */
+
+/**
+ * Interface for runtime factory implementations
+ * Allows for dependency injection and testing
+ */
+interface IRuntimeFactory {
+    /**
+     * Creates a new ScriptRuntime from a ScriptBlock
+     * @param block - The WOD block containing workout script and parsed statements
+     * @param options - Optional runtime options (debug mode, logging, tracker, etc.)
+     * @returns A fully initialized ScriptRuntime, or null if block has no statements
+     */
+    createRuntime(block: ScriptBlock, options?: RuntimeStackOptions): IScriptRuntime | null;
+    /**
+     * Disposes of a runtime and cleans up resources
+     * @param runtime - The runtime to dispose
+     */
+    disposeRuntime(runtime: IScriptRuntime): void;
+}
+/**
+ * Default implementation of IRuntimeFactory
+ */
+declare class RuntimeFactory implements IRuntimeFactory {
+    private readonly compiler;
+    private readonly nowProvider;
+    constructor(compiler: JitCompiler, nowProvider?: INowProvider);
+    /**
+     * Creates a new ScriptRuntime from a ScriptBlock
+     *
+     * Process:
+     * 1. Validates block has statements
+     * 2. Creates WhiteboardScript from content + statements
+     * 3. Instantiates ScriptRuntime with JIT compiler and options
+     * 4. Dispatches StartSessionAction to wrap script in session root block and push it
+     *
+     * @param block - The WOD block to create runtime for
+     * @param options - Optional runtime options (debug mode, logging, tracker, etc.)
+     * @returns Initialized ScriptRuntime or null if invalid block
+     */
+    createRuntime(block: ScriptBlock, options?: RuntimeStackOptions): IScriptRuntime | null;
+    /**
+     * Disposes of a runtime, cleaning up all blocks and resources
+     *
+     * @param runtime - The runtime to dispose
+     */
+    disposeRuntime(runtime: IScriptRuntime): void;
+}
+
+/**
+ * RuntimeBuilder provides a fluent API for constructing ScriptRuntime instances
+ * with configurable options including debug mode, logging, and custom block wrappers.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const runtime = new RuntimeBuilder(script, compiler).build();
+ *
+ * // With debug mode
+ * const debugRuntime = new RuntimeBuilder(script, compiler)
+ *   .withDebugMode(true)
+ *   .build();
+ *
+ * // With custom configuration
+ * const customRuntime = new RuntimeBuilder(script, compiler)
+ *   .withDebugMode(true)
+ *   .withLogging(true)
+ *   .withDefaultTestableConfig({ mountMode: 'spy', nextMode: 'spy' })
+ *   .withDebugLogHandler((event) => {
+ *     console.log('[Debug]', event);
+ *   })
+ *   .build();
+ * ```
+ */
+declare class RuntimeBuilder {
+    private readonly script;
+    private readonly compiler;
+    private options;
+    private nowProvider;
+    constructor(script: WhiteboardScript, compiler: JitCompiler);
+    /**
+     * Enable or disable debug mode.
+     * When enabled:
+     * - All blocks are wrapped with TestableBlock for inspection
+     * - Lifecycle events are tracked and can be inspected
+     */
+    withDebugMode(enabled: boolean): this;
+    /**
+     * Enable or disable debug logging.
+     * Can be enabled independently of debug mode for lighter-weight logging.
+     */
+    withLogging(enabled: boolean): this;
+    /**
+     * Set default TestableBlock configuration.
+     * Applied to all blocks wrapped in debug mode.
+     */
+    withDefaultTestableConfig(config: Partial<TestableBlockConfig>): this;
+    /**
+     * Set a custom block wrapper factory.
+     * Use this to customize how blocks are wrapped in debug mode.
+     */
+    withBlockWrapperFactory(factory: IRuntimeOptions['blockWrapperFactory']): this;
+    /**
+     * Set a custom debug log handler.
+     * Called for every debug event in addition to console logging.
+     */
+    withDebugLogHandler(handler: IRuntimeOptions['onDebugLog']): this;
+    /**
+     * Set a custom INowProvider (time seam — see docs/adr/time-seam.md).
+     * Defaults to wall-clock.
+     */
+    withNowProvider(provider: INowProvider): this;
+    /**
+     * Get the current options (for inspection/debugging)
+     */
+    getOptions(): Readonly<IRuntimeOptions>;
+    /**
+     * Build the ScriptRuntime with the configured options.
+     */
+    build(): ScriptRuntime;
+    /**
+     * Build the runtime and also return the options used.
+     * Useful for debugging the builder configuration.
+     */
+    buildWithOptions(): {
+        runtime: ScriptRuntime;
+        options: IRuntimeOptions;
+    };
+}
+
+type EventHandlerRegistration = {
+    handler: IEventHandler;
+    ownerId: string;
+    priority: number;
+    scope: HandlerScope;
+};
+/**
+ * Simple in-memory event bus for runtime events.
+ *
+ * ## Handler Scope Filtering
+ *
+ * Handlers registered via `register()` are filtered by scope before dispatch:
+ * - `'active'` (default): Only fires when ownerId matches the current/active block on the stack
+ * - `'bubble'`: Fires when ownerId is anywhere on the stack (parent can listen to child events)
+ * - `'global'`: Always fires regardless of stack state (for runtime-level handlers)
+ *
+ * ## Callbacks vs Handlers
+ *
+ * - **Handlers** (via `register()`): Produce `IRuntimeAction[]`, are scope-filtered
+ * - **Callbacks** (via `on()`): Simple notifications for UI, are NOT scope-filtered (always fire)
+ *
+ * Callbacks are intended for UI components that need to react to all events regardless
+ * of which block is active. They do not produce actions and cannot affect runtime state.
+ */
+declare class EventBus implements IEventBus {
+    private handlersByEvent;
+    private callbacksByEvent;
+    register(eventName: string, handler: IEventHandler, ownerId: string, options?: EventHandlerOptions): () => void;
+    on(eventName: string, callback: EventCallback, ownerId: string): () => void;
+    unregisterById(handlerId: string): void;
+    unregisterByOwner(ownerId: string): void;
+    dispatch(event: IEvent, runtime: IScriptRuntime): IRuntimeAction[];
+    emit(event: IEvent, runtime: IScriptRuntime): void;
+    /**
+     * Dispose of all handlers and callbacks, releasing all references.
+     */
+    dispose(): void;
+}
+
+declare class NextEvent implements IEvent {
+    private readonly now;
+    readonly name: string;
+    readonly timestamp: Date;
+    private _data?;
+    private static _counter;
+    constructor(data?: unknown, now?: INowProvider);
+    get data(): unknown;
+    set data(value: unknown);
+    toJSON(): {
+        name: string;
+        timestamp: Date;
+        data: unknown;
+    };
+}
+
+declare class NextEventHandler implements IEventHandler {
+    private _id;
+    private _name;
+    constructor(id: string);
+    get id(): string;
+    set id(_value: string);
+    get name(): string;
+    set name(_value: string);
+    handler(event: IEvent, runtime: IScriptRuntime): IRuntimeAction[];
+}
+
+interface RuntimeButton {
+    id: string;
+    label?: string;
+    icon?: 'play' | 'pause' | 'stop' | 'next' | 'check' | 'analytics' | 'x';
+    action: string;
+    variant?: 'default' | 'secondary' | 'destructive' | 'outline' | 'ghost' | 'link';
+    color?: string;
+    disabled?: boolean;
+    size?: 'default' | 'sm' | 'lg' | 'icon';
+}
+interface RuntimeControls {
+    buttons: RuntimeButton[];
+    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.
+ *
+ * Iterates the span list, summing (end − start) for each span.
+ * Open spans (no `ended`) use `now` as the end timestamp.
+ *
+ * This is the canonical Elapsed computation — all behaviors
+ * that need pause-aware active time should use this function.
+ *
+ * ## Glossary (docs/architecture/time-terminology.md)
+ * - **Elapsed** = Σ(end − start) per span (this function)
+ * - **Total** = lastEnd − firstStart (computed elsewhere)
+ *
+ * @param timer The timer state containing the Time spans
+ * @param now Current timestamp in milliseconds for open spans
+ * @returns Elapsed time in milliseconds (active only, excludes pauses)
+ */
+declare function calculateElapsed(timer: TimerState, now: number): number;
+/**
+ * Formats milliseconds as mm:ss for display.
+ *
+ * @param ms Duration or Elapsed value in milliseconds
+ * @returns Formatted string like "5:03"
+ */
+declare function formatDuration(ms: number): string;
+
+/** A list of execution spans. The trailing span may be open (`ended === undefined`). */
+type SpanList = readonly TimeSpan[];
+/**
+ * Start a fresh span list with a single open span.
+ * Used for the initial mount span and for interval/timer resets.
+ */
+declare function startSpan(nowMs: number): TimeSpan[];
+/**
+ * Close the trailing open span at `nowMs` (pause / unmount).
+ * No-op for spans that are already closed.
+ */
+declare function closeCurrentSpan(spans: SpanList, nowMs: number): TimeSpan[];
+/** Append a new open span at `nowMs` (resume). */
+declare function openSpan(spans: SpanList, nowMs: number): TimeSpan[];
+/**
+ * Read the `TimerState` from a block's `time` memory, or `undefined` if absent.
+ * This is the canonical accessor — prefer it over reaching into
+ * `getMemoryByTag('time')[0]?.metrics[0]?.value` by hand.
+ */
+declare function readTimer(ctx: IBehaviorContext): TimerState | undefined;
+/**
+ * Apply a span transform to the block's `time` memory, preserving the metric
+ * fragment (image, direction, durationMs, label, role) and swapping only the
+ * `spans` array.
+ *
+ * @returns `true` when the timer existed and was updated; `false` otherwise.
+ */
+declare function mutateTimerSpans(ctx: IBehaviorContext, transform: (spans: SpanList, nowMs: number) => TimeSpan[]): boolean;
+
+/**
+ * Shared utility for managing IMetric arrays and labels.
+ *
+ * This utility is used by multiple UI components:
+ * - RuntimeEventLog (sectioned log view)
+ * - RuntimeHistoryPanel (tree view)
+ * - AnalyticsLayout (timeline/graphs)
+ */
+
+/**
+ * Extract a human-readable label from an array of metric.
+ */
+declare function metricsToLabel(metrics: MetricContainer | IMetric[] | IMetric[][]): string;
+
+/**
+ * Configuration for the session root block.
+ */
+interface SessionRootConfig {
+    /** Session label (e.g., "Morning WOD") */
+    label?: string;
+    /** Child statement ID groups to execute */
+    childGroups: number[][];
+    /** Total rounds for the workout (default: 1) */
+    totalRounds?: number;
+}
+/**
+ * SessionRootBlock is the top-level container for a workout session.
+ *
+ * ## Lifecycle
+ *
+ * 1. Mount: Emits 'segment' output with session label, starts elapsed timer,
+ *    pushes WaitingToStart block as first child (index 0)
+ * 2. First next(): WaitingToStart pops → ChildRunner pushes first workout block
+ * 3. Subsequent next(): ChildRunner pushes remaining workout blocks in sequence
+ * 4. Final next(): All children done → marks complete and pops
+ * 5. Pop: emits a 'segment' output carrying the completion reason, records history
+ *
+ * ## Behavior Chain Order
+ *
+ * Behaviors are order-independent for correctness. ChildSelectionBehavior
+ * handles round advancement internally, and RuntimeBlock.next() auto-pops
+ * when any behavior marks the block complete.
+ *
+ * - CountupTimerBehavior (elapsed workout timer)
+ * - ChildSelectionBehavior (child dispatch + round init + advancement + safety net)
+ * - WaitingToStartInjectorBehavior (pushes WaitingToStart gate on mount)
+ * - ReportOutputBehavior (output on mount/unmount)
+ * - LabelingBehavior (display)
+ * - ButtonBehavior (controls)
+ *
+ * History persistence is the responsibility of the workbench — all data
+ * needed for history is available in the output stream (ReportOutputBehavior).
+ */
+declare class SessionRootBlock extends RuntimeBlock {
+    constructor(runtime: IRuntimeContext, config: SessionRootConfig);
+    /**
+     * Builds the behavior list for a session root block.
+     * @param config Session configuration
+     * @param runtime Script runtime (needed for WaitingToStartInjectorBehavior)
+     */
+    static buildBehaviors(config: SessionRootConfig, runtime: IRuntimeContext): IRuntimeBehavior[];
+    mount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    unmount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    dispose(runtime: IRuntimeContext): void;
+}
+
+/**
+ * EffortBlock Configuration
+ */
+interface EffortBlockConfig {
+    exerciseName: string;
+    targetReps: number;
+}
+/**
+ * EffortBlock tracks individual exercise/rep completion.
+ */
+declare class EffortBlock extends RuntimeBlock {
+    private readonly config;
+    private currentReps;
+    private lastCompletionMode;
+    constructor(runtime: IRuntimeContext, sourceIds: number[], config: EffortBlockConfig, metrics?: MetricContainer[]);
+    mount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    unmount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    dispose(runtime: IRuntimeContext): void;
+    /**
+     * Check if the effort target has been met.
+     * Note: This is distinct from the block's isComplete flag which is used by the stack.
+     */
+    isTargetComplete(): boolean;
+    getCurrentReps(): number;
+    getTargetReps(): number;
+    getExerciseName(): string;
+    incrementRep(): IRuntimeAction[];
+    setReps(count: number): IRuntimeAction[];
+    markComplete(): IRuntimeAction[];
+    private getMetricActions;
+}
+
+/**
+ * Configuration for the rest block.
+ */
+interface RestBlockConfig {
+    /** Duration of the rest period in milliseconds */
+    durationMs: number;
+    /** Label for the rest period (default: "Rest") */
+    label?: string;
+}
+/**
+ * RestBlock is a timer-based block for rest periods between exercises.
+ *
+ * Timer-based parents (AMRAP, EMOM) can auto-generate Rest blocks between exercises.
+ * The rest block counts down from the configured duration and auto-pops when the timer expires.
+ *
+ * ## Lifecycle
+ *
+ * 1. Mount: Emits 'segment' output with rest label and duration, starts countdown timer
+ * 2. Timer counts down via CountdownTimerBehavior span tracking
+ * 3. CountdownTimerBehavior marks complete when elapsed >= durationMs
+ * 4. Pop: emits a 'segment' output carrying the completion reason, plays rest-over sound cue
+ *
+ * ## Behavior Chain
+ *
+ * - ReportOutputBehavior (output on mount/unmount)
+ * - CountdownTimerBehavior (countdown timer + pause/resume + auto-complete)
+ * - LabelingBehavior (show rest countdown)
+ * - SoundCueBehavior (beep on unmount for rest-over signal)
+ */
+declare class RestBlock extends RuntimeBlock {
+    constructor(runtime: IRuntimeContext, config: RestBlockConfig);
+    /**
+     * Builds the behavior list for a rest block.
+     */
+    static buildBehaviors(config: RestBlockConfig): IRuntimeBehavior[];
+    mount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    unmount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    dispose(runtime: IRuntimeContext): void;
+}
+
+/**
+ * WaitingToStartBlock is an idle gate that pauses before workout execution.
+ *
+ * The user must click 'next()' (i.e., the "Start" button) to advance.
+ * When next() is called, WaitingToStart pops immediately via ExitBehavior.
+ * The parent SessionRoot then detects the pop and pushes the first workout block.
+ *
+ * ## Lifecycle
+ *
+ * 1. Mount: Emits 'segment' output with "Ready to Start" message
+ * 2. User clicks next → ExitBehavior marks complete, returns PopBlockAction
+ * 3. Pop: emits a 'segment' output carrying the completion reason
+ * 4. Parent receives control, pushes next child
+ *
+ * ## Behavior Chain
+ *
+ * - ReportOutputBehavior (output on mount/unmount)
+ * - LabelingBehavior (show "Ready to Start")
+ * - ButtonBehavior (show "Start" button)
+ * - ExitBehavior (pop on user advance)
+ */
+declare class WaitingToStartBlock extends RuntimeBlock {
+    constructor(runtime: IRuntimeContext);
+    /**
+     * Builds the behavior list for the WaitingToStart block.
+     */
+    static buildBehaviors(): IRuntimeBehavior[];
+    mount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    unmount(runtime: IRuntimeContext, options?: BlockLifecycleOptions): IRuntimeAction[];
+    dispose(runtime: IRuntimeContext): void;
+}
+
+/**
+ * Consumer-facing strategy registry, pre-seeded with the built-in strategies.
+ *
+ * Replaces the previous hardcoded `PRODUCTION_STRATEGIES` flat array. Consumer
+ * code can call `strategyRegistry.register(new MyStrategy())` to add their
+ * own strategies without editing the library.
+ *
+ * @example
+ * ```typescript
+ * import { strategyRegistry } from 'wod-wiki/core';
+ * strategyRegistry.register(new MySportStrategy());
+ * ```
+ *
+ * Note: rest blocks are NOT produced by a JIT strategy. They are built
+ * directly at runtime (PushRestBlockAction / BlockBuilder) and pushed onto
+ * the stack, so no rest strategy appears in this registry.
+ */
+declare const strategyRegistry: Registry<IRuntimeBlockStrategy>;
+/**
+ * Legacy array form of the production strategy set, kept for backward
+ * compatibility. Derived from {@link strategyRegistry} (same instances, same
+ * priority-sorted order `JitCompiler` itself would apply) rather than
+ * re-constructing a separate set of strategy instances — a previous version
+ * of this export built its own `new XxxStrategy()` list independently,
+ * which meant `strategyRegistry.register()`/`unregister()` calls silently
+ * had no effect on anything reading `PRODUCTION_STRATEGIES` directly. Use
+ * `strategyRegistry` (or `createCompiler()`, which reads it live) for new code.
+ */
+declare const PRODUCTION_STRATEGIES: readonly IRuntimeBlockStrategy[];
+/**
+ * Create a JitCompiler with the given strategies (or the registered set).
+ *
+ * The default argument now reads from the consumer-facing
+ * {@link strategyRegistry} so consumer registrations are honored. Pass an
+ * explicit array to override (e.g. in tests).
+ */
+declare function createCompiler(strategies?: IRuntimeBlockStrategy[]): JitCompiler;
+
+/**
+ * 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.
+ */
+interface AnalyticsProfileContext {
+    dialect: FenceDialect;
+    scriptMetricTypes: ReadonlySet<MetricType | string>;
+    /**
+     * Optional user physiological profile. Used by calculations that personalize
+     * output (the TIS composed calc uses vo2max to compute METmax).
+     */
+    userProfile?: {
+        /** VO2max in mL/kg/min — for personalized MET-Score normalization */
+        vo2max?: number;
+    };
+    /**
+     * Analytics context with injected services (e.g. effort resolver).
+     * When provided, the profile wires two-pass effort resolution and
+     * processors consume resolved effort data instead of hardcoded lookups.
+     */
+    analyticsContext?: AnalyticsContext;
+    /**
+     * User-authored composed calcs (#880), registered after the built-ins so
+     * they override same-id built-ins and evaluate at high priority.
+     */
+    calcs?: CalculationDefinition$1[];
+}
+/**
+ * Profile that assembles the realtime and summary processor lists
+ * for a given workout context.
+ */
+interface IAnalyticsProfile {
+    build(context: AnalyticsProfileContext): {
+        realtime: IRealtimeProcessor[];
+        summary: ISummaryProcessor[];
+    };
+}
+
+declare class AnalyticsEngine implements IAnalyticsEngine {
+    private realtimeProcessors;
+    private summaryProcessors;
+    private outputHistory;
+    /** Emits a live 'analytics' snapshot per segment so the UI updates in real time. */
+    private _onLiveOutput?;
+    /**
+     * Signature of the last live projection emission. Used by finalize() to avoid
+     * re-emitting the same projections at session end. Timestamps are ignored.
+     */
+    private _lastLiveProjectionSignature?;
+    /**
+     * Wire a sink for live analytics outputs. The sink receives the FULL
+     * projection snapshot (a replaceable, ephemeral set) each time projections
+     * change — not appended one-at-a-time. The snapshot is display-only; it must
+     * not be persisted. Persistence happens once via {@link finalize}.
+     */
+    setLiveOutputEmitter(emit: (outputs: IOutputStatement[]) => void): void;
+    addRealtimeProcessor(processor: IRealtimeProcessor): void;
+    addSummaryProcessor(processor: ISummaryProcessor): void;
+    run(output: IOutputStatement): IOutputStatement;
+    finalize(): IOutputStatement[];
+    /**
+     * Identity of a projection set for dedupe — which fields make two emission
+     * sets 'the same'. Timestamps are intentionally ignored; display/fact
+     * layers have their own keys (see getAnalyticsFromLogs and
+     * normalizeSummaryFacts).
+     */
+    private _projectionSignature;
+    /** Build one 'analytics' OutputStatement per summary projection. */
+    private _buildProjectionOutputs;
+    /** Run all summary processors over current output history. */
+    private _runSummaries;
+}
+
+/**
+ * Union accepted by the transformer — either a live OutputStatement (from a
+ * running runtime) or a plain StoredOutputStatement (loaded from IndexedDB).
+ */
+type OutputLike = IOutputStatement | StoredOutputStatement;
+/**
+ * UI-ready segment format.
+ */
+interface SegmentWithMetadata extends Segment {
+    metrics?: MetricContainer;
+    tags?: string[];
+    spanType?: string;
+    context?: Record<string, any>;
+}
+/**
+ * AnalyticsTransformer - Transforms OutputStatements into UI-ready analytics data.
+ */
+declare class AnalyticsTransformer {
+    /**
+     * Transform OutputStatements into UI-ready Segments.
+     * This is the primary API for the new runtime architecture.
+     */
+    fromOutputStatements(outputs: OutputLike[], workoutStartTime?: number, now?: INowProvider): SegmentWithMetadata[];
+    /**
+     * Group segments by analytics categories.
+     */
+    toAnalyticsGroup(segments: SegmentWithMetadata[]): AnalyticsGroup[];
+    /**
+     * Filter segments by tag.
+     */
+    filterByTags(segments: SegmentWithMetadata[], tags: string[]): SegmentWithMetadata[];
+    /**
+     * Filter segments by workout type.
+     */
+    filterByType(segments: SegmentWithMetadata[], type: string): SegmentWithMetadata[];
+    /**
+     * Get debug context from a segment.
+     */
+    getDebugContext(segment: SegmentWithMetadata): Record<string, unknown>;
+    /**
+     * Check if a segment was created by a specific strategy.
+     */
+    isFromStrategy(segment: SegmentWithMetadata, strategyName: string): boolean;
+}
+/**
+ * Analytics result from transforming runtime output.
+ */
+interface AnalyticsResult {
+    segments: SegmentWithMetadata[];
+    groups: AnalyticsGroup[];
+}
+/**
+ * Transform runtime output statements into analytics-ready data.
+ * This is the primary entry point for analytics visualization.
+ *
+ * @param runtime The script runtime to extract output from
+ * @returns Analytics data including time-series data, segments, and metric groups
+ */
+declare function getAnalyticsFromRuntime(runtime: IScriptRuntime | null): AnalyticsResult;
+/**
+ * Derive analytics segments from a stored workout log.
+ *
+ * This is the **canonical read path** for all analytics derived from a
+ * completed workout. WorkoutResult.data.logs (StoredOutputStatement[]) is
+ * the source of truth; call this function to obtain Segment[] for display,
+ * review grids, or trend summaries.
+ *
+ * Relationship to the analytics IDB store:
+ *   The `analytics` IndexedDB store holds AnalyticsDataPoint[] summary fact
+ *   rows written by normalizeSummaryFacts() from Tier-2 outputs in data.logs.
+ *   They are NOT required for any current display feature. If they disagree
+ *   with logs, logs win. Use this function — not the analytics store — to
+ *   obtain segment data for display.
+ *
+ * @param outputs - StoredOutputStatement[] from WorkoutResult.data.logs
+ * @param workoutStartTime - Optional workout start timestamp (ms). Used to
+ *   anchor relative timing in the segment timeline.
+ * @param now - Optional clock provider; defaults to wall-clock.
+ */
+declare function getAnalyticsFromLogs(outputs: StoredOutputStatement[], workoutStartTime?: number, now?: INowProvider): AnalyticsResult;
+
+/**
+ * Consumer-facing registries for analytics processors — extension points
+ * for custom (e.g. sport-specific) processors. The built-in calculations
+ * are no longer processors: they are registered composed calcs evaluated
+ * by the CalcEngine (#879 cutover). Register custom processors with the
+ * standard `register`/`unregister` shape.
+ *
+ * @example
+ * ```typescript
+ * import { summaryProcessorRegistry } from 'wod-wiki/core';
+ * summaryProcessorRegistry.register(ClimbGradeProgressionProcess);
+ * ```
+ */
+declare const realtimeProcessorRegistry: Registry<IRealtimeProcessor>;
+declare const summaryProcessorRegistry: Registry<ISummaryProcessor>;
+/**
+ * Standard built-in analytics profile.
+ *
+ * Chain: TwoPassEffortResolutionProcess (effort-data infrastructure) →
+ * CalcEngine (the composed calculation layer: phase-1 segment annotations
+ * as a realtime processor, phase-2 workout running totals as a summary
+ * processor) → any custom registry processors. Applicability of individual
+ * calcs is dynamic (`when` predicates, #848); the fence/requiredMetrics
+ * filter below still applies to custom registry processors.
+ */
+declare class StandardAnalyticsProfile implements IAnalyticsProfile {
+    build(context: AnalyticsProfileContext): {
+        realtime: IRealtimeProcessor[];
+        summary: ISummaryProcessor[];
+    };
+    private isApplicable;
+}
+
+interface CreateAnalyticsEngineResult {
+    engine: AnalyticsEngine;
+    analyticsContext: AnalyticsContext;
+}
+interface CreateAnalyticsEngineOptions {
+    effortResolver?: IEffortResolver;
+    userProfile?: {
+        vo2max?: number;
+    };
+    /** User-authored composed calcs (#880), registered after the built-ins. */
+    calcs?: CalculationDefinition$1[];
+}
+/**
+ * Creates a fully-configured AnalyticsEngine for a workout block.
+ *
+ * Extracts the dialect and metric types from the block, builds a
+ * StandardAnalyticsProfile, and assembles the engine with all
+ * applicable realtime and summary processors.
+ *
+ * When no effortResolver is provided, creates a default one backed
+ * by the bundled effort catalog (synchronously seeded).
+ */
+declare function createAnalyticsEngineForBlock(block: ScriptBlock, options?: CreateAnalyticsEngineOptions): CreateAnalyticsEngineResult;
+
+/**
+ * Two-Pass Effort Resolution — Realtime Processor
+ *
+ * Pass 1 (compile-time recovery):
+ *   Output statements that carry an effort metric with `origin: 'compiler'`
+ *   are treated as already-canonical. The processor looks them up by
+ *   slug/alias and attaches the full {@link IEffort} record.
+ *
+ * Pass 2 (analytics-time fuzzy recovery):
+ *   Output statements with free-form effort or action text get resolved
+ *   through fuzzy alias matching. A successful match attaches the effort
+ *   with `origin: 'analyzed'`; a synthetic fallback attaches it with
+ *   `origin: 'analyzed-estimated'`.
+ *
+ * The resolved effort is stored as a metric of type `'effort-data'` so
+ * downstream summary processors can consume it without importing the
+ * registry directly.
+ *
+ * @see docs/adr/effort-resolution-compile-time.md
+ */
+declare class TwoPassEffortResolutionProcess implements IRealtimeProcessor {
+    private readonly resolver;
+    readonly id = "two-pass-effort-resolution";
+    readonly fenceTypes: readonly ["time", "log"];
+    constructor(resolver: IEffortResolver);
+    process(output: IOutputStatement): IOutputStatement;
+    private resolve;
+}
+
+/**
+ * Custom metric type for resolved effort data attached by
+ * TwoPassEffortResolutionProcess.
+ */
+declare const EFFORT_DATA_METRIC_TYPE: "effort-data";
+/**
+ * Resolved effort data extracted from an enriched metrics stream.
+ */
+declare const DEFAULT_UNRESOLVED_EFFORT_MET: number;
+interface ResolvedEffortData {
+    /** Effective resolved effort instance. */
+    resolved: ResolvedEffort;
+    /** Effective effort copy retained for legacy callers. */
+    effort: IEffort;
+    origin: MetricOrigin;
+}
+/**
+ * Extract the most recent resolved effort data from a metric stream.
+ *
+ * Iterates in order and returns the last `effort-data` metric found,
+ * since metrics are processed sequentially and later entries override
+ * earlier ones within a segment.
+ */
+declare function extractEffortData(metrics: IMetric[]): ResolvedEffortData | undefined;
+/**
+ * Determine the dominant origin across a collection of effort data.
+ *
+ * Priority: analyzed-estimated (most conservative) > analyzed > compiler.
+ * If any effort was unresolved synthetic, the whole projection is flagged
+ * as estimated so downstream consumers know to treat it with caution.
+ */
+declare function resolveDominantOrigin(origins: MetricOrigin[]): MetricOrigin;
+
+/**
+ * Flatten all metrics from a collection of output statements into a single array.
+ * Preserves order. Used by projection stages to replicate the metric stream
+ * that AnalysisService previously received from ProjectionSyncProcess.
+ */
+declare function extractMetrics(outputs: IOutputStatement[]): IMetric[];
+
+interface CalculationDefinition {
+    readonly target: string;
+    readonly expression: string;
+    readonly raw: string;
+    readonly line: number;
+    readonly ast: ExpressionNode;
+    readonly sources: string[];
+}
+interface CalculateBlockParseError {
+    readonly line: number;
+    readonly raw: string;
+    readonly message: string;
+}
+interface CalculateBlockParseResult {
+    readonly definitions: CalculationDefinition[];
+    readonly errors: CalculateBlockParseError[];
+}
+type ExpressionNode = NumberNode | IdentifierNode | UnaryNode | BinaryNode | CallNode;
+interface NumberNode {
+    readonly kind: 'number';
+    readonly value: number;
+}
+interface IdentifierNode {
+    readonly kind: 'identifier';
+    readonly name: string;
+}
+interface UnaryNode {
+    readonly kind: 'unary';
+    readonly operator: '+' | '-';
+    readonly argument: ExpressionNode;
+}
+interface BinaryNode {
+    readonly kind: 'binary';
+    readonly operator: '+' | '-' | '*' | '/' | '^';
+    readonly left: ExpressionNode;
+    readonly right: ExpressionNode;
+}
+interface CallNode {
+    readonly kind: 'call';
+    readonly name: string;
+    readonly args: ExpressionNode[];
+}
+declare class CalculateBlockProcessor implements ISummaryProcessor {
+    private readonly definitions;
+    readonly id = "calculate-block";
+    readonly name = "CalculateBlockProcessor";
+    constructor(definitions: readonly CalculationDefinition[]);
+    summarize(outputs: IOutputStatement[]): ProjectionResult[];
+}
+/**
+ * Parse a `calculate` block into assignment definitions.
+ */
+declare function parseCalculateBlock(content: string): CalculateBlockParseResult;
+/**
+ * Evaluate calculate definitions against runtime output statements.
+ */
+declare function evaluateCalculateDefinitions(definitions: readonly CalculationDefinition[], outputs: readonly IOutputStatement[]): ProjectionResult[];
+
+/**
+ * Unit registry for the composed calculations layer.
+ *
+ * Every unit maps to a dimension vector plus a conversion factor to the
+ * vector's canonical base unit (ms, m, kg, reps, cal, and products thereof).
+ * `convert(x, u)` is vector-checked: source and target vectors must match,
+ * then the scalar rescales by `factor(from) / factor(to)`.
+ *
+ * Named zero-vector units (AU, pts, MET-min, ratio) are **authoritative
+ * casts** (spec §5.3): declaring them as an output unit overrides the
+ * computed vector instead of failing validation.
+ */
+
+interface UnitDef {
+    readonly dim: DimVector;
+    /** Multiply a value in this unit by `factor` to get the base-unit value. */
+    readonly factor: number;
+}
+declare const AUTHORITATIVE_CASTS: Record<string, true>;
+declare const UNITS: Record<string, UnitDef>;
+/** Authoritative casts are also valid output units (zero-vector override). */
+declare function getUnit(name: string): UnitDef | undefined;
+/**
+ * Convert a scalar between units. Vectors must match (static checking catches
+ * mismatches at registration; this is the runtime guard). A value with no
+ * recorded unit is treated as already being in the vector's base unit.
+ */
+declare function convertScalar(value: number, fromUnit: string | undefined, toUnit: string): number;
+declare class CalcUnitError extends Error {
+    constructor(message: string);
+}
+/**
+ * Compose units through `*`. Dimensionless sides contribute nothing; count
+ * units (`reps`) drop when any non-count unit is present — the domain
+ * convention behind `kg` (volume) and `kg/s` (power) rather than `kg·reps`.
+ */
+declare function composeMulUnit(a: string | undefined, aDim: DimVector, b: string | undefined, bDim: DimVector, resultDim: DimVector): string | undefined;
+/** Compose units through `/` (`m` ÷ `s` → `m/s`). */
+declare function composeDivUnit(a: string | undefined, b: string | undefined, bDim: DimVector, resultDim: DimVector): string | undefined;
+
+/**
+ * Dimension-aware value model for calc evaluation.
+ *
+ * Numbers carry a dimension vector and (optionally) the unit they were
+ * measured in; arithmetic tracks vectors per spec §5.1. `absent` is the
+ * missing-data value: it propagates through arithmetic, reads as `false` in
+ * predicates (applicability decision, #848), and is what `has()` probes.
+ */
+
+type Val = {
+    kind: 'number';
+    value: number;
+    dim: DimVector;
+    unit?: string;
+} | {
+    kind: 'string';
+    value: string;
+} | {
+    kind: 'series';
+    points: Map<number, number>;
+    dim: DimVector;
+    unit?: string;
+} | {
+    kind: 'period';
+    days: number;
+} | {
+    kind: 'absent';
+};
+declare const ABSENT: Val;
+declare function num(value: number, dim?: DimVector, unit?: string): Val;
+declare function str(value: string): Val;
+/** Predicate truthiness: absent → false; numbers → ≠ 0; strings → non-empty. */
+declare function truthy(v: Val): boolean;
+
+/**
+ * Hand-rolled parser for the calc expression language.
+ *
+ * Line-oriented and small by design (review doc §11.4): expressions use a
+ * Pratt parser; WQL atoms (`sum:reps{...} by {effort}`) lex as single atoms
+ * and stay opaque here — the QueryService layer executes them. The full
+ * authoring surface (sections, `|` variant sugar, `where` bindings) belongs
+ * to the line-form compiler (#863/#880); seeds are DAG records (#849), so
+ * only the expression/predicate core and the single-line form live here.
+ */
+
+declare class CalcParseError extends Error {
+    readonly pos: number;
+    constructor(message: string, pos: number);
+}
+/** Parse a standalone expression or predicate. */
+declare function parseExpression(src: string): ExprNode;
+/**
+ * Parse one calc line: `name = expr -> unit when predicate`.
+ * Unit may be `auto`; `key`/`grouped` output declarations are registry
+ * concerns (record form), not parsed here.
+ */
+declare function parseCalcLine(src: string): CalcLine;
+
+/**
+ * Lossless line-form compiler for the composed calculations layer (spec §2).
+ *
+ * Round-trips between the author-facing line syntax and canonical DAG
+ * records (`CalculationDefinition`, spec §2.2). The line syntax is a superset
+ * of `parseCalcLine`: it adds scope headers, `(library)` markers, `key`,
+ * `grouped`, `label`, `emit`, `meta` output clauses, `|` variant sugar (with
+ * optional `estimated` origin and per-variant `when`), and `where`
+ * intermediate bindings.
+ *
+ * Guarantees (verified by tests):
+ *   - `compile(print(def))` deep-equals `def` for any def this module emits.
+ *   - Output defs register cleanly into `CalculationRegistry` (no
+ *     `CalcRegistrationError`), so diagnostics reuse registration-time
+ *     checking.
+ *
+ * Only the atom/expression grammar lives in `parser.ts`; line structure,
+ * sections, variants, and output clauses live here.
+ */
+
+interface LineFormScope {
+    scope: CalcScope;
+    fences?: string[];
+}
+interface CompiledLineForm {
+    defs: CalculationDefinition$1[];
+    warnings: string[];
+}
+/**
+ * Compile calc-line source into DAG records.
+ *
+ * Two document styles are accepted:
+ *  - A scope header line per calc: `segment on [time, log] when P: name = …`
+ *  - A bare line: `name = …` (scope from `defaultScope`, default 'segment').
+ *
+ * One `CalculationDefinition` per line; `where` bindings fold into the line's
+ * node graph.
+ */
+declare function compileLineForm(src: string, defaultScope?: LineFormScope): CompiledLineForm;
+/**
+ * Render one `CalculationDefinition` back to canonical line form, losslessly
+ * preserving everything the parser reads (scope, fences, when, variants,
+ * origins, units, output clauses, intermediate nodes).
+ */
+/** First output node id (output.nodeId may be a single id or an array). */
+declare function outputNodeId(def: CalculationDefinition$1): string | undefined;
+declare function printCalculation(def: CalculationDefinition$1): string;
+
+/**
+ * Expression evaluator for the composed calculations layer.
+ *
+ * The core owns arithmetic, comparison/logic, and the scalar function table
+ * (min, max, abs, round, floor, ceil, clamp, convert, has). Everything
+ * scope-dependent — metric refs, context nodes, stream aggregates, lookup(),
+ * WQL atoms — resolves through the EvalContext, so the same evaluator serves
+ * segment, workout, and store scopes (spec §3.1).
+ */
+
+declare class CalcEvalError extends Error {
+    constructor(message: string);
+}
+interface EvalContext {
+    /** Resolve a ref atom (metric, context node, library node). ABSENT when missing. */
+    resolveRef(name: string): Val;
+    /**
+     * Extension functions (stream aggregates, lookup). Receives evaluated args
+     * plus the raw arg nodes (aggregates need the filter node unevaluated).
+     * Return undefined to signal "not mine" → CalcEvalError.
+     */
+    callFunction?(name: string, args: Val[], rawArgs: ExprNode[]): Val | undefined;
+    /** Store-scope WQL selections (QueryService). Store scope only. */
+    resolveWql?(node: Extract<ExprNode, {
+        kind: 'wql';
+    }>): Val;
+}
+declare function evaluate(node: ExprNode, ctx: EvalContext): Val;
+
+/**
+ * Static dimension checking, run at calc registration time (spec §5).
+ *
+ * Walks an expression computing dimension vectors: `*` adds, `/` subtracts,
+ * `+`/`-`/comparisons require equal vectors (numeric literal 0 is polymorphic
+ * so `elapsed > 0` passes), `convert()` targets must match the source
+ * vector. Declared output units must match the computed vector unless the
+ * unit is `auto` or a named zero-vector authoritative cast (AU, pts,
+ * MET-min, ratio). Any mismatch or unknown symbol is a registration error —
+ * bad calcs never reach the evaluator.
+ */
+
+declare class CalcRegistrationError extends Error {
+    constructor(message: string);
+}
+interface StaticEnv {
+    /** Dimension of a ref atom; undefined → unknown symbol error. */
+    refDim(name: string): DimVector | undefined;
+    /** Dimension of an extension function result (aggregates, lookup fields). */
+    callDim?(name: string, argDims: (DimVector | undefined)[]): DimVector | undefined;
+    /** Dimension of a lookup() table field; undefined → unknown table/field. */
+    lookupDim?(table: string, field: string): DimVector | undefined;
+    /** Dimension of a WQL selection result; defaults to dimensionless. */
+    wqlDim?(node: Extract<ExprNode, {
+        kind: 'wql';
+    }>): DimVector | undefined;
+}
+/** Infer the dimension vector of an expression, throwing on any violation. */
+declare function inferDim(node: ExprNode, env: StaticEnv): DimVector;
+/**
+ * Validate a parsed calc line's declared output unit against the computed
+ * vector. `auto` always passes; authoritative casts override; anything else
+ * must match exactly.
+ */
+declare function validateOutputUnit(exprDim: DimVector, unit: string | undefined): void;
+/** Full registration-time check for one calc line. Returns the computed vector. */
+declare function checkCalcLine(line: CalcLine, env: StaticEnv): DimVector;
+
+/**
+ * Lookup table registry (spec §4).
+ *
+ * Tables are adapters over heterogeneous sources (effort resolver, static
+ * maps, user profile) exposing a uniform single-row lookup contract:
+ * `lookup("table", keyExpr, "field")`. Registration is layered —
+ * bundled → dialect → user — with later layers replacing earlier ones
+ * (mirrors the Dialect Stack's personal-overrides-last rule). Miss behavior
+ * is per-table: `absent` yields the absent value; `default-row` yields a
+ * synthetic row so calcs never see a miss.
+ */
+
+interface LookupFieldDef {
+    dimension: DimVector;
+    type: 'number' | 'string';
+}
+interface ILookupTable {
+    readonly id: string;
+    readonly fields: Record<string, LookupFieldDef>;
+    readonly missPolicy: 'absent' | 'default-row';
+    /** Single-row lookup. `absent` tables return undefined on a miss. */
+    get(key: string, field: string): Val | undefined;
+}
+type LookupLayer = 'bundled' | 'dialect' | 'user';
+declare class LookupRegistry {
+    private readonly tables;
+    /** Register a table; a later-or-equal layer replaces the existing entry. */
+    register(table: ILookupTable, layer?: LookupLayer): void;
+    get(tableId: string): ILookupTable | undefined;
+    /** Field dimension for static checking; undefined when table/field unknown. */
+    fieldDim(tableId: string, field: string): DimVector | undefined;
+    /** Runtime lookup honoring the table's miss policy. */
+    lookup(tableId: string, key: string, field: string): Val;
+    /**
+     * EvalContext `callFunction` implementation for `lookup("table", key, "field")`.
+     * Compose with other extension functions (aggregates) at the engine layer.
+     */
+    readonly callFunction: EvalContext['callFunction'];
+}
+
+/**
+ * Built-in lookup table adapters (spec §4.1).
+ *
+ * - `effort` — IEffortResolver-backed; preserves fuzzy matching, aliases,
+ *   derivations, modifiers. Miss policy `default-row`: the resolver's
+ *   synthetic unresolved effort (default MET 5.0, flagged isEstimated)
+ *   guarantees a row for any key.
+ * - `rpe-labels` — effort label → RPE map shared by SessionLoad and TIS
+ *   (replaces the duplicated effortToRpe maps, review doc §7 note b).
+ * - `profile` — user profile attributes (vo2max). Miss policy `absent`.
+ * - `disciplines` — canonical discipline factor table. Miss policy
+ *   `default-row` (1.0).
+ */
+
+/** Label → RPE. Canonical map (SessionLoadProjectionEngine / TISProcessor). */
+declare const RPE_LABELS: Record<string, number>;
+declare function createEffortTable(resolver: IEffortResolver): ILookupTable;
+declare function createRpeLabelsTable(): ILookupTable;
+interface IProfileSource {
+    readonly vo2max?: number;
+}
+declare function createProfileTable(profile: IProfileSource | undefined): ILookupTable;
+declare function createDisciplinesTable(): ILookupTable;
+
+/**
+ * Known atom vocabulary for the composed calculations layer.
+ *
+ * Stream atoms name metrics on the log stream that aggregates scan
+ * (`sum(metMinutes)` reads `metMinutes` segment annotations). Context atoms
+ * are engine-provided nodes (`session.duration`, `effort`, …). Registration
+ * uses these tables for static dimension checking; evaluation uses them to
+ * resolve refs and stamp units.
+ */
+
+interface StreamAtomDef {
+    dim: DimVector;
+    /** Metric type scanned on the log stream. */
+    metricType: string;
+    /** Unit stamped on aggregate values (last-seen source unit wins for distance/volume). */
+    unit?: string;
+}
+declare const STREAM_ATOMS: Record<string, StreamAtomDef>;
+/** Engine-provided context nodes (both scopes, where meaningful). */
+declare const CONTEXT_ATOMS: Record<string, DimVector>;
+/** Stream aggregate builtins (workout scope). `count` is dimensionless. */
+declare const AGGREGATE_BUILTINS: Record<string, true>;
+
+/**
+ * Calculation registry — registration and static validation of composed
+ * calculation DAG records (spec §2.2).
+ *
+ * Every expression and predicate is parsed and dimension-checked at
+ * registration (spec §5): unknown symbols, dimension mismatches, bad
+ * convert targets, and invalid output units fail here, never at runtime.
+ * Library calcs register their node dimensions under qualified names
+ * (`calcId.nodeId`) so dependent calcs can reference them statically.
+ */
+
+declare class CalculationRegistry {
+    private readonly lookups;
+    private readonly defs;
+    /** Qualified library node dimensions: `calcId.nodeId` → vector. */
+    private readonly libraryDims;
+    constructor(lookups: LookupRegistry);
+    /** All registered calcs for a scope, registration order preserved. */
+    byScope(scope: CalcScope): CalculationDefinition$1[];
+    get(id: string): CalculationDefinition$1 | undefined;
+    /**
+     * Register a calculation. Compiles every node expression and predicate,
+     * runs static dimension checking, and (for library calcs) publishes node
+     * dimensions for dependent calcs. Throws CalcRegistrationError on any
+     * violation.
+     */
+    register(def: CalculationDefinition$1): void;
+    /** Parse + dimension-check every node and predicate in a variant. */
+    private compileVariant;
+    /** Static environment for a calc: siblings → library → stream → context. */
+    private staticEnv;
+}
+/** Output node ids as an array regardless of the single/multi form. */
+declare function outputNodeIds(def: CalculationDefinition$1): string[];
+
+/**
+ * Composed calculation engine — Phases 1 & 2 of the evaluation pipeline
+ * (spec §1.1).
+ *
+ * Implements both legacy processor contracts so it drops into the existing
+ * AnalyticsEngine chain:
+ *
+ * - `process(output)` — **Phase 1, segment scope.** On each leaf segment,
+ *   evaluates segment calcs against the segment's metrics + context and
+ *   appends `analyzed` / `analyzed-estimated` annotations to the segment's
+ *   own OutputStatement (pace, power, and the library nodes segmentVolume,
+ *   effortRpe, metMinutes + the metMinutesEstimated companion count).
+ *
+ * - `summarize(outputs)` — **Phase 2, workout scope.** Recompute-all over
+ *   the accumulated log-stream history: stream aggregates, context nodes,
+ *   variant resolution, grouped emission. Emits ProjectionResults which the
+ *   AnalyticsEngine turns into replacement `analytics` OutputStatements
+ *   with signature dedupe (live running totals).
+ *
+ * Store scope (Phase 3) lives in the rollup driver replacement (#877).
+ */
+
+interface CalcEngineDeps {
+    /** Fence dialect of the block being analyzed; calcs filter on it. */
+    dialect: string;
+    lookups: LookupRegistry;
+    userProfile?: IProfileSource;
+}
+declare class CalcEngine implements IRealtimeProcessor, ISummaryProcessor {
+    private readonly registry;
+    private readonly deps;
+    readonly id = "composed-calculations";
+    readonly fenceTypes: readonly ["time", "log"];
+    private readonly segmentCalcs;
+    private readonly workoutCalcs;
+    /**
+     * Last resolved effort slug seen this workout — the "last-seen effort"
+     * scan state from MetMinuteProjectionEngine, carried across process()
+     * calls (segments arrive in stream order, live and in replay).
+     */
+    private lastSegmentEffort?;
+    constructor(registry: CalculationRegistry, deps: CalcEngineDeps);
+    process(output: IOutputStatement): IOutputStatement;
+    private appendAnnotation;
+    /** A frozen prediction of this type already rides the segment (replay). */
+    private hasFrozen;
+    summarize(outputs: IOutputStatement[]): ProjectionResult[];
+    private summarizeUngrouped;
+    private summarizeGrouped;
+    private lookupString;
+    private toProjection;
+    private applicable;
+    /** First applicable variant wins (variants are pre-sorted by priority). */
+    private selectVariant;
+    /** Evaluate all nodes in a variant, resolving sibling refs lazily. */
+    private evaluateVariant;
+    private makeContext;
+    /** Workout-scope atoms over a segment list (full history or one group). */
+    private buildWorkoutAtoms;
+}
+
+/**
+ * Built-in calculation suite as DAG seed records (#849 resolution 4: seeds
+ * are TS object literals; no parser on the critical path — the line-form
+ * parser's acceptance test is round-tripping these exact records).
+ *
+ * This is spec §6 compiled to record form, with the migration decisions
+ * baked in:
+ * - rest exclusion pinned once as the shared filter `rest|pause|rest-*` (§10.6);
+ * - origin provenance via the metMinutesEstimated companion count (§10.3);
+ * - TIS intermediate nodes published as fact metadata (§10.4);
+ * - durationScore carries a `pts` cast — §5.3 applied to intermediates so
+ *   the score algebra passes static dimension checking;
+ * - rounding lives in `round()` where today rounds, nowhere else (§10.9).
+ */
+
+/** Shared rest/pause exclusion filter constant (§10.6). */
+declare const REST_EXCLUSION = "rest|pause|rest-*";
+declare const BUILTIN_CALCS: CalculationDefinition$1[];
+declare const STORE_CALCS: CalculationDefinition$1[];
+
+/**
+ * Factory for a fully-seeded composed calculation stack: lookup registry
+ * with the four built-in adapters, calculation registry with the built-in
+ * suite statically validated, and the engine ready to join an
+ * AnalyticsEngine processor chain.
+ */
+
+interface CalcStackOptions {
+    effortResolver: IEffortResolver;
+    userProfile?: IProfileSource;
+    /** Extra/override calcs (dialect, user) registered after the built-ins. */
+    calcs?: CalculationDefinition$1[];
+}
+interface CalcStack {
+    lookups: LookupRegistry;
+    registry: CalculationRegistry;
+}
+declare function createCalcStack(options: CalcStackOptions): CalcStack;
+declare function createCalcEngine(dialect: string, options: CalcStackOptions): CalcEngine;
+
+interface CalcDiagnostic {
+    severity: 'error' | 'warning';
+    message: string;
+}
+interface CalcAnalysis {
+    defs: CalculationDefinition$1[];
+    diagnostics: CalcDiagnostic[];
+    dim: DimVector | undefined;
+    compound: string | undefined;
+}
+declare function buildStaticLookups(): LookupRegistry;
+
+declare const index_ABSENT: typeof ABSENT;
+declare const index_AGGREGATE_BUILTINS: typeof AGGREGATE_BUILTINS;
+declare const index_AUTHORITATIVE_CASTS: typeof AUTHORITATIVE_CASTS;
+declare const index_BUILTIN_CALCS: typeof BUILTIN_CALCS;
+type index_BinaryOp = BinaryOp;
+declare const index_CONTEXT_ATOMS: typeof CONTEXT_ATOMS;
+type index_CalcAnalysis = CalcAnalysis;
+type index_CalcDiagnostic = CalcDiagnostic;
+type index_CalcEngine = CalcEngine;
+declare const index_CalcEngine: typeof CalcEngine;
+type index_CalcEngineDeps = CalcEngineDeps;
+type index_CalcEvalError = CalcEvalError;
+declare const index_CalcEvalError: typeof CalcEvalError;
+type index_CalcLine = CalcLine;
+type index_CalcNode = CalcNode;
+type index_CalcOrigin = CalcOrigin;
+type index_CalcParseError = CalcParseError;
+declare const index_CalcParseError: typeof CalcParseError;
+type index_CalcRegistrationError = CalcRegistrationError;
+declare const index_CalcRegistrationError: typeof CalcRegistrationError;
+type index_CalcScope = CalcScope;
+type index_CalcStack = CalcStack;
+type index_CalcStackOptions = CalcStackOptions;
+type index_CalcUnitError = CalcUnitError;
+declare const index_CalcUnitError: typeof CalcUnitError;
+type index_CalcVariant = CalcVariant;
+type index_CalculationRegistry = CalculationRegistry;
+declare const index_CalculationRegistry: typeof CalculationRegistry;
+type index_CompiledLineForm = CompiledLineForm;
+declare const index_DIM_COUNT: typeof DIM_COUNT;
+declare const index_DIM_ENERGY: typeof DIM_ENERGY;
+declare const index_DIM_LENGTH: typeof DIM_LENGTH;
+declare const index_DIM_MASS: typeof DIM_MASS;
+declare const index_DIM_TIME: typeof DIM_TIME;
+declare const index_DIM_ZERO: typeof DIM_ZERO;
+type index_DimVector = DimVector;
+type index_EvalContext = EvalContext;
+type index_ExprNode = ExprNode;
+type index_ILookupTable = ILookupTable;
+type index_IProfileSource = IProfileSource;
+type index_LineFormScope = LineFormScope;
+type index_LookupFieldDef = LookupFieldDef;
+type index_LookupLayer = LookupLayer;
+type index_LookupRegistry = LookupRegistry;
+declare const index_LookupRegistry: typeof LookupRegistry;
+declare const index_NAMED_COMPOUNDS: typeof NAMED_COMPOUNDS;
+declare const index_REST_EXCLUSION: typeof REST_EXCLUSION;
+declare const index_RPE_LABELS: typeof RPE_LABELS;
+declare const index_STORE_CALCS: typeof STORE_CALCS;
+declare const index_STREAM_ATOMS: typeof STREAM_ATOMS;
+type index_StaticEnv = StaticEnv;
+type index_StreamAtomDef = StreamAtomDef;
+declare const index_UNITS: typeof UNITS;
+type index_UnitDef = UnitDef;
+type index_Val = Val;
+declare const index_addDim: typeof addDim;
+declare const index_buildStaticLookups: typeof buildStaticLookups;
+declare const index_checkCalcLine: typeof checkCalcLine;
+declare const index_compileLineForm: typeof compileLineForm;
+declare const index_composeDivUnit: typeof composeDivUnit;
+declare const index_composeMulUnit: typeof composeMulUnit;
+declare const index_compoundName: typeof compoundName;
+declare const index_convertScalar: typeof convertScalar;
+declare const index_createCalcEngine: typeof createCalcEngine;
+declare const index_createCalcStack: typeof createCalcStack;
+declare const index_createDisciplinesTable: typeof createDisciplinesTable;
+declare const index_createEffortTable: typeof createEffortTable;
+declare const index_createProfileTable: typeof createProfileTable;
+declare const index_createRpeLabelsTable: typeof createRpeLabelsTable;
+declare const index_dimEquals: typeof dimEquals;
+declare const index_evaluate: typeof evaluate;
+declare const index_formatDim: typeof formatDim;
+declare const index_getUnit: typeof getUnit;
+declare const index_inferDim: typeof inferDim;
+declare const index_isDimensionless: typeof isDimensionless;
+declare const index_num: typeof num;
+declare const index_outputNodeId: typeof outputNodeId;
+declare const index_outputNodeIds: typeof outputNodeIds;
+declare const index_parseCalcLine: typeof parseCalcLine;
+declare const index_parseExpression: typeof parseExpression;
+declare const index_printCalculation: typeof printCalculation;
+declare const index_str: typeof str;
+declare const index_subDim: typeof subDim;
+declare const index_truthy: typeof truthy;
+declare const index_validateOutputUnit: typeof validateOutputUnit;
+declare namespace index {
+  export { index_ABSENT as ABSENT, index_AGGREGATE_BUILTINS as AGGREGATE_BUILTINS, index_AUTHORITATIVE_CASTS as AUTHORITATIVE_CASTS, index_BUILTIN_CALCS as BUILTIN_CALCS, type index_BinaryOp as BinaryOp, index_CONTEXT_ATOMS as CONTEXT_ATOMS, type index_CalcAnalysis as CalcAnalysis, type index_CalcDiagnostic as CalcDiagnostic, index_CalcEngine as CalcEngine, type index_CalcEngineDeps as CalcEngineDeps, index_CalcEvalError as CalcEvalError, type index_CalcLine as CalcLine, type index_CalcNode as CalcNode, type index_CalcOrigin as CalcOrigin, index_CalcParseError as CalcParseError, index_CalcRegistrationError as CalcRegistrationError, type index_CalcScope as CalcScope, type index_CalcStack as CalcStack, type index_CalcStackOptions as CalcStackOptions, index_CalcUnitError as CalcUnitError, type index_CalcVariant as CalcVariant, type CalculationDefinition$1 as CalculationDefinition, index_CalculationRegistry as CalculationRegistry, type index_CompiledLineForm as CompiledLineForm, index_DIM_COUNT as DIM_COUNT, index_DIM_ENERGY as DIM_ENERGY, index_DIM_LENGTH as DIM_LENGTH, index_DIM_MASS as DIM_MASS, index_DIM_TIME as DIM_TIME, index_DIM_ZERO as DIM_ZERO, type index_DimVector as DimVector, type index_EvalContext as EvalContext, type index_ExprNode as ExprNode, type index_ILookupTable as ILookupTable, type index_IProfileSource as IProfileSource, type index_LineFormScope as LineFormScope, type index_LookupFieldDef as LookupFieldDef, type index_LookupLayer as LookupLayer, index_LookupRegistry as LookupRegistry, index_NAMED_COMPOUNDS as NAMED_COMPOUNDS, index_REST_EXCLUSION as REST_EXCLUSION, index_RPE_LABELS as RPE_LABELS, index_STORE_CALCS as STORE_CALCS, index_STREAM_ATOMS as STREAM_ATOMS, type index_StaticEnv as StaticEnv, type index_StreamAtomDef as StreamAtomDef, index_UNITS as UNITS, type index_UnitDef as UnitDef, type index_Val as Val, index_addDim as addDim, index_buildStaticLookups as buildStaticLookups, index_checkCalcLine as checkCalcLine, index_compileLineForm as compileLineForm, index_composeDivUnit as composeDivUnit, index_composeMulUnit as composeMulUnit, index_compoundName as compoundName, index_convertScalar as convertScalar, index_createCalcEngine as createCalcEngine, index_createCalcStack as createCalcStack, index_createDisciplinesTable as createDisciplinesTable, index_createEffortTable as createEffortTable, index_createProfileTable as createProfileTable, index_createRpeLabelsTable as createRpeLabelsTable, index_dimEquals as dimEquals, index_evaluate as evaluate, index_formatDim as formatDim, index_getUnit as getUnit, index_inferDim as inferDim, index_isDimensionless as isDimensionless, index_num as num, index_outputNodeId as outputNodeId, index_outputNodeIds as outputNodeIds, index_parseCalcLine as parseCalcLine, index_parseExpression as parseExpression, index_printCalculation as printCalculation, index_str as str, index_subDim as subDim, index_truthy as truthy, index_validateOutputUnit as validateOutputUnit };
+}
+
+/**
+ * workloadRollup — pure workload-window math behind Rollup Facts
+ * (CONTEXT.md §Analytics). Foster sRPE periodization over daily SessionLoad:
+ *
+ *   dailyLoad[d] = Σ sessionLoad fact values in UTC day d
+ *   acute        = mean daily load over the trailing 7 days  (D-6 … D)
+ *   chronic      = mean daily load over the trailing 28 days (D-27 … D)
+ *   ACWR         = acute / chronic            — emitted when chronic > 0
+ *   monotony     = mean7 / sd7                — population SD (÷7) over the 7
+ *                  daily values; emitted when sd7 > 0 (a flat week has no
+ *                  meaningful monotony)
+ *   strain       = monotony × (Σ of the 7 daily loads) — emitted with monotony
+ *
+ * Day buckets are UTC (`Math.floor(ts / DAY)`) — the same bucketing the
+ * Query Service uses for the `day` dimension, so rollup rows land in the
+ * buckets widgets already group by.
+ */
+declare const DAY = 86400000;
+/** Local day bucket for a canonical timestamp. */
+declare function dayBucket(ts: number): number;
+/** One UTC day's computed windows; absent fields were suppressed (see header). */
+interface DayRollup {
+    day: number;
+    acwr?: number;
+    monotony?: number;
+    strain?: number;
+}
+/** Sum fact values into UTC day buckets. */
+declare function dailySessionLoads(facts: readonly {
+    timestamp: number;
+    value: number;
+}[]): Map<number, number>;
+/**
+ * Compute the Foster windows for every day that can produce a value: from
+ * the first day with load through `throughDay` (inclusive, UTC day bucket).
+ * Earlier days have empty chronic windows and zero-variance acute windows,
+ * so every value would be suppressed anyway.
+ */
+declare function computeWorkloadRollups(loads: ReadonlyMap<number, number>, throughDay: number): DayRollup[];
+
+/**
+ * Convert a live IOutputStatement into a StoredOutputStatement.
+ *
+ * Normalises non-serialisable types (`Set` → `string[]`, `MetricContainer` → `IMetric[]`)
+ * so the result survives a JSON / IndexedDB round-trip without data loss.
+ */
+declare function toStoredOutputStatement(output: IOutputStatement | OutputStatement): StoredOutputStatement;
+
+export { AbortSessionAction, type ActionDescriptor, type ActionPrimitive, AnalyticsContext, AnalyticsEngine, type AnalyticsProfileContext, type AnalyticsResult, AnalyticsTransformer, BUILTIN_CALCS, BUNDLED_EFFORT_COUNT, BehaviorContext, BlockContext, BlockLifecycleOptions, CONSUMED_HINTS, CONSUMED_HINT_KEYS, type CalculationDefinition$1 as CalcDefinition, CalcEngine, type CalcOrigin, type CalcScope, type CalculationDefinition as CalculateBlockDefinition, type CalculateBlockParseError, type CalculateBlockParseResult, CalculateBlockProcessor, CalculationRegistry, CardioDialect, ClearChildrenAction, ClimbDialect, type ClimbGradeMetricValue, type ClimbGradeSystem, ClimbMetricType, CompileAndPushBlockAction, CompletionDecision, type CreateAnalyticsEngineOptions, type CreateAnalyticsEngineResult, CrossFitDialect, DAY, DEFAULT_UNRESOLVED_EFFORT_MET, DIM_LENGTH, DIM_MASS, DIM_TIME, DIM_ZERO, type DayRollup, DialectStack, type Dimension, type DurationPrimitive, EFFORT_DATA_METRIC_TYPE, EffortBlock, type EffortBlockConfig, type EffortPrimitive, EffortRegistrySource, EffortResolutionOptions, EffortResolver, EffortResolverOptions, EmitEventAction, EmitSystemOutputAction, ErrorAction, EventBus, type EventHandlerRegistration, ExecutionContext, type FuzzyCandidate, HabitsDialect, type HeadingPrimitive, IAnalyticsEngine, type IAnalyticsProfile, IBlockContext, IEffort, IEffortRegistry, IEffortResolver, IEvent, IEventBus, IJitCompiler, type ILookupTable, IMemoryLocation, IMemoryReference, type IMetricPresentationPolicy, INowProvider, IRealtimeProcessor, IRuntimeAction, IRuntimeBehavior, IRuntimeBlock, type IRuntimeBlockStrategy, IRuntimeClock, type IRuntimeFactory, IRuntimeStack, IScript, IScriptRuntime, ISummaryProcessor, InMemoryEffortRegistry, JitCompiler, type LapPrimitive, type LineLocator, type LogLevel, LookupRegistry, MdTimerRuntime, MemoryTag, MemoryTypeEnum, type MetricObjectPrimitive, type MetricPresentationSurface, type MetricPresentationToken, type MetricRenderKind, type MetricTone, MetricVisibility, type MockClock, NextAction, NextEvent, NextEventHandler, OutputEmitter, PREDEFINED_SOUNDS, PRODUCTION_STRATEGIES, type ParseOptions, PlaySoundAction, PopBlockAction, type PredefinedSoundName, ProjectionResult, type PropertyPrimitive, PushBlockAction, PushRestBlockAction, type QuantityPrimitive, RegisterEventHandlerAction, Registry, ResolvedEffort, type ResolvedEffortData, RestBlock, type RestBlockConfig, type RoundsPrimitive, RuntimeBlock, type RuntimeBlockOptions, RuntimeBuilder, type RuntimeButton, RuntimeClock, type RuntimeController, type RuntimeControls, RuntimeError, RuntimeFactory, type RuntimeLogEntry, RuntimeLogger, RuntimeMemory, type RuntimeMemoryLocation, RuntimeObservers, RuntimeStack, STANDARD_UNITS, STORE_CALCS, ScriptRuntime, type SegmentWithMetadata, SessionRootBlock, type SessionRootConfig, SnapshotClock, type SoundBehaviorConfig, type SoundCue, type SoundCueState, type SoundState, type SourceInput, type SpanList, StackObserver, StackSnapshot, StandardAnalyticsProfile, StartSessionAction, type StartSessionOptions, StartWorkoutAction, type StartWorkoutOptions, type SyntaxFacts, type SyntaxMeta, type SyntaxPrimitive, type SyntaxStatement, type TextPrimitive, ThrowError, ThrowErrorAction, TimeSpan, TimerState, TwoPassEffortResolutionProcess, TypedMemoryReference, type UnitDef$1 as UnitDef, type UnitMatch, UnitRegistry, UnitSet, UnitsDialect, UnregisterEventHandlerAction, Unsubscribe, UpdateNextPreviewAction, WaitingToStartBlock, WhiteboardScript, WodDialect, YogaDialect, buildTooltip, bundledEfforts, index as calc, calculateElapsed, classifyStatements, closeCurrentSpan, commonFixtureSet, computeColumnLabel, computeLabel, computeWorkloadRollups, createAnalyticsEngineForBlock, createCalcEngine, createCompiler, createDialectStack, createLineLocator, createPolicy as createMetricPresentationPolicy, createMockClock, createParser, dailySessionLoads, dayBucket, dialectRegistry, dialectStack, evaluate, evaluateCalculateDefinitions, extractEffortData, extractMetrics, extractStatements, extractStatementsRaw, extractSyntaxFacts, findBestFuzzyMatch, fixtureBackSquat, fixtureBurpee, fixturePlank, fixtureRowing, fixtureRunning, fixtureUserCustom, fixtureUserOverride, formatDuration, metricsToLabel as fragmentsToLabel, fullFixtureSet, fuseUnits, fuseUnitsInMetrics, getAnalyticsFromLogs, getAnalyticsFromRuntime, getHints, hasHint, hintMetric, hintsToContainer, isTimeLikeMetric, isWithinThreshold, levenshteinDistance, metricPresentation, mutateTimerSpans, normalizeForFuzzy, openSpan, parseCalcLine, parseCalculateBlock, parseExpression, parseScript, readTimer, realtimeProcessorRegistry, resolveDominantOrigin, sharedParser, startSpan, strategyRegistry, summaryProcessorRegistry, toStoredOutputStatement, parser as whiteboardParser, whiteboardScript, whiteboardScriptLanguage };