@holoscript/core 6.0.4 → 6.1.2

package/dist/chunk-EOFNVCM6.js

@@ -0,0 +1,325 @@
+import { init_CompilerBase, CompilerBase } from './chunk-QTPMJRGS.js';
+
+// src/compiler/QuantumCircuitCompiler.ts
+init_CompilerBase();
+function qubitsForMolecule(atoms) {
+  const orbitalCount = atoms.reduce((sum, a) => {
+    if (a.symbol === "H") return sum + 1;
+    if (["C", "N", "O", "F"].includes(a.symbol)) return sum + 5;
+    return sum + 9;
+  }, 0);
+  return orbitalCount * 2;
+}
+function extractNumber(config, key) {
+  const entry = config[key];
+  if (!entry) return void 0;
+  const v = entry.value;
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const n = parseFloat(v);
+    return isNaN(n) ? void 0 : n;
+  }
+  return void 0;
+}
+function extractAtoms(config) {
+  const entry = config["molecule"] ?? config["atoms"];
+  if (!entry) return void 0;
+  let raw = entry.value;
+  if (typeof raw === "string") {
+    try {
+      raw = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  if (!Array.isArray(raw)) return void 0;
+  return raw.filter(
+    (a) => typeof a === "object" && a !== null && typeof a["symbol"] === "string"
+  );
+}
+function extractWeightMatrix(config) {
+  const entry = config["weightMatrix"] ?? config["weight_matrix"] ?? config["adjacency"];
+  if (!entry) return void 0;
+  let raw = entry.value;
+  if (typeof raw === "string") {
+    try {
+      raw = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  if (!Array.isArray(raw)) return void 0;
+  if (!raw.every((row) => Array.isArray(row))) return void 0;
+  return raw;
+}
+function generateVQECircuit(atoms, moleculeName, ansatzLayers, initialParams) {
+  const warnings = [];
+  let numQubits = qubitsForMolecule(atoms);
+  if (numQubits > 50) {
+    warnings.push(
+      `Molecule requires ${numQubits} qubits which exceeds the 50-qubit cap. Clamping to 50. Use classical QM for larger systems.`
+    );
+    numQubits = 50;
+  }
+  if (numQubits > 20) {
+    warnings.push(
+      `Circuit uses ${numQubits} qubits \u2014 near-term hardware is limited to ~20 qubits without error correction. Consider a smaller basis set.`
+    );
+  }
+  const n = numQubits;
+  const totalParams = ansatzLayers * n;
+  const paramNames = [];
+  for (let i = 0; i < totalParams; i++) {
+    paramNames.push(`theta_${i}`);
+  }
+  const lines = [];
+  lines.push("OPENQASM 3.0;");
+  lines.push('include "stdgates.inc";');
+  lines.push(`// Hardware-efficient ansatz for ${moleculeName} (${n} qubits, sto-3g)`);
+  lines.push("// Generated by HoloScript QuantumCircuitCompiler");
+  lines.push(`qubit[${n}] q;`);
+  lines.push(`bit[${n}] c;`);
+  lines.push(`// Parameters: bindable by optimizer (initial values are defaults)`);
+  for (let i = 0; i < totalParams; i++) {
+    const defaultVal = initialParams?.[i] ?? 0.1;
+    lines.push(`input float theta_${i}; // default=${defaultVal}`);
+  }
+  let paramIdx = 0;
+  for (let layer = 0; layer < ansatzLayers; layer++) {
+    lines.push(`// Layer ${layer}: Ry rotations (\u03B8[${paramIdx}..${paramIdx + n - 1}] optimised by VQE)`);
+    for (let i = 0; i < n; i++) {
+      lines.push(`ry(theta_${paramIdx}) q[${i}];`);
+      paramIdx++;
+    }
+    if (layer < ansatzLayers - 1 || n > 1) {
+      lines.push(`// Entanglement: linear CNOT chain`);
+      for (let i = 0; i < n - 1; i++) {
+        lines.push(`cx q[${i}], q[${i + 1}];`);
+      }
+    }
+  }
+  lines.push("// Measurement");
+  lines.push("c = measure q;");
+  const estimatedDepth = ansatzLayers * 2 + 1;
+  return { qasm: lines.join("\n"), numQubits: n, estimatedDepth, warnings, paramNames };
+}
+function generateQAOACircuit(weightMatrix, p, initialGamma, initialBeta) {
+  const warnings = [];
+  let n = weightMatrix.length;
+  if (n > 100) {
+    warnings.push(
+      `Graph has ${n} nodes which exceeds the 100-qubit cap. Clamping to 100. Use classical solvers for larger instances.`
+    );
+    n = 100;
+    weightMatrix = weightMatrix.slice(0, 100).map((row) => row.slice(0, 100));
+  }
+  if (n > 50) {
+    warnings.push(
+      `Circuit uses ${n} qubits \u2014 near-term hardware handles ~50 qubits without error correction.`
+    );
+  }
+  const defaultGamma = initialGamma ?? 0.5;
+  const defaultBeta = initialBeta ?? 0.5;
+  const paramNames = [];
+  for (let round = 0; round < p; round++) {
+    paramNames.push(`gamma_${round}`);
+    paramNames.push(`beta_${round}`);
+  }
+  const lines = [];
+  lines.push("OPENQASM 3.0;");
+  lines.push('include "stdgates.inc";');
+  lines.push(`// QAOA Max-Cut circuit for ${n}-node graph (p=${p})`);
+  lines.push("// Generated by HoloScript QuantumCircuitCompiler");
+  lines.push(`qubit[${n}] q;`);
+  lines.push(`bit[${n}] c;`);
+  lines.push("// Parameters: bindable by optimizer (initial values are defaults)");
+  for (let round = 0; round < p; round++) {
+    lines.push(`input float gamma_${round}; // default=${defaultGamma}`);
+    lines.push(`input float beta_${round}; // default=${defaultBeta}`);
+  }
+  lines.push("// Initial superposition");
+  for (let i = 0; i < n; i++) {
+    lines.push(`h q[${i}];`);
+  }
+  for (let round = 0; round < p; round++) {
+    lines.push(`// Problem unitary \u2014 round ${round + 1} (gamma=gamma_${round})`);
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        const w = weightMatrix[i]?.[j] ?? 0;
+        if (w !== 0) {
+          lines.push(`// Edge (${i},${j}) weight=${w}: rzz(2.0*gamma_${round}*${w.toFixed(4)})`);
+          lines.push(`cx q[${i}], q[${j}];`);
+          lines.push(`rz(2.0 * gamma_${round} * ${w.toFixed(4)}) q[${j}];`);
+          lines.push(`cx q[${i}], q[${j}];`);
+        }
+      }
+    }
+    lines.push(`// Mixer unitary \u2014 round ${round + 1} (beta=beta_${round})`);
+    for (let i = 0; i < n; i++) {
+      lines.push(`rx(2.0 * beta_${round}) q[${i}];`);
+    }
+  }
+  lines.push("// Measurement");
+  lines.push("c = measure q;");
+  const edgeCount = weightMatrix.flat().filter((w) => w !== 0).length / 2;
+  const estimatedDepth = 1 + p * (Math.ceil(edgeCount * 3) + 1) + 1;
+  return { qasm: lines.join("\n"), numQubits: n, estimatedDepth, warnings, paramNames };
+}
+function generateStubCircuit() {
+  const qasm = [
+    "OPENQASM 3.0;",
+    'include "stdgates.inc";',
+    "// Stub circuit: no @quantumCircuit trait found in composition",
+    "// Generated by HoloScript QuantumCircuitCompiler",
+    "qubit[1] q;",
+    "bit[1] c;",
+    "h q[0];",
+    "c = measure q;"
+  ].join("\n");
+  return {
+    qasm,
+    warnings: [
+      "No @quantumCircuit (or @quantum_circuit) trait found in the composition. A stub 1-qubit circuit has been emitted. Add a @quantumCircuit trait with `molecule` or `weightMatrix` params to generate a real circuit."
+    ]
+  };
+}
+var QuantumCircuitCompiler = class extends CompilerBase {
+  constructor() {
+    super(...arguments);
+    this.compilerName = "QuantumCircuitCompiler";
+  }
+  /**
+   * Compile a HoloScript composition to an OpenQASM 3.0 circuit.
+   *
+   * The method scans `composition.objects` for the first object that carries a
+   * `@quantumCircuit` or `@quantum_circuit` trait. Trait params drive the type:
+   *   - `molecule` (or `atoms`) → VQE hardware-efficient ansatz
+   *   - `weightMatrix` / `weight_matrix` / `adjacency` / `numNodes` → QAOA Max-Cut
+   *   - none of the above → stub 1-qubit circuit with a warning
+   *
+   * @param composition - Parsed HoloScript AST
+   * @param agentToken  - JWT RBAC token or UCAN CapabilityTokenCredential (optional)
+   * @param outputPath  - Optional path for output-scope RBAC check
+   * @param _sceneGraph - Unused (reserved for future scene-graph hints)
+   * @returns {@link QASMOutput}
+   */
+  compile(composition, agentToken, outputPath, _sceneGraph) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    const quantum = this.findQuantumTrait(composition.objects ?? []);
+    if (!quantum) {
+      const { qasm: qasm2, warnings: warnings2 } = generateStubCircuit();
+      return {
+        qasm: qasm2,
+        numQubits: 1,
+        numClbits: 1,
+        estimatedDepth: 2,
+        circuitType: "custom",
+        recommendedBackend: "aer",
+        warnings: warnings2
+      };
+    }
+    const { trait } = quantum;
+    const cfg = trait.config;
+    const atoms = extractAtoms(cfg);
+    const weightMatrix = extractWeightMatrix(cfg);
+    const numNodes = extractNumber(cfg, "numNodes") ?? extractNumber(cfg, "num_nodes");
+    if (atoms && atoms.length > 0) {
+      return this.buildVQEOutput(atoms, cfg);
+    }
+    if (weightMatrix) {
+      return this.buildQAOAOutput(weightMatrix, cfg);
+    }
+    if (numNodes !== void 0 && numNodes > 0) {
+      const n = Math.min(Math.round(numNodes), 100);
+      const matrix = Array.from(
+        { length: n },
+        (_, i) => Array.from({ length: n }, (_2, j) => i !== j ? 1 : 0)
+      );
+      return this.buildQAOAOutput(matrix, cfg);
+    }
+    const { qasm, warnings } = generateStubCircuit();
+    warnings.unshift(
+      "@quantumCircuit trait found but neither `molecule`/`atoms` nor `weightMatrix`/`numNodes` params are present. Add params to generate a circuit."
+    );
+    return {
+      qasm,
+      numQubits: 1,
+      numClbits: 1,
+      estimatedDepth: 2,
+      circuitType: "custom",
+      recommendedBackend: "aer",
+      warnings
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Walk `objects` (and their children) recursively, returning the first object
+   * that has a `@quantumCircuit` or `@quantum_circuit` trait, plus the trait.
+   */
+  findQuantumTrait(objects) {
+    for (const obj of objects) {
+      for (const trait of obj.traits ?? []) {
+        if (trait.name === "quantumCircuit" || trait.name === "quantum_circuit") {
+          return { obj, trait };
+        }
+      }
+      if (obj.children && obj.children.length > 0) {
+        const found = this.findQuantumTrait(obj.children);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  }
+  /** Build a {@link QASMOutput} for a VQE circuit. */
+  buildVQEOutput(atoms, cfg) {
+    const moleculeName = (extractNumber(cfg, "moleculeName") !== void 0 ? void 0 : cfg["moleculeName"]?.value) ?? atoms.map((a) => a.symbol).join("") ?? "molecule";
+    const ansatzLayers = Math.max(1, Math.round(extractNumber(cfg, "ansatzLayers") ?? extractNumber(cfg, "ansatz_layers") ?? 2));
+    const initialParams = cfg["initialParams"]?.value ?? cfg["initial_params"]?.value ?? void 0;
+    const { qasm, numQubits, estimatedDepth, warnings, paramNames } = generateVQECircuit(
+      atoms,
+      moleculeName,
+      ansatzLayers,
+      initialParams
+    );
+    return {
+      qasm,
+      numQubits,
+      numClbits: numQubits,
+      estimatedDepth,
+      circuitType: "vqe",
+      molecule: { atoms },
+      recommendedBackend: numQubits <= 20 ? "aer" : "ibm-quantum",
+      warnings,
+      paramNames
+    };
+  }
+  /** Build a {@link QASMOutput} for a QAOA circuit. */
+  buildQAOAOutput(weightMatrix, cfg) {
+    const p = Math.max(1, Math.round(extractNumber(cfg, "p") ?? 1));
+    const initialGamma = extractNumber(cfg, "gamma") ?? extractNumber(cfg, "initial_gamma");
+    const initialBeta = extractNumber(cfg, "beta") ?? extractNumber(cfg, "initial_beta");
+    const { qasm, numQubits, estimatedDepth, warnings, paramNames } = generateQAOACircuit(
+      weightMatrix,
+      p,
+      initialGamma,
+      initialBeta
+    );
+    return {
+      qasm,
+      numQubits,
+      numClbits: numQubits,
+      estimatedDepth,
+      circuitType: "qaoa",
+      weightMatrix,
+      recommendedBackend: numQubits <= 50 ? "aer" : "ibm-quantum",
+      warnings,
+      paramNames
+    };
+  }
+};
+
+export { QuantumCircuitCompiler };
+//# sourceMappingURL=chunk-EOFNVCM6.js.map
+//# sourceMappingURL=chunk-EOFNVCM6.js.map

package/dist/{chunk-FHQVYCH2.js → chunk-ER4GATIU.js}

@@ -1,8 +1,8 @@
-import { init_ARCompiler, ARCompiler } from './chunk-MEASWI2Y.js';
-import { init_BabylonCompiler, BabylonCompiler } from './chunk-KED34ILP.js';
-import { init_VRRCompiler, VRRCompiler } from './chunk-R7MA7QWV.js';
-import { init_CompilerBase, CompilerBase } from './chunk-6XSERL6L.js';
-import { ANSCapabilityPath } from '@holoscript/platform';
+import { init_VRRCompiler, VRRCompiler } from './chunk-R3IVNY6P.js';
+import { init_ARCompiler, ARCompiler } from './chunk-OPZ7XDDI.js';
+import { init_BabylonCompiler, BabylonCompiler } from './chunk-6ASWLXXN.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QTPMJRGS.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
 
 // src/compiler/MultiLayerCompiler.ts
 init_VRRCompiler();
@@ -66,5 +66,5 @@ var MultiLayerCompiler = class extends CompilerBase {
 };
 
 export { MultiLayerCompiler };
-//# sourceMappingURL=chunk-FHQVYCH2.js.map
-//# sourceMappingURL=chunk-FHQVYCH2.js.map
+//# sourceMappingURL=chunk-ER4GATIU.js.map
+//# sourceMappingURL=chunk-ER4GATIU.js.map

package/dist/{chunk-N5FTS757.cjs → chunk-EXKSFGSX.cjs}

@@ -1,5 +1,7 @@
 'use strict';
 
+var chunkOSYNRVOV_cjs = require('./chunk-OSYNRVOV.cjs');
+
 // src/interop/InteropBindingGenerator.ts
 var InteropBindingGenerator = class {
   /**
@@ -186,149 +188,10 @@ var InteropBindingGenerator = class {
   }
 };
 
-// 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({
+    this.breaker = new chunkOSYNRVOV_cjs.CircuitBreaker({
       failureThreshold: config.failureThreshold ?? 5,
       successThreshold: config.successThreshold ?? 2,
       resetTimeoutMs: config.resetTimeoutMs ?? 3e4,
@@ -342,9 +205,9 @@ var MCPCircuitBreaker = class {
   async callTool(tool, args, timeoutMs = 15e3) {
     try {
       const result = await this.breaker.execute(async () => {
-        return retryWithBackoff(
+        return chunkOSYNRVOV_cjs.retryWithBackoff(
           async () => {
-            const response = await withTimeout(
+            const response = await chunkOSYNRVOV_cjs.withTimeout(
               fetch(`${this.baseUrl}/api/mcp/tools/${tool}`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -404,12 +267,8 @@ function getMCPCircuitBreaker(config) {
   return defaultInstance;
 }
 
-exports.CircuitBreaker = CircuitBreaker;
-exports.CircuitBreakerState = CircuitBreakerState;
 exports.InteropBindingGenerator = InteropBindingGenerator;
 exports.MCPCircuitBreaker = MCPCircuitBreaker;
 exports.getMCPCircuitBreaker = getMCPCircuitBreaker;
-exports.retryWithBackoff = retryWithBackoff;
-exports.withTimeout = withTimeout;
-//# sourceMappingURL=chunk-N5FTS757.cjs.map
-//# sourceMappingURL=chunk-N5FTS757.cjs.map
+//# sourceMappingURL=chunk-EXKSFGSX.cjs.map
+//# sourceMappingURL=chunk-EXKSFGSX.cjs.map

package/dist/{chunk-LK5IAVH6.cjs → chunk-EXUP2BUM.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunk3FYZOR7S_cjs = require('./chunk-3FYZOR7S.cjs');
+var chunkZDSYWBIE_cjs = require('./chunk-ZDSYWBIE.cjs');
 
 // src/compiler/ProceduralGeometry.ts
 var LOD_PRESETS = {
@@ -313,36 +313,36 @@ function generateSplineGeometry(points, radii, radialSegments = 32, lengthSteps
     const v = ring / (totalRings - 1);
     let tangent;
     if (ring === 0) {
-      tangent = chunk3FYZOR7S_cjs.vec3SubArray(pathPoints[1], pathPoints[0]);
+      tangent = chunkZDSYWBIE_cjs.vec3SubArray(pathPoints[1], pathPoints[0]);
     } else if (ring === totalRings - 1) {
-      tangent = chunk3FYZOR7S_cjs.vec3SubArray(pathPoints[totalRings - 1], pathPoints[totalRings - 2]);
+      tangent = chunkZDSYWBIE_cjs.vec3SubArray(pathPoints[totalRings - 1], pathPoints[totalRings - 2]);
     } else {
-      tangent = chunk3FYZOR7S_cjs.vec3SubArray(pathPoints[ring + 1], pathPoints[ring - 1]);
+      tangent = chunkZDSYWBIE_cjs.vec3SubArray(pathPoints[ring + 1], pathPoints[ring - 1]);
     }
-    chunk3FYZOR7S_cjs.vec3NormalizeInPlace(tangent);
+    chunkZDSYWBIE_cjs.vec3NormalizeInPlace(tangent);
     let normal;
     let binormal;
     if (ring === 0) {
       if (Math.abs(tangent[0]) < 0.9) {
-        normal = chunk3FYZOR7S_cjs.vec3CrossArray(tangent, [1, 0, 0]);
+        normal = chunkZDSYWBIE_cjs.vec3CrossArray(tangent, [1, 0, 0]);
       } else {
-        normal = chunk3FYZOR7S_cjs.vec3CrossArray(tangent, [0, 1, 0]);
+        normal = chunkZDSYWBIE_cjs.vec3CrossArray(tangent, [0, 1, 0]);
       }
-      chunk3FYZOR7S_cjs.vec3NormalizeInPlace(normal);
-      binormal = chunk3FYZOR7S_cjs.vec3CrossArray(tangent, normal);
-      chunk3FYZOR7S_cjs.vec3NormalizeInPlace(binormal);
+      chunkZDSYWBIE_cjs.vec3NormalizeInPlace(normal);
+      binormal = chunkZDSYWBIE_cjs.vec3CrossArray(tangent, normal);
+      chunkZDSYWBIE_cjs.vec3NormalizeInPlace(binormal);
     } else {
-      normal = chunk3FYZOR7S_cjs.vec3SubArray(
+      normal = chunkZDSYWBIE_cjs.vec3SubArray(
         prevNormal,
-        chunk3FYZOR7S_cjs.vec3ScaleArray(
+        chunkZDSYWBIE_cjs.vec3ScaleArray(
           tangent,
           prevNormal[0] * tangent[0] + prevNormal[1] * tangent[1] + prevNormal[2] * tangent[2]
         )
       );
-      const nLen = chunk3FYZOR7S_cjs.vec3NormalizeInPlace(normal);
+      const nLen = chunkZDSYWBIE_cjs.vec3NormalizeInPlace(normal);
       if (nLen < 1e-6) normal = [...prevNormal];
-      binormal = chunk3FYZOR7S_cjs.vec3CrossArray(tangent, normal);
-      chunk3FYZOR7S_cjs.vec3NormalizeInPlace(binormal);
+      binormal = chunkZDSYWBIE_cjs.vec3CrossArray(tangent, normal);
+      chunkZDSYWBIE_cjs.vec3NormalizeInPlace(binormal);
     }
     prevNormal = normal;
     for (let i = 0; i <= radialSegments; i++) {
@@ -369,8 +369,8 @@ function generateSplineGeometry(points, radii, radialSegments = 32, lengthSteps
   }
   const startCenter = positions.length / 3;
   const sp = pathPoints[0];
-  const startTangent = chunk3FYZOR7S_cjs.vec3SubArray(pathPoints[1], pathPoints[0]);
-  chunk3FYZOR7S_cjs.vec3NormalizeInPlace(startTangent);
+  const startTangent = chunkZDSYWBIE_cjs.vec3SubArray(pathPoints[1], pathPoints[0]);
+  chunkZDSYWBIE_cjs.vec3NormalizeInPlace(startTangent);
   positions.push(sp[0], sp[1], sp[2]);
   normals.push(-startTangent[0], -startTangent[1], -startTangent[2]);
   uvs.push(0.5, 0);
@@ -379,8 +379,8 @@ function generateSplineGeometry(points, radii, radialSegments = 32, lengthSteps
   }
   const endCenter = positions.length / 3;
   const ep = pathPoints[totalRings - 1];
-  const endTangent = chunk3FYZOR7S_cjs.vec3SubArray(pathPoints[totalRings - 1], pathPoints[totalRings - 2]);
-  chunk3FYZOR7S_cjs.vec3NormalizeInPlace(endTangent);
+  const endTangent = chunkZDSYWBIE_cjs.vec3SubArray(pathPoints[totalRings - 1], pathPoints[totalRings - 2]);
+  chunkZDSYWBIE_cjs.vec3NormalizeInPlace(endTangent);
   positions.push(ep[0], ep[1], ep[2]);
   normals.push(endTangent[0], endTangent[1], endTangent[2]);
   uvs.push(0.5, 1);
@@ -981,7 +981,7 @@ function generateHullGeometry(blobs, resolution = 24, threshold = 1, lod) {
     const gradEps = Math.min(dx, dy, dz) * 0.5;
     const grad = evalGradient(x, y, z, gradEps);
     const n = [-grad[0], -grad[1], -grad[2]];
-    chunk3FYZOR7S_cjs.vec3NormalizeInPlace(n);
+    chunkZDSYWBIE_cjs.vec3NormalizeInPlace(n);
     const vertIdx = positions.length / 3;
     positions.push(x, y, z);
     normals.push(n[0], n[1], n[2]);
@@ -1094,14 +1094,14 @@ function generateMembraneGeometry(anchors, subdivisions = 8, bulge = 0.15, lod)
   for (let i = 0; i < anchors.length; i++) {
     const a = anchors[i];
     const b = anchors[(i + 1) % anchors.length];
-    const ca = chunk3FYZOR7S_cjs.vec3SubArray(a, center);
-    const cb = chunk3FYZOR7S_cjs.vec3SubArray(b, center);
-    const cross = chunk3FYZOR7S_cjs.vec3CrossArray(ca, cb);
+    const ca = chunkZDSYWBIE_cjs.vec3SubArray(a, center);
+    const cb = chunkZDSYWBIE_cjs.vec3SubArray(b, center);
+    const cross = chunkZDSYWBIE_cjs.vec3CrossArray(ca, cb);
     memNormal[0] += cross[0];
     memNormal[1] += cross[1];
     memNormal[2] += cross[2];
   }
-  chunk3FYZOR7S_cjs.vec3NormalizeInPlace(memNormal);
+  chunkZDSYWBIE_cjs.vec3NormalizeInPlace(memNormal);
   const numAnchors = anchors.length;
   const centerIdx = 0;
   positions.push(
@@ -1133,7 +1133,7 @@ function generateMembraneGeometry(anchors, subdivisions = 8, bulge = 0.15, lod)
         memNormal[1] + dy * bulge * 0.5,
         memNormal[2] + dz * bulge * 0.5
       ];
-      chunk3FYZOR7S_cjs.vec3NormalizeInPlace(n);
+      chunkZDSYWBIE_cjs.vec3NormalizeInPlace(n);
       normals.push(n[0], n[1], n[2]);
       const angle = seg / numAnchors * Math.PI * 2;
       uvs.push(0.5 + t * 0.5 * Math.cos(angle), 0.5 + t * 0.5 * Math.sin(angle));
@@ -1169,5 +1169,5 @@ function generateMembraneGeometry(anchors, subdivisions = 8, bulge = 0.15, lod)
 exports.generateHullGeometry = generateHullGeometry;
 exports.generateMembraneGeometry = generateMembraneGeometry;
 exports.generateSplineGeometry = generateSplineGeometry;
-//# sourceMappingURL=chunk-LK5IAVH6.cjs.map
-//# sourceMappingURL=chunk-LK5IAVH6.cjs.map
+//# sourceMappingURL=chunk-EXUP2BUM.cjs.map
+//# sourceMappingURL=chunk-EXUP2BUM.cjs.map