@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-SLU6UPJI.cjs

@@ -0,0 +1,410 @@
+'use strict';
+
+var chunkE7JP3BS3_cjs = require('./chunk-E7JP3BS3.cjs');
+var path = require('path');
+var fs = require('fs');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+
+// src/interop/Interoperability.ts
+chunkE7JP3BS3_cjs.init_safeJsonParse();
+var ModuleResolver = class {
+  constructor(basePath = process.cwd()) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.resolvedPaths = /* @__PURE__ */ new Map();
+    this.basePath = basePath;
+  }
+  /**
+   * Resolve module path
+   */
+  resolveModule(modulePath, fromPath) {
+    const cacheKey = `${modulePath}:${fromPath || "root"}`;
+    if (this.resolvedPaths.has(cacheKey)) {
+      return this.resolvedPaths.get(cacheKey);
+    }
+    const resolved = this.performResolve(modulePath, fromPath);
+    this.resolvedPaths.set(cacheKey, resolved);
+    return resolved;
+  }
+  /**
+   * Perform actual module resolution
+   */
+  performResolve(modulePath, fromPath) {
+    if (this.isBuiltinModule(modulePath)) {
+      return modulePath;
+    }
+    if (modulePath.startsWith(".")) {
+      const basePath = fromPath ? path__namespace.dirname(fromPath) : this.basePath;
+      const resolved = path__namespace.resolve(basePath, modulePath);
+      return this.findModuleFile(resolved);
+    }
+    if (modulePath.startsWith("@")) {
+      return this.resolveNodeModule(modulePath);
+    }
+    return this.resolveNodeModule(modulePath);
+  }
+  /**
+   * Check if built-in module
+   */
+  isBuiltinModule(modulePath) {
+    const builtins = ["fs", "path", "crypto", "util", "stream", "events"];
+    return builtins.includes(modulePath);
+  }
+  /**
+   * Resolve from node_modules
+   */
+  resolveNodeModule(modulePath) {
+    let current = this.basePath;
+    while (current !== path__namespace.dirname(current)) {
+      const nodeModulesPath = path__namespace.join(current, "node_modules", modulePath);
+      if (fs__namespace.existsSync(nodeModulesPath)) {
+        return nodeModulesPath;
+      }
+      const packageJsonPath = path__namespace.join(nodeModulesPath, "package.json");
+      if (fs__namespace.existsSync(packageJsonPath)) {
+        const packageJson = chunkE7JP3BS3_cjs.readJson(fs__namespace.readFileSync(packageJsonPath, "utf-8"));
+        return this.findModuleFile(path__namespace.join(nodeModulesPath, packageJson.main || "index.js"));
+      }
+      current = path__namespace.dirname(current);
+    }
+    throw new Error(`Module not found: ${modulePath}`);
+  }
+  /**
+   * Find module file with various extensions
+   */
+  findModuleFile(basePath) {
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
+    if (fs__namespace.existsSync(basePath)) {
+      return basePath;
+    }
+    for (const ext of extensions) {
+      const withExt = basePath + ext;
+      if (fs__namespace.existsSync(withExt)) {
+        return withExt;
+      }
+    }
+    const indexPath = path__namespace.join(basePath, "index");
+    for (const ext of extensions) {
+      const withExt = indexPath + ext;
+      if (fs__namespace.existsSync(withExt)) {
+        return withExt;
+      }
+    }
+    throw new Error(`Cannot resolve file: ${basePath}`);
+  }
+  /**
+   * Load module (with caching)
+   */
+  loadModule(modulePath, fromPath) {
+    const resolved = this.resolveModule(modulePath, fromPath);
+    const cacheKey = resolved;
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    const module = {
+      path: resolved,
+      exports: {}
+    };
+    this.cache.set(cacheKey, module);
+    return module;
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.cache.clear();
+    this.resolvedPaths.clear();
+  }
+};
+var ExportImportHandler = class {
+  constructor() {
+    this.exports = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Define named export
+   */
+  defineExport(modulePath, name, value) {
+    if (!this.exports.has(modulePath)) {
+      this.exports.set(modulePath, /* @__PURE__ */ new Map());
+    }
+    this.exports.get(modulePath).set(name, value);
+  }
+  /**
+   * Get named export
+   */
+  getExport(modulePath, name) {
+    const moduleExports = this.exports.get(modulePath);
+    if (!moduleExports) {
+      throw new Error(`Module not found: ${modulePath}`);
+    }
+    if (!moduleExports.has(name)) {
+      throw new Error(`Named export '${name}' not found in ${modulePath}`);
+    }
+    return moduleExports.get(name);
+  }
+  /**
+   * Get all exports from module
+   */
+  getAllExports(modulePath) {
+    const moduleExports = this.exports.get(modulePath);
+    if (!moduleExports) {
+      return {};
+    }
+    const result = {};
+    for (const [name, value] of moduleExports) {
+      result[name] = value;
+    }
+    return result;
+  }
+  /**
+   * Check if export exists
+   */
+  hasExport(modulePath, name) {
+    return this.exports.has(modulePath) && this.exports.get(modulePath).has(name);
+  }
+};
+var AsyncFunctionHandler = class {
+  /**
+   * Wrap async function for HoloScript
+   */
+  wrapAsyncFunction(fn) {
+    return async (...args) => {
+      try {
+        return await fn(...args);
+      } catch (error) {
+        throw this.normalizeError(error);
+      }
+    };
+  }
+  /**
+   * Check if function is async
+   */
+  isAsync(fn) {
+    if (typeof fn !== "function") {
+      return false;
+    }
+    const fnStr = fn.toString().trim();
+    return fnStr.startsWith("async ") || fn.constructor.name === "AsyncFunction";
+  }
+  /**
+   * Convert callback to promise
+   */
+  callbackToPromise(fn) {
+    return new Promise((resolve2, reject) => {
+      fn((err, result) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve2(result);
+        }
+      });
+    });
+  }
+  /**
+   * Normalize error from async function
+   */
+  normalizeError(error) {
+    if (error instanceof Error) {
+      return error;
+    }
+    if (typeof error === "string") {
+      return new Error(error);
+    }
+    return new Error(JSON.stringify(error));
+  }
+};
+var ErrorBoundary = class {
+  constructor(onError) {
+    this.errors = [];
+    this.onError = onError;
+  }
+  /**
+   * Wrap function with error boundary
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  wrap(fn) {
+    return ((...args) => {
+      try {
+        const result = fn(...args);
+        if (result instanceof Promise) {
+          return result.catch((error) => {
+            this.handleError(error);
+            throw error;
+          });
+        }
+        return result;
+      } catch (error) {
+        this.handleError(error);
+        throw error;
+      }
+    });
+  }
+  /**
+   * Wrap async function with error boundary
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  wrapAsync(fn) {
+    return (async (...args) => {
+      try {
+        return await fn(...args);
+      } catch (error) {
+        this.handleError(error);
+        throw error;
+      }
+    });
+  }
+  /**
+   * Execute function in boundary
+   */
+  execute(fn) {
+    try {
+      return fn();
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Execute async function in boundary
+   */
+  async executeAsync(fn) {
+    try {
+      return await fn();
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Handle error
+   */
+  handleError(error) {
+    const normalized = this.normalizeError(error);
+    this.errors.push(normalized);
+    if (this.onError) {
+      this.onError(normalized);
+    }
+  }
+  /**
+   * Get errors
+   */
+  getErrors() {
+    return [...this.errors];
+  }
+  /**
+   * Clear errors
+   */
+  clearErrors() {
+    this.errors = [];
+  }
+  /**
+   * Normalize error
+   */
+  normalizeError(error) {
+    if (error instanceof Error) {
+      return error;
+    }
+    if (typeof error === "string") {
+      return new Error(error);
+    }
+    return new Error(JSON.stringify(error));
+  }
+};
+var TypeScriptTypeLoader = class {
+  /**
+   * Load types from TypeScript declaration file
+   */
+  loadTypes(_filePath) {
+    const types = /* @__PURE__ */ new Map();
+    return types;
+  }
+  /**
+   * Convert TypeScript type to HoloScript type
+   */
+  convertType(tsType) {
+    const mapping = {
+      string: "text",
+      number: "numeric",
+      boolean: "logical",
+      void: "void",
+      any: "dynamic",
+      unknown: "dynamic",
+      null: "null",
+      undefined: "void"
+    };
+    if (typeof tsType === "string") {
+      return mapping[tsType] || tsType;
+    }
+    if (Array.isArray(tsType)) {
+      return {
+        kind: "array",
+        elementType: this.convertType(tsType[0])
+      };
+    }
+    if (typeof tsType === "object") {
+      return {
+        kind: "object",
+        properties: Object.entries(tsType).reduce(
+          (acc, [key, val]) => {
+            acc[key] = this.convertType(val);
+            return acc;
+          },
+          {}
+        )
+      };
+    }
+    return tsType;
+  }
+};
+var InteropContext = class {
+  constructor(basePath) {
+    this.moduleResolver = new ModuleResolver(basePath);
+    this.exportImportHandler = new ExportImportHandler();
+    this.asyncHandler = new AsyncFunctionHandler();
+    this.errorBoundary = new ErrorBoundary();
+    this.typeLoader = new TypeScriptTypeLoader();
+  }
+  getModuleResolver() {
+    return this.moduleResolver;
+  }
+  getExportImportHandler() {
+    return this.exportImportHandler;
+  }
+  getAsyncHandler() {
+    return this.asyncHandler;
+  }
+  getErrorBoundary() {
+    return this.errorBoundary;
+  }
+  getTypeLoader() {
+    return this.typeLoader;
+  }
+};
+
+exports.AsyncFunctionHandler = AsyncFunctionHandler;
+exports.ErrorBoundary = ErrorBoundary;
+exports.ExportImportHandler = ExportImportHandler;
+exports.InteropContext = InteropContext;
+exports.ModuleResolver = ModuleResolver;
+exports.TypeScriptTypeLoader = TypeScriptTypeLoader;
+//# sourceMappingURL=chunk-SLU6UPJI.cjs.map
+//# sourceMappingURL=chunk-SLU6UPJI.cjs.map

package/dist/chunk-SMIWS6DE.cjs

@@ -0,0 +1,212 @@
+'use strict';
+
+// 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();
+
+exports.EventBus = EventBus;
+exports.getSharedEventBus = getSharedEventBus;
+exports.setSharedEventBus = setSharedEventBus;
+exports.telemetry = telemetry;
+//# sourceMappingURL=chunk-SMIWS6DE.cjs.map
+//# sourceMappingURL=chunk-SMIWS6DE.cjs.map