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

package/dist/transformers.web.js

@@ -5,32 +5,31 @@ var __export = (target, all) => {
 };
 
 // ignore-modules:node:fs
-var emptyObj = {};
-var node_fs_default = emptyObj;
+var node_fs_default = {};
 
 // ignore-modules:node:path
-var emptyObj2 = {};
-var node_path_default = emptyObj2;
+var node_path_default = {};
 
 // ignore-modules:node:url
-var emptyObj3 = {};
-var node_url_default = emptyObj3;
+var node_url_default = {};
 
 // src/env.js
-var VERSION = "4.0.0-next.3";
-var IS_PROCESS_AVAILABLE = typeof process !== "undefined";
-var IS_NODE_ENV = IS_PROCESS_AVAILABLE && process?.release?.name === "node";
+var VERSION = "4.0.0-next.5";
 var IS_FS_AVAILABLE = !isEmpty(node_fs_default);
 var IS_PATH_AVAILABLE = !isEmpty(node_path_default);
+var IS_WEB_CACHE_AVAILABLE = typeof self !== "undefined" && "caches" in self;
 var IS_DENO_RUNTIME = typeof globalThis.Deno !== "undefined";
 var IS_BUN_RUNTIME = typeof globalThis.Bun !== "undefined";
+var IS_DENO_WEB_RUNTIME = IS_DENO_RUNTIME && IS_WEB_CACHE_AVAILABLE && !IS_FS_AVAILABLE;
+var IS_PROCESS_AVAILABLE = typeof process !== "undefined";
+var IS_NODE_ENV = IS_PROCESS_AVAILABLE && process?.release?.name === "node" && !IS_DENO_WEB_RUNTIME;
 var IS_BROWSER_ENV = typeof window !== "undefined" && typeof window.document !== "undefined";
 var IS_WEBWORKER_ENV = typeof self !== "undefined" && ["DedicatedWorkerGlobalScope", "ServiceWorkerGlobalScope", "SharedWorkerGlobalScope"].includes(
   self.constructor?.name
 );
-var IS_WEB_CACHE_AVAILABLE = typeof self !== "undefined" && "caches" in self;
 var IS_WEBGPU_AVAILABLE = IS_NODE_ENV || typeof navigator !== "undefined" && "gpu" in navigator;
 var IS_WEBNN_AVAILABLE = typeof navigator !== "undefined" && "ml" in navigator;
+var IS_CRYPTO_AVAILABLE = typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function";
 var isSafari = () => {
   if (typeof navigator === "undefined") {
     return false;
@@ -62,7 +61,9 @@ var apis = Object.freeze({
   /** Whether the filesystem API is available */
   IS_FS_AVAILABLE,
   /** Whether the path API is available */
-  IS_PATH_AVAILABLE
+  IS_PATH_AVAILABLE,
+  /** Whether the crypto API is available */
+  IS_CRYPTO_AVAILABLE
 });
 var RUNNING_LOCALLY = IS_FS_AVAILABLE && IS_PATH_AVAILABLE;
 var dirname__ = "./";
@@ -77,6 +78,20 @@ if (RUNNING_LOCALLY) {
 var DEFAULT_CACHE_DIR = RUNNING_LOCALLY ? node_path_default.join(dirname__, "/.cache/") : null;
 var DEFAULT_LOCAL_MODEL_PATH = "/models/";
 var localModelPath = RUNNING_LOCALLY ? node_path_default.join(dirname__, DEFAULT_LOCAL_MODEL_PATH) : DEFAULT_LOCAL_MODEL_PATH;
+var DEFAULT_FETCH = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
+var LogLevel = Object.freeze({
+  /** All messages including debug output (value: 10) */
+  DEBUG: 10,
+  /** Errors, warnings, and info messages (value: 20) */
+  INFO: 20,
+  /** Errors and warnings (value: 30) */
+  WARNING: 30,
+  /** Only error messages (value: 40) */
+  ERROR: 40,
+  /** No logging output (value: 50) */
+  NONE: 50
+});
+var logLevel = LogLevel.WARNING;
 var env = {
   version: VERSION,
   /////////////////// Backends settings ///////////////////
@@ -85,28 +100,132 @@ var env = {
     // onnxruntime-web/onnxruntime-node
     onnx: {}
   },
+  /////////////////// Logging settings ///////////////////
+  get logLevel() {
+    return logLevel;
+  },
+  set logLevel(level) {
+    logLevel = level;
+    env.backends.onnx?.setLogLevel?.(level);
+  },
   /////////////////// Model settings ///////////////////
   allowRemoteModels: true,
   remoteHost: "https://huggingface.co/",
   remotePathTemplate: "{model}/resolve/{revision}/",
-  allowLocalModels: !(IS_BROWSER_ENV || IS_WEBWORKER_ENV),
+  allowLocalModels: !(IS_BROWSER_ENV || IS_WEBWORKER_ENV || IS_DENO_WEB_RUNTIME),
+  // Default to true for non-web environments, false for web environments
   localModelPath,
   useFS: IS_FS_AVAILABLE,
   /////////////////// Cache settings ///////////////////
-  useBrowserCache: IS_WEB_CACHE_AVAILABLE && !IS_DENO_RUNTIME,
+  useBrowserCache: IS_WEB_CACHE_AVAILABLE,
   useFSCache: IS_FS_AVAILABLE,
   cacheDir: DEFAULT_CACHE_DIR,
   useCustomCache: false,
   customCache: null,
   useWasmCache: IS_WEB_CACHE_AVAILABLE || IS_FS_AVAILABLE,
-  cacheKey: "transformers-cache"
+  cacheKey: "transformers-cache",
+  /////////////////// Custom fetch /////////////////////
+  fetch: DEFAULT_FETCH
   //////////////////////////////////////////////////////
 };
 function isEmpty(obj) {
   return Object.keys(obj).length === 0;
 }
 
-// ../../node_modules/.pnpm/@huggingface+tokenizers@0.1.1/node_modules/@huggingface/tokenizers/dist/tokenizers.mjs
+// src/utils/core.js
+function dispatchCallback(progress_callback, data) {
+  if (progress_callback) progress_callback(data);
+}
+function isIntegralNumber(x) {
+  return Number.isInteger(x) || typeof x === "bigint";
+}
+function isNullishDimension(x) {
+  return x === null || x === void 0 || x === -1;
+}
+function calculateDimensions(arr) {
+  const dimensions = [];
+  let current = arr;
+  while (Array.isArray(current)) {
+    dimensions.push(current.length);
+    current = current[0];
+  }
+  return dimensions;
+}
+function mergeArrays(...arrs) {
+  return Array.prototype.concat.apply([], arrs);
+}
+function product(...a) {
+  return a.reduce((a2, b) => a2.flatMap((d) => b.map((e) => [d, e])));
+}
+function calculateReflectOffset(i, w) {
+  return Math.abs((i + w) % (2 * w) - w);
+}
+function pick(o, props) {
+  return Object.assign(
+    {},
+    ...props.map((prop) => {
+      if (o[prop] !== void 0) {
+        return { [prop]: o[prop] };
+      }
+    })
+  );
+}
+function count(arr, value) {
+  let count2 = 0;
+  for (const v of arr) {
+    if (v === value) ++count2;
+  }
+  return count2;
+}
+
+// src/utils/logger.js
+var logger = {
+  /**
+   * Log an error message. Only suppressed when logLevel is NONE.
+   * @param  {...any} args - Arguments to log
+   */
+  error(...args) {
+    if (env.logLevel <= LogLevel.ERROR) {
+      console.error(...args);
+    }
+  },
+  /**
+   * Log a warning message. Shown when logLevel <= WARNING.
+   * @param  {...any} args - Arguments to log
+   */
+  warn(...args) {
+    if (env.logLevel <= LogLevel.WARNING) {
+      console.warn(...args);
+    }
+  },
+  /**
+   * Log an info message. Shown when logLevel <= INFO.
+   * @param  {...any} args - Arguments to log
+   */
+  info(...args) {
+    if (env.logLevel <= LogLevel.INFO) {
+      console.log(...args);
+    }
+  },
+  /**
+   * Log a debug message. Only shown when logLevel is DEBUG.
+   * @param  {...any} args - Arguments to log
+   */
+  debug(...args) {
+    if (env.logLevel <= LogLevel.DEBUG) {
+      console.log(...args);
+    }
+  },
+  /**
+   * Log a message (alias for info). Shown when logLevel <= INFO.
+   * @param  {...any} args - Arguments to log
+   */
+  log(...args) {
+    this.info(...args);
+  }
+};
+
+// ../../node_modules/.pnpm/@huggingface+tokenizers@0.1.2/node_modules/@huggingface/tokenizers/dist/tokenizers.mjs
 var DictionarySplitter = class {
   /**
    * @param dictionary The dictionary of words to use for splitting.
@@ -230,6 +349,14 @@ var PROBLEMATIC_REGEX_MAP = /* @__PURE__ */ new Map([
   // JS doesn't support possessive quantifiers (these are used in recent OpenAI tokenizers).
   ["[^\\r\\n\\p{L}\\p{N}]?+", "[^\\r\\n\\p{L}\\p{N}]?"],
   ["[^\\s\\p{L}\\p{N}]++", "[^\\s\\p{L}\\p{N}]+"],
+  // JS doesn't support atomic groups (these are used in AFMoE tokenizers).
+  ["(?>\\p{Nd}{510})", "(?:\\p{Nd}{510})"],
+  // JS doesn't support stacking quantifiers.
+  // Uncaught SyntaxError: Invalid regular expression: /\p{Nd}{3}+/u: Nothing to repeat
+  ["\\p{Nd}{3}+", "(?:\\p{Nd}{3})+"],
+  // \G is an invalid escape in JS, and in most cases is just used as an optimization.
+  // So, we can safely remove it.
+  ["\\G", ""],
   // Used to override the default (invalid) regex of the bloom pretokenizer.
   // For more information, see https://github.com/huggingface/transformers.js/issues/94
   [` ?[^(\\s|[${BLOOM_SPLIT_CHARS}])]+`, ` ?[^\\s${BLOOM_SPLIT_CHARS}]+`]
@@ -239,6 +366,7 @@ var clean_up_tokenization = (text) => text.replace(/ \./g, ".").replace(/ \?/g,
 var create_pattern = (pattern, invert = true) => {
   if (pattern.Regex !== void 0) {
     let regex = pattern.Regex.replace(/\\([#&~])/g, "$1");
+    regex = regex.replace(/\\A/g, "^").replace(/\\z/g, "$").replace(/\\Z/g, "(?=\\r?\\n?$)");
     for (const [key, value] of PROBLEMATIC_REGEX_MAP) {
       regex = regex.replaceAll(key, value);
     }
@@ -5380,52 +5508,6 @@ var Callable2 = (
   }
 );
 
-// src/utils/core.js
-function dispatchCallback(progress_callback, data) {
-  if (progress_callback) progress_callback(data);
-}
-function isIntegralNumber(x) {
-  return Number.isInteger(x) || typeof x === "bigint";
-}
-function isNullishDimension(x) {
-  return x === null || x === void 0 || x === -1;
-}
-function calculateDimensions(arr) {
-  const dimensions = [];
-  let current = arr;
-  while (Array.isArray(current)) {
-    dimensions.push(current.length);
-    current = current[0];
-  }
-  return dimensions;
-}
-function mergeArrays(...arrs) {
-  return Array.prototype.concat.apply([], arrs);
-}
-function product(...a) {
-  return a.reduce((a2, b) => a2.flatMap((d) => b.map((e) => [d, e])));
-}
-function calculateReflectOffset(i, w) {
-  return Math.abs((i + w) % (2 * w) - w);
-}
-function pick(o, props) {
-  return Object.assign(
-    {},
-    ...props.map((prop) => {
-      if (o[prop] !== void 0) {
-        return { [prop]: o[prop] };
-      }
-    })
-  );
-}
-function count(arr, value) {
-  let count2 = 0;
-  for (const v of arr) {
-    if (v === value) ++count2;
-  }
-  return count2;
-}
-
 // src/utils/hub/files.js
 var CONTENT_TYPE_MAP = {
   txt: "text/plain",
@@ -5603,11 +5685,23 @@ var FileCache = class {
       throw error;
     }
   }
+  /**
+   * Deletes the cache entry for the given request.
+   * @param {string} request
+   * @returns {Promise<boolean>} A Promise that resolves to `true` if the cache entry was deleted, `false` otherwise.
+   */
+  async delete(request) {
+    let filePath = node_path_default.join(this.path, request);
+    try {
+      await node_fs_default.promises.unlink(filePath);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
   // TODO add the rest?
   // addAll(requests: RequestInfo[]): Promise<void>;
-  // delete(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<boolean>;
   // keys(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;
-  // match(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<Response | undefined>;
   // matchAll(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;
 };
 
@@ -5669,12 +5763,12 @@ function handleError(status, remoteURL, fatal) {
   const message = ERROR_MAPPING[status] ?? `Error (${status}) occurred while trying to load file`;
   throw Error(`${message}: "${remoteURL}".`);
 }
-async function readResponse(response, progress_callback) {
+async function readResponse(response, progress_callback, expectedSize) {
   const contentLength = response.headers.get("Content-Length");
-  if (contentLength === null) {
-    console.warn("Unable to determine content-length from response headers. Will expand buffer when needed.");
+  let total = contentLength ? parseInt(contentLength, 10) : expectedSize ?? 0;
+  if (contentLength === null && !expectedSize) {
+    logger.warn("Unable to determine content-length from response headers. Will expand buffer when needed.");
   }
-  let total = parseInt(contentLength ?? "0");
   let buffer = new Uint8Array(total);
   let loaded = 0;
   const reader = response.body.getReader();
@@ -5719,7 +5813,7 @@ async function getCache(file_cache_dir = null) {
     try {
       cache = await caches.open(env.cacheKey);
     } catch (e) {
-      console.warn("An error occurred while opening the browser cache:", e);
+      logger.warn("An error occurred while opening the browser cache:", e);
     }
   }
   if (!cache && env.useFSCache) {
@@ -5742,16 +5836,109 @@ async function tryCache(cache, ...names) {
   return void 0;
 }
 
+// src/utils/model_registry/get_file_metadata.js
+async function fetch_file_head(urlOrPath) {
+  if (!isValidUrl(urlOrPath, ["http:", "https:"])) {
+    return null;
+  }
+  const headers = getFetchHeaders(urlOrPath);
+  headers.set("Range", "bytes=0-0");
+  return env.fetch(urlOrPath, { method: "GET", headers });
+}
+async function get_file_metadata(path_or_repo_id, filename, options = {}) {
+  const cache = await getCache(options?.cache_dir);
+  const { localPath, remoteURL, proposedCacheKey, validModelId } = buildResourcePaths(
+    path_or_repo_id,
+    filename,
+    options,
+    cache
+  );
+  const cachedResponse = await checkCachedResource(cache, localPath, proposedCacheKey);
+  if (cachedResponse !== void 0 && typeof cachedResponse !== "string") {
+    const size = cachedResponse.headers.get("content-length");
+    const contentType = cachedResponse.headers.get("content-type");
+    return {
+      exists: true,
+      size: size ? parseInt(size, 10) : void 0,
+      contentType: contentType || void 0,
+      fromCache: true
+    };
+  }
+  if (env.allowLocalModels) {
+    const isURL = isValidUrl(localPath, ["http:", "https:"]);
+    if (!isURL) {
+      try {
+        const response = await getFile(localPath);
+        if (typeof response !== "string" && response.status !== 404) {
+          const size = response.headers.get("content-length");
+          const contentType = response.headers.get("content-type");
+          return {
+            exists: true,
+            size: size ? parseInt(size, 10) : void 0,
+            contentType: contentType || void 0,
+            fromCache: false
+          };
+        }
+      } catch (e) {
+      }
+    }
+  }
+  if (env.allowRemoteModels && !options.local_files_only && validModelId) {
+    try {
+      const rangeResponse = await fetch_file_head(remoteURL);
+      if (rangeResponse && rangeResponse.status >= 200 && rangeResponse.status < 300) {
+        let size;
+        const contentType = rangeResponse.headers.get("content-type");
+        if (rangeResponse.status === 206) {
+          const contentRange = rangeResponse.headers.get("content-range");
+          if (contentRange) {
+            const match = contentRange.match(/bytes \d+-\d+\/(\d+)/);
+            if (match) {
+              size = parseInt(match[1], 10);
+            }
+          }
+        } else if (rangeResponse.status === 200) {
+          try {
+            await rangeResponse.body?.cancel();
+          } catch (cancelError) {
+          }
+        }
+        if (size === void 0) {
+          const contentLength = rangeResponse.headers.get("content-length");
+          size = contentLength ? parseInt(contentLength, 10) : void 0;
+        }
+        return {
+          exists: true,
+          size,
+          contentType: contentType || void 0,
+          fromCache: false
+        };
+      }
+    } catch (e) {
+      logger.warn(`Unable to fetch file metadata for "${remoteURL}": ${e}`);
+    }
+  }
+  return { exists: false, fromCache: false };
+}
+
 // src/utils/hub.js
 async function getFile(urlOrPath) {
   if (env.useFS && !isValidUrl(urlOrPath, ["http:", "https:", "blob:"])) {
     return new FileResponse(
       urlOrPath instanceof URL ? urlOrPath.protocol === "file:" ? urlOrPath.pathname : urlOrPath.toString() : urlOrPath
     );
-  } else if (typeof process !== "undefined" && process?.release?.name === "node") {
+  } else {
+    return env.fetch(urlOrPath, {
+      headers: getFetchHeaders(urlOrPath)
+    });
+  }
+}
+function getFetchHeaders(urlOrPath) {
+  const isNode = typeof process !== "undefined" && process?.release?.name === "node";
+  const headers = new Headers();
+  if (isNode) {
     const IS_CI = !!process.env?.TESTING_REMOTELY;
     const version = env.version;
-    const headers = new Headers();
     headers.set("User-Agent", `transformers.js/${version}; is_ci/${IS_CI};`);
     const isHFURL = isValidUrl(urlOrPath, ["http:", "https:"], ["huggingface.co", "hf.co"]);
     if (isHFURL) {
@@ -5760,10 +5947,9 @@ async function getFile(urlOrPath) {
         headers.set("Authorization", `Bearer ${token}`);
       }
     }
-    return fetch(urlOrPath, { headers });
   } else {
-    return fetch(urlOrPath);
   }
+  return headers;
 }
 function buildResourcePaths(path_or_repo_id, filename, options = {}, cache = null) {
   const revision = options.revision ?? "main";
@@ -5823,7 +6009,7 @@ async function storeCachedResource(path_or_repo_id, filename, cache, cacheKey, r
         }
       )
     ).catch((err) => {
-      console.warn(`Unable to add response to browser cache: ${err}.`);
+      logger.warn(`Unable to add response to browser cache: ${err}.`);
     });
   }
 }
@@ -5847,7 +6033,7 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
           response = await getFile(localPath);
           cacheKey = localPath;
         } catch (e) {
-          console.warn(`Unable to load from local path "${localPath}": "${e}"`);
+          logger.warn(`Unable to load from local path "${localPath}": "${e}"`);
         }
       } else if (options.local_files_only) {
         throw new Error(`\`local_files_only=true\`, but attempted to load a remote file from: ${requestURL}.`);
@@ -5906,14 +6092,31 @@ async function loadResourceFile(path_or_repo_id, filename, fatal = true, options
           total: buffer.length
         });
       } else {
-        buffer = await readResponse(response, (data) => {
-          dispatchCallback(options.progress_callback, {
-            status: "progress",
-            name: path_or_repo_id,
-            file: filename,
-            ...data
-          });
-        });
+        let expectedSize;
+        const contentLength = response.headers.get("content-length");
+        if (contentLength) {
+          expectedSize = parseInt(contentLength, 10);
+        } else {
+          try {
+            const metadata = await get_file_metadata(path_or_repo_id, filename, options);
+            if (metadata.size) {
+              expectedSize = metadata.size;
+            }
+          } catch (e) {
+          }
+        }
+        buffer = await readResponse(
+          response,
+          (data) => {
+            dispatchCallback(options.progress_callback, {
+              status: "progress",
+              name: path_or_repo_id,
+              file: filename,
+              ...data
+            });
+          },
+          expectedSize
+        );
       }
     }
     result = buffer;
@@ -6760,20 +6963,9 @@ var uint16_to_float32 = /* @__PURE__ */ (function() {
 // ignore-modules:onnxruntime-node
 var onnxruntime_node_exports = {};
 __export(onnxruntime_node_exports, {
-  Readable: () => Readable,
-  createReadStream: () => createReadStream,
-  createWriteStream: () => createWriteStream,
-  default: () => onnxruntime_node_default,
-  pipeline: () => pipeline
+  default: () => onnxruntime_node_default
 });
-var noop = () => {
-};
-var emptyObj4 = {};
-var onnxruntime_node_default = emptyObj4;
-var Readable = { fromWeb: noop };
-var pipeline = noop;
-var createWriteStream = noop;
-var createReadStream = noop;
+var onnxruntime_node_default = {};
 
 // src/backends/onnx.js
 import * as ONNX_WEB from "onnxruntime-web/webgpu";
@@ -6791,9 +6983,9 @@ async function loadAndCacheFile(url) {
       }
     }
   } catch (error) {
-    console.warn(`Failed to load ${fileName} from cache:`, error);
+    logger.warn(`Failed to load ${fileName} from cache:`, error);
   }
-  const response = await fetch(url);
+  const response = await env.fetch(url);
   if (!response.ok) {
     throw new Error(`Failed to fetch ${fileName}: ${response.status} ${response.statusText}`);
   }
@@ -6801,7 +6993,7 @@ async function loadAndCacheFile(url) {
     try {
       await cache.put(url, response.clone());
     } catch (e) {
-      console.warn(`Failed to cache ${fileName}:`, e);
+      logger.warn(`Failed to cache ${fileName}:`, e);
     }
   }
   return response;
@@ -6812,7 +7004,7 @@ async function loadWasmBinary(wasmURL) {
   try {
     return await response.arrayBuffer();
   } catch (error) {
-    console.warn("Failed to read WASM binary:", error);
+    logger.warn("Failed to read WASM binary:", error);
     return null;
   }
 }
@@ -6822,11 +7014,12 @@ async function loadWasmFactory(libURL) {
   try {
     let code = await response.text();
     const baseUrl = libURL.split("/").slice(0, -1).join("/");
-    code = code.replace(/import\.meta\.url/g, `"${baseUrl}"`);
+    code = code.replaceAll("import.meta.url", `"${baseUrl}"`);
+    code = code.replaceAll("globalThis.process?.versions?.node", "false");
     const blob = new Blob([code], { type: "text/javascript" });
     return URL.createObjectURL(blob);
   } catch (error) {
-    console.warn("Failed to read WASM binary:", error);
+    logger.warn("Failed to read WASM binary:", error);
     return null;
   }
 }
@@ -6873,8 +7066,26 @@ var DEVICE_TO_EXECUTION_PROVIDER_MAPPING = Object.freeze({
   "webnn-cpu": { name: "webnn", deviceType: "cpu" }
   // WebNN CPU
 });
-var LOG_LEVELS = ["verbose", "info", "warning", "error", "fatal"];
-var DEFAULT_LOG_LEVEL = 4;
+function getOnnxLogSeverityLevel(logLevel2) {
+  if (logLevel2 <= LogLevel.DEBUG) {
+    return 0;
+  } else if (logLevel2 <= LogLevel.INFO) {
+    return 2;
+  } else if (logLevel2 <= LogLevel.WARNING) {
+    return 3;
+  } else if (logLevel2 <= LogLevel.ERROR) {
+    return 3;
+  } else {
+    return 4;
+  }
+}
+var ONNX_LOG_LEVEL_NAMES = {
+  0: "verbose",
+  1: "info",
+  2: "warning",
+  3: "error",
+  4: "fatal"
+};
 var supportedDevices = [];
 var defaultDevices;
 var ONNX;
@@ -6950,7 +7161,7 @@ async function ensureWasmLoaded() {
             ONNX_ENV.wasm.wasmBinary = wasmBinary;
           }
         } catch (err) {
-          console.warn("Failed to pre-load WASM binary:", err);
+          logger.warn("Failed to pre-load WASM binary:", err);
         }
       })() : Promise.resolve(),
       // Load and cache the WASM factory
@@ -6961,7 +7172,7 @@ async function ensureWasmLoaded() {
             ONNX_ENV.wasm.wasmPaths.mjs = wasmFactoryBlob;
           }
         } catch (err) {
-          console.warn("Failed to pre-load WASM factory:", err);
+          logger.warn("Failed to pre-load WASM factory:", err);
         }
       })() : Promise.resolve()
     ]);
@@ -6970,9 +7181,10 @@ async function ensureWasmLoaded() {
 }
 async function createInferenceSession(buffer_or_path, session_options, session_config) {
   await ensureWasmLoaded();
+  const logSeverityLevel = getOnnxLogSeverityLevel(env.logLevel ?? LogLevel.WARNING);
   const load = () => InferenceSession.create(buffer_or_path, {
-    // Set default log level, but allow overriding through session options
-    logSeverityLevel: DEFAULT_LOG_LEVEL,
+    // Set default log severity level, but allow overriding through session options
+    logSeverityLevel,
     ...session_options
   });
   const session = await (IS_WEB_ENV ? webInitChain = webInitChain.then(load) : load());
@@ -6989,7 +7201,6 @@ function isONNXTensor(x) {
   return x instanceof ONNX.Tensor;
 }
 var ONNX_ENV = ONNX?.env;
-ONNX_ENV.logLevel = LOG_LEVELS[DEFAULT_LOG_LEVEL];
 if (ONNX_ENV?.wasm) {
   if (
     // @ts-ignore Cannot find name 'ServiceWorkerGlobalScope'.ts(2304)
@@ -7012,7 +7223,15 @@ if (ONNX_ENV?.webgpu) {
 function isONNXProxy() {
   return ONNX_ENV?.wasm?.proxy;
 }
-env.backends.onnx = ONNX_ENV;
+function setLogLevel(logLevel2) {
+  const severityLevel = getOnnxLogSeverityLevel(logLevel2);
+  ONNX_ENV.logLevel = ONNX_LOG_LEVEL_NAMES[severityLevel];
+}
+setLogLevel(env.logLevel ?? LogLevel.WARNING);
+env.backends.onnx = {
+  ...ONNX_ENV,
+  setLogLevel
+};
 
 // src/ops/registry.js
 var wrap = async (session_bytes, session_options, names) => {
@@ -8099,6 +8318,16 @@ var DEVICE_TYPES = Object.freeze({
   "webnn-cpu": "webnn-cpu"
   // WebNN CPU
 });
+var DEFAULT_DEVICE = apis.IS_NODE_ENV ? "cpu" : "wasm";
+function selectDevice(deviceConfig, fileName, { warn } = {}) {
+  if (!deviceConfig) return DEFAULT_DEVICE;
+  if (typeof deviceConfig === "string") return deviceConfig;
+  if (deviceConfig.hasOwnProperty(fileName)) return deviceConfig[fileName];
+  if (warn) {
+    warn(`device not specified for "${fileName}". Using the default device (${DEFAULT_DEVICE}).`);
+  }
+  return DEFAULT_DEVICE;
+}
 
 // src/utils/dtypes.js
 var isWebGpuFp16Supported = /* @__PURE__ */ (function() {
@@ -8132,6 +8361,7 @@ var DATA_TYPES = Object.freeze({
   q4f16: "q4f16"
   // fp16 model with int4 block weight quantization
 });
+var DEFAULT_DEVICE_DTYPE = DATA_TYPES.fp32;
 var DEFAULT_DEVICE_DTYPE_MAPPING = Object.freeze({
   // NOTE: If not specified, will default to fp32
   [DEVICE_TYPES.wasm]: DATA_TYPES.q8
@@ -8146,6 +8376,45 @@ var DEFAULT_DTYPE_SUFFIX_MAPPING = Object.freeze({
   [DATA_TYPES.q4f16]: "_q4f16",
   [DATA_TYPES.bnb4]: "_bnb4"
 });
+function selectDtype(dtype, fileName, selectedDevice, { configDtype = null, warn } = {}) {
+  let resolved;
+  let needsWarn = false;
+  if (dtype && typeof dtype !== "string") {
+    if (dtype.hasOwnProperty(fileName)) {
+      resolved = dtype[fileName];
+    } else {
+      resolved = null;
+      needsWarn = true;
+    }
+  } else {
+    resolved = /** @type {string|null|undefined} */
+    dtype;
+  }
+  let result;
+  if (resolved === DATA_TYPES.auto) {
+    if (configDtype) {
+      const fallback = typeof configDtype === "string" ? configDtype : configDtype?.[fileName];
+      if (fallback && fallback !== DATA_TYPES.auto && DATA_TYPES.hasOwnProperty(fallback)) {
+        return (
+          /** @type {DataType} */
+          fallback
+        );
+      }
+    }
+    result = DEFAULT_DEVICE_DTYPE_MAPPING[selectedDevice] ?? DEFAULT_DEVICE_DTYPE;
+  } else if (resolved && DATA_TYPES.hasOwnProperty(resolved)) {
+    result = /** @type {DataType} */
+    resolved;
+  } else {
+    result = DEFAULT_DEVICE_DTYPE_MAPPING[selectedDevice] ?? DEFAULT_DEVICE_DTYPE;
+  }
+  if (needsWarn && warn) {
+    warn(
+      `dtype not specified for "${fileName}". Using the default dtype (${result}) for this device (${selectedDevice}).`
+    );
+  }
+  return result;
+}
 var DataTypeMap = Object.freeze({
   float32: Float32Array,
   // @ts-ignore ts(2552) Limited availability of Float16Array across browsers:
@@ -8167,6 +8436,167 @@ var DataTypeMap = Object.freeze({
   int4: Int8Array
 });
 
+// src/utils/random.js
+var Random = class {
+  constructor(seed) {
+    this._mt = new Uint32Array(624);
+    this._idx = 625;
+    this._gauss_next = null;
+    this._random_fn = this.random.bind(this);
+    this.seed(seed);
+  }
+  /**
+   * Seeds this instance's PRNG.
+   *
+   * When called with a number, initializes the state deterministically from that value.
+   * When called with no arguments (or `undefined`/`null`), seeds from OS entropy
+   * via `crypto.getRandomValues`, matching Python's `random.seed()` behaviour.
+   *
+   * @param {number} [n] The seed value. Omit to seed from OS entropy.
+   */
+  seed(n) {
+    if (n === void 0 || n === null) {
+      if (apis.IS_CRYPTO_AVAILABLE) {
+        const buf = new Uint32Array(1);
+        crypto.getRandomValues(buf);
+        n = buf[0];
+      } else {
+        n = Date.now() >>> 0;
+      }
+    }
+    const mt = this._mt;
+    const u = (a, b) => Math.imul(a, b) >>> 0, key = [];
+    for (let v = n || 0; v > 0; v = Math.floor(v / 4294967296)) key.push(v & 4294967295);
+    if (!key.length) key.push(0);
+    mt[0] = 19650218;
+    for (let k = 1; k < 624; ++k) mt[k] = u(1812433253, mt[k - 1] ^ mt[k - 1] >>> 30) + k >>> 0;
+    let i = 1, j = 0;
+    for (let k = Math.max(624, key.length); k > 0; --k, ++i, ++j) {
+      if (i >= 624) {
+        mt[0] = mt[623];
+        i = 1;
+      }
+      if (j >= key.length) j = 0;
+      mt[i] = (mt[i] ^ u(mt[i - 1] ^ mt[i - 1] >>> 30, 1664525)) + key[j] + j >>> 0;
+    }
+    for (let k = 623; k > 0; --k, ++i) {
+      if (i >= 624) {
+        mt[0] = mt[623];
+        i = 1;
+      }
+      mt[i] = (mt[i] ^ u(mt[i - 1] ^ mt[i - 1] >>> 30, 1566083941)) - i >>> 0;
+    }
+    mt[0] = 2147483648;
+    this._idx = 624;
+    this._gauss_next = null;
+  }
+  /**
+   * Generates a random unsigned 32-bit integer.
+   *
+   * Performs the "twist" step when the state buffer is exhausted,
+   * then applies the standard MT19937 tempering transform.
+   *
+   * @returns {number} A random integer in the range [0, 2^32 - 1].
+   */
+  _int32() {
+    const mt = this._mt;
+    if (this._idx >= 624) {
+      for (let k = 0; k < 624; ++k) {
+        const y2 = mt[k] & 2147483648 | mt[(k + 1) % 624] & 2147483647;
+        mt[k] = (mt[(k + 397) % 624] ^ y2 >>> 1 ^ (y2 & 1 ? 2567483615 : 0)) >>> 0;
+      }
+      this._idx = 0;
+    }
+    let y = mt[this._idx++];
+    y ^= y >>> 11;
+    y ^= y << 7 & 2636928640;
+    y ^= y << 15 & 4022730752;
+    y ^= y >>> 18;
+    return y >>> 0;
+  }
+  /**
+   * Generates a random floating-point number in the half-open interval [0, 1).
+   *
+   * Combines two 32-bit integers (using 53 bits of precision) to produce
+   * a uniformly distributed double, matching Python's `random.random()`.
+   *
+   * @returns {number} A random float in [0, 1).
+   */
+  random() {
+    return ((this._int32() >>> 5) * 67108864 + (this._int32() >>> 6)) / 9007199254740992;
+  }
+  /**
+   * Generates a random number from a Gaussian (normal) distribution.
+   *
+   * Uses the Box-Muller transform with a cached spare value,
+   * matching Python's `random.gauss()` output for the same seed.
+   *
+   * @param {number} [mu=0] The mean of the distribution.
+   * @param {number} [sigma=1] The standard deviation of the distribution.
+   * @returns {number} A normally distributed random value.
+   */
+  gauss(mu = 0, sigma = 1) {
+    let z = this._gauss_next;
+    this._gauss_next = null;
+    if (z === null) {
+      const x2pi = this.random() * 2 * Math.PI, g2rad = Math.sqrt(-2 * Math.log(1 - this.random()));
+      z = Math.cos(x2pi) * g2rad;
+      this._gauss_next = Math.sin(x2pi) * g2rad;
+    }
+    return mu + z * sigma;
+  }
+  /**
+   * Shuffles an array in-place using the Fisher-Yates algorithm.
+   *
+   * Uses rejection sampling via `getrandbits`-style bit masking to ensure
+   * a uniform distribution, matching Python's `random.shuffle()`.
+   *
+   * @param {any[]} arr The array to shuffle in-place.
+   */
+  shuffle(arr) {
+    for (let i = arr.length - 1; i > 0; --i) {
+      const k = 32 - Math.clz32(i + 1);
+      let r = this._int32() >>> 32 - k;
+      while (r > i) r = this._int32() >>> 32 - k;
+      const t = arr[i];
+      arr[i] = arr[r];
+      arr[r] = t;
+    }
+  }
+  /**
+   * Selects a single element from a weighted population.
+   *
+   * Matches Python's `random.choices(population, weights=weights, k=1)[0]`
+   *
+   * @param {any[]} population The array of items to choose from.
+   * @param {number[]} weights An array of non-negative weights, one per population element.
+   * @returns {*} A single randomly selected element from the population.
+   */
+  choices(population, weights) {
+    return population[_weightedIndexWith(this._random_fn, weights)];
+  }
+};
+function _weightedIndexWith(randomFn, weights) {
+  let sum = 0;
+  for (let i = 0; i < weights.length; ++i) sum += weights[i];
+  let x = randomFn() * sum;
+  for (let i = 0; i < weights.length; ++i) {
+    x -= weights[i];
+    if (x < 0) return i;
+  }
+  return weights.length - 1;
+}
+var _default = new Random();
+var random = Object.freeze({
+  Random,
+  seed: _default.seed.bind(_default),
+  random: _default.random.bind(_default),
+  gauss: _default.gauss.bind(_default),
+  shuffle: _default.shuffle.bind(_default),
+  choices: _default.choices.bind(_default)
+});
+var _weightedIndex = (weights) => _weightedIndexWith(random.random, weights);
+
 // src/utils/tensor.js
 var Tensor2 = class _Tensor {
   /**
@@ -9297,24 +9727,17 @@ function rand(size) {
   const length = size.reduce((a, b) => a * b, 1);
   return new Tensor2(
     "float32",
-    Float32Array.from({ length }, () => Math.random()),
+    Float32Array.from({ length }, () => random.random()),
     size
   );
 }
 function randn(size) {
   const length = size.reduce((a, b) => a * b, 1);
-  const data = new Float32Array(length);
-  for (let i = 0; i < length; i += 2) {
-    const u = 1 - Math.random();
-    const v = Math.random();
-    const mag = Math.sqrt(-2 * Math.log(u));
-    const angle = 2 * Math.PI * v;
-    data[i] = mag * Math.cos(angle);
-    if (i + 1 < length) {
-      data[i + 1] = mag * Math.sin(angle);
-    }
-  }
-  return new Tensor2("float32", data, size);
+  return new Tensor2(
+    "float32",
+    Float32Array.from({ length }, () => random.gauss()),
+    size
+  );
 }
 function quantize_embeddings(tensor, precision) {
   if (tensor.dims.length !== 2) {
@@ -9343,13 +9766,24 @@ function quantize_embeddings(tensor, precision) {
   return new Tensor2(dtype, outputData, [tensor.dims[0], tensor.dims[1] / 8]);
 }
 
+// src/utils/model_registry/get_tokenizer_files.js
+async function get_tokenizer_files(modelId) {
+  if (!modelId) {
+    throw new Error("modelId is required for get_tokenizer_files");
+  }
+  const metadata = await get_file_metadata(modelId, "tokenizer_config.json", {});
+  if (metadata.exists) {
+    return ["tokenizer.json", "tokenizer_config.json"];
+  }
+  return [];
+}
+
 // src/tokenization_utils.js
 async function loadTokenizer(pretrained_model_name_or_path, options) {
-  const info = await Promise.all([
-    getModelJSON(pretrained_model_name_or_path, "tokenizer.json", true, options),
-    getModelJSON(pretrained_model_name_or_path, "tokenizer_config.json", true, options)
-  ]);
-  return info;
+  const tokenizerFiles = await get_tokenizer_files(pretrained_model_name_or_path);
+  return await Promise.all(
+    tokenizerFiles.map((file) => getModelJSON(pretrained_model_name_or_path, file, true, options))
+  );
 }
 function prepareTensorForDecode(tensor) {
   const dims = tensor.dims;
@@ -9523,10 +9957,10 @@ var PreTrainedTokenizer = class extends Callable2 {
    * @param {string|string[]} [options.text_pair=null] Optional second sequence to be encoded. If set, must be the same type as text.
    * @param {boolean|'max_length'} [options.padding=false] Whether to pad the input sequences.
    * @param {boolean} [options.add_special_tokens=true] Whether or not to add the special tokens associated with the corresponding model.
-   * @param {boolean} [options.truncation=null] Whether to truncate the input sequences.
-   * @param {number} [options.max_length=null] Maximum length of the returned list and optionally padding length.
+   * @param {boolean|null} [options.truncation=null] Whether to truncate the input sequences.
+   * @param {number|null} [options.max_length=null] Maximum length of the returned list and optionally padding length.
    * @param {boolean} [options.return_tensor=true] Whether to return the results as Tensors or arrays.
-   * @param {boolean} [options.return_token_type_ids=null] Whether to return the token type ids.
+   * @param {boolean|null} [options.return_token_type_ids=null] Whether to return the token type ids.
    * @returns {BatchEncoding} Object to be passed to the model.
    */
   _call(text, {
@@ -9572,12 +10006,12 @@ var PreTrainedTokenizer = class extends Callable2 {
       max_length = this.model_max_length;
     } else if (truncation === null) {
       if (padding === true) {
-        console.warn(
+        logger.warn(
           "`max_length` is ignored when `padding: true` and there is no truncation strategy. To pad to max length, use `padding: 'max_length'`."
         );
         max_length = this.model_max_length;
       } else if (padding === false) {
-        console.warn(
+        logger.warn(
           "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation: true` to explicitly truncate examples to max length."
         );
         truncation = true;
@@ -9661,9 +10095,9 @@ var PreTrainedTokenizer = class extends Callable2 {
    *
    * @param {string} text The text to encode.
    * @param {Object} options An optional object containing the following properties:
-   * @param {string} [options.text_pair=null] The optional second text to encode.
+   * @param {string|null} [options.text_pair=null] The optional second text to encode.
    * @param {boolean} [options.add_special_tokens=true] Whether or not to add the special tokens associated with the corresponding model.
-   * @param {boolean} [options.return_token_type_ids=null] Whether to return token_type_ids.
+   * @param {boolean|null} [options.return_token_type_ids=null] Whether to return token_type_ids.
    * @returns {{input_ids: number[], attention_mask: number[], token_type_ids?: number[]}} An object containing the encoded text.
    * @private
    */
@@ -9683,7 +10117,7 @@ var PreTrainedTokenizer = class extends Callable2 {
    * Converts a string into a sequence of tokens.
    * @param {string} text The sequence to be encoded.
    * @param {Object} options An optional object containing the following properties:
-   * @param {string} [options.pair] A second sequence to be encoded with the first.
+   * @param {string|null} [options.pair] A second sequence to be encoded with the first.
    * @param {boolean} [options.add_special_tokens=false] Whether or not to add the special tokens associated with the corresponding model.
    * @returns {string[]} The list of tokens.
    */
@@ -9695,9 +10129,9 @@ var PreTrainedTokenizer = class extends Callable2 {
    *
    * @param {string} text The text to encode.
    * @param {Object} options An optional object containing the following properties:
-   * @param {string} [options.text_pair=null] The optional second text to encode.
+   * @param {string|null} [options.text_pair=null] The optional second text to encode.
    * @param {boolean} [options.add_special_tokens=true] Whether or not to add the special tokens associated with the corresponding model.
-   * @param {boolean} [options.return_token_type_ids=null] Whether to return token_type_ids.
+   * @param {boolean|null} [options.return_token_type_ids=null] Whether to return token_type_ids.
    * @returns {number[]} An array of token IDs representing the encoded text(s).
    */
   encode(text, { text_pair = null, add_special_tokens = true, return_token_type_ids = null } = {}) {
@@ -9744,7 +10178,7 @@ var PreTrainedTokenizer = class extends Callable2 {
    * @param {number[]|bigint[]} token_ids List of token ids to decode
    * @param {Object} decode_args Optional arguments for decoding
    * @param {boolean} [decode_args.skip_special_tokens=false] Whether to skip special tokens during decoding
-   * @param {boolean} [decode_args.clean_up_tokenization_spaces=null] Whether to clean up tokenization spaces during decoding.
+   * @param {boolean|null} [decode_args.clean_up_tokenization_spaces=null] Whether to clean up tokenization spaces during decoding.
    * If null, the value is set to `this.decoder.cleanup` if it exists, falling back to `this.clean_up_tokenization_spaces` if it exists, falling back to `true`.
    * @returns {string} The decoded string
    */
@@ -9760,7 +10194,7 @@ var PreTrainedTokenizer = class extends Callable2 {
    * template for better generation tracking.
    *
    * @param {Object} options An optional object containing the following properties:
-   * @param {string} [options.chat_template=null]
+   * @param {string|null} [options.chat_template=null]
    * A Jinja template or the name of a template to use for this conversion.
    * It is usually not necessary to pass anything to this argument,
    * as the model's template will be used by default.
@@ -9829,7 +10263,7 @@ var PreTrainedTokenizer = class extends Callable2 {
    * @param {Message[]} conversation A list of message objects with `"role"` and `"content"` keys,
    * representing the chat history so far.
    * @param {Object} options An optional object containing the following properties:
-   * @param {string} [options.chat_template=null] A Jinja template to use for this conversion. If
+   * @param {string|null} [options.chat_template=null] A Jinja template to use for this conversion. If
    * this is not passed, the model's chat template will be used instead.
    * @param {Object[]} [options.tools=null]
    * A list of tools (callable functions) that will be accessible to the model. If the template does not
@@ -9850,7 +10284,7 @@ var PreTrainedTokenizer = class extends Callable2 {
    * @param {boolean} [options.tokenize=true] Whether to tokenize the output. If false, the output will be a string.
    * @param {boolean} [options.padding=false] Whether to pad sequences to the maximum length. Has no effect if tokenize is false.
    * @param {boolean} [options.truncation=false] Whether to truncate sequences to the maximum length. Has no effect if tokenize is false.
-   * @param {number} [options.max_length=null] Maximum length (in tokens) to use for padding or truncation. Has no effect if tokenize is false.
+   * @param {number|null} [options.max_length=null] Maximum length (in tokens) to use for padding or truncation. Has no effect if tokenize is false.
    * If not specified, the tokenizer's `max_length` attribute will be used as a default.
    * @param {boolean} [options.return_tensor=true] Whether to return the output as a Tensor or an Array. Has no effect if tokenize is false.
    * @param {boolean} [options.return_dict=true] Whether to return a dictionary with named outputs. Has no effect if tokenize is false.
@@ -10128,7 +10562,7 @@ var MarianTokenizer = class extends PreTrainedTokenizer {
     super(tokenizerJSON, tokenizerConfig);
     this.languageRegex = /^(>>\w+<<)\s*/g;
     this.supported_language_codes = Array.from(this.get_vocab().keys()).filter((x) => this.languageRegex.test(x));
-    console.warn(
+    logger.warn(
       'WARNING: `MarianTokenizer` is not yet supported by Hugging Face\'s "fast" tokenizers library. Therefore, you may experience slightly inaccurate results.'
     );
   }
@@ -10148,7 +10582,7 @@ var MarianTokenizer = class extends PreTrainedTokenizer {
     } else if (remainder.length === 2) {
       const [language, text2] = remainder;
       if (!this.supported_language_codes.includes(language)) {
-        console.warn(
+        logger.warn(
           `Unsupported language code "${language}" detected, which may lead to unexpected behavior. Should be one of: ${JSON.stringify(this.supported_language_codes)}`
         );
       }
@@ -10865,7 +11299,7 @@ var XLMTokenizer = class extends PreTrainedTokenizer {
   return_token_type_ids = true;
   constructor(tokenizerJSON, tokenizerConfig) {
     super(tokenizerJSON, tokenizerConfig);
-    console.warn(
+    logger.warn(
       'WARNING: `XLMTokenizer` is not yet supported by Hugging Face\'s "fast" tokenizers library. Therefore, you may experience slightly inaccurate results.'
     );
   }
@@ -10899,7 +11333,7 @@ var AutoTokenizer = class {
     const tokenizerName = tokenizerConfig.tokenizer_class?.replace(/Fast$/, "") ?? "PreTrainedTokenizer";
     let cls = tokenizers_exports[tokenizerName];
     if (!cls) {
-      console.warn(`Unknown tokenizer class "${tokenizerName}", attempting to construct from base class.`);
+      logger.warn(`Unknown tokenizer class "${tokenizerName}", attempting to construct from base class.`);
       cls = PreTrainedTokenizer;
     }
     return new cls(tokenizerJSON, tokenizerConfig);
@@ -11048,6 +11482,8 @@ __export(processors_exports, {
   Processor: () => Processor,
   PyAnnoteProcessor: () => PyAnnoteProcessor,
   Qwen2VLProcessor: () => Qwen2VLProcessor,
+  Qwen2_5_VLProcessor: () => Qwen2_5_VLProcessor,
+  Qwen3VLProcessor: () => Qwen3VLProcessor,
   Sam2Processor: () => Sam2Processor,
   Sam2VideoProcessor: () => Sam2VideoProcessor,
   SamProcessor: () => SamProcessor,
@@ -11122,14 +11558,14 @@ __export(feature_extractors_exports, {
 });
 
 // ignore-modules:node:stream
-var noop2 = () => {
+var noop = () => {
 };
-var Readable2 = { fromWeb: noop2 };
+var Readable = { fromWeb: noop };
 
 // ignore-modules:node:stream/promises
-var noop3 = () => {
+var noop2 = () => {
 };
-var pipeline2 = noop3;
+var pipeline = noop2;
 
 // src/utils/io.js
 async function saveBlob(path, blob) {
@@ -11146,9 +11582,9 @@ async function saveBlob(path, blob) {
     URL.revokeObjectURL(dataURL);
   } else if (apis.IS_FS_AVAILABLE) {
     const webStream = blob.stream();
-    const nodeStream = Readable2.fromWeb(webStream);
+    const nodeStream = Readable.fromWeb(webStream);
     const fileStream = node_fs_default.createWriteStream(path);
-    await pipeline2(nodeStream, fileStream);
+    await pipeline(nodeStream, fileStream);
   } else {
     throw new Error("Unable to save because filesystem is disabled in this environment.");
   }
@@ -11164,7 +11600,7 @@ async function read_audio(url, sampling_rate) {
   const response = await (await getFile(url)).arrayBuffer();
   const audioCTX = new AudioContext({ sampleRate: sampling_rate });
   if (typeof sampling_rate === "undefined") {
-    console.warn(`No sampling rate provided, using default of ${audioCTX.sampleRate}Hz.`);
+    logger.warn(`No sampling rate provided, using default of ${audioCTX.sampleRate}Hz.`);
   }
   const decoded = await audioCTX.decodeAudioData(response);
   let audio;
@@ -11820,7 +12256,7 @@ var ClapFeatureExtractor = class extends FeatureExtractor {
     if (diff > 0) {
       if (truncation === "rand_trunc") {
         longer = true;
-        const idx = Math.floor(Math.random() * (diff + 1));
+        const idx = Math.floor(random.random() * (diff + 1));
         waveform = waveform.subarray(idx, idx + max_length);
         input_mel = await this._extract_fbank_features(
           waveform,
@@ -12553,7 +12989,7 @@ var WhisperFeatureExtractor = class extends FeatureExtractor {
     const length = max_length ?? this.config.n_samples;
     if (audio.length > length) {
       if (audio.length > this.config.n_samples) {
-        console.warn(
+        logger.warn(
           "Attempting to extract features for audio longer than 30 seconds. If using a pipeline to extract transcript from a long audio clip, remember to specify `chunk_length_s` and/or `stride_length_s`."
         );
       }
@@ -12600,8 +13036,7 @@ var ChatterboxProcessor = class extends Processor {
 };
 
 // ignore-modules:sharp
-var emptyObj5 = {};
-var sharp_default = emptyObj5;
+var sharp_default = {};
 
 // src/utils/image.js
 var createCanvasFunction;
@@ -12924,7 +13359,7 @@ var RawImage = class _RawImage {
         case "box":
         case "hamming":
           if (resampleMethod === "box" || resampleMethod === "hamming") {
-            console.warn(
+            logger.warn(
               `Resampling method ${resampleMethod} is not yet supported. Using bilinear instead.`
             );
             resampleMethod = "bilinear";
@@ -13423,30 +13858,9 @@ function compute_segments(mask_probs, pred_scores, pred_labels, mask_threshold,
   }
   return [segmentation, segments];
 }
-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) {
-    throw new Error(
-      `absolute aspect ratio must be smaller than 200, got ${Math.max(height, width) / Math.min(height, width)}`
-    );
-  }
-  let h_bar = Math.round(height / factor) * factor;
-  let w_bar = Math.round(width / factor) * factor;
-  if (h_bar * w_bar > max_pixels) {
-    const beta = Math.sqrt(height * width / max_pixels);
-    h_bar = Math.floor(height / beta / factor) * factor;
-    w_bar = Math.floor(width / beta / factor) * factor;
-  } else if (h_bar * w_bar < min_pixels) {
-    const beta = Math.sqrt(min_pixels / (height * width));
-    h_bar = Math.ceil(height * beta / factor) * factor;
-    w_bar = Math.ceil(width * beta / factor) * factor;
-  }
-  return [h_bar, w_bar];
-}
 function post_process_panoptic_segmentation(outputs, threshold = 0.5, mask_threshold = 0.5, overlap_mask_area_threshold = 0.8, label_ids_to_fuse = null, target_sizes = null) {
   if (label_ids_to_fuse === null) {
-    console.warn("`label_ids_to_fuse` unset. No instance will be fused.");
+    logger.warn("`label_ids_to_fuse` unset. No instance will be fused.");
     label_ids_to_fuse = /* @__PURE__ */ new Set();
   }
   const class_queries_logits = outputs.class_queries_logits ?? outputs.logits;
@@ -13713,9 +14127,6 @@ var ImageProcessor = class extends Callable2 {
       return [newWidth, newHeight];
     } else if (this.size_divisibility !== void 0) {
       return enforce_size_divisibility([srcWidth, srcHeight], this.size_divisibility);
-    } else if (this.min_pixels !== void 0 && this.max_pixels !== void 0) {
-      const factor = this.config.patch_size * this.config.merge_size;
-      return smart_resize(srcHeight, srcWidth, factor, this.min_pixels, this.max_pixels);
     } else {
       throw new Error(
         `Could not resize image due to unsupported \`this.size\` option in config: ${JSON.stringify(size)}`
@@ -14539,7 +14950,40 @@ var PvtImageProcessor = class extends ImageProcessor {
 };
 
 // src/models/qwen2_vl/image_processing_qwen2_vl.js
+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) {
+    throw new Error(
+      `absolute aspect ratio must be smaller than 200, got ${Math.max(height, width) / Math.min(height, width)}`
+    );
+  }
+  let h_bar = Math.round(height / factor) * factor;
+  let w_bar = Math.round(width / factor) * factor;
+  if (h_bar * w_bar > max_pixels) {
+    const beta = Math.sqrt(height * width / max_pixels);
+    h_bar = Math.floor(height / beta / factor) * factor;
+    w_bar = Math.floor(width / beta / factor) * factor;
+  } else if (h_bar * w_bar < min_pixels) {
+    const beta = Math.sqrt(min_pixels / (height * width));
+    h_bar = Math.ceil(height * beta / factor) * factor;
+    w_bar = Math.ceil(width * beta / factor) * factor;
+  }
+  return [h_bar, w_bar];
+}
 var Qwen2VLImageProcessor = class extends ImageProcessor {
+  constructor(config) {
+    super(config);
+    this.min_pixels = config.min_pixels ?? config.size?.shortest_edge;
+    this.max_pixels = config.max_pixels ?? config.size?.longest_edge;
+    this.patch_size = config.patch_size;
+    this.merge_size = config.merge_size;
+  }
+  /** @type {ImageProcessor['get_resize_output_image_size']} */
+  get_resize_output_image_size(image, size) {
+    const factor = this.patch_size * this.merge_size;
+    return smart_resize(image.height, image.width, factor, this.min_pixels, this.max_pixels);
+  }
   async _call(images, ...args) {
     const { pixel_values, original_sizes, reshaped_input_sizes } = await super._call(images, ...args);
     let patches = pixel_values;
@@ -14941,7 +15385,7 @@ var AutoImageProcessor = class {
     let image_processor_class = image_processors_exports[key?.replace(/Fast$/, "")];
     if (!image_processor_class) {
       if (key !== void 0) {
-        console.warn(
+        logger.warn(
           `Image processor type '${key}' not found, assuming base ImageProcessor. Please report this at ${GITHUB_ISSUE_URL}.`
         );
       }
@@ -15610,7 +16054,7 @@ var PaliGemmaProcessor = class extends Processor {
   // `images` is required, `text` is optional
   async _call(images, text = null, kwargs = {}) {
     if (!text) {
-      console.warn(
+      logger.warn(
         "You are using PaliGemma without a text prefix. It will perform as a picture-captioning model."
       );
       text = "";
@@ -15632,7 +16076,7 @@ var PaliGemmaProcessor = class extends Processor {
         return expanded_sample.slice(0, bos_index) + bos_token + expanded_sample.slice(bos_index) + "\n";
       });
     } else {
-      console.warn(
+      logger.warn(
         "You are passing both `text` and `images` to `PaliGemmaProcessor`. The processor expects special image tokens in the text, as many tokens as there are images per each text. It is recommended to add `<image>` tokens in the very beginning of your text. For this call, we will infer how many images each text has and add special tokens."
       );
       input_strings = text.map(
@@ -15788,6 +16232,14 @@ var Qwen2VLProcessor = class extends Processor {
   }
 };
 
+// src/models/qwen2_5_vl/processing_qwen2_5_vl.js
+var Qwen2_5_VLProcessor = class extends Qwen2VLProcessor {
+};
+
+// src/models/qwen3_vl/processing_qwen3_vl.js
+var Qwen3VLProcessor = class extends Qwen2_5_VLProcessor {
+};
+
 // src/models/sam/processing_sam.js
 var SamProcessor = class extends Processor {
   static image_processor_class = AutoImageProcessor;
@@ -16033,6 +16485,8 @@ function getNormalizedConfig(config) {
     case "gemma3n":
     case "chatterbox":
     case "mistral3":
+    case "qwen2_5_vl":
+    case "qwen3_vl":
       init_normalized_config = getNormalizedConfig(config.text_config);
       break;
     case "moondream1":
@@ -16069,6 +16523,7 @@ function getNormalizedConfig(config) {
     case "nanochat":
     case "apertus":
     case "arcee":
+    case "afmoe":
     case "lfm2":
     case "lfm2_moe":
     case "smollm3":
@@ -16079,10 +16534,13 @@ function getNormalizedConfig(config) {
     case "granite":
     case "granitemoehybrid":
     case "cohere":
+    case "cohere2":
     case "mistral":
     case "starcoder2":
     case "qwen2":
     case "qwen2_vl":
+    case "qwen2_5_vl_text":
+    case "qwen3_vl_text":
     case "phi":
     case "phi3":
     case "phi3_v":
@@ -16227,7 +16685,10 @@ function getCacheShapes(config, options) {
     const pkv_prefix = options?.prefix ?? "past_key_values";
     const conv_prefix = pkv_prefix === "present" ? "present" : "past";
     const cache_values = {};
-    const { layer_types, num_attention_heads, num_key_value_heads, hidden_size, conv_L_cache } = config;
+    const { layer_types, num_attention_heads, num_key_value_heads, hidden_size, conv_L_cache } = (
+      /** @type {any} */
+      config
+    );
     const head_dim = hidden_size / num_attention_heads;
     const batch_size = options?.batch_size ?? 1;
     for (let i = 0; i < layer_types.length; ++i) {
@@ -16278,6 +16739,48 @@ function getCacheShapes(config, options) {
       }
     }
     return cache_values;
+  } else if (["qwen3_5", "qwen3_5_moe"].includes(config.model_type)) {
+    const pkv_prefix = options?.prefix ?? "past_key_values";
+    const conv_prefix = pkv_prefix === "present" ? "present" : "past";
+    const cache_values = {};
+    const {
+      head_dim,
+      layer_types,
+      num_attention_heads,
+      num_key_value_heads,
+      hidden_size,
+      linear_num_value_heads,
+      linear_num_key_heads,
+      linear_key_head_dim,
+      linear_value_head_dim,
+      linear_conv_kernel_dim
+    } = (
+      /** @type {any} */
+      config.text_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) {
+      if (layer_types[i] === "full_attention") {
+        for (const kv of ["key", "value"]) {
+          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];
+        cache_values[`${conv_prefix}_recurrent.${i}`] = [
+          batch_size,
+          linear_num_value_heads,
+          linear_key_head_dim,
+          linear_value_head_dim
+        ];
+      } else {
+        throw new Error(`Unsupported layer type: ${layer_types[i]}`);
+      }
+    }
+    return cache_values;
   }
   return getKeyValueShapes(config, options);
 }
@@ -16382,6 +16885,22 @@ var AutoConfig = class {
 };
 
 // src/utils/model-loader.js
+function resolveExternalDataFormat(config, fullName, fileName) {
+  if (!config) return 0;
+  if (typeof config === "object" && config !== null) {
+    if (config.hasOwnProperty(fullName)) return +config[fullName];
+    if (config.hasOwnProperty(fileName)) return +config[fileName];
+    return 0;
+  }
+  return +config;
+}
+function getExternalDataChunkNames(fullName, numChunks) {
+  const names = [];
+  for (let i = 0; i < numChunks; ++i) {
+    names.push(`${fullName}_data${i === 0 ? "" : "_" + i}`);
+  }
+  return names;
+}
 async function getCoreModelFile(pretrained_model_name_or_path, fileName, options, suffix) {
   const baseName = `${fileName}${suffix}.onnx`;
   const fullPath = `${options.subfolder ?? ""}/${baseName}`;
@@ -16391,27 +16910,15 @@ async function getModelDataFiles(pretrained_model_name_or_path, fileName, suffix
   const baseName = `${fileName}${suffix}.onnx`;
   const return_path = apis.IS_NODE_ENV;
   let externalDataPromises = [];
-  if (use_external_data_format) {
-    let external_data_format;
-    if (typeof use_external_data_format === "object") {
-      if (use_external_data_format.hasOwnProperty(baseName)) {
-        external_data_format = use_external_data_format[baseName];
-      } else if (use_external_data_format.hasOwnProperty(fileName)) {
-        external_data_format = use_external_data_format[fileName];
-      } else {
-        external_data_format = false;
-      }
-    } else {
-      external_data_format = use_external_data_format;
-    }
-    const num_chunks = +external_data_format;
+  const num_chunks = resolveExternalDataFormat(use_external_data_format, baseName, fileName);
+  if (num_chunks > 0) {
     if (num_chunks > MAX_EXTERNAL_DATA_CHUNKS) {
       throw new Error(
         `The number of external data chunks (${num_chunks}) exceeds the maximum allowed value (${MAX_EXTERNAL_DATA_CHUNKS}).`
       );
     }
-    for (let i = 0; i < num_chunks; ++i) {
-      const path = `${baseName}_data${i === 0 ? "" : "_" + i}`;
+    const chunkNames = getExternalDataChunkNames(baseName, num_chunks);
+    for (const path of chunkNames) {
       const fullPath = `${options.subfolder ?? ""}/${path}`;
       externalDataPromises.push(
         new Promise(async (resolve, reject) => {
@@ -16441,18 +16948,11 @@ async function getModelDataFiles(pretrained_model_name_or_path, fileName, suffix
 // src/models/session.js
 async function getSession(pretrained_model_name_or_path, fileName, options, is_decoder = false) {
   let custom_config = options.config?.["transformers.js_config"] ?? {};
-  let device = options.device ?? custom_config.device;
-  if (device && typeof device !== "string") {
-    if (device.hasOwnProperty(fileName)) {
-      device = device[fileName];
-    } else {
-      console.warn(`device not specified for "${fileName}". Using the default device.`);
-      device = null;
-    }
-  }
   const selectedDevice = (
     /** @type {import("../utils/devices.js").DeviceType} */
-    device ?? (apis.IS_NODE_ENV ? "cpu" : "wasm")
+    selectDevice(options.device ?? custom_config.device, fileName, {
+      warn: (msg) => logger.info(msg)
+    })
   );
   const executionProviders = deviceToExecutionProviders(selectedDevice);
   const device_config = custom_config.device_config ?? {};
@@ -16462,31 +16962,12 @@ async function getSession(pretrained_model_name_or_path, fileName, options, is_d
       ...device_config[selectedDevice]
     };
   }
-  let dtype = options.dtype ?? custom_config.dtype;
-  if (typeof dtype !== "string") {
-    if (dtype && dtype.hasOwnProperty(fileName)) {
-      dtype = dtype[fileName];
-    } else {
-      dtype = DEFAULT_DEVICE_DTYPE_MAPPING[selectedDevice] ?? DATA_TYPES.fp32;
-      console.warn(
-        `dtype not specified for "${fileName}". Using the default dtype (${dtype}) for this device (${selectedDevice}).`
-      );
-    }
-  }
-  if (dtype === DATA_TYPES.auto) {
-    let config_dtype = custom_config.dtype;
-    if (typeof config_dtype !== "string") {
-      config_dtype = config_dtype?.[fileName];
-    }
-    if (config_dtype && config_dtype !== DATA_TYPES.auto && DATA_TYPES.hasOwnProperty(config_dtype)) {
-      dtype = config_dtype;
-    } else {
-      dtype = DEFAULT_DEVICE_DTYPE_MAPPING[selectedDevice] ?? DATA_TYPES.fp32;
-    }
-  }
   const selectedDtype = (
     /** @type {import("../utils/dtypes.js").DataType} */
-    dtype
+    selectDtype(options.dtype ?? custom_config.dtype, fileName, selectedDevice, {
+      configDtype: custom_config.dtype,
+      warn: (msg) => logger.info(msg)
+    })
   );
   if (!DEFAULT_DTYPE_SUFFIX_MAPPING.hasOwnProperty(selectedDtype)) {
     throw new Error(`Invalid dtype: ${selectedDtype}. Should be one of: ${Object.keys(DATA_TYPES).join(", ")}`);
@@ -16506,7 +16987,7 @@ async function getSession(pretrained_model_name_or_path, fileName, options, is_d
   if (free_dimension_overrides) {
     session_options.freeDimensionOverrides ??= free_dimension_overrides;
   } else if (selectedDevice.startsWith("webnn") && !session_options.freeDimensionOverrides) {
-    console.warn(
+    logger.warn(
       `WebNN does not currently support dynamic shapes and requires 'free_dimension_overrides' to be set in config.json, preferably as a field within config["transformers.js_config"]["device_config"]["${selectedDevice}"]. When 'free_dimension_overrides' is not set, you may experience significant performance degradation.`
     );
   }
@@ -16602,8 +17083,8 @@ async function sessionRun(session, inputs) {
         return [k, unpacked];
       })
     );
-    console.error(`An error occurred during model execution: "${e}".`);
-    console.error("Inputs given to model:", formatted);
+    logger.error(`An error occurred during model execution: "${e}".`);
+    logger.error("Inputs given to model:", formatted);
     throw e;
   }
 }
@@ -16627,7 +17108,7 @@ function validateInputs(session, inputs) {
   const numInputsNeeded = session.inputNames.length;
   if (numInputsProvided > numInputsNeeded) {
     let ignored = Object.keys(inputs).filter((inputName) => !session.inputNames.includes(inputName));
-    console.warn(
+    logger.warn(
       `WARNING: Too many inputs were provided (${numInputsProvided} > ${numInputsNeeded}). The following inputs will be ignored: "${ignored.join(", ")}".`
     );
   }
@@ -17760,22 +18241,11 @@ var LogitsSampler = class extends Callable2 {
   }
   /**
    * Selects an item randomly based on the specified probabilities.
-   * @param {import("../transformers.js").DataArray} probabilities An array of probabilities to use for selection.
+   * @param {Float32Array} probabilities An array of probabilities to use for selection.
    * @returns {number} The index of the selected item.
    */
   randomSelect(probabilities) {
-    let sumProbabilities = 0;
-    for (let i = 0; i < probabilities.length; ++i) {
-      sumProbabilities += probabilities[i];
-    }
-    let r = Math.random() * sumProbabilities;
-    for (let i = 0; i < probabilities.length; ++i) {
-      r -= probabilities[i];
-      if (r <= 0) {
-        return i;
-      }
-    }
-    return 0;
+    return _weightedIndex(probabilities);
   }
   /**
    * Returns a Sampler object based on the specified options.
@@ -18281,7 +18751,7 @@ var PreTrainedModel = class extends Callable2 {
       if (modelType === void 0) {
         const type = modelName ?? config?.model_type;
         if (type !== "custom") {
-          console.warn(
+          logger.warn(
             `Model type for '${type}' not found, assuming encoder-only architecture. Please report this at ${GITHUB_ISSUE_URL}.`
           );
         }
@@ -18372,7 +18842,7 @@ var PreTrainedModel = class extends Callable2 {
       processors.push(new ClassifierFreeGuidanceLogitsProcessor(generation_config.guidance_scale));
     }
     if (generation_config.temperature === 0 && generation_config.do_sample) {
-      console.warn(
+      logger.warn(
         "`do_sample` changed to false because `temperature: 0` implies greedy sampling (always selecting the most likely token), which is incompatible with `do_sample: true`."
       );
       generation_config.do_sample = false;
@@ -18745,7 +19215,7 @@ var PreTrainedModel = class extends Callable2 {
     const pkvs = /* @__PURE__ */ Object.create(null);
     for (const name in decoderResults) {
       if (name.startsWith("present")) {
-        const newName = name.replace("present_ssm", "past_ssm").replace("present_conv", "past_conv").replace("present", "past_key_values");
+        const newName = name.replace("present_ssm", "past_ssm").replace("present_conv", "past_conv").replace("present_recurrent", "past_recurrent").replace("present", "past_key_values");
         const is_encoder_pkv = name.includes("encoder");
         if (is_encoder_pkv && pastKeyValues) {
           pkvs[newName] = pastKeyValues[newName];
@@ -18917,7 +19387,9 @@ async function generic_text_to_text_forward(self2, {
     }
   }
   if (!position_ids) {
-    if (self2.config.model_type === "qwen2_vl") {
+    if (["qwen2_vl", "qwen2_5_vl_text", "qwen3_vl_text", "qwen3_5_text", "qwen3_5_moe_text"].includes(
+      self2.config.model_type
+    )) {
       const { image_grid_thw, video_grid_thw } = kwargs;
       [position_ids] = self2.get_rope_index(input_ids, image_grid_thw, video_grid_thw, attention_mask);
     }
@@ -19099,6 +19571,9 @@ __export(models_exports, {
   ASTForAudioClassification: () => ASTForAudioClassification,
   ASTModel: () => ASTModel,
   ASTPreTrainedModel: () => ASTPreTrainedModel,
+  AfmoeForCausalLM: () => AfmoeForCausalLM,
+  AfmoeModel: () => AfmoeModel,
+  AfmoePreTrainedModel: () => AfmoePreTrainedModel,
   AlbertForMaskedLM: () => AlbertForMaskedLM,
   AlbertForQuestionAnswering: () => AlbertForQuestionAnswering,
   AlbertForSequenceClassification: () => AlbertForSequenceClassification,
@@ -19158,6 +19633,9 @@ __export(models_exports, {
   CodeGenForCausalLM: () => CodeGenForCausalLM,
   CodeGenModel: () => CodeGenModel,
   CodeGenPreTrainedModel: () => CodeGenPreTrainedModel,
+  Cohere2ForCausalLM: () => Cohere2ForCausalLM,
+  Cohere2Model: () => Cohere2Model,
+  Cohere2PreTrainedModel: () => Cohere2PreTrainedModel,
   CohereForCausalLM: () => CohereForCausalLM,
   CohereModel: () => CohereModel,
   CoherePreTrainedModel: () => CoherePreTrainedModel,
@@ -19503,9 +19981,13 @@ __export(models_exports, {
   Qwen2PreTrainedModel: () => Qwen2PreTrainedModel,
   Qwen2VLForConditionalGeneration: () => Qwen2VLForConditionalGeneration,
   Qwen2VLPreTrainedModel: () => Qwen2VLPreTrainedModel,
+  Qwen2_5_VLForConditionalGeneration: () => Qwen2_5_VLForConditionalGeneration,
   Qwen3ForCausalLM: () => Qwen3ForCausalLM,
   Qwen3Model: () => Qwen3Model,
   Qwen3PreTrainedModel: () => Qwen3PreTrainedModel,
+  Qwen3VLForConditionalGeneration: () => Qwen3VLForConditionalGeneration,
+  Qwen3_5ForConditionalGeneration: () => Qwen3_5ForConditionalGeneration,
+  Qwen3_5MoeForConditionalGeneration: () => Qwen3_5MoeForConditionalGeneration,
   RFDetrForObjectDetection: () => RFDetrForObjectDetection,
   RFDetrModel: () => RFDetrModel,
   RFDetrObjectDetectionOutput: () => RFDetrObjectDetectionOutput,
@@ -19716,6 +20198,14 @@ var ApertusModel = class extends ApertusPreTrainedModel {
 var ApertusForCausalLM = class extends ApertusPreTrainedModel {
 };
 
+// src/models/afmoe/modeling_afmoe.js
+var AfmoePreTrainedModel = class extends PreTrainedModel {
+};
+var AfmoeModel = class extends AfmoePreTrainedModel {
+};
+var AfmoeForCausalLM = class extends AfmoePreTrainedModel {
+};
+
 // src/models/arcee/modeling_arcee.js
 var ArceePreTrainedModel = class extends PreTrainedModel {
 };
@@ -20155,6 +20645,14 @@ var CohereModel = class extends CoherePreTrainedModel {
 var CohereForCausalLM = class extends CoherePreTrainedModel {
 };
 
+// src/models/cohere2/modeling_cohere2.js
+var Cohere2PreTrainedModel = class extends PreTrainedModel {
+};
+var Cohere2Model = class extends Cohere2PreTrainedModel {
+};
+var Cohere2ForCausalLM = class extends Cohere2PreTrainedModel {
+};
+
 // src/models/convbert/modeling_convbert.js
 var ConvBertPreTrainedModel = class extends PreTrainedModel {
 };
@@ -22267,6 +22765,7 @@ var Qwen2VLPreTrainedModel = class extends PreTrainedModel {
   ];
 };
 var Qwen2VLForConditionalGeneration = class extends Qwen2VLPreTrainedModel {
+  image_grid_thw_name = "grid_thw";
   /**
    * Calculate the 3D rope index based on image and video's temporal, height and width in LLM.
    *
@@ -22431,7 +22930,10 @@ var Qwen2VLForConditionalGeneration = class extends Qwen2VLPreTrainedModel {
     }
   }
   async encode_image({ pixel_values, image_grid_thw }) {
-    const features = (await sessionRun(this.sessions["vision_encoder"], { pixel_values, grid_thw: image_grid_thw })).image_features;
+    const features = (await sessionRun(this.sessions["vision_encoder"], {
+      pixel_values,
+      [this.image_grid_thw_name]: image_grid_thw
+    })).image_features;
     return features;
   }
   _merge_input_ids_with_image_features(kwargs) {
@@ -22461,6 +22963,11 @@ var Qwen2VLForConditionalGeneration = class extends Qwen2VLPreTrainedModel {
   }
 };
 
+// src/models/qwen2_5_vl/modeling_qwen2_5_vl.js
+var Qwen2_5_VLForConditionalGeneration = class extends Qwen2VLForConditionalGeneration {
+  image_grid_thw_name = "image_grid_thw";
+};
+
 // src/models/qwen3/modeling_qwen3.js
 var Qwen3PreTrainedModel = class extends PreTrainedModel {
 };
@@ -22469,6 +22976,18 @@ var Qwen3Model = class extends Qwen3PreTrainedModel {
 var Qwen3ForCausalLM = class extends Qwen3PreTrainedModel {
 };
 
+// src/models/qwen3_vl/modeling_qwen3_vl.js
+var Qwen3VLForConditionalGeneration = class extends Qwen2_5_VLForConditionalGeneration {
+};
+
+// src/models/qwen3_5/modeling_qwen3_5.js
+var Qwen3_5ForConditionalGeneration = class extends Qwen3VLForConditionalGeneration {
+};
+
+// src/models/qwen3_5_moe/modeling_qwen3_5_moe.js
+var Qwen3_5MoeForConditionalGeneration = class extends Qwen3_5ForConditionalGeneration {
+};
+
 // src/models/resnet/modeling_resnet.js
 var ResNetPreTrainedModel = class extends PreTrainedModel {
 };
@@ -23526,7 +24045,7 @@ var WhisperForConditionalGeneration = class extends WhisperPreTrainedModel {
     const task = generation_config.task;
     if (generation_config.is_multilingual) {
       if (!language) {
-        console.warn("No language specified - defaulting to English (en).");
+        logger.warn("No language specified - defaulting to English (en).");
         language = "en";
       }
       const language_code = whisper_language_to_code(language);
@@ -23541,7 +24060,7 @@ var WhisperForConditionalGeneration = class extends WhisperPreTrainedModel {
     if (!generation_config.return_timestamps && generation_config.no_timestamps_token_id && init_tokens.at(-1) !== generation_config.no_timestamps_token_id) {
       init_tokens.push(generation_config.no_timestamps_token_id);
     } else if (generation_config.return_timestamps && init_tokens.at(-1) === generation_config.no_timestamps_token_id) {
-      console.warn(
+      logger.warn(
         "<|notimestamps|> prompt token is removed from generation_config since `return_timestamps` is set to `true`."
       );
       init_tokens.pop();
@@ -23583,7 +24102,7 @@ var WhisperForConditionalGeneration = class extends WhisperPreTrainedModel {
         );
       }
       if (generation_config.task === "translate") {
-        console.warn("Token-level timestamps may not be reliable for task 'translate'.");
+        logger.warn("Token-level timestamps may not be reliable for task 'translate'.");
       }
       generation_config.output_attentions = true;
       generation_config.return_dict_in_generate = true;
@@ -23624,13 +24143,13 @@ var WhisperForConditionalGeneration = class extends WhisperPreTrainedModel {
       );
     }
     if (num_frames == null) {
-      console.warn(
+      logger.warn(
         "`num_frames` has not been set, meaning the entire audio will be analyzed. This may lead to inaccurate token-level timestamps for short audios (< 30 seconds)."
       );
     }
     let median_filter_width = this.config.median_filter_width;
     if (median_filter_width === void 0) {
-      console.warn("Model config has no `median_filter_width`, using default value of 7.");
+      logger.warn("Model config has no `median_filter_width`, using default value of 7.");
       median_filter_width = 7;
     }
     const batch = generate_outputs.cross_attentions;
@@ -23948,6 +24467,7 @@ var MODEL_MAPPING_NAMES_DECODER_ONLY = /* @__PURE__ */ new Map([
   ["apertus", "ApertusModel"],
   ["nanochat", "NanoChatModel"],
   ["arcee", "ArceeModel"],
+  ["afmoe", "AfmoeModel"],
   ["lfm2", "Lfm2Model"],
   ["lfm2_moe", "Lfm2MoeModel"],
   ["smollm3", "SmolLM3Model"],
@@ -23959,6 +24479,7 @@ var MODEL_MAPPING_NAMES_DECODER_ONLY = /* @__PURE__ */ new Map([
   ["granite", "GraniteModel"],
   ["granitemoehybrid", "GraniteMoeHybridModel"],
   ["cohere", "CohereModel"],
+  ["cohere2", "Cohere2Model"],
   ["gemma", "GemmaModel"],
   ["gemma2", "Gemma2Model"],
   ["vaultgemma", "VaultGemmaModel"],
@@ -24061,6 +24582,7 @@ var MODEL_FOR_CAUSAL_LM_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["apertus", "ApertusForCausalLM"],
   ["llama4_text", "Llama4ForCausalLM"],
   ["arcee", "ArceeForCausalLM"],
+  ["afmoe", "AfmoeForCausalLM"],
   ["lfm2", "Lfm2ForCausalLM"],
   ["lfm2_moe", "Lfm2MoeForCausalLM"],
   ["smollm3", "SmolLM3ForCausalLM"],
@@ -24072,6 +24594,7 @@ var MODEL_FOR_CAUSAL_LM_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["granite", "GraniteForCausalLM"],
   ["granitemoehybrid", "GraniteMoeHybridForCausalLM"],
   ["cohere", "CohereForCausalLM"],
+  ["cohere2", "Cohere2ForCausalLM"],
   ["gemma", "GemmaForCausalLM"],
   ["gemma2", "Gemma2ForCausalLM"],
   ["vaultgemma", "VaultGemmaForCausalLM"],
@@ -24150,7 +24673,11 @@ var MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES = /* @__PURE__ */ new Map([
   ["llava_onevision", "LlavaOnevisionForConditionalGeneration"],
   ["moondream1", "Moondream1ForConditionalGeneration"],
   ["florence2", "Florence2ForConditionalGeneration"],
-  ["qwen2-vl", "Qwen2VLForConditionalGeneration"],
+  ["qwen2_vl", "Qwen2VLForConditionalGeneration"],
+  ["qwen2_5_vl", "Qwen2_5_VLForConditionalGeneration"],
+  ["qwen3_vl", "Qwen3VLForConditionalGeneration"],
+  ["qwen3_5", "Qwen3_5ForConditionalGeneration"],
+  ["qwen3_5_moe", "Qwen3_5MoeForConditionalGeneration"],
   ["idefics3", "Idefics3ForConditionalGeneration"],
   ["smolvlm", "SmolVLMForConditionalGeneration"],
   ["paligemma", "PaliGemmaForConditionalGeneration"],
@@ -24456,7 +24983,7 @@ var PretrainedMixin = class {
     }
     if (this.BASE_IF_FAIL) {
       if (!CUSTOM_ARCHITECTURES.has(model_type)) {
-        console.warn(`Unknown model class "${model_type}", attempting to construct from base class.`);
+        logger.warn(`Unknown model class "${model_type}", attempting to construct from base class.`);
       }
       return await PreTrainedModel.from_pretrained(pretrained_model_name_or_path, options);
     } else {
@@ -24859,6 +25386,10 @@ function isChat(x) {
 }
 var TextGenerationPipeline = class extends /** @type {new (options: TextPipelineConstructorArgs) => TextGenerationPipelineType} */
 Pipeline {
+  /**
+   * @param {string | string[] | import('../tokenization_utils.js').Message[] | import('../tokenization_utils.js').Message[][]} texts
+   * @param {Partial<TextGenerationConfig>} generate_kwargs
+   */
   async _call(texts, generate_kwargs = {}) {
     let isBatched = false;
     let isChatInput = false;
@@ -24954,12 +25485,12 @@ Pipeline {
     );
     this.entailment_id = this.label2id["entailment"];
     if (this.entailment_id === void 0) {
-      console.warn("Could not find 'entailment' in label2id mapping. Using 2 as entailment_id.");
+      logger.warn("Could not find 'entailment' in label2id mapping. Using 2 as entailment_id.");
       this.entailment_id = 2;
     }
     this.contradiction_id = this.label2id["contradiction"] ?? this.label2id["not_entailment"];
     if (this.contradiction_id === void 0) {
-      console.warn("Could not find 'contradiction' in label2id mapping. Using 0 as contradiction_id.");
+      logger.warn("Could not find 'contradiction' in label2id mapping. Using 0 as contradiction_id.");
       this.contradiction_id = 0;
     }
   }
@@ -25097,10 +25628,10 @@ Pipeline {
   }
   async _call_wav2vec2(audio, kwargs) {
     if (kwargs.language) {
-      console.warn('`language` parameter is not yet supported for `wav2vec2` models, defaulting to "English".');
+      logger.warn('`language` parameter is not yet supported for `wav2vec2` models, defaulting to "English".');
     }
     if (kwargs.task) {
-      console.warn('`task` parameter is not yet supported for `wav2vec2` models, defaulting to "transcribe".');
+      logger.warn('`task` parameter is not yet supported for `wav2vec2` models, defaulting to "transcribe".');
     }
     const single = !Array.isArray(audio);
     const batchedAudio = single ? [audio] : audio;
@@ -25232,7 +25763,7 @@ Pipeline {
   }
   async _prepare_speaker_embeddings(speaker_embeddings, batch_size) {
     if (typeof speaker_embeddings === "string" || speaker_embeddings instanceof URL) {
-      speaker_embeddings = new Float32Array(await (await fetch(speaker_embeddings)).arrayBuffer());
+      speaker_embeddings = new Float32Array(await (await env.fetch(speaker_embeddings)).arrayBuffer());
     }
     if (speaker_embeddings instanceof Float32Array) {
       speaker_embeddings = new Tensor2("float32", speaker_embeddings, [speaker_embeddings.length]);
@@ -25318,7 +25849,7 @@ Pipeline {
   }
   async _call_text_to_spectrogram(text_inputs, { speaker_embeddings }) {
     if (!this.vocoder) {
-      console.log("No vocoder specified, using default HifiGan vocoder.");
+      logger.info("No vocoder specified, using default HifiGan vocoder.");
       this.vocoder = await AutoModel.from_pretrained(this.DEFAULT_VOCODER_ID, { dtype: "fp32" });
     }
     const { input_ids } = this.tokenizer(text_inputs, {
@@ -25785,7 +26316,7 @@ Pipeline {
   }
 };
 
-// src/pipelines.js
+// src/pipelines/index.js
 var SUPPORTED_TASKS = Object.freeze({
   "text-classification": {
     tokenizer: AutoTokenizer,
@@ -26081,7 +26612,191 @@ var TASK_ALIASES = Object.freeze({
   // Add for backwards compatibility
   embeddings: "feature-extraction"
 });
-async function pipeline3(task, model = null, {
+
+// src/utils/model_registry/get_model_files.js
+async function get_model_files(modelId, { config = null, dtype: overrideDtype = null, device: overrideDevice = null, model_file_name = null } = {}) {
+  config = await AutoConfig.from_pretrained(modelId, { config });
+  const files = [
+    // Add config.json (always loaded)
+    "config.json"
+  ];
+  const custom_config = config["transformers.js_config"] ?? {};
+  const use_external_data_format = custom_config.use_external_data_format;
+  const subfolder = "onnx";
+  const rawDevice = overrideDevice ?? custom_config.device;
+  let dtype = overrideDtype ?? custom_config.dtype;
+  let modelType;
+  const architectures = (
+    /** @type {string[]} */
+    config.architectures || []
+  );
+  let foundInMapping = false;
+  for (const arch of architectures) {
+    const mappedType = MODEL_TYPE_MAPPING.get(arch);
+    if (mappedType !== void 0) {
+      modelType = mappedType;
+      foundInMapping = true;
+      break;
+    }
+  }
+  if (!foundInMapping && config.model_type) {
+    const mappedType = MODEL_TYPE_MAPPING.get(config.model_type);
+    if (mappedType !== void 0) {
+      modelType = mappedType;
+      foundInMapping = true;
+    }
+  }
+  if (!foundInMapping) {
+    const archList = architectures.length > 0 ? architectures.join(", ") : "(none)";
+    logger.warn(
+      `[get_model_files] Architecture(s) not found in MODEL_TYPE_MAPPING: [${archList}] for model type '${config.model_type}'. Falling back to EncoderOnly (single model.onnx file). If you encounter issues, please report at: ${GITHUB_ISSUE_URL}`
+    );
+    modelType = MODEL_TYPES.EncoderOnly;
+  }
+  const add_model_file = (fileName, baseName = null) => {
+    baseName = baseName ?? fileName;
+    const selectedDevice = selectDevice(rawDevice, fileName);
+    const selectedDtype = selectDtype(dtype, fileName, selectedDevice);
+    const suffix = DEFAULT_DTYPE_SUFFIX_MAPPING[selectedDtype] ?? "";
+    const fullName = `${baseName}${suffix}.onnx`;
+    const fullPath = subfolder ? `${subfolder}/${fullName}` : fullName;
+    files.push(fullPath);
+    const num_chunks = resolveExternalDataFormat(use_external_data_format, fullName, fileName);
+    for (const dataFileName of getExternalDataChunkNames(fullName, num_chunks)) {
+      const dataFilePath = subfolder ? `${subfolder}/${dataFileName}` : dataFileName;
+      files.push(dataFilePath);
+    }
+  };
+  const singleModelName = model_file_name ?? "model";
+  if (modelType === MODEL_TYPES.DecoderOnly) {
+    add_model_file("model", singleModelName);
+    files.push("generation_config.json");
+  } else if (modelType === MODEL_TYPES.DecoderOnlyWithoutHead) {
+    add_model_file("model", singleModelName);
+  } else if (modelType === MODEL_TYPES.Seq2Seq || modelType === MODEL_TYPES.Vision2Seq) {
+    add_model_file("model", "encoder_model");
+    add_model_file("decoder_model_merged");
+    files.push("generation_config.json");
+  } else if (modelType === MODEL_TYPES.MaskGeneration) {
+    add_model_file("model", "vision_encoder");
+    add_model_file("prompt_encoder_mask_decoder");
+  } else if (modelType === MODEL_TYPES.EncoderDecoder) {
+    add_model_file("model", "encoder_model");
+    add_model_file("decoder_model_merged");
+  } else if (modelType === MODEL_TYPES.ImageTextToText) {
+    add_model_file("embed_tokens");
+    add_model_file("vision_encoder");
+    add_model_file("decoder_model_merged");
+    if (config.is_encoder_decoder) {
+      add_model_file("model", "encoder_model");
+    }
+    files.push("generation_config.json");
+  } else if (modelType === MODEL_TYPES.AudioTextToText) {
+    add_model_file("embed_tokens");
+    add_model_file("audio_encoder");
+    add_model_file("decoder_model_merged");
+    files.push("generation_config.json");
+  } else if (modelType === MODEL_TYPES.ImageAudioTextToText) {
+    add_model_file("embed_tokens");
+    add_model_file("audio_encoder");
+    add_model_file("vision_encoder");
+    add_model_file("decoder_model_merged");
+    files.push("generation_config.json");
+  } else if (modelType === MODEL_TYPES.Musicgen) {
+    add_model_file("model", "text_encoder");
+    add_model_file("decoder_model_merged");
+    add_model_file("encodec_decode");
+    files.push("generation_config.json");
+  } else if (modelType === MODEL_TYPES.MultiModality) {
+    add_model_file("prepare_inputs_embeds");
+    add_model_file("model", "language_model");
+    add_model_file("lm_head");
+    add_model_file("gen_head");
+    add_model_file("gen_img_embeds");
+    add_model_file("image_decode");
+    files.push("generation_config.json");
+  } else if (modelType === MODEL_TYPES.Phi3V) {
+    add_model_file("prepare_inputs_embeds");
+    add_model_file("model");
+    add_model_file("vision_encoder");
+    files.push("generation_config.json");
+  } else if (modelType === MODEL_TYPES.Chatterbox) {
+    add_model_file("embed_tokens");
+    add_model_file("speech_encoder");
+    add_model_file("model", "language_model");
+    add_model_file("conditional_decoder");
+    files.push("generation_config.json");
+  } else if (modelType === MODEL_TYPES.AutoEncoder) {
+    add_model_file("encoder_model");
+    add_model_file("decoder_model");
+  } else if (modelType === MODEL_TYPES.Supertonic) {
+    add_model_file("text_encoder");
+    add_model_file("latent_denoiser");
+    add_model_file("voice_decoder");
+  } else {
+    add_model_file("model", singleModelName);
+  }
+  return files;
+}
+
+// src/utils/model_registry/get_processor_files.js
+async function get_processor_files(modelId) {
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  const metadata = await get_file_metadata(modelId, IMAGE_PROCESSOR_NAME, {});
+  return metadata.exists ? [IMAGE_PROCESSOR_NAME] : [];
+}
+
+// src/utils/model_registry/get_files.js
+async function get_files(modelId, {
+  config = null,
+  dtype = null,
+  device = null,
+  model_file_name = null,
+  include_tokenizer = true,
+  include_processor = true
+} = {}) {
+  const files = await get_model_files(modelId, { config, dtype, device, model_file_name });
+  if (include_tokenizer) {
+    const tokenizerFiles = await get_tokenizer_files(modelId);
+    files.push(...tokenizerFiles);
+  }
+  if (include_processor) {
+    const processorFiles = await get_processor_files(modelId);
+    files.push(...processorFiles);
+  }
+  return files;
+}
+
+// src/utils/model_registry/get_pipeline_files.js
+function get_task_components(task) {
+  const taskConfig = SUPPORTED_TASKS[task];
+  if (!taskConfig) {
+    return null;
+  }
+  return {
+    tokenizer: !!taskConfig.tokenizer,
+    processor: !!taskConfig.processor
+  };
+}
+async function get_pipeline_files(task, modelId, options = {}) {
+  task = TASK_ALIASES[task] ?? task;
+  const components = get_task_components(task);
+  if (!components) {
+    throw new Error(
+      `Unsupported pipeline task: ${task}. Must be one of [${Object.keys(SUPPORTED_TASKS).join(", ")}]`
+    );
+  }
+  return get_files(modelId, {
+    ...options,
+    include_tokenizer: components.tokenizer,
+    include_processor: components.processor
+  });
+}
+
+// src/pipelines.js
+async function pipeline2(task, model = null, {
   progress_callback = null,
   config = null,
   cache_dir = null,
@@ -26101,13 +26816,51 @@ async function pipeline3(task, model = null, {
   }
   if (!model) {
     model = pipelineInfo.default.model;
-    console.log(`No model specified. Using default model: "${model}".`);
+    logger.info(`No model specified. Using default model: "${model}".`);
     if (!dtype && pipelineInfo.default.dtype) {
       dtype = pipelineInfo.default.dtype;
     }
   }
+  let files_loading = {};
+  if (progress_callback) {
+    const expected_files = await get_pipeline_files(task, model, {
+      device,
+      dtype
+    });
+    const metadata = await Promise.all(expected_files.map(async (file) => get_file_metadata(model, file)));
+    metadata.forEach((m, i) => {
+      if (m.exists) {
+        files_loading[expected_files[i]] = {
+          loaded: 0,
+          total: m.size ?? 0
+        };
+      }
+    });
+  }
   const pretrainedOptions = {
-    progress_callback,
+    progress_callback: progress_callback ? (
+      /** @param {import('./utils/core.js').ProgressInfo} info */
+      (info) => {
+        if (info.status === "progress") {
+          files_loading[info.file] = {
+            loaded: info.loaded,
+            total: info.total
+          };
+          const loaded = Object.values(files_loading).reduce((acc, curr) => acc + curr.loaded, 0);
+          const total = Object.values(files_loading).reduce((acc, curr) => acc + curr.total, 0);
+          const progress = total > 0 ? loaded / total * 100 : 0;
+          progress_callback({
+            status: "progress_total",
+            name: info.name,
+            progress,
+            loaded,
+            total,
+            files: structuredClone(files_loading)
+          });
+        }
+        progress_callback(info);
+      }
+    ) : void 0,
     config,
     cache_dir,
     local_files_only,
@@ -26424,7 +27177,7 @@ async function load_video(src, { num_frames = null, fps = null } = {}) {
   }
   await new Promise((resolve) => video.onloadedmetadata = resolve);
   if (video.seekable.start(0) === video.seekable.end(0)) {
-    const response = await fetch(video.src);
+    const response = await env.fetch(video.src);
     const blob = await response.blob();
     video.src = URL.createObjectURL(blob);
     await new Promise((resolve) => video.onloadedmetadata = resolve);
@@ -26460,11 +27213,282 @@ async function load_video(src, { num_frames = null, fps = null } = {}) {
   video.remove();
   return new RawVideo(frames, duration);
 }
+
+// src/utils/model_registry/is_cached.js
+async function check_files_cache(modelId, files, options = {}) {
+  const cache = await getCache(options?.cache_dir);
+  if (!cache) {
+    const fileStatuses2 = files.map((filename) => ({ file: filename, cached: false }));
+    return { allCached: false, files: fileStatuses2 };
+  }
+  const fileStatuses = await Promise.all(
+    files.map(async (filename) => {
+      const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache);
+      const cached = await checkCachedResource(cache, localPath, proposedCacheKey);
+      return { file: filename, cached: !!cached };
+    })
+  );
+  return { allCached: fileStatuses.every((f) => f.cached), files: fileStatuses };
+}
+async function is_cached(modelId, options = {}) {
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  const files = await get_files(modelId, options);
+  return await check_files_cache(modelId, files, options);
+}
+async function is_pipeline_cached(task, modelId, options = {}) {
+  if (!task) {
+    throw new Error("task is required");
+  }
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  const files = await get_pipeline_files(task, modelId, options);
+  return await check_files_cache(modelId, files, options);
+}
+
+// src/utils/model_registry/clear_cache.js
+async function clear_files_from_cache(modelId, files, options = {}) {
+  const cache = await getCache(options?.cache_dir);
+  if (!cache) {
+    return {
+      filesDeleted: 0,
+      filesCached: 0,
+      files: files.map((filename) => ({ file: filename, deleted: false, wasCached: false }))
+    };
+  }
+  if (!cache.delete) {
+    throw new Error("Cache does not support delete operation");
+  }
+  const results = await Promise.all(
+    files.map(async (filename) => {
+      const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache);
+      const cached = await checkCachedResource(cache, localPath, proposedCacheKey);
+      const wasCached = !!cached;
+      let deleted = false;
+      if (wasCached) {
+        const deletedWithProposed = await cache.delete(proposedCacheKey);
+        const deletedWithLocal = !deletedWithProposed && proposedCacheKey !== localPath ? await cache.delete(localPath) : false;
+        deleted = deletedWithProposed || deletedWithLocal;
+      }
+      return { file: filename, deleted, wasCached };
+    })
+  );
+  return {
+    filesDeleted: results.filter((r) => r.deleted).length,
+    filesCached: results.filter((r) => r.wasCached).length,
+    files: results
+  };
+}
+async function clear_cache(modelId, options = {}) {
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  const files = await get_files(modelId, options);
+  return await clear_files_from_cache(modelId, files, options);
+}
+async function clear_pipeline_cache(task, modelId, options = {}) {
+  if (!task) {
+    throw new Error("task is required");
+  }
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  const files = await get_pipeline_files(task, modelId, options);
+  return await clear_files_from_cache(modelId, files, options);
+}
+
+// src/utils/model_registry/ModelRegistry.js
+var ModelRegistry = class {
+  /**
+   * Get all files (model, tokenizer, processor) needed for a model.
+   *
+   * @param {string} modelId - The model id (e.g., "onnx-community/bert-base-uncased-ONNX")
+   * @param {Object} [options] - Optional parameters
+   * @param {import('../../configs.js').PretrainedConfig} [options.config=null] - Pre-loaded config
+   * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
+   * @param {string} [options.model_file_name=null] - Override the model file name (excluding .onnx suffix)
+   * @param {boolean} [options.include_tokenizer=true] - Whether to check for tokenizer files
+   * @param {boolean} [options.include_processor=true] - Whether to check for processor files
+   * @returns {Promise<string[]>} Array of file paths
+   *
+   * @example
+   * const files = await ModelRegistry.get_files('onnx-community/gpt2-ONNX');
+   * console.log(files); // ['config.json', 'tokenizer.json', 'onnx/model_q4.onnx', ...]
+   */
+  static async get_files(modelId, options = {}) {
+    return get_files(modelId, options);
+  }
+  /**
+   * Get all files needed for a specific pipeline task.
+   * Automatically determines which components are needed based on the task.
+   *
+   * @param {string} task - The pipeline task (e.g., "text-generation", "background-removal")
+   * @param {string} modelId - The model id (e.g., "onnx-community/bert-base-uncased-ONNX")
+   * @param {Object} [options] - Optional parameters
+   * @param {import('../../configs.js').PretrainedConfig} [options.config=null] - Pre-loaded config
+   * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
+   * @param {string} [options.model_file_name=null] - Override the model file name (excluding .onnx suffix)
+   * @returns {Promise<string[]>} Array of file paths
+   *
+   * @example
+   * const files = await ModelRegistry.get_pipeline_files('text-generation', 'onnx-community/gpt2-ONNX');
+   * console.log(files); // ['config.json', 'tokenizer.json', 'onnx/model_q4.onnx', ...]
+   */
+  static async get_pipeline_files(task, modelId, options = {}) {
+    return get_pipeline_files(task, modelId, options);
+  }
+  /**
+   * Get model files needed for a specific model.
+   *
+   * @param {string} modelId - The model id
+   * @param {Object} [options] - Optional parameters
+   * @param {import('../../configs.js').PretrainedConfig} [options.config=null] - Pre-loaded config
+   * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
+   * @param {string} [options.model_file_name=null] - Override the model file name (excluding .onnx suffix)
+   * @returns {Promise<string[]>} Array of model file paths
+   *
+   * @example
+   * const files = await ModelRegistry.get_model_files('onnx-community/bert-base-uncased-ONNX');
+   * console.log(files); // ['config.json', 'onnx/model_q4.onnx', 'generation_config.json']
+   */
+  static async get_model_files(modelId, options = {}) {
+    return get_model_files(modelId, options);
+  }
+  /**
+   * Get tokenizer files needed for a specific model.
+   *
+   * @param {string} modelId - The model id
+   * @returns {Promise<string[]>} Array of tokenizer file paths
+   *
+   * @example
+   * const files = await ModelRegistry.get_tokenizer_files('onnx-community/gpt2-ONNX');
+   * console.log(files); // ['tokenizer.json', 'tokenizer_config.json']
+   */
+  static async get_tokenizer_files(modelId) {
+    return get_tokenizer_files(modelId);
+  }
+  /**
+   * Get processor files needed for a specific model.
+   *
+   * @param {string} modelId - The model id
+   * @returns {Promise<string[]>} Array of processor file paths
+   *
+   * @example
+   * const files = await ModelRegistry.get_processor_files('onnx-community/vit-base-patch16-224-ONNX');
+   * console.log(files); // ['preprocessor_config.json']
+   */
+  static async get_processor_files(modelId) {
+    return get_processor_files(modelId);
+  }
+  /**
+   * Check if a model and all its required files are cached.
+   *
+   * @param {string} modelId - The model id
+   * @param {Object} [options] - Optional parameters
+   * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
+   * @returns {Promise<import('./is_cached.js').CacheCheckResult>} Object with allCached boolean and files array with cache status
+   *
+   * @example
+   * const status = await ModelRegistry.is_cached('onnx-community/bert-base-uncased-ONNX');
+   * console.log(status.allCached); // true or false
+   */
+  static async is_cached(modelId, options = {}) {
+    return is_cached(modelId, options);
+  }
+  /**
+   * Check if all files for a specific pipeline task are cached.
+   * Automatically determines which components are needed based on the task.
+   *
+   * @param {string} task - The pipeline task (e.g., "text-generation", "background-removal")
+   * @param {string} modelId - The model id
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.cache_dir] - Custom cache directory
+   * @param {string} [options.revision] - Model revision (default: 'main')
+   * @param {import('../../configs.js').PretrainedConfig} [options.config] - Pre-loaded config
+   * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
+   * @returns {Promise<import('./is_cached.js').CacheCheckResult>} Object with allCached boolean and files array with cache status
+   *
+   * @example
+   * const status = await ModelRegistry.is_pipeline_cached('text-generation', 'onnx-community/gpt2-ONNX');
+   * console.log(status.allCached); // true or false
+   */
+  static async is_pipeline_cached(task, modelId, options = {}) {
+    return is_pipeline_cached(task, modelId, options);
+  }
+  /**
+   * Get metadata for a specific file without downloading it.
+   *
+   * @param {string} path_or_repo_id - Model id or path
+   * @param {string} filename - The file name
+   * @param {import('../hub.js').PretrainedOptions} [options] - Optional parameters
+   * @returns {Promise<{exists: boolean, size?: number, contentType?: string, fromCache?: boolean}>} File metadata
+   *
+   * @example
+   * const metadata = await ModelRegistry.get_file_metadata('onnx-community/gpt2-ONNX', 'config.json');
+   * console.log(metadata.exists, metadata.size); // true, 665
+   */
+  static async get_file_metadata(path_or_repo_id, filename, options = {}) {
+    return get_file_metadata(path_or_repo_id, filename, options);
+  }
+  /**
+   * Clears all cached files for a given model.
+   * Automatically determines which files are needed and removes them from the cache.
+   *
+   * @param {string} modelId - The model id (e.g., "onnx-community/gpt2-ONNX")
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.cache_dir] - Custom cache directory
+   * @param {string} [options.revision] - Model revision (default: 'main')
+   * @param {import('../../configs.js').PretrainedConfig} [options.config] - Pre-loaded config
+   * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device] - Override device
+   * @param {boolean} [options.include_tokenizer=true] - Whether to clear tokenizer files
+   * @param {boolean} [options.include_processor=true] - Whether to clear processor files
+   * @returns {Promise<import('./clear_cache.js').CacheClearResult>} Object with deletion statistics and file status
+   *
+   * @example
+   * const result = await ModelRegistry.clear_cache('onnx-community/bert-base-uncased-ONNX');
+   * console.log(`Deleted ${result.filesDeleted} of ${result.filesCached} cached files`);
+   */
+  static async clear_cache(modelId, options = {}) {
+    return clear_cache(modelId, options);
+  }
+  /**
+   * Clears all cached files for a specific pipeline task.
+   * Automatically determines which components are needed based on the task.
+   *
+   * @param {string} task - The pipeline task (e.g., "text-generation", "image-classification")
+   * @param {string} modelId - The model id (e.g., "onnx-community/gpt2-ONNX")
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.cache_dir] - Custom cache directory
+   * @param {string} [options.revision] - Model revision (default: 'main')
+   * @param {import('../../configs.js').PretrainedConfig} [options.config] - Pre-loaded config
+   * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype] - Override dtype
+   * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device] - Override device
+   * @returns {Promise<import('./clear_cache.js').CacheClearResult>} Object with deletion statistics and file status
+   *
+   * @example
+   * const result = await ModelRegistry.clear_pipeline_cache('text-generation', 'onnx-community/gpt2-ONNX');
+   * console.log(`Deleted ${result.filesDeleted} of ${result.filesCached} cached files`);
+   */
+  static async clear_pipeline_cache(task, modelId, options = {}) {
+    return clear_pipeline_cache(task, modelId, options);
+  }
+};
 export {
   ASTFeatureExtractor,
   ASTForAudioClassification,
   ASTModel,
   ASTPreTrainedModel,
+  AfmoeForCausalLM,
+  AfmoeModel,
+  AfmoePreTrainedModel,
   AlbertForMaskedLM,
   AlbertForQuestionAnswering,
   AlbertForSequenceClassification,
@@ -26583,6 +27607,9 @@ export {
   CodeGenPreTrainedModel,
   CodeGenTokenizer,
   CodeLlamaTokenizer,
+  Cohere2ForCausalLM,
+  Cohere2Model,
+  Cohere2PreTrainedModel,
   CohereForCausalLM,
   CohereModel,
   CoherePreTrainedModel,
@@ -26828,6 +27855,7 @@ export {
   LlavaPreTrainedModel,
   LlavaProcessor,
   LlavaQwen2ForCausalLM,
+  LogLevel,
   LogitsProcessor,
   LogitsProcessorList,
   LogitsWarper,
@@ -26927,6 +27955,7 @@ export {
   MobileViTV2ForImageClassification,
   MobileViTV2Model,
   MobileViTV2PreTrainedModel,
+  ModelRegistry,
   ModernBertDecoderForCausalLM,
   ModernBertDecoderModel,
   ModernBertDecoderPreTrainedModel,
@@ -27038,9 +28067,15 @@ export {
   Qwen2VLImageProcessor,
   Qwen2VLPreTrainedModel,
   Qwen2VLProcessor,
+  Qwen2_5_VLForConditionalGeneration,
+  Qwen2_5_VLProcessor,
   Qwen3ForCausalLM,
   Qwen3Model,
   Qwen3PreTrainedModel,
+  Qwen3VLForConditionalGeneration,
+  Qwen3VLProcessor,
+  Qwen3_5ForConditionalGeneration,
+  Qwen3_5MoeForConditionalGeneration,
   RFDetrForObjectDetection,
   RFDetrModel,
   RFDetrObjectDetectionOutput,
@@ -27293,10 +28328,11 @@ export {
   ones,
   ones_like,
   permute,
-  pipeline3 as pipeline,
+  pipeline2 as pipeline,
   quantize_embeddings,
   rand,
   randn,
+  random,
   read_audio,
   rfft,
   slice2 as slice,