edgeflowjs 0.1.0 → 0.3.0

package/README.md

@@ -2,10 +2,10 @@
 
 <div align="center">
 
-**Lightweight, high-performance browser ML inference framework.**
+**Browser ML inference framework with task scheduling and smart caching.**
 
 [![npm version](https://img.shields.io/npm/v/edgeflowjs.svg)](https://www.npmjs.com/package/edgeflowjs)
-[![bundle size](https://img.shields.io/bundlephobia/minzip/edgeflowjs)](https://bundlephobia.com/package/edgeflowjs)
+[![install size](https://packagephobia.com/badge?p=edgeflowjs)](https://packagephobia.com/result?p=edgeflowjs)
 [![license](https://img.shields.io/npm/l/edgeflowjs)](LICENSE)
 
 [Documentation](https://edgeflow.js.org) · [Examples](examples/) · [API Reference](https://edgeflow.js.org/api) · [English](README.md) | [中文](README_CN.md)
@@ -16,30 +16,34 @@
 
 ## ✨ Features
 
-- 🚀 **Native Concurrency** - Run multiple models in parallel, no more serial execution bottleneck
-- 📦 **Lightweight** - Core bundle < 500KB, zero runtime dependencies
-- 🔄 **Native Batch Processing** - Efficient batch inference out of the box
-- 💾 **Smart Memory Management** - Automatic memory tracking and cleanup
-- 🎯 **Developer Friendly** - Full TypeScript support with intuitive APIs
-- 🔌 **Modular Architecture** - Import only what you need
-- 📥 **Advanced Model Loading** - Preloading, sharding, resume download support
-- 💿 **Intelligent Caching** - IndexedDB-based model caching for offline use
-- ⚡ **High Performance** - WebGPU-first with automatic fallback to WebNN/WASM
+- 📋 **Task Scheduler** - Priority queue, concurrency control, task cancellation
+- 🔄 **Batch Processing** - Efficient batch inference out of the box
+- 💾 **Memory Management** - Automatic memory tracking and cleanup with scopes
+- 📥 **Smart Model Loading** - Preloading, sharding, resume download support
+- 💿 **Offline Caching** - IndexedDB-based model caching for offline use
+- ⚡ **Multi-Backend** - ONNX Runtime with WebGPU/WASM execution providers, automatic fallback
+- 🤗 **HuggingFace Hub** - Direct model download with one line
+- 🔤 **Real Tokenizers** - BPE & WordPiece tokenizers, load tokenizer.json directly
+- 👷 **Web Worker Support** - Run inference in background threads
+- 📦 **Batteries Included** - ONNX Runtime bundled, zero configuration needed
+- 🎯 **TypeScript First** - Full type support with intuitive APIs
 
 ## 📦 Installation
 
 ```bash
-npm install edgeflow
+npm install edgeflowjs
 ```
 
 ```bash
-yarn add edgeflow
+yarn add edgeflowjs
 ```
 
 ```bash
-pnpm add edgeflow
+pnpm add edgeflowjs
 ```
 
+> **Note**: ONNX Runtime is included as a dependency. No additional setup required.
+
 ## 🚀 Quick Start
 
 ### Try the Demo
@@ -67,14 +71,14 @@ Open **http://localhost:3000** in your browser:
    - 🧮 **Tensor Operations** - Test tensor creation, math ops, softmax, relu
    - 📝 **Text Classification** - Run sentiment analysis on text
    - 🔍 **Feature Extraction** - Extract embeddings from text
-   - ⚡ **Concurrent Execution** - Test parallel inference
+   - ⚡ **Task Scheduling** - Test priority-based scheduling
    - 📋 **Task Scheduler** - Test priority-based task scheduling
    - 💾 **Memory Management** - Test allocation and cleanup
 
 ### Basic Usage
 
 ```typescript
-import { pipeline } from 'edgeflow';
+import { pipeline } from 'edgeflowjs';
 
 // Create a sentiment analysis pipeline
 const sentiment = await pipeline('sentiment-analysis');
@@ -103,16 +107,16 @@ console.log(results);
 // ]
 ```
 
-### Concurrent Execution
+### Multiple Pipelines
 
 ```typescript
-import { pipeline } from 'edgeflow';
+import { pipeline } from 'edgeflowjs';
 
 // Create multiple pipelines
 const classifier = await pipeline('text-classification');
 const extractor = await pipeline('feature-extraction');
 
-// Run concurrently - no more serial bottleneck!
+// Run in parallel with Promise.all
 const [classification, features] = await Promise.all([
   classifier.run('Sample text'),
   extractor.run('Sample text')
@@ -122,7 +126,7 @@ const [classification, features] = await Promise.all([
 ### Image Classification
 
 ```typescript
-import { pipeline } from 'edgeflow';
+import { pipeline } from 'edgeflowjs';
 
 const classifier = await pipeline('image-classification');
 
@@ -137,48 +141,159 @@ const result = await classifier.run(img);
 const results = await classifier.run([img1, img2, img3]);
 ```
 
-## 🎯 Supported Tasks
+### Text Generation (Streaming)
 
-| Task | Pipeline | Status |
-|------|----------|--------|
-| Text Classification | `text-classification` | ✅ |
-| Sentiment Analysis | `sentiment-analysis` | ✅ |
-| Feature Extraction | `feature-extraction` | ✅ |
-| Image Classification | `image-classification` | ✅ |
-| Object Detection | `object-detection` | 🔜 |
-| Text Generation | `text-generation` | 🔜 |
-| Speech Recognition | `automatic-speech-recognition` | 🔜 |
+```typescript
+import { pipeline } from 'edgeflowjs';
+
+const generator = await pipeline('text-generation');
+
+// Simple generation
+const result = await generator.run('Once upon a time', {
+  maxNewTokens: 50,
+  temperature: 0.8,
+});
+console.log(result.generatedText);
+
+// Streaming output
+for await (const event of generator.stream('Hello, ')) {
+  process.stdout.write(event.token);
+  if (event.done) break;
+}
+```
+
+### Zero-shot Classification
+
+```typescript
+import { pipeline } from 'edgeflowjs';
 
-## ⚡ Performance
+const classifier = await pipeline('zero-shot-classification');
 
-### Comparison with transformers.js
+const result = await classifier.classify(
+  'I love playing soccer on weekends',
+  ['sports', 'politics', 'technology', 'entertainment']
+);
 
-| Feature | transformers.js | edgeFlow.js |
-|---------|-----------------|-------------|
-| Concurrent Execution | ❌ Serial | ✅ Parallel |
-| Batch Processing | ⚠️ Partial | ✅ Native |
-| Memory Management | ⚠️ Basic | ✅ Complete |
-| Bundle Size | ~2-5MB | <500KB |
-| Dependencies | ONNX Runtime | Optional |
+console.log(result.labels[0], result.scores[0]);
+// 'sports', 0.92
+```
 
-### Benchmarks
+### Question Answering
 
+```typescript
+import { pipeline } from 'edgeflowjs';
+
+const qa = await pipeline('question-answering');
+
+const result = await qa.run({
+  question: 'What is the capital of France?',
+  context: 'Paris is the capital and largest city of France.'
+});
+
+console.log(result.answer); // 'Paris'
 ```
-Text Classification (BERT-base):
-- transformers.js: 45ms (serial)
-- edgeFlow.js: 42ms (parallel capable)
 
-Concurrent 4 models:
-- transformers.js: 180ms (4 × 45ms serial)
-- edgeFlow.js: 52ms (parallel execution)
+### Load from HuggingFace Hub
+
+```typescript
+import { fromHub, fromTask } from 'edgeflowjs';
+
+// Load by model ID (auto-downloads model, tokenizer, config)
+const bundle = await fromHub('Xenova/distilbert-base-uncased-finetuned-sst-2-english');
+console.log(bundle.tokenizer); // Tokenizer instance
+console.log(bundle.config);    // Model config
+
+// Load by task name (uses recommended model)
+const sentimentBundle = await fromTask('sentiment-analysis');
 ```
 
+### Web Workers (Background Inference)
+
+```typescript
+import { runInWorker, WorkerPool, isWorkerSupported } from 'edgeflowjs';
+
+// Simple: run inference in background thread
+if (isWorkerSupported()) {
+  const outputs = await runInWorker(modelUrl, inputs);
+}
+
+// Advanced: use worker pool for parallel processing
+const pool = new WorkerPool({ numWorkers: 4 });
+await pool.init();
+
+const modelId = await pool.loadModel(modelUrl);
+const results = await pool.runBatch(modelId, batchInputs);
+
+pool.terminate();
+```
+
+## 🎯 Supported Tasks
+
+| Task | Pipeline | Status |
+|------|----------|--------|
+| Text Generation | `text-generation` | ✅ Production (TinyLlama, streaming, KV cache) |
+| Image Segmentation | `image-segmentation` | ✅ Production (SlimSAM, interactive prompts) |
+| Text Classification | `text-classification` | ⚠️ Experimental (heuristic, provide own model) |
+| Sentiment Analysis | `sentiment-analysis` | ⚠️ Experimental (heuristic, provide own model) |
+| Feature Extraction | `feature-extraction` | ⚠️ Experimental (mock embeddings, provide own model) |
+| Image Classification | `image-classification` | ⚠️ Experimental (heuristic, provide own model) |
+| Object Detection | `object-detection` | ⚠️ Experimental (real NMS/IoU, needs own model) |
+| Speech Recognition | `automatic-speech-recognition` | ⚠️ Experimental (preprocessing only, needs model) |
+| Zero-shot Classification | `zero-shot-classification` | ⚠️ Experimental (random scoring, needs NLI model) |
+| Question Answering | `question-answering` | ⚠️ Experimental (word overlap heuristic, needs model) |
+
+> **Note:** Experimental pipelines work for demos and testing the API surface. For production accuracy, provide a real ONNX model via `options.model` or use the **transformers.js adapter backend** to leverage HuggingFace's model ecosystem.
+
+## ⚡ Key Differentiators
+
+edgeFlow.js is not a replacement for transformers.js — it is a **production orchestration layer** that can wrap any inference engine (including transformers.js) and add the features real apps need.
+
+### What edgeFlow.js adds on top of inference engines
+
+| Feature | Inference engines alone | With edgeFlow.js |
+|---------|------------------------|------------------|
+| Task Scheduling | None — run and hope | Priority queue with concurrency limits |
+| Task Cancellation | Not possible | Cancel pending/queued tasks |
+| Batch Processing | Manual | Built-in batching with configurable size |
+| Memory Management | Manual cleanup | Automatic scopes, leak detection, GC hints |
+| Model Preloading | Manual | Background preloading with priority queue |
+| Resume Download | Start over on failure | Chunked download with automatic resume |
+| Model Caching | Basic or none | IndexedDB cache with stats and eviction |
+| Pipeline Composition | Not available | Chain multiple models (ASR → translate → TTS) |
+| Device Adaptation | Manual model selection | Auto-select model variant by device capability |
+| Performance Monitoring | External tooling needed | Built-in dashboard and alerting |
+
+## 🔌 transformers.js Adapter (Recommended)
+
+Use edgeFlow.js as an orchestration layer on top of [transformers.js](https://huggingface.co/docs/transformers.js) to get access to 1000+ HuggingFace models with scheduling, caching, and memory management:
+
+```typescript
+import { pipeline as tfPipeline } from '@xenova/transformers';
+import { useTransformersBackend, pipeline } from 'edgeflowjs';
+
+// Register transformers.js as the inference backend
+useTransformersBackend({
+  pipelineFactory: tfPipeline,
+  device: 'webgpu',    // GPU acceleration
+  dtype: 'fp16',       // Half precision
+});
+
+// Use edgeFlow.js API — scheduling, caching, memory management included
+const classifier = await pipeline('text-classification', {
+  model: 'Xenova/distilbert-base-uncased-finetuned-sst-2-english',
+});
+
+const result = await classifier.run('I love this product!');
+```
+
+> **Why?** transformers.js is excellent at loading and running single models. edgeFlow.js adds the production features you need when running multiple models, managing memory on constrained devices, caching for offline use, and scheduling concurrent inference.
+
 ## 🔧 Configuration
 
 ### Runtime Selection
 
 ```typescript
-import { pipeline } from 'edgeflow';
+import { pipeline } from 'edgeflowjs';
 
 // Automatic (recommended)
 const model = await pipeline('text-classification');
@@ -192,7 +307,7 @@ const model = await pipeline('text-classification', {
 ### Memory Management
 
 ```typescript
-import { pipeline, getMemoryStats, gc } from 'edgeflow';
+import { pipeline, getMemoryStats, gc } from 'edgeflowjs';
 
 const model = await pipeline('text-classification');
 
@@ -213,7 +328,7 @@ gc();
 ### Scheduler Configuration
 
 ```typescript
-import { configureScheduler } from 'edgeflow';
+import { configureScheduler } from 'edgeflowjs';
 
 configureScheduler({
   maxConcurrentTasks: 4,
@@ -227,7 +342,7 @@ configureScheduler({
 ### Caching
 
 ```typescript
-import { pipeline, Cache } from 'edgeflow';
+import { pipeline, Cache } from 'edgeflowjs';
 
 // Create a cache
 const cache = new Cache({
@@ -246,7 +361,7 @@ const model = await pipeline('text-classification', {
 ### Custom Model Loading
 
 ```typescript
-import { loadModel, runInference } from 'edgeflow';
+import { loadModel, runInference } from 'edgeflowjs';
 
 // Load from URL with caching, sharding, and resume support
 const model = await loadModel('https://example.com/model.bin', {
@@ -268,7 +383,7 @@ model.dispose();
 ### Preloading Models
 
 ```typescript
-import { preloadModel, preloadModels, getPreloadStatus } from 'edgeflow';
+import { preloadModel, preloadModels, getPreloadStatus } from 'edgeflowjs';
 
 // Preload a single model in background (with priority)
 preloadModel('https://example.com/model1.onnx', { priority: 10 });
@@ -293,7 +408,7 @@ import {
   deleteCachedModel, 
   clearModelCache,
   getModelCacheStats 
-} from 'edgeflow';
+} from 'edgeflowjs';
 
 // Check if model is cached
 if (await isModelCached('https://example.com/model.onnx')) {
@@ -319,7 +434,7 @@ console.log(`${stats.models} models cached, ${stats.totalSize} bytes total`);
 Large model downloads automatically support resuming from where they left off:
 
 ```typescript
-import { loadModelData } from 'edgeflow';
+import { loadModelData } from 'edgeflowjs';
 
 // Download with progress and resume support
 const modelData = await loadModelData('https://example.com/large-model.onnx', {
@@ -338,7 +453,7 @@ const modelData = await loadModelData('https://example.com/large-model.onnx', {
 ### Model Quantization
 
 ```typescript
-import { quantize } from 'edgeflow/tools';
+import { quantize } from 'edgeflowjs/tools';
 
 const quantized = await quantize(model, {
   method: 'int8',
@@ -352,7 +467,7 @@ console.log(`Compression: ${quantized.compressionRatio}x`);
 ### Benchmarking
 
 ```typescript
-import { benchmark } from 'edgeflow/tools';
+import { benchmark } from 'edgeflowjs/tools';
 
 const result = await benchmark(
   () => model.run('sample text'),
@@ -371,7 +486,7 @@ console.log(result);
 ### Memory Scope
 
 ```typescript
-import { withMemoryScope, tensor } from 'edgeflow';
+import { withMemoryScope, tensor } from 'edgeflowjs';
 
 const result = await withMemoryScope(async (scope) => {
   // Tensors tracked in scope
@@ -390,7 +505,7 @@ const result = await withMemoryScope(async (scope) => {
 ## 🔌 Tensor Operations
 
 ```typescript
-import { tensor, zeros, ones, matmul, softmax, relu } from 'edgeflow';
+import { tensor, zeros, ones, matmul, softmax, relu } from 'edgeflowjs';
 
 // Create tensors
 const a = tensor([[1, 2], [3, 4]]);
@@ -417,6 +532,10 @@ c.dispose();
 | Firefox 118+ | ⚠️ Flag | ❌ | ✅ |
 | Safari 17+ | ⚠️ Preview | ❌ | ✅ |
 
+## Star History
+
+[![Star History Chart](https://api.star-history.com/image?repos=s-zx/edgeFlow.js&type=date&legend=top-left)](https://www.star-history.com/?repos=s-zx%2FedgeFlow.js&type=date&legend=top-left)
+
 ## 📖 API Reference
 
 ### Core
@@ -426,20 +545,35 @@ c.dispose();
 - `runInference(model, inputs)` - Run model inference
 - `getScheduler()` - Get the global scheduler
 - `getMemoryManager()` - Get the memory manager
+- `runInWorker(url, inputs)` - Run inference in a Web Worker
+- `WorkerPool` - Manage multiple workers for parallel inference
 
 ### Pipelines
 
-- `TextClassificationPipeline`
-- `SentimentAnalysisPipeline`
-- `FeatureExtractionPipeline`
-- `ImageClassificationPipeline`
+- `TextClassificationPipeline` - Text/sentiment classification
+- `SentimentAnalysisPipeline` - Sentiment analysis
+- `FeatureExtractionPipeline` - Text embeddings
+- `ImageClassificationPipeline` - Image classification
+- `TextGenerationPipeline` - Text generation with streaming
+- `ObjectDetectionPipeline` - Object detection with bounding boxes
+- `AutomaticSpeechRecognitionPipeline` - Speech to text
+- `ZeroShotClassificationPipeline` - Classify without training
+- `QuestionAnsweringPipeline` - Extractive QA
+
+### HuggingFace Hub
+
+- `fromHub(modelId, options?)` - Load model bundle from HuggingFace
+- `fromTask(task, options?)` - Load recommended model for task
+- `downloadTokenizer(modelId)` - Download tokenizer only
+- `downloadConfig(modelId)` - Download config only
+- `POPULAR_MODELS` - Registry of popular models by task
 
 ### Utilities
 
-- `Tokenizer` - Text tokenization
-- `ImagePreprocessor` - Image preprocessing
-- `AudioPreprocessor` - Audio preprocessing
-- `Cache` - Caching utilities
+- `Tokenizer` - BPE/WordPiece tokenization with HuggingFace support
+- `ImagePreprocessor` - Image preprocessing with HuggingFace config support
+- `AudioPreprocessor` - Audio preprocessing for Whisper/wav2vec
+- `Cache` - LRU caching utilities
 
 ### Tools
 

package/dist/backends/index.d.ts

@@ -4,10 +4,17 @@
 export { WebGPURuntime, createWebGPURuntime } from './webgpu.js';
 export { WebNNRuntime, createWebNNRuntime } from './webnn.js';
 export { WASMRuntime, createWASMRuntime } from './wasm.js';
-export { ONNXRuntime, createONNXRuntime } from './onnx.js';
+export { ONNXRuntime, createONNXRuntime, isOnnxAvailable, setOnnxModule, configureOnnxAssets, type OnnxAssetPaths, } from './onnx.js';
+export { TransformersAdapterRuntime, useTransformersBackend, getTransformersAdapter, type TransformersAdapterOptions, type TransformersPipelineFactory, } from './transformers-adapter.js';
 export type { Runtime, RuntimeType, RuntimeCapabilities } from '../core/types.js';
 /**
- * Register all available backends
+ * Register all available backends.
+ *
+ * Always registers the ONNX Runtime factory synchronously so there is no
+ * async race between registration and the first pipeline() call.
+ * `ONNXRuntime.isAvailable()` is called lazily by RuntimeManager when it
+ * selects a backend, so if onnxruntime-web is not installed the runtime is
+ * simply skipped at that point.
  */
 export declare function registerAllBackends(): void;
 //# sourceMappingURL=index.d.ts.map

package/dist/backends/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/backends/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGjE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAG9D,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAG3D,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAG3D,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAUlF;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAK1C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/backends/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGjE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAG9D,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAG3D,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,KAAK,cAAc,GACpB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,EACtB,sBAAsB,EACtB,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,GACjC,MAAM,2BAA2B,CAAC;AAGnC,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAKlF;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C"}

package/dist/backends/index.js

@@ -1,32 +1,32 @@
 /**
  * edgeFlow.js - Backend Exports
  */
-// WebGPU Backend
+// WebGPU Backend (planned - skeleton only)
 export { WebGPURuntime, createWebGPURuntime } from './webgpu.js';
-// WebNN Backend
+// WebNN Backend (planned - skeleton only)
 export { WebNNRuntime, createWebNNRuntime } from './webnn.js';
 // WASM Backend (basic tensor ops)
 export { WASMRuntime, createWASMRuntime } from './wasm.js';
 // ONNX Runtime Backend (real model inference)
-export { ONNXRuntime, createONNXRuntime } from './onnx.js';
-/**
- * Initialize all backends with the runtime manager
- */
+export { ONNXRuntime, createONNXRuntime, isOnnxAvailable, setOnnxModule, configureOnnxAssets, } from './onnx.js';
+// transformers.js Adapter Backend
+export { TransformersAdapterRuntime, useTransformersBackend, getTransformersAdapter, } from './transformers-adapter.js';
 import { registerRuntime } from '../core/runtime.js';
-import { createWebGPURuntime } from './webgpu.js';
-import { createWebNNRuntime } from './webnn.js';
 import { createONNXRuntime } from './onnx.js';
 /**
- * Register all available backends
+ * Register all available backends.
+ *
+ * Always registers the ONNX Runtime factory synchronously so there is no
+ * async race between registration and the first pipeline() call.
+ * `ONNXRuntime.isAvailable()` is called lazily by RuntimeManager when it
+ * selects a backend, so if onnxruntime-web is not installed the runtime is
+ * simply skipped at that point.
  */
 export function registerAllBackends() {
-    registerRuntime('webgpu', createWebGPURuntime);
-    registerRuntime('webnn', createWebNNRuntime);
-    // Use ONNX Runtime as the WASM backend for real model inference
     registerRuntime('wasm', createONNXRuntime);
 }
 /**
- * Auto-register backends on module load
+ * Auto-register backends on module load (synchronous — no race condition).
  */
 registerAllBackends();
 //# sourceMappingURL=index.js.map

package/dist/backends/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/backends/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,iBAAiB;AACjB,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEjE,gBAAgB;AAChB,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE9D,kCAAkC;AAClC,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE3D,8CAA8C;AAC9C,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAK3D;;GAEG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C;;GAEG;AACH,MAAM,UAAU,mBAAmB;IACjC,eAAe,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;IAC/C,eAAe,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC;IAC7C,gEAAgE;IAChE,eAAe,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAC7C,CAAC;AAED;;GAEG;AACH,mBAAmB,EAAE,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/backends/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,2CAA2C;AAC3C,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEjE,0CAA0C;AAC1C,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE9D,kCAAkC;AAClC,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE3D,8CAA8C;AAC9C,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,mBAAmB,GAEpB,MAAM,WAAW,CAAC;AAEnB,kCAAkC;AAClC,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,EACtB,sBAAsB,GAGvB,MAAM,2BAA2B,CAAC;AAKnC,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB;IACjC,eAAe,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAC7C,CAAC;AAED;;GAEG;AACH,mBAAmB,EAAE,CAAC"}

package/dist/backends/onnx.d.ts

@@ -2,12 +2,53 @@
  * edgeFlow.js - ONNX Runtime Backend
  *
  * Uses onnxruntime-web for real ONNX model inference.
- * Automatically loads ONNX Runtime from CDN when needed.
+ * onnxruntime-web is an optional peer dependency loaded dynamically.
  */
 import { Runtime, RuntimeType, RuntimeCapabilities, LoadedModel, ModelLoadOptions, Tensor } from '../core/types.js';
+/**
+ * Override paths for the onnxruntime-web WASM assets, mirroring ORT's
+ * `env.wasm.wasmPaths` object form. Set via {@link configureOnnxAssets}
+ * when the consumer's bundler emits content-hashed asset URLs (a bare
+ * directory prefix can't address those).
+ */
+export interface OnnxAssetPaths {
+    /** URL/path for the main `.wasm` binary. */
+    wasm?: string;
+    /** URL/path for the loader `.mjs` glue. */
+    mjs?: string;
+}
+/**
+ * Inject a pre-imported onnxruntime-web module — the recommended
+ * integration path for Web Workers and custom bundler setups, where the
+ * internal dynamic `import('onnxruntime-web/wasm')` may be dropped.
+ *
+ * ONNX Runtime is an optional peer dependency that the consumer owns:
+ * once you inject a module, **you** own its configuration. Configure it
+ * first (`ort.env.wasm.wasmPaths`, `numThreads`, execution providers,
+ * ...) and the backend will use it as-is without overriding anything.
+ *
+ *     import * as ort from "onnxruntime-web/wasm";
+ *     ort.env.wasm.wasmPaths = { wasm: wasmUrl, mjs: mjsUrl };
+ *     ort.env.wasm.numThreads = 1;
+ *     setOnnxModule(ort);
+ */
+export declare function setOnnxModule(module: any): void;
+/**
+ * Configure the onnxruntime-web WASM asset locations (sets
+ * `env.wasm.wasmPaths` during init). Primarily for the auto-load path —
+ * when you let the backend import ORT itself but your bundler content-
+ * hashes the `.wasm` / `.mjs` files (e.g. Vite `?url` imports), so the
+ * default `/ort/` prefix can't resolve them. If you inject your own
+ * module via {@link setOnnxModule}, prefer configuring it directly.
+ * An explicit call here is still honored even for an injected module.
+ */
+export declare function configureOnnxAssets(paths: OnnxAssetPaths): void;
+/**
+ * Check whether onnxruntime-web is importable.
+ */
+export declare function isOnnxAvailable(): Promise<boolean>;
 /**
  * ONNXRuntime - Real ONNX model inference using onnxruntime-web
- * Automatically loads ONNX Runtime from CDN when first used.
  */
 export declare class ONNXRuntime implements Runtime {
     readonly name: RuntimeType;
@@ -15,11 +56,11 @@ export declare class ONNXRuntime implements Runtime {
     private executionProvider;
     get capabilities(): RuntimeCapabilities;
     /**
-     * Check if ONNX Runtime is available (always true - will be loaded from CDN)
+     * Check if ONNX Runtime is available (peer dependency installed)
      */
     isAvailable(): Promise<boolean>;
     /**
-     * Initialize the ONNX runtime (loads from CDN if needed)
+     * Initialize the ONNX runtime
      */
     initialize(): Promise<void>;
     /**
@@ -30,6 +71,10 @@ export declare class ONNXRuntime implements Runtime {
      * Run inference
      */
     run(model: LoadedModel, inputs: Tensor[]): Promise<Tensor[]>;
+    /**
+     * Run inference with named inputs
+     */
+    runNamed(model: LoadedModel, namedInputs: Map<string, Tensor>): Promise<Tensor[]>;
     /**
      * Unload a model
      */

package/dist/backends/onnx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onnx.d.ts","sourceRoot":"","sources":["../../src/backends/onnx.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,OAAO,EACP,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,gBAAgB,EAEhB,MAAM,EAIP,MAAM,kBAAkB,CAAC;AAuF1B;;;GAGG;AACH,qBAAa,WAAY,YAAW,OAAO;IACzC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAU;IAEpC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,iBAAiB,CAA6B;IAEtD,IAAI,YAAY,IAAI,mBAAmB,CAStC;IAED;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAKrC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAejC;;OAEG;IACG,SAAS,CACb,SAAS,EAAE,WAAW,EACtB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,WAAW,CAAC;IA0EvB;;OAEG;IACG,GAAG,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAmElE;;OAEG;YACW,WAAW;IAQzB;;OAEG;IACH,OAAO,IAAI,IAAI;CAKhB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C"}
+{"version":3,"file":"onnx.d.ts","sourceRoot":"","sources":["../../src/backends/onnx.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,OAAO,EACP,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,gBAAgB,EAEhB,MAAM,EAIP,MAAM,kBAAkB,CAAC;AAkB1B;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,4CAA4C;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAID;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,aAAa,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAE/C;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAE/D;AAkBD;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC,CAExD;AAkBD;;GAEG;AACH,qBAAa,WAAY,YAAW,OAAO;IACzC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAU;IAEpC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,iBAAiB,CAA6B;IAEtD,IAAI,YAAY,IAAI,mBAAmB,CAStC;IAED;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAIrC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAmDjC;;OAEG;IACG,SAAS,CACb,SAAS,EAAE,WAAW,EACtB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,WAAW,CAAC;IA+EvB;;OAEG;IACG,GAAG,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA+DlE;;OAEG;IACG,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA2DvF;;OAEG;YACW,WAAW;IAQzB;;OAEG;IACH,OAAO,IAAI,IAAI;CAKhB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C"}