@ruvector/ruqu 0.1.0 → 0.2.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Ruvector Team
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Ruvector Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,39 +1,35 @@
-# ruqu
+# @ruvector/ruqu
 
-**Agent-harness CLI for the [ruqu](https://github.com/ruvnet/ruqu) quantum project.** Boots the
-[metaharness](https://github.com/ruvnet/agent-harness-generator) kernel + a Claude Code host
-adapter, with a self-evolving agent loop (hypothesizer → experimenter → federator) over a
-witness-signed evolution log.
+**Quantum computing from your terminal** — a state-vector quantum circuit simulator compiled to
+**WebAssembly** (the pure-Rust [`ruqu`](https://github.com/ruvnet/ruqu) crates), wrapped in a
+[metaharness](https://github.com/ruvnet/agent-harness-generator) agent CLI.
 
 ```bash
-npx @ruvector/ruqu init      # boot the kernel + host adapter
-npx @ruvector/ruqu doctor    # verify the install end-to-end
+npx @ruvector/ruqu capabilities          # what it can do
+npx @ruvector/ruqu simulate --qubits 4   # GHZ state-vector simulation
+npx @ruvector/ruqu grover --qubits 3 --target 5
+npx @ruvector/ruqu qaoa --nodes 4        # QAOA MaxCut on a ring
+npx @ruvector/ruqu doctor                # verify kernel + quantum WASM
 ```
 
-Or install globally:
+## Commands
 
-```bash
-npm install -g @ruvector/ruqu
-ruqu doctor
-```
-
-## Agents
-
-| Agent | Role |
+| Command | What it does |
 |---|---|
-| `hypothesizer` | Proposes a falsifiable self-improvement. |
-| `experimenter` | Tests the hypothesis safely and records it. |
-| `federator` | Shares vetted improvements across instances. |
+| `simulate [--qubits N]` | Run a GHZ/Bell circuit on the WASM state-vector simulator (up to 25 qubits). |
+| `grover [--qubits N --target T --seed S]` | Grover amplitude amplification / search. |
+| `qaoa [--nodes N --p P]` | QAOA MaxCut on a ring graph. |
+| `capabilities` | List gates, algorithms, qubit/memory limits. |
+| `init` · `doctor` | Boot / verify the agent-harness kernel **and** the quantum WASM. |
+| `version` | Kernel + WASM versions. |
 
-Ships with the **claude-code** host adapter.
+Gates: `h x y z s t rx ry rz cnot cz swap rzz measure reset barrier`. Up to **25 qubits**.
 
-## Kernel backend
+## How it works
 
-The harness loads `@metaharness/kernel`, which resolves a backend in order **native → wasm → js**.
-The published `@metaharness/kernel@0.1.0` beta ships only the **pure-JS** floor backend; the native
-(NAPI) and WASM artifacts are produced by separate upstream build jobs and are not in the npm
-package yet, so `ruqu doctor` currently reports the **`js`** backend. It will pick up native/WASM
-automatically once those kernel artifacts are published — no change needed here.
+The CLI bundles a `--target nodejs` WebAssembly build of the `ruqu-wasm` crate (real state-vector
+simulation in Rust → WASM) and loads it directly in Node — no native addon, no Python. It also boots
+the metaharness kernel + Claude Code host adapter for the agent-harness commands (`init`/`doctor`).
 
 ## License
 

package/bin/cli.js

@@ -1,100 +1,170 @@
-#!/usr/bin/env node
-// SPDX-License-Identifier: MIT
-// Generated by metaharness — the `ruqu` CLI entry point.
-//
-// This is plain ESM JavaScript on purpose: it runs as-is via `npx ruqu`
-// with NO build step. `npm run build` (tsc) is only needed if you extend the
-// TypeScript in src/. The published package ships this file directly (see the
-// "bin" + "files" fields in package.json), so `npx ruqu` works the moment
-// `npm install` has resolved @metaharness/kernel + @metaharness/host-claude-code.
-
-import { loadKernel } from '@metaharness/kernel';
-import adapter from '@metaharness/host-claude-code';
-
-const HARNESS_NAME = 'ruqu';
-
-/** `ruqu init` — boot the kernel + host adapter and report status. */
-async function init() {
-  const kernel = await loadKernel();
-  const info = kernel.kernelInfo();
-  console.log(`${HARNESS_NAME} — kernel ${info.version} (${kernel.backend})`);
-  console.log(`Host adapter: ${adapter.name}`);
-  console.log(`Run \`${HARNESS_NAME} doctor\` to verify the install.`);
-  return 0;
-}
-
-/** `ruqu doctor` — verify the install end-to-end (kernel + host resolve). */
-async function doctor() {
-  const kernel = await loadKernel();
-  const info = kernel.kernelInfo();
-  const checks = [
-    ['kernel loads', !!kernel],
-    ['kernel reports a version', typeof info.version === 'string' && info.version.length > 0],
-    ['kernel backend is native|wasm|js', ['native', 'wasm', 'js'].includes(kernel.backend)],
-    ['host adapter has a name', typeof adapter?.name === 'string' && adapter.name.length > 0],
-  ];
-  let ok = true;
-  for (const [label, pass] of checks) {
-    console.log(`${pass ? 'PASS' : 'FAIL'} ${label}`);
-    if (!pass) ok = false;
-  }
-  console.log(
-    ok
-      ? `\n${HARNESS_NAME}: all checks passed (kernel ${info.version}, ${kernel.backend} backend, host ${adapter.name})`
-      : `\n${HARNESS_NAME}: doctor found problems`,
-  );
-  return ok ? 0 : 1;
-}
-
-/**
- * Dispatch one CLI invocation. Exported (not just run on import) so a test can
- * drive it without spawning a subprocess. Returns the intended exit code.
- */
-export async function run(argv) {
-  const cmd = argv[0] ?? 'init';
-  switch (cmd) {
-    case 'init':
-      return init();
-    case 'doctor':
-      return doctor();
-    case '--version':
-    case '-v': {
-      const kernel = await loadKernel();
-      console.log(kernel.version());
-      return 0;
-    }
-    case '--help':
-    case '-h':
-      console.log(`Usage: ${HARNESS_NAME} <command>\n\n  init     boot the kernel + host adapter (default)\n  doctor   verify the install end-to-end\n  --version  print the kernel version`);
-      return 0;
-    default:
-      console.error(`Unknown command: ${cmd}. Try \`${HARNESS_NAME} --help\`.`);
-      return 2;
-  }
-}
-
-// CLI guard: execute only when invoked directly (not when imported by a test).
-// npm's bin shims pass a NON-normalized argv[1] (e.g. ".../.bin/../<pkg>/bin/cli.js"
-// on Windows) and may differ in case, so realpath BOTH sides before comparing —
-// a naive string === misses the npx/shim path and the CLI silently no-ops.
-import { fileURLToPath } from 'node:url';
-import { realpathSync } from 'node:fs';
-import { argv } from 'node:process';
-const invokedDirectly = (() => {
-  if (!argv[1]) return false;
-  try {
-    const a = realpathSync(argv[1]);
-    const b = realpathSync(fileURLToPath(import.meta.url));
-    return process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
-  } catch {
-    return false;
-  }
-})();
-if (invokedDirectly) {
-  run(argv.slice(2))
-    .then((code) => process.exit(code))
-    .catch((err) => {
-      console.error(err);
-      process.exit(1);
-    });
-}
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+// The `ruqu` CLI — an agent harness over the metaharness kernel PLUS real
+// quantum-circuit execution via the bundled ruqu-wasm WebAssembly module.
+//
+// Plain ESM JS: runs as-is via `npx @ruvector/ruqu` with no build step.
+
+import { loadKernel } from '@metaharness/kernel';
+import adapter from '@metaharness/host-claude-code';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const HARNESS_NAME = 'ruqu';
+const require = createRequire(import.meta.url);
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+/** Lazily load the bundled nodejs-target quantum WASM (ruqu-wasm crate). */
+let _wasm;
+function quantum() {
+  if (!_wasm) _wasm = require(join(HERE, '..', 'wasm', 'ruqu_wasm.js'));
+  return _wasm;
+}
+
+function arg(args, flag, def) {
+  const i = args.indexOf(flag);
+  return i >= 0 && args[i + 1] !== undefined ? args[i + 1] : def;
+}
+function intArg(args, flag, def) {
+  const v = arg(args, flag, undefined);
+  return v === undefined ? def : parseInt(v, 10);
+}
+/** Top-k computational basis states by probability, as [bitstring, p]. */
+function topStates(probs, n, k = 8) {
+  return probs
+    .map((p, i) => [i.toString(2).padStart(n, '0'), p])
+    .filter(([, p]) => p > 1e-9)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, k);
+}
+
+/** `ruqu init` — boot the agent-harness kernel + host adapter. */
+async function init() {
+  const kernel = await loadKernel();
+  const info = kernel.kernelInfo();
+  console.log(`${HARNESS_NAME} — kernel ${info.version} (${kernel.backend}) · host ${adapter.name}`);
+  console.log(`Quantum WASM: ${quantum().max_qubits()} qubits max. Try \`${HARNESS_NAME} capabilities\`.`);
+  return 0;
+}
+
+/** `ruqu doctor` — verify the harness kernel AND the quantum WASM end-to-end. */
+async function doctor() {
+  const kernel = await loadKernel();
+  const info = kernel.kernelInfo();
+  let maxq = 0;
+  try { maxq = quantum().max_qubits(); } catch { maxq = 0; }
+  const checks = [
+    ['metaharness kernel loads', !!kernel],
+    ['kernel reports a version', typeof info.version === 'string' && info.version.length > 0],
+    ['host adapter has a name', typeof adapter?.name === 'string' && adapter.name.length > 0],
+    ['quantum WASM loads (ruqu-wasm)', maxq > 0],
+    [`quantum WASM runs a Bell state`, runsBell()],
+  ];
+  let ok = true;
+  for (const [label, pass] of checks) { console.log(`${pass ? 'PASS' : 'FAIL'} ${label}`); if (!pass) ok = false; }
+  console.log(ok
+    ? `\n${HARNESS_NAME}: all checks passed (kernel ${info.version} ${kernel.backend}; quantum WASM ${maxq} qubits)`
+    : `\n${HARNESS_NAME}: doctor found problems`);
+  return ok ? 0 : 1;
+}
+function runsBell() {
+  try {
+    const q = quantum();
+    const c = new q.WasmQuantumCircuit(2); c.h(0); c.cnot(0, 1);
+    const r = q.simulate(c);
+    return Math.abs(r.probabilities[0] - 0.5) < 1e-6 && Math.abs(r.probabilities[3] - 0.5) < 1e-6;
+  } catch { return false; }
+}
+
+/** `ruqu capabilities` — list the quantum capabilities this CLI exposes. */
+function capabilities() {
+  const q = quantum();
+  const mem = q.estimate_memory(q.max_qubits());
+  console.log(`${HARNESS_NAME} — quantum capabilities (pure-Rust → WebAssembly)`);
+  console.log(`  max qubits        ${q.max_qubits()}`);
+  console.log(`  state @ max       ~${(mem / 1e6).toFixed(1)} MB`);
+  console.log(`  gates             h x y z s t rx ry rz cnot cz swap rzz measure reset barrier`);
+  console.log(`  algorithms        simulate · grover · qaoa`);
+  console.log(`  commands          init · doctor · capabilities · simulate · grover · qaoa · version`);
+  return 0;
+}
+
+/** `ruqu simulate [--qubits N]` — run a GHZ/Bell circuit and show the distribution. */
+function simulate(args) {
+  const q = quantum();
+  const n = intArg(args, '--qubits', 2);
+  const c = new q.WasmQuantumCircuit(n);
+  c.h(0);
+  for (let i = 1; i < n; i++) c.cnot(0, i);
+  const r = q.simulate(c);
+  console.log(`${HARNESS_NAME} simulate — ${n}-qubit GHZ · ${r.gate_count} gates · ${r.execution_time_ms.toFixed(2)} ms`);
+  for (const [bits, p] of topStates(r.probabilities, n)) console.log(`  |${bits}⟩  ${(p * 100).toFixed(1)}%`);
+  return 0;
+}
+
+/** `ruqu grover [--qubits N] [--target T] [--seed S]` — amplitude amplification. */
+function grover(args) {
+  const q = quantum();
+  const n = intArg(args, '--qubits', 3);
+  const target = intArg(args, '--target', (1 << n) - 1);
+  const seed = args.includes('--seed') ? intArg(args, '--seed', 0) : null;
+  const r = q.grover_search(n, [target], seed);
+  console.log(`${HARNESS_NAME} grover — ${n} qubits, target=${target}`);
+  console.log(`  iterations         ${r.num_iterations}`);
+  console.log(`  success probability ${(r.success_probability * 100).toFixed(1)}%`);
+  console.log(`  measured state      ${r.measured_state}`);
+  return 0;
+}
+
+/** `ruqu qaoa [--nodes N] [--p P]` — QAOA MaxCut on a ring graph. */
+function qaoa(args) {
+  const q = quantum();
+  const nodes = intArg(args, '--nodes', 4);
+  const edges = [];
+  for (let i = 0; i < nodes; i++) { edges.push(i, (i + 1) % nodes); }
+  const p = intArg(args, '--p', 1);
+  const gammas = Array.from({ length: p }, () => 0.8);
+  const betas = Array.from({ length: p }, () => 0.6);
+  const r = q.qaoa_maxcut(nodes, edges, p, gammas, betas, null);
+  console.log(`${HARNESS_NAME} qaoa — ${nodes}-node ring MaxCut, p=${p}`);
+  for (const [bits, prob] of topStates(r.probabilities, nodes, 5)) console.log(`  cut ${bits}  ${(prob * 100).toFixed(1)}%`);
+  return 0;
+}
+
+async function version() {
+  const k = await loadKernel();
+  console.log(`${HARNESS_NAME} CLI — metaharness kernel ${k.kernelInfo().version} (${k.backend}) · quantum WASM ${quantum().max_qubits()}q`);
+  return 0;
+}
+
+export async function run(argv) {
+  const [cmd, ...rest] = argv;
+  switch (cmd) {
+    case undefined:
+    case 'init': return init();
+    case 'doctor': return doctor();
+    case 'capabilities': case 'caps': return capabilities();
+    case 'simulate': case 'sim': return simulate(rest);
+    case 'grover': return grover(rest);
+    case 'qaoa': return qaoa(rest);
+    case 'version': case '--version': return version();
+    case 'help': case '--help':
+      console.log(`Usage: ${HARNESS_NAME} <command>\n\n  init           boot the kernel + host adapter (default)\n  doctor         verify kernel + quantum WASM end-to-end\n  capabilities   list quantum capabilities\n  simulate       run a GHZ/Bell circuit  [--qubits N]\n  grover         Grover search           [--qubits N --target T --seed S]\n  qaoa           QAOA MaxCut on a ring    [--nodes N --p P]\n  version        print versions`);
+      return 0;
+    default:
+      console.error(`Unknown command: ${cmd}. Try \`${HARNESS_NAME} --help\`.`);
+      return 1;
+  }
+}
+
+// Execute only when invoked directly (not when imported by a test).
+import { realpathSync } from 'node:fs';
+import { argv } from 'node:process';
+const invokedDirectly = (() => {
+  try { return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(argv[1]); }
+  catch { return false; }
+})();
+if (invokedDirectly) {
+  run(argv.slice(2)).then((code) => process.exit(code)).catch((e) => { console.error(e); process.exit(1); });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ruvector/ruqu",
-  "version": "0.1.0",
-  "description": "Agent-harness CLI for the ruqu quantum project — boots the metaharness kernel + Claude Code host adapter. Run: npx @ruvector/ruqu",
+  "version": "0.2.0",
+  "description": "Quantum circuit simulator in WebAssembly + agent harness CLI — run state-vector simulation, Grover search, and QAOA MaxCut from your terminal. npx @ruvector/ruqu",
   "type": "module",
   "bin": {
     "ruqu": "bin/cli.js"
@@ -13,7 +13,8 @@
     ".claude/**",
     "CLAUDE.md",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "wasm/**"
   ],
   "scripts": {
     "build": "tsc",
@@ -57,6 +58,14 @@
     "claude-code",
     "quantum",
     "harness",
-    "npx"
+    "npx",
+    "quantum-computing",
+    "quantum-simulator",
+    "webassembly",
+    "wasm",
+    "qaoa",
+    "grover",
+    "state-vector",
+    "quantum-circuit"
   ]
 }

package/wasm/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/wasm/ruqu_wasm.d.ts

@@ -0,0 +1,207 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A JavaScript-friendly quantum circuit builder.
+ *
+ * Wraps `ruqu_core::circuit::QuantumCircuit` with wasm-bindgen annotations.
+ * All gate methods validate qubit indices against the circuit size internally
+ * via the core library.
+ *
+ * ## JavaScript Example
+ *
+ * ```javascript
+ * const qc = new WasmQuantumCircuit(3);
+ * qc.h(0);           // Hadamard on qubit 0
+ * qc.cnot(0, 1);     // CNOT: control=0, target=1
+ * qc.rz(2, Math.PI); // Rz rotation on qubit 2
+ * qc.measure_all();
+ *
+ * console.log(`Qubits: ${qc.num_qubits}`);
+ * console.log(`Gates:  ${qc.gate_count}`);
+ * console.log(`Depth:  ${qc.depth}`);
+ * ```
+ */
+export class WasmQuantumCircuit {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Insert a barrier (prevents gate reordering across this point).
+     */
+    barrier(): void;
+    /**
+     * Apply CNOT (controlled-X) gate.
+     */
+    cnot(control: number, target: number): void;
+    /**
+     * Apply controlled-Z gate.
+     */
+    cz(q1: number, q2: number): void;
+    /**
+     * Apply Hadamard gate to the target qubit.
+     */
+    h(qubit: number): void;
+    /**
+     * Add a measurement operation on a single qubit.
+     */
+    measure(qubit: number): void;
+    /**
+     * Add measurement operations on all qubits.
+     */
+    measure_all(): void;
+    /**
+     * Create a new quantum circuit with the given number of qubits.
+     *
+     * Returns an error if `num_qubits` exceeds the WASM limit (25).
+     */
+    constructor(num_qubits: number);
+    /**
+     * Reset a qubit to the |0> state.
+     */
+    reset(qubit: number): void;
+    /**
+     * Apply Rx rotation gate with the given angle (radians).
+     */
+    rx(qubit: number, angle: number): void;
+    /**
+     * Apply Ry rotation gate with the given angle (radians).
+     */
+    ry(qubit: number, angle: number): void;
+    /**
+     * Apply Rz rotation gate with the given angle (radians).
+     */
+    rz(qubit: number, angle: number): void;
+    /**
+     * Apply Rzz (ZZ-rotation) gate with the given angle (radians).
+     */
+    rzz(q1: number, q2: number, angle: number): void;
+    /**
+     * Apply S (phase) gate to the target qubit.
+     */
+    s(qubit: number): void;
+    /**
+     * Apply SWAP gate.
+     */
+    swap(q1: number, q2: number): void;
+    /**
+     * Apply T gate to the target qubit.
+     */
+    t(qubit: number): void;
+    /**
+     * Apply Pauli-X (NOT) gate to the target qubit.
+     */
+    x(qubit: number): void;
+    /**
+     * Apply Pauli-Y gate to the target qubit.
+     */
+    y(qubit: number): void;
+    /**
+     * Apply Pauli-Z gate to the target qubit.
+     */
+    z(qubit: number): void;
+    /**
+     * The circuit depth (longest path through the gate DAG).
+     */
+    readonly depth: number;
+    /**
+     * The total number of gates applied so far.
+     */
+    readonly gate_count: number;
+    /**
+     * The number of qubits in this circuit.
+     */
+    readonly num_qubits: number;
+}
+
+/**
+ * Estimate memory usage (in bytes) for a state vector of `num_qubits` qubits.
+ *
+ * Each qubit doubles the state vector size. The formula is `2^n * 16` bytes
+ * (two f64 values per complex amplitude).
+ */
+export function estimate_memory(num_qubits: number): number;
+
+/**
+ * Run Grover's quantum search algorithm.
+ *
+ * Searches for one or more target states in a space of `2^num_qubits` items.
+ * The optimal number of iterations is computed automatically when not specified.
+ *
+ * ## Parameters
+ *
+ * - `num_qubits` - Number of qubits (search space = 2^num_qubits).
+ * - `target_states` - Array of target state indices to search for (as u32 values).
+ * - `seed` - Optional RNG seed for reproducibility. Pass `null` or `undefined`
+ *            for non-deterministic execution. If provided, interpreted as a
+ *            floating-point number and truncated to a 64-bit unsigned integer.
+ *
+ * ## Returns
+ *
+ * A JS object:
+ * ```typescript
+ * {
+ *   measured_state: number,
+ *   target_found: boolean,
+ *   success_probability: number,
+ *   num_iterations: number,
+ * }
+ * ```
+ */
+export function grover_search(num_qubits: number, target_states: Uint32Array, seed: any): any;
+
+/**
+ * Called automatically when the WASM module is instantiated.
+ *
+ * Sets up `console_error_panic_hook` (when the feature is enabled) so that
+ * Rust panics produce readable stack traces in the browser console instead
+ * of opaque "unreachable" errors.
+ */
+export function init(): void;
+
+/**
+ * Get the maximum number of qubits supported in the WASM environment.
+ */
+export function max_qubits(): number;
+
+/**
+ * Build and simulate a QAOA (Quantum Approximate Optimization Algorithm)
+ * circuit for the MaxCut problem on an undirected graph.
+ *
+ * ## Parameters
+ *
+ * - `num_nodes` - Number of graph nodes (one qubit per node).
+ * - `edges_flat` - Flattened edge list as consecutive pairs: `[i1, j1, i2, j2, ...]`.
+ *   Each `(i, j)` pair defines an undirected edge with unit weight.
+ * - `p` - Number of QAOA rounds (circuit depth parameter).
+ * - `gammas` - Problem-unitary angles, length must equal `p`.
+ * - `betas` - Mixer-unitary angles, length must equal `p`.
+ * - `seed` - Optional RNG seed. Pass `null` or `undefined` for non-deterministic
+ *            execution.
+ *
+ * ## Returns
+ *
+ * A JS object:
+ * ```typescript
+ * {
+ *   probabilities: number[],   // length = 2^num_nodes
+ *   expected_cut: number,      // expected cut value from the output state
+ * }
+ * ```
+ */
+export function qaoa_maxcut(num_nodes: number, edges_flat: Uint32Array, p: number, gammas: Float64Array, betas: Float64Array, seed: any): any;
+
+/**
+ * Run a quantum circuit simulation and return the results as a JS object.
+ *
+ * The returned object has the shape:
+ * ```typescript
+ * {
+ *   probabilities: number[],   // length = 2^num_qubits
+ *   measurements: Array<{ qubit: number, result: boolean, probability: number }>,
+ *   num_qubits: number,
+ *   gate_count: number,
+ *   execution_time_ms: number,
+ * }
+ * ```
+ */
+export function simulate(circuit: WasmQuantumCircuit): any;

package/wasm/ruqu_wasm.js

@@ -0,0 +1,672 @@
+/* @ts-self-types="./ruqu_wasm.d.ts" */
+
+/**
+ * A JavaScript-friendly quantum circuit builder.
+ *
+ * Wraps `ruqu_core::circuit::QuantumCircuit` with wasm-bindgen annotations.
+ * All gate methods validate qubit indices against the circuit size internally
+ * via the core library.
+ *
+ * ## JavaScript Example
+ *
+ * ```javascript
+ * const qc = new WasmQuantumCircuit(3);
+ * qc.h(0);           // Hadamard on qubit 0
+ * qc.cnot(0, 1);     // CNOT: control=0, target=1
+ * qc.rz(2, Math.PI); // Rz rotation on qubit 2
+ * qc.measure_all();
+ *
+ * console.log(`Qubits: ${qc.num_qubits}`);
+ * console.log(`Gates:  ${qc.gate_count}`);
+ * console.log(`Depth:  ${qc.depth}`);
+ * ```
+ */
+class WasmQuantumCircuit {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmQuantumCircuitFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmquantumcircuit_free(ptr, 0);
+    }
+    /**
+     * Insert a barrier (prevents gate reordering across this point).
+     */
+    barrier() {
+        wasm.wasmquantumcircuit_barrier(this.__wbg_ptr);
+    }
+    /**
+     * Apply CNOT (controlled-X) gate.
+     * @param {number} control
+     * @param {number} target
+     */
+    cnot(control, target) {
+        wasm.wasmquantumcircuit_cnot(this.__wbg_ptr, control, target);
+    }
+    /**
+     * Apply controlled-Z gate.
+     * @param {number} q1
+     * @param {number} q2
+     */
+    cz(q1, q2) {
+        wasm.wasmquantumcircuit_cz(this.__wbg_ptr, q1, q2);
+    }
+    /**
+     * The circuit depth (longest path through the gate DAG).
+     * @returns {number}
+     */
+    get depth() {
+        const ret = wasm.wasmquantumcircuit_depth(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * The total number of gates applied so far.
+     * @returns {number}
+     */
+    get gate_count() {
+        const ret = wasm.wasmquantumcircuit_gate_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Apply Hadamard gate to the target qubit.
+     * @param {number} qubit
+     */
+    h(qubit) {
+        wasm.wasmquantumcircuit_h(this.__wbg_ptr, qubit);
+    }
+    /**
+     * Add a measurement operation on a single qubit.
+     * @param {number} qubit
+     */
+    measure(qubit) {
+        wasm.wasmquantumcircuit_measure(this.__wbg_ptr, qubit);
+    }
+    /**
+     * Add measurement operations on all qubits.
+     */
+    measure_all() {
+        wasm.wasmquantumcircuit_measure_all(this.__wbg_ptr);
+    }
+    /**
+     * Create a new quantum circuit with the given number of qubits.
+     *
+     * Returns an error if `num_qubits` exceeds the WASM limit (25).
+     * @param {number} num_qubits
+     */
+    constructor(num_qubits) {
+        const ret = wasm.wasmquantumcircuit_new(num_qubits);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        WasmQuantumCircuitFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * The number of qubits in this circuit.
+     * @returns {number}
+     */
+    get num_qubits() {
+        const ret = wasm.wasmquantumcircuit_num_qubits(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Reset a qubit to the |0> state.
+     * @param {number} qubit
+     */
+    reset(qubit) {
+        wasm.wasmquantumcircuit_reset(this.__wbg_ptr, qubit);
+    }
+    /**
+     * Apply Rx rotation gate with the given angle (radians).
+     * @param {number} qubit
+     * @param {number} angle
+     */
+    rx(qubit, angle) {
+        wasm.wasmquantumcircuit_rx(this.__wbg_ptr, qubit, angle);
+    }
+    /**
+     * Apply Ry rotation gate with the given angle (radians).
+     * @param {number} qubit
+     * @param {number} angle
+     */
+    ry(qubit, angle) {
+        wasm.wasmquantumcircuit_ry(this.__wbg_ptr, qubit, angle);
+    }
+    /**
+     * Apply Rz rotation gate with the given angle (radians).
+     * @param {number} qubit
+     * @param {number} angle
+     */
+    rz(qubit, angle) {
+        wasm.wasmquantumcircuit_rz(this.__wbg_ptr, qubit, angle);
+    }
+    /**
+     * Apply Rzz (ZZ-rotation) gate with the given angle (radians).
+     * @param {number} q1
+     * @param {number} q2
+     * @param {number} angle
+     */
+    rzz(q1, q2, angle) {
+        wasm.wasmquantumcircuit_rzz(this.__wbg_ptr, q1, q2, angle);
+    }
+    /**
+     * Apply S (phase) gate to the target qubit.
+     * @param {number} qubit
+     */
+    s(qubit) {
+        wasm.wasmquantumcircuit_s(this.__wbg_ptr, qubit);
+    }
+    /**
+     * Apply SWAP gate.
+     * @param {number} q1
+     * @param {number} q2
+     */
+    swap(q1, q2) {
+        wasm.wasmquantumcircuit_swap(this.__wbg_ptr, q1, q2);
+    }
+    /**
+     * Apply T gate to the target qubit.
+     * @param {number} qubit
+     */
+    t(qubit) {
+        wasm.wasmquantumcircuit_t(this.__wbg_ptr, qubit);
+    }
+    /**
+     * Apply Pauli-X (NOT) gate to the target qubit.
+     * @param {number} qubit
+     */
+    x(qubit) {
+        wasm.wasmquantumcircuit_x(this.__wbg_ptr, qubit);
+    }
+    /**
+     * Apply Pauli-Y gate to the target qubit.
+     * @param {number} qubit
+     */
+    y(qubit) {
+        wasm.wasmquantumcircuit_y(this.__wbg_ptr, qubit);
+    }
+    /**
+     * Apply Pauli-Z gate to the target qubit.
+     * @param {number} qubit
+     */
+    z(qubit) {
+        wasm.wasmquantumcircuit_z(this.__wbg_ptr, qubit);
+    }
+}
+if (Symbol.dispose) WasmQuantumCircuit.prototype[Symbol.dispose] = WasmQuantumCircuit.prototype.free;
+exports.WasmQuantumCircuit = WasmQuantumCircuit;
+
+/**
+ * Estimate memory usage (in bytes) for a state vector of `num_qubits` qubits.
+ *
+ * Each qubit doubles the state vector size. The formula is `2^n * 16` bytes
+ * (two f64 values per complex amplitude).
+ * @param {number} num_qubits
+ * @returns {number}
+ */
+function estimate_memory(num_qubits) {
+    const ret = wasm.estimate_memory(num_qubits);
+    return ret >>> 0;
+}
+exports.estimate_memory = estimate_memory;
+
+/**
+ * Run Grover's quantum search algorithm.
+ *
+ * Searches for one or more target states in a space of `2^num_qubits` items.
+ * The optimal number of iterations is computed automatically when not specified.
+ *
+ * ## Parameters
+ *
+ * - `num_qubits` - Number of qubits (search space = 2^num_qubits).
+ * - `target_states` - Array of target state indices to search for (as u32 values).
+ * - `seed` - Optional RNG seed for reproducibility. Pass `null` or `undefined`
+ *            for non-deterministic execution. If provided, interpreted as a
+ *            floating-point number and truncated to a 64-bit unsigned integer.
+ *
+ * ## Returns
+ *
+ * A JS object:
+ * ```typescript
+ * {
+ *   measured_state: number,
+ *   target_found: boolean,
+ *   success_probability: number,
+ *   num_iterations: number,
+ * }
+ * ```
+ * @param {number} num_qubits
+ * @param {Uint32Array} target_states
+ * @param {any} seed
+ * @returns {any}
+ */
+function grover_search(num_qubits, target_states, seed) {
+    const ptr0 = passArray32ToWasm0(target_states, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.grover_search(num_qubits, ptr0, len0, seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.grover_search = grover_search;
+
+/**
+ * Called automatically when the WASM module is instantiated.
+ *
+ * Sets up `console_error_panic_hook` (when the feature is enabled) so that
+ * Rust panics produce readable stack traces in the browser console instead
+ * of opaque "unreachable" errors.
+ */
+function init() {
+    wasm.init();
+}
+exports.init = init;
+
+/**
+ * Get the maximum number of qubits supported in the WASM environment.
+ * @returns {number}
+ */
+function max_qubits() {
+    const ret = wasm.max_qubits();
+    return ret >>> 0;
+}
+exports.max_qubits = max_qubits;
+
+/**
+ * Build and simulate a QAOA (Quantum Approximate Optimization Algorithm)
+ * circuit for the MaxCut problem on an undirected graph.
+ *
+ * ## Parameters
+ *
+ * - `num_nodes` - Number of graph nodes (one qubit per node).
+ * - `edges_flat` - Flattened edge list as consecutive pairs: `[i1, j1, i2, j2, ...]`.
+ *   Each `(i, j)` pair defines an undirected edge with unit weight.
+ * - `p` - Number of QAOA rounds (circuit depth parameter).
+ * - `gammas` - Problem-unitary angles, length must equal `p`.
+ * - `betas` - Mixer-unitary angles, length must equal `p`.
+ * - `seed` - Optional RNG seed. Pass `null` or `undefined` for non-deterministic
+ *            execution.
+ *
+ * ## Returns
+ *
+ * A JS object:
+ * ```typescript
+ * {
+ *   probabilities: number[],   // length = 2^num_nodes
+ *   expected_cut: number,      // expected cut value from the output state
+ * }
+ * ```
+ * @param {number} num_nodes
+ * @param {Uint32Array} edges_flat
+ * @param {number} p
+ * @param {Float64Array} gammas
+ * @param {Float64Array} betas
+ * @param {any} seed
+ * @returns {any}
+ */
+function qaoa_maxcut(num_nodes, edges_flat, p, gammas, betas, seed) {
+    const ptr0 = passArray32ToWasm0(edges_flat, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(gammas, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF64ToWasm0(betas, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.qaoa_maxcut(num_nodes, ptr0, len0, p, ptr1, len1, ptr2, len2, seed);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.qaoa_maxcut = qaoa_maxcut;
+
+/**
+ * Run a quantum circuit simulation and return the results as a JS object.
+ *
+ * The returned object has the shape:
+ * ```typescript
+ * {
+ *   probabilities: number[],   // length = 2^num_qubits
+ *   measurements: Array<{ qubit: number, result: boolean, probability: number }>,
+ *   num_qubits: number,
+ *   gate_count: number,
+ *   execution_time_ms: number,
+ * }
+ * ```
+ * @param {WasmQuantumCircuit} circuit
+ * @returns {any}
+ */
+function simulate(circuit) {
+    _assertClass(circuit, WasmQuantumCircuit);
+    const ret = wasm.simulate(circuit.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.simulate = simulate;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_fdd633d4bb5dd76a: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_is_function_acc5528be2b923f2: function(arg0) {
+            const ret = typeof(arg0) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_null_6d937fbfb6478470: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_0beba4a1980d3eea: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_1fca8072260dd261: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_721f8decd50c87a3: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_1cc01dd708740256: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_throw_ea4887a5f8f9a9db: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_call_5575218572ead796: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_crypto_38df2bab126b63dc: function(arg0) {
+            const ret = arg0.crypto;
+            return ret;
+        },
+        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
+            arg0.getRandomValues(arg1);
+        }, arguments); },
+        __wbg_length_589238bdcf171f0e: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+            const ret = arg0.msCrypto;
+            return ret;
+        },
+        __wbg_new_2e117a478906f062: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_36e147a8ced3c6e0: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_with_length_9b650f44b5c44a4e: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_node_84ea875411254db1: function(arg0) {
+            const ret = arg0.node;
+            return ret;
+        },
+        __wbg_now_e7c6795a7f81e10f: function(arg0) {
+            const ret = arg0.now();
+            return ret;
+        },
+        __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
+            const ret = arg0.performance;
+            return ret;
+        },
+        __wbg_process_44c7a14e11e9f69e: function(arg0) {
+            const ret = arg0.process;
+            return ret;
+        },
+        __wbg_prototypesetcall_d721637c7ca66eb8: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
+            arg0.randomFillSync(arg1);
+        }, arguments); },
+        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
+            const ret = module.require;
+            return ret;
+        }, arguments); },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            arg0[arg1] = arg2;
+        },
+        __wbg_set_dc601f4a69da0bc2: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
+        },
+        __wbg_static_accessor_GLOBAL_THIS_2fee5048bcca5938: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_GLOBAL_ce44e66a4935da8c: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_SELF_44f6e0cb5e67cdad: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_WINDOW_168f178805d978fe: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_subarray_b0e8ac4ed313fea8: function(arg0, arg1, arg2) {
+            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
+        __wbg_versions_276b2795b1c6a219: function(arg0) {
+            const ret = arg0.versions;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000004: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./ruqu_wasm_bg.js": import0,
+    };
+}
+
+const WasmQuantumCircuitFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmquantumcircuit_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/ruqu_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
+wasm.__wbindgen_start();

package/wasm/ruqu_wasm_bg.wasm.d.ts

@@ -0,0 +1,38 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_wasmquantumcircuit_free: (a: number, b: number) => void;
+export const estimate_memory: (a: number) => number;
+export const grover_search: (a: number, b: number, c: number, d: any) => [number, number, number];
+export const init: () => void;
+export const max_qubits: () => number;
+export const qaoa_maxcut: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: any) => [number, number, number];
+export const simulate: (a: number) => [number, number, number];
+export const wasmquantumcircuit_barrier: (a: number) => void;
+export const wasmquantumcircuit_cnot: (a: number, b: number, c: number) => void;
+export const wasmquantumcircuit_cz: (a: number, b: number, c: number) => void;
+export const wasmquantumcircuit_depth: (a: number) => number;
+export const wasmquantumcircuit_gate_count: (a: number) => number;
+export const wasmquantumcircuit_h: (a: number, b: number) => void;
+export const wasmquantumcircuit_measure: (a: number, b: number) => void;
+export const wasmquantumcircuit_measure_all: (a: number) => void;
+export const wasmquantumcircuit_new: (a: number) => [number, number, number];
+export const wasmquantumcircuit_num_qubits: (a: number) => number;
+export const wasmquantumcircuit_reset: (a: number, b: number) => void;
+export const wasmquantumcircuit_rx: (a: number, b: number, c: number) => void;
+export const wasmquantumcircuit_ry: (a: number, b: number, c: number) => void;
+export const wasmquantumcircuit_rz: (a: number, b: number, c: number) => void;
+export const wasmquantumcircuit_rzz: (a: number, b: number, c: number, d: number) => void;
+export const wasmquantumcircuit_s: (a: number, b: number) => void;
+export const wasmquantumcircuit_swap: (a: number, b: number, c: number) => void;
+export const wasmquantumcircuit_t: (a: number, b: number) => void;
+export const wasmquantumcircuit_x: (a: number, b: number) => void;
+export const wasmquantumcircuit_y: (a: number, b: number) => void;
+export const wasmquantumcircuit_z: (a: number, b: number) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;