@soulcraft/brainy 6.5.0 → 6.6.1

package/dist/embeddings/wasm/types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Type definitions for WASM Embedding Engine
+ *
+ * Clean, production-grade types for direct ONNX WASM embeddings.
+ */
+/**
+ * Tokenizer configuration for WordPiece
+ */
+export interface TokenizerConfig {
+    /** Vocabulary mapping word → token ID */
+    vocab: Map<string, number>;
+    /** [UNK] token ID (100 for BERT-based models) */
+    unkTokenId: number;
+    /** [CLS] token ID (101 for BERT-based models) */
+    clsTokenId: number;
+    /** [SEP] token ID (102 for BERT-based models) */
+    sepTokenId: number;
+    /** [PAD] token ID (0 for BERT-based models) */
+    padTokenId: number;
+    /** Maximum sequence length (512 for all-MiniLM-L6-v2) */
+    maxLength: number;
+    /** Whether to lowercase input (true for uncased models) */
+    doLowerCase: boolean;
+}
+/**
+ * Result of tokenization
+ */
+export interface TokenizedInput {
+    /** Token IDs including [CLS] and [SEP] */
+    inputIds: number[];
+    /** Attention mask (1 for real tokens, 0 for padding) */
+    attentionMask: number[];
+    /** Token type IDs (all 0 for single sentence) */
+    tokenTypeIds: number[];
+    /** Number of tokens (excluding special tokens) */
+    tokenCount: number;
+}
+/**
+ * ONNX inference engine configuration
+ */
+export interface InferenceConfig {
+    /** Path to ONNX model file */
+    modelPath: string;
+    /** Path to WASM files directory */
+    wasmPath?: string;
+    /** Number of threads (1 for universal compatibility) */
+    numThreads: number;
+    /** Enable SIMD if available */
+    enableSimd: boolean;
+    /** Enable CPU memory arena (false for memory efficiency) */
+    enableCpuMemArena: boolean;
+}
+/**
+ * Embedding result with metadata
+ */
+export interface EmbeddingResult {
+    /** 384-dimensional embedding vector */
+    embedding: number[];
+    /** Number of tokens processed */
+    tokenCount: number;
+    /** Processing time in milliseconds */
+    processingTimeMs: number;
+}
+/**
+ * Engine statistics
+ */
+export interface EngineStats {
+    /** Whether the engine is initialized */
+    initialized: boolean;
+    /** Total number of embeddings generated */
+    embedCount: number;
+    /** Total processing time in milliseconds */
+    totalProcessingTimeMs: number;
+    /** Average processing time per embedding */
+    avgProcessingTimeMs: number;
+    /** Model name */
+    modelName: string;
+}
+/**
+ * Model configuration (from config.json)
+ */
+export interface ModelConfig {
+    /** Model architecture type */
+    architectures: string[];
+    /** Hidden size (384 for all-MiniLM-L6-v2) */
+    hidden_size: number;
+    /** Number of attention heads */
+    num_attention_heads: number;
+    /** Number of hidden layers */
+    num_hidden_layers: number;
+    /** Vocabulary size */
+    vocab_size: number;
+    /** Maximum position embeddings */
+    max_position_embeddings: number;
+}
+/**
+ * Special token IDs for BERT-based models
+ */
+export declare const SPECIAL_TOKENS: {
+    readonly PAD: 0;
+    readonly UNK: 100;
+    readonly CLS: 101;
+    readonly SEP: 102;
+    readonly MASK: 103;
+};
+/**
+ * Model constants for all-MiniLM-L6-v2
+ */
+export declare const MODEL_CONSTANTS: {
+    readonly HIDDEN_SIZE: 384;
+    readonly MAX_SEQUENCE_LENGTH: 512;
+    readonly VOCAB_SIZE: 30522;
+    readonly MODEL_NAME: "all-MiniLM-L6-v2";
+};

package/dist/embeddings/wasm/types.js

@@ -0,0 +1,25 @@
+/**
+ * Type definitions for WASM Embedding Engine
+ *
+ * Clean, production-grade types for direct ONNX WASM embeddings.
+ */
+/**
+ * Special token IDs for BERT-based models
+ */
+export const SPECIAL_TOKENS = {
+    PAD: 0,
+    UNK: 100,
+    CLS: 101,
+    SEP: 102,
+    MASK: 103,
+};
+/**
+ * Model constants for all-MiniLM-L6-v2
+ */
+export const MODEL_CONSTANTS = {
+    HIDDEN_SIZE: 384,
+    MAX_SEQUENCE_LENGTH: 512,
+    VOCAB_SIZE: 30522,
+    MODEL_NAME: 'all-MiniLM-L6-v2',
+};
+//# sourceMappingURL=types.js.map

package/dist/setup.d.ts

@@ -1,17 +1,17 @@
 /**
- * CRITICAL: This file is imported for its side effects to patch the environment
- * for Node.js compatibility before any other library code runs.
+ * Brainy Setup - Minimal Polyfills
  *
- * It ensures that by the time Transformers.js/ONNX Runtime is imported by any other
- * module, the necessary compatibility fixes for the current Node.js
- * environment are already in place.
+ * ARCHITECTURE (v7.0.0):
+ * Brainy uses direct ONNX WASM for embeddings.
+ * No transformers.js dependency, no hacks required.
  *
- * This file MUST be imported as the first import in unified.ts to prevent
- * race conditions with library initialization. Failure to do so may
- * result in errors like "TextEncoder is not a constructor" when the package
- * is used in Node.js environments.
+ * This file provides minimal polyfills for cross-environment compatibility:
+ * - TextEncoder/TextDecoder for older environments
  *
- * The package.json file marks this file as having side effects to prevent
- * tree-shaking by bundlers, ensuring the patch is always applied.
+ * BENEFITS:
+ * - Clean codebase with no workarounds
+ * - Works everywhere: Node.js, Bun, Bun --compile, browsers, Deno
+ * - No platform-specific binaries
+ * - Model bundled in package (no runtime downloads)
  */
 export {};

package/dist/setup.js

@@ -1,45 +1,31 @@
 /**
- * CRITICAL: This file is imported for its side effects to patch the environment
- * for Node.js compatibility before any other library code runs.
+ * Brainy Setup - Minimal Polyfills
  *
- * It ensures that by the time Transformers.js/ONNX Runtime is imported by any other
- * module, the necessary compatibility fixes for the current Node.js
- * environment are already in place.
+ * ARCHITECTURE (v7.0.0):
+ * Brainy uses direct ONNX WASM for embeddings.
+ * No transformers.js dependency, no hacks required.
  *
- * This file MUST be imported as the first import in unified.ts to prevent
- * race conditions with library initialization. Failure to do so may
- * result in errors like "TextEncoder is not a constructor" when the package
- * is used in Node.js environments.
+ * This file provides minimal polyfills for cross-environment compatibility:
+ * - TextEncoder/TextDecoder for older environments
  *
- * The package.json file marks this file as having side effects to prevent
- * tree-shaking by bundlers, ensuring the patch is always applied.
+ * BENEFITS:
+ * - Clean codebase with no workarounds
+ * - Works everywhere: Node.js, Bun, Bun --compile, browsers, Deno
+ * - No platform-specific binaries
+ * - Model bundled in package (no runtime downloads)
  */
-// Get the appropriate global object for the current environment
-const globalObj = (() => {
-    if (typeof globalThis !== 'undefined')
-        return globalThis;
-    if (typeof global !== 'undefined')
-        return global;
-    if (typeof self !== 'undefined')
-        return self;
-    return null; // No global object available
-})();
-// Define TextEncoder and TextDecoder globally to make sure they're available
-// Now works across all environments: Node.js, serverless, and other server environments
+// ============================================================================
+// TextEncoder/TextDecoder Polyfills
+// ============================================================================
+const globalObj = globalThis ?? global ?? self;
 if (globalObj) {
-    if (!globalObj.TextEncoder) {
+    if (!globalObj.TextEncoder)
         globalObj.TextEncoder = TextEncoder;
-    }
-    if (!globalObj.TextDecoder) {
+    if (!globalObj.TextDecoder)
         globalObj.TextDecoder = TextDecoder;
-    }
-    // Create special global constructors for library compatibility
     globalObj.__TextEncoder__ = TextEncoder;
     globalObj.__TextDecoder__ = TextDecoder;
 }
-// Also import normally for ES modules environments
 import { applyTensorFlowPatch } from './utils/textEncoding.js';
-// Apply the TextEncoder/TextDecoder compatibility patch
 applyTensorFlowPatch();
-console.log('Applied TextEncoder/TextDecoder patch via ES modules in setup.ts');
 //# sourceMappingURL=setup.js.map

package/dist/types/brainy.types.d.ts

@@ -518,11 +518,6 @@ export interface BrainyConfig {
         options?: any;
         branch?: string;
     };
-    model?: {
-        type: 'fast' | 'accurate' | 'balanced' | 'custom';
-        name?: string;
-        precision?: 'q8';
-    };
     index?: {
         m?: number;
         efConstruction?: number;

package/dist/utils/embedding.d.ts

@@ -1,60 +1,37 @@
 /**
- * Embedding functions for converting data to vectors using Transformers.js
- * Complete rewrite to eliminate TensorFlow.js and use ONNX-based models
+ * Embedding functions for converting data to vectors
+ *
+ * Uses direct ONNX WASM for universal compatibility.
+ * No transformers.js dependency - clean, production-grade implementation.
  */
 import { EmbeddingFunction, EmbeddingModel, Vector } from '../coreTypes.js';
 /**
- * Detect the best available GPU device for the current environment
- */
-export declare function detectBestDevice(): Promise<'cpu' | 'webgpu' | 'cuda'>;
-/**
- * Resolve device string to actual device configuration
- */
-export declare function resolveDevice(device?: string): Promise<string>;
-/**
- * Transformers.js Sentence Encoder embedding model
- * Uses ONNX Runtime for fast, offline embeddings with smaller models
- * Default model: all-MiniLM-L6-v2 (384 dimensions, ~90MB)
+ * TransformerEmbedding options (kept for backward compatibility)
  */
 export interface TransformerEmbeddingOptions {
-    /** Model name/path to use - defaults to all-MiniLM-L6-v2 */
+    /** Model name - only all-MiniLM-L6-v2 is supported */
     model?: string;
     /** Whether to enable verbose logging */
     verbose?: boolean;
-    /** Custom cache directory for models */
+    /** Custom cache directory - ignored (model is bundled) */
     cacheDir?: string;
-    /** Force local files only (no downloads) */
+    /** Force local files only - ignored (model is bundled) */
     localFilesOnly?: boolean;
-    /** Model precision: 'q8' = 75% smaller quantized model, 'fp32' = full precision (default) */
+    /** Model precision - always q8 */
     precision?: 'fp32' | 'q8';
-    /** Device to run inference on - 'auto' detects best available */
+    /** Device - always WASM */
     device?: 'auto' | 'cpu' | 'webgpu' | 'cuda' | 'gpu';
 }
+/**
+ * TransformerEmbedding - Sentence embeddings using WASM ONNX
+ *
+ * This class delegates all work to EmbeddingManager which uses
+ * the direct ONNX WASM engine. Kept for backward compatibility.
+ */
 export declare class TransformerEmbedding implements EmbeddingModel {
-    private extractor;
     private initialized;
     private verbose;
-    private options;
-    /**
-     * Create a new TransformerEmbedding instance
-     */
     constructor(options?: TransformerEmbeddingOptions);
-    /**
-     * Get the default cache directory for models
-     */
-    private getDefaultCacheDir;
-    /**
-     * Check if we're running in a test environment
-     */
-    private isTestEnvironment;
-    /**
-     * Log message only if verbose mode is enabled
-     */
-    private logger;
-    /**
-     * Generate mock embeddings for unit tests
-     */
-    private getMockEmbedding;
     /**
      * Initialize the embedding model
      */
@@ -64,45 +41,51 @@ export declare class TransformerEmbedding implements EmbeddingModel {
      */
     embed(data: string | string[]): Promise<Vector>;
     /**
-     * Dispose of the model and free resources
+     * Get the embedding function
      */
-    dispose(): Promise<void>;
+    getEmbeddingFunction(): EmbeddingFunction;
     /**
-     * Get the dimension of embeddings produced by this model
+     * Check if initialized
      */
-    getDimension(): number;
+    isInitialized(): boolean;
     /**
-     * Check if the model is initialized
+     * Dispose resources (no-op for WASM engine)
      */
-    isInitialized(): boolean;
+    dispose(): Promise<void>;
 }
-export declare const UniversalSentenceEncoder: typeof TransformerEmbedding;
 /**
- * Create a new embedding model instance
+ * Create a simple embedding function using the default TransformerEmbedding
+ * This is the recommended way to create an embedding function for Brainy
  */
-export declare function createEmbeddingModel(options?: TransformerEmbeddingOptions): EmbeddingModel;
+export declare function createEmbeddingFunction(options?: TransformerEmbeddingOptions): EmbeddingFunction;
 /**
- * Default embedding function using the unified EmbeddingManager
- * Simple, clean, reliable - no more layers of indirection
+ * Create a TransformerEmbedding instance (backward compatibility)
+ */
+export declare function createTransformerEmbedding(options?: TransformerEmbeddingOptions): TransformerEmbedding;
+/**
+ * Convenience function to detect best device (always returns 'wasm')
+ */
+export declare function detectBestDevice(): Promise<'cpu' | 'webgpu' | 'cuda' | 'wasm'>;
+/**
+ * Resolve device string (always returns 'wasm')
+ */
+export declare function resolveDevice(_device?: string): Promise<string>;
+/**
+ * Default embedding function (backward compatibility)
  */
 export declare const defaultEmbeddingFunction: EmbeddingFunction;
 /**
- * Create an embedding function with custom options
- * NOTE: Options are validated but the singleton EmbeddingManager is always used
+ * UniversalSentenceEncoder alias (backward compatibility)
  */
-export declare function createEmbeddingFunction(options?: TransformerEmbeddingOptions): EmbeddingFunction;
+export declare const UniversalSentenceEncoder: typeof TransformerEmbedding;
 /**
- * Batch embedding function for processing multiple texts efficiently
+ * Batch embed function (backward compatibility)
  */
-export declare function batchEmbed(texts: string[], options?: TransformerEmbeddingOptions): Promise<Vector[]>;
+export declare function batchEmbed(texts: string[]): Promise<Vector[]>;
 /**
- * Embedding functions for specific model types
+ * Embedding functions registry (backward compatibility)
  */
 export declare const embeddingFunctions: {
-    /** Default lightweight model (all-MiniLM-L6-v2, 384 dimensions) */
-    default: EmbeddingFunction;
-    /** Create custom embedding function */
-    create: typeof createEmbeddingFunction;
-    /** Batch processing */
-    batch: typeof batchEmbed;
+    transformer: typeof createEmbeddingFunction;
+    default: typeof createEmbeddingFunction;
 };