@bitcobblers/wod-wiki-lang 0.1.5 → 0.1.8

package/dist/index.cjs

@@ -5620,6 +5620,11 @@ function createBrowserRuntimeNow() {
     nowMs: () => getRuntimeNowMs()
   };
 }
+
+// src/runtime/contracts/ICastSubscription.ts
+function isCastSubscription(s) {
+  return "sendAnalyticsSummary" in s && typeof s.sendAnalyticsSummary === "function";
+}
 var CompletionTimestampBehavior = class {
   completionTime;
   wasComplete = false;
@@ -11598,6 +11603,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) => wodWikiCore.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, " ");
 }
@@ -12766,13 +13279,13 @@ 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"
 };
 
 exports.AbortSessionAction = AbortSessionAction;
@@ -12818,6 +13331,8 @@ exports.HabitsDialect = HabitsDialect;
 exports.INTENSITY_TIERS = INTENSITY_TIERS;
 exports.InMemoryEffortRegistry = InMemoryEffortRegistry;
 exports.JitCompiler = JitCompiler;
+exports.LocalEventProvider = LocalEventProvider;
+exports.LocalRuntimeSubscription = LocalRuntimeSubscription;
 exports.LookupRegistry = LookupRegistry;
 exports.MdTimerRuntime = MdTimerRuntime;
 exports.MemoryLocation = MemoryLocation;
@@ -12835,6 +13350,7 @@ exports.PushRestBlockAction = PushRestBlockAction;
 exports.RegisterEventHandlerAction = RegisterEventHandlerAction;
 exports.Registry = Registry;
 exports.RestBlock = RestBlock;
+exports.RuntimeAdapter = RuntimeAdapter;
 exports.RuntimeBlock = RuntimeBlock;
 exports.RuntimeBuilder = RuntimeBuilder;
 exports.RuntimeClock = RuntimeClock;
@@ -12852,6 +13368,7 @@ exports.SnapshotClock = SnapshotClock;
 exports.StandardAnalyticsProfile = StandardAnalyticsProfile;
 exports.StartSessionAction = StartSessionAction;
 exports.StartWorkoutAction = StartWorkoutAction;
+exports.SubscriptionManager = SubscriptionManager;
 exports.ThrowError = ThrowError;
 exports.ThrowErrorAction = ThrowErrorAction;
 exports.TimeSpan = TimeSpan;
@@ -12923,6 +13440,7 @@ exports.getRuntimeNowMs = getRuntimeNowMs;
 exports.hasHint = hasHint;
 exports.hintMetric = hintMetric;
 exports.hintsToContainer = hintsToContainer;
+exports.isCastSubscription = isCastSubscription;
 exports.isEffortDiscipline = isEffortDiscipline;
 exports.isFragmentTag = isFragmentTag;
 exports.isTimeLikeMetric = isTimeLikeMetric;