@huggingface/transformers 4.0.0-next.5 → 4.0.0-next.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huggingface/transformers",
-  "version": "4.0.0-next.5",
+  "version": "4.0.0-next.7",
   "description": "State-of-the-art Machine Learning for the web. Run 🤗 Transformers directly in your browser, with no need for a server!",
   "main": "./dist/transformers.node.cjs",
   "types": "./types/transformers.d.ts",
@@ -43,10 +43,10 @@
   },
   "homepage": "https://github.com/huggingface/transformers.js#readme",
   "dependencies": {
-    "@huggingface/jinja": "^0.5.5",
+    "@huggingface/jinja": "^0.5.6",
     "@huggingface/tokenizers": "^0.1.2",
-    "onnxruntime-node": "1.24.2",
-    "onnxruntime-web": "1.25.0-dev.20260228-6e72d31970",
+    "onnxruntime-node": "1.24.3",
+    "onnxruntime-web": "1.25.0-dev.20260307-d626b568e0",
     "sharp": "^0.34.5"
   },
   "devDependencies": {

package/src/backends/onnx.js

@@ -22,7 +22,8 @@ import { env, apis, LogLevel } from '../env.js';
 // In either case, we select the default export if it exists, otherwise we use the named export.
 import * as ONNX_NODE from 'onnxruntime-node';
 import * as ONNX_WEB from 'onnxruntime-web/webgpu';
-import { isBlobURL, loadWasmBinary, loadWasmFactory, toAbsoluteURL } from './utils/cacheWasm.js';
+import { loadWasmBinary, loadWasmFactory } from './utils/cacheWasm.js';
+import { isBlobURL, toAbsoluteURL } from '../utils/hub/utils.js';
 import { logger } from '../utils/logger.js';
 export { Tensor } from 'onnxruntime-common';
 
@@ -176,8 +177,6 @@ export function deviceToExecutionProviders(device = null) {
     throw new Error(`Unsupported device: "${device}". Should be one of: ${supportedDevices.join(', ')}.`);
 }
 
-const IS_WEB_ENV = apis.IS_BROWSER_ENV || apis.IS_WEBWORKER_ENV;
-
 /**
  * Currently, Transformers.js doesn't support simultaneous loading of sessions in WASM/WebGPU.
  * For this reason, we need to chain the loading calls.
@@ -204,14 +203,23 @@ async function ensureWasmLoaded() {
         return wasmLoadPromise;
     }
 
+    // Check if we should load the WASM binary
     const shouldUseWasmCache =
         env.useWasmCache &&
         typeof ONNX_ENV?.wasm?.wasmPaths === 'object' &&
         ONNX_ENV?.wasm?.wasmPaths?.wasm &&
         ONNX_ENV?.wasm?.wasmPaths?.mjs;
 
-    // Check if we should load the WASM binary
     if (!shouldUseWasmCache) {
+        // In Deno's web runtime, the WASM factory must be loaded via blob URL so that Node.js detection
+        // can be patched out (see loadWasmFactory). Without caching, the factory is imported directly
+        // from its URL and Deno would crash trying to use Node.js APIs. useWasmCache defaults to true
+        // in this environment, so this only happens if the user explicitly disables it.
+        if (apis.IS_DENO_WEB_RUNTIME) {
+            throw new Error(
+                "env.useWasmCache=false is not supported in Deno's web runtime. Remove the useWasmCache override.",
+            );
+        }
         wasmLoadPromise = Promise.resolve();
         return wasmLoadPromise;
     }
@@ -222,7 +230,10 @@ async function ensureWasmLoaded() {
         // shouldUseWasmCache checks for wasmPaths.wasm and wasmPaths.mjs
         const urls = /** @type {{ wasm: string, mjs: string }} */ (ONNX_ENV.wasm.wasmPaths);
 
-        // Load and cache both the WASM binary and factory
+        // Load both in parallel; the .mjs blob URL is only kept if wasmBinary succeeded.
+        // ORT only sets locateFile when wasmBinary is provided (onnxruntime PR https://github.com/microsoft/onnxruntime/pull/27411), which
+        // prevents new URL(fileName, import.meta.url) from failing inside a blob URL factory.
+        let wasmBinaryLoaded = false;
         await Promise.all([
             // Load and cache the WASM binary
             urls.wasm && !isBlobURL(urls.wasm)
@@ -231,6 +242,7 @@ async function ensureWasmLoaded() {
                           const wasmBinary = await loadWasmBinary(toAbsoluteURL(urls.wasm));
                           if (wasmBinary) {
                               ONNX_ENV.wasm.wasmBinary = wasmBinary;
+                              wasmBinaryLoaded = true;
                           }
                       } catch (err) {
                           logger.warn('Failed to pre-load WASM binary:', err);
@@ -238,7 +250,7 @@ async function ensureWasmLoaded() {
                   })()
                 : Promise.resolve(),
 
-            // Load and cache the WASM factory
+            // Load and cache the WASM factory as a blob URL
             urls.mjs && !isBlobURL(urls.mjs)
                 ? (async () => {
                       try {
@@ -253,6 +265,12 @@ async function ensureWasmLoaded() {
                   })()
                 : Promise.resolve(),
         ]);
+
+        // If wasmBinary failed to load, revert wasmPaths.mjs to the original URL (factory can only be loaded from blob if ONNX_ENV.wasm.wasmBinary is set. @see ORT PR #27411)
+        if (!wasmBinaryLoaded) {
+            // @ts-ignore
+            ONNX_ENV.wasm.wasmPaths.mjs = urls.mjs;
+        }
     })();
 
     return wasmLoadPromise;
@@ -274,7 +292,7 @@ export async function createInferenceSession(buffer_or_path, session_options, se
             logSeverityLevel,
             ...session_options,
         });
-    const session = await (IS_WEB_ENV ? (webInitChain = webInitChain.then(load)) : load());
+    const session = await (apis.IS_WEB_ENV ? (webInitChain = webInitChain.then(load)) : load());
     session.config = session_config;
     return session;
 }
@@ -294,8 +312,7 @@ let webInferenceChain = Promise.resolve();
  */
 export async function runInferenceSession(session, ortFeed) {
     const run = () => session.run(ortFeed);
-    const output = await (IS_WEB_ENV ? (webInferenceChain = webInferenceChain.then(run)) : run());
-    return output;
+    return apis.IS_WEB_ENV ? (webInferenceChain = webInferenceChain.then(run)) : run();
 }
 
 /**
@@ -306,41 +323,8 @@ export async function runInferenceSession(session, ortFeed) {
 export function isONNXTensor(x) {
     return x instanceof ONNX.Tensor;
 }
-
 /** @type {import('onnxruntime-common').Env} */
 const ONNX_ENV = ONNX?.env;
-if (ONNX_ENV?.wasm) {
-    // Initialize wasm backend with suitable default settings.
-
-    // (Optional) Set path to wasm files. This will override the default path search behavior of onnxruntime-web.
-    // By default, we only do this if we are not in a service worker and the wasmPaths are not already set.
-    if (
-        // @ts-ignore Cannot find name 'ServiceWorkerGlobalScope'.ts(2304)
-        !(typeof ServiceWorkerGlobalScope !== 'undefined' && self instanceof ServiceWorkerGlobalScope) &&
-        ONNX_ENV.versions?.web &&
-        !ONNX_ENV.wasm.wasmPaths
-    ) {
-        const wasmPathPrefix = `https://cdn.jsdelivr.net/npm/onnxruntime-web@${ONNX_ENV.versions.web}/dist/`;
-
-        ONNX_ENV.wasm.wasmPaths = apis.IS_SAFARI
-            ? {
-                  mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.mjs`,
-                  wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.wasm`,
-              }
-            : {
-                  mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.mjs`,
-                  wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.wasm`,
-              };
-    }
-
-    // Users may wish to proxy the WASM backend to prevent the UI from freezing,
-    // However, this is not necessary when using WebGPU, so we default to false.
-    ONNX_ENV.wasm.proxy = false;
-}
-
-if (ONNX_ENV?.webgpu) {
-    ONNX_ENV.webgpu.powerPreference = 'high-performance';
-}
 
 /**
  * Check if ONNX's WASM backend is being proxied.
@@ -351,21 +335,56 @@ export function isONNXProxy() {
     return ONNX_ENV?.wasm?.proxy;
 }
 
-/**
- * A function to map Transformers.js log levels to ONNX Runtime log severity
- * levels, and set the log level environment variable in ONNX Runtime.
- * @param {number} logLevel The log level to set.
- */
-function setLogLevel(logLevel) {
-    const severityLevel = getOnnxLogSeverityLevel(logLevel);
-    ONNX_ENV.logLevel = ONNX_LOG_LEVEL_NAMES[severityLevel];
-}
+if (ONNX_ENV) {
+    if (ONNX_ENV.wasm) {
+        // Initialize wasm backend with suitable default settings.
+
+        // (Optional) Set path to wasm files. This will override the default path search behavior of onnxruntime-web.
+        // By default, we only do this if we are not in a service worker and the wasmPaths are not already set.
+        if (
+            // @ts-ignore Cannot find name 'ServiceWorkerGlobalScope'.ts(2304)
+            !(typeof ServiceWorkerGlobalScope !== 'undefined' && self instanceof ServiceWorkerGlobalScope) &&
+            ONNX_ENV.versions?.web &&
+            !ONNX_ENV.wasm.wasmPaths
+        ) {
+            const wasmPathPrefix = `https://cdn.jsdelivr.net/npm/onnxruntime-web@${ONNX_ENV.versions.web}/dist/`;
+
+            ONNX_ENV.wasm.wasmPaths = apis.IS_SAFARI
+                ? {
+                      mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.mjs`,
+                      wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.wasm`,
+                  }
+                : {
+                      mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.mjs`,
+                      wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.wasm`,
+                  };
+        }
+
+        // Users may wish to proxy the WASM backend to prevent the UI from freezing,
+        // However, this is not necessary when using WebGPU, so we default to false.
+        ONNX_ENV.wasm.proxy = false;
+    }
+
+    if (ONNX_ENV.webgpu) {
+        ONNX_ENV.webgpu.powerPreference = 'high-performance';
+    }
 
-// Set the initial log level to be the default Transformers.js log level.
-setLogLevel(env.logLevel ?? LogLevel.WARNING);
+    /**
+     * A function to map Transformers.js log levels to ONNX Runtime log severity
+     * levels, and set the log level environment variable in ONNX Runtime.
+     * @param {number} logLevel The log level to set.
+     */
+    function setLogLevel(logLevel) {
+        const severityLevel = getOnnxLogSeverityLevel(logLevel);
+        ONNX_ENV.logLevel = ONNX_LOG_LEVEL_NAMES[severityLevel];
+    }
 
-// Expose ONNX environment variables to `env.backends.onnx`
-env.backends.onnx = {
-    ...ONNX_ENV,
-    setLogLevel,
-};
+    // Set the initial log level to be the default Transformers.js log level.
+    setLogLevel(env.logLevel ?? LogLevel.WARNING);
+
+    // Expose ONNX environment variables to `env.backends.onnx`
+    env.backends.onnx = {
+        ...ONNX_ENV,
+        setLogLevel,
+    };
+}

package/src/backends/utils/cacheWasm.js

@@ -1,12 +1,11 @@
+import { apis, env } from '../../env.js';
 import { getCache } from '../../utils/cache.js';
-import { isValidUrl } from '../../utils/hub/utils.js';
 import { logger } from '../../utils/logger.js';
-import { env } from '../../env.js';
 
 /**
  * Loads and caches a file from the given URL.
  * @param {string} url The URL of the file to load.
- * @returns {Promise<Response|import('../../utils/hub/files.js').FileResponse|null|string>} The response object, or null if loading failed.
+ * @returns {Promise<Response|import('../../utils/hub/FileResponse.js').FileResponse|null|string>} The response object, or null if loading failed.
  */
 async function loadAndCacheFile(url) {
     const fileName = url.split('/').pop();
@@ -65,58 +64,38 @@ export async function loadWasmBinary(wasmURL) {
 }
 
 /**
- * Loads and caches the WASM Factory for ONNX Runtime.
+ * Loads and caches the WASM Factory (.mjs file) for ONNX Runtime.
+ * Creates a blob URL from cached content (when safe) to bridge Cache API with dynamic imports used in ORT.
  * @param {string} libURL The URL of the WASM Factory to load.
- * @returns {Promise<string|null>} The blob URL of the WASM Factory, or null if loading failed.
+ * @returns {Promise<string|null>} The blob URL (if enabled), original URL (if disabled), or null if loading failed.
  */
 export async function loadWasmFactory(libURL) {
+    // We can't use Blob URLs in some environments (Service Workers, Chrome extensions) due to security restrictions on dynamic import() of blob URLs.
+    // In such cases, just return the original URL and don't bother caching since dynamic import() won't use the Cache API anyway.
+    // See https://github.com/huggingface/transformers.js/issues/1532.
+    if (apis.IS_SERVICE_WORKER_ENV || apis.IS_CHROME_AVAILABLE) {
+        return libURL;
+    }
+
+    // Fetch from cache or network, then create blob URL
     const response = await loadAndCacheFile(libURL);
     if (!response || typeof response === 'string') return null;
 
     try {
         let code = await response.text();
-        // Fix relative paths when loading factory from blob, overwrite import.meta.url with actual baseURL
-        const baseUrl = libURL.split('/').slice(0, -1).join('/');
-        code = code.replaceAll('import.meta.url', `"${baseUrl}"`);
+
+        // Handle the case where we are importing the bundled version of the library in Deno (e.g., via CDN or local file),
+        // where we need to patch out Node.js detection in the factory. Without this, Deno (which exposes globalThis.process.versions.node)
+        // would enter the Node.js branch and try to use Node.js APIs (worker_threads, fs, etc.) that aren't used in the bundled web version.
+        // Only needed for the asyncify (single-threaded) variant loaded via blob URL. The module-level pthread auto-start code is unreachable since asyncify never spawns workers.
+        // See https://github.com/huggingface/transformers.js/pull/1546/ for more information.
+        //
+        // NOTE: This does not affect default usage via Deno (i.e., imported via npm: prefix), since we'll be using onnxruntime-node (Native) instead of onnxruntime-web (WASM).
         code = code.replaceAll('globalThis.process?.versions?.node', 'false');
         const blob = new Blob([code], { type: 'text/javascript' });
         return URL.createObjectURL(blob);
     } catch (error) {
-        logger.warn('Failed to read WASM binary:', error);
+        logger.warn('Failed to read WASM factory:', error);
         return null;
     }
 }
-
-/**
- * Checks if the given URL is a blob URL (created via URL.createObjectURL).
- * Blob URLs should not be cached as they are temporary in-memory references.
- * @param {string} url - The URL to check.
- * @returns {boolean} True if the URL is a blob URL, false otherwise.
- */
-export function isBlobURL(url) {
-    return isValidUrl(url, ['blob:']);
-}
-
-/**
- * Converts any URL to an absolute URL if needed.
- * If the URL is already absolute (http://, https://, or blob:), returns it unchanged (handled by new URL(...)).
- * Otherwise, resolves it relative to the current page location (browser) or module location (Node/Bun/Deno).
- * @param {string} url - The URL to convert (can be relative or absolute).
- * @returns {string} The absolute URL.
- */
-export function toAbsoluteURL(url) {
-    let baseURL;
-
-    if (typeof location !== 'undefined' && location.href) {
-        // Browser environment: use location.href
-        baseURL = location.href;
-    } else if (typeof import.meta !== 'undefined' && import.meta.url) {
-        // Node.js/Bun/Deno module environment: use import.meta.url
-        baseURL = import.meta.url;
-    } else {
-        // Fallback: if no base is available, return the URL unchanged
-        return url;
-    }
-
-    return new URL(url, baseURL).href;
-}

package/src/cache_utils.js

@@ -0,0 +1,62 @@
+import { Tensor } from './utils/tensor.js';
+
+/**
+ * A cache class that stores past key values as named tensors.
+ */
+class _DynamicCache {
+    /**
+     * Create a DynamicCache, optionally pre-populated with entries.
+     * @param {Record<string, Tensor>} [entries] Initial name→Tensor mappings.
+     */
+    constructor(entries) {
+        if (!entries) return;
+        for (const key in entries) {
+            if (key in this) {
+                throw new TypeError(`Key "${key}" conflicts with an existing property on DynamicCache`);
+            }
+            const value = entries[key];
+            if (!(value instanceof Tensor)) {
+                throw new TypeError(`Expected a Tensor for key "${key}", got ${typeof value}`);
+            }
+            this[key] = value;
+        }
+    }
+
+    /**
+     * Get the cached sequence length. This requires at least one attention cache entry to be present.
+     * @returns {number} The past sequence length.
+     */
+    get_seq_length() {
+        /** @type {Record<string, Tensor>} */
+        const self = /** @type {any} */ (this);
+        for (const name in self) {
+            if (name.startsWith('past_key_values.')) {
+                return self[name].dims.at(-2);
+            }
+        }
+        throw new Error('Unable to determine sequence length from the cache.');
+    }
+
+    /**
+     * Dispose all contained tensors whose data resides on the GPU.
+     * Returns a promise that resolves when all disposals are complete.
+     * @returns {Promise<void>} Promise that resolves when all GPU tensors are disposed.
+     */
+    async dispose() {
+        const promises = [];
+        for (const t of /** @type {Tensor[]} */ (Object.values(this))) {
+            if (t.location === 'gpu-buffer') {
+                promises.push(t.dispose());
+            }
+        }
+        await Promise.all(promises);
+    }
+}
+
+/**
+ * @typedef {_DynamicCache & Record<string, Tensor>} DynamicCache
+ */
+
+export const DynamicCache = /** @type {new (entries?: Record<string, Tensor>) => DynamicCache} */ (
+    /** @type {unknown} */ (_DynamicCache)
+);

package/src/configs.js

@@ -68,14 +68,18 @@ function getNormalizedConfig(config) {
         case 'florence2':
         case 'llava_onevision':
         case 'idefics3':
+        case 'granite_speech':
         case 'ultravox':
         case 'voxtral':
+        case 'voxtral_realtime':
         case 'smolvlm':
         case 'gemma3n':
+        case 'lfm2_vl':
         case 'chatterbox':
         case 'mistral3':
         case 'qwen2_5_vl':
         case 'qwen3_vl':
+        case 'qwen3_vl_moe':
             // @ts-expect-error TS2339
             init_normalized_config = getNormalizedConfig(config.text_config);
             break;
@@ -130,11 +134,17 @@ function getNormalizedConfig(config) {
         case 'cohere':
         case 'cohere2':
         case 'mistral':
+        case 'voxtral_realtime_text':
+        case 'voxtral_realtime_encoder':
         case 'starcoder2':
         case 'qwen2':
+        case 'qwen2_moe':
         case 'qwen2_vl':
+        case 'qwen2_vl_text':
         case 'qwen2_5_vl_text':
+        case 'qwen3_moe':
         case 'qwen3_vl_text':
+        case 'qwen3_vl_moe_text':
         case 'phi':
         case 'phi3':
         case 'phi3_v':
@@ -289,6 +299,9 @@ function getNormalizedConfig(config) {
  * @returns {Record<string, number[]>}
  */
 export function getCacheShapes(config, options) {
+    if (!(config instanceof PretrainedConfig)) {
+        config = new PretrainedConfig(config);
+    }
     if (['lfm2', 'lfm2_moe'].includes(config.model_type)) {
         const pkv_prefix = options?.prefix ?? 'past_key_values';
         const conv_prefix = pkv_prefix === 'present' ? 'present' : 'past';
@@ -348,7 +361,7 @@ export function getCacheShapes(config, options) {
             }
         }
         return cache_values;
-    } else if (['qwen3_5', 'qwen3_5_moe'].includes(config.model_type)) {
+    } else if (['qwen3_next', 'qwen3_5_text', 'qwen3_5_moe_text', 'olmo_hybrid'].includes(config.model_type)) {
         const pkv_prefix = options?.prefix ?? 'past_key_values';
         const conv_prefix = pkv_prefix === 'present' ? 'present' : 'past';
 
@@ -365,13 +378,11 @@ export function getCacheShapes(config, options) {
             linear_key_head_dim,
             linear_value_head_dim,
             linear_conv_kernel_dim,
-        } = /** @type {any} */ (config).text_config;
+        } = /** @type {any} */ (config);
 
         const key_dim = linear_key_head_dim * linear_num_key_heads;
         const value_dim = linear_value_head_dim * linear_num_value_heads;
 
-        const conv_dim = key_dim * 2 + value_dim;
-
         const final_head_dim = head_dim ?? hidden_size / num_attention_heads;
         const batch_size = options?.batch_size ?? 1;
         for (let i = 0; i < layer_types.length; ++i) {
@@ -380,7 +391,14 @@ export function getCacheShapes(config, options) {
                     cache_values[`${pkv_prefix}.${i}.${kv}`] = [batch_size, num_key_value_heads, 0, final_head_dim];
                 }
             } else if (layer_types[i] === 'linear_attention') {
-                cache_values[`${conv_prefix}_conv.${i}`] = [batch_size, conv_dim, linear_conv_kernel_dim];
+                if (config.model_type === 'olmo_hybrid') {
+                    cache_values[`${conv_prefix}_conv.${i}.key`] = [batch_size, key_dim, linear_conv_kernel_dim];
+                    cache_values[`${conv_prefix}_conv.${i}.value`] = [batch_size, value_dim, linear_conv_kernel_dim];
+                    cache_values[`${conv_prefix}_conv.${i}.query`] = [batch_size, key_dim, linear_conv_kernel_dim];
+                } else {
+                    const conv_dim = key_dim * 2 + value_dim;
+                    cache_values[`${conv_prefix}_conv.${i}`] = [batch_size, conv_dim, linear_conv_kernel_dim];
+                }
                 cache_values[`${conv_prefix}_recurrent.${i}`] = [
                     batch_size,
                     linear_num_value_heads,
@@ -392,7 +410,16 @@ export function getCacheShapes(config, options) {
             }
         }
         return cache_values;
+    } else if (['lfm2_vl', 'qwen3_5', 'qwen3_5_moe', 'voxtral_realtime'].includes(config.model_type)) {
+        let subConfig;
+        if (config.model_type === 'voxtral_realtime' && options?.session_name === 'audio_encoder') {
+            subConfig = /** @type {any} */ (config).audio_config;
+        } else {
+            subConfig = /** @type {any} */ (config).text_config;
+        }
+        return getCacheShapes(subConfig, options);
     }
+
     return getKeyValueShapes(config, options);
 }
 

package/src/env.js

@@ -26,11 +26,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import url from 'node:url';
 
-const VERSION = '4.0.0-next.5';
+const VERSION = '4.0.0-next.7';
+
+const HAS_SELF = typeof self !== 'undefined';
 
 const IS_FS_AVAILABLE = !isEmpty(fs);
 const IS_PATH_AVAILABLE = !isEmpty(path);
-const IS_WEB_CACHE_AVAILABLE = typeof self !== 'undefined' && 'caches' in self;
+const IS_WEB_CACHE_AVAILABLE = HAS_SELF && 'caches' in self;
 
 // Runtime detection
 const IS_DENO_RUNTIME = typeof globalThis.Deno !== 'undefined';
@@ -44,14 +46,24 @@ const IS_NODE_ENV = IS_PROCESS_AVAILABLE && process?.release?.name === 'node' &&
 // Check if various APIs are available (depends on environment)
 const IS_BROWSER_ENV = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 const IS_WEBWORKER_ENV =
-    typeof self !== 'undefined' &&
+    HAS_SELF &&
     ['DedicatedWorkerGlobalScope', 'ServiceWorkerGlobalScope', 'SharedWorkerGlobalScope'].includes(
         self.constructor?.name,
     );
+const IS_WEB_ENV = IS_BROWSER_ENV || IS_WEBWORKER_ENV || IS_DENO_WEB_RUNTIME;
+
 const IS_WEBGPU_AVAILABLE = IS_NODE_ENV || (typeof navigator !== 'undefined' && 'gpu' in navigator);
 const IS_WEBNN_AVAILABLE = typeof navigator !== 'undefined' && 'ml' in navigator;
 const IS_CRYPTO_AVAILABLE = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function';
 
+const IS_CHROME_AVAILABLE =
+    // @ts-ignore - chrome may not exist in all environments
+    typeof chrome !== 'undefined' && typeof chrome.runtime !== 'undefined' && typeof chrome.runtime.id === 'string';
+
+const IS_SERVICE_WORKER_ENV =
+    // @ts-ignore - ServiceWorkerGlobalScope may not exist in all environments
+    typeof ServiceWorkerGlobalScope !== 'undefined' && HAS_SELF && self instanceof ServiceWorkerGlobalScope;
+
 /**
  * Check if the current environment is Safari browser.
  * Works in both browser and web worker contexts.
@@ -90,6 +102,15 @@ export const apis = Object.freeze({
     /** Whether we are running in a web worker environment */
     IS_WEBWORKER_ENV,
 
+    /** Whether we are running in a web-like environment (browser, web worker, or Deno web runtime) */
+    IS_WEB_ENV,
+
+    /** Whether we are running in a service worker environment */
+    IS_SERVICE_WORKER_ENV,
+
+    /** Whether we are running in Deno's web runtime (CDN imports, Cache API available, no filesystem) */
+    IS_DENO_WEB_RUNTIME,
+
     /** Whether the Cache API is available */
     IS_WEB_CACHE_AVAILABLE,
 
@@ -116,6 +137,9 @@ export const apis = Object.freeze({
 
     /** Whether the crypto API is available */
     IS_CRYPTO_AVAILABLE,
+
+    /** Whether the Chrome runtime API is available */
+    IS_CHROME_AVAILABLE,
 });
 
 const RUNNING_LOCALLY = IS_FS_AVAILABLE && IS_PATH_AVAILABLE;
@@ -197,10 +221,14 @@ export const LogLevel = Object.freeze({
  * @property {boolean} useCustomCache Whether to use a custom cache system (defined by `customCache`), defaults to `false`.
  * @property {import('./utils/cache.js').CacheInterface|null} customCache The custom cache to use. Defaults to `null`. Note: this must be an object which
  * implements the `match` and `put` functions of the Web Cache API. For more information, see https://developer.mozilla.org/en-US/docs/Web/API/Cache.
- * @property {boolean} useWasmCache Whether to pre-load and cache WASM binaries for ONNX Runtime. Defaults to `true` when cache is available.
- * This can improve performance by avoiding repeated downloads of WASM files. Note: Only the WASM binary is cached.
- * The MJS loader file still requires network access unless you use a Service Worker.
+ * @property {boolean} useWasmCache Whether to pre-load and cache WASM binaries and the WASM factory (.mjs) for ONNX Runtime.
+ * Defaults to `true` when cache is available. This can improve performance and enables offline usage by avoiding repeated downloads.
  * @property {string} cacheKey The cache key to use for storing models and WASM binaries. Defaults to 'transformers-cache'.
+ * @property {boolean} experimental_useCrossOriginStorage Whether to use the Cross-Origin Storage API to cache model files
+ * across origins, allowing different sites to share the same cached model weights. Defaults to `false`.
+ * Requires the Cross-Origin Storage Chrome extension: {@link https://chromewebstore.google.com/detail/cross-origin-storage/denpnpcgjgikjpoglpjefakmdcbmlgih}.
+ * The `experimental_` prefix indicates that the underlying browser API is not yet standardised and may change or be
+ * removed without a major version bump. For more information, see {@link https://github.com/WICG/cross-origin-storage}.
  * @property {(input: string | URL, init?: any) => Promise<any>} fetch The fetch function to use. Defaults to `fetch`.
  */
 
@@ -247,6 +275,8 @@ export const env = {
     useWasmCache: IS_WEB_CACHE_AVAILABLE || IS_FS_AVAILABLE,
     cacheKey: 'transformers-cache',
 
+    experimental_useCrossOriginStorage: false,
+
     /////////////////// Custom fetch /////////////////////
     fetch: DEFAULT_FETCH,
 

package/src/image_processors_utils.js

@@ -14,7 +14,7 @@ import { logger } from './utils/logger.js';
  */
 
 /**
- * @typedef {object} ImageProcessorResult
+ * @typedef {Object} ImageProcessorResult
  * @property {Tensor} pixel_values The pixel values of the batched preprocessed images.
  * @property {HeightWidth[]} original_sizes Array of two-dimensional tuples like [[480, 640]].
  * @property {HeightWidth[]} reshaped_input_sizes Array of two-dimensional tuples like [[1000, 1330]].
@@ -407,7 +407,7 @@ function compute_segments(
  * @returns {[number, number]} The new height and width of the image.
  * @throws {Error} If the height or width is smaller than the factor.
  */
-function smart_resize(height, width, factor = 28, min_pixels = 56 * 56, max_pixels = 14 * 14 * 4 * 1280) {
+export function smart_resize(height, width, factor = 28, min_pixels = 56 * 56, max_pixels = 14 * 14 * 4 * 1280) {
     if (height < factor || width < factor) {
         throw new Error(`height:${height} or width:${width} must be larger than factor:${factor}`);
     } else if (Math.max(height, width) / Math.min(height, width) > 200) {
@@ -886,7 +886,7 @@ export class ImageProcessor extends Callable {
     }
 
     /**
-     * @typedef {object} PreprocessedImage
+     * @typedef {Object} PreprocessedImage
      * @property {HeightWidth} original_size The original size of the image.
      * @property {HeightWidth} reshaped_input_size The reshaped input size of the image.
      * @property {Tensor} pixel_values The pixel values of the preprocessed image.

package/src/models/auto/modeling_auto.js

@@ -62,6 +62,19 @@ class PretrainedMixin {
      */
     static BASE_IF_FAIL = false;
 
+    /**
+     * Check whether this AutoModel class supports a given model type.
+     * @param {string} model_type The model type from config (e.g., 'bert', 'whisper').
+     * @returns {boolean} Whether this class can handle the given model type.
+     */
+    static supports(model_type) {
+        if (!this.MODEL_CLASS_MAPPINGS) return false;
+        for (const mapping of this.MODEL_CLASS_MAPPINGS) {
+            if (mapping.has(model_type)) return true;
+        }
+        return this.BASE_IF_FAIL;
+    }
+
     /** @type {typeof PreTrainedModel.from_pretrained} */
     static async from_pretrained(
         pretrained_model_name_or_path,
@@ -97,7 +110,7 @@ class PretrainedMixin {
         if (!this.MODEL_CLASS_MAPPINGS) {
             throw new Error('`MODEL_CLASS_MAPPINGS` not implemented for this type of `AutoClass`: ' + this.name);
         }
-        const model_type = options.config.model_type;
+        const { model_type } = options.config;
         for (const MODEL_CLASS_MAPPING of this.MODEL_CLASS_MAPPINGS) {
             let modelInfo = MODEL_CLASS_MAPPING.get(model_type);
             if (!modelInfo) {

package/src/models/chatterbox/modeling_chatterbox.js

@@ -105,7 +105,7 @@ export class ChatterboxModel extends ChatterboxPreTrainedModel {
                 if (!past_key_values || target_length !== 1) {
                     throw new Error('Incorrect state encountered during generation.');
                 }
-                const past_length = Object.values(past_key_values)[0].dims.at(-2);
+                const past_length = past_key_values.get_seq_length();
                 attention_mask = ones([inputs_embeds.dims[0], past_length + target_length]);
             }
         }