@bitcobblers/wod-wiki-lang 0.1.5 → 0.1.8

package/dist/index.mjs

@@ -5542,6 +5542,11 @@ var RuntimeStack = class {
     }
   }
 };
+
+// src/runtime/contracts/ICastSubscription.ts
+function isCastSubscription(s) {
+  return "sendAnalyticsSummary" in s && typeof s.sendAnalyticsSummary === "function";
+}
 var CompletionTimestampBehavior = class {
   completionTime;
   wasComplete = false;
@@ -11520,6 +11525,514 @@ var PlaySoundAction = class {
     return runtime.eventBus.dispatch(event, runtime);
   }
 };
+
+// src/runtime/utils/MemoryUtils.ts
+function searchStackMemory(runtime, criteria) {
+  const results = [];
+  if (!runtime.stack || !runtime.stack.blocks) {
+    return results;
+  }
+  for (const block of runtime.stack.blocks) {
+    if (!block.context || !block.context.references) {
+      continue;
+    }
+    const matches = block.context.references.filter((ref) => {
+      if (criteria.id !== void 0 && criteria.id !== null && ref.id !== criteria.id) return false;
+      if (criteria.ownerId !== void 0 && criteria.ownerId !== null && ref.ownerId !== criteria.ownerId) return false;
+      if (criteria.type !== void 0 && criteria.type !== null && ref.type !== criteria.type) return false;
+      if (criteria.visibility !== void 0 && criteria.visibility !== null && ref.visibility !== criteria.visibility) return false;
+      return true;
+    });
+    results.push(...matches);
+  }
+  return results;
+}
+
+// src/runtime/adapters/RuntimeAdapter.ts
+var RuntimeAdapter = class {
+  /**
+   * Creates immutable snapshot of runtime state for UI rendering
+   */
+  createSnapshot(runtime) {
+    const stackBlocks = this.extractStackBlocks(runtime);
+    const memoryEntries = this.extractMemoryEntries(runtime);
+    const activeIndex = stackBlocks.findIndex((block) => block.isActive);
+    const groupedByOwner = this.groupMemoryEntries(memoryEntries, "owner");
+    const groupedByType = this.groupMemoryEntries(memoryEntries, "type");
+    const status = this.determineExecutionStatus(stackBlocks);
+    return {
+      stack: {
+        blocks: stackBlocks,
+        activeIndex: activeIndex >= 0 ? activeIndex : 0,
+        depth: stackBlocks.length,
+        rootBlockKey: stackBlocks.length > 0 ? stackBlocks[0].key : void 0
+      },
+      memory: {
+        entries: memoryEntries,
+        groupedByOwner,
+        groupedByType,
+        totalEntries: memoryEntries.length
+      },
+      status,
+      metadata: {
+        stepCount: 0,
+        // TODO: Track actual step count
+        elapsedTime: 0,
+        // TODO: Track actual elapsed time
+        lastEvent: void 0,
+        lastEventTime: void 0
+      },
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Extracts RuntimeStackBlocks from runtime stack
+   */
+  extractStackBlocks(runtime) {
+    const blocks = runtime.stack.blocks;
+    return blocks.map((block, index) => {
+      const blockType = this.mapBlockType(block);
+      const isActive = index === blocks.length - 1;
+      const status = this.determineBlockStatus(isActive);
+      const metrics = this.extractBlockFragments(runtime, block);
+      const displayLocs = block.getMemoryByTag("metric:display");
+      const metricGroups = displayLocs.length > 1 ? displayLocs.map((loc) => MetricContainer.from([...loc.metrics])) : void 0;
+      return {
+        key: block.key.toString(),
+        blockType,
+        parentKey: this.findParentKey(blocks, index),
+        children: this.findChildrenKeys(blocks, block.key.toString()),
+        depth: index,
+        label: block.label || this.generateBlockLabel(blockType),
+        color: this.getBlockColor(blockType),
+        icon: this.getBlockIcon(blockType),
+        isActive,
+        isComplete: status === "complete",
+        status,
+        metric: {},
+        // TODO: Extract actual metrics
+        metrics,
+        metricGroups,
+        sourceIds: block.sourceIds,
+        lineNumber: block.sourceIds.length > 0 ? block.sourceIds[0] : void 0,
+        metadata: {
+          mountTime: void 0,
+          executionTime: void 0,
+          iterationCount: void 0
+        }
+      };
+    });
+  }
+  /**
+   * Extracts metrics from block's source statements for unified visualization
+   */
+  extractBlockFragments(_runtime, block) {
+    if (!block.sourceIds || block.sourceIds.length === 0) {
+      return void 0;
+    }
+    return void 0;
+  }
+  /**
+   * Extracts MemoryEntries from runtime memory
+   */
+  extractMemoryEntries(runtime) {
+    const entries = [];
+    const ownerLineMap = /* @__PURE__ */ new Map();
+    const ownerLabelMap = /* @__PURE__ */ new Map();
+    runtime.stack.blocks.forEach((block) => {
+      const key = block.key.toString();
+      if (block.sourceIds && block.sourceIds.length > 0) {
+        ownerLineMap.set(key, block.sourceIds[0]);
+      }
+      ownerLabelMap.set(key, block.label);
+    });
+    for (const block of runtime.stack.blocks) {
+      const blockKey = block.key.toString();
+      const locations = block.getAllMemory();
+      for (const loc of locations) {
+        const tag = loc.tag;
+        const value = loc.metrics.length > 0 ? loc.metrics[0].value : void 0;
+        const memoryType = this.mapMemoryType(tag);
+        const entryId = `${blockKey}-${tag}`;
+        entries.push({
+          id: entryId,
+          ownerId: blockKey,
+          ownerLabel: ownerLabelMap.get(blockKey) ?? blockKey,
+          type: memoryType,
+          value,
+          valueFormatted: this.formatValue(value),
+          label: this.generateMemoryLabelFromType(tag, memoryType),
+          groupLabel: this.generateGroupLabel(memoryType),
+          icon: this.getMemoryIcon(memoryType),
+          lineNumber: ownerLineMap.get(blockKey),
+          isValid: value !== void 0,
+          isHighlighted: false,
+          metadata: {
+            createdAt: void 0,
+            lastModified: void 0,
+            accessCount: void 0
+          },
+          references: [],
+          referencedBy: []
+        });
+      }
+    }
+    const references = searchStackMemory(runtime, {});
+    for (const ref of references) {
+      const existingId = `${ref.ownerId}-${ref.type}`;
+      if (entries.some((e) => e.id === existingId)) {
+        continue;
+      }
+      const value = ref.value();
+      const memoryType = this.mapMemoryType(ref.type);
+      entries.push({
+        id: ref.id,
+        ownerId: ref.ownerId,
+        ownerLabel: ownerLabelMap.get(ref.ownerId) ?? this.generateOwnerLabel(ref.ownerId),
+        type: memoryType,
+        value,
+        valueFormatted: this.formatValue(value),
+        label: this.generateMemoryLabel(ref, memoryType),
+        groupLabel: this.generateGroupLabel(memoryType),
+        icon: this.getMemoryIcon(memoryType),
+        lineNumber: ownerLineMap.get(ref.ownerId),
+        isValid: value !== void 0,
+        isHighlighted: false,
+        metadata: {
+          createdAt: void 0,
+          lastModified: void 0,
+          accessCount: void 0
+        },
+        references: [],
+        referencedBy: []
+      });
+    }
+    return entries;
+  }
+  /**
+   * Generates a label for a memory entry from its type
+   */
+  generateMemoryLabelFromType(rawType, _displayType) {
+    const typeStr = rawType.toString();
+    return typeStr.charAt(0).toUpperCase() + typeStr.slice(1).replace(/-/g, " ");
+  }
+  /**
+   * Groups memory entries by specified grouping strategy
+   */
+  groupMemoryEntries(entries, groupBy) {
+    const groups = /* @__PURE__ */ new Map();
+    if (groupBy === "none") {
+      groups.set("All Entries", entries);
+      return groups;
+    }
+    for (const entry of entries) {
+      let groupKey;
+      switch (groupBy) {
+        case "owner":
+          groupKey = entry.ownerLabel || entry.ownerId;
+          break;
+        case "type":
+          groupKey = entry.type;
+          break;
+        default:
+          groupKey = "Unknown";
+      }
+      if (!groups.has(groupKey)) {
+        groups.set(groupKey, []);
+      }
+      groups.get(groupKey).push(entry);
+    }
+    return groups;
+  }
+  // Helper methods
+  determineExecutionStatus(stackBlocks) {
+    if (stackBlocks.length === 0) {
+      return "idle";
+    }
+    const hasActiveBlock = stackBlocks.some((block) => block.isActive);
+    if (hasActiveBlock) {
+      return "executing";
+    }
+    return "idle";
+  }
+  mapBlockType(block) {
+    const blockType = block.blockType?.toLowerCase();
+    switch (blockType) {
+      case "workout":
+        return "workout";
+      case "group":
+        return "group";
+      case "timer":
+        return "timer";
+      case "rounds":
+        return "rounds";
+      case "effort":
+        return "effort";
+      case "exercise":
+        return "exercise";
+      default:
+        return "custom";
+    }
+  }
+  determineBlockStatus(isActive) {
+    if (isActive) {
+      return "active";
+    }
+    return "pending";
+  }
+  findParentKey(blocks, currentIndex) {
+    if (currentIndex === 0) return void 0;
+    return blocks[currentIndex - 1].key.toString();
+  }
+  findChildrenKeys(_blocks, _parentKey) {
+    return [];
+  }
+  generateBlockLabel(blockType) {
+    return `${blockType.charAt(0).toUpperCase() + blockType.slice(1)} Block`;
+  }
+  getBlockColor(blockType) {
+    const colors = {
+      workout: "#3B82F6",
+      // blue
+      group: "#10B981",
+      // green
+      timer: "#F59E0B",
+      // yellow
+      rounds: "#8B5CF6",
+      // purple
+      effort: "#EF4444",
+      // red
+      exercise: "#06B6D4",
+      // cyan
+      custom: "#6B7280"
+      // gray
+    };
+    return colors[blockType];
+  }
+  getBlockIcon(blockType) {
+    const icons = {
+      workout: "\u{1F3CB}\uFE0F",
+      timer: "\u23F1\uFE0F",
+      rounds: "\u{1F504}",
+      exercise: "\u{1F4AA}"
+    };
+    return icons[blockType];
+  }
+  mapMemoryType(type) {
+    if (!type) return "unknown";
+    const lowerType = type.toLowerCase();
+    if (lowerType.includes("metric")) return "metric";
+    if (lowerType.includes("timer")) return "timer-state";
+    if (lowerType.includes("loop")) return "loop-state";
+    if (lowerType.includes("group")) return "group-state";
+    if (lowerType.includes("handler")) return "handler";
+    if (lowerType.includes("span")) return "span";
+    return "unknown";
+  }
+  generateOwnerLabel(ownerId) {
+    return ownerId;
+  }
+  formatValue(value) {
+    if (value === void 0 || value === null) {
+      return "undefined";
+    }
+    if (typeof value === "string") {
+      return `"${value}"`;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return value.toString();
+    }
+    if (Array.isArray(value)) {
+      return `Array(${value.length})`;
+    }
+    if (typeof value === "object") {
+      return `{${Object.keys(value).length} properties}`;
+    }
+    return typeof value;
+  }
+  generateMemoryLabel(ref, memoryType) {
+    return `${memoryType}: ${ref.id}`;
+  }
+  generateGroupLabel(memoryType) {
+    return memoryType;
+  }
+  getMemoryIcon(memoryType) {
+    const icons = {
+      metric: "\u{1F4CA}",
+      "timer-state": "\u23F1\uFE0F",
+      "loop-state": "\u{1F504}",
+      "group-state": "\u{1F4C1}",
+      handler: "\u2699\uFE0F",
+      span: "\u{1F4CF}",
+      unknown: "\u2753"
+    };
+    return icons[memoryType];
+  }
+};
+
+// src/runtime/subscriptions/LocalRuntimeSubscription.ts
+var LocalRuntimeSubscription = class {
+  id;
+  onStackSnapshotCallback;
+  onOutputCallback;
+  constructor(options) {
+    this.id = options?.id ?? "local";
+    this.onStackSnapshotCallback = options?.onStackSnapshot;
+    this.onOutputCallback = options?.onOutput;
+  }
+  onStackSnapshot(snapshot) {
+    this.onStackSnapshotCallback?.(snapshot);
+  }
+  onOutput(output) {
+    this.onOutputCallback?.(output);
+  }
+  dispose() {
+    this.onStackSnapshotCallback = void 0;
+    this.onOutputCallback = void 0;
+  }
+};
+
+// src/runtime/subscriptions/LocalEventProvider.ts
+var LocalEventProvider = class _LocalEventProvider {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  runtime;
+  static subscriptionCounter = 0;
+  unsubscribes = [];
+  disposed = false;
+  dispatch(event) {
+    if (this.disposed) return;
+    this.runtime.handle(event);
+  }
+  onEvent(handler) {
+    if (this.disposed) return () => {
+    };
+    const ownerId = `local-event-provider-${_LocalEventProvider.subscriptionCounter++}`;
+    const unsubscribeFromBus = this.runtime.eventBus.on("*", (event) => {
+      handler(event);
+    }, ownerId);
+    const unsubscribe = () => {
+      unsubscribeFromBus();
+      this.unsubscribes = this.unsubscribes.filter((candidate) => candidate !== unsubscribe);
+    };
+    this.unsubscribes.push(unsubscribe);
+    return unsubscribe;
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    const unsubscribes = [...this.unsubscribes];
+    this.unsubscribes = [];
+    for (const unsubscribe of unsubscribes) {
+      unsubscribe();
+    }
+  }
+};
+
+// src/runtime/subscriptions/SubscriptionManager.ts
+var SubscriptionManager = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.stackUnsub = this.runtime.subscribeToStack((snapshot) => {
+      for (const sub of this.subscriptions.values()) {
+        try {
+          sub.onStackSnapshot(snapshot);
+        } catch (err) {
+          console.error(`[SubscriptionManager] Error in subscription '${sub.id}' onStackSnapshot:`, err);
+        }
+      }
+    });
+    this.outputUnsub = this.runtime.subscribeToOutput((output) => {
+      for (const sub of this.subscriptions.values()) {
+        try {
+          sub.onOutput(output);
+        } catch (err) {
+          console.error(`[SubscriptionManager] Error in subscription '${sub.id}' onOutput:`, err);
+        }
+      }
+    });
+  }
+  runtime;
+  subscriptions = /* @__PURE__ */ new Map();
+  stackUnsub = null;
+  outputUnsub = null;
+  disposed = false;
+  /**
+   * Register a subscription. If a subscription with the same ID already exists,
+   * the old one is disposed and replaced.
+   * 
+   * New subscriptions immediately receive the current stack state and any
+   * existing output statements to catch them up.
+   */
+  add(subscription) {
+    if (this.disposed) {
+      console.warn("[SubscriptionManager] Cannot add subscription after dispose");
+      return;
+    }
+    const existing = this.subscriptions.get(subscription.id);
+    if (existing) {
+      existing.dispose();
+    }
+    this.subscriptions.set(subscription.id, subscription);
+    try {
+      subscription.onStackSnapshot({
+        type: "initial",
+        blocks: [...this.runtime.stack.blocks],
+        depth: this.runtime.stack.count,
+        clockTime: this.runtime.clock.currentDate
+      });
+      const currentOutputs = this.runtime.getOutputStatements();
+      for (const output of currentOutputs) {
+        subscription.onOutput(output);
+      }
+    } catch (err) {
+      console.error(`[SubscriptionManager] Error catching up subscription '${subscription.id}':`, err);
+    }
+  }
+  /**
+   * Remove and dispose a subscription by ID.
+   * Returns true if the subscription was found and removed.
+   */
+  remove(id) {
+    const sub = this.subscriptions.get(id);
+    if (!sub) return false;
+    sub.dispose();
+    this.subscriptions.delete(id);
+    return true;
+  }
+  /**
+   * Check if a subscription with the given ID is registered.
+   */
+  has(id) {
+    return this.subscriptions.has(id);
+  }
+  /**
+   * Get the number of active subscriptions.
+   */
+  get count() {
+    return this.subscriptions.size;
+  }
+  /**
+   * Dispose all subscriptions and unsubscribe from the runtime.
+   */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.stackUnsub?.();
+    this.stackUnsub = null;
+    this.outputUnsub?.();
+    this.outputUnsub = null;
+    for (const sub of this.subscriptions.values()) {
+      try {
+        sub.dispose();
+      } catch (err) {
+        console.error(`[SubscriptionManager] Error disposing subscription '${sub.id}':`, err);
+      }
+    }
+    this.subscriptions.clear();
+  }
+};
 function formatMetricLabel(key) {
   return key.charAt(0).toUpperCase() + key.slice(1).replace(/_/g, " ");
 }
@@ -12688,15 +13201,15 @@ function toStoredOutputStatement(output) {
 }
 
 // src/version.ts
-var VERSION = "0.1.5";
-var GIT_SHA = "8c595e1";
-var BUILD_TIME = "2026-08-18T18:07:40.647Z";
+var VERSION = "0.1.8";
+var GIT_SHA = "52af1e3";
+var BUILD_TIME = "2026-08-18T18:19:06.086Z";
 var SEMVER = {
-  version: "0.1.5",
-  gitSha: "8c595e1",
-  buildTime: "2026-08-18T18:07:40.647Z"
+  version: "0.1.8",
+  gitSha: "52af1e3",
+  buildTime: "2026-08-18T18:19:06.086Z"
 };
 
-export { AbortSessionAction, AnalyticsEngine, AnalyticsTransformer, BUILD_TIME, BUILTIN_CALCS, BUNDLED_EFFORT_COUNT, BehaviorContext, BlockContext, CONSUMED_HINTS, CONSUMED_HINT_KEYS, CalcEngine, CalculateBlockProcessor, CalculationRegistry, CardioDialect, ClearChildrenAction, ClimbDialect, ClimbMetricType, CompileAndPushBlockAction, CrossFitDialect, DAY, DEFAULT_RESOLVER_OPTIONS, DEFAULT_UNRESOLVED_EFFORT_MET, DIM_LENGTH, DIM_MASS, DIM_TIME, DIM_ZERO, DISCIPLINE_FACTORS, DialectStack, EFFORT_DATA_METRIC_TYPE, EFFORT_DISCIPLINES, EFFORT_REGISTRY_ORIGINS, EffortBlock, EffortResolver, EmitEventAction, EmitSystemOutputAction, ErrorAction, EventBus, ExecutionContext, GIT_SHA, HabitsDialect, INTENSITY_TIERS, InMemoryEffortRegistry, JitCompiler, LookupRegistry, MdTimerRuntime, MemoryLocation, MemoryTypeEnum, NextAction, NextEvent, NextEventHandler, OutputEmitter, PREDEFINED_SOUNDS, PRODUCTION_STRATEGIES, PlaySoundAction, PopBlockAction, PushBlockAction, PushRestBlockAction, RegisterEventHandlerAction, Registry, RestBlock, RuntimeBlock, RuntimeBuilder, RuntimeClock, RuntimeFactory, RuntimeLogger, RuntimeMemory, RuntimeObservers, RuntimeStack, SEMVER, STANDARD_UNITS, STORE_CALCS, ScriptRuntime, SessionRootBlock, SnapshotClock, StandardAnalyticsProfile, StartSessionAction, StartWorkoutAction, ThrowError, ThrowErrorAction, TimeSpan, TwoPassEffortResolutionProcess, TypedMemoryReference, UnitRegistry, UnitSet, UnitsDialect, UnregisterEventHandlerAction, UpdateNextPreviewAction, VERSION, VISIBILITY_ICONS, VISIBILITY_LABELS, WaitingToStartBlock, WhiteboardScript, WodDialect, YogaDialect, buildTooltip, bundledEfforts, calc_exports as calc, calculateElapsed, classifyStatements, closeCurrentSpan, commonFixtureSet, computeColumnLabel, computeLabel, computeWorkloadRollups, createAnalyticsEngineForBlock, createCalcEngine, createCompiler, createDialectStack, createLineLocator, createPolicy as createMetricPresentationPolicy, createMockClock, createParser, dailySessionLoads, dayBucket, dialectRegistry, dialectStack, disciplineFactorFor, evaluate, evaluateCalculateDefinitions, extractEffortData, extractMetrics, extractStatements, extractStatementsRaw, extractSyntaxFacts, filterTagsByVisibility, findBestFuzzyMatch, fixtureBackSquat, fixtureBurpee, fixturePlank, fixtureRowing, fixtureRunning, fixtureUserCustom, fixtureUserOverride, formatDuration, metricsToLabel as fragmentsToLabel, fullFixtureSet, fuseUnits, fuseUnitsInMetrics, getAnalyticsFromLogs, getAnalyticsFromRuntime, getHints, getMetricVisibility, hasHint, hintMetric, hintsToContainer, isEffortDiscipline, isFragmentTag, isTimeLikeMetric, isWithinThreshold, levenshteinDistance, metricPresentation, mutateTimerSpans, normalizeForFuzzy, openSpan, parseCalcLine, parseCalculateBlock, parseExpression, parseScript, readTimer, realtimeProcessorRegistry, resolveDominantOrigin, sharedParser, startSpan, strategyRegistry, summaryProcessorRegistry, toStoredOutputStatement, parser as whiteboardParser, whiteboardScript, whiteboardScriptLanguage };
+export { AbortSessionAction, AnalyticsEngine, AnalyticsTransformer, BUILD_TIME, BUILTIN_CALCS, BUNDLED_EFFORT_COUNT, BehaviorContext, BlockContext, CONSUMED_HINTS, CONSUMED_HINT_KEYS, CalcEngine, CalculateBlockProcessor, CalculationRegistry, CardioDialect, ClearChildrenAction, ClimbDialect, ClimbMetricType, CompileAndPushBlockAction, CrossFitDialect, DAY, DEFAULT_RESOLVER_OPTIONS, DEFAULT_UNRESOLVED_EFFORT_MET, DIM_LENGTH, DIM_MASS, DIM_TIME, DIM_ZERO, DISCIPLINE_FACTORS, DialectStack, EFFORT_DATA_METRIC_TYPE, EFFORT_DISCIPLINES, EFFORT_REGISTRY_ORIGINS, EffortBlock, EffortResolver, EmitEventAction, EmitSystemOutputAction, ErrorAction, EventBus, ExecutionContext, GIT_SHA, HabitsDialect, INTENSITY_TIERS, InMemoryEffortRegistry, JitCompiler, LocalEventProvider, LocalRuntimeSubscription, LookupRegistry, MdTimerRuntime, MemoryLocation, MemoryTypeEnum, NextAction, NextEvent, NextEventHandler, OutputEmitter, PREDEFINED_SOUNDS, PRODUCTION_STRATEGIES, PlaySoundAction, PopBlockAction, PushBlockAction, PushRestBlockAction, RegisterEventHandlerAction, Registry, RestBlock, RuntimeAdapter, RuntimeBlock, RuntimeBuilder, RuntimeClock, RuntimeFactory, RuntimeLogger, RuntimeMemory, RuntimeObservers, RuntimeStack, SEMVER, STANDARD_UNITS, STORE_CALCS, ScriptRuntime, SessionRootBlock, SnapshotClock, StandardAnalyticsProfile, StartSessionAction, StartWorkoutAction, SubscriptionManager, ThrowError, ThrowErrorAction, TimeSpan, TwoPassEffortResolutionProcess, TypedMemoryReference, UnitRegistry, UnitSet, UnitsDialect, UnregisterEventHandlerAction, UpdateNextPreviewAction, VERSION, VISIBILITY_ICONS, VISIBILITY_LABELS, WaitingToStartBlock, WhiteboardScript, WodDialect, YogaDialect, buildTooltip, bundledEfforts, calc_exports as calc, calculateElapsed, classifyStatements, closeCurrentSpan, commonFixtureSet, computeColumnLabel, computeLabel, computeWorkloadRollups, createAnalyticsEngineForBlock, createCalcEngine, createCompiler, createDialectStack, createLineLocator, createPolicy as createMetricPresentationPolicy, createMockClock, createParser, dailySessionLoads, dayBucket, dialectRegistry, dialectStack, disciplineFactorFor, evaluate, evaluateCalculateDefinitions, extractEffortData, extractMetrics, extractStatements, extractStatementsRaw, extractSyntaxFacts, filterTagsByVisibility, findBestFuzzyMatch, fixtureBackSquat, fixtureBurpee, fixturePlank, fixtureRowing, fixtureRunning, fixtureUserCustom, fixtureUserOverride, formatDuration, metricsToLabel as fragmentsToLabel, fullFixtureSet, fuseUnits, fuseUnitsInMetrics, getAnalyticsFromLogs, getAnalyticsFromRuntime, getHints, getMetricVisibility, hasHint, hintMetric, hintsToContainer, isCastSubscription, isEffortDiscipline, isFragmentTag, isTimeLikeMetric, isWithinThreshold, levenshteinDistance, metricPresentation, mutateTimerSpans, normalizeForFuzzy, openSpan, parseCalcLine, parseCalculateBlock, parseExpression, parseScript, readTimer, realtimeProcessorRegistry, resolveDominantOrigin, sharedParser, startSpan, strategyRegistry, summaryProcessorRegistry, toStoredOutputStatement, parser as whiteboardParser, whiteboardScript, whiteboardScriptLanguage };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map