@ruvector/ruvllm 4.0.1 → 4.1.0

package/dist/esm/export.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Export/Serialization for SONA Models
+ *
+ * Support for SafeTensors, JSON, and other export formats.
+ *
+ * @example
+ * ```typescript
+ * import { ModelExporter, SafeTensorsWriter } from '@ruvector/ruvllm';
+ *
+ * // Export model to SafeTensors format
+ * const exporter = new ModelExporter();
+ * const buffer = exporter.toSafeTensors({
+ *   weights: loraAdapter.getWeights(),
+ *   config: loraAdapter.getConfig(),
+ * });
+ *
+ * // Save to file
+ * fs.writeFileSync('model.safetensors', buffer);
+ * ```
+ */
+import { LoRAConfig, LearnedPattern, EwcStats, Embedding, ModelMetadata } from './types.js';
+import { LoraWeights } from './lora.js';
+/**
+ * Exportable model data
+ */
+export interface ExportableModel {
+    /** Model metadata */
+    metadata: ModelMetadata;
+    /** LoRA weights (if applicable) */
+    loraWeights?: LoraWeights;
+    /** LoRA config */
+    loraConfig?: LoRAConfig;
+    /** Learned patterns */
+    patterns?: LearnedPattern[];
+    /** EWC statistics */
+    ewcStats?: EwcStats;
+    /** Raw tensors */
+    tensors?: Map<string, Float32Array>;
+}
+/**
+ * SafeTensors Writer
+ *
+ * Writes tensors in SafeTensors format for compatibility with
+ * HuggingFace ecosystem.
+ */
+export declare class SafeTensorsWriter {
+    private tensors;
+    private metadata;
+    /**
+     * Add a tensor
+     */
+    addTensor(name: string, data: Float32Array, shape: number[]): this;
+    /**
+     * Add 2D tensor from number array
+     */
+    add2D(name: string, data: number[][]): this;
+    /**
+     * Add 1D tensor from number array
+     */
+    add1D(name: string, data: number[]): this;
+    /**
+     * Add metadata
+     */
+    addMetadata(key: string, value: string): this;
+    /**
+     * Build SafeTensors buffer
+     */
+    build(): Uint8Array;
+    /**
+     * Clear all tensors and metadata
+     */
+    clear(): void;
+}
+/**
+ * SafeTensors Reader
+ *
+ * Reads tensors from SafeTensors format.
+ */
+export declare class SafeTensorsReader {
+    private buffer;
+    private header;
+    private dataOffset;
+    constructor(buffer: Uint8Array);
+    /**
+     * Get tensor names
+     */
+    getTensorNames(): string[];
+    /**
+     * Get tensor by name
+     */
+    getTensor(name: string): {
+        data: Float32Array;
+        shape: number[];
+    } | null;
+    /**
+     * Get tensor as 2D array
+     */
+    getTensor2D(name: string): number[][] | null;
+    /**
+     * Get tensor as 1D array
+     */
+    getTensor1D(name: string): number[] | null;
+    /**
+     * Get metadata
+     */
+    getMetadata(): Record<string, string>;
+    private parseHeader;
+}
+/**
+ * Model Exporter
+ *
+ * Unified export interface for SONA models.
+ */
+export declare class ModelExporter {
+    /**
+     * Export to SafeTensors format
+     */
+    toSafeTensors(model: ExportableModel): Uint8Array;
+    /**
+     * Export to JSON format
+     */
+    toJSON(model: ExportableModel): string;
+    /**
+     * Export to compact binary format
+     */
+    toBinary(model: ExportableModel): Uint8Array;
+    /**
+     * Export for HuggingFace Hub compatibility
+     */
+    toHuggingFace(model: ExportableModel): {
+        safetensors: Uint8Array;
+        config: string;
+        readme: string;
+    };
+}
+/**
+ * Model Importer
+ *
+ * Import models from various formats.
+ */
+export declare class ModelImporter {
+    /**
+     * Import from SafeTensors format
+     */
+    fromSafeTensors(buffer: Uint8Array): Partial<ExportableModel>;
+    /**
+     * Import from JSON format
+     */
+    fromJSON(json: string): Partial<ExportableModel>;
+    /**
+     * Import from binary format
+     */
+    fromBinary(buffer: Uint8Array): Partial<ExportableModel>;
+}
+/**
+ * Dataset Exporter
+ *
+ * Export training data in various formats.
+ */
+export declare class DatasetExporter {
+    /**
+     * Export to JSONL format (one JSON per line)
+     */
+    toJSONL(data: Array<{
+        input: Embedding;
+        output: Embedding;
+        quality: number;
+    }>): string;
+    /**
+     * Export to CSV format
+     */
+    toCSV(data: Array<{
+        input: Embedding;
+        output: Embedding;
+        quality: number;
+    }>): string;
+    /**
+     * Export patterns for pre-training
+     */
+    toPretrain(patterns: LearnedPattern[]): string;
+}
+//# sourceMappingURL=export.d.ts.map

package/dist/esm/export.d.ts.map

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

package/dist/esm/export.js

@@ -0,0 +1,414 @@
+/**
+ * Export/Serialization for SONA Models
+ *
+ * Support for SafeTensors, JSON, and other export formats.
+ *
+ * @example
+ * ```typescript
+ * import { ModelExporter, SafeTensorsWriter } from '@ruvector/ruvllm';
+ *
+ * // Export model to SafeTensors format
+ * const exporter = new ModelExporter();
+ * const buffer = exporter.toSafeTensors({
+ *   weights: loraAdapter.getWeights(),
+ *   config: loraAdapter.getConfig(),
+ * });
+ *
+ * // Save to file
+ * fs.writeFileSync('model.safetensors', buffer);
+ * ```
+ */
+/**
+ * SafeTensors Writer
+ *
+ * Writes tensors in SafeTensors format for compatibility with
+ * HuggingFace ecosystem.
+ */
+export class SafeTensorsWriter {
+    constructor() {
+        this.tensors = new Map();
+        this.metadata = {};
+    }
+    /**
+     * Add a tensor
+     */
+    addTensor(name, data, shape) {
+        this.tensors.set(name, { data, shape });
+        return this;
+    }
+    /**
+     * Add 2D tensor from number array
+     */
+    add2D(name, data) {
+        const rows = data.length;
+        const cols = data[0]?.length || 0;
+        const flat = new Float32Array(rows * cols);
+        for (let i = 0; i < rows; i++) {
+            for (let j = 0; j < cols; j++) {
+                flat[i * cols + j] = data[i][j];
+            }
+        }
+        return this.addTensor(name, flat, [rows, cols]);
+    }
+    /**
+     * Add 1D tensor from number array
+     */
+    add1D(name, data) {
+        return this.addTensor(name, new Float32Array(data), [data.length]);
+    }
+    /**
+     * Add metadata
+     */
+    addMetadata(key, value) {
+        this.metadata[key] = value;
+        return this;
+    }
+    /**
+     * Build SafeTensors buffer
+     */
+    build() {
+        // Build header
+        const header = {};
+        let offset = 0;
+        const tensorData = [];
+        for (const [name, { data, shape }] of this.tensors) {
+            const bytes = new Uint8Array(data.buffer);
+            const dataLength = bytes.length;
+            header[name] = {
+                dtype: 'F32',
+                shape,
+                data_offsets: [offset, offset + dataLength],
+            };
+            tensorData.push(bytes);
+            offset += dataLength;
+        }
+        // Add metadata
+        if (Object.keys(this.metadata).length > 0) {
+            header['__metadata__'] = this.metadata;
+        }
+        // Encode header
+        const headerJson = JSON.stringify(header);
+        const headerBytes = new TextEncoder().encode(headerJson);
+        // Pad header to 8-byte alignment
+        const headerPadding = (8 - (headerBytes.length % 8)) % 8;
+        const paddedHeaderLength = headerBytes.length + headerPadding;
+        // Build final buffer
+        const totalLength = 8 + paddedHeaderLength + offset;
+        const buffer = new Uint8Array(totalLength);
+        const view = new DataView(buffer.buffer);
+        // Write header length (8 bytes, little-endian)
+        view.setBigUint64(0, BigInt(paddedHeaderLength), true);
+        // Write header
+        buffer.set(headerBytes, 8);
+        // Write tensor data
+        let dataOffset = 8 + paddedHeaderLength;
+        for (const data of tensorData) {
+            buffer.set(data, dataOffset);
+            dataOffset += data.length;
+        }
+        return buffer;
+    }
+    /**
+     * Clear all tensors and metadata
+     */
+    clear() {
+        this.tensors.clear();
+        this.metadata = {};
+    }
+}
+/**
+ * SafeTensors Reader
+ *
+ * Reads tensors from SafeTensors format.
+ */
+export class SafeTensorsReader {
+    constructor(buffer) {
+        this.header = {};
+        this.dataOffset = 0;
+        this.buffer = buffer;
+        this.parseHeader();
+    }
+    /**
+     * Get tensor names
+     */
+    getTensorNames() {
+        return Object.keys(this.header).filter(k => k !== '__metadata__');
+    }
+    /**
+     * Get tensor by name
+     */
+    getTensor(name) {
+        const entry = this.header[name];
+        if (!entry || typeof entry === 'object' && 'dtype' in entry === false) {
+            return null;
+        }
+        const tensorHeader = entry;
+        const [start, end] = tensorHeader.data_offsets;
+        const bytes = this.buffer.slice(this.dataOffset + start, this.dataOffset + end);
+        return {
+            data: new Float32Array(bytes.buffer, bytes.byteOffset, bytes.length / 4),
+            shape: tensorHeader.shape,
+        };
+    }
+    /**
+     * Get tensor as 2D array
+     */
+    getTensor2D(name) {
+        const tensor = this.getTensor(name);
+        if (!tensor || tensor.shape.length !== 2)
+            return null;
+        const [rows, cols] = tensor.shape;
+        const result = [];
+        for (let i = 0; i < rows; i++) {
+            const row = [];
+            for (let j = 0; j < cols; j++) {
+                row.push(tensor.data[i * cols + j]);
+            }
+            result.push(row);
+        }
+        return result;
+    }
+    /**
+     * Get tensor as 1D array
+     */
+    getTensor1D(name) {
+        const tensor = this.getTensor(name);
+        if (!tensor)
+            return null;
+        return Array.from(tensor.data);
+    }
+    /**
+     * Get metadata
+     */
+    getMetadata() {
+        const meta = this.header['__metadata__'];
+        if (!meta || typeof meta !== 'object')
+            return {};
+        return meta;
+    }
+    parseHeader() {
+        const view = new DataView(this.buffer.buffer, this.buffer.byteOffset);
+        const headerLength = Number(view.getBigUint64(0, true));
+        const headerBytes = this.buffer.slice(8, 8 + headerLength);
+        const headerJson = new TextDecoder().decode(headerBytes);
+        this.header = JSON.parse(headerJson.replace(/\0+$/, '')); // Remove padding nulls
+        this.dataOffset = 8 + headerLength;
+    }
+}
+/**
+ * Model Exporter
+ *
+ * Unified export interface for SONA models.
+ */
+export class ModelExporter {
+    /**
+     * Export to SafeTensors format
+     */
+    toSafeTensors(model) {
+        const writer = new SafeTensorsWriter();
+        // Add metadata
+        writer.addMetadata('name', model.metadata.name);
+        writer.addMetadata('version', model.metadata.version);
+        writer.addMetadata('architecture', model.metadata.architecture);
+        if (model.metadata.training) {
+            writer.addMetadata('training_steps', String(model.metadata.training.steps));
+            writer.addMetadata('training_loss', String(model.metadata.training.loss));
+        }
+        // Add LoRA weights
+        if (model.loraWeights) {
+            writer.add2D('lora.A', model.loraWeights.loraA);
+            writer.add2D('lora.B', model.loraWeights.loraB);
+            writer.add1D('lora.scaling', [model.loraWeights.scaling]);
+        }
+        // Add patterns as embeddings
+        if (model.patterns && model.patterns.length > 0) {
+            const embeddings = model.patterns.map(p => p.embedding);
+            writer.add2D('patterns.embeddings', embeddings);
+            const successRates = model.patterns.map(p => p.successRate);
+            writer.add1D('patterns.success_rates', successRates);
+        }
+        // Add raw tensors
+        if (model.tensors) {
+            for (const [name, data] of model.tensors) {
+                writer.addTensor(name, data, [data.length]);
+            }
+        }
+        return writer.build();
+    }
+    /**
+     * Export to JSON format
+     */
+    toJSON(model) {
+        return JSON.stringify({
+            metadata: model.metadata,
+            loraConfig: model.loraConfig,
+            loraWeights: model.loraWeights,
+            patterns: model.patterns,
+            ewcStats: model.ewcStats,
+        }, null, 2);
+    }
+    /**
+     * Export to compact binary format
+     */
+    toBinary(model) {
+        const json = this.toJSON(model);
+        const jsonBytes = new TextEncoder().encode(json);
+        // Simple format: [4-byte length][json bytes]
+        const buffer = new Uint8Array(4 + jsonBytes.length);
+        const view = new DataView(buffer.buffer);
+        view.setUint32(0, jsonBytes.length, true);
+        buffer.set(jsonBytes, 4);
+        return buffer;
+    }
+    /**
+     * Export for HuggingFace Hub compatibility
+     */
+    toHuggingFace(model) {
+        const safetensors = this.toSafeTensors(model);
+        const config = JSON.stringify({
+            model_type: 'sona-lora',
+            ...model.metadata,
+            lora_config: model.loraConfig,
+        }, null, 2);
+        const readme = `---
+license: mit
+tags:
+- sona
+- lora
+- ruvector
+---
+
+# ${model.metadata.name}
+
+${model.metadata.architecture} model trained with SONA adaptive learning.
+
+## Usage
+
+\`\`\`typescript
+import { LoraAdapter, SafeTensorsReader } from '@ruvector/ruvllm';
+
+const reader = new SafeTensorsReader(buffer);
+const adapter = new LoraAdapter();
+adapter.setWeights({
+  loraA: reader.getTensor2D('lora.A'),
+  loraB: reader.getTensor2D('lora.B'),
+  scaling: reader.getTensor1D('lora.scaling')[0],
+});
+\`\`\`
+
+## Training Info
+
+- Steps: ${model.metadata.training?.steps || 'N/A'}
+- Final Loss: ${model.metadata.training?.loss || 'N/A'}
+`;
+        return { safetensors, config, readme };
+    }
+}
+/**
+ * Model Importer
+ *
+ * Import models from various formats.
+ */
+export class ModelImporter {
+    /**
+     * Import from SafeTensors format
+     */
+    fromSafeTensors(buffer) {
+        const reader = new SafeTensorsReader(buffer);
+        const metadata = reader.getMetadata();
+        const result = {
+            metadata: {
+                name: metadata.name || 'unknown',
+                version: metadata.version || '1.0.0',
+                architecture: metadata.architecture || 'sona-lora',
+                training: metadata.training_steps ? {
+                    steps: parseInt(metadata.training_steps),
+                    loss: parseFloat(metadata.training_loss || '0'),
+                    learningRate: 0,
+                } : undefined,
+            },
+        };
+        // Load LoRA weights
+        const loraA = reader.getTensor2D('lora.A');
+        const loraB = reader.getTensor2D('lora.B');
+        const loraScaling = reader.getTensor1D('lora.scaling');
+        if (loraA && loraB && loraScaling) {
+            result.loraWeights = {
+                loraA,
+                loraB,
+                scaling: loraScaling[0],
+            };
+        }
+        // Load patterns
+        const patternEmbeddings = reader.getTensor2D('patterns.embeddings');
+        const patternRates = reader.getTensor1D('patterns.success_rates');
+        if (patternEmbeddings && patternRates) {
+            result.patterns = patternEmbeddings.map((embedding, i) => ({
+                id: `imported-${i}`,
+                type: 'query_response',
+                embedding,
+                successRate: patternRates[i] || 0,
+                useCount: 0,
+                lastUsed: new Date(),
+            }));
+        }
+        return result;
+    }
+    /**
+     * Import from JSON format
+     */
+    fromJSON(json) {
+        return JSON.parse(json);
+    }
+    /**
+     * Import from binary format
+     */
+    fromBinary(buffer) {
+        const view = new DataView(buffer.buffer, buffer.byteOffset);
+        const length = view.getUint32(0, true);
+        const jsonBytes = buffer.slice(4, 4 + length);
+        const json = new TextDecoder().decode(jsonBytes);
+        return this.fromJSON(json);
+    }
+}
+/**
+ * Dataset Exporter
+ *
+ * Export training data in various formats.
+ */
+export class DatasetExporter {
+    /**
+     * Export to JSONL format (one JSON per line)
+     */
+    toJSONL(data) {
+        return data
+            .map(item => JSON.stringify({
+            input: item.input,
+            output: item.output,
+            quality: item.quality,
+        }))
+            .join('\n');
+    }
+    /**
+     * Export to CSV format
+     */
+    toCSV(data) {
+        const header = 'quality,input,output';
+        const rows = data.map(item => `${item.quality},"${item.input.join(',')}","${item.output.join(',')}"`);
+        return [header, ...rows].join('\n');
+    }
+    /**
+     * Export patterns for pre-training
+     */
+    toPretrain(patterns) {
+        return patterns
+            .filter(p => p.successRate >= 0.7)
+            .map(p => JSON.stringify({
+            embedding: p.embedding,
+            type: p.type,
+            quality: p.successRate,
+        }))
+            .join('\n');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"export.js","sourceRoot":"","sources":["../../src/export.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Export/Serialization for SONA Models\n *\n * Support for SafeTensors, JSON, and other export formats.\n *\n * @example\n * ```typescript\n * import { ModelExporter, SafeTensorsWriter } from '@ruvector/ruvllm';\n *\n * // Export model to SafeTensors format\n * const exporter = new ModelExporter();\n * const buffer = exporter.toSafeTensors({\n *   weights: loraAdapter.getWeights(),\n *   config: loraAdapter.getConfig(),\n * });\n *\n * // Save to file\n * fs.writeFileSync('model.safetensors', buffer);\n * ```\n */\n\nimport { LoRAConfig, LearnedPattern, EwcStats, Embedding, ModelMetadata } from './types';\nimport { LoraWeights } from './lora';\n\n/**\n * Exportable model data\n */\nexport interface ExportableModel {\n  /** Model metadata */\n  metadata: ModelMetadata;\n  /** LoRA weights (if applicable) */\n  loraWeights?: LoraWeights;\n  /** LoRA config */\n  loraConfig?: LoRAConfig;\n  /** Learned patterns */\n  patterns?: LearnedPattern[];\n  /** EWC statistics */\n  ewcStats?: EwcStats;\n  /** Raw tensors */\n  tensors?: Map<string, Float32Array>;\n}\n\n/**\n * SafeTensors header entry\n */\ninterface SafeTensorsHeader {\n  dtype: string;\n  shape: number[];\n  data_offsets: [number, number];\n}\n\n/**\n * SafeTensors Writer\n *\n * Writes tensors in SafeTensors format for compatibility with\n * HuggingFace ecosystem.\n */\nexport class SafeTensorsWriter {\n  private tensors: Map<string, { data: Float32Array; shape: number[] }> = new Map();\n  private metadata: Record<string, string> = {};\n\n  /**\n   * Add a tensor\n   */\n  addTensor(name: string, data: Float32Array, shape: number[]): this {\n    this.tensors.set(name, { data, shape });\n    return this;\n  }\n\n  /**\n   * Add 2D tensor from number array\n   */\n  add2D(name: string, data: number[][]): this {\n    const rows = data.length;\n    const cols = data[0]?.length || 0;\n    const flat = new Float32Array(rows * cols);\n\n    for (let i = 0; i < rows; i++) {\n      for (let j = 0; j < cols; j++) {\n        flat[i * cols + j] = data[i][j];\n      }\n    }\n\n    return this.addTensor(name, flat, [rows, cols]);\n  }\n\n  /**\n   * Add 1D tensor from number array\n   */\n  add1D(name: string, data: number[]): this {\n    return this.addTensor(name, new Float32Array(data), [data.length]);\n  }\n\n  /**\n   * Add metadata\n   */\n  addMetadata(key: string, value: string): this {\n    this.metadata[key] = value;\n    return this;\n  }\n\n  /**\n   * Build SafeTensors buffer\n   */\n  build(): Uint8Array {\n    // Build header\n    const header: Record<string, SafeTensorsHeader | Record<string, string>> = {};\n    let offset = 0;\n\n    const tensorData: Uint8Array[] = [];\n\n    for (const [name, { data, shape }] of this.tensors) {\n      const bytes = new Uint8Array(data.buffer);\n      const dataLength = bytes.length;\n\n      header[name] = {\n        dtype: 'F32',\n        shape,\n        data_offsets: [offset, offset + dataLength],\n      };\n\n      tensorData.push(bytes);\n      offset += dataLength;\n    }\n\n    // Add metadata\n    if (Object.keys(this.metadata).length > 0) {\n      header['__metadata__'] = this.metadata;\n    }\n\n    // Encode header\n    const headerJson = JSON.stringify(header);\n    const headerBytes = new TextEncoder().encode(headerJson);\n\n    // Pad header to 8-byte alignment\n    const headerPadding = (8 - (headerBytes.length % 8)) % 8;\n    const paddedHeaderLength = headerBytes.length + headerPadding;\n\n    // Build final buffer\n    const totalLength = 8 + paddedHeaderLength + offset;\n    const buffer = new Uint8Array(totalLength);\n    const view = new DataView(buffer.buffer);\n\n    // Write header length (8 bytes, little-endian)\n    view.setBigUint64(0, BigInt(paddedHeaderLength), true);\n\n    // Write header\n    buffer.set(headerBytes, 8);\n\n    // Write tensor data\n    let dataOffset = 8 + paddedHeaderLength;\n    for (const data of tensorData) {\n      buffer.set(data, dataOffset);\n      dataOffset += data.length;\n    }\n\n    return buffer;\n  }\n\n  /**\n   * Clear all tensors and metadata\n   */\n  clear(): void {\n    this.tensors.clear();\n    this.metadata = {};\n  }\n}\n\n/**\n * SafeTensors Reader\n *\n * Reads tensors from SafeTensors format.\n */\nexport class SafeTensorsReader {\n  private buffer: Uint8Array;\n  private header: Record<string, SafeTensorsHeader | Record<string, string>> = {};\n  private dataOffset: number = 0;\n\n  constructor(buffer: Uint8Array) {\n    this.buffer = buffer;\n    this.parseHeader();\n  }\n\n  /**\n   * Get tensor names\n   */\n  getTensorNames(): string[] {\n    return Object.keys(this.header).filter(k => k !== '__metadata__');\n  }\n\n  /**\n   * Get tensor by name\n   */\n  getTensor(name: string): { data: Float32Array; shape: number[] } | null {\n    const entry = this.header[name];\n    if (!entry || typeof entry === 'object' && 'dtype' in entry === false) {\n      return null;\n    }\n\n    const tensorHeader = entry as SafeTensorsHeader;\n    const [start, end] = tensorHeader.data_offsets;\n    const bytes = this.buffer.slice(this.dataOffset + start, this.dataOffset + end);\n\n    return {\n      data: new Float32Array(bytes.buffer, bytes.byteOffset, bytes.length / 4),\n      shape: tensorHeader.shape,\n    };\n  }\n\n  /**\n   * Get tensor as 2D array\n   */\n  getTensor2D(name: string): number[][] | null {\n    const tensor = this.getTensor(name);\n    if (!tensor || tensor.shape.length !== 2) return null;\n\n    const [rows, cols] = tensor.shape;\n    const result: number[][] = [];\n\n    for (let i = 0; i < rows; i++) {\n      const row: number[] = [];\n      for (let j = 0; j < cols; j++) {\n        row.push(tensor.data[i * cols + j]);\n      }\n      result.push(row);\n    }\n\n    return result;\n  }\n\n  /**\n   * Get tensor as 1D array\n   */\n  getTensor1D(name: string): number[] | null {\n    const tensor = this.getTensor(name);\n    if (!tensor) return null;\n    return Array.from(tensor.data);\n  }\n\n  /**\n   * Get metadata\n   */\n  getMetadata(): Record<string, string> {\n    const meta = this.header['__metadata__'];\n    if (!meta || typeof meta !== 'object') return {};\n    return meta as Record<string, string>;\n  }\n\n  private parseHeader(): void {\n    const view = new DataView(this.buffer.buffer, this.buffer.byteOffset);\n    const headerLength = Number(view.getBigUint64(0, true));\n\n    const headerBytes = this.buffer.slice(8, 8 + headerLength);\n    const headerJson = new TextDecoder().decode(headerBytes);\n    this.header = JSON.parse(headerJson.replace(/\\0+$/, '')); // Remove padding nulls\n\n    this.dataOffset = 8 + headerLength;\n  }\n}\n\n/**\n * Model Exporter\n *\n * Unified export interface for SONA models.\n */\nexport class ModelExporter {\n  /**\n   * Export to SafeTensors format\n   */\n  toSafeTensors(model: ExportableModel): Uint8Array {\n    const writer = new SafeTensorsWriter();\n\n    // Add metadata\n    writer.addMetadata('name', model.metadata.name);\n    writer.addMetadata('version', model.metadata.version);\n    writer.addMetadata('architecture', model.metadata.architecture);\n\n    if (model.metadata.training) {\n      writer.addMetadata('training_steps', String(model.metadata.training.steps));\n      writer.addMetadata('training_loss', String(model.metadata.training.loss));\n    }\n\n    // Add LoRA weights\n    if (model.loraWeights) {\n      writer.add2D('lora.A', model.loraWeights.loraA);\n      writer.add2D('lora.B', model.loraWeights.loraB);\n      writer.add1D('lora.scaling', [model.loraWeights.scaling]);\n    }\n\n    // Add patterns as embeddings\n    if (model.patterns && model.patterns.length > 0) {\n      const embeddings: number[][] = model.patterns.map(p => p.embedding);\n      writer.add2D('patterns.embeddings', embeddings);\n\n      const successRates = model.patterns.map(p => p.successRate);\n      writer.add1D('patterns.success_rates', successRates);\n    }\n\n    // Add raw tensors\n    if (model.tensors) {\n      for (const [name, data] of model.tensors) {\n        writer.addTensor(name, data, [data.length]);\n      }\n    }\n\n    return writer.build();\n  }\n\n  /**\n   * Export to JSON format\n   */\n  toJSON(model: ExportableModel): string {\n    return JSON.stringify({\n      metadata: model.metadata,\n      loraConfig: model.loraConfig,\n      loraWeights: model.loraWeights,\n      patterns: model.patterns,\n      ewcStats: model.ewcStats,\n    }, null, 2);\n  }\n\n  /**\n   * Export to compact binary format\n   */\n  toBinary(model: ExportableModel): Uint8Array {\n    const json = this.toJSON(model);\n    const jsonBytes = new TextEncoder().encode(json);\n\n    // Simple format: [4-byte length][json bytes]\n    const buffer = new Uint8Array(4 + jsonBytes.length);\n    const view = new DataView(buffer.buffer);\n    view.setUint32(0, jsonBytes.length, true);\n    buffer.set(jsonBytes, 4);\n\n    return buffer;\n  }\n\n  /**\n   * Export for HuggingFace Hub compatibility\n   */\n  toHuggingFace(model: ExportableModel): {\n    safetensors: Uint8Array;\n    config: string;\n    readme: string;\n  } {\n    const safetensors = this.toSafeTensors(model);\n\n    const config = JSON.stringify({\n      model_type: 'sona-lora',\n      ...model.metadata,\n      lora_config: model.loraConfig,\n    }, null, 2);\n\n    const readme = `---\nlicense: mit\ntags:\n- sona\n- lora\n- ruvector\n---\n\n# ${model.metadata.name}\n\n${model.metadata.architecture} model trained with SONA adaptive learning.\n\n## Usage\n\n\\`\\`\\`typescript\nimport { LoraAdapter, SafeTensorsReader } from '@ruvector/ruvllm';\n\nconst reader = new SafeTensorsReader(buffer);\nconst adapter = new LoraAdapter();\nadapter.setWeights({\n  loraA: reader.getTensor2D('lora.A'),\n  loraB: reader.getTensor2D('lora.B'),\n  scaling: reader.getTensor1D('lora.scaling')[0],\n});\n\\`\\`\\`\n\n## Training Info\n\n- Steps: ${model.metadata.training?.steps || 'N/A'}\n- Final Loss: ${model.metadata.training?.loss || 'N/A'}\n`;\n\n    return { safetensors, config, readme };\n  }\n}\n\n/**\n * Model Importer\n *\n * Import models from various formats.\n */\nexport class ModelImporter {\n  /**\n   * Import from SafeTensors format\n   */\n  fromSafeTensors(buffer: Uint8Array): Partial<ExportableModel> {\n    const reader = new SafeTensorsReader(buffer);\n    const metadata = reader.getMetadata();\n\n    const result: Partial<ExportableModel> = {\n      metadata: {\n        name: metadata.name || 'unknown',\n        version: metadata.version || '1.0.0',\n        architecture: metadata.architecture || 'sona-lora',\n        training: metadata.training_steps ? {\n          steps: parseInt(metadata.training_steps),\n          loss: parseFloat(metadata.training_loss || '0'),\n          learningRate: 0,\n        } : undefined,\n      },\n    };\n\n    // Load LoRA weights\n    const loraA = reader.getTensor2D('lora.A');\n    const loraB = reader.getTensor2D('lora.B');\n    const loraScaling = reader.getTensor1D('lora.scaling');\n\n    if (loraA && loraB && loraScaling) {\n      result.loraWeights = {\n        loraA,\n        loraB,\n        scaling: loraScaling[0],\n      };\n    }\n\n    // Load patterns\n    const patternEmbeddings = reader.getTensor2D('patterns.embeddings');\n    const patternRates = reader.getTensor1D('patterns.success_rates');\n\n    if (patternEmbeddings && patternRates) {\n      result.patterns = patternEmbeddings.map((embedding, i) => ({\n        id: `imported-${i}`,\n        type: 'query_response' as const,\n        embedding,\n        successRate: patternRates[i] || 0,\n        useCount: 0,\n        lastUsed: new Date(),\n      }));\n    }\n\n    return result;\n  }\n\n  /**\n   * Import from JSON format\n   */\n  fromJSON(json: string): Partial<ExportableModel> {\n    return JSON.parse(json);\n  }\n\n  /**\n   * Import from binary format\n   */\n  fromBinary(buffer: Uint8Array): Partial<ExportableModel> {\n    const view = new DataView(buffer.buffer, buffer.byteOffset);\n    const length = view.getUint32(0, true);\n    const jsonBytes = buffer.slice(4, 4 + length);\n    const json = new TextDecoder().decode(jsonBytes);\n    return this.fromJSON(json);\n  }\n}\n\n/**\n * Dataset Exporter\n *\n * Export training data in various formats.\n */\nexport class DatasetExporter {\n  /**\n   * Export to JSONL format (one JSON per line)\n   */\n  toJSONL(data: Array<{ input: Embedding; output: Embedding; quality: number }>): string {\n    return data\n      .map(item => JSON.stringify({\n        input: item.input,\n        output: item.output,\n        quality: item.quality,\n      }))\n      .join('\\n');\n  }\n\n  /**\n   * Export to CSV format\n   */\n  toCSV(data: Array<{ input: Embedding; output: Embedding; quality: number }>): string {\n    const header = 'quality,input,output';\n    const rows = data.map(item =>\n      `${item.quality},\"${item.input.join(',')}\",\"${item.output.join(',')}\"`\n    );\n    return [header, ...rows].join('\\n');\n  }\n\n  /**\n   * Export patterns for pre-training\n   */\n  toPretrain(patterns: LearnedPattern[]): string {\n    return patterns\n      .filter(p => p.successRate >= 0.7)\n      .map(p => JSON.stringify({\n        embedding: p.embedding,\n        type: p.type,\n        quality: p.successRate,\n      }))\n      .join('\\n');\n  }\n}\n"]}