@bitcobblers/wod-wiki-lang 0.1.3 → 0.1.6

package/dist/index.cjs

@@ -11598,6 +11598,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) => 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];
+  }
+};
 function formatMetricLabel(key) {
   return key.charAt(0).toUpperCase() + key.slice(1).replace(/_/g, " ");
 }
@@ -12766,13 +13110,13 @@ function toStoredOutputStatement(output) {
 }
 
 // src/version.ts
-var VERSION = "0.1.3";
-var GIT_SHA = "0aa2522";
-var BUILD_TIME = "2026-08-18T18:01:16.459Z";
+var VERSION = "0.1.6";
+var GIT_SHA = "9c5467d";
+var BUILD_TIME = "2026-08-18T18:12:54.408Z";
 var SEMVER = {
-  version: "0.1.3",
-  gitSha: "0aa2522",
-  buildTime: "2026-08-18T18:01:16.459Z"
+  version: "0.1.6",
+  gitSha: "9c5467d",
+  buildTime: "2026-08-18T18:12:54.408Z"
 };
 
 exports.AbortSessionAction = AbortSessionAction;
@@ -12835,6 +13179,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;