warpvector 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,3 +1,45 @@
+import * as _prisma_client_extension from '@prisma/client/extension';
+import * as _prisma_client_runtime_client from '@prisma/client/runtime/client';
+import { Embeddings, EmbeddingsParams } from '@langchain/core/embeddings';
+
+type InputVector = number[] | Float32Array;
+type OutputVector = Float32Array | Int8Array | Uint8Array;
+type AdapterState = Record<string, unknown> | string;
+/**
+ * WarpVector のすべてのベクトル変換アダプターに共通するインターフェース。
+ * 外部の統合ライブラリ（Prisma, LangChainなど）は、このインターフェースを通じて
+ * さまざまなアダプター（IntentAdapter, MlpAdapter, WhiteningAdapter など）を
+ * 透過的に扱うことができます。
+ */
+interface WarpAdapter {
+    /**
+     * 与えられたベクトルを変換（ワープ）します。
+     *
+     * @param vector 変換前のベクトル (number[] または Float32Array)
+     * @param context オプションのコンテキスト情報 (意図の名前、バージョンなど)
+     * @returns 変換後のベクトル (Float32Array, 量子化の場合は Int8Array や Uint8Array)
+     */
+    tune(vector: InputVector, context?: string): OutputVector;
+    /**
+     * 複数のベクトルを一括で変換します（オプション実装）
+     * WASMやSIMDを使用した最適化処理を提供します。
+     *
+     * @param vectors 変換前のベクトルの配列
+     * @param context オプションのコンテキスト情報
+     */
+    tuneBatch?(vectors: InputVector[], context?: string): OutputVector[];
+    /**
+     * 非同期での初期化処理（オプション実装）
+     * WASMのロードなどが必要なアダプタで実装します。
+     */
+    init?(): Promise<void>;
+    /**
+     * アダプタの状態（学習済み重みなど）をエクスポートします（オプション実装）
+     * importState に渡して完全に復元可能なJSON形式を返します。
+     */
+    exportState?(): AdapterState;
+}
+
 /**
  * 渡されたベクトルのL2ノルム（ユークリッド距離）を計算し、
  * 長さが1になるように正規化（normalize）した新しい Float32Array を返します。
@@ -29,6 +71,16 @@ declare function slerp(v1: number[] | Float32Array, v2: number[] | Float32Array,
  * @throws {Error} ベクトルの次元数が異なる場合にエラーをスローします。
  */
 declare function innerProduct(v1: number[] | Float32Array, v2: number[] | Float32Array): number;
+/**
+ * target ベクトルに対して、source ベクトルを定数倍したものを足し込みます（インプレース操作）。
+ * target += scale * source (BLAS の axpy 相当)
+ *
+ * @param target 更新対象のベクトル (In-place)
+ * @param source 足し込むベクトル
+ * @param scale 掛け合わせるスカラー値 (デフォルト: 1.0)
+ * @throws {Error} ベクトルの次元数が異なる場合にエラーをスローします。
+ */
+declare function addScaledVector(target: Float32Array | number[], source: Float32Array | number[], scale?: number): void;
 /**
  * コサイン類似度 (Cosine Similarity)
  * 2つのベクトル間のコサイン類似度 (-1.0 〜 1.0) を計算します。
@@ -52,14 +104,14 @@ declare function cosineSimilarity(v1: number[] | Float32Array, v2: number[] | Fl
 declare function reject(baseVector: number[] | Float32Array, negativeVector: number[] | Float32Array): Float32Array;
 /**
  * 活性化関数の種類を定義します。
- * @typedef {"relu" | "sigmoid" | "tanh"} Activation
+ * @typedef {"linear" | "relu" | "sigmoid" | "tanh"} Activation
  */
-type Activation = "relu" | "sigmoid" | "tanh";
+type Activation = "linear" | "relu" | "sigmoid" | "tanh";
 /**
  * ベクトルに対して非線形活性化関数を適用します (In-place処理)。
  *
  * @param {Float32Array} vector - 活性化関数を適用する対象のベクトル（直接変更されます）
- * @param {Activation} [activation] - 適用する活性化関数の種類（"relu", "sigmoid", "tanh"）
+ * @param {Activation} [activation] - 適用する活性化関数の種類（"linear", "relu", "sigmoid", "tanh"）
  * @returns {void}
  */
 declare function applyActivationToVector(vector: Float32Array, activation?: Activation): void;
@@ -91,6 +143,33 @@ declare function flattenMatrix(matrix: number[][], rows: number, cols: number, c
  * @throws {Error} 次元数が一致しない場合にエラーをスローします。
  */
 declare function assertDimension(vector: number[] | Float32Array, expectedDimension: number, contextName?: string): void;
+/**
+ * 変換行列とバイアスを持つオブジェクトから、処理しやすいFloat32Arrayのセットを生成します。
+ *
+ * @param weights 行列(2Dまたは1D)とバイアスを含むオブジェクト
+ * @param dim 次元数
+ * @param contextName エラー時のコンテキスト名
+ * @returns 1次元化されたFloat32Arrayの行列とバイアス
+ */
+declare function getFlatMatrixAndBias(weights: {
+    matrix: number[][] | Float32Array;
+    bias: number[] | Float32Array;
+}, dim: number, contextName?: string): {
+    flatMatrix: Float32Array;
+    bias: Float32Array;
+};
+/**
+ * ベクトルに対してアフィン変換 (x' = W * x + b) を適用します。
+ * 次元削減/拡張 (M x N) にも対応しています。
+ *
+ * @param matrix 1次元にフラット化された変換行列 (outDim x inDim)
+ * @param bias バイアスベクトル (outDim)。省略可能
+ * @param vector 変換元の入力ベクトル (inDim)
+ * @param result 計算結果を格納する配列 (出力先, outDim)
+ * @param inDim 入力ベクトルの次元数
+ * @param outDim 出力ベクトルの次元数 (省略時は inDim と同じ)
+ */
+declare function applyAffine(matrix: Float32Array, bias: Float32Array | undefined | null, vector: number[] | Float32Array, result: Float32Array, inDim: number, outDim?: number): void;
 
 /**
  * 意図（コンテキスト）ごとの変換情報を定義するインターフェース
@@ -119,7 +198,8 @@ interface IntentWeights {
  * パフォーマンスのために内部ではすべての配列を Float32Array として扱い、
  * 大規模なバッチ処理には自動的にWASM/SIMDによる最適化を利用します。
  */
-declare class IntentAdapter {
+declare class IntentAdapter implements WarpAdapter {
+    private weightsMap;
     private readonly dimension;
     private readonly matrices;
     private readonly biases;
@@ -149,16 +229,6 @@ declare class IntentAdapter {
      * @returns {void}
      */
     removeIntent(intentName: string): void;
-    /**
-     * 行列とバイアスを用いてベクトルにアフィン変換を適用する内部関数 (x' = W * x + b)
-     *
-     * @param {Float32Array} matrix - フラット化された変換行列
-     * @param {Float32Array} bias - バイアスベクトル
-     * @param {number[] | Float32Array} vector - 変換元の入力ベクトル
-     * @param {Float32Array} result - 計算結果を格納する配列 (出力先)
-     * @returns {void}
-     */
-    private applyAffine;
     /**
      * 複数の意図を指定された重みでブレンドした一時的な行列とバイアスを計算します。
      * W_blend = Σ(w_i * W_i), b_blend = Σ(w_i * b_i)
@@ -239,6 +309,15 @@ declare class IntentAdapter {
      * @param {Uint8Array} binary - exportIntentBinary で生成されたバイナリデータ
      */
     importIntentBinary(intentName: string, binary: Uint8Array): void;
+    /**
+     * 現在の IntentAdapter の全状態（全インテント）を JSON としてシリアライズしてエクスポートします。
+     * (WarpPipeline 等の統合管理用)
+     */
+    exportState(): string;
+    /**
+     * エクスポートされた JSON 状態から IntentAdapter を復元します。
+     */
+    static importState(stateJson: string): IntentAdapter;
 }
 
 /**
@@ -266,7 +345,7 @@ interface LoraIntentWeights {
  * LoraIntentAdapter クラス
  * 低ランク行列（A, B）を使用して高次元ベクトルのアフィン変換をメモリ効率良く行います。
  */
-declare class LoraIntentAdapter {
+declare class LoraIntentAdapter implements WarpAdapter {
     private readonly dimension;
     private readonly rank;
     private readonly matricesA;
@@ -310,8 +389,47 @@ declare class LoraIntentAdapter {
      * @throws {Error} ベクトルの次元数が一致しない、または指定された意図が存在しない場合にエラーをスローします。
      */
     tune(baseVector: number[] | Float32Array, intent: string): Float32Array;
+    /**
+     * 現在の LoraIntentAdapter の全状態を JSON としてエクスポートします。
+     */
+    exportState(): string;
+    /**
+     * エクスポートされた JSON 状態から LoraIntentAdapter を復元します。
+     */
+    static importState(stateJson: string): LoraIntentAdapter;
 }
 
+interface RankedResult {
+    id: string | number;
+    score?: number;
+    rank?: number;
+    metadata?: Record<string, any>;
+}
+interface FusionResult {
+    id: string | number;
+    score: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Reciprocal Rank Fusion (RRF) を計算し、複数の検索結果リストを統合します。
+ * スコアの絶対値に依存せず、各リスト内での「順位」を用いて新しいスコアを算出します。
+ *
+ * @param resultSets 検索結果リストの配列（例: [denseResults, sparseResults]）
+ * @param k RRFの平滑化定数（通常は60が使用されます）
+ * @returns RRFスコアの降順でソートされた統合結果の配列
+ */
+declare function rrf(resultSets: RankedResult[][], k?: number): FusionResult[];
+
+/**
+ * Relative Score Fusion (RSF) を計算し、複数の検索結果リストを統合します。
+ * 各リストのスコアをMin-Max正規化によって [0, 1] にスケーリングし、重み付け加算を行います。
+ *
+ * @param resultSets 検索結果リストの配列（例: [denseResults, sparseResults]）
+ * @param weights 各検索結果に対する重み（例: [0.7, 0.3]）。省略時は全て1.0
+ * @returns 重み付き正規化スコアの降順でソートされた統合結果の配列
+ */
+declare function rsf(resultSets: RankedResult[][], weights?: number[]): FusionResult[];
+
 /**
  * 次元削減/拡張のための射影行列の重みを定義するインターフェース
  * @interface ProjectionWeights
@@ -333,9 +451,10 @@ interface ProjectionWeights {
  * ProjectionAdapter クラス
  * PCAやSVDなどで事前計算された射影行列を用いて、ベクトルの次元削減（または拡張）を行います。
  */
-declare class ProjectionAdapter {
+declare class ProjectionAdapter implements WarpAdapter {
     private readonly inDimension;
     private readonly outDimension;
+    private wasmInstance;
     private readonly matrices;
     private readonly biases;
     /**
@@ -364,15 +483,394 @@ declare class ProjectionAdapter {
      */
     removeProjection(name: string): void;
     /**
-     * ベクトルに射影変換を適用し、次元を変更した新しいベクトルを返します。
-     * 数式: y = W * x
+     * ベクトルの次元削減（射影）を実行します。
+     * (WarpAdapter の実装として project の代わりに tune を提供します)
      *
-     * @param {number[] | Float32Array} baseVector - 変換元の入力ベクトル
-     * @param {string} projectionName - 適用する射影設定の名前
-     * @returns {Float32Array} 射影変換適用後の新しいベクトル
-     * @throws {Error} ベクトルの次元数が inDimension と一致しない場合、または射影設定が存在しない場合にエラーをスローします。
+     * @param vector 変換前のベクトル (例: 1536次元)
+     * @param version 適用する変換バージョンの識別子 (オプション)
+     * @returns 変換後のベクトル (例: 512次元)
+     */
+    tune(vector: number[] | Float32Array, version?: string): Float32Array;
+    /**
+     * 現在の射影行列の状態をシリアライズしてエクスポートします。
+     */
+    exportState(): string;
+    /**
+     * エクスポートされた状態から ProjectionAdapter を復元します。
+     * 注意: 保存されている matrix は既にフラット化された 1D 配列であることを前提としています。
      */
-    project(baseVector: number[] | Float32Array, projectionName: string): Float32Array;
+    static importState(stateJson: string): ProjectionAdapter;
+}
+
+/**
+ * MLPの1層を定義するインターフェース
+ */
+interface MlpLayer {
+    /** 変換行列 W */
+    matrix: number[][] | Float32Array;
+    /** バイアス b */
+    bias: number[] | Float32Array;
+    /** 活性化関数 */
+    activation: Activation;
+}
+/**
+ * MlpAdapter は WASM を使用して超高速に非線形な多層推論を行うラッパーです。
+ *
+ * @example
+ * const mlp = new MlpAdapter([{ inputDim: 1536, outputDim: 128, activation: "relu" }]);
+ * const output = mlp.tune(inputVector);
+ */
+declare class MlpAdapter implements WarpAdapter {
+    private layers;
+    private wasmInstance;
+    private isWasmReady;
+    private inputDim;
+    private outputDim;
+    private numLayers;
+    private inputPtr;
+    private outputPtr;
+    private weightsPtr;
+    private layerDimsPtr;
+    private activationsPtr;
+    private bufferPtr;
+    private bufBPtr;
+    constructor(layers: MlpLayer[]);
+    /**
+     * WASMの初期化と、MLP構造をWASMメモリに書き込む準備を行います。
+     * インスタンス作成後に必ず呼び出してください。
+     */
+    init(): Promise<void>;
+    /**
+     * ニューラルネットワークの順伝播を実行し、結果を返します。
+     * (WarpAdapter の実装として、predict の代わりに tune を提供します)
+     *
+     * @param input 入力ベクトル
+     * @returns 推論結果ベクトル
+     */
+    tune(input: number[] | Float32Array): Float32Array;
+    /**
+     * 現在のMLP構造と重みをシリアライズして出力します。
+     */
+    exportState(): string;
+    /**
+     * シリアライズされた状態から MlpAdapter を復元します。
+     * 注意: 復元後、再度 `await init()` を呼び出してWASMメモリを初期化する必要があります。
+     */
+    static importState(stateJson: string): MlpAdapter;
+}
+
+interface WhiteningConfig {
+    /**
+     * 学習率 (0.0 ~ 1.0)
+     * 平均と主成分を更新する際の指数移動平均の重み。
+     * デフォルトは 0.01
+     */
+    learningRate?: number;
+    /**
+     * 除去するトップ主成分（PC）の数。
+     * 通常、事前学習モデルのコーン（偏り）問題を取り除くには、
+     * 上位 1〜2 個の主成分を除去する（All-but-the-Top）だけで十分な効果があります。
+     * デフォルトは 1
+     */
+    numComponents?: number;
+}
+/**
+ * WhiteningAdapter は、ストリーミングデータに対して
+ * Oja's Rule によるオンラインPCAを実行し、
+ * ベクトル空間の等方化（Whitening / Anisotropy Reduction）を行うアダプターです。
+ */
+declare class WhiteningAdapter implements WarpAdapter {
+    dim: number;
+    mean: Float32Array;
+    components: Float32Array[];
+    private count;
+    private learningRate;
+    private numComponents;
+    private componentsPtr;
+    private xResidualPtr;
+    private isWasmReady;
+    init(): Promise<void>;
+    /**
+     * 新しい WhiteningAdapter を作成します。
+     * @param dim ベクトルの次元数
+     * @param config 設定オプション
+     */
+    constructor(dim: number, config?: WhiteningConfig);
+    /**
+     * 入力ベクトルを用いて、平均と主成分をオンライン更新します。
+     * (Oja's Rule + Generalized Hebbian Algorithm)
+     *
+     * @param vector 学習用の入力ベクトル
+     */
+    update(vector: number[] | Float32Array): void;
+    /**
+     * 推論 (Whitening の適用):
+     * 入力ベクトルから平均を引き、偏りの原因である上位主成分を除去します (All-but-the-Top)。
+     *
+     * @param vector 推論・補正対象のベクトル
+     * @returns 等方化・ゼロセンタリングされた新しいベクトル
+     */
+    tune(vector: number[] | Float32Array): Float32Array;
+    /**
+     * 現在の学習状態（平均ベクトル、主成分ベクトルなど）をシリアライズして出力します。
+     * エッジ環境でのインスタンス再構築時に役立ちます。
+     */
+    exportState(): string;
+    /**
+     * シリアライズされた学習状態から WhiteningAdapter を復元します。
+     */
+    static importState(stateJson: string): WhiteningAdapter;
+}
+
+declare class ColbertAdapter {
+    private wasm;
+    constructor();
+    /**
+     * 単一のクエリと単一のドキュメント間の Late Interaction (MaxSim) スコアを計算します。
+     *
+     * @param queryTokens クエリのトークンベクトル行列 (要素数 = queryLength * dim の平坦化された配列)
+     * @param documentTokens ドキュメントのトークンベクトル行列
+     * @param dim ベクトルの次元数
+     * @returns MaxSimスコア
+     */
+    score(queryTokens: Float32Array, documentTokens: Float32Array, dim: number): number;
+    /**
+     * クエリと複数のドキュメント間の MaxSim スコアを計算し、スコアの降順にソートして返します。
+     *
+     * @param queryTokens クエリのトークンベクトル行列
+     * @param documentTokensArray ドキュメントのトークンベクトル行列の配列
+     * @param dim ベクトルの次元数
+     * @returns スコアの降順にソートされたドキュメントのインデックスとスコアの配列
+     */
+    rank(queryTokens: Float32Array, documentTokensArray: Float32Array[], dim: number): {
+        index: number;
+        score: number;
+    }[];
+}
+
+interface WarpPrismaConfig {
+    /**
+     * WarpVectorのアダプター (IntentAdapter, WhiteningAdapter など)
+     */
+    adapter: WarpAdapter;
+    /**
+     * pgvector のベクトルデータが保存されているカラム名
+     * デフォルト: "embedding"
+     */
+    vectorField?: string;
+    /**
+     * 類似度検索に使用する距離関数
+     * '<->' : ユークリッド距離 (デフォルト)
+     * '<#>' : 内積 (マイナス)
+     * '<=>' : コサイン距離
+     */
+    distanceOperator?: "<->" | "<#>" | "<=>";
+}
+/**
+ * Prisma Client に対して WarpVector の推論と pgvector のベクトル検索を
+ * 透過的に実行するメソッド `searchByVector` を追加する拡張機能です。
+ */
+declare const withWarpVector: (config: WarpPrismaConfig) => (client: any) => _prisma_client_extension.PrismaClientExtends<_prisma_client_runtime_client.InternalArgs<{}, {
+    $allModels: {
+        /**
+         * 生のベクトルを受け取り、WarpVectorで変換した後に pgvector 検索を行います。
+         *
+         * @param args.vector 生のベクトル (変換前)
+         * @param args.topK 取得する最大件数 (デフォルト: 10)
+         * @param args.where 追加のフィルタリング条件 (例: "category = 'science'")
+         */
+        searchByVector<T>(this: T, args: {
+            vector: number[] | Float32Array;
+            topK?: number;
+            where?: string;
+        }): Promise<any>;
+    };
+}, {}, {}> & _prisma_client_runtime_client.DefaultArgs>;
+
+/**
+ * WarpEmbeddings の設定オプション
+ */
+interface WarpEmbeddingsOptions extends EmbeddingsParams {
+    /**
+     * ラップするベースの Embeddings インスタンス（例: OpenAIEmbeddings）
+     * 初期の密ベクトル（Dense Vector）の生成に使用されます。
+     */
+    baseEmbeddings: Embeddings;
+    /**
+     * 初期化済みの WarpVector IntentAdapter。
+     * 意図（インテント）の変換行列とバイアスを保持しています。
+     */
+    adapter: IntentAdapter;
+    /**
+     * (オプション) 検索クエリに使用する初期の意図（インテント）名。
+     * 指定しない場合、検索を実行する前に `setIntent()` で設定する必要があります。
+     */
+    intentName?: string;
+    /**
+     * (オプション) アフィン変換後に適用する非線形活性化関数（'relu', 'sigmoid', 'tanh'など）。
+     */
+    activation?: Activation;
+    /**
+     * (オプション) 単一の意図を指定する代わりに、自己アテンションベースの
+     * 動的意図合成（Auto-blending）を使用するかどうか。
+     * true の場合、クエリ実行時に `intentName` は無視されます。
+     */
+    autoBlend?: boolean;
+}
+/**
+ * WarpEmbeddings は、LangChain の BaseEmbeddings インスタンスをラップするクラスです。
+ * `embedQuery` メソッドをインターセプトし、ベースベクトルを生成した後に、
+ * 現在のコンテキスト/意図に基づいて動的なアフィン変換（WarpVector）を適用します。
+ *
+ * VectorStore へ正確なセマンティクスとして保存（インデックス）できるよう、
+ * ドキュメントは変換されず、通常通り埋め込まれます。
+ * ユーザーの「検索クエリ」に対してのみワープが適用されます。
+ *
+ * @example
+ * ```typescript
+ * import { OpenAIEmbeddings } from "@langchain/openai";
+ * import { IntentAdapter } from "warpvector";
+ * import { WarpEmbeddings } from "warpvector/integrations/langchain";
+ *
+ * const baseEmbeddings = new OpenAIEmbeddings();
+ * const adapter = new IntentAdapter({ ... });
+ *
+ * const embeddings = new WarpEmbeddings({
+ *   baseEmbeddings,
+ *   adapter,
+ *   intentName: "riskAnalysis"
+ * });
+ *
+ * // このラップされた embeddings インスタンスを LangChain の VectorStore に直接渡せます！
+ * const vectorStore = new MemoryVectorStore(embeddings);
+ * ```
+ */
+declare class WarpEmbeddings extends Embeddings {
+    private baseEmbeddings;
+    private adapter;
+    private intentName?;
+    private activation?;
+    private autoBlend;
+    constructor(options: WarpEmbeddingsOptions);
+    /**
+     * 実行時にアクティブな意図（インテント）を動的に切り替えます。
+     */
+    setIntent(intentName: string, activation?: Activation): void;
+    /**
+     * 自己アテンション型の動的意図合成（Auto-blending）を有効化または無効化します。
+     */
+    setAutoBlend(enabled: boolean): void;
+    /**
+     * ベースの embeddings モデルを使用して、ドキュメントを通常通り埋め込みます。
+     * VectorDB には客観的な空間データを含める必要があるため、インデックスされるドキュメントはワープ（変換）しません。
+     */
+    embedDocuments(documents: string[]): Promise<number[][]>;
+    /**
+     * ユーザーのクエリを埋め込み、WarpVector によるアフィン変換を適用します。
+     */
+    embedQuery(document: string): Promise<number[]>;
+}
+
+/**
+ * LlamaIndex の BaseEmbedding インターフェース互換
+ * 依存関係を避けるため、Duck Typing 用のインターフェースを定義しています。
+ */
+interface LlamaIndexBaseEmbedding {
+    getTextEmbedding(text: string): Promise<number[]>;
+    getQueryEmbedding(query: string): Promise<number[]>;
+    getTextEmbeddings?(texts: string[]): Promise<number[][]>;
+}
+interface WarpLlamaIndexEmbeddingsOptions {
+    /**
+     * ラップするベースの Embeddings インスタンス（LlamaIndex の BaseEmbedding 継承クラス）
+     * 初期の密ベクトル（Dense Vector）の生成に使用されます。
+     */
+    baseEmbeddings: LlamaIndexBaseEmbedding;
+    /**
+     * 初期化済みの WarpVector IntentAdapter。
+     */
+    adapter: IntentAdapter;
+    /**
+     * (オプション) 検索クエリに使用する初期の意図（インテント）名。
+     */
+    intentName?: string;
+    /**
+     * (オプション) アフィン変換後に適用する非線形活性化関数。
+     */
+    activation?: Activation;
+    /**
+     * (オプション) 自己アテンションベースの動的意図合成（Auto-blending）を使用するかどうか。
+     */
+    autoBlend?: boolean;
+}
+/**
+ * WarpLlamaIndexEmbeddings は、LlamaIndex の BaseEmbedding インスタンスをラップします。
+ * `getQueryEmbedding` メソッドをインターセプトし、ベースベクトルを生成した後に
+ * 現在のコンテキスト/意図に基づいて動的なアフィン変換（WarpVector）を適用します。
+ */
+declare class WarpLlamaIndexEmbeddings implements LlamaIndexBaseEmbedding {
+    private baseEmbeddings;
+    private adapter;
+    private intentName?;
+    private activation?;
+    private autoBlend;
+    constructor(options: WarpLlamaIndexEmbeddingsOptions);
+    setIntent(intentName: string, activation?: Activation): void;
+    setAutoBlend(enabled: boolean): void;
+    /**
+     * ドキュメントの埋め込み（インデックス作成用）は変換を行いません。
+     */
+    getTextEmbedding(text: string): Promise<number[]>;
+    /**
+     * 複数ドキュメントの埋め込み
+     */
+    getTextEmbeddings(texts: string[]): Promise<number[][]>;
+    /**
+     * クエリの埋め込み（検索用）にのみ WarpVector 変換を適用します。
+     */
+    getQueryEmbedding(query: string): Promise<number[]>;
+}
+
+type QuantizationType = "int8" | "binary";
+interface QuantizationConfig {
+    /**
+     * "int8": 8-bit スカラー量子化 (Int8Array を返す)
+     * "binary": 1-bit 二値化 (Uint8Array を返す、8次元分を1バイトにパック)
+     */
+    type: QuantizationType;
+    /**
+     * 量子化するベクトルの次元数
+     */
+    dim: number;
+    /**
+     * 動的キャリブレーション（スケール算出）を有効にするか。
+     * trueの場合、ベクトルの絶対値の最大値 max(abs(v)) を算出し、
+     * scale = 127 / max(abs(v)) を用いて量子化します。
+     */
+    dynamic?: boolean;
+}
+/**
+ * QuantizationAdapter は、Float32のベクトルを Int8 や Binary に圧縮し、
+ * メモリ使用量と保存コストを劇的に（1/4 〜 1/32 に）削減します。
+ */
+declare class QuantizationAdapter implements WarpAdapter {
+    private type;
+    private dim;
+    private dynamic;
+    constructor(config: QuantizationConfig);
+    tune(vector: number[] | Float32Array): Int8Array | Uint8Array;
+    /**
+     * Binary量子化された2つのベクトル間のハミング距離を計算します。
+     * ハミング距離が小さいほど類似度が高いことを意味します。
+     */
+    static hammingDistance(a: Uint8Array, b: Uint8Array): number;
+    /**
+     * Int8量子化された2つのベクトル間のドット積（内積）を計算します。
+     * 動的スケーリングが埋め込まれている場合はスケールを戻して計算します。
+     */
+    static int8DotProduct(a: Int8Array, b: Int8Array): number;
+    exportState(): string;
+    static importState(stateJson: string): QuantizationAdapter;
 }
 
 /**
@@ -391,13 +889,29 @@ interface BaseTrainingOptions {
     /** trueの場合、事前に数エポックのテストランを行い、最適な学習率を自動探索します。デフォルト: false */
     autoTune?: boolean;
 }
+/**
+ * Adam最適化のステート変数を管理する共通基底クラス
+ */
+declare abstract class AbstractAdamTrainer {
+    protected t: number;
+    protected mW: Float32Array;
+    protected vW: Float32Array;
+    protected mb: Float32Array;
+    protected vb: Float32Array;
+    protected initAdamState(sDim: number, tDim: number): void;
+    /**
+     * アフィンレイヤー (matrix, bias) に対する Adam のパラメータ更新を適用します。
+     * InfoNCE や Triplet など、様々な損失関数で計算された勾配(outputGradients)を元に更新を行います。
+     */
+    protected applyAdamToAffine(matrix: Float32Array, bias: Float32Array, mMatrix: Float32Array, vMatrix: Float32Array, mBias: Float32Array, vBias: Float32Array, input: number[] | Float32Array, outputGradients: number[] | Float32Array, lr: number, reg: number, t: number): void;
+}
 /**
  * 確率的勾配降下法 (SGD + Momentum) を用いた学習のための共通基底クラス。
  *
  * @template TExample 学習に用いるデータペアの型 (入力と理想の出力のペアなど)
  * @template TResult 最終的に学習結果として出力される重み (行列やバイアス) の型
  */
-declare abstract class BaseTrainer<TExample, TResult> {
+declare abstract class BaseTrainer<TExample, TResult> extends AbstractAdamTrainer {
     /** 学習用サンプルの配列 */
     protected examples: TExample[];
     /** 入力ベクトル（ソース）の次元数 */
@@ -447,20 +961,11 @@ declare abstract class BaseTrainer<TExample, TResult> {
      */
     protected findBestLearningRate(options: BaseTrainingOptions): number;
     /**
-     * SGD + Momentum アルゴリズムによる1ステップのパラメータ更新を実行します。
+     * Adam オプティマイザによる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 モメンタム係数
+     * WASM 版の Adam 実装ができるまではネイティブ JS で処理します。
      */
-    protected sgdMomentumStep(matrix: Float32Array, bias: Float32Array, vMatrix: Float32Array, vBias: Float32Array, x: number[] | Float32Array, y: number[] | Float32Array, lr: number, reg: number, momentum: number): void;
+    protected adamStep(matrix: Float32Array, bias: Float32Array, mMatrix: Float32Array, vMatrix: Float32Array, mBias: Float32Array, vBias: Float32Array, x: number[] | Float32Array, y: number[] | Float32Array, lr: number, reg: number, t: number): void;
 }
 
 /**
@@ -475,8 +980,16 @@ interface TrainingExample {
 }
 /**
  * 学習時の最適化オプション
+export interface TrainingOptions extends BaseTrainingOptions {}
+
+/**
+ * IntentTrainer のオンライン学習オプション
  */
-interface TrainingOptions extends BaseTrainingOptions {
+interface IntentOnlineOptions {
+    /** 1ステップの学習率 (デフォルト: 0.01) */
+    learningRate?: number;
+    /** L2正則化の強さ (デフォルト: 0.001) */
+    regularization?: number;
 }
 /**
  * サンプルデータから最適な `IntentWeights` (行列Wとバイアスb) を
@@ -507,13 +1020,109 @@ declare class IntentTrainer extends BaseTrainer<TrainingExample, IntentWeights>
      * ユーザーのクリックなどの 1 回のフィードバックからリアルタイムに重みを微調整します。
      *
      * @param {IntentWeights} currentWeights - 現在の重み
-     * @param {number[] | Float32Array} input - 検索されたクエリベクトル
-     * @param {number[] | Float32Array} target - クリックされた(理想の)ドキュメントのベクトル
-     * @param {number} learningRate - 1ステップの学習率 (デフォルト: 0.01)
-     * @param {number} regularization - L2正則化の強さ (デフォルト: 0.001)
+     * @param {TrainingExample} example - アンカー、正解を含む学習データ
+     * @param {IntentOnlineOptions} [options={}] - 学習オプション
      * @returns {IntentWeights} 微調整された新しい重み
      */
-    updateOnline(currentWeights: IntentWeights, input: number[] | Float32Array, target: number[] | Float32Array, learningRate?: number, regularization?: number): Promise<IntentWeights>;
+    updateOnline(currentWeights: IntentWeights, example: TrainingExample, options?: IntentOnlineOptions): Promise<IntentWeights>;
+}
+
+/**
+ * 学習データのペア（Anchor, Positive, Negative）
+ * @interface TripletExample
+ */
+interface TripletExample {
+    /** 基準となるベクトル（検索クエリなど） */
+    anchor: number[] | Float32Array;
+    /** Anchorに近づけたい正解ベクトル（クリックされた商品など） */
+    positive: number[] | Float32Array;
+    /** Anchorから遠ざけたい不正解ベクトル（スルーされた商品など） */
+    negative: number[] | Float32Array;
+}
+/**
+ * TripletTrainer のオンライン学習オプション
+ */
+interface TripletOnlineOptions {
+    /** 1ステップの学習率 (デフォルト: 0.01) */
+    learningRate?: number;
+    /** トリプレットロスのマージン (デフォルト: 0.1) */
+    margin?: number;
+    /** L2正則化の強さ (デフォルト: 0.001) */
+    regularization?: number;
+}
+/**
+ * Contrastive Learning (トリプレットロス) を用いて、相対的な距離感から
+ * IntentWeights (行列W と バイアスb) を学習するトレーナークラス。
+ *
+ * "Anchor" を変換したベクトル A' が、"Negative" よりも "Positive" に
+ * 設定されたマージン(Margin)分だけ確実により近づくように重みを更新します。
+ */
+declare class TripletTrainer extends AbstractAdamTrainer {
+    private dimension;
+    /**
+     * TripletTrainer のインスタンスを作成します。
+     * @param {number} dimension ベクトルの次元数
+     */
+    constructor(dimension: number);
+    private toWeights;
+    /**
+     * オンライン学習 (フィードバックループ) 用のメソッド。
+     * 1つのトリプレットデータからリアルタイムに重みを微調整します。
+     *
+     * @param {IntentWeights} currentWeights - 現在の重み
+     * @param {TripletExample} example - アンカー、正解、不正解を含むトリプレットデータ
+     * @param {TripletOnlineOptions} [options={}] - 学習オプション
+     * @returns {Promise<IntentWeights>} 微調整された新しい重み
+     */
+    updateOnline(currentWeights: IntentWeights, example: TripletExample, options?: TripletOnlineOptions): Promise<IntentWeights>;
+}
+
+/**
+ * 学習データのペア（Anchor, Positive, 複数のNegatives）
+ * @interface InfoNCEExample
+ */
+interface InfoNCEExample {
+    /** 基準となるベクトル（検索クエリなど） */
+    anchor: number[] | Float32Array;
+    /** Anchorに近づけたい正解ベクトル（クリックされた商品など） */
+    positive: number[] | Float32Array;
+    /** Anchorから遠ざけたい不正解ベクトルの配列（スルーされた商品群など） */
+    negatives: (number[] | Float32Array)[];
+}
+/**
+ * InfoNCETrainer のオンライン学習オプション
+ */
+interface InfoNCEOnlineOptions {
+    /** 1ステップの学習率 (デフォルト: 0.01) */
+    learningRate?: number;
+    /** Softmaxの温度パラメータ (デフォルト: 0.1) */
+    temperature?: number;
+    /** L2正則化の強さ (デフォルト: 0.001) */
+    regularization?: number;
+}
+/**
+ * InfoNCE Loss (Softmax Cross Entropy) を用いて、
+ * 「1つの正解を近づけ、複数の不正解を一気に遠ざける」ように
+ * IntentWeights (行列W と バイアスb) を学習するトレーナークラス。
+ */
+declare class InfoNCETrainer extends AbstractAdamTrainer {
+    private dimension;
+    /**
+     * InfoNCETrainer のインスタンスを作成します。
+     * @param {number} dimension ベクトルの次元数
+     */
+    constructor(dimension: number);
+    private toWeights;
+    /**
+     * オンライン学習 (フィードバックループ) 用のメソッド。
+     * 1つのクエリ(Anchor)、1つのクリック(Positive)、複数のスルー(Negatives)から重みを微調整します。
+     *
+     * @param {IntentWeights} currentWeights - 現在の重み
+     * @param {InfoNCEExample} example - アンカー、正解、複数の不正解を含むデータ
+     * @param {InfoNCEOnlineOptions} [options={}] - 学習オプション
+     * @returns {Promise<IntentWeights>} 微調整された新しい重み
+     */
+    updateOnline(currentWeights: IntentWeights, example: InfoNCEExample, options?: InfoNCEOnlineOptions): Promise<IntentWeights>;
 }
 
 /**
@@ -559,6 +1168,15 @@ declare class MigrationTrainer extends BaseTrainer<MigrationExample, ProjectionW
     protected toWeights(flatMatrix: Float32Array, bias: Float32Array): ProjectionWeights;
 }
 
+type index_WarpEmbeddings = WarpEmbeddings;
+declare const index_WarpEmbeddings: typeof WarpEmbeddings;
+type index_WarpEmbeddingsOptions = WarpEmbeddingsOptions;
+type index_WarpPrismaConfig = WarpPrismaConfig;
+declare const index_withWarpVector: typeof withWarpVector;
+declare namespace index {
+  export { index_WarpEmbeddings as WarpEmbeddings, type index_WarpEmbeddingsOptions as WarpEmbeddingsOptions, type index_WarpPrismaConfig as WarpPrismaConfig, index_withWarpVector as withWarpVector };
+}
+
 /**
  * 外部のベクトルデータベース（pgvector, Pinecone, Redisなど）へ
  * ワープ変換後のベクトルを保存・検索するためのアダプター/ユーティリティクラス
@@ -574,7 +1192,7 @@ declare class VectorDBAdapter {
      * @param {number[] | Float32Array} vector ワープ変換後のベクトル
      * @returns {string} `'[0.1, 0.2, 0.3]'` のような文字列表現
      */
-    static toPgvector(vector: number[] | Float32Array): string;
+    static toPgvector(vector: number[] | Float32Array | Int8Array | Uint8Array): string;
     /**
      * Pinecone 用のクエリオブジェクトを生成します。
      * Pinecone クライアントに直接渡せる形式のオブジェクトを返します。
@@ -588,7 +1206,7 @@ declare class VectorDBAdapter {
      * @param {Record<string, any>} [filter] メタデータフィルタ（オプション）
      * @returns {Record<string, any>} Pineconeのqueryメソッド用オブジェクト
      */
-    static toPineconeQuery(vector: number[] | Float32Array, topK?: number, filter?: Record<string, any>): Record<string, any>;
+    static toPineconeQuery(vector: number[] | Float32Array | Int8Array | Uint8Array, topK?: number, filter?: Record<string, unknown>): Record<string, unknown>;
     /**
      * Redis (RediSearch) のベクトルフィールド用に、
      * Float32Array をバイナリ（Uint8Array）に変換します。
@@ -601,7 +1219,251 @@ declare class VectorDBAdapter {
      * @param {number[] | Float32Array} vector ワープ変換後のベクトル
      * @returns {Uint8Array} バイナリデータ (Float32のバイト表現)
      */
-    static toRedis(vector: number[] | Float32Array): Uint8Array;
+    static toRedis(vector: number[] | Float32Array | Int8Array | Uint8Array): Uint8Array;
+}
+
+/**
+ * ベクトル・シンボリック・アーキテクチャ (VSA) / 超次元計算アダプタ
+ *
+ * ベクトル同士を論理的・数学的に結合（バインド）したり束ねたり（バンドル）することで、
+ * 1つの密なベクトルの中にキーと値（メタデータなど）を埋め込み、検索空間上で
+ * そのまま演算を行えるようにする機能を提供します。
+ */
+/**
+ * VSA演算のオプション
+ */
+interface VsaOptions {
+    /** 結果をL2正規化するかどうか（デフォルト: true） */
+    shouldNormalize?: boolean;
+}
+declare class VsaAdapter {
+    /**
+     * ベクトルのバンドリング (Bundling / Superposition)
+     * 複数のベクトルを足し合わせ（重ね合わせ）て1つのベクトルに統合します。
+     * 「A と B の両方の概念を含む」ベクトルを作成する際に使用します。
+     *
+     * @param vectors 束ねるベクトルの配列
+     * @param options 演算オプション
+     * @returns 束ねられた新しいベクトル
+     */
+    static bundle(vectors: (number[] | Float32Array)[], options?: VsaOptions): Float32Array;
+    /**
+     * ベクトルのバインディング (Binding / Hadamard Product)
+     * アダマール積（要素ごとの積）を用いて、2つのベクトルを「結合」します。
+     * 例: キー（ユーザーID）と値（好み）を掛け合わせ、特有の「ユーザーの好み」ベクトルを生成します。
+     *
+     * @param vec1 バインドするベクトル1
+     * @param vec2 バインドするベクトル2
+     * @param options 演算オプション
+     * @returns バインドされた新しいベクトル
+     */
+    static bind(vec1: number[] | Float32Array, vec2: number[] | Float32Array, options?: VsaOptions): Float32Array;
+    /**
+     * ベクトルのアンバインディング (Unbinding)
+     * バインドされたベクトルから、片方のベクトル（キー）を使って元の値（バリュー）を取り出します。
+     * アダマール積によるバインディングの逆演算（要素ごとの除算）を行います。
+     *
+     * @param boundVec バインド済みのベクトル
+     * @param keyVec 抽出に使用するキーベクトル
+     * @param options 演算オプション
+     * @returns アンバインドされて抽出されたベクトル
+     */
+    static unbind(boundVec: number[] | Float32Array, keyVec: number[] | Float32Array, options?: VsaOptions): Float32Array;
+    /**
+     * ---------------------------------------------------------
+     * Binary VSA (バイナリベクトル・シンボリック・アーキテクチャ)
+     * ---------------------------------------------------------
+     * QuantizationAdapter で 1-bit (Binary) 量子化された Uint8Array ベクトルに
+     * 対する超次元計算を行います。XOR 演算により、超高速・極小メモリでの処理が可能です。
+     */
+    /**
+     * バイナリベクトルのバインディング (Binary Binding / XOR)
+     * XOR (排他的論理和) を用いて2つのバイナリベクトルを結合します。
+     * Binary VSA において、XOR は情報を結合するための標準的な演算です。
+     *
+     * @param bin1 バインドするバイナリベクトル1 (Uint8Array)
+     * @param bin2 バインドするバイナリベクトル2 (Uint8Array)
+     * @returns バインドされた新しいバイナリベクトル (Uint8Array)
+     */
+    static bindBinary(bin1: Uint8Array, bin2: Uint8Array): Uint8Array;
+    /**
+     * バイナリベクトルのアンバインディング (Binary Unbinding / XOR)
+     * XOR の自己逆性 (A ^ B ^ B = A) を利用して、キーを用いて元の値を抽出します。
+     * 内部的には bindBinary と全く同じ処理です。
+     *
+     * @param boundBin バインド済みのバイナリベクトル (Uint8Array)
+     * @param keyBin 抽出に使用するキーバイナリベクトル (Uint8Array)
+     * @returns アンバインドされて抽出されたバイナリベクトル (Uint8Array)
+     */
+    static unbindBinary(boundBin: Uint8Array, keyBin: Uint8Array): Uint8Array;
+    /**
+     * バイナリベクトルのバンドリング (Binary Bundling / Majority Vote)
+     * 複数のバイナリベクトルを重ね合わせます。各ビット位置で 1 と 0 の出現回数をカウントし、
+     * 多数決 (Majority Vote) で最終的なビットを決定します。
+     *
+     * @param bins 束ねるバイナリベクトルの配列 (Uint8Arrayの配列)
+     * @returns 束ねられた新しいバイナリベクトル (Uint8Array)
+     */
+    static bundleBinary(bins: Uint8Array[]): Uint8Array;
+}
+
+interface TaskConfig {
+    /**
+     * 追加するタスクの重み（学習済み IntentWeights）
+     */
+    weights: IntentWeights;
+    /**
+     * そのタスクを合成するスケール（重み付け）。
+     * 1.0 が標準、0.5で半分、マイナスで逆効果。
+     */
+    scale: number;
+}
+/**
+ * Task Arithmetic (モデルマージ) ユーティリティ
+ *
+ * 複数の学習済みアダプタの重み（IntentWeights）を「タスクベクトル」として扱い、
+ * それらを合成（マージ）することで、推論時にオーバーヘッドのない新しい静的なアダプタ行列を生成します。
+ */
+declare class TaskArithmetic {
+    /**
+     * 複数のタスク（IntentWeights）を合成し、新しい IntentWeights を作成します。
+     * 数式: W_new = W_base + Σ scale_i * (W_i - W_base)
+     *
+     * @param tasks 合成するタスクのリスト（IntentWeights と スケールのペア）
+     * @param baseIntent 基準となる IntentWeights。省略された場合は恒等行列（Identity）とゼロバイアスがベースになります。
+     * @returns 完全にマージされた新しい IntentWeights
+     */
+    static merge(tasks: TaskConfig[], baseIntent?: IntentWeights): IntentWeights;
+}
+
+interface PipelineStep {
+    type: string;
+    adapter: WarpAdapter;
+}
+interface PipelineState {
+    type: string;
+    state: AdapterState | null;
+}
+interface RunContext {
+    intent?: string;
+    version?: string;
+}
+interface FormatOptions {
+    format: string;
+    topK?: number;
+    filter?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * WarpPipeline (統一インターフェース)
+ *
+ * 複数の WarpAdapter を直感的なビルダーパターンで数珠つなぎ（チェーン）し、
+ * データパイプラインとして一括で実行・保存・復元するためのラッパークラスです。
+ */
+declare class WarpPipeline {
+    inputDim: number;
+    private steps;
+    /**
+     * アダプタの復元関数を保持するレジストリ。
+     * カスタムアダプタをパイプラインで利用・復元可能にするために使用します。
+     */
+    private static adapterRegistry;
+    /**
+     * カスタムアダプタをパイプラインのレジストリに登録します。
+     * これにより importState でカスタムアダプタを復元可能になります。
+     *
+     * @param type アダプタの識別子 (例: "MyCustomAdapter")
+     * @param importFn 状態オブジェクトからアダプタインスタンスを復元する関数
+     */
+    static registerAdapter(type: string, importFn: (state: AdapterState) => WarpAdapter): void;
+    /**
+     * フォーマット変換ロジックを保持するレジストリ。
+     */
+    private static formatRegistry;
+    /**
+     * カスタムの出力フォーマットを登録します。
+     * これにより、ユーザー独自のDB形式（Milvus, Weaviateなど）への変換を動的に追加できます。
+     *
+     * @param format フォーマット名 (例: "pgvector")
+     * @param formatFn 変換を行うコールバック関数
+     */
+    static registerFormat(format: string, formatFn: (vector: OutputVector, options: FormatOptions) => unknown): void;
+    constructor(inputDim: number);
+    /**
+     * IntentAdapter (意図による線形変換) をパイプラインに追加します。
+     */
+    addIntent(intents?: Record<string, IntentWeights>): this;
+    /**
+     * LoraIntentAdapter (低ランク適応による線形変換) をパイプラインに追加します。
+     */
+    addLoraIntent(rank: number, intents?: Record<string, LoraIntentWeights>): this;
+    /**
+     * WhiteningAdapter (PCAによる空間的偏りの除去) をパイプラインに追加します。
+     */
+    addWhitening(options?: WhiteningConfig): this;
+    /**
+     * ProjectionAdapter (次元圧縮) をパイプラインに追加します。
+     */
+    addProjection(outputDim: number, projections?: Record<string, ProjectionWeights>): this;
+    /**
+     * MlpAdapter (多層ニューラルネットワーク / 非線形推論) をパイプラインに追加します。
+     */
+    addMlp(layers: MlpLayer[]): this;
+    /**
+     * QuantizationAdapter (ベクトル量子化 / 圧縮) をパイプラインに追加します。
+     * これは通常、パイプラインの最後のステップとして使用されます。
+     */
+    quantize(type: QuantizationType): this;
+    /**
+     * カスタムアダプタを直接パイプラインの末尾に追加します。
+     * (ビルダーパターンで独自の拡張アダプタを組み込む際に使用します)
+     *
+     * @param type アダプタの識別子（レジストリ登録名と一致させることを推奨）
+     * @param adapter WarpAdapterを実装したインスタンス
+     */
+    addStep(type: string, adapter: WarpAdapter): this;
+    /**
+     * パイプライン内に WASM などの非同期初期化を必要とするアダプタが含まれている場合、
+     * それらを一括でセットアップします。
+     */
+    init(): Promise<void>;
+    /**
+     * パイプラインを順次実行し、入力ベクトルを最終的な表現に変換します。
+     *
+     * @param vector 変換元のベースベクトル
+     * @param context インテントやバージョンなどのコンテキスト情報
+     * @returns パイプラインを通過した最終的なベクトル (Float32Array または Uint8Array/Int8Array)
+     */
+    run(vector: InputVector, context?: RunContext): OutputVector;
+    /**
+     * 複数のベクトル（バッチ）を一括でパイプラインに通します。
+     * 内部の tuneBatch が実装されているアダプタでは WASM/SIMD による高速処理が適用されます。
+     *
+     * @param vectors 変換元のベースベクトルの配列
+     * @param context インテントやバージョンなどのコンテキスト情報
+     * @returns 変換されたベクトルの配列
+     */
+    runBatch(vectors: InputVector[], context?: RunContext): OutputVector[];
+    /**
+     * ベクトル変換から特定データベース向けのフォーマットまでを1回の呼び出しで行います。
+     *
+     * @param vector 変換元のベースベクトル
+     * @param dbOptions フォーマットの指定オプション
+     * @param context パイプラインのコンテキスト
+     * @returns 指定されたデータベース形式のオブジェクトや文字列
+     */
+    runAndFormat(vector: InputVector, dbOptions: FormatOptions, context?: RunContext): unknown;
+    /**
+     * パイプライン内の全アダプタの状態（学習済みの重みなど）を JSON 化可能な配列として出力します。
+     * これにより、DBやRedis等への永続化が容易になります。
+     */
+    exportState(): PipelineState[];
+    /**
+     * エクスポートされた JSON 状態から、パイプラインを完全に復元（再構築）します。
+     * @param states exportState で出力された配列
+     * @returns 復元された新しい WarpPipeline インスタンス
+     */
+    static importState(states: PipelineState[]): WarpPipeline;
 }
 
-export { type Activation, IntentAdapter, IntentTrainer, type IntentWeights, LoraIntentAdapter, type LoraIntentWeights, type MigrationExample, type MigrationOptions, MigrationTrainer, ProjectionAdapter, type ProjectionWeights, type TrainingExample, type TrainingOptions, VectorDBAdapter, applyActivationToVector, assertDimension, cosineSimilarity, flattenMatrix, innerProduct, normalize, reject, slerp, softmax };
+export { type Activation, type AdapterState, ColbertAdapter, type FormatOptions, type FusionResult, type InfoNCEExample, type InfoNCEOnlineOptions, InfoNCETrainer, type InputVector, IntentAdapter, type IntentOnlineOptions, IntentTrainer, type IntentWeights, type LlamaIndexBaseEmbedding, LoraIntentAdapter, type LoraIntentWeights, type MigrationExample, type MigrationOptions, MigrationTrainer, MlpAdapter, type MlpLayer, type OutputVector, type PipelineState, type PipelineStep, ProjectionAdapter, type ProjectionWeights, QuantizationAdapter, type QuantizationConfig, type QuantizationType, type RankedResult, type RunContext, TaskArithmetic, type TaskConfig, type TrainingExample, type TripletExample, type TripletOnlineOptions, TripletTrainer, VectorDBAdapter, VsaAdapter, type VsaOptions, type WarpAdapter, WarpEmbeddings, type WarpEmbeddingsOptions, WarpLlamaIndexEmbeddings, type WarpLlamaIndexEmbeddingsOptions, WarpPipeline, type WarpPrismaConfig, WhiteningAdapter, type WhiteningConfig, addScaledVector, applyActivationToVector, applyAffine, assertDimension, cosineSimilarity, flattenMatrix, getFlatMatrixAndBias, innerProduct, index as integrations, normalize, reject, rrf, rsf, slerp, softmax, withWarpVector };