@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-R75BSDH7.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// src/deploy/provenance.ts
+function computeContentHash(source) {
+  const normalized = source.replace(/\r\n/g, "\n");
+  return crypto.createHash("sha256").update(normalized, "utf8").digest("hex");
+}
+function classifyPublishMode(ast) {
+  const imports = ast?.imports ?? ast?.ast?.imports ?? [];
+  const hasImports = Array.isArray(imports) && imports.length > 0;
+  if (!hasImports) return "original";
+  const body = ast?.body ?? ast?.ast?.body ?? [];
+  const hasOwnContent = Array.isArray(body) && body.some(
+    (node) => node.type === "composition" || node.type === "ObjectDeclaration" || node.type === "scene" || node.type === "object" || node.type === "character" || node.type === "environment"
+  );
+  if (hasOwnContent) return "remix";
+  return "curated";
+}
+function extractImports(ast) {
+  const imports = ast?.imports ?? ast?.ast?.imports ?? [];
+  if (!Array.isArray(imports)) return [];
+  return imports.map((imp) => ({
+    // @ts-expect-error
+    path: imp.path ?? imp.source ?? "",
+    // @ts-expect-error
+    hash: imp.hash,
+    // @ts-expect-error
+    author: imp.author
+  })).filter((imp) => imp.path.length > 0);
+}
+function generateProvenance(source, ast, options) {
+  return {
+    author: options.author,
+    created: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    hash: computeContentHash(source),
+    license: options.license,
+    version: 1,
+    publishMode: classifyPublishMode(ast),
+    imports: extractImports(ast)
+  };
+}
+
+exports.classifyPublishMode = classifyPublishMode;
+exports.computeContentHash = computeContentHash;
+exports.extractImports = extractImports;
+exports.generateProvenance = generateProvenance;
+//# sourceMappingURL=chunk-R75BSDH7.cjs.map
+//# sourceMappingURL=chunk-R75BSDH7.cjs.map

package/dist/chunk-RARB3MBR.js

@@ -0,0 +1,207 @@
+// src/events/EventBus.ts
+var EventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+    this.history = [];
+    this.maxHistory = 100;
+    this.nextId = 0;
+    this.paused = false;
+  }
+  /**
+   * Subscribe to an event.
+   */
+  on(event, callback, priority = 0) {
+    const id = this.nextId++;
+    const list = this.listeners.get(event) || [];
+    list.push({ callback, priority, once: false, id });
+    list.sort((a, b) => b.priority - a.priority);
+    this.listeners.set(event, list);
+    return id;
+  }
+  /**
+   * Subscribe to an event once (auto-removes after first fire).
+   */
+  once(event, callback, priority = 0) {
+    const id = this.nextId++;
+    const list = this.listeners.get(event) || [];
+    list.push({ callback, priority, once: true, id });
+    list.sort((a, b) => b.priority - a.priority);
+    this.listeners.set(event, list);
+    return id;
+  }
+  /**
+   * Unsubscribe by listener ID.
+   */
+  off(listenerId) {
+    for (const [event, list] of this.listeners) {
+      const idx = list.findIndex((l) => l.id === listenerId);
+      if (idx !== -1) {
+        list.splice(idx, 1);
+        return;
+      }
+    }
+  }
+  /**
+   * Unsubscribe all listeners for an event.
+   */
+  offAll(event) {
+    this.listeners.delete(event);
+  }
+  /**
+   * Emit an event to all subscribers.
+   */
+  emit(event, data) {
+    if (this.paused) return;
+    this.history.push({ event, data, timestamp: Date.now() });
+    if (this.history.length > this.maxHistory) this.history.shift();
+    const list = this.listeners.get(event);
+    if (list) {
+      const toRemove = [];
+      for (const listener of list) {
+        listener.callback(data);
+        if (listener.once) toRemove.push(listener.id);
+      }
+      for (const id of toRemove) {
+        const idx = list.findIndex((l) => l.id === id);
+        if (idx !== -1) list.splice(idx, 1);
+      }
+    }
+    if (event !== "*") {
+      const wildcardList = this.listeners.get("*");
+      if (wildcardList) {
+        for (const listener of wildcardList) {
+          listener.callback({ event, data });
+        }
+      }
+    }
+  }
+  /**
+   * Get event history.
+   */
+  getHistory() {
+    return [...this.history];
+  }
+  /**
+   * Get listener count for an event.
+   */
+  listenerCount(event) {
+    return this.listeners.get(event)?.length || 0;
+  }
+  /**
+   * Pause/resume event emission.
+   */
+  setPaused(paused) {
+    this.paused = paused;
+  }
+  /**
+   * Clear all listeners and history.
+   */
+  clear() {
+    this.listeners.clear();
+    this.history = [];
+  }
+};
+var sharedBus = null;
+function getSharedEventBus() {
+  if (!sharedBus) sharedBus = new EventBus();
+  return sharedBus;
+}
+function setSharedEventBus(bus) {
+  sharedBus = bus;
+}
+
+// src/monitoring/telemetry.ts
+var TelemetryRegistry = class {
+  constructor() {
+    this.measurements = [];
+    this.maxHistory = 1e4;
+  }
+  /**
+   * Increments a monotonic counter (e.g., total_nodes_executed)
+   */
+  incrementCounter(name, value = 1, labels) {
+    this.measurements.push({
+      name,
+      type: "counter",
+      value,
+      labels,
+      timestamp: Date.now()
+    });
+    if (this.measurements.length > this.maxHistory) this.measurements.shift();
+  }
+  /**
+   * Records an instantaneous value (e.g., active_agents)
+   */
+  setGauge(name, value, labels) {
+    this.measurements.push({
+      name,
+      type: "gauge",
+      value,
+      labels,
+      timestamp: Date.now()
+    });
+    if (this.measurements.length > this.maxHistory) this.measurements.shift();
+  }
+  /**
+   * Wraps an async function and records its execution latency into a histogram.
+   */
+  async measureLatency(name, fn, labels) {
+    const start = performance.now();
+    try {
+      return await fn();
+    } finally {
+      const duration = performance.now() - start;
+      this.measurements.push({
+        name,
+        type: "histogram",
+        value: duration,
+        labels,
+        timestamp: Date.now()
+      });
+      if (this.measurements.length > this.maxHistory) this.measurements.shift();
+      if (duration > 500) {
+        this.measurements.push({
+          name: "slo_violation_count",
+          type: "counter",
+          value: 1,
+          labels: { ...labels, metric_name: name, threshold: "500ms" },
+          timestamp: Date.now()
+        });
+      }
+    }
+  }
+  /**
+   * Snapshots current aggregations for dashboard export.
+   */
+  getSnapshot() {
+    const snapshot = { counters: {}, histograms: {}, gauges: {} };
+    const histAggregations = {};
+    for (const m of this.measurements) {
+      const key = m.labels ? `${m.name}{${JSON.stringify(m.labels)}}` : m.name;
+      if (m.type === "counter") {
+        snapshot.counters[key] = (snapshot.counters[key] || 0) + m.value;
+      } else if (m.type === "gauge") {
+        snapshot.gauges[key] = m.value;
+      } else if (m.type === "histogram") {
+        if (!histAggregations[key]) histAggregations[key] = { count: 0, sum: 0, max: 0 };
+        histAggregations[key].count++;
+        histAggregations[key].sum += m.value;
+        if (m.value > histAggregations[key].max) histAggregations[key].max = m.value;
+      }
+    }
+    for (const [key, agg] of Object.entries(histAggregations)) {
+      snapshot.histograms[key] = {
+        count: agg.count,
+        sum: agg.sum,
+        avg: agg.count > 0 ? agg.sum / agg.count : 0,
+        max: agg.max
+      };
+    }
+    return snapshot;
+  }
+};
+var telemetry = new TelemetryRegistry();
+
+export { EventBus, getSharedEventBus, setSharedEventBus, telemetry };
+//# sourceMappingURL=chunk-RARB3MBR.js.map
+//# sourceMappingURL=chunk-RARB3MBR.js.map