@swarmdo/cli 1.4.8

package/vendor/neural/dist/utils/rng.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rng.js","sourceRoot":"","sources":["../../src/utils/rng.ts"],"names":[],"mappings":"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"}

package/vendor/neural/dist/utils/self-consistency.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Self-consistency orchestrator (Wang et al. 2022, "Self-Consistency Improves
+ * Chain of Thought Reasoning in Language Models").
+ *
+ * Runs an arbitrary stochastic operation N times and aggregates the results.
+ * Reduces variance from single-shot stochastic predictions; on reasoning
+ * benchmarks the technique typically gains 5–15pp accuracy at the cost of
+ * Nx compute. The package's RL algorithms, pattern matching, and routing
+ * all benefit since they sample randomly and can produce different outputs
+ * across calls.
+ *
+ * Aggregators:
+ *   - 'majority': pick the most common output (for discrete answers / labels).
+ *                 Uses JSON.stringify for grouping; stable for primitive and
+ *                 plain-object outputs. Float32Array values aggregate via
+ *                 their array-form encoding.
+ *   - 'mean':     numeric average (operation must return number).
+ *                 Agreement = 1 - normalized stddev.
+ *   - 'first':    take the first sample (no aggregation; useful for testing
+ *                 or deterministic ops).
+ *
+ * Pair with `setGlobalRng(new Mulberry32(seed))` to make a self-consistency
+ * run reproducible across machines.
+ */
+import type { RNG } from './rng.js';
+import { random } from './rng.js';
+export type SelfConsistencyAggregator = 'majority' | 'mean' | 'first';
+export interface SelfConsistencyConfig {
+    /** Number of samples to draw. Required. Larger N = more stable, more compute. */
+    N: number;
+    /** How to aggregate samples into a single answer. Default: 'majority'. */
+    aggregator?: SelfConsistencyAggregator;
+    /**
+     * Optional RNG to advance per sample (e.g. to differentiate seeds across
+     * samples when the operation reads from the global RNG). The orchestrator
+     * itself doesn't directly call this RNG; it's provided so callers can
+     * thread per-sample state (e.g. by reseeding before each call).
+     */
+    rng?: RNG;
+}
+export interface SelfConsistencyResult<T> {
+    /** The aggregated answer (majority vote, mean, or first). */
+    finalAnswer: T;
+    /** Every sample produced, in the order produced. Length === config.N. */
+    samples: T[];
+    /**
+     * For 'majority': fraction of samples matching finalAnswer (0..1).
+     * For 'mean':    1 - normalized stddev (rough confidence proxy).
+     * For 'first':   always 1.
+     */
+    agreement: number;
+    /** The config used for this run. */
+    config: SelfConsistencyConfig;
+}
+/**
+ * Run an operation N times and aggregate. The operation is awaited
+ * sequentially — if the caller wants concurrency they can wrap it themselves.
+ */
+export declare function selfConsistency<T>(operation: () => Promise<T> | T, config: SelfConsistencyConfig): Promise<SelfConsistencyResult<T>>;
+export { random };
+//# sourceMappingURL=self-consistency.d.ts.map

package/vendor/neural/dist/utils/self-consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-consistency.d.ts","sourceRoot":"","sources":["../../src/utils/self-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,MAAM,MAAM,yBAAyB,GAAG,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC;AAEtE,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,CAAC,EAAE,MAAM,CAAC;IACV,0EAA0E;IAC1E,UAAU,CAAC,EAAE,yBAAyB,CAAC;IACvC;;;;;OAKG;IACH,GAAG,CAAC,EAAE,GAAG,CAAC;CACX;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACtC,6DAA6D;IAC7D,WAAW,EAAE,CAAC,CAAC;IACf,yEAAyE;IACzE,OAAO,EAAE,CAAC,EAAE,CAAC;IACb;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,MAAM,EAAE,qBAAqB,CAAC;CAC/B;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,CAAC,EACrC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAC/B,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAiDnC;AAkBD,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/vendor/neural/dist/utils/self-consistency.js

@@ -0,0 +1,97 @@
+/**
+ * Self-consistency orchestrator (Wang et al. 2022, "Self-Consistency Improves
+ * Chain of Thought Reasoning in Language Models").
+ *
+ * Runs an arbitrary stochastic operation N times and aggregates the results.
+ * Reduces variance from single-shot stochastic predictions; on reasoning
+ * benchmarks the technique typically gains 5–15pp accuracy at the cost of
+ * Nx compute. The package's RL algorithms, pattern matching, and routing
+ * all benefit since they sample randomly and can produce different outputs
+ * across calls.
+ *
+ * Aggregators:
+ *   - 'majority': pick the most common output (for discrete answers / labels).
+ *                 Uses JSON.stringify for grouping; stable for primitive and
+ *                 plain-object outputs. Float32Array values aggregate via
+ *                 their array-form encoding.
+ *   - 'mean':     numeric average (operation must return number).
+ *                 Agreement = 1 - normalized stddev.
+ *   - 'first':    take the first sample (no aggregation; useful for testing
+ *                 or deterministic ops).
+ *
+ * Pair with `setGlobalRng(new Mulberry32(seed))` to make a self-consistency
+ * run reproducible across machines.
+ */
+import { random } from './rng.js';
+/**
+ * Run an operation N times and aggregate. The operation is awaited
+ * sequentially — if the caller wants concurrency they can wrap it themselves.
+ */
+export async function selfConsistency(operation, config) {
+    if (!Number.isInteger(config.N) || config.N <= 0) {
+        throw new Error(`selfConsistency: N must be a positive integer, got ${config.N}`);
+    }
+    const samples = [];
+    for (let i = 0; i < config.N; i++) {
+        samples.push(await operation());
+    }
+    const aggregator = config.aggregator ?? 'majority';
+    let finalAnswer;
+    let agreement;
+    if (aggregator === 'majority') {
+        // Group by JSON-stringified value (handles primitives, plain objects,
+        // arrays). Float32Array does NOT JSON-encode losslessly by default —
+        // callers wanting f32 majority should pre-convert via Array.from.
+        const counts = new Map();
+        for (const s of samples) {
+            const key = canonicalKey(s);
+            const existing = counts.get(key);
+            if (existing)
+                existing.count += 1;
+            else
+                counts.set(key, { value: s, count: 1 });
+        }
+        let best = { value: samples[0], count: 0 };
+        for (const c of counts.values()) {
+            if (c.count > best.count)
+                best = c;
+        }
+        finalAnswer = best.value;
+        agreement = best.count / samples.length;
+    }
+    else if (aggregator === 'mean') {
+        const nums = samples;
+        if (!nums.every((v) => typeof v === 'number' && Number.isFinite(v))) {
+            throw new Error("selfConsistency: aggregator='mean' requires every sample to be a finite number");
+        }
+        const mean = nums.reduce((a, b) => a + b, 0) / nums.length;
+        const variance = nums.reduce((s, v) => s + (v - mean) ** 2, 0) / nums.length;
+        const stddev = Math.sqrt(variance);
+        const range = Math.max(1e-9, Math.abs(mean) || 1); // avoid div-by-0
+        finalAnswer = mean;
+        agreement = Math.max(0, Math.min(1, 1 - stddev / range));
+    }
+    else {
+        finalAnswer = samples[0];
+        agreement = 1;
+    }
+    return { finalAnswer, samples, agreement, config };
+}
+/**
+ * Canonical-form key for grouping. JSON.stringify is enough for primitives,
+ * arrays, and plain objects with stable key order. Callers wanting locale-
+ * insensitive or shape-aware aggregation should pre-canonicalize their
+ * outputs before calling selfConsistency.
+ */
+function canonicalKey(v) {
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        // Cyclic structures, BigInt, etc.
+        return String(v);
+    }
+}
+// Re-export for callers that need it
+export { random };
+//# sourceMappingURL=self-consistency.js.map

package/vendor/neural/dist/utils/self-consistency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-consistency.js","sourceRoot":"","sources":["../../src/utils/self-consistency.ts"],"names":[],"mappings":"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"}

package/vendor/neural/dist/utils/serialize.d.ts

@@ -0,0 +1,38 @@
+/**
+ * JSON-safe serialization helpers for neural state.
+ *
+ * The package's hot-path types use `Float32Array` and `Map<string, X>` which
+ * don't survive `JSON.stringify` cleanly. These helpers encode/decode them
+ * in a stable shape so SONAManager / ReasoningBank / PatternLearner can
+ * round-trip through `serialize()` → `JSON.stringify` → file → `JSON.parse`
+ * → `deserialize()` without losing precision or structure.
+ *
+ * Encoding:
+ *   Float32Array  ↔ { __f32: number[] }
+ *   Map<K, V>     ↔ { __map: Array<[K, V]> }
+ *
+ * Numbers in Float32Array are stored as plain JS `number` (double precision).
+ * Round-trip is loss-free at single-precision (the values were f32 originally;
+ * widening to f64 then narrowing back is exact for any finite f32).
+ */
+export interface EncodedFloat32Array {
+    __f32: number[];
+}
+export interface EncodedMap<V> {
+    __map: Array<[string, V]>;
+}
+export declare function encodeFloat32Array(arr: Float32Array): EncodedFloat32Array;
+export declare function decodeFloat32Array(encoded: EncodedFloat32Array): Float32Array;
+export declare function isEncodedFloat32Array(v: unknown): v is EncodedFloat32Array;
+export declare function encodeMap<V>(map: Map<string, V>, encodeValue?: (v: V) => unknown): EncodedMap<unknown>;
+export declare function decodeMap<V>(encoded: EncodedMap<unknown>, decodeValue?: (v: unknown) => V): Map<string, V>;
+export declare function isEncodedMap(v: unknown): v is EncodedMap<unknown>;
+/**
+ * Deep walk an object and encode all Float32Array/Map nodes. Useful when
+ * a class's state contains nested f32 arrays in unknown locations (e.g.,
+ * Trajectory.steps[i].stateEmbedding). Skip with caution — the deep walker
+ * is recursive and shouldn't be used on objects with cycles.
+ */
+export declare function deepEncode(value: unknown): unknown;
+export declare function deepDecode(value: unknown): unknown;
+//# sourceMappingURL=serialize.d.ts.map

package/vendor/neural/dist/utils/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/utils/serialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,KAAK,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;CAC3B;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,GAAG,mBAAmB,CAEzE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,YAAY,CAE7E;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,mBAAmB,CAE1E;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,CAMtG;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAM1G;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC,CAEjE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAYlD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAYlD"}

package/vendor/neural/dist/utils/serialize.js

@@ -0,0 +1,82 @@
+/**
+ * JSON-safe serialization helpers for neural state.
+ *
+ * The package's hot-path types use `Float32Array` and `Map<string, X>` which
+ * don't survive `JSON.stringify` cleanly. These helpers encode/decode them
+ * in a stable shape so SONAManager / ReasoningBank / PatternLearner can
+ * round-trip through `serialize()` → `JSON.stringify` → file → `JSON.parse`
+ * → `deserialize()` without losing precision or structure.
+ *
+ * Encoding:
+ *   Float32Array  ↔ { __f32: number[] }
+ *   Map<K, V>     ↔ { __map: Array<[K, V]> }
+ *
+ * Numbers in Float32Array are stored as plain JS `number` (double precision).
+ * Round-trip is loss-free at single-precision (the values were f32 originally;
+ * widening to f64 then narrowing back is exact for any finite f32).
+ */
+export function encodeFloat32Array(arr) {
+    return { __f32: Array.from(arr) };
+}
+export function decodeFloat32Array(encoded) {
+    return new Float32Array(encoded.__f32);
+}
+export function isEncodedFloat32Array(v) {
+    return typeof v === 'object' && v !== null && Array.isArray(v.__f32);
+}
+export function encodeMap(map, encodeValue) {
+    const entries = [];
+    for (const [k, v] of map.entries()) {
+        entries.push([k, encodeValue ? encodeValue(v) : v]);
+    }
+    return { __map: entries };
+}
+export function decodeMap(encoded, decodeValue) {
+    const m = new Map();
+    for (const [k, v] of encoded.__map) {
+        m.set(k, (decodeValue ? decodeValue(v) : v));
+    }
+    return m;
+}
+export function isEncodedMap(v) {
+    return typeof v === 'object' && v !== null && Array.isArray(v.__map);
+}
+/**
+ * Deep walk an object and encode all Float32Array/Map nodes. Useful when
+ * a class's state contains nested f32 arrays in unknown locations (e.g.,
+ * Trajectory.steps[i].stateEmbedding). Skip with caution — the deep walker
+ * is recursive and shouldn't be used on objects with cycles.
+ */
+export function deepEncode(value) {
+    if (value instanceof Float32Array)
+        return encodeFloat32Array(value);
+    if (value instanceof Map) {
+        return encodeMap(value, (v) => deepEncode(v));
+    }
+    if (Array.isArray(value))
+        return value.map((v) => deepEncode(v));
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = deepEncode(v);
+        return out;
+    }
+    return value;
+}
+export function deepDecode(value) {
+    if (isEncodedFloat32Array(value))
+        return decodeFloat32Array(value);
+    if (isEncodedMap(value)) {
+        return decodeMap(value, (v) => deepDecode(v));
+    }
+    if (Array.isArray(value))
+        return value.map((v) => deepDecode(v));
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = deepDecode(v);
+        return out;
+    }
+    return value;
+}
+//# sourceMappingURL=serialize.js.map

package/vendor/neural/dist/utils/serialize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.js","sourceRoot":"","sources":["../../src/utils/serialize.ts"],"names":[],"mappings":"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"}

package/vendor/neural/package.json

@@ -0,0 +1,126 @@
+{
+  "name": "@swarmdo/neural",
+  "version": "3.0.0-alpha.9",
+  "type": "module",
+  "description": "Self-Optimizing Neural Architecture (SONA) for Swarmdo — adaptive learning, trajectory tracking, pattern reuse, 7 RL algorithms (PPO/A2C/DQN/Q-Learning/SARSA/Decision Transformer/Curiosity), Flash Attention, MoE routing, LoRA, EWC++ for continual learning. Reproducible via seedable PRNG; persistence via serialize/deserialize.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "ai-agents",
+    "multi-agent",
+    "multi-agent-systems",
+    "agentic",
+    "agentic-ai",
+    "agentic-systems",
+    "swarmdo",
+    "swarmdo",
+    "claude",
+    "claude-code",
+    "anthropic",
+    "neural",
+    "neural-network",
+    "neural-networks",
+    "sona",
+    "self-optimizing",
+    "self-improving",
+    "adaptive-learning",
+    "continual-learning",
+    "lifelong-learning",
+    "online-learning",
+    "reinforcement-learning",
+    "rl",
+    "deep-rl",
+    "ppo",
+    "proximal-policy-optimization",
+    "dqn",
+    "deep-q-network",
+    "a2c",
+    "advantage-actor-critic",
+    "q-learning",
+    "sarsa",
+    "decision-transformer",
+    "curiosity-driven",
+    "exploration",
+    "policy-gradient",
+    "value-function",
+    "lora",
+    "low-rank-adaptation",
+    "ewc",
+    "elastic-weight-consolidation",
+    "catastrophic-forgetting",
+    "flash-attention",
+    "fast-attention",
+    "mixture-of-experts",
+    "moe",
+    "expert-routing",
+    "trajectory",
+    "trajectory-learning",
+    "experience-replay",
+    "pattern-recognition",
+    "pattern-matching",
+    "pattern-extraction",
+    "pattern-evolution",
+    "reasoning",
+    "reasoning-bank",
+    "reasoning-traces",
+    "self-consistency",
+    "ensemble",
+    "embeddings",
+    "vector-embeddings",
+    "vector-search",
+    "hnsw",
+    "semantic-search",
+    "cosine-similarity",
+    "agentdb",
+    "memory",
+    "knowledge-distillation",
+    "model-compression",
+    "quantization",
+    "fine-tuning",
+    "transfer-learning",
+    "meta-learning",
+    "mcp",
+    "model-context-protocol",
+    "llm",
+    "llm-agents",
+    "agent-orchestration",
+    "agent-coordination",
+    "ml",
+    "machine-learning",
+    "typescript",
+    "esm",
+    "wasm",
+    "open-source"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/SwarmDo/swarmdo",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SwarmDo/swarmdo.git",
+    "directory": "v3/@swarmdo/neural"
+  },
+  "bugs": {
+    "url": "https://github.com/SwarmDo/swarmdo/issues"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@swarmdo/memory": "file:../memory",
+    "@swarmvector/sona": "file:../sona"
+  },
+  "optionalDependencies": {
+    "agentdb": "^2.0.0 || ^3.0.0-alpha.1"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "v3alpha"
+  }
+}

package/vendor/neural/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vendor/rabitq-wasm/README.md

@@ -0,0 +1,129 @@
+# @swarmvector/rabitq-wasm
+
+**RaBitQ 1-bit quantized vector index in WebAssembly.** Compress embeddings 32× and run approximate nearest-neighbor search in the browser, Cloudflare Workers, Deno, or Bun.
+
+[![npm](https://img.shields.io/npm/v/@swarmvector/rabitq-wasm.svg)](https://www.npmjs.com/package/@swarmvector/rabitq-wasm)
+[![License](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue)](the upstream project (see NOTICE)#license)
+
+## What is RaBitQ?
+
+RaBitQ is a rotation-based 1-bit vector quantization scheme that compresses each f32 embedding into a single bit per dimension while preserving rank order under L2 distance. A small "rerank pool" of exact-distance computations on the top candidates restores recall.
+
+For a 768-dimensional embedding (~3 KB raw), RaBitQ stores **96 bytes** of quantized code plus the rotation matrix — a 32× memory reduction. Search runs in two phases:
+
+1. **Hamming-distance scan** over the 1-bit codes — fast, branch-free, ~10× more vectors per cache line than f32.
+2. **Exact L2² rerank** of the top `rerank_factor × k` candidates — restores recall.
+
+The rotation is **deterministic** from `(seed, dim, vectors)`, so the same input always produces bit-identical codes whether you build on x86_64, aarch64, or wasm32.
+
+## Install
+
+```bash
+npm install @swarmvector/rabitq-wasm
+```
+
+## Usage (browser)
+
+```js
+import init, { RabitqIndex } from "@swarmvector/rabitq-wasm";
+
+await init();
+
+const dim = 768;
+const n = 10_000;
+const vectors = new Float32Array(n * dim);
+// ... populate `vectors` with your embeddings (n × dim, row-major) ...
+
+// seed = 42 for reproducibility; rerank_factor = 20 is the typical default
+const idx = RabitqIndex.build(vectors, dim, 42n, 20);
+
+const query = new Float32Array(dim);
+// ... fill query ...
+
+const results = idx.search(query, 10);
+// → [{ id: 7421, distance: 0.0023 }, { id: 9011, distance: 0.0041 }, ...]
+```
+
+## Usage (Node.js / Bun)
+
+```js
+import { RabitqIndex } from "@swarmvector/rabitq-wasm/node/swarmvector_rabitq_wasm.js";
+// no `init()` needed for the node target
+
+const idx = RabitqIndex.build(vectors, 768, 42n, 20);
+const results = idx.search(query, 10);
+```
+
+## Usage (bundlers — Vite, Webpack, Rollup)
+
+```js
+import { RabitqIndex } from "@swarmvector/rabitq-wasm/bundler/swarmvector_rabitq_wasm.js";
+// the bundler handles the .wasm import transparently
+```
+
+## API
+
+### `class RabitqIndex`
+
+#### `RabitqIndex.build(vectors, dim, seed, rerankFactor)`
+
+Build an index from a flat `Float32Array` of length `n * dim`.
+
+| Parameter | Type | Description |
+|---|---|---|
+| `vectors` | `Float32Array` | Row-major matrix of `n` vectors, each of length `dim`. |
+| `dim` | `number` | Vector dimensionality. |
+| `seed` | `bigint` | Random rotation seed. Same `(seed, dim, vectors)` triple → bit-identical codes. |
+| `rerankFactor` | `number` | Multiplier on `k` for the exact-L2² rerank pool. Typical: 20. |
+
+Throws if `dim == 0`, `vectors` is empty, or `vectors.length` is not a multiple of `dim`.
+
+#### `idx.search(query, k)`
+
+Find the `k` nearest neighbors of `query`. Returns an array of `SearchResult` ordered ascending by distance.
+
+#### `idx.len` (getter, number)
+
+Number of vectors indexed.
+
+#### `idx.isEmpty` (getter, boolean)
+
+`true` iff no vectors have been indexed.
+
+### `interface SearchResult`
+
+```ts
+{
+  id: number;       // caller-supplied vector id (its row index in `build`)
+  distance: number; // approximate L2² distance after rerank
+}
+```
+
+### `version()`
+
+Returns the crate version baked at build time.
+
+## Why use this in the browser
+
+- **32× smaller indices.** A 100 K × 768 embedding store is ~9.6 MB instead of ~300 MB — fits comfortably in any browser tab.
+- **Cache-line-friendly hamming scan.** The 1-bit codes pack 64 dimensions into one `u64`, so the hot path runs at memory bandwidth.
+- **Deterministic across architectures.** Builds on your x86_64 build server, runs identically on the user's ARM phone or in a Cloudflare Worker.
+- **No server.** Run RAG, semantic search, or recommendation lookup entirely client-side.
+
+## Sister packages
+
+- [`@swarmvector/acorn-wasm`](https://www.npmjs.com/package/@swarmvector/acorn-wasm) — predicate-agnostic filtered HNSW (when you also need to filter results by metadata).
+- [`@swarmvector/graph-wasm`](https://www.npmjs.com/package/@swarmvector/graph-wasm) — Cypher-compatible hypergraph database in WASM.
+- [`swarmvector`](https://www.npmjs.com/package/swarmvector), [`@swarmvector/core`](https://www.npmjs.com/package/@swarmvector/core) — Node.js NAPI bindings for the full swarmvector engine.
+
+## Source
+
+- **Rust crate**: [`crates/swarmvector-rabitq-wasm/`](the upstream project (see NOTICE))
+- **Algorithm crate**: [`crates/swarmvector-rabitq/`](the upstream project (see NOTICE))
+- **ADR**: [ADR-154 RaBitQ rotation-based 1-bit quantization](the upstream project (see NOTICE))
+- **Packaging ADR**: [ADR-161 — `swarmvector-rabitq-wasm` npm package](the upstream project (see NOTICE))
+- **Repository**: [the upstream project (see NOTICE)](the upstream project (see NOTICE))
+
+## License
+
+MIT OR Apache-2.0

package/vendor/rabitq-wasm/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@swarmvector/rabitq-wasm",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "RaBitQ 1-bit quantized vector index in WebAssembly — 32× embedding compression with high-recall rerank, for browsers, Cloudflare Workers, Deno, and Bun",
+  "main": "swarmvector_rabitq_wasm.js",
+  "types": "swarmvector_rabitq_wasm.d.ts",
+  "module": "swarmvector_rabitq_wasm.js",
+  "sideEffects": [
+    "./snippets/*"
+  ],
+  "keywords": [
+    "rabitq",
+    "vector-search",
+    "ann",
+    "approximate-nearest-neighbor",
+    "quantization",
+    "1-bit-quantization",
+    "embeddings",
+    "wasm",
+    "webassembly",
+    "ai",
+    "machine-learning",
+    "rag",
+    "retrieval-augmented-generation",
+    "semantic-search",
+    "rust",
+    "browser",
+    "edge",
+    "cloudflare-workers"
+  ],
+  "author": "SwarmVector Team",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+the upstream project (see NOTICE)",
+    "directory": "crates/swarmvector-rabitq-wasm"
+  },
+  "homepage": "the upstream project (see NOTICE)#readme",
+  "bugs": {
+    "url": "the upstream project (see NOTICE)"
+  },
+  "files": [
+    "swarmvector_rabitq_wasm_bg.wasm",
+    "swarmvector_rabitq_wasm.js",
+    "swarmvector_rabitq_wasm.d.ts",
+    "swarmvector_rabitq_wasm_bg.wasm.d.ts",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}