@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-FDSGHPAK.js

@@ -0,0 +1,130 @@
+import { __esm } from './chunk-OL46QLBJ.js';
+
+// src/compiler/AndroidKotlinHelpers.ts
+function toKotlinType(value) {
+  if (value === null) return "Any?";
+  if (typeof value === "boolean") return "Boolean";
+  if (typeof value === "number") return Number.isInteger(value) ? "Int" : "Float";
+  if (typeof value === "string") return "String";
+  if (Array.isArray(value)) {
+    if (value.length === 3 && value.every((v) => typeof v === "number")) return "Vector3";
+    return "List<Any>";
+  }
+  return "Any";
+}
+function toKotlinValue(value, escapeFn) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? `${value}` : `${value}f`;
+  }
+  if (typeof value === "string") return `"${escapeFn(value, "Kotlin")}"`;
+  if (Array.isArray(value)) {
+    if (value.length === 3 && value.every((v) => typeof v === "number")) {
+      return `Vector3(${value[0]}f, ${value[1]}f, ${value[2]}f)`;
+    }
+    return `listOf(${value.map((v) => toKotlinValue(v, escapeFn)).join(", ")})`;
+  }
+  return "null";
+}
+function sanitizeNameCapitalized(name) {
+  const result = name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^[0-9]/, "_$&");
+  return result.charAt(0).toUpperCase() + result.slice(1);
+}
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function toAndroidColor(value) {
+  if (!value) return "android.graphics.Color.BLUE";
+  if (typeof value === "string") {
+    if (value.startsWith("#")) {
+      return `android.graphics.Color.parseColor("${value}")`;
+    }
+    return NAMED_COLORS[value.toLowerCase()] || "android.graphics.Color.BLUE";
+  }
+  if (Array.isArray(value) && value.length >= 3) {
+    const [r, g, b, a = 1] = value;
+    return `android.graphics.Color.argb(${Math.round(a * 255)}, ${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)})`;
+  }
+  return "android.graphics.Color.BLUE";
+}
+function toKotlinColor(hex) {
+  if (typeof hex === "string" && hex.startsWith("#")) {
+    const raw = hex.slice(1);
+    if (raw.length === 6) return `Color(0xFF${raw.toUpperCase()})`;
+    if (raw.length === 8) {
+      const [rr, gg, bb, aa] = [
+        raw.substring(0, 2),
+        raw.substring(2, 4),
+        raw.substring(4, 6),
+        raw.substring(6, 8)
+      ];
+      return `Color(0x${aa.toUpperCase()}${rr.toUpperCase()}${gg.toUpperCase()}${bb.toUpperCase()})`;
+    }
+  }
+  return "Color.White";
+}
+function getSceneformGeometry(meshType) {
+  return SCENEFORM_GEOMETRIES[meshType] || DEFAULT_GEOMETRY;
+}
+function mapShapeToFilament(type) {
+  return FILAMENT_SHAPES[type] ?? `Unknown("${type}")`;
+}
+function findObjProp(obj, key) {
+  return obj.properties?.find((p) => p.key === key)?.value;
+}
+function compositionHasTrait(composition, traitName) {
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (name === traitName) return true;
+    }
+  }
+  return false;
+}
+function compositionUsesArCoreDepthTraits(composition) {
+  const depthTraits = /* @__PURE__ */ new Set(["occlusion_mesh", "environment_probe", "spatial_awareness"]);
+  return composition.objects?.some((o) => o.traits?.some((t) => depthTraits.has(t.name))) ?? false;
+}
+function toKotlinFloat3(arr) {
+  if (Array.isArray(arr) && arr.length >= 3) return `Float3(${arr[0]}f, ${arr[1]}f, ${arr[2]}f)`;
+  if (Array.isArray(arr) && arr.length >= 1) return `Float3(${arr[0]}f, ${arr[0]}f, ${arr[0]}f)`;
+  const v = typeof arr === "number" ? arr : 0;
+  return `Float3(${v}f, ${v}f, ${v}f)`;
+}
+var NAMED_COLORS, SCENEFORM_GEOMETRIES, DEFAULT_GEOMETRY, FILAMENT_SHAPES;
+var init_AndroidKotlinHelpers = __esm({
+  "src/compiler/AndroidKotlinHelpers.ts"() {
+    NAMED_COLORS = {
+      red: "android.graphics.Color.RED",
+      green: "android.graphics.Color.GREEN",
+      blue: "android.graphics.Color.BLUE",
+      white: "android.graphics.Color.WHITE",
+      black: "android.graphics.Color.BLACK",
+      yellow: "android.graphics.Color.YELLOW",
+      cyan: "android.graphics.Color.CYAN",
+      magenta: "android.graphics.Color.MAGENTA"
+    };
+    SCENEFORM_GEOMETRIES = {
+      cube: "ShapeFactory.makeCube(Vector3(0.1f, 0.1f, 0.1f), Vector3.zero(), material)",
+      box: "ShapeFactory.makeCube(Vector3(0.1f, 0.1f, 0.1f), Vector3.zero(), material)",
+      sphere: "ShapeFactory.makeSphere(0.05f, Vector3.zero(), material)",
+      cylinder: "ShapeFactory.makeCylinder(0.05f, 0.1f, Vector3.zero(), material)"
+    };
+    DEFAULT_GEOMETRY = "ShapeFactory.makeCube(Vector3(0.1f, 0.1f, 0.1f), Vector3.zero(), material)";
+    FILAMENT_SHAPES = {
+      cube: "BoxShape",
+      box: "BoxShape",
+      sphere: "IcoSphereShape",
+      cylinder: "CylinderShape",
+      cone: "ConeShape",
+      plane: "QuadShape",
+      torus: "CustomRingGeometry",
+      capsule: "CapsuleShape"
+    };
+  }
+});
+
+export { compositionHasTrait, compositionUsesArCoreDepthTraits, findObjProp, getSceneformGeometry, init_AndroidKotlinHelpers, mapShapeToFilament, sanitizeName, sanitizeNameCapitalized, toAndroidColor, toKotlinColor, toKotlinFloat3, toKotlinType, toKotlinValue };
+//# sourceMappingURL=chunk-FDSGHPAK.js.map
+//# sourceMappingURL=chunk-FDSGHPAK.js.map

package/dist/chunk-FEWUHQNM.cjs

@@ -0,0 +1,144 @@
+'use strict';
+
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// src/compiler/AndroidKotlinHelpers.ts
+function toKotlinType(value) {
+  if (value === null) return "Any?";
+  if (typeof value === "boolean") return "Boolean";
+  if (typeof value === "number") return Number.isInteger(value) ? "Int" : "Float";
+  if (typeof value === "string") return "String";
+  if (Array.isArray(value)) {
+    if (value.length === 3 && value.every((v) => typeof v === "number")) return "Vector3";
+    return "List<Any>";
+  }
+  return "Any";
+}
+function toKotlinValue(value, escapeFn) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? `${value}` : `${value}f`;
+  }
+  if (typeof value === "string") return `"${escapeFn(value, "Kotlin")}"`;
+  if (Array.isArray(value)) {
+    if (value.length === 3 && value.every((v) => typeof v === "number")) {
+      return `Vector3(${value[0]}f, ${value[1]}f, ${value[2]}f)`;
+    }
+    return `listOf(${value.map((v) => toKotlinValue(v, escapeFn)).join(", ")})`;
+  }
+  return "null";
+}
+function sanitizeNameCapitalized(name) {
+  const result = name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^[0-9]/, "_$&");
+  return result.charAt(0).toUpperCase() + result.slice(1);
+}
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function toAndroidColor(value) {
+  if (!value) return "android.graphics.Color.BLUE";
+  if (typeof value === "string") {
+    if (value.startsWith("#")) {
+      return `android.graphics.Color.parseColor("${value}")`;
+    }
+    return NAMED_COLORS[value.toLowerCase()] || "android.graphics.Color.BLUE";
+  }
+  if (Array.isArray(value) && value.length >= 3) {
+    const [r, g, b, a = 1] = value;
+    return `android.graphics.Color.argb(${Math.round(a * 255)}, ${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)})`;
+  }
+  return "android.graphics.Color.BLUE";
+}
+function toKotlinColor(hex) {
+  if (typeof hex === "string" && hex.startsWith("#")) {
+    const raw = hex.slice(1);
+    if (raw.length === 6) return `Color(0xFF${raw.toUpperCase()})`;
+    if (raw.length === 8) {
+      const [rr, gg, bb, aa] = [
+        raw.substring(0, 2),
+        raw.substring(2, 4),
+        raw.substring(4, 6),
+        raw.substring(6, 8)
+      ];
+      return `Color(0x${aa.toUpperCase()}${rr.toUpperCase()}${gg.toUpperCase()}${bb.toUpperCase()})`;
+    }
+  }
+  return "Color.White";
+}
+function getSceneformGeometry(meshType) {
+  return SCENEFORM_GEOMETRIES[meshType] || DEFAULT_GEOMETRY;
+}
+function mapShapeToFilament(type) {
+  return FILAMENT_SHAPES[type] ?? `Unknown("${type}")`;
+}
+function findObjProp(obj, key) {
+  return obj.properties?.find((p) => p.key === key)?.value;
+}
+function compositionHasTrait(composition, traitName) {
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (name === traitName) return true;
+    }
+  }
+  return false;
+}
+function compositionUsesArCoreDepthTraits(composition) {
+  const depthTraits = /* @__PURE__ */ new Set(["occlusion_mesh", "environment_probe", "spatial_awareness"]);
+  return composition.objects?.some((o) => o.traits?.some((t) => depthTraits.has(t.name))) ?? false;
+}
+function toKotlinFloat3(arr) {
+  if (Array.isArray(arr) && arr.length >= 3) return `Float3(${arr[0]}f, ${arr[1]}f, ${arr[2]}f)`;
+  if (Array.isArray(arr) && arr.length >= 1) return `Float3(${arr[0]}f, ${arr[0]}f, ${arr[0]}f)`;
+  const v = typeof arr === "number" ? arr : 0;
+  return `Float3(${v}f, ${v}f, ${v}f)`;
+}
+var NAMED_COLORS, SCENEFORM_GEOMETRIES, DEFAULT_GEOMETRY, FILAMENT_SHAPES;
+var init_AndroidKotlinHelpers = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/AndroidKotlinHelpers.ts"() {
+    NAMED_COLORS = {
+      red: "android.graphics.Color.RED",
+      green: "android.graphics.Color.GREEN",
+      blue: "android.graphics.Color.BLUE",
+      white: "android.graphics.Color.WHITE",
+      black: "android.graphics.Color.BLACK",
+      yellow: "android.graphics.Color.YELLOW",
+      cyan: "android.graphics.Color.CYAN",
+      magenta: "android.graphics.Color.MAGENTA"
+    };
+    SCENEFORM_GEOMETRIES = {
+      cube: "ShapeFactory.makeCube(Vector3(0.1f, 0.1f, 0.1f), Vector3.zero(), material)",
+      box: "ShapeFactory.makeCube(Vector3(0.1f, 0.1f, 0.1f), Vector3.zero(), material)",
+      sphere: "ShapeFactory.makeSphere(0.05f, Vector3.zero(), material)",
+      cylinder: "ShapeFactory.makeCylinder(0.05f, 0.1f, Vector3.zero(), material)"
+    };
+    DEFAULT_GEOMETRY = "ShapeFactory.makeCube(Vector3(0.1f, 0.1f, 0.1f), Vector3.zero(), material)";
+    FILAMENT_SHAPES = {
+      cube: "BoxShape",
+      box: "BoxShape",
+      sphere: "IcoSphereShape",
+      cylinder: "CylinderShape",
+      cone: "ConeShape",
+      plane: "QuadShape",
+      torus: "CustomRingGeometry",
+      capsule: "CapsuleShape"
+    };
+  }
+});
+
+exports.compositionHasTrait = compositionHasTrait;
+exports.compositionUsesArCoreDepthTraits = compositionUsesArCoreDepthTraits;
+exports.findObjProp = findObjProp;
+exports.getSceneformGeometry = getSceneformGeometry;
+exports.init_AndroidKotlinHelpers = init_AndroidKotlinHelpers;
+exports.mapShapeToFilament = mapShapeToFilament;
+exports.sanitizeName = sanitizeName;
+exports.sanitizeNameCapitalized = sanitizeNameCapitalized;
+exports.toAndroidColor = toAndroidColor;
+exports.toKotlinColor = toKotlinColor;
+exports.toKotlinFloat3 = toKotlinFloat3;
+exports.toKotlinType = toKotlinType;
+exports.toKotlinValue = toKotlinValue;
+//# sourceMappingURL=chunk-FEWUHQNM.cjs.map
+//# sourceMappingURL=chunk-FEWUHQNM.cjs.map

package/dist/chunk-FFAOS5HQ.js

@@ -0,0 +1,70 @@
+import { init_VRRCompiler, VRRCompiler } from './chunk-4SDKXQ4C.js';
+import { init_ARCompiler, ARCompiler } from './chunk-UJXISJBN.js';
+import { init_BabylonCompiler, BabylonCompiler } from './chunk-J7XZV333.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+
+// src/compiler/MultiLayerCompiler.ts
+init_VRRCompiler();
+init_ARCompiler();
+init_BabylonCompiler();
+init_CompilerBase();
+var MultiLayerCompiler = class extends CompilerBase {
+  constructor(options) {
+    super();
+    this.compilerName = "MultiLayerCompiler";
+    this.options = options;
+  }
+  getRequiredCapability() {
+    return ANSCapabilityPath.MULTI_LAYER;
+  }
+  compile(composition, agentToken, outputPath) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    const result = {
+      success: true,
+      warnings: [],
+      errors: []
+    };
+    if (this.options.targets.includes("ar")) {
+      const arCompiler = new ARCompiler({
+        target: "webxr",
+        minify: this.options.minify,
+        source_maps: this.options.source_maps,
+        features: { hit_test: true, image_tracking: true }
+      });
+      const arResult = arCompiler.compile(composition, agentToken);
+      result.ar = arResult;
+      if (!arResult.success) result.success = false;
+    }
+    if (this.options.targets.includes("vrr")) {
+      const vrrCompiler = new VRRCompiler({
+        target: "threejs",
+        minify: this.options.minify,
+        source_maps: this.options.source_maps,
+        performance: { target_fps: 60, max_players: 1e3, lazy_loading: true },
+        api_integrations: {}
+        // Configured upstream based on @reality_mirror traits
+      });
+      const vrrResult = vrrCompiler.compile(composition, agentToken);
+      result.vrr = vrrResult;
+      if (!vrrResult.success) result.success = false;
+    }
+    if (this.options.targets.includes("vr")) {
+      const vrCompiler = new BabylonCompiler({});
+      try {
+        const vrResult = vrCompiler.compile(composition, agentToken);
+        result.vr = vrResult;
+      } catch (err) {
+        result.success = false;
+        result.errors.push(
+          `VR Compilation Error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return result;
+  }
+};
+
+export { MultiLayerCompiler };
+//# sourceMappingURL=chunk-FFAOS5HQ.js.map
+//# sourceMappingURL=chunk-FFAOS5HQ.js.map

package/dist/chunk-FGGJQRLZ.js

@@ -0,0 +1,270 @@
+import { CircuitBreaker, retryWithBackoff, withTimeout } from './chunk-A6KINLZJ.js';
+
+// 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/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 { InteropBindingGenerator, MCPCircuitBreaker, getMCPCircuitBreaker };
+//# sourceMappingURL=chunk-FGGJQRLZ.js.map
+//# sourceMappingURL=chunk-FGGJQRLZ.js.map