@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-OSYNRVOV.cjs

@@ -0,0 +1,243 @@
+'use strict';
+
+// src/resilience/ResiliencePatterns.ts
+var CircuitBreakerState = /* @__PURE__ */ ((CircuitBreakerState2) => {
+  CircuitBreakerState2["CLOSED"] = "CLOSED";
+  CircuitBreakerState2["OPEN"] = "OPEN";
+  CircuitBreakerState2["HALF_OPEN"] = "HALF_OPEN";
+  return CircuitBreakerState2;
+})(CircuitBreakerState || {});
+var CircuitBreaker = class {
+  constructor(config = {}) {
+    this.state = "CLOSED" /* CLOSED */;
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+    this.failures = [];
+    this.config = {
+      failureThreshold: 5,
+      successThreshold: 2,
+      resetTimeoutMs: 6e4,
+      // 1 minute
+      windowMs: 3e4,
+      // 30 seconds
+      isRetryable: (err) => err instanceof Error,
+      ...config
+    };
+  }
+  /**
+   * Execute function with circuit breaker protection
+   */
+  async execute(fn) {
+    if (this.state === "OPEN" /* OPEN */) {
+      if (Date.now() - (this.lastFailureTime || 0) > this.config.resetTimeoutMs) {
+        this.state = "HALF_OPEN" /* HALF_OPEN */;
+        this.successCount = 0;
+      } else {
+        throw new Error(`Circuit breaker is OPEN. Retry after ${this.config.resetTimeoutMs}ms`);
+      }
+    }
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure(error);
+      throw error;
+    }
+  }
+  onSuccess() {
+    this.failureCount = 0;
+    this.failures = this.failures.filter((f) => Date.now() - f.timestamp < this.config.windowMs);
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.successCount++;
+      if (this.successCount >= this.config.successThreshold) {
+        this.state = "CLOSED" /* CLOSED */;
+      }
+    }
+  }
+  onFailure(error) {
+    this.lastFailureTime = Date.now();
+    this.failureCount++;
+    this.failures.push({ timestamp: Date.now(), error });
+    this.failures = this.failures.filter((f) => Date.now() - f.timestamp < this.config.windowMs);
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.state = "OPEN" /* OPEN */;
+    } else if (this.failureCount >= this.config.failureThreshold) {
+      this.state = "OPEN" /* OPEN */;
+      console.error(`Circuit breaker OPEN after ${this.failureCount} failures: ${error.message}`);
+    }
+  }
+  get currentState() {
+    return this.state;
+  }
+  /**
+   * Get current circuit breaker state (accessor method)
+   */
+  getState() {
+    if (this.state === "OPEN" /* OPEN */ && Date.now() - (this.lastFailureTime || 0) > this.config.resetTimeoutMs) {
+      return "HALF_OPEN" /* HALF_OPEN */;
+    }
+    return this.state;
+  }
+  /**
+   * Get circuit breaker metrics
+   */
+  getMetrics() {
+    return {
+      state: this.state,
+      totalFailures: this.failureCount,
+      totalSuccesses: this.successCount,
+      lastFailureTime: this.lastFailureTime,
+      totalRequests: this.failureCount + this.successCount
+    };
+  }
+};
+async function retryWithBackoff(fn, config = {}) {
+  const cfg = {
+    maxAttempts: 3,
+    initialBackoffMs: 100,
+    maxBackoffMs: 1e4,
+    multiplier: 2,
+    jitter: true,
+    isRetryable: (err, attempt) => attempt < cfg.maxAttempts,
+    ...config
+  };
+  let lastError = null;
+  for (let attempt = 1; attempt <= cfg.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!cfg.isRetryable(lastError, attempt)) {
+        throw lastError;
+      }
+      if (attempt < cfg.maxAttempts) {
+        const backoff = Math.min(
+          cfg.initialBackoffMs * Math.pow(cfg.multiplier, attempt - 1),
+          cfg.maxBackoffMs
+        );
+        const jitteredBackoff = cfg.jitter ? backoff * (0.5 + Math.random() * 0.5) : backoff;
+        console.warn(
+          `Attempt ${attempt} failed: ${lastError.message}. Retrying in ${Math.round(jitteredBackoff)}ms`
+        );
+        await sleep(jitteredBackoff);
+      }
+    }
+  }
+  throw lastError || new Error("Max retry attempts exceeded");
+}
+var Bulkhead = class {
+  constructor(config = {}) {
+    this.running = 0;
+    this.queue = [];
+    this.config = {
+      maxConcurrent: 10,
+      queueSize: 100,
+      timeoutMs: 3e4,
+      ...config
+    };
+  }
+  /**
+   * Execute function within bulkhead
+   */
+  async execute(fn) {
+    if (this.queue.length >= this.config.queueSize) {
+      throw new Error("Bulkhead queue full - too many pending operations");
+    }
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const idx = this.queue.findIndex((item) => item.resolve === resolve);
+        if (idx !== -1) {
+          this.queue.splice(idx, 1);
+        }
+        reject(new Error("Bulkhead operation timeout"));
+      }, this.config.timeoutMs);
+      this.queue.push({
+        fn,
+        // @ts-expect-error
+        resolve,
+        reject,
+        timeoutId
+      });
+      this.processQueue();
+    });
+  }
+  processQueue() {
+    while (this.running < this.config.maxConcurrent && this.queue.length > 0) {
+      const item = this.queue.shift();
+      if (!item) break;
+      this.running++;
+      item.fn().then((result) => {
+        clearTimeout(item.timeoutId);
+        item.resolve(result);
+      }).catch((error) => {
+        clearTimeout(item.timeoutId);
+        item.reject(error);
+      }).finally(() => {
+        this.running--;
+        this.processQueue();
+      });
+    }
+  }
+  get stats() {
+    return {
+      running: this.running,
+      queued: this.queue.length
+    };
+  }
+  /**
+   * Get bulkhead state (accessor method)
+   */
+  getState() {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+      maxConcurrent: this.config.maxConcurrent
+    };
+  }
+  /**
+   * Get bulkhead metrics
+   */
+  getMetrics() {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+      utilizationPercent: this.running / this.config.maxConcurrent * 100,
+      queueUtilizationPercent: this.queue.length / this.config.queueSize * 100
+    };
+  }
+};
+async function fallbackChain(strategies) {
+  let lastError = null;
+  for (let i = 0; i < strategies.length; i++) {
+    try {
+      const result = await strategies[i]();
+      return result;
+    } catch (error) {
+      lastError = error;
+      console.warn(`Strategy ${i + 1} failed: ${lastError.message}`);
+    }
+  }
+  throw lastError || new Error("All fallback strategies failed");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withTimeout(promise, timeoutMs) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`Operation timeout after ${timeoutMs}ms`)), timeoutMs)
+    )
+  ]);
+}
+
+exports.Bulkhead = Bulkhead;
+exports.CircuitBreaker = CircuitBreaker;
+exports.CircuitBreakerState = CircuitBreakerState;
+exports.fallbackChain = fallbackChain;
+exports.retryWithBackoff = retryWithBackoff;
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=chunk-OSYNRVOV.cjs.map
+//# sourceMappingURL=chunk-OSYNRVOV.cjs.map

package/dist/chunk-PGANYCAG.cjs

@@ -0,0 +1,220 @@
+'use strict';
+
+// src/testing/DeterminismHarness.ts
+function getGlobal() {
+  return globalThis ?? {};
+}
+function detectRuntime() {
+  const g = getGlobal();
+  if (typeof g.window !== "undefined" && typeof g.document !== "undefined") {
+    return "browser";
+  }
+  if (typeof g.process !== "undefined" && g.process.versions?.node) {
+    return "node";
+  }
+  return "unknown";
+}
+function detectBrowserFromUserAgent(ua) {
+  if (!ua) return {};
+  let browser;
+  let os;
+  if (/Firefox\//.test(ua)) browser = "firefox";
+  else if (/Edg\//.test(ua)) browser = "edge";
+  else if (/Chrome\//.test(ua)) browser = "chromium";
+  else if (/Safari\//.test(ua)) browser = "safari";
+  if (/Windows NT/.test(ua)) os = "windows";
+  else if (/Mac OS X/.test(ua)) os = "macos";
+  else if (/Linux/.test(ua)) os = "linux";
+  else if (/Android/.test(ua)) os = "android";
+  else if (/iPhone|iPad/.test(ua)) os = "ios";
+  return { browser, os };
+}
+async function captureEnvironment(annotations = {}) {
+  const runtime = detectRuntime();
+  const g = getGlobal();
+  const info = { runtime };
+  if (Object.keys(annotations).length > 0) info.annotations = { ...annotations };
+  if (runtime === "browser") {
+    const nav = g.navigator;
+    const ua = nav?.userAgent;
+    info.browser = { userAgent: ua, ...detectBrowserFromUserAgent(ua) };
+    if (nav?.gpu?.requestAdapter) {
+      try {
+        const adapter = await nav.gpu.requestAdapter();
+        let gpuInfo = adapter?.info;
+        if (!gpuInfo && adapter?.requestAdapterInfo) {
+          gpuInfo = await adapter.requestAdapterInfo();
+        }
+        if (gpuInfo) {
+          info.gpu = {
+            vendor: gpuInfo.vendor,
+            architecture: gpuInfo.architecture,
+            device: gpuInfo.device,
+            description: gpuInfo.description,
+            backend: "webgpu"
+          };
+        }
+      } catch {
+      }
+    }
+  } else if (runtime === "node") {
+    const proc = g.process;
+    if (proc) {
+      info.node = {
+        version: proc.versions?.node ?? "unknown",
+        arch: proc.arch ?? "unknown",
+        platform: proc.platform ?? "unknown"
+      };
+    }
+  }
+  return info;
+}
+function toUint8Array(input) {
+  if (input instanceof Uint8Array) return input;
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(input);
+  }
+  const bytes = new Uint8Array(input.length);
+  for (let i = 0; i < input.length; i++) bytes[i] = input.charCodeAt(i) & 255;
+  return bytes;
+}
+function fnv1a64Hex(bytes) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mask = 0xffffffffffffffffn;
+  for (let i = 0; i < bytes.length; i++) {
+    hash = (hash ^ BigInt(bytes[i])) & mask;
+    hash = hash * prime & mask;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+async function hashBytes(input, algo = "sha256") {
+  const bytes = toUint8Array(input);
+  if (algo === "sha256") {
+    const g = getGlobal();
+    const subtle = g.crypto?.subtle;
+    if (subtle && typeof subtle.digest === "function") {
+      try {
+        const digest = await subtle.digest("SHA-256", bytes);
+        const view = new Uint8Array(digest);
+        let hex = "";
+        for (let i = 0; i < view.length; i++) hex += view[i].toString(16).padStart(2, "0");
+        return `sha256:${hex}`;
+      } catch {
+      }
+    }
+  }
+  return `fnv1a-64:${fnv1a64Hex(bytes)}`;
+}
+var DeterminismHarness = class {
+  constructor(options = {}) {
+    this.options = {
+      captureOutput: options.captureOutput ?? false,
+      hashAlgorithm: options.hashAlgorithm ?? "sha256",
+      annotations: options.annotations ?? {}
+    };
+  }
+  /**
+   * Run a probe function, capture environment, hash the output,
+   * return a structured ProbeResult. Never throws — errors are
+   * caught and reported on the result's `error` field with a
+   * sentinel outputHash of `error:<message>`.
+   */
+  async probe(name, fn, annotations = {}) {
+    const timestamp = Date.now();
+    const mergedAnnotations = { ...this.options.annotations, ...annotations };
+    const environment = await captureEnvironment(mergedAnnotations);
+    const started = typeof performance !== "undefined" ? performance.now() : timestamp;
+    let output;
+    let error;
+    try {
+      output = await fn();
+    } catch (err) {
+      error = err instanceof Error ? err.message : String(err);
+    }
+    const ended = typeof performance !== "undefined" ? performance.now() : Date.now();
+    const durationMs = Math.max(0, ended - started);
+    if (error !== void 0 || output === void 0) {
+      return {
+        name,
+        timestamp,
+        environment,
+        durationMs,
+        outputHash: `error:${error ?? "no-output"}`,
+        outputSize: 0,
+        error
+      };
+    }
+    const outputHash = await hashBytes(output, this.options.hashAlgorithm);
+    const outputSize = output instanceof Uint8Array ? output.byteLength : toUint8Array(output).byteLength;
+    const result = {
+      name,
+      timestamp,
+      environment,
+      durationMs,
+      outputHash,
+      outputSize
+    };
+    if (this.options.captureOutput) result.output = output;
+    return result;
+  }
+  /**
+   * Compare a collection of probe results and report whether they
+   * agree. Groups results by hash so the caller can see which
+   * environments produced which outputs.
+   */
+  static compareResults(results) {
+    if (results.length === 0) {
+      return {
+        probeName: "(empty)",
+        totalResults: 0,
+        uniqueHashes: 0,
+        divergent: false,
+        groups: [],
+        summary: "No results supplied to compare."
+      };
+    }
+    const probeName = results[0].name;
+    const byHash = /* @__PURE__ */ new Map();
+    for (const r of results) {
+      const existing = byHash.get(r.outputHash);
+      if (existing) existing.push(r);
+      else byHash.set(r.outputHash, [r]);
+    }
+    const groups = Array.from(byHash.entries()).map(([hash, rs]) => ({
+      hash,
+      results: rs,
+      environments: rs.map((r) => describeEnvironment(r.environment))
+    }));
+    const divergent = groups.length > 1;
+    const summary = divergent ? `DIVERGENT: ${groups.length} distinct hashes across ${results.length} runs of "${probeName}".` : `CONVERGENT: all ${results.length} runs of "${probeName}" produced hash ${groups[0].hash}.`;
+    return {
+      probeName,
+      totalResults: results.length,
+      uniqueHashes: groups.length,
+      divergent,
+      groups,
+      summary
+    };
+  }
+};
+function describeEnvironment(env) {
+  const parts = [env.runtime];
+  if (env.browser?.browser) parts.push(env.browser.browser);
+  if (env.browser?.os) parts.push(env.browser.os);
+  if (env.node) parts.push(`node ${env.node.version} ${env.node.platform}/${env.node.arch}`);
+  if (env.gpu?.vendor) parts.push(`gpu:${env.gpu.vendor}${env.gpu.architecture ? "/" + env.gpu.architecture : ""}`);
+  if (env.annotations) {
+    for (const [k, v] of Object.entries(env.annotations)) {
+      parts.push(`${k}=${v}`);
+    }
+  }
+  return parts.join(" | ");
+}
+
+exports.DeterminismHarness = DeterminismHarness;
+exports.captureEnvironment = captureEnvironment;
+exports.describeEnvironment = describeEnvironment;
+exports.hashBytes = hashBytes;
+//# sourceMappingURL=chunk-PGANYCAG.cjs.map
+//# sourceMappingURL=chunk-PGANYCAG.cjs.map

package/dist/chunk-PHENW4MQ.js

@@ -0,0 +1,65 @@
+// src/logger.ts
+var NoOpLogger = class {
+  /**
+   * Debug-level logging (no-op implementation).
+   * @param message - Debug message to discard
+   * @param meta - Optional metadata to discard
+   */
+  debug(message, meta) {
+  }
+  /**
+   * Info-level logging (no-op implementation).
+   * @param message - Info message to discard
+   * @param meta - Optional metadata to discard
+   */
+  info(message, meta) {
+  }
+  /**
+   * Warning-level logging (no-op implementation).
+   * @param message - Warning message to discard
+   * @param meta - Optional metadata to discard
+   */
+  warn(message, meta) {
+  }
+  /**
+   * Error-level logging (no-op implementation).
+   * @param message - Error message to discard
+   * @param meta - Optional metadata to discard
+   */
+  error(message, meta) {
+  }
+};
+var ConsoleLogger = class {
+  debug(message, meta) {
+    console.debug(`[HoloScript:DEBUG] ${message}`, meta ?? "");
+  }
+  info(message, meta) {
+    console.info(`[HoloScript:INFO] ${message}`, meta ?? "");
+  }
+  warn(message, meta) {
+    console.warn(`[HoloScript:WARN] ${message}`, meta ?? "");
+  }
+  error(message, meta) {
+    console.error(`[HoloScript:ERROR] ${message}`, meta ?? "");
+  }
+};
+var currentLogger = new NoOpLogger();
+function setHoloScriptLogger(logger2) {
+  currentLogger = logger2;
+}
+function enableConsoleLogging() {
+  currentLogger = new ConsoleLogger();
+}
+function resetLogger() {
+  currentLogger = new NoOpLogger();
+}
+var logger = {
+  debug: (msg, meta) => currentLogger.debug(msg, meta),
+  info: (msg, meta) => currentLogger.info(msg, meta),
+  warn: (msg, meta) => currentLogger.warn(msg, meta),
+  error: (msg, meta) => currentLogger.error(msg, meta)
+};
+
+export { ConsoleLogger, NoOpLogger, enableConsoleLogging, logger, resetLogger, setHoloScriptLogger };
+//# sourceMappingURL=chunk-PHENW4MQ.js.map
+//# sourceMappingURL=chunk-PHENW4MQ.js.map