@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-5GLCTO44.js

@@ -1,161 +0,0 @@
-// src/compiler/ReproducibilityMode.ts
-var DEFAULT_FIXED_TIMESTAMP = "2026-01-01T00:00:00.000Z";
-var DEFAULT_SEED = 42;
-var DEFAULT_GENERATOR = "holoscript-compiler";
-var COMPILER_VERSION = "6.0.0";
-function createSeededRNG(seed = DEFAULT_SEED) {
-  let state = seed | 0;
-  const initialSeed = state;
-  function next() {
-    state = state + 1831565813 | 0;
-    let t = Math.imul(state ^ state >>> 15, 1 | state);
-    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  }
-  function nextInt(min, max) {
-    return Math.floor(next() * (max - min + 1)) + min;
-  }
-  function nextUUID() {
-    const hex = (n, len) => Array.from({ length: len }, () => nextInt(0, 15).toString(16)).join("");
-    return `${hex(0, 8)}-${hex(0, 4)}-4${hex(0, 3)}-${(8 + nextInt(0, 3)).toString(16)}${hex(0, 3)}-${hex(0, 12)}`;
-  }
-  function reset() {
-    state = initialSeed;
-  }
-  function getState() {
-    return state;
-  }
-  return { next, nextInt, nextUUID, reset, getState };
-}
-function sortKeysDeep(value) {
-  if (value === null || value === void 0) return value;
-  if (Array.isArray(value)) {
-    return value.map((item) => sortKeysDeep(item));
-  }
-  if (typeof value === "object") {
-    const sorted = {};
-    const keys = Object.keys(value).sort();
-    for (const key of keys) {
-      sorted[key] = sortKeysDeep(value[key]);
-    }
-    return sorted;
-  }
-  return value;
-}
-function fnv1a32(input) {
-  let hash = 2166136261;
-  for (let i = 0; i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function hashComposition(composition) {
-  const sorted = sortKeysDeep(composition);
-  const serialized = JSON.stringify(sorted);
-  const h1 = fnv1a32(serialized);
-  const h2 = fnv1a32(serialized + h1);
-  const h3 = fnv1a32(serialized + h2);
-  const h4 = fnv1a32(serialized + h3);
-  const h5 = fnv1a32(serialized + h4);
-  const h6 = fnv1a32(serialized + h5);
-  const h7 = fnv1a32(serialized + h6);
-  const h8 = fnv1a32(serialized + h7);
-  return `${h1}${h2}${h3}${h4}${h5}${h6}${h7}${h8}`;
-}
-function createReproducibilityContext(config) {
-  const fullConfig = {
-    enabled: config.enabled,
-    fixedTimestamp: config.fixedTimestamp ?? DEFAULT_FIXED_TIMESTAMP,
-    randomSeed: config.randomSeed ?? DEFAULT_SEED,
-    sortKeys: config.sortKeys ?? config.enabled,
-    deterministicIds: config.deterministicIds ?? config.enabled,
-    generatorString: config.generatorString ?? DEFAULT_GENERATOR,
-    includeManifest: config.includeManifest ?? false
-  };
-  const rng = createSeededRNG(fullConfig.randomSeed);
-  function random() {
-    return fullConfig.enabled ? rng.next() : Math.random();
-  }
-  function randomInt(min, max) {
-    return fullConfig.enabled ? rng.nextInt(min, max) : Math.floor(Math.random() * (max - min + 1)) + min;
-  }
-  function timestamp() {
-    return fullConfig.enabled ? fullConfig.fixedTimestamp : (/* @__PURE__ */ new Date()).toISOString();
-  }
-  function timestampDate() {
-    return fullConfig.enabled ? new Date(fullConfig.fixedTimestamp) : /* @__PURE__ */ new Date();
-  }
-  function uuid() {
-    if (!fullConfig.enabled || !fullConfig.deterministicIds) {
-      return crypto?.randomUUID?.() ?? rng.nextUUID();
-    }
-    return rng.nextUUID();
-  }
-  function generator() {
-    return fullConfig.generatorString;
-  }
-  function stabilize(value) {
-    if (!fullConfig.enabled || !fullConfig.sortKeys) return value;
-    return sortKeysDeep(value);
-  }
-  function manifest(composition) {
-    return {
-      reproducible: true,
-      seed: fullConfig.randomSeed,
-      timestamp: fullConfig.fixedTimestamp,
-      inputHash: hashComposition(composition),
-      compilerVersion: COMPILER_VERSION
-    };
-  }
-  function reset() {
-    rng.reset();
-  }
-  function stringify(value, indent = 2) {
-    const processed = fullConfig.enabled && fullConfig.sortKeys ? sortKeysDeep(value) : value;
-    return JSON.stringify(processed, null, indent);
-  }
-  return {
-    enabled: fullConfig.enabled,
-    config: fullConfig,
-    random,
-    randomInt,
-    timestamp,
-    timestampDate,
-    uuid,
-    generator,
-    stabilize,
-    manifest,
-    reset,
-    stringify
-  };
-}
-function parseReproducibilityFlags(args) {
-  const config = { enabled: false };
-  for (const arg of args) {
-    if (arg === "--reproducible") {
-      config.enabled = true;
-    }
-    if (arg === "--no-reproducible") {
-      config.enabled = false;
-    }
-    if (arg.startsWith("--reproducible-seed=")) {
-      config.enabled = true;
-      config.randomSeed = parseInt(arg.split("=")[1], 10);
-      if (isNaN(config.randomSeed)) config.randomSeed = DEFAULT_SEED;
-    }
-    if (arg.startsWith("--reproducible-timestamp=")) {
-      config.enabled = true;
-      config.fixedTimestamp = arg.split("=")[1].replace(/"/g, "");
-    }
-    if (arg === "--reproducible-manifest") {
-      config.includeManifest = true;
-    }
-  }
-  return config;
-}
-var ReproducibilityMode_default = createReproducibilityContext;
-
-export { ReproducibilityMode_default, createReproducibilityContext, createSeededRNG, fnv1a32, hashComposition, parseReproducibilityFlags, sortKeysDeep };
-//# sourceMappingURL=chunk-5GLCTO44.js.map
-//# sourceMappingURL=chunk-5GLCTO44.js.map

package/dist/chunk-5TOFIR6L.js

@@ -1,407 +0,0 @@
-// src/interop/InteropBindingGenerator.ts
-var InteropBindingGenerator = class {
-  /**
-   * Extract exports from a HoloScript AST
-   */
-  extractExports(ast) {
-    const exports$1 = [];
-    if (!ast.body) return exports$1;
-    for (const node of ast.body) {
-      const nodeRecord = node;
-      const nodeType = nodeRecord.type;
-      const nodeName = nodeRecord.name;
-      if (nodeType === "FunctionDeclaration" || nodeType === "function") {
-        const params = nodeRecord.params || [];
-        exports$1.push({
-          name: nodeName || "anonymous",
-          type: "function",
-          parameters: params.map((p) => {
-            if (typeof p === "string") {
-              return { name: p, type: "any", optional: false };
-            }
-            return {
-              name: p.name || "",
-              type: p.type || "any",
-              optional: p.optional || false
-            };
-          }),
-          returnType: nodeRecord.returnType || "void"
-        });
-      }
-      if (nodeType === "template" || nodeType === "ClassDeclaration") {
-        exports$1.push({
-          name: nodeName || "UnnamedTemplate",
-          type: "class"
-        });
-      }
-      if (nodeType === "composition") {
-        exports$1.push({
-          name: nodeName || "default",
-          type: "module"
-        });
-      }
-      if (nodeType === "VariableDeclaration" || nodeType === "state") {
-        exports$1.push({
-          name: nodeName || "unnamed",
-          type: "constant",
-          value: nodeRecord.value
-        });
-      }
-    }
-    return exports$1;
-  }
-  /**
-   * Generate Python bindings from HoloScript AST
-   */
-  generatePythonBindings(ast, sourceFile) {
-    const exports$1 = this.extractExports(ast);
-    const lines = [
-      '"""',
-      `Auto-generated Python bindings for ${sourceFile}`,
-      `Generated by HoloScript InteropBindingGenerator`,
-      `Do not edit manually \u2014 regenerate with: holoscript compile ${sourceFile} --target python`,
-      '"""',
-      "",
-      "from typing import Any, Optional, Dict, List",
-      "import json",
-      ""
-    ];
-    for (const exp of exports$1) {
-      switch (exp.type) {
-        case "function": {
-          const params = (exp.parameters || []).map((p) => {
-            const pyType = this.tsPyType(p.type);
-            return p.optional ? `${p.name}: ${pyType} = None` : `${p.name}: ${pyType}`;
-          }).join(", ");
-          const retType = this.tsPyType(exp.returnType || "void");
-          lines.push(`def ${exp.name}(${params}) -> ${retType}:`);
-          lines.push(`    """HoloScript function: ${exp.name}"""`);
-          lines.push(`    raise NotImplementedError("Bridge to HoloScript runtime required")`);
-          lines.push("");
-          break;
-        }
-        case "class": {
-          lines.push(`class ${exp.name}:`);
-          lines.push(`    """HoloScript template: ${exp.name}"""`);
-          lines.push(`    def __init__(self, **kwargs: Any) -> None:`);
-          lines.push(`        self._props = kwargs`);
-          lines.push("");
-          break;
-        }
-        case "constant": {
-          lines.push(`${exp.name} = ${JSON.stringify(exp.value ?? "None")}`);
-          lines.push("");
-          break;
-        }
-        case "module": {
-          lines.push(`class ${exp.name}Module:`);
-          lines.push(`    """HoloScript composition: ${exp.name}"""`);
-          lines.push(`    pass`);
-          lines.push("");
-          break;
-        }
-      }
-    }
-    lines.push(`__all__ = [${exports$1.map((e) => `"${e.name}"`).join(", ")}]`);
-    return {
-      language: "python",
-      code: lines.join("\n"),
-      exports: exports$1.map((e) => e.name),
-      metadata: {
-        sourceFile,
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        holoScriptVersion: "5.0.0"
-      }
-    };
-  }
-  /**
-   * Generate JavaScript (ESM) bindings from HoloScript AST
-   */
-  generateJSBindings(ast, sourceFile) {
-    const exports$1 = this.extractExports(ast);
-    const lines = [
-      `// Auto-generated JS bindings for ${sourceFile}`,
-      `// Generated by HoloScript InteropBindingGenerator`,
-      `// Do not edit manually`,
-      ""
-    ];
-    for (const exp of exports$1) {
-      switch (exp.type) {
-        case "function": {
-          const params = (exp.parameters || []).map((p) => p.name).join(", ");
-          lines.push(`export function ${exp.name}(${params}) {`);
-          lines.push(`  throw new Error("Bridge to HoloScript runtime required");`);
-          lines.push(`}`);
-          lines.push("");
-          break;
-        }
-        case "class": {
-          lines.push(`export class ${exp.name} {`);
-          lines.push(`  constructor(props = {}) { this._props = props; }`);
-          lines.push(`}`);
-          lines.push("");
-          break;
-        }
-        case "constant": {
-          lines.push(`export const ${exp.name} = ${JSON.stringify(exp.value ?? null)};`);
-          lines.push("");
-          break;
-        }
-        case "module": {
-          lines.push(`export const ${exp.name} = { /* HoloScript composition */ };`);
-          lines.push("");
-          break;
-        }
-      }
-    }
-    return {
-      language: "javascript",
-      code: lines.join("\n"),
-      exports: exports$1.map((e) => e.name),
-      metadata: {
-        sourceFile,
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        holoScriptVersion: "5.0.0"
-      }
-    };
-  }
-  /**
-   * Map TypeScript types to Python types
-   */
-  tsPyType(tsType) {
-    const mapping = {
-      string: "str",
-      number: "float",
-      int: "int",
-      boolean: "bool",
-      void: "None",
-      any: "Any",
-      unknown: "Any",
-      "string[]": "List[str]",
-      "number[]": "List[float]"
-    };
-    return mapping[tsType] || "Any";
-  }
-};
-
-// 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");
-}
-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)
-    )
-  ]);
-}
-
-// src/mcp/MCPCircuitBreaker.ts
-var MCPCircuitBreaker = class {
-  constructor(config = {}) {
-    this.breaker = new CircuitBreaker({
-      failureThreshold: config.failureThreshold ?? 5,
-      successThreshold: config.successThreshold ?? 2,
-      resetTimeoutMs: config.resetTimeoutMs ?? 3e4,
-      windowMs: config.windowMs ?? 6e4
-    });
-    this.baseUrl = config.baseUrl ?? "http://localhost:3000";
-  }
-  /**
-   * Call an MCP tool with circuit breaker protection + retry + timeout
-   */
-  async callTool(tool, args, timeoutMs = 15e3) {
-    try {
-      const result = await this.breaker.execute(async () => {
-        return retryWithBackoff(
-          async () => {
-            const response = await withTimeout(
-              fetch(`${this.baseUrl}/api/mcp/tools/${tool}`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ arguments: args })
-              }),
-              timeoutMs
-            );
-            if (!response.ok) {
-              throw new Error(`MCP tool ${tool} failed: ${response.status} ${response.statusText}`);
-            }
-            return response.json();
-          },
-          {
-            maxAttempts: 2,
-            initialBackoffMs: 500,
-            maxBackoffMs: 3e3
-          }
-        );
-      });
-      return {
-        success: true,
-        content: result,
-        circuitState: this.breaker.getState()
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        circuitState: this.breaker.getState()
-      };
-    }
-  }
-  /**
-   * Get current circuit breaker state
-   */
-  getState() {
-    return this.breaker.getState();
-  }
-  /**
-   * Get circuit breaker metrics
-   */
-  getMetrics() {
-    return this.breaker.getMetrics();
-  }
-  /**
-   * Check if MCP server is available (circuit not open)
-   */
-  isAvailable() {
-    return this.breaker.getState() !== "OPEN" /* OPEN */;
-  }
-};
-var defaultInstance = null;
-function getMCPCircuitBreaker(config) {
-  if (!defaultInstance) {
-    defaultInstance = new MCPCircuitBreaker(config);
-  }
-  return defaultInstance;
-}
-
-export { CircuitBreaker, CircuitBreakerState, InteropBindingGenerator, MCPCircuitBreaker, getMCPCircuitBreaker, retryWithBackoff, withTimeout };
-//# sourceMappingURL=chunk-5TOFIR6L.js.map
-//# sourceMappingURL=chunk-5TOFIR6L.js.map