@bitcobblers/wod-wiki-lang 0.1.5 → 0.1.6

package/dist/index.mjs

@@ -11520,6 +11520,350 @@ 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];
+  }
+};
 function formatMetricLabel(key) {
   return key.charAt(0).toUpperCase() + key.slice(1).replace(/_/g, " ");
 }
@@ -12688,15 +13032,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.6";
+var GIT_SHA = "9c5467d";
+var BUILD_TIME = "2026-08-18T18:12:54.408Z";
 var SEMVER = {
-  version: "0.1.5",
-  gitSha: "8c595e1",
-  buildTime: "2026-08-18T18:07:40.647Z"
+  version: "0.1.6",
+  gitSha: "9c5467d",
+  buildTime: "2026-08-18T18:12:54.408Z"
 };
 
-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, 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, 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 };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map