@holoscript/core 8.0.7 → 8.0.9

package/dist/{src-J6CM4AUR.js → src-UXYA7HM6.js}

@@ -1,4 +1,4 @@
-import { __esm, __export, __toCommonJS } from './chunk-OL46QLBJ.js';
+import { __esm, __export, __toCommonJS } from './chunk-W4GABFCR.js';
 
 // ../plugins/qm-bridge/src/QmSolver.ts
 function requireCapability(backend, capability) {
@@ -77,6 +77,19 @@ var init_QmSolver = __esm({
         qmMm: false,
         // Stage 3
         maxAtoms: 200
+      },
+      quantinuum: {
+        molecular: true,
+        // logical-qubit VQE for small molecules
+        periodic: false,
+        semiEmpirical: false,
+        nmrGiao: false,
+        tdDft: false,
+        postHf: false,
+        transitionStates: false,
+        qmMm: false,
+        maxAtoms: 8
+        // logical qubits are scarce; small molecules on encoded qubits
       }
     };
   }
@@ -460,6 +473,336 @@ var init_ibm_quantum = __esm({
   }
 });
 
+// ../plugins/qm-bridge/src/backends/quantinuum.ts
+var quantinuum_exports = {};
+__export(quantinuum_exports, {
+  QuantinuumBackend: () => QuantinuumBackend
+});
+var QuantinuumBackend;
+var init_quantinuum = __esm({
+  "../plugins/qm-bridge/src/backends/quantinuum.ts"() {
+    init_QmSolver();
+    QuantinuumBackend = class {
+      constructor(config) {
+        this.mode = "steady-state";
+        this.fieldNames = ["total_energy"];
+        this.scale = "quantum";
+        this.backend = "quantinuum";
+        this.lastEnergy = null;
+        this.lastResult = null;
+        this.config = config;
+        this.qmConfig = config;
+      }
+      // ── SimSolver lifecycle ──────────────────────────────────────────────────
+      step(_dt) {
+      }
+      solve() {
+      }
+      getField(name) {
+        if (name === "total_energy") {
+          if (this.lastEnergy === null) {
+            throw new Error(
+              "[quantinuum] No energy computed yet. Call computeEnergy or runLogicalVQE first."
+            );
+          }
+          return new Float64Array([this.lastEnergy]);
+        }
+        throw new Error(`[quantinuum] Unknown field '${name}'. Available fields: total_energy`);
+      }
+      getStats() {
+        return {
+          backend: this.backend,
+          executionMode: this.config.executionMode ?? "sim",
+          codeFamily: this.config.codeFamily ?? "steane",
+          codeDistance: this.config.codeDistance ?? 3,
+          lastEnergy: this.lastEnergy,
+          lastConverged: this.lastResult?.converged ?? null,
+          lastLogicalErrorRate: this.lastResult?.logicalErrorRate ?? null,
+          lastAcceptanceFraction: this.lastResult?.postSelection.acceptanceFraction ?? null
+        };
+      }
+      dispose() {
+        this.lastEnergy = null;
+        this.lastResult = null;
+      }
+      reset() {
+        this.dispose();
+      }
+      // ── Implemented capabilities ────────────────────────────────────────────
+      /**
+       * Compute ground-state energy via logical-qubit VQE.
+       *
+       * Drop-in compatible with the QmEnergyResult shape so a logical run can stand
+       * in for Psi4 in energy-only workflows. Nuclear repulsion is estimated
+       * classically from the geometry (same approach as the IBM backend).
+       */
+      async computeEnergy(molecule) {
+        requireCapability("quantinuum", "molecular");
+        const vqe = await this.runLogicalVQE(molecule);
+        const nucRepulsion = this._estimateNuclearRepulsion(molecule);
+        const result = {
+          totalEnergy: vqe.groundStateEnergy,
+          electronicEnergy: vqe.groundStateEnergy - nucRepulsion,
+          nuclearRepulsionEnergy: nucRepulsion,
+          scfIterations: vqe.optimizerIterations,
+          converged: vqe.converged,
+          solverConfig: this.qmConfig,
+          wallTimeSeconds: vqe.wallTimeSeconds
+        };
+        this.lastEnergy = result.totalEnergy;
+        return result;
+      }
+      /** Geometry optimisation is not supported — use Psi4, then validate energy here. */
+      async optimizeGeometry(_molecule) {
+        throw new Error(
+          "[quantinuum] Quantinuum backend does not support geometry optimization. Use Psi4 for optimization, then quantinuum for logical-qubit energy validation."
+        );
+      }
+      /**
+       * Run VQE on logical (error-corrected) qubits and return the full QEC bookkeeping.
+       *
+       * Builds a JSON payload describing the molecule + encoding, invokes
+       * quantinuum_execute.py, and maps the response onto QuantinuumQECResult — which
+       * carries logical-vs-physical error AND the post-selection acceptance fraction.
+       */
+      async runLogicalVQE(molecule) {
+        requireCapability("quantinuum", "molecular");
+        const startTime = performance.now();
+        const executionMode = this.config.executionMode ?? "sim";
+        const input = {
+          task: "logical_vqe",
+          molecule: {
+            atoms: molecule.atoms.map((a) => ({ symbol: a.symbol, x: a.x, y: a.y, z: a.z })),
+            charge: molecule.charge ?? 0,
+            multiplicity: molecule.multiplicity ?? 1,
+            units: molecule.units ?? "angstrom"
+          },
+          method: this.qmConfig.basis ?? "sto-3g",
+          ansatz_layers: this.config.ansatzLayers ?? 1,
+          max_iterations: this.config.maxOptimizerIterations ?? 100,
+          execution_mode: executionMode,
+          device: this.config.device ?? null,
+          code_family: this.config.codeFamily ?? "steane",
+          code_distance: this.config.codeDistance ?? 3,
+          rounds: this.config.rounds ?? 1,
+          physical_error_rate: this.config.physicalErrorRate ?? 1e-3
+        };
+        const raw = await this._runPythonBridge(input);
+        if (raw.error) {
+          throw new Error(`[quantinuum] logical VQE failed: ${raw.error}`);
+        }
+        const wallTime = raw.wall_time_seconds ?? (performance.now() - startTime) / 1e3;
+        const executionBackend = raw.execution_backend === "quantinuum" ? "quantinuum" : "quantinuum-sim";
+        const result = {
+          groundStateEnergy: raw.ground_state_energy ?? 0,
+          converged: raw.converged ?? false,
+          optimizerIterations: raw.optimizer_iterations ?? 0,
+          finalCost: raw.final_cost ?? 0,
+          numQubits: raw.num_qubits ?? raw.physical_qubits ?? 0,
+          circuitDepth: raw.circuit_depth ?? 0,
+          executionBackend,
+          jobId: raw.job_id,
+          wallTimeSeconds: wallTime,
+          solverConfig: this.qmConfig,
+          logicalQubits: raw.logical_qubits ?? 0,
+          physicalQubits: raw.physical_qubits ?? 0,
+          codeFamily: raw.code_family ?? (this.config.codeFamily ?? "steane"),
+          codeDistance: raw.code_distance ?? (this.config.codeDistance ?? 3),
+          rounds: raw.rounds ?? (this.config.rounds ?? 1),
+          physicalErrorRate: raw.physical_error_rate ?? (this.config.physicalErrorRate ?? 1e-3),
+          logicalErrorRate: raw.logical_error_rate ?? 0,
+          postSelection: {
+            used: raw.post_selection_used ?? false,
+            acceptanceFraction: raw.acceptance_fraction ?? 1
+          }
+        };
+        this.lastResult = result;
+        this.lastEnergy = result.groundStateEnergy;
+        return result;
+      }
+      /**
+       * VQERunnerTrait / QmSolver compatibility shim: returns the plain VQEResult slice
+       * of the logical run, so the Quantinuum backend is usable anywhere `runVQE` is.
+       */
+      async runVQE(molecule, _ansatzLayers = 1) {
+        return this.runLogicalVQE(molecule);
+      }
+      /**
+       * Map a logical-VQE result onto a `cael-quantum-v1.qec` receipt — the honest,
+       * cross-vendor record. A post-selected result keeps `post_selection.used=true`
+       * and a sub-1.0 acceptance fraction, so the suppression figure can never be
+       * quoted without the discard rate that produced it.
+       */
+      async toQecReceipt(result) {
+        const isHw = result.executionBackend === "quantinuum";
+        const suppression = result.logicalErrorRate > 0 ? result.physicalErrorRate / result.logicalErrorRate : null;
+        const base = {
+          schema: "cael-quantum-v1.qec",
+          kind: "qec_logical_vqe_receipt",
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          tier: isHw ? "hardware" : "simulate",
+          claim_boundary: isHw ? "Logical-qubit VQE on real Quantinuum H-series hardware (error-corrected)." : "Local classical surrogate of logical-qubit error suppression; NOT hardware and NOT a full stabiliser simulation. Verifies pipeline + receipt only.",
+          code: {
+            family: result.codeFamily,
+            name: `${result.codeFamily}-d${result.codeDistance}`,
+            distance: result.codeDistance,
+            logical_qubits: result.logicalQubits,
+            physical_qubits: result.physicalQubits
+          },
+          noise_model: isHw ? "hardware" : "depolarizing-surrogate",
+          decoder: result.codeFamily === "none" ? "none" : "lookup-table",
+          rounds: result.rounds,
+          measurement: {
+            physical_error_rate: result.physicalErrorRate,
+            logical_error_rate: result.logicalErrorRate,
+            suppression_factor_physical_over_logical: suppression,
+            ground_state_energy: result.groundStateEnergy,
+            converged: result.converged
+          },
+          post_selection: {
+            used: result.postSelection.used,
+            acceptance_fraction: result.postSelection.acceptanceFraction,
+            note: "A fair logical-vs-physical suppression figure must be scaled by acceptance_fraction; a sub-1.0 fraction means shots were discarded."
+          }
+        };
+        const { createHash } = await import('crypto');
+        const payload_hash = createHash("sha256").update(
+          JSON.stringify({
+            schema: base.schema,
+            code: base.code,
+            noise_model: base.noise_model,
+            decoder: base.decoder,
+            rounds: base.rounds,
+            measurement: base.measurement,
+            post_selection: base.post_selection
+          })
+        ).digest("hex");
+        return { ...base, payload_hash, receipt_id: `qec-${payload_hash.slice(0, 16)}` };
+      }
+      // ── Unsupported classical QM methods ─────────────────────────────────────
+      async computeVibrations() {
+        throw new Error(this._unsupportedMsg("computeVibrations"));
+      }
+      async computeChargeDensity() {
+        throw new Error(this._unsupportedMsg("computeChargeDensity"));
+      }
+      async computeBandStructure() {
+        throw new Error(this._unsupportedMsg("computeBandStructure"));
+      }
+      async computeDipoleMoment() {
+        throw new Error(this._unsupportedMsg("computeDipoleMoment"));
+      }
+      async computeDftMaterials() {
+        throw new Error(this._unsupportedMsg("computeDftMaterials"));
+      }
+      async computeNmrSpectrum() {
+        throw new Error(this._unsupportedMsg("computeNmrSpectrum"));
+      }
+      async computeSemiEmpiricalEnergy() {
+        throw new Error(this._unsupportedMsg("computeSemiEmpiricalEnergy"));
+      }
+      async computeTransitionState() {
+        throw new Error(this._unsupportedMsg("computeTransitionState"));
+      }
+      async computeQmMm() {
+        throw new Error(this._unsupportedMsg("computeQmMm"));
+      }
+      // ── Private helpers ──────────────────────────────────────────────────────
+      /**
+       * Invoke the Python bridge with a JSON payload. The token is passed through the
+       * child environment (QUANTINUUM_API_KEY), never the argv JSON, so it cannot leak
+       * into process listings or logs. Mirrors the IBM backend's secret discipline.
+       */
+      async _runPythonBridge(input) {
+        const { execFile } = await import('child_process');
+        const { promisify } = await import('util');
+        const execFileAsync = promisify(execFile);
+        const scriptPath = this.config.scriptPath ?? new URL("../../../../../../scripts/quantinuum_execute.py", import.meta.url).pathname;
+        const pythonExe = process.env.QISKIT_PYTHON ?? (process.platform === "win32" ? "C:\\Python314\\python.exe" : "python3");
+        const bridgeInput = { ...input };
+        delete bridgeInput["api_token"];
+        delete bridgeInput["apiToken"];
+        const apiToken = this._resolveApiToken();
+        const childEnv = apiToken ? { ...process.env, QUANTINUUM_API_KEY: apiToken } : process.env;
+        const { stdout, stderr } = await execFileAsync(
+          pythonExe,
+          [scriptPath, JSON.stringify(bridgeInput)],
+          { maxBuffer: 10 * 1024 * 1024, env: childEnv }
+        );
+        if (stderr) {
+          const fatal = stderr.split("\n").filter(
+            (l) => l.includes("Error:") || l.includes("Traceback") || l.includes("SyntaxError")
+          );
+          if (fatal.length > 0) {
+            throw new Error(`[quantinuum] Python bridge error: ${fatal.join("\n")}`);
+          }
+        }
+        return JSON.parse(stdout);
+      }
+      _resolveApiToken() {
+        if (this.config.apiToken) {
+          return this.config.apiToken;
+        }
+        if (typeof process !== "undefined" && process.env["QUANTINUUM_API_KEY"]) {
+          return process.env["QUANTINUUM_API_KEY"];
+        }
+        return null;
+      }
+      /** Estimate nuclear repulsion from pairwise Coulomb (Hartree, a.u.). */
+      _estimateNuclearRepulsion(molecule) {
+        const ANGSTROM_TO_BOHR = 1.8897259886;
+        const atomicNumbers = {
+          H: 1,
+          He: 2,
+          Li: 3,
+          Be: 4,
+          B: 5,
+          C: 6,
+          N: 7,
+          O: 8,
+          F: 9,
+          Ne: 10,
+          Na: 11,
+          Mg: 12,
+          Al: 13,
+          Si: 14,
+          P: 15,
+          S: 16,
+          Cl: 17,
+          Ar: 18,
+          K: 19,
+          Ca: 20,
+          Fe: 26,
+          Co: 27,
+          Ni: 28,
+          Cu: 29,
+          Zn: 30
+        };
+        const atoms = molecule.atoms;
+        let repulsion = 0;
+        for (let i = 0; i < atoms.length; i++) {
+          for (let j = i + 1; j < atoms.length; j++) {
+            const ai = atoms[i];
+            const aj = atoms[j];
+            if (ai === void 0 || aj === void 0) continue;
+            const zi = atomicNumbers[ai.symbol] ?? 6;
+            const zj = atomicNumbers[aj.symbol] ?? 6;
+            const dx = (ai.x - aj.x) * ANGSTROM_TO_BOHR;
+            const dy = (ai.y - aj.y) * ANGSTROM_TO_BOHR;
+            const dz = (ai.z - aj.z) * ANGSTROM_TO_BOHR;
+            const r = Math.sqrt(dx * dx + dy * dy + dz * dz);
+            if (r > 0) repulsion += zi * zj / r;
+          }
+        }
+        return repulsion;
+      }
+      _unsupportedMsg(methodName) {
+        return `[quantinuum] ${methodName} is not supported. Quantinuum backend supports logical-qubit VQE (computeEnergy / runLogicalVQE / runVQE) only. Use Psi4 or TBLite for classical QM methods.`;
+      }
+    };
+  }
+});
+
 // ../plugins/qm-bridge/src/index.ts
 init_QmSolver();
 
@@ -887,9 +1230,21 @@ var Psi4Backend = class {
       "1H": 31.882,
       "13C": 184.133
     };
-    const nucleusLabels = molecule.atoms.map(
-      (a) => `${getAtomicNumber(a.symbol) === 1 ? "1" : a.symbol}H`
-    );
+    const nmrIsotopeLabel = (symbol) => {
+      switch (symbol) {
+        case "H":
+          return "1H";
+        case "C":
+          return "13C";
+        case "N":
+          return "15N";
+        case "P":
+          return "31P";
+        default:
+          return symbol;
+      }
+    };
+    const nucleusLabels = molecule.atoms.map((a) => nmrIsotopeLabel(a.symbol));
     const shieldings = raw.shieldings ?? new Array(molecule.atoms.length).fill(0);
     const chemicalShifts = shieldings.map((s, i) => {
       const label = nucleusLabels[i]?.replace(/\d+/, "") || "1H";
@@ -965,15 +1320,57 @@ var Psi4Backend = class {
   /**
    * Run a Psi4 input script and parse the JSON result.
    *
-   * In production, this invokes `psi4` as a subprocess. In test/mock mode,
-   * the result is synthesized. The bridge pattern keeps Psi4 (a C++/Python
-   * application) outside the HoloScript Node.js process.
+   * When psi4Path is '__mock__' or unset, returns synthesised mock data so
+   * the CAEL recording pipeline can be validated end-to-end without a Psi4
+   * installation. When psi4Path is any other value (a real binary path),
+   * the script is written to a temp file, psi4 is spawned as a subprocess,
+   * and the %%QM_RESULT%% marker is parsed from stdout. If the spawn fails
+   * (e.g. binary not found), an error is thrown — silent fallback to mock
+   * would be "verifier theater" (a bridge that always returns mock data is
+   * indistinguishable from a broken bridge).
    */
   async runPsi4(inputScript) {
     if (!this.psi4Path || this.psi4Path === "__mock__") {
       return this.mockPsi4Result(inputScript);
     }
-    return this.mockPsi4Result(inputScript);
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const os = await import('os');
+    const path = await import('path');
+    const fs = await import('fs/promises');
+    const execFileAsync = promisify(execFile);
+    const tmpDir = os.tmpdir();
+    const inputPath = path.join(tmpDir, `holoscript_psi4_${Date.now()}.py`);
+    const outputPath = path.join(tmpDir, `holoscript_psi4_${Date.now()}.out`);
+    try {
+      await fs.writeFile(inputPath, inputScript, "utf8");
+      const { stdout, stderr } = await execFileAsync(
+        this.psi4Path,
+        ["-i", inputPath, "-o", outputPath],
+        { maxBuffer: 10 * 1024 * 1024 }
+      );
+      if (stderr) {
+        const fatal = stderr.split("\n").filter(
+          (l) => l.includes("Error:") || l.includes("Traceback") || l.includes("SyntaxError")
+        );
+        if (fatal.length > 0) {
+          throw new Error(`[psi4] Subprocess error: ${fatal.join("\n")}`);
+        }
+      }
+      const marker = "%%QM_RESULT%%";
+      const markerIdx = stdout.indexOf(marker);
+      if (markerIdx === -1) {
+        throw new Error("[psi4] Output did not contain %%QM_RESULT%% marker");
+      }
+      const jsonStr = stdout.slice(markerIdx + marker.length).trim().split("\n")[0] ?? "";
+      return JSON.parse(jsonStr);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`[psi4] Failed to run psi4 at '${this.psi4Path}': ${msg}`);
+    } finally {
+      await fs.unlink(inputPath).catch(() => void 0);
+      await fs.unlink(outputPath).catch(() => void 0);
+    }
   }
   /** Mock result for testing without Psi4 installed. */
   mockPsi4Result(_input) {
@@ -1232,11 +1629,74 @@ var QuantumEspressoBackend = class {
     throw new Error("[qm-bridge] Quantum ESPRESSO does not support QM/MM. Use psi4 backend.");
   }
   // ── Subprocess bridge ──────────────────────────────────────────────────
-  async runQe(_input) {
+  /**
+   * Run pw.x with the given SCF input and parse the output.
+   *
+   * When pwPath is '__mock__', returns synthesised results for testing
+   * without a QE installation. When pwPath is any other value, the input is
+   * written to a temp directory, pw.x is spawned with stdin redirect, and
+   * the output is parsed for total energy, Fermi energy, and band gap.
+   * If the spawn fails, an error is thrown — silent fallback to mock would
+   * be verifier theater.
+   *
+   * Output parsing targets QE 7.x XML output (in the ./tmp/holoscript_qm.save/
+   * directory) or falls back to stdout pattern matching.
+   */
+  async runQe(input) {
     if (this.pwPath === "__mock__") {
       return this.mockQeResult();
     }
-    return this.mockQeResult();
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const os = await import('os');
+    const path = await import('path');
+    const fs = await import('fs/promises');
+    const execFileAsync = promisify(execFile);
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "holoscript_qe_"));
+    const inputPath = path.join(tmpDir, "pw.in");
+    const outputPath = path.join(tmpDir, "pw.out");
+    try {
+      const patchedInput = input.replace("outdir = './tmp'", `outdir = '${tmpDir}/tmp'`);
+      await fs.writeFile(inputPath, patchedInput, "utf8");
+      const { stdout, stderr } = await execFileAsync(
+        this.pwPath,
+        ["-in", inputPath],
+        {
+          cwd: tmpDir,
+          maxBuffer: 50 * 1024 * 1024,
+          env: { ...process.env, OMP_NUM_THREADS: "1" }
+        }
+      );
+      await fs.writeFile(outputPath, stdout, "utf8").catch(() => void 0);
+      if (stderr) {
+        const fatal = stderr.split("\n").filter((l) => l.includes("Error") || l.includes("Traceback") || l.includes("forrtl"));
+        if (fatal.length > 0) {
+          throw new Error(`[quantum-espresso] pw.x stderr: ${fatal.join("\n")}`);
+        }
+      }
+      const energyMatch = stdout.match(/!\s+total energy\s+=\s+([-\d.]+)\s+Ry/);
+      const totalEnergy = energyMatch?.[1] !== void 0 ? parseFloat(energyMatch[1]) : void 0;
+      const fermiMatch = stdout.match(/the Fermi energy is\s+([-\d.]+)\s+ev/i);
+      const fermiEnergy = fermiMatch?.[1] !== void 0 ? parseFloat(fermiMatch[1]) : void 0;
+      const convMatch = stdout.match(/convergence has been achieved in\s+(\d+)/i);
+      const converged = convMatch !== null;
+      const scfIterations = convMatch?.[1] !== void 0 ? parseInt(convMatch[1], 10) : 0;
+      return {
+        total_energy: totalEnergy,
+        fermi_energy: fermiEnergy,
+        band_gap: void 0,
+        // Requires post-processing with bands.x
+        is_metallic: fermiEnergy !== void 0 && totalEnergy !== void 0,
+        scf_iterations: scfIterations,
+        converged,
+        band_energies: []
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`[quantum-espresso] Failed to run pw.x at '${this.pwPath}': ${msg}`);
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => void 0);
+    }
   }
   mockQeResult() {
     return {
@@ -1355,12 +1815,61 @@ var TBLiteBackend = class {
     throw new Error("[qm-bridge] TBLite does not support QM/MM. Use psi4 backend.");
   }
   // ── Subprocess bridge ──────────────────────────────────────────────────
+  /**
+   * Invoke xtb for a single-point (--sp) or geometry optimisation (--opt).
+   *
+   * When xtbPath is '__mock__', returns synthesised results so tests that do
+   * not have xtb installed can still exercise the interface. When xtbPath is
+   * any other value, the XYZ input is written to a temp directory, xtb is
+   * spawned, and the JSON output (xtb --json writes xtbout.json) is parsed.
+   * If the spawn fails, an error is thrown — silent fallback to mock would
+   * be verifier theater.
+   */
   async runXtb(molecule, task) {
-    this.moleculeToXyz(molecule);
     if (this.xtbPath === "__mock__") {
       return this.mockXtbResult(molecule, task);
     }
-    return this.mockXtbResult(molecule, task);
+    const xyz = this.moleculeToXyz(molecule);
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const os = await import('os');
+    const path = await import('path');
+    const fs = await import('fs/promises');
+    const execFileAsync = promisify(execFile);
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "holoscript_xtb_"));
+    const inputPath = path.join(tmpDir, "input.xyz");
+    const jsonOutputPath = path.join(tmpDir, "xtbout.json");
+    try {
+      await fs.writeFile(inputPath, xyz, "utf8");
+      const args = [inputPath, task, "--json", "--namespace", "xtbout"];
+      if (this.xtbMethod === "GFN0-xTB") args.push("--gfn", "0");
+      else if (this.xtbMethod === "GFN1-xTB") args.push("--gfn", "1");
+      const { stderr } = await execFileAsync(this.xtbPath, args, {
+        cwd: tmpDir,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      if (stderr) {
+        const fatal = stderr.split("\n").filter((l) => l.includes("ERROR") || l.includes("Traceback"));
+        if (fatal.length > 0) {
+          throw new Error(`[tblite] xtb stderr: ${fatal.join("\n")}`);
+        }
+      }
+      const jsonRaw = await fs.readFile(jsonOutputPath, "utf8");
+      const parsed = JSON.parse(jsonRaw);
+      return {
+        total_energy: typeof parsed["total energy"] === "number" ? parsed["total energy"] : void 0,
+        converged: true,
+        scf_iterations: typeof parsed["number of iterations taken for SCC"] === "number" ? parsed["number of iterations taken for SCC"] : void 0,
+        dipole_moment: Array.isArray(parsed["dipole"]) ? parsed["dipole"] : void 0,
+        gradient_norm: typeof parsed["gradient norm"] === "number" ? parsed["gradient norm"] : void 0,
+        opt_steps: typeof parsed["optimization steps"] === "number" ? parsed["optimization steps"] : void 0
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`[tblite] Failed to run xtb at '${this.xtbPath}': ${msg}`);
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => void 0);
+    }
   }
   /** Convert molecule to XYZ format for xtb input. */
   moleculeToXyz(molecule) {
@@ -2045,11 +2554,17 @@ var PySCFBackend = class {
 };
 
 // ../plugins/qm-bridge/src/index.ts
+init_quantinuum();
 init_ibm_quantum();
+init_quantinuum();
 function createIBMQuantumBackend(config) {
   const { IBMQuantumBackend: IBMQuantumBackend2 } = (init_ibm_quantum(), __toCommonJS(ibm_quantum_exports));
   return new IBMQuantumBackend2(config);
 }
+function createQuantinuumBackend(config) {
+  const { QuantinuumBackend: QuantinuumBackend2 } = (init_quantinuum(), __toCommonJS(quantinuum_exports));
+  return new QuantinuumBackend2(config);
+}
 function createQmSolver(config) {
   switch (config.backend) {
     case "psi4":
@@ -2062,14 +2577,19 @@ function createQmSolver(config) {
       return new IBMQuantumBackend(config);
     case "pyscf":
       return new PySCFBackend(config);
+    case "quantinuum":
+      return new QuantinuumBackend(config);
     default:
       throw new Error(
-        `[qm-bridge] Unknown backend: '${config.backend}'. Supported: psi4, quantum-espresso, tblite, ibm-quantum, pyscf`
+        `[qm-bridge] Unknown backend: '${config.backend}'. Supported: psi4, quantum-espresso, tblite, ibm-quantum, pyscf, quantinuum`
       );
   }
 }
 function selectQmBackend(questionType) {
   const q = questionType.toLowerCase();
+  if (q.includes("quantinuum") || q.includes("logical qubit") || q.includes("error-corrected") || q.includes("error corrected") || q.includes("error correction") || q.includes("qec") || q.includes("carbon code") || q.includes("tesseract") || q.includes("h-series") || q.includes("fault-tolerant") || q.includes("fault tolerant")) {
+    return "quantinuum";
+  }
   if (q.includes("vqe") || q.includes("variational quantum") || q.includes("quantum circuit") || q.includes("qaoa") || q.includes("qubo") || q.includes("ibm quantum") || q.includes("quantum hardware")) {
     return "ibm-quantum";
   }
@@ -2108,6 +2628,9 @@ function getDefaultQmConfig(backend, questionType) {
     case "ibm-quantum": {
       return { backend: "ibm-quantum", method: "vqe", basis: "sto-3g" };
     }
+    case "quantinuum": {
+      return { backend: "quantinuum", method: "vqe", basis: "sto-3g" };
+    }
     case "pyscf": {
       if (q.includes("phonon") || q.includes("dos") || q.includes("density of states")) {
         return { backend: "pyscf", method: "pbe", basis: "sto-3g" };
@@ -2126,6 +2649,6 @@ function getDefaultQmConfig(backend, questionType) {
 }
 var VERSION = "0.1.0";
 
-export { IBMQuantumBackend, Psi4Backend, PySCFBackend, QM_ACCEPTANCE_CRITERIA, QM_BACKEND_CAPABILITIES, QuantumEspressoBackend, TBLiteBackend, VERSION, computeMeasurementBasis, createIBMQuantumBackend, createQmSolver, estimateMeasurementCost, getDefaultQmConfig, groupPauliTerms, parsePauliList, paulisCommute, qmConfigToCael, qmResultToCaelSummary, requireCapability, selectQmBackend, verifyQmAcceptance };
-//# sourceMappingURL=src-J6CM4AUR.js.map
-//# sourceMappingURL=src-J6CM4AUR.js.map
+export { IBMQuantumBackend, Psi4Backend, PySCFBackend, QM_ACCEPTANCE_CRITERIA, QM_BACKEND_CAPABILITIES, QuantinuumBackend, QuantumEspressoBackend, TBLiteBackend, VERSION, computeMeasurementBasis, createIBMQuantumBackend, createQmSolver, createQuantinuumBackend, estimateMeasurementCost, getDefaultQmConfig, groupPauliTerms, parsePauliList, paulisCommute, qmConfigToCael, qmResultToCaelSummary, requireCapability, selectQmBackend, verifyQmAcceptance };
+//# sourceMappingURL=src-UXYA7HM6.js.map
+//# sourceMappingURL=src-UXYA7HM6.js.map