warpvector 0.1.0

package/dist/index.js

@@ -0,0 +1,1298 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  IntentAdapter: () => IntentAdapter,
+  IntentTrainer: () => IntentTrainer,
+  LoraIntentAdapter: () => LoraIntentAdapter,
+  MigrationTrainer: () => MigrationTrainer,
+  ProjectionAdapter: () => ProjectionAdapter,
+  VectorDBAdapter: () => VectorDBAdapter,
+  applyActivationToVector: () => applyActivationToVector,
+  assertDimension: () => assertDimension,
+  cosineSimilarity: () => cosineSimilarity,
+  flattenMatrix: () => flattenMatrix,
+  innerProduct: () => innerProduct,
+  normalize: () => normalize,
+  reject: () => reject,
+  slerp: () => slerp,
+  softmax: () => softmax
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils.ts
+function normalize(vector) {
+  const dim = vector.length;
+  let sumOfSquares = 0;
+  for (let i = 0; i < dim; i++) {
+    const val = vector[i];
+    sumOfSquares += val * val;
+  }
+  const norm = Math.sqrt(sumOfSquares);
+  const result = new Float32Array(dim);
+  if (norm === 0) {
+    return result;
+  }
+  for (let i = 0; i < dim; i++) {
+    result[i] = vector[i] / norm;
+  }
+  return result;
+}
+function slerp(v1, v2, t) {
+  const dim = v1.length;
+  if (dim !== v2.length) {
+    throw new Error("Vectors must have the same dimension for slerp.");
+  }
+  let dot = 0;
+  let norm1Sq = 0;
+  let norm2Sq = 0;
+  for (let i = 0; i < dim; i++) {
+    dot += v1[i] * v2[i];
+    norm1Sq += v1[i] * v1[i];
+    norm2Sq += v2[i] * v2[i];
+  }
+  const norm1 = Math.sqrt(norm1Sq);
+  const norm2 = Math.sqrt(norm2Sq);
+  if (norm1 === 0 || norm2 === 0) {
+    throw new Error("Cannot apply slerp on zero vectors.");
+  }
+  let cosTheta = dot / (norm1 * norm2);
+  cosTheta = Math.max(-1, Math.min(1, cosTheta));
+  const theta = Math.acos(cosTheta);
+  const sinTheta = Math.sin(theta);
+  const result = new Float32Array(dim);
+  if (sinTheta < 1e-6) {
+    for (let i = 0; i < dim; i++) {
+      result[i] = v1[i] + t * (v2[i] - v1[i]);
+    }
+    return result;
+  }
+  const w1 = Math.sin((1 - t) * theta) / sinTheta;
+  const w2 = Math.sin(t * theta) / sinTheta;
+  const interpolatedMagnitude = norm1 + t * (norm2 - norm1);
+  for (let i = 0; i < dim; i++) {
+    const scaledV1 = v1[i] / norm1;
+    const scaledV2 = v2[i] / norm2;
+    result[i] = (scaledV1 * w1 + scaledV2 * w2) * interpolatedMagnitude;
+  }
+  return result;
+}
+function innerProduct(v1, v2) {
+  const dim = v1.length;
+  if (dim !== v2.length) {
+    throw new Error("Vectors must have the same dimension.");
+  }
+  let dot = 0;
+  for (let i = 0; i < dim; i++) {
+    dot += v1[i] * v2[i];
+  }
+  return dot;
+}
+function cosineSimilarity(v1, v2) {
+  const dim = v1.length;
+  if (dim !== v2.length) {
+    throw new Error("Vectors must have the same dimension.");
+  }
+  let dot = 0;
+  let norm1Sq = 0;
+  let norm2Sq = 0;
+  for (let i = 0; i < dim; i++) {
+    const val1 = v1[i];
+    const val2 = v2[i];
+    dot += val1 * val2;
+    norm1Sq += val1 * val1;
+    norm2Sq += val2 * val2;
+  }
+  if (norm1Sq === 0 || norm2Sq === 0) return 0;
+  return dot / (Math.sqrt(norm1Sq) * Math.sqrt(norm2Sq));
+}
+function reject(baseVector, negativeVector) {
+  const dim = baseVector.length;
+  if (dim !== negativeVector.length) {
+    throw new Error("Vectors must have the same dimension.");
+  }
+  let dotVU = 0;
+  let dotUU = 0;
+  for (let i = 0; i < dim; i++) {
+    const u = negativeVector[i];
+    dotVU += baseVector[i] * u;
+    dotUU += u * u;
+  }
+  if (dotUU === 0) {
+    const result2 = new Float32Array(dim);
+    result2.set(baseVector);
+    return result2;
+  }
+  const scalar = dotVU / dotUU;
+  const result = new Float32Array(dim);
+  for (let i = 0; i < dim; i++) {
+    result[i] = baseVector[i] - scalar * negativeVector[i];
+  }
+  return result;
+}
+function applyActivationToVector(vector, activation) {
+  if (!activation) return;
+  const dim = vector.length;
+  if (activation === "relu") {
+    for (let i = 0; i < dim; i++) {
+      if (vector[i] < 0) vector[i] = 0;
+    }
+  } else if (activation === "sigmoid") {
+    for (let i = 0; i < dim; i++) {
+      vector[i] = 1 / (1 + Math.exp(-vector[i]));
+    }
+  } else if (activation === "tanh") {
+    for (let i = 0; i < dim; i++) {
+      vector[i] = Math.tanh(vector[i]);
+    }
+  }
+}
+function softmax(values) {
+  if (values.length === 0) return [];
+  const max = Math.max(...values);
+  let sum = 0;
+  const exps = values.map((v) => {
+    const e = Math.exp(v - max);
+    sum += e;
+    return e;
+  });
+  return exps.map((e) => e / sum);
+}
+function flattenMatrix(matrix, rows, cols, contextName = "Matrix") {
+  if (matrix.length !== rows) {
+    throw new Error(
+      `${contextName}: Row dimension mismatch. Expected ${rows}, got ${matrix.length}.`
+    );
+  }
+  const flat = new Float32Array(rows * cols);
+  for (let i = 0; i < rows; i++) {
+    if (matrix[i].length !== cols) {
+      throw new Error(
+        `${contextName}: Column dimension mismatch at row ${i}. Expected ${cols}, got ${matrix[i].length}.`
+      );
+    }
+    for (let j = 0; j < cols; j++) {
+      flat[i * cols + j] = matrix[i][j];
+    }
+  }
+  return flat;
+}
+function assertDimension(vector, expectedDimension, contextName = "Vector") {
+  if (vector.length !== expectedDimension) {
+    throw new Error(
+      `${contextName} dimension mismatch. Expected ${expectedDimension}, got ${vector.length}.`
+    );
+  }
+}
+
+// src/wasm/wasm-binary.ts
+var wasmBase64 = "AGFzbQEAAAABGQJgBn9/f39/fwBgDH9/f39/f319fX9/fwADAwIAAQUDAQAABzADDXR1bmVCYXRjaFdhc20AABNzZ2RNb21lbnR1bVN0ZXBXYXNtAAEGbWVtb3J5AgAK4QMCoAECBX8BfQNAIAUgCEoEQEEAIQYDQCAEIAZKBEBDAAAAACELIAQgBmwhCSAEIAhsIQpBACEHA0AgBCAHSgRAIAsgACAHIAlqQQJ0aioCACACIAcgCmpBAnRqKgIAlJIhCyAHQQFqIQcMAQsLIAMgBCAIbCAGakECdGogCyABIAZBAnRqKgIAkjgCACAGQQFqIQYMAQsLIAhBAWohCAwBCwsLvAICBX8DfQNAIAogDUoEQEMAAAAAIREgCSANbCEPQQAhDANAIAkgDEoEQCARIAAgDCAPakECdGoqAgAgBCAMQQJ0aioCAJSSIREgDEEBaiEMDAELCyANQQJ0IgwgC2ogESABIAxqKgIAkjgCACANQQFqIQ0MAQsLA0AgCiAOSgRAIA5BAnQiDCALaioCACAFIAxqKgIAkyERIAggAyAMaiINKgIAlCAGIBGUkyESIA0gEjgCACABIAxqIgwgDCoCACASkjgCACAJIA5sIQ9BACEMA0AgCSAMSgRAIAwgD2pBAnQiECAAaiINKgIAIRIgCCACIBBqIhAqAgCUIAYgESAEIAxBAnRqKgIAlCAHIBKUkpSTIRMgECATOAIAIA0gEiATkjgCACAMQQFqIQwMAQsLIA5BAWohDgwBCwsL";
+
+// src/wasm/wasm-loader.ts
+var wasmInstance = null;
+var wasmMemory = null;
+var initPromise = null;
+function getWasmMemory() {
+  return wasmMemory;
+}
+function getWasmInstance() {
+  return wasmInstance;
+}
+async function initWasm() {
+  if (wasmInstance) return wasmInstance;
+  if (initPromise) return initPromise;
+  try {
+    const bytes = Uint8Array.from(atob(wasmBase64), (c) => c.charCodeAt(0));
+    const module2 = await WebAssembly.compile(bytes);
+    wasmInstance = new WebAssembly.Instance(module2);
+    wasmMemory = wasmInstance.exports.memory;
+    return wasmInstance;
+  } catch (e) {
+    console.warn("WASM initialization failed, falling back to JS.", e);
+    return null;
+  }
+}
+function ensureWasmMemory(requiredBytes) {
+  if (!wasmMemory) return false;
+  if (requiredBytes <= wasmMemory.buffer.byteLength) {
+    return true;
+  }
+  const currentPages = wasmMemory.buffer.byteLength / 65536;
+  const requiredPages = Math.ceil(requiredBytes / 65536);
+  try {
+    wasmMemory.grow(requiredPages - currentPages);
+    return true;
+  } catch (e) {
+    console.warn("WASM memory grow failed", e);
+    return false;
+  }
+}
+
+// src/IntentAdapter.ts
+var IntentAdapter = class {
+  dimension;
+  matrices;
+  biases;
+  routingVectors;
+  /**
+   * IntentAdapter を初期化します。
+   * 行列とバイアスを Float32Array にコンパイルし、キャッシュ局所性と計算速度を最適化します。
+   *
+   * @constructor
+   * @param {Record<string, IntentWeights> | number} intentsOrDimension - 各インテント名と IntentWeights のマッピング、または次元数（空から始める場合）
+   * @throws {Error} インテントが一つも提供されておらず、次元数も不明な場合にエラーをスローします。
+   */
+  constructor(intentsOrDimension) {
+    this.matrices = /* @__PURE__ */ new Map();
+    this.biases = /* @__PURE__ */ new Map();
+    this.routingVectors = /* @__PURE__ */ new Map();
+    if (typeof intentsOrDimension === "number") {
+      this.dimension = intentsOrDimension;
+    } else {
+      const intentKeys = Object.keys(intentsOrDimension);
+      if (intentKeys.length === 0) {
+        throw new Error(
+          "At least one intent or a specific dimension must be provided."
+        );
+      }
+      const firstIntent = intentsOrDimension[intentKeys[0]];
+      this.dimension = firstIntent.bias.length;
+      for (const [intentName, weights] of Object.entries(intentsOrDimension)) {
+        this.addIntent(intentName, weights);
+      }
+    }
+  }
+  /**
+   * 実行時に新しい意図を動的に追加または更新します。
+   *
+   * @param {string} intentName - 追加する意図の名前
+   * @param {IntentWeights} weights - 意図の重み（行列とバイアス、任意でルーティングベクトル）
+   * @throws {Error} 行列やバイアスの次元数が現在の次元数と一致しない場合にエラーをスローします。
+   * @returns {void}
+   */
+  addIntent(intentName, weights) {
+    const { matrix, bias, routingVector } = weights;
+    assertDimension(bias, this.dimension, `Intent '${intentName}' Bias`);
+    let flatMatrix;
+    if (matrix instanceof Float32Array) {
+      assertDimension(
+        matrix,
+        this.dimension * this.dimension,
+        `Intent '${intentName}' Flat matrix`
+      );
+      flatMatrix = new Float32Array(matrix);
+    } else {
+      flatMatrix = flattenMatrix(
+        matrix,
+        this.dimension,
+        this.dimension,
+        `Intent '${intentName}' Matrix`
+      );
+    }
+    this.matrices.set(intentName, flatMatrix);
+    this.biases.set(intentName, new Float32Array(bias));
+    if (routingVector) {
+      assertDimension(
+        routingVector,
+        this.dimension,
+        `Intent '${intentName}' Routing vector`
+      );
+      this.routingVectors.set(intentName, new Float32Array(routingVector));
+    }
+  }
+  /**
+   * 指定した意図を削除します。
+   *
+   * @param {string} intentName - 削除する意図の名前
+   * @returns {void}
+   */
+  removeIntent(intentName) {
+    this.matrices.delete(intentName);
+    this.biases.delete(intentName);
+    this.routingVectors.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];
+    }
+  }
+  /**
+   * 複数の意図を指定された重みでブレンドした一時的な行列とバイアスを計算します。
+   * W_blend = Σ(w_i * W_i), b_blend = Σ(w_i * b_i)
+   *
+   * @param {Record<string, number>} blendWeights - ブレンドする各意図の重みマップ
+   * @returns {{matrix: Float32Array, bias: Float32Array}} ブレンドされた合成行列とバイアス
+   * @throws {Error} 指定された意図が見つからない場合にエラーをスローします。
+   */
+  computeBlendedWeights(blendWeights) {
+    const dim = this.dimension;
+    const blendedMatrix = new Float32Array(dim * dim);
+    const blendedBias = new Float32Array(dim);
+    for (const [intentName, weight] of Object.entries(blendWeights)) {
+      const matrix = this.matrices.get(intentName);
+      const bias = this.biases.get(intentName);
+      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;
+        }
+      }
+    }
+    return { matrix: blendedMatrix, bias: blendedBias };
+  }
+  /**
+   * 指定された意図（intent）に基づいて、ベースベクトルにアフィン変換を適用します。
+   * 数式: x' = W_I * x + b_I
+   *
+   * @param {number[] | Float32Array} baseVector - 変換元のベクトル
+   * @param {string} intent - 適用する意図（intent）の名前
+   * @param {Activation} [activation] - （オプション）変換後に適用する非線形活性化関数
+   * @returns {Float32Array} 変換後のベクトル
+   * @throws {Error} ベクトルの次元数が一致しない場合、または指定された意図が存在しない場合にエラーをスローします。
+   */
+  tune(baseVector, intent, activation) {
+    assertDimension(baseVector, this.dimension, "Base vector");
+    const matrix = this.matrices.get(intent);
+    const bias = this.biases.get(intent);
+    if (!matrix || !bias) {
+      throw new Error(`Intent '${intent}' not found.`);
+    }
+    const result = new Float32Array(this.dimension);
+    this.applyAffine(matrix, bias, baseVector, result);
+    applyActivationToVector(result, activation);
+    return result;
+  }
+  /**
+   * 複数のベースベクトルに対して、指定された意図のアフィン変換をバッチ処理で適用します。
+   * メモリと条件が許せば、自動的にWASM/SIMDエンジンにオフロードして超高速処理を行います。
+   *
+   * @param {(number[] | Float32Array)[]} baseVectors - 変換元のベクトルの配列 (2次元配列)
+   * @param {string} intent - 適用する意図（intent）の名前
+   * @param {Activation} [activation] - （オプション）非線形活性化関数
+   * @returns {Float32Array[]} 変換後のベクトルの配列
+   * @throws {Error} 指定された意図が存在しない場合や入力ベクトルの次元が不正な場合にエラーをスローします。
+   */
+  tuneBatch(baseVectors, intent, activation) {
+    const matrix = this.matrices.get(intent);
+    const bias = this.biases.get(intent);
+    if (!matrix || !bias) {
+      throw new Error(`Intent '${intent}' not found.`);
+    }
+    const batchSize = baseVectors.length;
+    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);
+      let ptr = 0;
+      const matrixPtr = ptr;
+      f32Mem.set(matrix, ptr);
+      ptr += this.dimension * this.dimension;
+      const biasPtr = ptr;
+      f32Mem.set(bias, ptr);
+      ptr += this.dimension;
+      const vectorsPtr = ptr;
+      for (let k = 0; k < batchSize; k++) {
+        f32Mem.set(baseVectors[k], ptr + k * this.dimension);
+      }
+      ptr += batchSize * this.dimension;
+      const resultsPtr = ptr;
+      const tuneBatchWasm = instance.exports.tuneBatchWasm;
+      tuneBatchWasm(
+        matrixPtr * 4,
+        biasPtr * 4,
+        vectorsPtr * 4,
+        resultsPtr * 4,
+        this.dimension,
+        batchSize
+      );
+      const results2 = new Array(batchSize);
+      for (let k = 0; k < batchSize; k++) {
+        const res = f32Mem.slice(
+          resultsPtr + k * this.dimension,
+          resultsPtr + (k + 1) * this.dimension
+        );
+        applyActivationToVector(res, activation);
+        results2[k] = res;
+      }
+      return results2;
+    }
+    const results = new Array(batchSize);
+    for (let k = 0; k < batchSize; k++) {
+      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);
+      applyActivationToVector(result, activation);
+      results[k] = result;
+    }
+    return results;
+  }
+  /**
+   * 複数の意図を指定された重みでブレンドし、ベクトルにアフィン変換を適用します。
+   *
+   * @param {number[] | Float32Array} baseVector - 変換元のベクトル
+   * @param {Record<string, number>} blendWeights - 意図の名前と重みのマッピング (例: { riskAnalysis: 0.7, economicImpact: 0.3 })
+   * @param {Activation} [activation] - （オプション）非線形活性化関数
+   * @returns {Float32Array} 変換後のベクトル
+   * @throws {Error} 入力ベクトルの次元が不正な場合、または指定された意図が存在しない場合にエラーをスローします。
+   */
+  tuneBlended(baseVector, blendWeights, activation) {
+    assertDimension(baseVector, this.dimension, "Base vector");
+    const { matrix, bias } = this.computeBlendedWeights(blendWeights);
+    const result = new Float32Array(this.dimension);
+    this.applyAffine(matrix, bias, baseVector, result);
+    applyActivationToVector(result, activation);
+    return result;
+  }
+  /**
+   * 複数の意図を指定された重みでブレンドし、複数のベクトルに一括で適用します。
+   * これもバッチ処理と同様に自動的にWASM最適化が有効になります。
+   *
+   * @param {(number[] | Float32Array)[]} baseVectors - 変換元のベクトルの配列
+   * @param {Record<string, number>} blendWeights - 意図の名前と重みのマッピング
+   * @param {Activation} [activation] - （オプション）非線形活性化関数
+   * @returns {Float32Array[]} 変換後のベクトルの配列
+   * @throws {Error} ベクトルの次元数が一致しない場合、または指定された意図が存在しない場合にエラーをスローします。
+   */
+  tuneBatchBlended(baseVectors, blendWeights, activation) {
+    const { matrix, bias } = this.computeBlendedWeights(blendWeights);
+    const batchSize = baseVectors.length;
+    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);
+      let ptr = 0;
+      const matrixPtr = ptr;
+      f32Mem.set(matrix, ptr);
+      ptr += this.dimension * this.dimension;
+      const biasPtr = ptr;
+      f32Mem.set(bias, ptr);
+      ptr += this.dimension;
+      const vectorsPtr = ptr;
+      for (let k = 0; k < batchSize; k++) {
+        f32Mem.set(baseVectors[k], ptr + k * this.dimension);
+      }
+      ptr += batchSize * this.dimension;
+      const resultsPtr = ptr;
+      const tuneBatchWasm = instance.exports.tuneBatchWasm;
+      tuneBatchWasm(
+        matrixPtr * 4,
+        biasPtr * 4,
+        vectorsPtr * 4,
+        resultsPtr * 4,
+        this.dimension,
+        batchSize
+      );
+      const results2 = new Array(batchSize);
+      for (let k = 0; k < batchSize; k++) {
+        const res = f32Mem.slice(
+          resultsPtr + k * this.dimension,
+          resultsPtr + (k + 1) * this.dimension
+        );
+        applyActivationToVector(res, activation);
+        results2[k] = res;
+      }
+      return results2;
+    }
+    const results = new Array(batchSize);
+    for (let k = 0; k < batchSize; k++) {
+      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);
+      applyActivationToVector(result, activation);
+      results[k] = result;
+    }
+    return results;
+  }
+  /**
+   * 自己アテンション型動的ブレンド (Auto-blending / Routing)
+   *
+   * クエリとして入力されたベースベクトル自体と、各意図の `routingVector`（代表ベクトル）の
+   * 類似度を比較し、Softmax関数により最適なブレンド比率を自動で算出・適用します。
+   *
+   * @param {number[] | Float32Array} baseVector - ユーザーからのクエリベクトルなど
+   * @param {Activation} [activation] - （オプション）非線形活性化関数
+   * @returns {Float32Array} 動的ブレンドによって変換されたベクトル
+   * @throws {Error} ベースベクトルの次元が異なる場合、またはルーティングベクトルが一つも存在しない場合にエラーをスローします。
+   */
+  tuneAutoBlended(baseVector, activation) {
+    assertDimension(baseVector, this.dimension, "Base vector");
+    const intentNames = [];
+    const scores = [];
+    for (const [intentName, vector] of this.routingVectors.entries()) {
+      intentNames.push(intentName);
+      scores.push(cosineSimilarity(baseVector, vector));
+    }
+    if (intentNames.length === 0) {
+      throw new Error("No routing vectors available for auto-blending.");
+    }
+    const weightsArray = softmax(scores);
+    const blendWeights = {};
+    for (let i = 0; i < intentNames.length; i++) {
+      blendWeights[intentNames[i]] = weightsArray[i];
+    }
+    return this.tuneBlended(baseVector, blendWeights, activation);
+  }
+  /**
+   * 学習済みの意図（IntentWeights）を軽量なバイナリ（Uint8Array）としてシリアライズします。
+   * これにより、JSONに比べてファイルサイズが劇的に小さくなり、ロードも高速になります。
+   *
+   * @param {string} intentName - エクスポートする意図の名前
+   * @returns {Uint8Array} シリアライズされたバイナリデータ
+   */
+  exportIntentBinary(intentName) {
+    const matrix = this.matrices.get(intentName);
+    const bias = this.biases.get(intentName);
+    const routingVector = this.routingVectors.get(intentName);
+    if (!matrix || !bias) {
+      throw new Error(`Intent '${intentName}' not found.`);
+    }
+    const dim = this.dimension;
+    const hasRouting = routingVector ? 1 : 0;
+    const totalBytes = 8 + dim * dim * 4 + dim * 4 + (hasRouting ? dim * 4 : 0);
+    const buffer = new ArrayBuffer(totalBytes);
+    const dataView = new DataView(buffer);
+    const uint8View = new Uint8Array(buffer);
+    dataView.setUint32(0, dim, true);
+    dataView.setUint8(4, hasRouting);
+    let offset = 8;
+    uint8View.set(
+      new Uint8Array(matrix.buffer, matrix.byteOffset, matrix.byteLength),
+      offset
+    );
+    offset += matrix.byteLength;
+    uint8View.set(
+      new Uint8Array(bias.buffer, bias.byteOffset, bias.byteLength),
+      offset
+    );
+    offset += bias.byteLength;
+    if (routingVector) {
+      uint8View.set(
+        new Uint8Array(
+          routingVector.buffer,
+          routingVector.byteOffset,
+          routingVector.byteLength
+        ),
+        offset
+      );
+    }
+    return uint8View;
+  }
+  /**
+   * バイナリデータ（Uint8Array）から IntentWeights を復元し、
+   * そのままアダプターに新しい意図として追加します。
+   *
+   * @param {string} intentName - 追加する意図の名前
+   * @param {Uint8Array} binary - exportIntentBinary で生成されたバイナリデータ
+   */
+  importIntentBinary(intentName, binary) {
+    if (binary.length < 8) {
+      throw new Error("Invalid binary format: too short.");
+    }
+    const dataView = new DataView(
+      binary.buffer,
+      binary.byteOffset,
+      binary.byteLength
+    );
+    const dim = dataView.getUint32(0, true);
+    const hasRouting = dataView.getUint8(4);
+    if (this.dimension !== void 0 && dim !== this.dimension) {
+      throw new Error(
+        `Dimension mismatch. Expected ${this.dimension}, got ${dim}.`
+      );
+    }
+    const expectedBytes = 8 + dim * dim * 4 + dim * 4 + (hasRouting ? dim * 4 : 0);
+    if (binary.length !== expectedBytes) {
+      throw new Error(
+        `Invalid binary length. Expected ${expectedBytes}, got ${binary.length}.`
+      );
+    }
+    let offset = 8;
+    const matrix = new Float32Array(dim * dim);
+    matrix.set(
+      new Float32Array(binary.buffer, binary.byteOffset + offset, dim * dim)
+    );
+    offset += dim * dim * 4;
+    const bias = new Float32Array(dim);
+    bias.set(new Float32Array(binary.buffer, binary.byteOffset + offset, dim));
+    offset += dim * 4;
+    let routingVector = void 0;
+    if (hasRouting) {
+      routingVector = new Float32Array(dim);
+      routingVector.set(
+        new Float32Array(binary.buffer, binary.byteOffset + offset, dim)
+      );
+    }
+    this.matrices.set(intentName, matrix);
+    this.biases.set(intentName, bias);
+    if (routingVector) {
+      this.routingVectors.set(intentName, routingVector);
+    }
+  }
+};
+
+// src/LoraIntentAdapter.ts
+var LoraIntentAdapter = class {
+  dimension;
+  rank;
+  // フラット化されたAとBの行列、およびバイアスを保存
+  matricesA;
+  matricesB;
+  biases;
+  /**
+   * LoraIntentAdapter を初期化します。
+   * 非常に高い次元（例：1536次元など）の埋め込みベクトルに対して、
+   * フルマトリックスの代わりに低ランク行列（A, B）を使用することで
+   * メモリ使用量と計算量を劇的に削減します。
+   *
+   * @constructor
+   * @param {number} dimension - ベクトル空間の元の次元数（D）
+   * @param {number} rank - 低ランク適応における中間ランク数（r）
+   * @param {Record<string, LoraIntentWeights>} [intents] - 初期化時に追加するインテントのマップ
+   */
+  constructor(dimension, rank, intents) {
+    this.dimension = dimension;
+    this.rank = rank;
+    this.matricesA = /* @__PURE__ */ new Map();
+    this.matricesB = /* @__PURE__ */ new Map();
+    this.biases = /* @__PURE__ */ new Map();
+    if (intents) {
+      for (const [intentName, weights] of Object.entries(intents)) {
+        this.addIntent(intentName, weights);
+      }
+    }
+  }
+  /**
+   * 実行時に新しいLoRA意図を動的に追加または更新します。
+   *
+   * @param {string} intentName - 追加または更新する意図の名前
+   * @param {LoraIntentWeights} weights - LoRA意図の重み（行列A、行列B、バイアス）
+   * @throws {Error} 行列またはバイアスの次元数が一致しない場合にエラーをスローします。
+   * @returns {void}
+   */
+  addIntent(intentName, weights) {
+    const { matrixA, matrixB, bias } = weights;
+    assertDimension(bias, this.dimension, `Intent '${intentName}' Bias`);
+    const flatA = flattenMatrix(
+      matrixA,
+      this.dimension,
+      this.rank,
+      `Intent '${intentName}' Matrix A`
+    );
+    const flatB = flattenMatrix(
+      matrixB,
+      this.rank,
+      this.dimension,
+      `Intent '${intentName}' Matrix B`
+    );
+    this.matricesA.set(intentName, flatA);
+    this.matricesB.set(intentName, flatB);
+    this.biases.set(intentName, new Float32Array(bias));
+  }
+  /**
+   * 指定したLoRA意図を削除します。
+   *
+   * @param {string} intentName - 削除する意図の名前
+   * @returns {void}
+   */
+  removeIntent(intentName) {
+    this.matricesA.delete(intentName);
+    this.matricesB.delete(intentName);
+    this.biases.delete(intentName);
+  }
+  /**
+   * LoRAアプローチを用いてベクトルにアフィン変換を適用します。
+   * 数式: x' = x + A(Bx) + b
+   *
+   * @param {number[] | Float32Array} baseVector - 変換元のベクトル
+   * @param {string} intent - 適用する意図の名前
+   * @returns {Float32Array} LoRA変換と残差結合が適用された新しいベクトル
+   * @throws {Error} ベクトルの次元数が一致しない、または指定された意図が存在しない場合にエラーをスローします。
+   */
+  tune(baseVector, intent) {
+    assertDimension(baseVector, this.dimension, "Base vector");
+    const matA = this.matricesA.get(intent);
+    const matB = this.matricesB.get(intent);
+    const bias = this.biases.get(intent);
+    if (!matA || !matB || !bias) {
+      throw new Error(`Intent '${intent}' not found.`);
+    }
+    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];
+      }
+      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];
+      }
+      result[i] = baseVector[i] + sum + bias[i];
+    }
+    return result;
+  }
+};
+
+// src/ProjectionAdapter.ts
+var ProjectionAdapter = class {
+  inDimension;
+  outDimension;
+  // フラット化された射影行列とバイアスを保存
+  matrices;
+  biases;
+  /**
+   * ProjectionAdapter を初期化します。
+   *
+   * @constructor
+   * @param {number} inDimension - 変換前の入力ベクトルの次元数
+   * @param {number} outDimension - 変換後の出力ベクトルの次元数
+   * @param {Record<string, ProjectionWeights>} [projections] - 初期化時に追加する射影設定のマップ
+   */
+  constructor(inDimension, outDimension, projections) {
+    this.inDimension = inDimension;
+    this.outDimension = outDimension;
+    this.matrices = /* @__PURE__ */ new Map();
+    this.biases = /* @__PURE__ */ new Map();
+    if (projections) {
+      for (const [name, weights] of Object.entries(projections)) {
+        this.addProjection(name, weights);
+      }
+    }
+  }
+  /**
+   * 実行時に新しい射影設定を動的に追加または更新します。
+   *
+   * @param {string} name - 追加または更新する射影設定の名前
+   * @param {ProjectionWeights} weights - 射影変換行列のデータ
+   * @throws {Error} 行列のサイズが指定された次元数と一致しない場合にエラーをスローします。
+   * @returns {void}
+   */
+  addProjection(name, weights) {
+    const { matrix } = weights;
+    const flatMatrix = flattenMatrix(
+      matrix,
+      this.outDimension,
+      this.inDimension,
+      `Projection '${name}' Matrix`
+    );
+    this.matrices.set(name, flatMatrix);
+    if (weights.bias) {
+      assertDimension(
+        weights.bias,
+        this.outDimension,
+        `Projection '${name}' Bias`
+      );
+      this.biases.set(name, new Float32Array(weights.bias));
+    } else {
+      this.biases.delete(name);
+    }
+  }
+  /**
+   * 指定した射影設定を削除します。
+   *
+   * @param {string} name - 削除する射影設定の名前
+   * @returns {void}
+   */
+  removeProjection(name) {
+    this.matrices.delete(name);
+    this.biases.delete(name);
+  }
+  /**
+   * ベクトルに射影変換を適用し、次元を変更した新しいベクトルを返します。
+   * 数式: y = W * x
+   *
+   * @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);
+    if (!matrix) {
+      throw new Error(`Projection '${projectionName}' 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];
+      }
+      result[i] = sum;
+    }
+    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}.`
+      );
+    }
+    if (target.length !== this.targetDimension) {
+      throw new Error(
+        `Target dimension mismatch. Expected ${this.targetDimension}.`
+      );
+    }
+    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);
+    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
+        );
+      }
+    }
+    return this.toWeights(flatMatrix, bias);
+  }
+  /**
+   * サンプルデータに対する短時間のテストランを行い、最も損失(Loss)が小さくなる最適な学習率を自動探索します。
+   * `options.autoTune` が true の場合に `train` メソッド内で自動的に呼び出されます。
+   *
+   * @param {BaseTrainingOptions} options 現在の学習オプション
+   * @returns {number} 探索された最適な学習率
+   */
+  findBestLearningRate(options) {
+    const candidateLrs = [0.1, 0.05, 0.01, 5e-3, 1e-3];
+    let bestLr = options.learningRate ?? 0.01;
+    let minLoss = Infinity;
+    const testEpochs = Math.min(10, options.epochs ?? 100);
+    const reg = options.regularization ?? 1e-3;
+    const momentum = options.momentum ?? 0.9;
+    const sDim = this.sourceDimension;
+    const tDim = this.targetDimension;
+    for (const lr of candidateLrs) {
+      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);
+      const vMatrix = new Float32Array(tDim * sDim);
+      const vBias = new Float32Array(tDim);
+      for (let epoch = 0; epoch < testEpochs; epoch++) {
+        for (const example of this.examples) {
+          const { source, target } = this.getInputs(example);
+          this.sgdMomentumStep(
+            flatMatrix,
+            bias,
+            vMatrix,
+            vBias,
+            source,
+            target,
+            lr,
+            reg,
+            momentum
+          );
+        }
+      }
+      let currentLoss = 0;
+      for (const example of this.examples) {
+        const { source, target } = this.getInputs(example);
+        const pred = new Float32Array(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;
+        }
+      }
+      if (currentLoss < minLoss) {
+        minLoss = currentLoss;
+        bestLr = lr;
+      }
+    }
+    return bestLr;
+  }
+  /**
+   * SGD + Momentum アルゴリズムによる1ステップのパラメータ更新を実行します。
+   * In-place (破壊的) に `matrix` と `bias` を更新します。
+   *
+   * @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];
+      }
+      pred[i] = sum + bias[i];
+    }
+    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];
+      }
+    }
+  }
+};
+
+// src/trainer.ts
+var IntentTrainer = class extends BaseTrainer {
+  dimension;
+  /**
+   * IntentTrainer のインスタンスを作成します。
+   * @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 };
+  }
+  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)
+    };
+  }
+  /**
+   * オンライン学習 (フィードバックループ) 用のメソッド。
+   * ユーザーのクリックなどの 1 回のフィードバックからリアルタイムに重みを微調整します。
+   *
+   * @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} 微調整された新しい重み
+   */
+  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}`);
+    }
+    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");
+    }
+    const bias = new Float32Array(currentWeights.bias);
+    const vMatrix = new Float32Array(dim * dim);
+    const vBias = new Float32Array(dim);
+    this.sgdMomentumStep(
+      flatMatrix,
+      bias,
+      vMatrix,
+      vBias,
+      input,
+      target,
+      learningRate,
+      regularization,
+      0
+      // no momentum for 1-shot online update
+    );
+    const newWeights = this.toWeights(flatMatrix, bias);
+    if (currentWeights.routingVector) {
+      newWeights.routingVector = [...currentWeights.routingVector];
+    }
+    return newWeights;
+  }
+};
+
+// src/migration.ts
+var MigrationTrainer = class extends BaseTrainer {
+  _sourceDimension;
+  _targetDimension;
+  /**
+   * @param {number} sourceDimension 移行元の次元数 (例: ada-002なら1536)
+   * @param {number} targetDimension 移行先の次元数 (例: text-embedding-3-smallなら512)
+   */
+  constructor(sourceDimension, targetDimension) {
+    super();
+    this._sourceDimension = sourceDimension;
+    this._targetDimension = targetDimension;
+  }
+  get sourceDimension() {
+    return this._sourceDimension;
+  }
+  get targetDimension() {
+    return this._targetDimension;
+  }
+  getInputs(example) {
+    return { source: example.source, target: example.target };
+  }
+  toWeights(flatMatrix, bias) {
+    const sDim = this.sourceDimension;
+    const tDim = this.targetDimension;
+    const outMatrix = new Array(tDim);
+    for (let i = 0; i < tDim; i++) {
+      const row = new Array(sDim);
+      const rowOffset = i * sDim;
+      for (let j = 0; j < sDim; j++) {
+        row[j] = flatMatrix[rowOffset + j];
+      }
+      outMatrix[i] = row;
+    }
+    return {
+      matrix: outMatrix,
+      bias: Array.from(bias)
+    };
+  }
+};
+
+// 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) {
+    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(vector);
+    return new Uint8Array(
+      f32Array.buffer.slice(
+        f32Array.byteOffset,
+        f32Array.byteOffset + f32Array.byteLength
+      )
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IntentAdapter,
+  IntentTrainer,
+  LoraIntentAdapter,
+  MigrationTrainer,
+  ProjectionAdapter,
+  VectorDBAdapter,
+  applyActivationToVector,
+  assertDimension,
+  cosineSimilarity,
+  flattenMatrix,
+  innerProduct,
+  normalize,
+  reject,
+  slerp,
+  softmax
+});