warpvector 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,3 +1,598 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "node_modules/eventemitter3/index.js"(exports, module) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+    EventEmitter.prefixed = prefix;
+    EventEmitter.EventEmitter = EventEmitter;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter;
+    }
+  }
+});
+
+// node_modules/p-finally/index.js
+var require_p_finally = __commonJS({
+  "node_modules/p-finally/index.js"(exports, module) {
+    "use strict";
+    module.exports = (promise, onFinally) => {
+      onFinally = onFinally || (() => {
+      });
+      return promise.then(
+        (val) => new Promise((resolve) => {
+          resolve(onFinally());
+        }).then(() => val),
+        (err) => new Promise((resolve) => {
+          resolve(onFinally());
+        }).then(() => {
+          throw err;
+        })
+      );
+    };
+  }
+});
+
+// node_modules/p-timeout/index.js
+var require_p_timeout = __commonJS({
+  "node_modules/p-timeout/index.js"(exports, module) {
+    "use strict";
+    var pFinally = require_p_finally();
+    var TimeoutError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "TimeoutError";
+      }
+    };
+    var pTimeout = (promise, milliseconds, fallback) => new Promise((resolve, reject2) => {
+      if (typeof milliseconds !== "number" || milliseconds < 0) {
+        throw new TypeError("Expected `milliseconds` to be a positive number");
+      }
+      if (milliseconds === Infinity) {
+        resolve(promise);
+        return;
+      }
+      const timer = setTimeout(() => {
+        if (typeof fallback === "function") {
+          try {
+            resolve(fallback());
+          } catch (error) {
+            reject2(error);
+          }
+          return;
+        }
+        const message = typeof fallback === "string" ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
+        const timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message);
+        if (typeof promise.cancel === "function") {
+          promise.cancel();
+        }
+        reject2(timeoutError);
+      }, milliseconds);
+      pFinally(
+        // eslint-disable-next-line promise/prefer-await-to-then
+        promise.then(resolve, reject2),
+        () => {
+          clearTimeout(timer);
+        }
+      );
+    });
+    module.exports = pTimeout;
+    module.exports.default = pTimeout;
+    module.exports.TimeoutError = TimeoutError;
+  }
+});
+
+// node_modules/p-queue/dist/lower-bound.js
+var require_lower_bound = __commonJS({
+  "node_modules/p-queue/dist/lower-bound.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function lowerBound(array, value, comparator) {
+      let first = 0;
+      let count = array.length;
+      while (count > 0) {
+        const step = count / 2 | 0;
+        let it = first + step;
+        if (comparator(array[it], value) <= 0) {
+          first = ++it;
+          count -= step + 1;
+        } else {
+          count = step;
+        }
+      }
+      return first;
+    }
+    exports.default = lowerBound;
+  }
+});
+
+// node_modules/p-queue/dist/priority-queue.js
+var require_priority_queue = __commonJS({
+  "node_modules/p-queue/dist/priority-queue.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var lower_bound_1 = require_lower_bound();
+    var PriorityQueue = class {
+      constructor() {
+        this._queue = [];
+      }
+      enqueue(run, options) {
+        options = Object.assign({ priority: 0 }, options);
+        const element = {
+          priority: options.priority,
+          run
+        };
+        if (this.size && this._queue[this.size - 1].priority >= options.priority) {
+          this._queue.push(element);
+          return;
+        }
+        const index = lower_bound_1.default(this._queue, element, (a, b) => b.priority - a.priority);
+        this._queue.splice(index, 0, element);
+      }
+      dequeue() {
+        const item = this._queue.shift();
+        return item === null || item === void 0 ? void 0 : item.run;
+      }
+      filter(options) {
+        return this._queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+      }
+      get size() {
+        return this._queue.length;
+      }
+    };
+    exports.default = PriorityQueue;
+  }
+});
+
+// node_modules/p-queue/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/p-queue/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var EventEmitter = require_eventemitter3();
+    var p_timeout_1 = require_p_timeout();
+    var priority_queue_1 = require_priority_queue();
+    var empty = () => {
+    };
+    var timeoutError = new p_timeout_1.TimeoutError();
+    var PQueue = class extends EventEmitter {
+      constructor(options) {
+        var _a, _b, _c, _d;
+        super();
+        this._intervalCount = 0;
+        this._intervalEnd = 0;
+        this._pendingCount = 0;
+        this._resolveEmpty = empty;
+        this._resolveIdle = empty;
+        options = Object.assign({ carryoverConcurrencyCount: false, intervalCap: Infinity, interval: 0, concurrency: Infinity, autoStart: true, queueClass: priority_queue_1.default }, options);
+        if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+          throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ""}\` (${typeof options.intervalCap})`);
+        }
+        if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+          throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ""}\` (${typeof options.interval})`);
+        }
+        this._carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+        this._isIntervalIgnored = options.intervalCap === Infinity || options.interval === 0;
+        this._intervalCap = options.intervalCap;
+        this._interval = options.interval;
+        this._queue = new options.queueClass();
+        this._queueClass = options.queueClass;
+        this.concurrency = options.concurrency;
+        this._timeout = options.timeout;
+        this._throwOnTimeout = options.throwOnTimeout === true;
+        this._isPaused = options.autoStart === false;
+      }
+      get _doesIntervalAllowAnother() {
+        return this._isIntervalIgnored || this._intervalCount < this._intervalCap;
+      }
+      get _doesConcurrentAllowAnother() {
+        return this._pendingCount < this._concurrency;
+      }
+      _next() {
+        this._pendingCount--;
+        this._tryToStartAnother();
+        this.emit("next");
+      }
+      _resolvePromises() {
+        this._resolveEmpty();
+        this._resolveEmpty = empty;
+        if (this._pendingCount === 0) {
+          this._resolveIdle();
+          this._resolveIdle = empty;
+          this.emit("idle");
+        }
+      }
+      _onResumeInterval() {
+        this._onInterval();
+        this._initializeIntervalIfNeeded();
+        this._timeoutId = void 0;
+      }
+      _isIntervalPaused() {
+        const now = Date.now();
+        if (this._intervalId === void 0) {
+          const delay = this._intervalEnd - now;
+          if (delay < 0) {
+            this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
+          } else {
+            if (this._timeoutId === void 0) {
+              this._timeoutId = setTimeout(() => {
+                this._onResumeInterval();
+              }, delay);
+            }
+            return true;
+          }
+        }
+        return false;
+      }
+      _tryToStartAnother() {
+        if (this._queue.size === 0) {
+          if (this._intervalId) {
+            clearInterval(this._intervalId);
+          }
+          this._intervalId = void 0;
+          this._resolvePromises();
+          return false;
+        }
+        if (!this._isPaused) {
+          const canInitializeInterval = !this._isIntervalPaused();
+          if (this._doesIntervalAllowAnother && this._doesConcurrentAllowAnother) {
+            const job = this._queue.dequeue();
+            if (!job) {
+              return false;
+            }
+            this.emit("active");
+            job();
+            if (canInitializeInterval) {
+              this._initializeIntervalIfNeeded();
+            }
+            return true;
+          }
+        }
+        return false;
+      }
+      _initializeIntervalIfNeeded() {
+        if (this._isIntervalIgnored || this._intervalId !== void 0) {
+          return;
+        }
+        this._intervalId = setInterval(() => {
+          this._onInterval();
+        }, this._interval);
+        this._intervalEnd = Date.now() + this._interval;
+      }
+      _onInterval() {
+        if (this._intervalCount === 0 && this._pendingCount === 0 && this._intervalId) {
+          clearInterval(this._intervalId);
+          this._intervalId = void 0;
+        }
+        this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
+        this._processQueue();
+      }
+      /**
+      Executes all queued functions until it reaches the limit.
+      */
+      _processQueue() {
+        while (this._tryToStartAnother()) {
+        }
+      }
+      get concurrency() {
+        return this._concurrency;
+      }
+      set concurrency(newConcurrency) {
+        if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+          throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+        }
+        this._concurrency = newConcurrency;
+        this._processQueue();
+      }
+      /**
+      Adds a sync or async task to the queue. Always returns a promise.
+      */
+      async add(fn, options = {}) {
+        return new Promise((resolve, reject2) => {
+          const run = async () => {
+            this._pendingCount++;
+            this._intervalCount++;
+            try {
+              const operation = this._timeout === void 0 && options.timeout === void 0 ? fn() : p_timeout_1.default(Promise.resolve(fn()), options.timeout === void 0 ? this._timeout : options.timeout, () => {
+                if (options.throwOnTimeout === void 0 ? this._throwOnTimeout : options.throwOnTimeout) {
+                  reject2(timeoutError);
+                }
+                return void 0;
+              });
+              resolve(await operation);
+            } catch (error) {
+              reject2(error);
+            }
+            this._next();
+          };
+          this._queue.enqueue(run, options);
+          this._tryToStartAnother();
+          this.emit("add");
+        });
+      }
+      /**
+          Same as `.add()`, but accepts an array of sync or async functions.
+      
+          @returns A promise that resolves when all functions are resolved.
+          */
+      async addAll(functions, options) {
+        return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+      }
+      /**
+      Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+      */
+      start() {
+        if (!this._isPaused) {
+          return this;
+        }
+        this._isPaused = false;
+        this._processQueue();
+        return this;
+      }
+      /**
+      Put queue execution on hold.
+      */
+      pause() {
+        this._isPaused = true;
+      }
+      /**
+      Clear the queue.
+      */
+      clear() {
+        this._queue = new this._queueClass();
+      }
+      /**
+          Can be called multiple times. Useful if you for example add additional items at a later time.
+      
+          @returns A promise that settles when the queue becomes empty.
+          */
+      async onEmpty() {
+        if (this._queue.size === 0) {
+          return;
+        }
+        return new Promise((resolve) => {
+          const existingResolve = this._resolveEmpty;
+          this._resolveEmpty = () => {
+            existingResolve();
+            resolve();
+          };
+        });
+      }
+      /**
+          The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+      
+          @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+          */
+      async onIdle() {
+        if (this._pendingCount === 0 && this._queue.size === 0) {
+          return;
+        }
+        return new Promise((resolve) => {
+          const existingResolve = this._resolveIdle;
+          this._resolveIdle = () => {
+            existingResolve();
+            resolve();
+          };
+        });
+      }
+      /**
+      Size of the queue.
+      */
+      get size() {
+        return this._queue.size;
+      }
+      /**
+          Size of the queue, filtered by the given options.
+      
+          For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+          */
+      sizeBy(options) {
+        return this._queue.filter(options).length;
+      }
+      /**
+      Number of pending promises.
+      */
+      get pending() {
+        return this._pendingCount;
+      }
+      /**
+      Whether the queue is currently paused.
+      */
+      get isPaused() {
+        return this._isPaused;
+      }
+      get timeout() {
+        return this._timeout;
+      }
+      /**
+      Set the timeout for future operations.
+      */
+      set timeout(milliseconds) {
+        this._timeout = milliseconds;
+      }
+    };
+    exports.default = PQueue;
+  }
+});
+
 // src/utils.ts
 function normalize(vector) {
   const dim = vector.length;
@@ -66,6 +661,15 @@ function innerProduct(v1, v2) {
   }
   return dot;
 }
+function addScaledVector(target, source, scale = 1) {
+  const dim = target.length;
+  if (dim !== source.length) {
+    throw new Error("Vectors must have the same dimension.");
+  }
+  for (let i = 0; i < dim; i++) {
+    target[i] += scale * source[i];
+  }
+}
 function cosineSimilarity(v1, v2) {
   const dim = v1.length;
   if (dim !== v2.length) {
@@ -109,7 +713,7 @@ function reject(baseVector, negativeVector) {
   return result;
 }
 function applyActivationToVector(vector, activation) {
-  if (!activation) return;
+  if (!activation || activation === "linear") return;
   const dim = vector.length;
   if (activation === "relu") {
     for (let i = 0; i < dim; i++) {
@@ -162,17 +766,34 @@ function assertDimension(vector, expectedDimension, contextName = "Vector") {
     );
   }
 }
+function getFlatMatrixAndBias(weights, dim, contextName = "Weights") {
+  let flatMatrix;
+  if (weights.matrix instanceof Float32Array) {
+    flatMatrix = new Float32Array(weights.matrix);
+  } else {
+    flatMatrix = flattenMatrix(weights.matrix, dim, dim, contextName);
+  }
+  const bias = new Float32Array(weights.bias);
+  return { flatMatrix, bias };
+}
+function applyAffine(matrix, bias, vector, result, inDim, outDim = inDim) {
+  for (let i = 0; i < outDim; i++) {
+    let sum = bias ? bias[i] : 0;
+    const rowOffset = i * inDim;
+    for (let j = 0; j < inDim; j++) {
+      sum += matrix[rowOffset + j] * vector[j];
+    }
+    result[i] = sum;
+  }
+}
 
 // src/wasm/wasm-binary.ts
-var wasmBase64 = "AGFzbQEAAAABGQJgBn9/f39/fwBgDH9/f39/f319fX9/fwADAwIAAQUDAQAABzADDXR1bmVCYXRjaFdhc20AABNzZ2RNb21lbnR1bVN0ZXBXYXNtAAEGbWVtb3J5AgAK4QMCoAECBX8BfQNAIAUgCEoEQEEAIQYDQCAEIAZKBEBDAAAAACELIAQgBmwhCSAEIAhsIQpBACEHA0AgBCAHSgRAIAsgACAHIAlqQQJ0aioCACACIAcgCmpBAnRqKgIAlJIhCyAHQQFqIQcMAQsLIAMgBCAIbCAGakECdGogCyABIAZBAnRqKgIAkjgCACAGQQFqIQYMAQsLIAhBAWohCAwBCwsLvAICBX8DfQNAIAogDUoEQEMAAAAAIREgCSANbCEPQQAhDANAIAkgDEoEQCARIAAgDCAPakECdGoqAgAgBCAMQQJ0aioCAJSSIREgDEEBaiEMDAELCyANQQJ0IgwgC2ogESABIAxqKgIAkjgCACANQQFqIQ0MAQsLA0AgCiAOSgRAIA5BAnQiDCALaioCACAFIAxqKgIAkyERIAggAyAMaiINKgIAlCAGIBGUkyESIA0gEjgCACABIAxqIgwgDCoCACASkjgCACAJIA5sIQ9BACEMA0AgCSAMSgRAIAwgD2pBAnQiECAAaiINKgIAIRIgCCACIBBqIhAqAgCUIAYgESAEIAxBAnRqKgIAlCAHIBKUkpSTIRMgECATOAIAIA0gEiATkjgCACAMQQFqIQwMAQsLIA5BAWohDgwBCwsL";
+var wasmBase64 = "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";
 
 // src/wasm/wasm-loader.ts
 var wasmInstance = null;
 var wasmMemory = null;
 var initPromise = null;
-function getWasmMemory() {
-  return wasmMemory;
-}
 function getWasmInstance() {
   return wasmInstance;
 }
@@ -205,9 +826,37 @@ function ensureWasmMemory(requiredBytes) {
     return false;
   }
 }
+var globalOffset = 65536;
+function allocateWasmMemory(bytes) {
+  const ptr = globalOffset;
+  globalOffset += bytes;
+  if (globalOffset % 4 !== 0) {
+    globalOffset += 4 - globalOffset % 4;
+  }
+  ensureWasmMemory(globalOffset);
+  return ptr;
+}
+function getWasmAllocatorOffset() {
+  return globalOffset;
+}
+function setWasmAllocatorOffset(offset) {
+  globalOffset = offset;
+}
+function writeFloat32ArrayToWasm(memory, data, byteOffset) {
+  const f32 = new Float32Array(memory.buffer);
+  const floatOffset = byteOffset / 4;
+  if (data instanceof Float32Array) {
+    f32.set(data, floatOffset);
+  } else {
+    for (let i = 0; i < data.length; i++) {
+      f32[floatOffset + i] = data[i];
+    }
+  }
+}
 
 // src/IntentAdapter.ts
-var IntentAdapter = class {
+var IntentAdapter = class _IntentAdapter {
+  weightsMap = /* @__PURE__ */ new Map();
   dimension;
   matrices;
   biases;
@@ -250,6 +899,7 @@ var IntentAdapter = class {
    */
   addIntent(intentName, weights) {
     const { matrix, bias, routingVector } = weights;
+    this.weightsMap.set(intentName, weights);
     assertDimension(bias, this.dimension, `Intent '${intentName}' Bias`);
     let flatMatrix;
     if (matrix instanceof Float32Array) {
@@ -288,27 +938,9 @@ var IntentAdapter = class {
     this.matrices.delete(intentName);
     this.biases.delete(intentName);
     this.routingVectors.delete(intentName);
+    this.weightsMap.delete(intentName);
   }
-  /**
-   * 行列とバイアスを用いてベクトルにアフィン変換を適用する内部関数 (x' = W * x + b)
-   *
-   * @param {Float32Array} matrix - フラット化された変換行列
-   * @param {Float32Array} bias - バイアスベクトル
-   * @param {number[] | Float32Array} vector - 変換元の入力ベクトル
-   * @param {Float32Array} result - 計算結果を格納する配列 (出力先)
-   * @returns {void}
-   */
-  applyAffine(matrix, bias, vector, result) {
-    const dim = this.dimension;
-    for (let i = 0; i < dim; i++) {
-      let sum = 0;
-      const rowOffset = i * dim;
-      for (let j = 0; j < dim; j++) {
-        sum += matrix[rowOffset + j] * vector[j];
-      }
-      result[i] = sum + bias[i];
-    }
-  }
+  // (Private applyAffine was removed in favor of utils.ts applyAffine)
   /**
    * 複数の意図を指定された重みでブレンドした一時的な行列とバイアスを計算します。
    * W_blend = Σ(w_i * W_i), b_blend = Σ(w_i * b_i)
@@ -327,13 +959,8 @@ var IntentAdapter = class {
       if (!matrix || !bias) {
         throw new Error(`Intent '${intentName}' not found during blending.`);
       }
-      for (let i = 0; i < dim; i++) {
-        blendedBias[i] += bias[i] * weight;
-        const rowOffset = i * dim;
-        for (let j = 0; j < dim; j++) {
-          blendedMatrix[rowOffset + j] += matrix[rowOffset + j] * weight;
-        }
-      }
+      addScaledVector(blendedBias, bias, weight);
+      addScaledVector(blendedMatrix, matrix, weight);
     }
     return { matrix: blendedMatrix, bias: blendedBias };
   }
@@ -355,7 +982,7 @@ var IntentAdapter = class {
       throw new Error(`Intent '${intent}' not found.`);
     }
     const result = new Float32Array(this.dimension);
-    this.applyAffine(matrix, bias, baseVector, result);
+    applyAffine(matrix, bias, baseVector, result, this.dimension);
     applyActivationToVector(result, activation);
     return result;
   }
@@ -379,35 +1006,39 @@ var IntentAdapter = class {
     const instance = getWasmInstance();
     const requiredBytes = (this.dimension * this.dimension + this.dimension + batchSize * this.dimension * 2) * 4;
     if (instance && ensureWasmMemory(requiredBytes)) {
-      const wasmMem = getWasmMemory();
-      const f32Mem = new Float32Array(wasmMem.buffer);
+      const memory = instance.exports.memory;
       let ptr = 0;
       const matrixPtr = ptr;
-      f32Mem.set(matrix, ptr);
-      ptr += this.dimension * this.dimension;
+      writeFloat32ArrayToWasm(memory, matrix, ptr);
+      ptr += this.dimension * this.dimension * 4;
       const biasPtr = ptr;
-      f32Mem.set(bias, ptr);
-      ptr += this.dimension;
+      writeFloat32ArrayToWasm(memory, bias, ptr);
+      ptr += this.dimension * 4;
       const vectorsPtr = ptr;
       for (let k = 0; k < batchSize; k++) {
-        f32Mem.set(baseVectors[k], ptr + k * this.dimension);
+        writeFloat32ArrayToWasm(
+          memory,
+          baseVectors[k],
+          ptr + k * this.dimension * 4
+        );
       }
-      ptr += batchSize * this.dimension;
+      ptr += batchSize * this.dimension * 4;
       const resultsPtr = ptr;
       const tuneBatchWasm = instance.exports.tuneBatchWasm;
       tuneBatchWasm(
-        matrixPtr * 4,
-        biasPtr * 4,
-        vectorsPtr * 4,
-        resultsPtr * 4,
+        matrixPtr,
+        biasPtr,
+        vectorsPtr,
+        resultsPtr,
         this.dimension,
         batchSize
       );
       const results2 = new Array(batchSize);
+      const outF32Mem = new Float32Array(memory.buffer);
       for (let k = 0; k < batchSize; k++) {
-        const res = f32Mem.slice(
-          resultsPtr + k * this.dimension,
-          resultsPtr + (k + 1) * this.dimension
+        const res = outF32Mem.slice(
+          resultsPtr / 4 + k * this.dimension,
+          resultsPtr / 4 + (k + 1) * this.dimension
         );
         applyActivationToVector(res, activation);
         results2[k] = res;
@@ -419,7 +1050,7 @@ var IntentAdapter = class {
       const baseVector = baseVectors[k];
       assertDimension(baseVector, this.dimension, `Base vector at index ${k}`);
       const result = new Float32Array(this.dimension);
-      this.applyAffine(matrix, bias, baseVector, result);
+      applyAffine(matrix, bias, baseVector, result, this.dimension);
       applyActivationToVector(result, activation);
       results[k] = result;
     }
@@ -438,7 +1069,7 @@ var IntentAdapter = class {
     assertDimension(baseVector, this.dimension, "Base vector");
     const { matrix, bias } = this.computeBlendedWeights(blendWeights);
     const result = new Float32Array(this.dimension);
-    this.applyAffine(matrix, bias, baseVector, result);
+    applyAffine(matrix, bias, baseVector, result, this.dimension);
     applyActivationToVector(result, activation);
     return result;
   }
@@ -458,35 +1089,39 @@ var IntentAdapter = class {
     const instance = getWasmInstance();
     const requiredBytes = (this.dimension * this.dimension + this.dimension + batchSize * this.dimension * 2) * 4;
     if (instance && ensureWasmMemory(requiredBytes)) {
-      const wasmMem = getWasmMemory();
-      const f32Mem = new Float32Array(wasmMem.buffer);
+      const memory = instance.exports.memory;
       let ptr = 0;
       const matrixPtr = ptr;
-      f32Mem.set(matrix, ptr);
-      ptr += this.dimension * this.dimension;
+      writeFloat32ArrayToWasm(memory, matrix, ptr);
+      ptr += this.dimension * this.dimension * 4;
       const biasPtr = ptr;
-      f32Mem.set(bias, ptr);
-      ptr += this.dimension;
+      writeFloat32ArrayToWasm(memory, bias, ptr);
+      ptr += this.dimension * 4;
       const vectorsPtr = ptr;
       for (let k = 0; k < batchSize; k++) {
-        f32Mem.set(baseVectors[k], ptr + k * this.dimension);
+        writeFloat32ArrayToWasm(
+          memory,
+          baseVectors[k],
+          ptr + k * this.dimension * 4
+        );
       }
-      ptr += batchSize * this.dimension;
+      ptr += batchSize * this.dimension * 4;
       const resultsPtr = ptr;
       const tuneBatchWasm = instance.exports.tuneBatchWasm;
       tuneBatchWasm(
-        matrixPtr * 4,
-        biasPtr * 4,
-        vectorsPtr * 4,
-        resultsPtr * 4,
+        matrixPtr,
+        biasPtr,
+        vectorsPtr,
+        resultsPtr,
         this.dimension,
         batchSize
       );
       const results2 = new Array(batchSize);
+      const outF32Mem = new Float32Array(memory.buffer);
       for (let k = 0; k < batchSize; k++) {
-        const res = f32Mem.slice(
-          resultsPtr + k * this.dimension,
-          resultsPtr + (k + 1) * this.dimension
+        const res = outF32Mem.slice(
+          resultsPtr / 4 + k * this.dimension,
+          resultsPtr / 4 + (k + 1) * this.dimension
         );
         applyActivationToVector(res, activation);
         results2[k] = res;
@@ -498,7 +1133,7 @@ var IntentAdapter = class {
       const baseVector = baseVectors[k];
       assertDimension(baseVector, this.dimension, `Base vector at index ${k}`);
       const result = new Float32Array(this.dimension);
-      this.applyAffine(matrix, bias, baseVector, result);
+      applyAffine(matrix, bias, baseVector, result, this.dimension);
       applyActivationToVector(result, activation);
       results[k] = result;
     }
@@ -629,10 +1264,42 @@ var IntentAdapter = class {
       this.routingVectors.set(intentName, routingVector);
     }
   }
+  /**
+   * 現在の IntentAdapter の全状態（全インテント）を JSON としてシリアライズしてエクスポートします。
+   * (WarpPipeline 等の統合管理用)
+   */
+  exportState() {
+    const intents = {};
+    for (const [name, matrix] of this.matrices.entries()) {
+      const bias = this.biases.get(name);
+      const routing = this.routingVectors.get(name);
+      intents[name] = {
+        matrix: Array.from(matrix),
+        bias: Array.from(bias),
+        routingVector: routing ? Array.from(routing) : void 0
+      };
+    }
+    return JSON.stringify({ dimension: this.dimension, intents });
+  }
+  /**
+   * エクスポートされた JSON 状態から IntentAdapter を復元します。
+   */
+  static importState(stateJson) {
+    const data = JSON.parse(stateJson);
+    const adapter = new _IntentAdapter(data.dimension);
+    for (const [name, intent] of Object.entries(data.intents)) {
+      adapter.addIntent(name, {
+        matrix: new Float32Array(intent.matrix),
+        bias: new Float32Array(intent.bias),
+        routingVector: intent.routingVector ? new Float32Array(intent.routingVector) : void 0
+      });
+    }
+    return adapter;
+  }
 };
 
 // src/LoraIntentAdapter.ts
-var LoraIntentAdapter = class {
+var LoraIntentAdapter = class _LoraIntentAdapter {
   dimension;
   rank;
   // フラット化されたAとBの行列、およびバイアスを保存
@@ -719,30 +1386,114 @@ var LoraIntentAdapter = class {
     }
     const result = new Float32Array(this.dimension);
     const y = new Float32Array(this.rank);
-    for (let i = 0; i < this.rank; i++) {
-      let sum = 0;
-      const rowOffset = i * this.dimension;
-      for (let j = 0; j < this.dimension; j++) {
-        sum += matB[rowOffset + j] * baseVector[j];
+    applyAffine(matB, null, baseVector, y, this.dimension, this.rank);
+    applyAffine(matA, bias, y, result, this.rank, this.dimension);
+    addScaledVector(result, baseVector, 1);
+    return result;
+  }
+  /**
+   * 現在の LoraIntentAdapter の全状態を JSON としてエクスポートします。
+   */
+  exportState() {
+    const intents = {};
+    for (const [name, flatA] of this.matricesA.entries()) {
+      const flatB = this.matricesB.get(name);
+      const bias = this.biases.get(name);
+      intents[name] = {
+        matrixA: Array.from(flatA),
+        // export as flattened for simplicity during import
+        matrixB: Array.from(flatB),
+        bias: Array.from(bias)
+      };
+    }
+    return JSON.stringify({
+      dimension: this.dimension,
+      rank: this.rank,
+      intents
+    });
+  }
+  /**
+   * エクスポートされた JSON 状態から LoraIntentAdapter を復元します。
+   */
+  static importState(stateJson) {
+    const data = JSON.parse(stateJson);
+    const adapter = new _LoraIntentAdapter(data.dimension, data.rank);
+    for (const [name, intent] of Object.entries(data.intents)) {
+      adapter.matricesA.set(name, new Float32Array(intent.matrixA));
+      adapter.matricesB.set(name, new Float32Array(intent.matrixB));
+      adapter.biases.set(name, new Float32Array(intent.bias));
+    }
+    return adapter;
+  }
+};
+
+// src/fusion/rrf.ts
+function rrf(resultSets, k = 60) {
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (const resultSet of resultSets) {
+    for (let i = 0; i < resultSet.length; i++) {
+      const item = resultSet[i];
+      const rank = item.rank !== void 0 ? item.rank : i + 1;
+      const rrfScore = 1 / (k + rank);
+      if (scoreMap.has(item.id)) {
+        const existing = scoreMap.get(item.id);
+        existing.score += rrfScore;
+        existing.metadata = { ...existing.metadata, ...item.metadata };
+      } else {
+        scoreMap.set(item.id, {
+          id: item.id,
+          score: rrfScore,
+          metadata: item.metadata
+        });
       }
-      y[i] = sum;
     }
-    for (let i = 0; i < this.dimension; i++) {
-      let sum = 0;
-      const rowOffset = i * this.rank;
-      for (let j = 0; j < this.rank; j++) {
-        sum += matA[rowOffset + j] * y[j];
+  }
+  return Array.from(scoreMap.values()).sort((a, b) => b.score - a.score);
+}
+
+// src/fusion/rsf.ts
+function rsf(resultSets, weights) {
+  if (weights && weights.length !== resultSets.length) {
+    throw new Error("Weights array length must match resultSets length");
+  }
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (let sIdx = 0; sIdx < resultSets.length; sIdx++) {
+    const resultSet = resultSets[sIdx];
+    const weight = weights ? weights[sIdx] : 1;
+    if (resultSet.length === 0) continue;
+    let min = Infinity;
+    let max = -Infinity;
+    for (const item of resultSet) {
+      const score = item.score !== void 0 ? item.score : 0;
+      if (score < min) min = score;
+      if (score > max) max = score;
+    }
+    const range = max - min;
+    for (const item of resultSet) {
+      const score = item.score !== void 0 ? item.score : 0;
+      const normalizedScore = range === 0 ? 1 : (score - min) / range;
+      const weightedScore = normalizedScore * weight;
+      if (scoreMap.has(item.id)) {
+        const existing = scoreMap.get(item.id);
+        existing.score += weightedScore;
+        existing.metadata = { ...existing.metadata, ...item.metadata };
+      } else {
+        scoreMap.set(item.id, {
+          id: item.id,
+          score: weightedScore,
+          metadata: item.metadata
+        });
       }
-      result[i] = baseVector[i] + sum + bias[i];
     }
-    return result;
   }
-};
+  return Array.from(scoreMap.values()).sort((a, b) => b.score - a.score);
+}
 
 // src/ProjectionAdapter.ts
-var ProjectionAdapter = class {
+var ProjectionAdapter = class _ProjectionAdapter {
   inDimension;
   outDimension;
+  wasmInstance = null;
   // フラット化された射影行列とバイアスを保存
   matrices;
   biases;
@@ -804,112 +1555,1340 @@ var ProjectionAdapter = class {
     this.biases.delete(name);
   }
   /**
-   * ベクトルに射影変換を適用し、次元を変更した新しいベクトルを返します。
-   * 数式: y = W * x
+   * ベクトルの次元削減（射影）を実行します。
+   * (WarpAdapter の実装として project の代わりに tune を提供します)
    *
-   * @param {number[] | Float32Array} baseVector - 変換元の入力ベクトル
-   * @param {string} projectionName - 適用する射影設定の名前
-   * @returns {Float32Array} 射影変換適用後の新しいベクトル
-   * @throws {Error} ベクトルの次元数が inDimension と一致しない場合、または射影設定が存在しない場合にエラーをスローします。
-   */
-  project(baseVector, projectionName) {
-    assertDimension(baseVector, this.inDimension, "Base vector");
-    const matrix = this.matrices.get(projectionName);
+   * @param vector 変換前のベクトル (例: 1536次元)
+   * @param version 適用する変換バージョンの識別子 (オプション)
+   * @returns 変換後のベクトル (例: 512次元)
+   */
+  tune(vector, version = "default") {
+    assertDimension(vector, this.inDimension, "Base vector");
+    const matrix = this.matrices.get(version);
+    const bias = this.biases.get(version);
     if (!matrix) {
-      throw new Error(`Projection '${projectionName}' not found.`);
+      throw new Error(`Projection '${version}' not found.`);
     }
-    const result = new Float32Array(this.outDimension);
-    const bias = this.biases.get(projectionName);
-    for (let i = 0; i < this.outDimension; i++) {
-      let sum = bias ? bias[i] : 0;
-      const rowOffset = i * this.inDimension;
-      for (let j = 0; j < this.inDimension; j++) {
-        sum += matrix[rowOffset + j] * baseVector[j];
+    const instance = getWasmInstance();
+    const matrixSize = this.inDimension * this.outDimension * 4;
+    const biasSize = bias ? this.outDimension * 4 : 0;
+    const vectorSize = this.inDimension * 4;
+    const outputSize = this.outDimension * 4;
+    const requiredBytes = matrixSize + biasSize + vectorSize + outputSize;
+    if (instance && instance.exports.projectWasm && ensureWasmMemory(requiredBytes)) {
+      const memory = instance.exports.memory;
+      let offset = 0;
+      const matrixPtr = offset;
+      offset += matrixSize;
+      const biasPtr = bias ? offset : 0;
+      if (bias) offset += biasSize;
+      const inputPtr = offset;
+      offset += vectorSize;
+      const outputPtr = offset;
+      offset += outputSize;
+      writeFloat32ArrayToWasm(memory, matrix, matrixPtr);
+      if (bias) writeFloat32ArrayToWasm(memory, bias, biasPtr);
+      writeFloat32ArrayToWasm(memory, vector, inputPtr);
+      const projectWasm = instance.exports.projectWasm;
+      projectWasm(
+        matrixPtr,
+        biasPtr,
+        inputPtr,
+        outputPtr,
+        this.inDimension,
+        this.outDimension
+      );
+      const result2 = new Float32Array(this.outDimension);
+      const outF32 = new Float32Array(memory.buffer);
+      const outIdx = outputPtr / 4;
+      for (let i = 0; i < this.outDimension; i++) {
+        result2[i] = outF32[outIdx + i];
       }
-      result[i] = sum;
+      return result2;
     }
+    const result = new Float32Array(this.outDimension);
+    applyAffine(
+      matrix,
+      bias,
+      vector,
+      result,
+      this.inDimension,
+      this.outDimension
+    );
     return result;
   }
-};
-
-// src/BaseTrainer.ts
-var BaseTrainer = class {
-  /** 学習用サンプルの配列 */
-  examples = [];
   /**
-   * 学習用のサンプルデータを追加します。
-   * 次元数がソース/ターゲットと一致しない場合はエラーとなります。
-   *
-   * @param {TExample} example 追加するサンプルデータ
-   * @throws {Error} 次元数が一致しない場合にスローされます。
+   * 現在の射影行列の状態をシリアライズしてエクスポートします。
    */
-  addExample(example) {
-    const { source, target } = this.getInputs(example);
-    if (source.length !== this.sourceDimension) {
-      throw new Error(
-        `Source dimension mismatch. Expected ${this.sourceDimension}.`
-      );
+  exportState() {
+    const projections = {};
+    for (const [name, matrix] of this.matrices.entries()) {
+      const bias = this.biases.get(name);
+      projections[name] = {
+        matrix: Array.from(matrix),
+        bias: bias ? Array.from(bias) : void 0
+      };
     }
-    if (target.length !== this.targetDimension) {
-      throw new Error(
-        `Target dimension mismatch. Expected ${this.targetDimension}.`
-      );
-    }
-    this.examples.push(example);
+    return JSON.stringify({
+      inDimension: this.inDimension,
+      outDimension: this.outDimension,
+      projections
+    });
   }
   /**
-   * 追加されたサンプルデータを用いて学習を実行します。
-   * 指定されたエポック数だけ SGD + Momentum によるパラメータ更新を行います。
-   * パフォーマンスのため、可能であれば内部で WebAssembly (WASM) を使用します。
-   *
-   * @param {BaseTrainingOptions} [options={}] 学習のハイパーパラメータオプション
-   * @returns {Promise<TResult>} 学習済みの重みを返します。
-   * @throws {Error} サンプルデータが追加されていない場合にスローされます。
+   * エクスポートされた状態から ProjectionAdapter を復元します。
+   * 注意: 保存されている matrix は既にフラット化された 1D 配列であることを前提としています。
    */
-  async train(options = {}) {
-    await initWasm();
-    if (this.examples.length === 0) {
-      throw new Error("No training examples provided.");
+  static importState(stateJson) {
+    const data = JSON.parse(stateJson);
+    const adapter = new _ProjectionAdapter(data.inDimension, data.outDimension);
+    for (const [name, proj] of Object.entries(data.projections)) {
+      adapter.matrices.set(name, new Float32Array(proj.matrix));
+      if (proj.bias) {
+        adapter.biases.set(name, new Float32Array(proj.bias));
+      }
     }
-    if (options.autoTune) {
-      options.learningRate = this.findBestLearningRate(options);
-      options.autoTune = false;
+    return adapter;
+  }
+};
+
+// src/MlpAdapter.ts
+function getActivationId(activation) {
+  switch (activation) {
+    case "linear":
+      return 0;
+    case "relu":
+      return 1;
+    case "sigmoid":
+      return 2;
+    case "tanh":
+      return 3;
+    default:
+      return 0;
+  }
+}
+var MlpAdapter = class _MlpAdapter {
+  layers;
+  wasmInstance = null;
+  // WASMのポインタと設定値
+  isWasmReady = false;
+  inputDim = 0;
+  outputDim = 0;
+  numLayers = 0;
+  inputPtr = 0;
+  outputPtr = 0;
+  weightsPtr = 0;
+  layerDimsPtr = 0;
+  activationsPtr = 0;
+  bufferPtr = 0;
+  bufBPtr = 0;
+  constructor(layers) {
+    if (layers.length === 0) {
+      throw new Error("MlpAdapter requires at least one layer.");
     }
-    const lr = options.learningRate ?? 0.01;
-    const epochs = options.epochs ?? 100;
-    const reg = options.regularization ?? 1e-3;
-    const momentum = options.momentum ?? 0.9;
-    const sDim = this.sourceDimension;
-    const tDim = this.targetDimension;
-    const flatMatrix = new Float32Array(tDim * sDim);
-    for (let i = 0; i < tDim; i++) {
-      if (i < sDim) {
-        flatMatrix[i * sDim + i] = 1;
-      }
+    this.layers = layers;
+    this.numLayers = layers.length;
+  }
+  /**
+   * WASMの初期化と、MLP構造をWASMメモリに書き込む準備を行います。
+   * インスタンス作成後に必ず呼び出してください。
+   */
+  async init() {
+    this.wasmInstance = await initWasm();
+    if (!this.wasmInstance) {
+      throw new Error("Failed to initialize WASM for MlpAdapter.");
     }
-    const bias = new Float32Array(tDim);
-    const vMatrix = new Float32Array(tDim * sDim);
-    const vBias = new Float32Array(tDim);
-    for (let epoch = 0; epoch < epochs; epoch++) {
-      for (const example of this.examples) {
-        const { source, target } = this.getInputs(example);
-        this.sgdMomentumStep(
-          flatMatrix,
-          bias,
-          vMatrix,
-          vBias,
-          source,
-          target,
-          lr,
-          reg,
-          momentum
+    const memory = this.wasmInstance.exports.memory;
+    let sDim = 0;
+    let tDim = 0;
+    let maxDim = 0;
+    let totalWeights = 0;
+    const layerDims = [];
+    const activations = [];
+    for (let i = 0; i < this.layers.length; i++) {
+      const layer = this.layers[i];
+      let rows, cols;
+      if (layer.matrix instanceof Float32Array) {
+        rows = layer.bias.length;
+        cols = layer.matrix.length / rows;
+      } else {
+        rows = layer.matrix.length;
+        cols = layer.matrix[0].length;
+      }
+      if (i === 0) {
+        sDim = cols;
+        layerDims.push(sDim);
+      } else if (cols !== tDim) {
+        throw new Error(
+          `Dimension mismatch at layer ${i}: expected input dim ${tDim}, got ${cols}`
         );
       }
+      tDim = rows;
+      layerDims.push(tDim);
+      if (sDim > maxDim) maxDim = sDim;
+      if (tDim > maxDim) maxDim = tDim;
+      totalWeights += rows * cols + rows;
+      activations.push(getActivationId(layer.activation));
     }
-    return this.toWeights(flatMatrix, bias);
+    this.inputDim = layerDims[0];
+    this.outputDim = layerDims[layerDims.length - 1];
+    this.inputPtr = allocateWasmMemory(this.inputDim * 4);
+    this.outputPtr = allocateWasmMemory(this.outputDim * 4);
+    this.layerDimsPtr = allocateWasmMemory((this.numLayers + 1) * 4);
+    this.activationsPtr = allocateWasmMemory(this.numLayers * 4);
+    this.weightsPtr = allocateWasmMemory(totalWeights * 4);
+    this.bufferPtr = allocateWasmMemory(maxDim * 4);
+    this.bufBPtr = allocateWasmMemory(maxDim * 4);
+    const memoryBuffer = memory.buffer;
+    const f32 = new Float32Array(memoryBuffer);
+    const i32 = new Int32Array(memoryBuffer);
+    for (let i = 0; i < layerDims.length; i++) {
+      i32[this.layerDimsPtr / 4 + i] = layerDims[i];
+    }
+    for (let i = 0; i < activations.length; i++) {
+      i32[this.activationsPtr / 4 + i] = activations[i];
+    }
+    let wIdx = this.weightsPtr / 4;
+    for (let i = 0; i < this.numLayers; i++) {
+      const layer = this.layers[i];
+      let rows, cols;
+      if (layer.matrix instanceof Float32Array) {
+        rows = layer.bias.length;
+        cols = layer.matrix.length / rows;
+        for (let r = 0; r < rows; r++) {
+          for (let c = 0; c < cols; c++) {
+            f32[wIdx++] = layer.matrix[r * cols + c];
+          }
+          f32[wIdx++] = layer.bias[r];
+        }
+      } else {
+        rows = layer.matrix.length;
+        cols = layer.matrix[0].length;
+        for (let r = 0; r < rows; r++) {
+          for (let c = 0; c < cols; c++) {
+            f32[wIdx++] = layer.matrix[r][c];
+          }
+          f32[wIdx++] = layer.bias[r];
+        }
+      }
+    }
+    this.isWasmReady = true;
   }
   /**
-   * サンプルデータに対する短時間のテストランを行い、最も損失(Loss)が小さくなる最適な学習率を自動探索します。
+   * ニューラルネットワークの順伝播を実行し、結果を返します。
+   * (WarpAdapter の実装として、predict の代わりに tune を提供します)
+   *
+   * @param input 入力ベクトル
+   * @returns 推論結果ベクトル
+   */
+  tune(input) {
+    if (!this.isWasmReady || !this.wasmInstance) {
+      throw new Error(
+        "MlpAdapter is not initialized. Call await init() first."
+      );
+    }
+    assertDimension(input, this.inputDim, "MlpAdapter.tune");
+    const memory = this.wasmInstance.exports.memory;
+    writeFloat32ArrayToWasm(memory, input, this.inputPtr);
+    const mlpInferenceWasm = this.wasmInstance.exports.mlpInferenceWasm;
+    mlpInferenceWasm(
+      this.inputPtr,
+      this.outputPtr,
+      this.weightsPtr,
+      this.layerDimsPtr,
+      this.activationsPtr,
+      this.numLayers,
+      this.bufferPtr,
+      this.bufBPtr
+    );
+    const result = new Float32Array(this.outputDim);
+    const outF32 = new Float32Array(memory.buffer);
+    const outIdx = this.outputPtr / 4;
+    for (let i = 0; i < this.outputDim; i++) {
+      result[i] = outF32[outIdx + i];
+    }
+    return result;
+  }
+  /**
+   * 現在のMLP構造と重みをシリアライズして出力します。
+   */
+  exportState() {
+    return JSON.stringify({
+      layers: this.layers.map((layer) => {
+        let matrix;
+        if (layer.matrix instanceof Float32Array) {
+          matrix = Array.from(layer.matrix);
+        } else {
+          matrix = layer.matrix;
+        }
+        return {
+          matrix,
+          bias: Array.from(layer.bias),
+          activation: layer.activation
+        };
+      })
+    });
+  }
+  /**
+   * シリアライズされた状態から MlpAdapter を復元します。
+   * 注意: 復元後、再度 `await init()` を呼び出してWASMメモリを初期化する必要があります。
+   */
+  static importState(stateJson) {
+    const data = JSON.parse(stateJson);
+    const layers = data.layers.map((l) => ({
+      // Float32Array に戻すか、そのまま2D配列として扱う
+      matrix: Array.isArray(l.matrix[0]) ? l.matrix : new Float32Array(l.matrix),
+      bias: new Float32Array(l.bias),
+      activation: l.activation
+    }));
+    return new _MlpAdapter(layers);
+  }
+};
+
+// src/WhiteningAdapter.ts
+var WhiteningAdapter = class _WhiteningAdapter {
+  dim;
+  mean;
+  components;
+  count = 0;
+  learningRate;
+  numComponents;
+  componentsPtr = 0;
+  xResidualPtr = 0;
+  isWasmReady = false;
+  async init() {
+    const instance = await initWasm();
+    if (instance) {
+      const componentsSize = this.numComponents * this.dim * 4;
+      const xResidualSize = this.dim * 4;
+      this.componentsPtr = allocateWasmMemory(componentsSize);
+      this.xResidualPtr = allocateWasmMemory(xResidualSize);
+      this.isWasmReady = true;
+    }
+  }
+  /**
+   * 新しい WhiteningAdapter を作成します。
+   * @param dim ベクトルの次元数
+   * @param config 設定オプション
+   */
+  constructor(dim, config = {}) {
+    this.dim = dim;
+    this.learningRate = config.learningRate ?? 0.01;
+    this.numComponents = config.numComponents ?? 1;
+    this.mean = new Float32Array(dim);
+    this.components = [];
+    for (let k = 0; k < this.numComponents; k++) {
+      const pc = new Float32Array(dim);
+      for (let i = 0; i < dim; i++) {
+        pc[i] = Math.random() * 2 - 1;
+      }
+      this.components.push(normalize(pc));
+    }
+  }
+  /**
+   * 入力ベクトルを用いて、平均と主成分をオンライン更新します。
+   * (Oja's Rule + Generalized Hebbian Algorithm)
+   *
+   * @param vector 学習用の入力ベクトル
+   */
+  update(vector) {
+    assertDimension(vector, this.dim, "WhiteningAdapter.update");
+    if (this.count === 0) {
+      for (let i = 0; i < this.dim; i++) {
+        this.mean[i] = vector[i];
+      }
+    } else {
+      for (let i = 0; i < this.dim; i++) {
+        this.mean[i] = (1 - this.learningRate) * this.mean[i] + this.learningRate * vector[i];
+      }
+    }
+    this.count++;
+    const x = new Float32Array(this.dim);
+    for (let i = 0; i < this.dim; i++) {
+      x[i] = vector[i] - this.mean[i];
+    }
+    const x_residual = new Float32Array(x);
+    const instance = getWasmInstance();
+    if (instance && instance.exports.sangerUpdateWasm) {
+      if (!this.isWasmReady) {
+        const componentsSize = this.numComponents * this.dim * 4;
+        const xResidualSize = this.dim * 4;
+        this.componentsPtr = allocateWasmMemory(componentsSize);
+        this.xResidualPtr = allocateWasmMemory(xResidualSize);
+        this.isWasmReady = true;
+      }
+      const memory = instance.exports.memory;
+      const componentsPtr = this.componentsPtr;
+      const xResidualPtr = this.xResidualPtr;
+      const f32 = new Float32Array(memory.buffer);
+      for (let k = 0; k < this.numComponents; k++) {
+        const comp = this.components[k];
+        for (let i = 0; i < this.dim; i++) {
+          f32[componentsPtr / 4 + k * this.dim + i] = comp[i];
+        }
+      }
+      writeFloat32ArrayToWasm(memory, x_residual, xResidualPtr);
+      const sangerUpdateWasm = instance.exports.sangerUpdateWasm;
+      sangerUpdateWasm(
+        componentsPtr,
+        xResidualPtr,
+        this.dim,
+        this.numComponents,
+        this.learningRate
+      );
+      for (let k = 0; k < this.numComponents; k++) {
+        for (let i = 0; i < this.dim; i++) {
+          this.components[k][i] = f32[componentsPtr / 4 + k * this.dim + i];
+        }
+      }
+    } else {
+      for (let k = 0; k < this.numComponents; k++) {
+        const w = this.components[k];
+        let y = innerProduct(w, x_residual);
+        addScaledVector(w, x_residual, this.learningRate * y);
+        addScaledVector(w, w, -this.learningRate * y * y);
+        this.components[k] = normalize(w);
+        addScaledVector(x_residual, this.components[k], -y);
+      }
+    }
+  }
+  /**
+   * 推論 (Whitening の適用):
+   * 入力ベクトルから平均を引き、偏りの原因である上位主成分を除去します (All-but-the-Top)。
+   *
+   * @param vector 推論・補正対象のベクトル
+   * @returns 等方化・ゼロセンタリングされた新しいベクトル
+   */
+  tune(vector) {
+    assertDimension(vector, this.dim, "WhiteningAdapter.tune");
+    let result = new Float32Array(this.dim);
+    for (let i = 0; i < this.dim; i++) {
+      result[i] = vector[i] - this.mean[i];
+    }
+    for (let k = 0; k < this.numComponents; k++) {
+      const w = this.components[k];
+      let dot = innerProduct(result, w);
+      addScaledVector(result, w, -dot);
+    }
+    return result;
+  }
+  /**
+   * 現在の学習状態（平均ベクトル、主成分ベクトルなど）をシリアライズして出力します。
+   * エッジ環境でのインスタンス再構築時に役立ちます。
+   */
+  exportState() {
+    return JSON.stringify({
+      dim: this.dim,
+      count: this.count,
+      learningRate: this.learningRate,
+      numComponents: this.numComponents,
+      mean: Array.from(this.mean),
+      components: this.components.map((c) => Array.from(c))
+    });
+  }
+  /**
+   * シリアライズされた学習状態から WhiteningAdapter を復元します。
+   */
+  static importState(stateJson) {
+    const data = JSON.parse(stateJson);
+    const adapter = new _WhiteningAdapter(data.dim, {
+      learningRate: data.learningRate,
+      numComponents: data.numComponents
+    });
+    adapter.count = data.count;
+    adapter.mean = new Float32Array(data.mean);
+    adapter.components = data.components.map(
+      (c) => new Float32Array(c)
+    );
+    return adapter;
+  }
+};
+
+// src/ColbertAdapter.ts
+var ColbertAdapter = class {
+  wasm;
+  constructor() {
+    this.wasm = getWasmInstance();
+  }
+  /**
+   * 単一のクエリと単一のドキュメント間の Late Interaction (MaxSim) スコアを計算します。
+   *
+   * @param queryTokens クエリのトークンベクトル行列 (要素数 = queryLength * dim の平坦化された配列)
+   * @param documentTokens ドキュメントのトークンベクトル行列
+   * @param dim ベクトルの次元数
+   * @returns MaxSimスコア
+   */
+  score(queryTokens, documentTokens, dim) {
+    const numQueryTokens = queryTokens.length / dim;
+    const numDocTokens = documentTokens.length / dim;
+    if (numQueryTokens % 1 !== 0) {
+      throw new Error(
+        `Invalid queryTokens length. Must be a multiple of dim (${dim})`
+      );
+    }
+    if (numDocTokens % 1 !== 0) {
+      throw new Error(
+        `Invalid documentTokens length. Must be a multiple of dim (${dim})`
+      );
+    }
+    const { memory, colbertMaxSimWasm } = this.wasm.exports;
+    const queryBytes = queryTokens.byteLength;
+    const docBytes = documentTokens.byteLength;
+    const initialOffset = getWasmAllocatorOffset();
+    try {
+      const queryPtr = allocateWasmMemory(queryBytes);
+      const docPtr = allocateWasmMemory(docBytes);
+      writeFloat32ArrayToWasm(memory, queryTokens, queryPtr);
+      writeFloat32ArrayToWasm(memory, documentTokens, docPtr);
+      return colbertMaxSimWasm(
+        queryPtr,
+        docPtr,
+        numQueryTokens,
+        numDocTokens,
+        dim
+      );
+    } finally {
+      setWasmAllocatorOffset(initialOffset);
+    }
+  }
+  /**
+   * クエリと複数のドキュメント間の MaxSim スコアを計算し、スコアの降順にソートして返します。
+   *
+   * @param queryTokens クエリのトークンベクトル行列
+   * @param documentTokensArray ドキュメントのトークンベクトル行列の配列
+   * @param dim ベクトルの次元数
+   * @returns スコアの降順にソートされたドキュメントのインデックスとスコアの配列
+   */
+  rank(queryTokens, documentTokensArray, dim) {
+    const numQueryTokens = queryTokens.length / dim;
+    if (numQueryTokens % 1 !== 0) {
+      throw new Error(
+        `Invalid queryTokens length. Must be a multiple of dim (${dim})`
+      );
+    }
+    const { memory, colbertMaxSimWasm } = this.wasm.exports;
+    let maxDocLen = 0;
+    for (const doc of documentTokensArray) {
+      if (doc.length > maxDocLen) maxDocLen = doc.length;
+    }
+    const queryBytes = queryTokens.byteLength;
+    const maxDocBytes = maxDocLen * Float32Array.BYTES_PER_ELEMENT;
+    const initialOffset = getWasmAllocatorOffset();
+    try {
+      const queryPtr = allocateWasmMemory(queryBytes);
+      const docPtr = allocateWasmMemory(maxDocBytes);
+      writeFloat32ArrayToWasm(memory, queryTokens, queryPtr);
+      const results = documentTokensArray.map((doc, index) => {
+        const numDocTokens = doc.length / dim;
+        if (numDocTokens % 1 !== 0) {
+          throw new Error(`Invalid documentTokens length at index ${index}`);
+        }
+        writeFloat32ArrayToWasm(memory, doc, docPtr);
+        const score = colbertMaxSimWasm(
+          queryPtr,
+          docPtr,
+          numQueryTokens,
+          numDocTokens,
+          dim
+        );
+        return { index, score };
+      });
+      return results.sort((a, b) => b.score - a.score);
+    } finally {
+      setWasmAllocatorOffset(initialOffset);
+    }
+  }
+};
+
+// src/integrations/prisma.ts
+import { Prisma } from "@prisma/client/extension";
+
+// src/db.ts
+var VectorDBAdapter = class {
+  /**
+   * PostgreSQL (pgvector) 用のクエリ文字列表現を生成します。
+   * INSERT や SELECT の際に使用できる形式です。
+   *
+   * @example
+   * const sql = `SELECT * FROM items ORDER BY embedding <-> '${VectorDBAdapter.toPgvector(warpedVector)}' LIMIT 5`;
+   *
+   * @param {number[] | Float32Array} vector ワープ変換後のベクトル
+   * @returns {string} `'[0.1, 0.2, 0.3]'` のような文字列表現
+   */
+  static toPgvector(vector) {
+    if (vector instanceof Uint8Array) {
+      let bitString = "";
+      for (let i = 0; i < vector.length; i++) {
+        bitString += vector[i].toString(2).padStart(8, "0");
+      }
+      return bitString;
+    }
+    return `[${Array.from(vector).join(", ")}]`;
+  }
+  /**
+   * Pinecone 用のクエリオブジェクトを生成します。
+   * Pinecone クライアントに直接渡せる形式のオブジェクトを返します。
+   *
+   * @example
+   * const query = VectorDBAdapter.toPineconeQuery(warpedVector, 10, { genre: "comedy" });
+   * await index.query(query);
+   *
+   * @param {number[] | Float32Array} vector 検索クエリベクトル
+   * @param {number} topK 取得する件数 (デフォルト: 10)
+   * @param {Record<string, any>} [filter] メタデータフィルタ（オプション）
+   * @returns {Record<string, any>} Pineconeのqueryメソッド用オブジェクト
+   */
+  static toPineconeQuery(vector, topK = 10, filter) {
+    return {
+      vector: Array.from(vector),
+      topK,
+      ...filter ? { filter } : {}
+    };
+  }
+  /**
+   * Redis (RediSearch) のベクトルフィールド用に、
+   * Float32Array をバイナリ（Uint8Array）に変換します。
+   * Node.js環境では Buffer.from() を使って Buffer に変換して渡してください。
+   *
+   * @example
+   * const blob = Buffer.from(VectorDBAdapter.toRedis(warpedVector));
+   * await redis.call('FT.SEARCH', 'idx', '*=>[KNN 5 @embedding $BLOB]', 'PARAMS', '2', 'BLOB', blob, 'DIALECT', '2');
+   *
+   * @param {number[] | Float32Array} vector ワープ変換後のベクトル
+   * @returns {Uint8Array} バイナリデータ (Float32のバイト表現)
+   */
+  static toRedis(vector) {
+    const f32Array = vector instanceof Float32Array ? vector : new Float32Array(Array.from(vector));
+    return new Uint8Array(
+      f32Array.buffer.slice(
+        f32Array.byteOffset,
+        f32Array.byteOffset + f32Array.byteLength
+      )
+    );
+  }
+};
+
+// src/integrations/prisma.ts
+var withWarpVector = (config) => {
+  const vectorField = config.vectorField ?? "embedding";
+  const distanceOp = config.distanceOperator ?? "<->";
+  return Prisma.defineExtension((client) => {
+    return client.$extends({
+      name: "warpvector",
+      model: {
+        $allModels: {
+          /**
+           * 生のベクトルを受け取り、WarpVectorで変換した後に pgvector 検索を行います。
+           *
+           * @param args.vector 生のベクトル (変換前)
+           * @param args.topK 取得する最大件数 (デフォルト: 10)
+           * @param args.where 追加のフィルタリング条件 (例: "category = 'science'")
+           */
+          async searchByVector(args) {
+            const context = Prisma.getExtensionContext(this);
+            const tableName = context.$name || "document";
+            if (!/^[a-zA-Z0-9_]+$/.test(tableName)) {
+              throw new Error(`Invalid table name: ${tableName}`);
+            }
+            if (!/^[a-zA-Z0-9_]+$/.test(vectorField)) {
+              throw new Error(`Invalid vector field name: ${vectorField}`);
+            }
+            if (!["<->", "<#>", "<=>"].includes(distanceOp)) {
+              throw new Error(`Invalid distance operator: ${distanceOp}`);
+            }
+            let whereClause = "";
+            if (args.where) {
+              const trimmedWhere = args.where.trim();
+              if (/;|--|\/\*/.test(trimmedWhere)) {
+                throw new Error("Potential SQL injection detected in where clause.");
+              }
+              whereClause = `WHERE ${trimmedWhere}`;
+            }
+            const limit = args.topK ?? 10;
+            if (typeof limit !== "number" || isNaN(limit) || limit < 0) {
+              throw new Error("Invalid topK value.");
+            }
+            const tunedVector = config.adapter.tune(args.vector);
+            const pgVectorStr = VectorDBAdapter.toPgvector(tunedVector);
+            const sql = `
+              SELECT *
+              FROM "${tableName}"
+              ${whereClause}
+              ORDER BY "${vectorField}" ${distanceOp} '${pgVectorStr}'::vector
+              LIMIT ${limit};
+            `.trim();
+            return client.$queryRawUnsafe(sql);
+          }
+        }
+      }
+    });
+  });
+};
+
+// node_modules/@langchain/core/dist/utils/signal.js
+function getAbortSignalError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  if (typeof signal?.reason === "string") return new Error(signal.reason);
+  return /* @__PURE__ */ new Error("Aborted");
+}
+
+// node_modules/@langchain/core/dist/utils/is-network-error/index.js
+var objectToString = Object.prototype.toString;
+var isError = (value) => objectToString.call(value) === "[object Error]";
+var errorMessages = /* @__PURE__ */ new Set([
+  "network error",
+  "Failed to fetch",
+  "NetworkError when attempting to fetch resource.",
+  "The Internet connection appears to be offline.",
+  "Network request failed",
+  "fetch failed",
+  "terminated",
+  " A network error occurred.",
+  "Network connection lost"
+]);
+function isNetworkError(error) {
+  if (!(error && isError(error) && error.name === "TypeError" && typeof error.message === "string")) return false;
+  const { message, stack } = error;
+  if (message === "Load failed") return stack === void 0 || "__sentry_captured__" in error;
+  if (message.startsWith("error sending request for url")) return true;
+  return errorMessages.has(message);
+}
+
+// node_modules/@langchain/core/dist/utils/p-retry/index.js
+function validateRetries(retries) {
+  if (typeof retries === "number") {
+    if (retries < 0) throw new TypeError("Expected `retries` to be a non-negative number.");
+    if (Number.isNaN(retries)) throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
+  } else if (retries !== void 0) throw new TypeError("Expected `retries` to be a number or Infinity.");
+}
+function validateNumberOption(name, value, { min = 0, allowInfinity = false } = {}) {
+  if (value === void 0) return;
+  if (typeof value !== "number" || Number.isNaN(value)) throw new TypeError(`Expected \`${name}\` to be a number${allowInfinity ? " or Infinity" : ""}.`);
+  if (!allowInfinity && !Number.isFinite(value)) throw new TypeError(`Expected \`${name}\` to be a finite number.`);
+  if (value < min) throw new TypeError(`Expected \`${name}\` to be \u2265 ${min}.`);
+}
+var AbortError = class extends Error {
+  constructor(message) {
+    super();
+    if (message instanceof Error) {
+      this.originalError = message;
+      ({ message } = message);
+    } else {
+      this.originalError = new Error(message);
+      this.originalError.stack = this.stack;
+    }
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+function calculateDelay(retriesConsumed, options) {
+  const attempt = Math.max(1, retriesConsumed + 1);
+  const random = options.randomize ? Math.random() + 1 : 1;
+  let timeout = Math.round(random * options.minTimeout * options.factor ** (attempt - 1));
+  timeout = Math.min(timeout, options.maxTimeout);
+  return timeout;
+}
+function calculateRemainingTime(start, max) {
+  if (!Number.isFinite(max)) return max;
+  return max - (performance.now() - start);
+}
+async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTime, options }) {
+  const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+  if (normalizedError instanceof AbortError) throw normalizedError.originalError;
+  const retriesLeft = Number.isFinite(options.retries) ? Math.max(0, options.retries - retriesConsumed) : options.retries;
+  const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
+  const context = Object.freeze({
+    error: normalizedError,
+    attemptNumber,
+    retriesLeft,
+    retriesConsumed
+  });
+  await options.onFailedAttempt(context);
+  if (calculateRemainingTime(startTime, maxRetryTime) <= 0) throw normalizedError;
+  const consumeRetry = await options.shouldConsumeRetry(context);
+  const remainingTime = calculateRemainingTime(startTime, maxRetryTime);
+  if (remainingTime <= 0 || retriesLeft <= 0) throw normalizedError;
+  if (normalizedError instanceof TypeError && !isNetworkError(normalizedError)) {
+    if (consumeRetry) throw normalizedError;
+    options.signal?.throwIfAborted();
+    return false;
+  }
+  if (!await options.shouldRetry(context)) throw normalizedError;
+  if (!consumeRetry) {
+    options.signal?.throwIfAborted();
+    return false;
+  }
+  const delayTime = calculateDelay(retriesConsumed, options);
+  const finalDelay = Math.min(delayTime, remainingTime);
+  if (finalDelay > 0) await new Promise((resolve, reject2) => {
+    const onAbort = () => {
+      clearTimeout(timeoutToken);
+      options.signal?.removeEventListener("abort", onAbort);
+      reject2(options.signal.reason);
+    };
+    const timeoutToken = setTimeout(() => {
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, finalDelay);
+    if (options.unref) timeoutToken.unref?.();
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+  });
+  options.signal?.throwIfAborted();
+  return true;
+}
+async function pRetry(input, options = {}) {
+  options = { ...options };
+  validateRetries(options.retries);
+  if (Object.hasOwn(options, "forever")) throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
+  options.retries ??= 10;
+  options.factor ??= 2;
+  options.minTimeout ??= 1e3;
+  options.maxTimeout ??= Number.POSITIVE_INFINITY;
+  options.maxRetryTime ??= Number.POSITIVE_INFINITY;
+  options.randomize ??= false;
+  options.onFailedAttempt ??= () => {
+  };
+  options.shouldRetry ??= () => true;
+  options.shouldConsumeRetry ??= () => true;
+  validateNumberOption("factor", options.factor, {
+    min: 0,
+    allowInfinity: false
+  });
+  validateNumberOption("minTimeout", options.minTimeout, {
+    min: 0,
+    allowInfinity: false
+  });
+  validateNumberOption("maxTimeout", options.maxTimeout, {
+    min: 0,
+    allowInfinity: true
+  });
+  validateNumberOption("maxRetryTime", options.maxRetryTime, {
+    min: 0,
+    allowInfinity: true
+  });
+  if (!(options.factor > 0)) options.factor = 1;
+  options.signal?.throwIfAborted();
+  let attemptNumber = 0;
+  let retriesConsumed = 0;
+  const startTime = performance.now();
+  while (Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true) {
+    attemptNumber++;
+    try {
+      options.signal?.throwIfAborted();
+      const result = await input(attemptNumber);
+      options.signal?.throwIfAborted();
+      return result;
+    } catch (error) {
+      if (await onAttemptFailure({
+        error,
+        attemptNumber,
+        retriesConsumed,
+        startTime,
+        options
+      })) retriesConsumed++;
+    }
+  }
+  throw new Error("Retry attempts exhausted without throwing an error.");
+}
+
+// node_modules/@langchain/core/dist/utils/async_caller.js
+var import_p_queue = __toESM(require_dist(), 1);
+var STATUS_NO_RETRY = [
+  400,
+  401,
+  402,
+  403,
+  404,
+  405,
+  406,
+  407,
+  409
+];
+var defaultFailedAttemptHandler = (error) => {
+  if (typeof error !== "object" || error === null) return;
+  if ("message" in error && typeof error.message === "string" && (error.message.startsWith("Cancel") || error.message.startsWith("AbortError")) || "name" in error && typeof error.name === "string" && error.name === "AbortError") throw error;
+  if ("code" in error && typeof error.code === "string" && error.code === "ECONNABORTED") throw error;
+  const responseStatus = "response" in error && typeof error.response === "object" && error.response !== null && "status" in error.response && typeof error.response.status === "number" ? error.response.status : void 0;
+  const directStatus = "status" in error && typeof error.status === "number" ? error.status : void 0;
+  const status = responseStatus ?? directStatus;
+  if (status && STATUS_NO_RETRY.includes(+status)) throw error;
+  if (("error" in error && typeof error.error === "object" && error.error !== null && "code" in error.error && typeof error.error.code === "string" ? error.error.code : void 0) === "insufficient_quota") {
+    const err = new Error("message" in error && typeof error.message === "string" ? error.message : "Insufficient quota");
+    err.name = "InsufficientQuotaError";
+    throw err;
+  }
+};
+var AsyncCaller = class {
+  maxConcurrency;
+  maxRetries;
+  onFailedAttempt;
+  queue;
+  constructor(params) {
+    this.maxConcurrency = params.maxConcurrency ?? Infinity;
+    this.maxRetries = params.maxRetries ?? 6;
+    this.onFailedAttempt = params.onFailedAttempt ?? defaultFailedAttemptHandler;
+    const PQueue = "default" in import_p_queue.default ? import_p_queue.default.default : import_p_queue.default;
+    this.queue = new PQueue({ concurrency: this.maxConcurrency });
+  }
+  async call(callable, ...args) {
+    return this.queue.add(() => pRetry(() => callable(...args).catch((error) => {
+      if (error instanceof Error) throw error;
+      else throw new Error(error);
+    }), {
+      onFailedAttempt: ({ error }) => this.onFailedAttempt?.(error),
+      retries: this.maxRetries,
+      randomize: true
+    }), { throwOnTimeout: true });
+  }
+  callWithOptions(options, callable, ...args) {
+    if (options.signal) {
+      let listener;
+      return Promise.race([this.call(callable, ...args), new Promise((_, reject2) => {
+        listener = () => {
+          reject2(getAbortSignalError(options.signal));
+        };
+        options.signal?.addEventListener("abort", listener, { once: true });
+      })]).finally(() => {
+        if (options.signal && listener) options.signal.removeEventListener("abort", listener);
+      });
+    }
+    return this.call(callable, ...args);
+  }
+  fetch(...args) {
+    return this.call(() => fetch(...args).then((res) => res.ok ? res : Promise.reject(res)));
+  }
+};
+
+// node_modules/@langchain/core/dist/embeddings.js
+var Embeddings = class {
+  /**
+  * The async caller should be used by subclasses to make any async calls,
+  * which will thus benefit from the concurrency and retry logic.
+  */
+  caller;
+  constructor(params) {
+    this.caller = new AsyncCaller(params ?? {});
+  }
+};
+
+// src/integrations/langchain.ts
+var WarpEmbeddings = class extends Embeddings {
+  baseEmbeddings;
+  adapter;
+  intentName;
+  activation;
+  autoBlend;
+  constructor(options) {
+    super(options);
+    this.baseEmbeddings = options.baseEmbeddings;
+    this.adapter = options.adapter;
+    this.intentName = options.intentName;
+    this.activation = options.activation;
+    this.autoBlend = options.autoBlend ?? false;
+  }
+  /**
+   * 実行時にアクティブな意図（インテント）を動的に切り替えます。
+   */
+  setIntent(intentName, activation) {
+    this.intentName = intentName;
+    this.activation = activation;
+    this.autoBlend = false;
+  }
+  /**
+   * 自己アテンション型の動的意図合成（Auto-blending）を有効化または無効化します。
+   */
+  setAutoBlend(enabled) {
+    this.autoBlend = enabled;
+  }
+  /**
+   * ベースの embeddings モデルを使用して、ドキュメントを通常通り埋め込みます。
+   * VectorDB には客観的な空間データを含める必要があるため、インデックスされるドキュメントはワープ（変換）しません。
+   */
+  async embedDocuments(documents) {
+    return this.baseEmbeddings.embedDocuments(documents);
+  }
+  /**
+   * ユーザーのクエリを埋め込み、WarpVector によるアフィン変換を適用します。
+   */
+  async embedQuery(document) {
+    const baseVector = await this.baseEmbeddings.embedQuery(document);
+    let warped;
+    if (this.autoBlend) {
+      warped = this.adapter.tuneAutoBlended(baseVector, this.activation);
+    } else {
+      if (!this.intentName) {
+        throw new Error(
+          "WarpEmbeddings: intentName \u304C\u8A2D\u5B9A\u3055\u308C\u3066\u304A\u3089\u305A\u3001autoBlend \u3082 false \u3067\u3059\u3002setIntent() \u3092\u547C\u3073\u51FA\u3059\u304B autoBlend \u3092\u6709\u52B9\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+        );
+      }
+      warped = this.adapter.tune(baseVector, this.intentName, this.activation);
+    }
+    return Array.from(warped);
+  }
+};
+
+// src/integrations/llama-index.ts
+var WarpLlamaIndexEmbeddings = class {
+  baseEmbeddings;
+  adapter;
+  intentName;
+  activation;
+  autoBlend;
+  constructor(options) {
+    this.baseEmbeddings = options.baseEmbeddings;
+    this.adapter = options.adapter;
+    this.intentName = options.intentName;
+    this.activation = options.activation;
+    this.autoBlend = options.autoBlend ?? false;
+  }
+  setIntent(intentName, activation) {
+    this.intentName = intentName;
+    this.activation = activation;
+    this.autoBlend = false;
+  }
+  setAutoBlend(enabled) {
+    this.autoBlend = enabled;
+  }
+  /**
+   * ドキュメントの埋め込み（インデックス作成用）は変換を行いません。
+   */
+  async getTextEmbedding(text) {
+    return this.baseEmbeddings.getTextEmbedding(text);
+  }
+  /**
+   * 複数ドキュメントの埋め込み
+   */
+  async getTextEmbeddings(texts) {
+    if (this.baseEmbeddings.getTextEmbeddings) {
+      return this.baseEmbeddings.getTextEmbeddings(texts);
+    }
+    return Promise.all(texts.map((t) => this.getTextEmbedding(t)));
+  }
+  /**
+   * クエリの埋め込み（検索用）にのみ WarpVector 変換を適用します。
+   */
+  async getQueryEmbedding(query) {
+    const baseVector = await this.baseEmbeddings.getQueryEmbedding(query);
+    let warped;
+    if (this.autoBlend) {
+      warped = this.adapter.tuneAutoBlended(baseVector, this.activation);
+    } else {
+      if (!this.intentName) {
+        throw new Error(
+          "WarpLlamaIndexEmbeddings: intentName \u304C\u8A2D\u5B9A\u3055\u308C\u3066\u304A\u3089\u305A\u3001autoBlend \u3082 false \u3067\u3059\u3002"
+        );
+      }
+      warped = this.adapter.tune(baseVector, this.intentName, this.activation);
+    }
+    return Array.from(warped);
+  }
+};
+
+// src/QuantizationAdapter.ts
+var QuantizationAdapter = class _QuantizationAdapter {
+  type;
+  dim;
+  dynamic;
+  constructor(config) {
+    this.type = config.type;
+    this.dim = config.dim;
+    this.dynamic = config.dynamic ?? false;
+    if (this.type === "binary" && this.dim % 8 !== 0) {
+      throw new Error(
+        `Binary quantization requires dimension to be a multiple of 8. Got ${this.dim}`
+      );
+    }
+  }
+  tune(vector) {
+    assertDimension(vector, this.dim, "QuantizationAdapter.tune");
+    if (this.type === "int8") {
+      if (this.dynamic) {
+        let maxVal = 1e-8;
+        for (let i = 0; i < this.dim; i++) {
+          const abs = Math.abs(vector[i]);
+          if (abs > maxVal) maxVal = abs;
+        }
+        const scale = 127 / maxVal;
+        const result = new Int8Array(this.dim + 4);
+        for (let i = 0; i < this.dim; i++) {
+          let val = Math.round(vector[i] * scale);
+          if (val > 127) val = 127;
+          if (val < -128) val = -128;
+          result[i] = val;
+        }
+        const view = new DataView(result.buffer, result.byteOffset, result.byteLength);
+        view.setFloat32(this.dim, maxVal, true);
+        return result;
+      } else {
+        const result = new Int8Array(this.dim);
+        for (let i = 0; i < this.dim; i++) {
+          let val = Math.round(vector[i] * 127);
+          if (val > 127) val = 127;
+          if (val < -128) val = -128;
+          result[i] = val;
+        }
+        return result;
+      }
+    } else if (this.type === "binary") {
+      const bytesLength = this.dim / 8;
+      const result = new Uint8Array(bytesLength);
+      for (let i = 0; i < this.dim; i++) {
+        if (vector[i] > 0) {
+          const byteIndex = Math.floor(i / 8);
+          const bitIndex = i % 8;
+          result[byteIndex] |= 1 << 7 - bitIndex;
+        }
+      }
+      return result;
+    }
+    throw new Error(`Unknown quantization type: ${this.type}`);
+  }
+  /**
+   * Binary量子化された2つのベクトル間のハミング距離を計算します。
+   * ハミング距離が小さいほど類似度が高いことを意味します。
+   */
+  static hammingDistance(a, b) {
+    if (a.length !== b.length) throw new Error("Length mismatch");
+    let distance = 0;
+    for (let i = 0; i < a.length; i++) {
+      let xor = a[i] ^ b[i];
+      while (xor > 0) {
+        distance++;
+        xor &= xor - 1;
+      }
+    }
+    return distance;
+  }
+  /**
+   * Int8量子化された2つのベクトル間のドット積（内積）を計算します。
+   * 動的スケーリングが埋め込まれている場合はスケールを戻して計算します。
+   */
+  static int8DotProduct(a, b) {
+    if (a.length !== b.length) throw new Error("Length mismatch");
+    const hasScaleBytes = a.length > 4;
+    let isDynamic = false;
+    let maxA = 1;
+    let maxB = 1;
+    if (hasScaleBytes) {
+      const dim = a.length - 4;
+      try {
+        const viewA = new DataView(a.buffer, a.byteOffset, a.byteLength);
+        const viewB = new DataView(b.buffer, b.byteOffset, b.byteLength);
+        maxA = viewA.getFloat32(dim, true);
+        maxB = viewB.getFloat32(dim, true);
+        if (!isNaN(maxA) && !isNaN(maxB) && maxA > 0 && maxA < 1e3 && maxB > 0 && maxB < 1e3) {
+          isDynamic = true;
+        }
+      } catch (e) {
+        isDynamic = false;
+      }
+    }
+    if (isDynamic) {
+      const dim = a.length - 4;
+      let dot = 0;
+      for (let i = 0; i < dim; i++) {
+        dot += a[i] * b[i];
+      }
+      return dot * (maxA / 127) * (maxB / 127);
+    } else {
+      let dot = 0;
+      for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+      }
+      return dot;
+    }
+  }
+  exportState() {
+    return JSON.stringify({ type: this.type, dim: this.dim, dynamic: this.dynamic });
+  }
+  static importState(stateJson) {
+    const config = JSON.parse(stateJson);
+    return new _QuantizationAdapter(config);
+  }
+};
+
+// src/BaseTrainer.ts
+var AbstractAdamTrainer = class {
+  t = 0;
+  mW;
+  vW;
+  mb;
+  vb;
+  initAdamState(sDim, tDim) {
+    if (!this.mW || this.mW.length !== sDim * tDim) {
+      this.mW = new Float32Array(sDim * tDim);
+      this.vW = new Float32Array(sDim * tDim);
+      this.mb = new Float32Array(tDim);
+      this.vb = new Float32Array(tDim);
+      this.t = 0;
+    }
+    assertDimension(this.mW, sDim * tDim, "AdamState mW");
+  }
+  /**
+   * アフィンレイヤー (matrix, bias) に対する Adam のパラメータ更新を適用します。
+   * InfoNCE や Triplet など、様々な損失関数で計算された勾配(outputGradients)を元に更新を行います。
+   */
+  applyAdamToAffine(matrix, bias, mMatrix, vMatrix, mBias, vBias, input, outputGradients, lr, reg, t) {
+    const tDim = bias.length;
+    const sDim = input.length;
+    const beta1 = 0.9;
+    const beta2 = 0.999;
+    const epsilon = 1e-8;
+    const instance = getWasmInstance();
+    if (instance && instance.exports.adamUpdateWasm) {
+      const memory = instance.exports.memory;
+      const matrixBytes = matrix.byteLength;
+      const biasBytes = bias.byteLength;
+      const inputBytes = sDim * 4;
+      const gradBytes = tDim * 4;
+      const initialOffset = getWasmAllocatorOffset();
+      try {
+        const matrixPtr = allocateWasmMemory(matrixBytes);
+        const biasPtr = allocateWasmMemory(biasBytes);
+        const mMatrixPtr = allocateWasmMemory(matrixBytes);
+        const vMatrixPtr = allocateWasmMemory(matrixBytes);
+        const mBiasPtr = allocateWasmMemory(biasBytes);
+        const vBiasPtr = allocateWasmMemory(biasBytes);
+        const inputPtr = allocateWasmMemory(inputBytes);
+        const gradPtr = allocateWasmMemory(gradBytes);
+        writeFloat32ArrayToWasm(memory, matrix, matrixPtr);
+        writeFloat32ArrayToWasm(memory, bias, biasPtr);
+        writeFloat32ArrayToWasm(memory, mMatrix, mMatrixPtr);
+        writeFloat32ArrayToWasm(memory, vMatrix, vMatrixPtr);
+        writeFloat32ArrayToWasm(memory, mBias, mBiasPtr);
+        writeFloat32ArrayToWasm(memory, vBias, vBiasPtr);
+        writeFloat32ArrayToWasm(memory, input, inputPtr);
+        writeFloat32ArrayToWasm(memory, outputGradients, gradPtr);
+        const adamUpdateWasm = instance.exports.adamUpdateWasm;
+        adamUpdateWasm(
+          matrixPtr,
+          biasPtr,
+          mMatrixPtr,
+          vMatrixPtr,
+          mBiasPtr,
+          vBiasPtr,
+          inputPtr,
+          gradPtr,
+          lr,
+          reg,
+          beta1,
+          beta2,
+          epsilon,
+          t,
+          sDim,
+          tDim
+        );
+        const f32 = new Float32Array(memory.buffer);
+        matrix.set(f32.subarray(matrixPtr / 4, matrixPtr / 4 + matrix.length));
+        bias.set(f32.subarray(biasPtr / 4, biasPtr / 4 + bias.length));
+        mMatrix.set(f32.subarray(mMatrixPtr / 4, mMatrixPtr / 4 + mMatrix.length));
+        vMatrix.set(f32.subarray(vMatrixPtr / 4, vMatrixPtr / 4 + vMatrix.length));
+        mBias.set(f32.subarray(mBiasPtr / 4, mBiasPtr / 4 + mBias.length));
+        vBias.set(f32.subarray(vBiasPtr / 4, vBiasPtr / 4 + vBias.length));
+      } finally {
+        setWasmAllocatorOffset(initialOffset);
+      }
+    } else {
+      for (let i = 0; i < tDim; i++) {
+        const bGrad = outputGradients[i];
+        mBias[i] = beta1 * mBias[i] + (1 - beta1) * bGrad;
+        vBias[i] = beta2 * vBias[i] + (1 - beta2) * (bGrad * bGrad);
+        const mHatB = mBias[i] / (1 - Math.pow(beta1, t));
+        const vHatB = vBias[i] / (1 - Math.pow(beta2, t));
+        bias[i] -= lr * mHatB / (Math.sqrt(vHatB) + epsilon);
+        const rowOffset = i * sDim;
+        for (let j = 0; j < sDim; j++) {
+          const wIdx = rowOffset + j;
+          const wGrad = bGrad * input[j] + reg * matrix[wIdx];
+          mMatrix[wIdx] = beta1 * mMatrix[wIdx] + (1 - beta1) * wGrad;
+          vMatrix[wIdx] = beta2 * vMatrix[wIdx] + (1 - beta2) * (wGrad * wGrad);
+          const mHatW = mMatrix[wIdx] / (1 - Math.pow(beta1, t));
+          const vHatW = vMatrix[wIdx] / (1 - Math.pow(beta2, t));
+          matrix[wIdx] -= lr * mHatW / (Math.sqrt(vHatW) + epsilon);
+        }
+      }
+    }
+  }
+};
+var BaseTrainer = class extends AbstractAdamTrainer {
+  /** 学習用サンプルの配列 */
+  examples = [];
+  /**
+   * 学習用のサンプルデータを追加します。
+   * 次元数がソース/ターゲットと一致しない場合はエラーとなります。
+   *
+   * @param {TExample} example 追加するサンプルデータ
+   * @throws {Error} 次元数が一致しない場合にスローされます。
+   */
+  addExample(example) {
+    const { source, target } = this.getInputs(example);
+    assertDimension(
+      source,
+      this.sourceDimension,
+      "BaseTrainer.addExample source"
+    );
+    assertDimension(
+      target,
+      this.targetDimension,
+      "BaseTrainer.addExample target"
+    );
+    this.examples.push(example);
+  }
+  /**
+   * 追加されたサンプルデータを用いて学習を実行します。
+   * 指定されたエポック数だけ SGD + Momentum によるパラメータ更新を行います。
+   * パフォーマンスのため、可能であれば内部で WebAssembly (WASM) を使用します。
+   *
+   * @param {BaseTrainingOptions} [options={}] 学習のハイパーパラメータオプション
+   * @returns {Promise<TResult>} 学習済みの重みを返します。
+   * @throws {Error} サンプルデータが追加されていない場合にスローされます。
+   */
+  async train(options = {}) {
+    await initWasm();
+    if (this.examples.length === 0) {
+      throw new Error("No training examples provided.");
+    }
+    if (options.autoTune) {
+      options.learningRate = this.findBestLearningRate(options);
+      options.autoTune = false;
+    }
+    const lr = options.learningRate ?? 0.01;
+    const epochs = options.epochs ?? 100;
+    const reg = options.regularization ?? 1e-3;
+    const momentum = options.momentum ?? 0.9;
+    const sDim = this.sourceDimension;
+    const tDim = this.targetDimension;
+    const flatMatrix = new Float32Array(tDim * sDim);
+    for (let i = 0; i < tDim; i++) {
+      if (i < sDim) {
+        flatMatrix[i * sDim + i] = 1;
+      }
+    }
+    const bias = new Float32Array(tDim);
+    this.initAdamState(sDim, tDim);
+    for (let epoch = 0; epoch < epochs; epoch++) {
+      for (const example of this.examples) {
+        this.t++;
+        const { source, target } = this.getInputs(example);
+        this.adamStep(
+          flatMatrix,
+          bias,
+          this.mW,
+          this.vW,
+          this.mb,
+          this.vb,
+          source,
+          target,
+          lr,
+          reg,
+          this.t
+        );
+      }
+    }
+    return this.toWeights(flatMatrix, bias);
+  }
+  /**
+   * サンプルデータに対する短時間のテストランを行い、最も損失(Loss)が小さくなる最適な学習率を自動探索します。
    * `options.autoTune` が true の場合に `train` メソッド内で自動的に呼び出されます。
    *
    * @param {BaseTrainingOptions} options 現在の学習オプション
@@ -930,21 +2909,27 @@ var BaseTrainer = class {
         if (i < sDim) flatMatrix[i * sDim + i] = 1;
       }
       const bias = new Float32Array(tDim);
+      const mMatrix = new Float32Array(tDim * sDim);
       const vMatrix = new Float32Array(tDim * sDim);
+      const mBias = new Float32Array(tDim);
       const vBias = new Float32Array(tDim);
+      let t = 0;
       for (let epoch = 0; epoch < testEpochs; epoch++) {
         for (const example of this.examples) {
+          t++;
           const { source, target } = this.getInputs(example);
-          this.sgdMomentumStep(
+          this.adamStep(
             flatMatrix,
             bias,
+            mMatrix,
             vMatrix,
+            mBias,
             vBias,
             source,
             target,
             lr,
             reg,
-            momentum
+            t
           );
         }
       }
@@ -952,12 +2937,8 @@ var BaseTrainer = class {
       for (const example of this.examples) {
         const { source, target } = this.getInputs(example);
         const pred = new Float32Array(tDim);
+        applyAffine(flatMatrix, bias, source, pred, sDim, tDim);
         for (let i = 0; i < tDim; i++) {
-          let sum = 0;
-          for (let j = 0; j < sDim; j++) {
-            sum += flatMatrix[i * sDim + j] * source[j];
-          }
-          pred[i] = sum + bias[i];
           const diff = pred[i] - target[i];
           currentLoss += diff * diff;
         }
@@ -967,170 +2948,304 @@ var BaseTrainer = class {
         bestLr = lr;
       }
     }
-    return bestLr;
+    return bestLr;
+  }
+  /**
+   * Adam オプティマイザによる1ステップのパラメータ更新を実行します。
+   * In-place (破壊的) に `matrix` と `bias` を更新します。
+   * WASM 版の Adam 実装ができるまではネイティブ JS で処理します。
+   */
+  adamStep(matrix, bias, mMatrix, vMatrix, mBias, vBias, x, y, lr, reg, t) {
+    const sDim = this.sourceDimension;
+    const tDim = this.targetDimension;
+    const beta1 = 0.9;
+    const beta2 = 0.999;
+    const epsilon = 1e-8;
+    const pred = new Float32Array(tDim);
+    applyAffine(matrix, bias, x, pred, sDim, tDim);
+    const outputGradients = new Float32Array(tDim);
+    for (let i = 0; i < tDim; i++) {
+      outputGradients[i] = pred[i] - y[i];
+    }
+    this.applyAdamToAffine(
+      matrix,
+      bias,
+      mMatrix,
+      vMatrix,
+      mBias,
+      vBias,
+      x,
+      outputGradients,
+      lr,
+      reg,
+      t
+    );
+  }
+};
+
+// src/trainer.ts
+var IntentTrainer = class extends BaseTrainer {
+  dimension;
+  /**
+   * IntentTrainer のインスタンスを作成します。
+   * @param {number} dimension ベクトルの次元数（入力・出力ともに同じ次元数となります）
+   */
+  constructor(dimension) {
+    super();
+    this.dimension = dimension;
+    this.initAdamState(dimension, dimension);
+  }
+  get sourceDimension() {
+    return this.dimension;
+  }
+  get targetDimension() {
+    return this.dimension;
+  }
+  getInputs(example) {
+    return { source: example.input, target: example.target };
+  }
+  toWeights(flatMatrix, bias) {
+    return {
+      matrix: flatMatrix,
+      // 変換のオーバーヘッドを避けるためネイティブ配列のまま返す
+      bias
+    };
+  }
+  /**
+   * オンライン学習 (フィードバックループ) 用のメソッド。
+   * ユーザーのクリックなどの 1 回のフィードバックからリアルタイムに重みを微調整します。
+   *
+   * @param {IntentWeights} currentWeights - 現在の重み
+   * @param {TrainingExample} example - アンカー、正解を含む学習データ
+   * @param {IntentOnlineOptions} [options={}] - 学習オプション
+   * @returns {IntentWeights} 微調整された新しい重み
+   */
+  async updateOnline(currentWeights, example, options = {}) {
+    const learningRate = options.learningRate ?? 0.01;
+    const regularization = options.regularization ?? 1e-3;
+    await initWasm();
+    assertDimension(
+      example.input,
+      this.dimension,
+      "IntentTrainer.addExample input"
+    );
+    assertDimension(
+      example.target,
+      this.dimension,
+      "IntentTrainer.addExample target"
+    );
+    const dim = this.dimension;
+    const { flatMatrix, bias } = getFlatMatrixAndBias(
+      currentWeights,
+      dim,
+      "updateOnline Matrix"
+    );
+    const warpedInput = new Float32Array(dim);
+    applyAffine(flatMatrix, bias, example.input, warpedInput, dim);
+    const outputGradients = new Float32Array(dim);
+    for (let i = 0; i < dim; i++) {
+      outputGradients[i] = warpedInput[i] - example.target[i];
+    }
+    this.t++;
+    this.applyAdamToAffine(
+      flatMatrix,
+      bias,
+      this.mW,
+      this.vW,
+      this.mb,
+      this.vb,
+      example.input,
+      outputGradients,
+      learningRate,
+      regularization,
+      this.t
+    );
+    const newWeights = this.toWeights(flatMatrix, bias);
+    if (currentWeights.routingVector) {
+      newWeights.routingVector = [...currentWeights.routingVector];
+    }
+    return newWeights;
   }
+};
+
+// src/TripletTrainer.ts
+var TripletTrainer = class extends AbstractAdamTrainer {
+  dimension;
   /**
-   * SGD + Momentum アルゴリズムによる1ステップのパラメータ更新を実行します。
-   * In-place (破壊的) に `matrix` と `bias` を更新します。
+   * TripletTrainer のインスタンスを作成します。
+   * @param {number} dimension ベクトルの次元数
+   */
+  constructor(dimension) {
+    super();
+    this.dimension = dimension;
+    this.initAdamState(dimension, dimension);
+  }
+  toWeights(flatMatrix, bias) {
+    return {
+      matrix: flatMatrix,
+      // 変換のオーバーヘッドを避けるためネイティブ配列のまま返す
+      bias
+    };
+  }
+  /**
+   * オンライン学習 (フィードバックループ) 用のメソッド。
+   * 1つのトリプレットデータからリアルタイムに重みを微調整します。
    *
-   * @param {Float32Array} matrix 現在の変換行列 (1次元フラット配列)
-   * @param {Float32Array} bias 現在のバイアスベクトル
-   * @param {Float32Array} vMatrix 行列のモメンタム (速度)
-   * @param {Float32Array} vBias バイアスのモメンタム (速度)
-   * @param {number[] | Float32Array} x 入力ベクトル (ソース)
-   * @param {number[] | Float32Array} y 理想の出力ベクトル (ターゲット)
-   * @param {number} lr 学習率
-   * @param {number} reg L2正則化係数
-   * @param {number} momentum モメンタム係数
-   */
-  sgdMomentumStep(matrix, bias, vMatrix, vBias, x, y, lr, reg, momentum) {
-    const sDim = this.sourceDimension;
-    const tDim = this.targetDimension;
-    const instance = getWasmInstance();
-    const requiredBytes = sDim * tDim * 4 + tDim * 4 + sDim * tDim * 4 + tDim * 4 + sDim * 4 + tDim * 4 + tDim * 4;
-    if (instance && ensureWasmMemory(requiredBytes)) {
-      const wasmMemory2 = getWasmMemory();
-      const f32Mem = new Float32Array(wasmMemory2.buffer);
-      let offset = 0;
-      const matrixOffset = offset;
-      offset += sDim * tDim;
-      const biasOffset = offset;
-      offset += tDim;
-      const vMatrixOffset = offset;
-      offset += sDim * tDim;
-      const vBiasOffset = offset;
-      offset += tDim;
-      const xOffset = offset;
-      offset += sDim;
-      const yOffset = offset;
-      offset += tDim;
-      const predOffset = offset;
-      offset += tDim;
-      f32Mem.set(matrix, matrixOffset);
-      f32Mem.set(bias, biasOffset);
-      f32Mem.set(vMatrix, vMatrixOffset);
-      f32Mem.set(vBias, vBiasOffset);
-      f32Mem.set(x, xOffset);
-      f32Mem.set(y, yOffset);
-      const sgdMomentumStepWasm = instance.exports.sgdMomentumStepWasm;
-      sgdMomentumStepWasm(
-        matrixOffset * 4,
-        biasOffset * 4,
-        vMatrixOffset * 4,
-        vBiasOffset * 4,
-        xOffset * 4,
-        yOffset * 4,
-        lr,
-        reg,
-        momentum,
-        sDim,
-        tDim,
-        predOffset * 4
-      );
-      matrix.set(f32Mem.subarray(matrixOffset, matrixOffset + sDim * tDim));
-      bias.set(f32Mem.subarray(biasOffset, biasOffset + tDim));
-      vMatrix.set(f32Mem.subarray(vMatrixOffset, vMatrixOffset + sDim * tDim));
-      vBias.set(f32Mem.subarray(vBiasOffset, vBiasOffset + tDim));
-      return;
-    }
-    const pred = new Float32Array(tDim);
-    for (let i = 0; i < tDim; i++) {
-      let sum = 0;
-      const rowOffset = i * sDim;
-      for (let j = 0; j < sDim; j++) {
-        sum += matrix[rowOffset + j] * x[j];
+   * @param {IntentWeights} currentWeights - 現在の重み
+   * @param {TripletExample} example - アンカー、正解、不正解を含むトリプレットデータ
+   * @param {TripletOnlineOptions} [options={}] - 学習オプション
+   * @returns {Promise<IntentWeights>} 微調整された新しい重み
+   */
+  async updateOnline(currentWeights, example, options = {}) {
+    const learningRate = options.learningRate ?? 0.01;
+    const margin = options.margin ?? 0.1;
+    const regularization = options.regularization ?? 1e-3;
+    assertDimension(
+      example.anchor,
+      this.dimension,
+      "TripletTrainer.train anchor"
+    );
+    assertDimension(
+      example.positive,
+      this.dimension,
+      "TripletTrainer.train positive"
+    );
+    assertDimension(
+      example.negative,
+      this.dimension,
+      "TripletTrainer.train negative"
+    );
+    const dim = this.dimension;
+    const { flatMatrix, bias } = getFlatMatrixAndBias(
+      currentWeights,
+      dim,
+      "updateOnline Matrix"
+    );
+    const warpedAnchor = new Float32Array(dim);
+    applyAffine(flatMatrix, bias, example.anchor, warpedAnchor, dim);
+    const posScore = innerProduct(warpedAnchor, example.positive);
+    const negScore = innerProduct(warpedAnchor, example.negative);
+    const loss = margin + negScore - posScore;
+    if (loss > 0) {
+      this.t += 1;
+      const outputGradients = new Float32Array(dim);
+      for (let i = 0; i < dim; i++) {
+        outputGradients[i] = example.negative[i] - example.positive[i];
       }
-      pred[i] = sum + bias[i];
+      this.applyAdamToAffine(
+        flatMatrix,
+        bias,
+        this.mW,
+        this.vW,
+        this.mb,
+        this.vb,
+        example.anchor,
+        outputGradients,
+        learningRate,
+        regularization,
+        this.t
+      );
     }
-    for (let i = 0; i < tDim; i++) {
-      const error = pred[i] - y[i];
-      const bGrad = error;
-      vBias[i] = momentum * vBias[i] - lr * bGrad;
-      bias[i] += vBias[i];
-      const rowOffset = i * sDim;
-      for (let j = 0; j < sDim; j++) {
-        const wIdx = rowOffset + j;
-        const wGrad = error * x[j] + reg * matrix[wIdx];
-        vMatrix[wIdx] = momentum * vMatrix[wIdx] - lr * wGrad;
-        matrix[wIdx] += vMatrix[wIdx];
-      }
+    const newWeights = this.toWeights(flatMatrix, bias);
+    if (currentWeights.routingVector) {
+      newWeights.routingVector = [...currentWeights.routingVector];
     }
+    return newWeights;
   }
 };
 
-// src/trainer.ts
-var IntentTrainer = class extends BaseTrainer {
+// src/InfoNCETrainer.ts
+var InfoNCETrainer = class extends AbstractAdamTrainer {
   dimension;
   /**
-   * IntentTrainer のインスタンスを作成します。
-   * @param {number} dimension ベクトルの次元数（入力・出力ともに同じ次元数となります）
+   * InfoNCETrainer のインスタンスを作成します。
+   * @param {number} dimension ベクトルの次元数
    */
   constructor(dimension) {
     super();
     this.dimension = dimension;
-  }
-  get sourceDimension() {
-    return this.dimension;
-  }
-  get targetDimension() {
-    return this.dimension;
-  }
-  getInputs(example) {
-    return { source: example.input, target: example.target };
+    this.initAdamState(dimension, dimension);
   }
   toWeights(flatMatrix, bias) {
-    const dim = this.dimension;
-    const outMatrix = new Array(dim);
-    for (let i = 0; i < dim; i++) {
-      const row = new Array(dim);
-      const rowOffset = i * dim;
-      for (let j = 0; j < dim; j++) {
-        row[j] = flatMatrix[rowOffset + j];
-      }
-      outMatrix[i] = row;
-    }
     return {
-      matrix: outMatrix,
-      bias: Array.from(bias)
+      matrix: flatMatrix,
+      // ネイティブ配列のまま返す
+      bias
     };
   }
   /**
    * オンライン学習 (フィードバックループ) 用のメソッド。
-   * ユーザーのクリックなどの 1 回のフィードバックからリアルタイムに重みを微調整します。
+   * 1つのクエリ(Anchor)、1つのクリック(Positive)、複数のスルー(Negatives)から重みを微調整します。
    *
    * @param {IntentWeights} currentWeights - 現在の重み
-   * @param {number[] | Float32Array} input - 検索されたクエリベクトル
-   * @param {number[] | Float32Array} target - クリックされた(理想の)ドキュメントのベクトル
-   * @param {number} learningRate - 1ステップの学習率 (デフォルト: 0.01)
-   * @param {number} regularization - L2正則化の強さ (デフォルト: 0.001)
-   * @returns {IntentWeights} 微調整された新しい重み
+   * @param {InfoNCEExample} example - アンカー、正解、複数の不正解を含むデータ
+   * @param {InfoNCEOnlineOptions} [options={}] - 学習オプション
+   * @returns {Promise<IntentWeights>} 微調整された新しい重み
    */
-  async updateOnline(currentWeights, input, target, learningRate = 0.01, regularization = 1e-3) {
-    await initWasm();
-    if (input.length !== this.dimension || target.length !== this.dimension) {
-      throw new Error(`Dimension mismatch. Expected ${this.dimension}`);
-    }
+  async updateOnline(currentWeights, example, options = {}) {
+    const learningRate = options.learningRate ?? 0.01;
+    const temperature = options.temperature ?? 0.1;
+    const regularization = options.regularization ?? 1e-3;
     const dim = this.dimension;
-    let flatMatrix;
-    if (currentWeights.matrix instanceof Float32Array) {
-      flatMatrix = new Float32Array(currentWeights.matrix);
-    } else {
-      flatMatrix = flattenMatrix(currentWeights.matrix, dim, dim, "updateOnline Matrix");
+    assertDimension(example.anchor, dim, "InfoNCETrainer.train anchor");
+    assertDimension(example.positive, dim, "InfoNCETrainer.train positive");
+    if (example.negatives.length === 0) {
+      throw new Error("InfoNCETrainer requires at least one negative example.");
     }
-    const bias = new Float32Array(currentWeights.bias);
-    const vMatrix = new Float32Array(dim * dim);
-    const vBias = new Float32Array(dim);
-    this.sgdMomentumStep(
+    for (const neg of example.negatives) {
+      assertDimension(neg, dim, "InfoNCETrainer.train negative");
+    }
+    const { flatMatrix, bias } = getFlatMatrixAndBias(
+      currentWeights,
+      dim,
+      "updateOnline Matrix"
+    );
+    const warpedAnchor = new Float32Array(dim);
+    applyAffine(flatMatrix, bias, example.anchor, warpedAnchor, dim);
+    const posScore = innerProduct(warpedAnchor, example.positive);
+    const negScores = new Float32Array(example.negatives.length);
+    for (let n = 0; n < example.negatives.length; n++) {
+      negScores[n] = innerProduct(warpedAnchor, example.negatives[n]);
+    }
+    let maxScore = posScore / temperature;
+    for (let n = 0; n < example.negatives.length; n++) {
+      const s = negScores[n] / temperature;
+      if (s > maxScore) maxScore = s;
+    }
+    const expPos = Math.exp(posScore / temperature - maxScore);
+    const expNegs = new Float32Array(example.negatives.length);
+    let sumExp = expPos;
+    for (let n = 0; n < example.negatives.length; n++) {
+      const expN = Math.exp(negScores[n] / temperature - maxScore);
+      expNegs[n] = expN;
+      sumExp += expN;
+    }
+    const pPos = expPos / sumExp;
+    const pNegs = new Float32Array(example.negatives.length);
+    for (let n = 0; n < example.negatives.length; n++) {
+      pNegs[n] = expNegs[n] / sumExp;
+    }
+    this.t += 1;
+    const outputGradients = new Float32Array(dim);
+    for (let i = 0; i < dim; i++) {
+      let gradA_i = (pPos - 1) * example.positive[i];
+      for (let n = 0; n < example.negatives.length; n++) {
+        gradA_i += pNegs[n] * example.negatives[n][i];
+      }
+      outputGradients[i] = gradA_i / temperature;
+    }
+    this.applyAdamToAffine(
       flatMatrix,
       bias,
-      vMatrix,
-      vBias,
-      input,
-      target,
+      this.mW,
+      this.vW,
+      this.mb,
+      this.vb,
+      example.anchor,
+      outputGradients,
       learningRate,
       regularization,
-      0
-      // no momentum for 1-shot online update
+      this.t
     );
     const newWeights = this.toWeights(flatMatrix, bias);
     if (currentWeights.routingVector) {
@@ -1181,77 +3296,519 @@ var MigrationTrainer = class extends BaseTrainer {
   }
 };
 
-// src/db.ts
-var VectorDBAdapter = class {
+// src/integrations/index.ts
+var integrations_exports = {};
+__export(integrations_exports, {
+  WarpEmbeddings: () => WarpEmbeddings,
+  withWarpVector: () => withWarpVector
+});
+
+// src/VsaAdapter.ts
+var VsaAdapter = class _VsaAdapter {
   /**
-   * PostgreSQL (pgvector) 用のクエリ文字列表現を生成します。
-   * INSERT や SELECT の際に使用できる形式です。
+   * ベクトルのバンドリング (Bundling / Superposition)
+   * 複数のベクトルを足し合わせ（重ね合わせ）て1つのベクトルに統合します。
+   * 「A と B の両方の概念を含む」ベクトルを作成する際に使用します。
    *
-   * @example
-   * const sql = `SELECT * FROM items ORDER BY embedding <-> '${VectorDBAdapter.toPgvector(warpedVector)}' LIMIT 5`;
+   * @param vectors 束ねるベクトルの配列
+   * @param options 演算オプション
+   * @returns 束ねられた新しいベクトル
+   */
+  static bundle(vectors, options = {}) {
+    if (vectors.length === 0) {
+      throw new Error("Cannot bundle an empty array of vectors.");
+    }
+    const dim = vectors[0].length;
+    const result = new Float32Array(dim);
+    for (let i = 0; i < vectors.length; i++) {
+      const vec = vectors[i];
+      assertDimension(vec, dim, `Vector at index ${i}`);
+      addScaledVector(result, vec, 1);
+    }
+    const shouldNormalize = options.shouldNormalize ?? true;
+    if (shouldNormalize) {
+      return normalize(result);
+    }
+    return result;
+  }
+  /**
+   * ベクトルのバインディング (Binding / Hadamard Product)
+   * アダマール積（要素ごとの積）を用いて、2つのベクトルを「結合」します。
+   * 例: キー（ユーザーID）と値（好み）を掛け合わせ、特有の「ユーザーの好み」ベクトルを生成します。
    *
-   * @param {number[] | Float32Array} vector ワープ変換後のベクトル
-   * @returns {string} `'[0.1, 0.2, 0.3]'` のような文字列表現
+   * @param vec1 バインドするベクトル1
+   * @param vec2 バインドするベクトル2
+   * @param options 演算オプション
+   * @returns バインドされた新しいベクトル
    */
-  static toPgvector(vector) {
-    return `[${Array.from(vector).join(", ")}]`;
+  static bind(vec1, vec2, options = {}) {
+    const dim = vec1.length;
+    assertDimension(vec2, dim, "Vector 2");
+    const result = new Float32Array(dim);
+    for (let i = 0; i < dim; i++) {
+      result[i] = vec1[i] * vec2[i];
+    }
+    const shouldNormalize = options.shouldNormalize ?? true;
+    if (shouldNormalize) {
+      return normalize(result);
+    }
+    return result;
   }
   /**
-   * Pinecone 用のクエリオブジェクトを生成します。
-   * Pinecone クライアントに直接渡せる形式のオブジェクトを返します。
+   * ベクトルのアンバインディング (Unbinding)
+   * バインドされたベクトルから、片方のベクトル（キー）を使って元の値（バリュー）を取り出します。
+   * アダマール積によるバインディングの逆演算（要素ごとの除算）を行います。
    *
-   * @example
-   * const query = VectorDBAdapter.toPineconeQuery(warpedVector, 10, { genre: "comedy" });
-   * await index.query(query);
+   * @param boundVec バインド済みのベクトル
+   * @param keyVec 抽出に使用するキーベクトル
+   * @param options 演算オプション
+   * @returns アンバインドされて抽出されたベクトル
+   */
+  static unbind(boundVec, keyVec, options = {}) {
+    const dim = boundVec.length;
+    assertDimension(keyVec, dim, "Key Vector");
+    const result = new Float32Array(dim);
+    for (let i = 0; i < dim; i++) {
+      const val = keyVec[i] === 0 ? 1e-8 : keyVec[i];
+      result[i] = boundVec[i] / val;
+    }
+    const shouldNormalize = options.shouldNormalize ?? true;
+    if (shouldNormalize) {
+      return normalize(result);
+    }
+    return result;
+  }
+  /**
+   * ---------------------------------------------------------
+   * Binary VSA (バイナリベクトル・シンボリック・アーキテクチャ)
+   * ---------------------------------------------------------
+   * QuantizationAdapter で 1-bit (Binary) 量子化された Uint8Array ベクトルに
+   * 対する超次元計算を行います。XOR 演算により、超高速・極小メモリでの処理が可能です。
+   */
+  /**
+   * バイナリベクトルのバインディング (Binary Binding / XOR)
+   * XOR (排他的論理和) を用いて2つのバイナリベクトルを結合します。
+   * Binary VSA において、XOR は情報を結合するための標準的な演算です。
    *
-   * @param {number[] | Float32Array} vector 検索クエリベクトル
-   * @param {number} topK 取得する件数 (デフォルト: 10)
-   * @param {Record<string, any>} [filter] メタデータフィルタ（オプション）
-   * @returns {Record<string, any>} Pineconeのqueryメソッド用オブジェクト
+   * @param bin1 バインドするバイナリベクトル1 (Uint8Array)
+   * @param bin2 バインドするバイナリベクトル2 (Uint8Array)
+   * @returns バインドされた新しいバイナリベクトル (Uint8Array)
    */
-  static toPineconeQuery(vector, topK = 10, filter) {
+  static bindBinary(bin1, bin2) {
+    if (bin1.length !== bin2.length) {
+      throw new Error("Binary vectors must have the same length in bytes.");
+    }
+    const len = bin1.length;
+    const result = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      result[i] = bin1[i] ^ bin2[i];
+    }
+    return result;
+  }
+  /**
+   * バイナリベクトルのアンバインディング (Binary Unbinding / XOR)
+   * XOR の自己逆性 (A ^ B ^ B = A) を利用して、キーを用いて元の値を抽出します。
+   * 内部的には bindBinary と全く同じ処理です。
+   *
+   * @param boundBin バインド済みのバイナリベクトル (Uint8Array)
+   * @param keyBin 抽出に使用するキーバイナリベクトル (Uint8Array)
+   * @returns アンバインドされて抽出されたバイナリベクトル (Uint8Array)
+   */
+  static unbindBinary(boundBin, keyBin) {
+    return _VsaAdapter.bindBinary(boundBin, keyBin);
+  }
+  /**
+   * バイナリベクトルのバンドリング (Binary Bundling / Majority Vote)
+   * 複数のバイナリベクトルを重ね合わせます。各ビット位置で 1 と 0 の出現回数をカウントし、
+   * 多数決 (Majority Vote) で最終的なビットを決定します。
+   *
+   * @param bins 束ねるバイナリベクトルの配列 (Uint8Arrayの配列)
+   * @returns 束ねられた新しいバイナリベクトル (Uint8Array)
+   */
+  static bundleBinary(bins) {
+    if (bins.length === 0) {
+      throw new Error("Cannot bundle an empty array of binary vectors.");
+    }
+    const numVectors = bins.length;
+    const len = bins[0].length;
+    const result = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      let resultByte = 0;
+      for (let bit = 0; bit < 8; bit++) {
+        let onesCount = 0;
+        const mask = 1 << bit;
+        for (let v = 0; v < numVectors; v++) {
+          if (bins[v].length !== len) {
+            throw new Error(
+              `Binary vector at index ${v} has mismatched length.`
+            );
+          }
+          if ((bins[v][i] & mask) !== 0) {
+            onesCount++;
+          }
+        }
+        if (onesCount > numVectors / 2) {
+          resultByte |= mask;
+        } else if (onesCount === numVectors / 2) {
+          resultByte |= mask;
+        }
+      }
+      result[i] = resultByte;
+    }
+    return result;
+  }
+};
+
+// src/TaskArithmetic.ts
+var TaskArithmetic = class {
+  /**
+   * 複数のタスク（IntentWeights）を合成し、新しい IntentWeights を作成します。
+   * 数式: W_new = W_base + Σ scale_i * (W_i - W_base)
+   *
+   * @param tasks 合成するタスクのリスト（IntentWeights と スケールのペア）
+   * @param baseIntent 基準となる IntentWeights。省略された場合は恒等行列（Identity）とゼロバイアスがベースになります。
+   * @returns 完全にマージされた新しい IntentWeights
+   */
+  static merge(tasks, baseIntent) {
+    if (tasks.length === 0) {
+      throw new Error("No tasks provided to merge.");
+    }
+    const dim = tasks[0].weights.bias.length;
+    let baseMatrix;
+    let baseBias;
+    if (baseIntent) {
+      assertDimension(baseIntent.bias, dim, "Base bias");
+      baseBias = new Float32Array(baseIntent.bias);
+      if (baseIntent.matrix instanceof Float32Array) {
+        assertDimension(baseIntent.matrix, dim * dim, "Base matrix");
+        baseMatrix = new Float32Array(baseIntent.matrix);
+      } else {
+        baseMatrix = flattenMatrix(baseIntent.matrix, dim, dim, "Base matrix");
+      }
+    } else {
+      baseMatrix = new Float32Array(dim * dim);
+      for (let i = 0; i < dim; i++) {
+        baseMatrix[i * dim + i] = 1;
+      }
+      baseBias = new Float32Array(dim);
+    }
+    const newMatrix = new Float32Array(baseMatrix);
+    const newBias = new Float32Array(baseBias);
+    for (let t = 0; t < tasks.length; t++) {
+      const { weights, scale } = tasks[t];
+      assertDimension(weights.bias, dim, `Task ${t} bias`);
+      const taskBias = new Float32Array(weights.bias);
+      let taskMatrix;
+      if (weights.matrix instanceof Float32Array) {
+        assertDimension(weights.matrix, dim * dim, `Task ${t} matrix`);
+        taskMatrix = weights.matrix;
+      } else {
+        taskMatrix = flattenMatrix(
+          weights.matrix,
+          dim,
+          dim,
+          `Task ${t} matrix`
+        );
+      }
+      addScaledVector(newMatrix, taskMatrix, scale);
+      addScaledVector(newMatrix, baseMatrix, -scale);
+      addScaledVector(newBias, taskBias, scale);
+      addScaledVector(newBias, baseBias, -scale);
+    }
     return {
-      vector: Array.from(vector),
-      topK,
-      ...filter ? { filter } : {}
+      matrix: newMatrix,
+      bias: newBias
     };
   }
+};
+
+// src/WarpPipeline.ts
+var WarpPipeline = class _WarpPipeline {
+  constructor(inputDim) {
+    this.inputDim = inputDim;
+  }
+  inputDim;
+  steps = [];
   /**
-   * Redis (RediSearch) のベクトルフィールド用に、
-   * Float32Array をバイナリ（Uint8Array）に変換します。
-   * Node.js環境では Buffer.from() を使って Buffer に変換して渡してください。
+   * アダプタの復元関数を保持するレジストリ。
+   * カスタムアダプタをパイプラインで利用・復元可能にするために使用します。
+   */
+  static adapterRegistry = /* @__PURE__ */ new Map();
+  /**
+   * カスタムアダプタをパイプラインのレジストリに登録します。
+   * これにより importState でカスタムアダプタを復元可能になります。
    *
-   * @example
-   * const blob = Buffer.from(VectorDBAdapter.toRedis(warpedVector));
-   * await redis.call('FT.SEARCH', 'idx', '*=>[KNN 5 @embedding $BLOB]', 'PARAMS', '2', 'BLOB', blob, 'DIALECT', '2');
+   * @param type アダプタの識別子 (例: "MyCustomAdapter")
+   * @param importFn 状態オブジェクトからアダプタインスタンスを復元する関数
+   */
+  static registerAdapter(type, importFn) {
+    _WarpPipeline.adapterRegistry.set(type, importFn);
+  }
+  /**
+   * フォーマット変換ロジックを保持するレジストリ。
+   */
+  static formatRegistry = /* @__PURE__ */ new Map();
+  /**
+   * カスタムの出力フォーマットを登録します。
+   * これにより、ユーザー独自のDB形式（Milvus, Weaviateなど）への変換を動的に追加できます。
    *
-   * @param {number[] | Float32Array} vector ワープ変換後のベクトル
-   * @returns {Uint8Array} バイナリデータ (Float32のバイト表現)
+   * @param format フォーマット名 (例: "pgvector")
+   * @param formatFn 変換を行うコールバック関数
    */
-  static toRedis(vector) {
-    const f32Array = vector instanceof Float32Array ? vector : new Float32Array(vector);
-    return new Uint8Array(
-      f32Array.buffer.slice(
-        f32Array.byteOffset,
-        f32Array.byteOffset + f32Array.byteLength
-      )
+  static registerFormat(format, formatFn) {
+    _WarpPipeline.formatRegistry.set(format, formatFn);
+  }
+  /**
+   * IntentAdapter (意図による線形変換) をパイプラインに追加します。
+   */
+  addIntent(intents) {
+    const adapter = new IntentAdapter(intents || this.inputDim);
+    this.steps.push({ type: "IntentAdapter", adapter });
+    return this;
+  }
+  /**
+   * LoraIntentAdapter (低ランク適応による線形変換) をパイプラインに追加します。
+   */
+  addLoraIntent(rank, intents) {
+    const adapter = new LoraIntentAdapter(this.inputDim, rank, intents);
+    this.steps.push({ type: "LoraIntentAdapter", adapter });
+    return this;
+  }
+  /**
+   * WhiteningAdapter (PCAによる空間的偏りの除去) をパイプラインに追加します。
+   */
+  addWhitening(options) {
+    const adapter = new WhiteningAdapter(this.inputDim, options);
+    this.steps.push({ type: "WhiteningAdapter", adapter });
+    return this;
+  }
+  /**
+   * ProjectionAdapter (次元圧縮) をパイプラインに追加します。
+   */
+  addProjection(outputDim, projections) {
+    const adapter = new ProjectionAdapter(
+      this.inputDim,
+      outputDim,
+      projections
     );
+    this.steps.push({ type: "ProjectionAdapter", adapter });
+    this.inputDim = outputDim;
+    return this;
+  }
+  /**
+   * MlpAdapter (多層ニューラルネットワーク / 非線形推論) をパイプラインに追加します。
+   */
+  addMlp(layers) {
+    const adapter = new MlpAdapter(layers);
+    this.steps.push({ type: "MlpAdapter", adapter });
+    const lastLayer = layers[layers.length - 1];
+    if (lastLayer.matrix instanceof Float32Array) {
+      this.inputDim = lastLayer.bias.length;
+    } else {
+      this.inputDim = lastLayer.matrix.length;
+    }
+    return this;
+  }
+  /**
+   * QuantizationAdapter (ベクトル量子化 / 圧縮) をパイプラインに追加します。
+   * これは通常、パイプラインの最後のステップとして使用されます。
+   */
+  quantize(type) {
+    const adapter = new QuantizationAdapter({ type, dim: this.inputDim });
+    this.steps.push({ type: "QuantizationAdapter", adapter });
+    return this;
+  }
+  /**
+   * カスタムアダプタを直接パイプラインの末尾に追加します。
+   * (ビルダーパターンで独自の拡張アダプタを組み込む際に使用します)
+   *
+   * @param type アダプタの識別子（レジストリ登録名と一致させることを推奨）
+   * @param adapter WarpAdapterを実装したインスタンス
+   */
+  addStep(type, adapter) {
+    this.steps.push({ type, adapter });
+    return this;
+  }
+  /**
+   * パイプライン内に WASM などの非同期初期化を必要とするアダプタが含まれている場合、
+   * それらを一括でセットアップします。
+   */
+  async init() {
+    for (const step of this.steps) {
+      if (typeof step.adapter.init === "function") {
+        await step.adapter.init();
+      }
+    }
+  }
+  /**
+   * パイプラインを順次実行し、入力ベクトルを最終的な表現に変換します。
+   *
+   * @param vector 変換元のベースベクトル
+   * @param context インテントやバージョンなどのコンテキスト情報
+   * @returns パイプラインを通過した最終的なベクトル (Float32Array または Uint8Array/Int8Array)
+   */
+  run(vector, context) {
+    let currentVector = vector;
+    for (const step of this.steps) {
+      currentVector = step.adapter.tune(
+        currentVector,
+        context?.intent || "default"
+      );
+    }
+    return currentVector;
+  }
+  /**
+   * 複数のベクトル（バッチ）を一括でパイプラインに通します。
+   * 内部の tuneBatch が実装されているアダプタでは WASM/SIMD による高速処理が適用されます。
+   *
+   * @param vectors 変換元のベースベクトルの配列
+   * @param context インテントやバージョンなどのコンテキスト情報
+   * @returns 変換されたベクトルの配列
+   */
+  runBatch(vectors, context) {
+    let currentVectors = vectors;
+    for (const step of this.steps) {
+      if (typeof step.adapter.tuneBatch === "function") {
+        currentVectors = step.adapter.tuneBatch(
+          currentVectors,
+          context?.intent || "default"
+        );
+      } else {
+        currentVectors = currentVectors.map(
+          (vec) => step.adapter.tune(vec, context?.intent || "default")
+        );
+      }
+    }
+    return currentVectors;
+  }
+  /**
+   * ベクトル変換から特定データベース向けのフォーマットまでを1回の呼び出しで行います。
+   *
+   * @param vector 変換元のベースベクトル
+   * @param dbOptions フォーマットの指定オプション
+   * @param context パイプラインのコンテキスト
+   * @returns 指定されたデータベース形式のオブジェクトや文字列
+   */
+  runAndFormat(vector, dbOptions, context) {
+    const tunedVector = this.run(vector, context);
+    const formatFn = _WarpPipeline.formatRegistry.get(dbOptions.format);
+    if (!formatFn) {
+      throw new Error(
+        `Unknown format: ${dbOptions.format}. Did you forget to register it?`
+      );
+    }
+    return formatFn(tunedVector, dbOptions);
+  }
+  /**
+   * パイプライン内の全アダプタの状態（学習済みの重みなど）を JSON 化可能な配列として出力します。
+   * これにより、DBやRedis等への永続化が容易になります。
+   */
+  exportState() {
+    return this.steps.map((step) => {
+      const state = typeof step.adapter.exportState === "function" ? step.adapter.exportState() : null;
+      return {
+        type: step.type,
+        state
+      };
+    });
+  }
+  /**
+   * エクスポートされた JSON 状態から、パイプラインを完全に復元（再構築）します。
+   * @param states exportState で出力された配列
+   * @returns 復元された新しい WarpPipeline インスタンス
+   */
+  static importState(states) {
+    if (!states || states.length === 0) {
+      throw new Error("No states provided to import.");
+    }
+    const pipeline = new _WarpPipeline(0);
+    for (const step of states) {
+      const importFn = _WarpPipeline.adapterRegistry.get(step.type);
+      if (!importFn) {
+        throw new Error(
+          `Unknown adapter type: ${step.type}. Did you forget to register it via WarpPipeline.registerAdapter?`
+        );
+      }
+      const adapter = importFn(step.state);
+      pipeline.steps.push({ type: step.type, adapter });
+    }
+    if (pipeline.steps.length > 0) {
+    }
+    return pipeline;
   }
 };
+WarpPipeline.registerAdapter(
+  "IntentAdapter",
+  (state) => IntentAdapter.importState(state)
+);
+WarpPipeline.registerAdapter(
+  "LoraIntentAdapter",
+  (state) => LoraIntentAdapter.importState(state)
+);
+WarpPipeline.registerAdapter(
+  "WhiteningAdapter",
+  (state) => WhiteningAdapter.importState(state)
+);
+WarpPipeline.registerAdapter(
+  "ProjectionAdapter",
+  (state) => ProjectionAdapter.importState(state)
+);
+WarpPipeline.registerAdapter(
+  "MlpAdapter",
+  (state) => MlpAdapter.importState(state)
+);
+WarpPipeline.registerAdapter(
+  "QuantizationAdapter",
+  (state) => QuantizationAdapter.importState(state)
+);
+WarpPipeline.registerFormat(
+  "pgvector",
+  (vec, _opts) => VectorDBAdapter.toPgvector(vec)
+);
+WarpPipeline.registerFormat(
+  "pinecone",
+  (vec, opts) => VectorDBAdapter.toPineconeQuery(
+    vec,
+    opts.topK,
+    opts.filter
+  )
+);
+WarpPipeline.registerFormat(
+  "redis",
+  (vec, _opts) => VectorDBAdapter.toRedis(vec)
+);
 export {
+  ColbertAdapter,
+  InfoNCETrainer,
   IntentAdapter,
   IntentTrainer,
   LoraIntentAdapter,
   MigrationTrainer,
+  MlpAdapter,
   ProjectionAdapter,
+  QuantizationAdapter,
+  TaskArithmetic,
+  TripletTrainer,
   VectorDBAdapter,
+  VsaAdapter,
+  WarpEmbeddings,
+  WarpLlamaIndexEmbeddings,
+  WarpPipeline,
+  WhiteningAdapter,
+  addScaledVector,
   applyActivationToVector,
+  applyAffine,
   assertDimension,
   cosineSimilarity,
   flattenMatrix,
+  getFlatMatrixAndBias,
   innerProduct,
+  integrations_exports as integrations,
   normalize,
   reject,
+  rrf,
+  rsf,
   slerp,
-  softmax
+  softmax,
+  withWarpVector
 };