@huggingface/transformers 4.0.0-next.0 → 4.0.0-next.10

package/src/utils/model_registry/is_cached.js

@@ -0,0 +1,169 @@
+import { getCache } from '../cache.js';
+import { buildResourcePaths, checkCachedResource } from '../hub.js';
+import { get_files } from './get_files.js';
+import { get_pipeline_files } from './get_pipeline_files.js';
+
+/**
+ * @typedef {Object} FileCacheStatus
+ * @property {string} file - The file path
+ * @property {boolean} cached - Whether the file is cached
+ */
+
+/**
+ * @typedef {Object} CacheCheckResult
+ * @property {boolean} allCached - Whether all files are cached
+ * @property {FileCacheStatus[]} files - Array of files with their cache status
+ */
+
+/**
+ * Internal helper to check cache status for a list of files
+ * @private
+ * @param {string} modelId - The model id
+ * @param {string[]} files - List of file paths to check
+ * @param {Object} options - Options including cache_dir
+ * @returns {Promise<CacheCheckResult>}
+ */
+async function check_files_cache(modelId, files, options = {}) {
+    const cache = await getCache(options?.cache_dir);
+
+    if (!cache) {
+        const fileStatuses = files.map((filename) => ({ file: filename, cached: false }));
+        // No cache available, all files considered not cached
+        return { allCached: false, files: fileStatuses };
+    }
+
+    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 };
+}
+
+/**
+ * Internal helper to check whether a single file is cached.
+ * @private
+ * @param {string} modelId - The model id
+ * @param {string} filename - The file path to check
+ * @param {Object} options - Options including cache_dir
+ * @returns {Promise<boolean>}
+ */
+async function is_file_cached(modelId, filename, options = {}) {
+    const cache = await getCache(options?.cache_dir);
+    if (!cache) return false;
+    const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache);
+    return !!(await checkCachedResource(cache, localPath, proposedCacheKey));
+}
+
+/**
+ * Quickly checks if a model is cached by verifying that `config.json` is present,
+ * then confirming all required files are cached.
+ * Returns a plain boolean — use `is_cached_files` if you need per-file detail.
+ *
+ * @param {string} modelId The model id (e.g., "Xenova/gpt2")
+ * @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<boolean>} Whether all required files are cached
+ */
+export async function is_cached(modelId, options = {}) {
+    if (!modelId) {
+        throw new Error('modelId is required');
+    }
+
+    // Fast early-exit: if config.json is missing we can expect the rest not to be cached too.
+    if (!(await is_file_cached(modelId, 'config.json', options))) {
+        return false;
+    }
+
+    const files = await get_files(modelId, options);
+    const result = await check_files_cache(modelId, files, options);
+    return result.allCached;
+}
+
+/**
+ * Checks if all files for a given model are already cached, with per-file detail.
+ * Automatically determines which files are needed using get_files().
+ *
+ * @param {string} modelId The model id (e.g., "Xenova/gpt2")
+ * @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<CacheCheckResult>} Object with allCached boolean and files array with cache status
+ */
+export async function is_cached_files(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);
+}
+
+/**
+ * Quickly checks if all files for a specific pipeline task are cached by verifying
+ * that `config.json` is present, then confirming all required files are cached.
+ * Returns a plain boolean — use `is_pipeline_cached_files` if you need per-file detail.
+ *
+ * @param {string} task - The pipeline task (e.g., "text-generation", "image-classification")
+ * @param {string} modelId - The model id (e.g., "Xenova/gpt2")
+ * @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<boolean>} Whether all required files are cached
+ */
+export async function is_pipeline_cached(task, modelId, options = {}) {
+    if (!task) {
+        throw new Error('task is required');
+    }
+    if (!modelId) {
+        throw new Error('modelId is required');
+    }
+
+    // Fast early-exit: if config.json is missing we can expect the rest not to be cached too.
+    if (!(await is_file_cached(modelId, 'config.json', options))) {
+        return false;
+    }
+
+    const files = await get_pipeline_files(task, modelId, options);
+    const result = await check_files_cache(modelId, files, options);
+    return result.allCached;
+}
+
+/**
+ * Checks if all files for a specific pipeline task are already cached, with per-file detail.
+ * 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., "Xenova/gpt2")
+ * @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<CacheCheckResult>} Object with allCached boolean and files array with cache status
+ */
+export async function is_pipeline_cached_files(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);
+}

package/src/utils/model_registry/resolve_model_type.js

@@ -0,0 +1,66 @@
+import { MODEL_MAPPING_NAMES, MODEL_TYPES, MODEL_TYPE_MAPPING } from '../../models/modeling_utils.js';
+import { GITHUB_ISSUE_URL } from '../constants.js';
+import { logger } from '../logger.js';
+
+/**
+ * @typedef {import('../../configs.js').PretrainedConfig} PretrainedConfig
+ */
+
+/**
+ * Resolves the model type (e.g., EncoderOnly, DecoderOnly, Seq2Seq, …) from a
+ * model config by checking architectures and model_type against the known
+ * MODEL_TYPE_MAPPING.
+ *
+ * Resolution order:
+ *   1. `config.architectures` entries looked up in MODEL_TYPE_MAPPING
+ *   2. `config.model_type` looked up directly in MODEL_TYPE_MAPPING
+ *   3. `config.model_type` looked up via MODEL_MAPPING_NAMES → architecture → MODEL_TYPE_MAPPING
+ *   4. Fallback to `MODEL_TYPES.EncoderOnly`
+ *
+ * @param {PretrainedConfig} config The model config object.
+ * @param {{ warn?: boolean }} [options] Set `warn` to false to suppress the
+ *   fallback warning (defaults to true).
+ * @returns {number} One of the MODEL_TYPES enum values.
+ */
+export function resolve_model_type(config, { warn = true } = {}) {
+    // @ts-ignore - architectures is set via Object.assign in PretrainedConfig constructor
+    const architectures = /** @type {string[]} */ (config.architectures || []);
+
+    // 1. Try architectures against MODEL_TYPE_MAPPING
+    for (const arch of architectures) {
+        const mappedType = MODEL_TYPE_MAPPING.get(arch);
+        if (mappedType !== undefined) {
+            return mappedType;
+        }
+    }
+
+    // 2. Try config.model_type directly
+    if (config.model_type) {
+        const mappedType = MODEL_TYPE_MAPPING.get(config.model_type);
+        if (mappedType !== undefined) {
+            return mappedType;
+        }
+
+        // 3. Try MODEL_MAPPING_NAMES as a last resort
+        for (const mapping of Object.values(MODEL_MAPPING_NAMES)) {
+            if (mapping.has(config.model_type)) {
+                const resolved = MODEL_TYPE_MAPPING.get(mapping.get(config.model_type));
+                if (resolved !== undefined) {
+                    return resolved;
+                }
+            }
+        }
+    }
+
+    // 4. Fallback
+    if (warn) {
+        const archList = architectures.length > 0 ? architectures.join(', ') : '(none)';
+        logger.warn(
+            `[resolve_model_type] 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}`,
+        );
+    }
+
+    return MODEL_TYPES.EncoderOnly;
+}

package/src/utils/random.js

@@ -0,0 +1,225 @@
+/**
+ * Let there be order amidst the chaos.
+ *
+ * This file implements Mersenne Twister 19937, matching Python's `random` module exactly for reproducibility.
+ *
+ * ```javascript
+ * import { random } from '@huggingface/transformers';
+ *
+ * random.seed(42);
+ * random.random();           // 0.6394267984578837  (matches Python)
+ * random.gauss(0, 1);        // normal-distributed value
+ * random.choices(['a','b'], [3, 1]);  // weighted pick
+ *
+ * const arr = [1, 2, 3, 4, 5];
+ * random.shuffle(arr);       // in-place Fisher-Yates shuffle
+ *
+ * // Use a separate instance to avoid affecting the global state:
+ * const rng = new random.Random(42);
+ * rng.random();              // 0.6394267984578837  (same seed, independent state)
+ * ```
+ *
+ * **Note on Reproducibility:**
+ * Similarly to the [Python random](https://docs.python.org/3/library/random.html#notes-on-reproducibility)
+ * module, it is useful to be able to reproduce the sequences given by a pseudo-random number generator.
+ * By reusing a seed value, the same sequence should be reproducible from run to run as long as multiple
+ * threads or asynchronous operations are not running concurrently.
+ *
+ * @module utils/random
+ */
+
+import { apis } from '../env.js';
+
+/**
+ * Mersenne Twister 19937 PRNG, matching Python's `random.Random` class exactly.
+ *
+ * Each instance has its own independent state, so seeding one instance does not
+ * affect any other instance or the global helper functions.
+ *
+ * @example
+ * const rng1 = new Random(42);
+ * const rng2 = new Random(42);
+ * rng1.random() === rng2.random(); // true (same seed, independent state)
+ */
+export class Random {
+    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 === undefined || 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 / 0x100000000)) key.push(v & 0xffffffff);
+        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] = 0x80000000;
+        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) {
+                // twist
+                const y = (mt[k] & 0x80000000) | (mt[(k + 1) % 624] & 0x7fffffff);
+                mt[k] = (mt[(k + 397) % 624] ^ (y >>> 1) ^ (y & 1 ? 0x9908b0df : 0)) >>> 0;
+            }
+            this._idx = 0;
+        }
+        let y = mt[this._idx++];
+        y ^= y >>> 11;
+        y ^= (y << 7) & 0x9d2c5680;
+        y ^= (y << 15) & 0xefc60000;
+        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.0 + (this._int32() >>> 6)) / 9007199254740992.0;
+    }
+
+    /**
+     * 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)];
+    }
+}
+
+/**
+ * Returns a random index into `weights`, where each index's probability
+ * is proportional to its weight. Uses a linear scan: O(n) time, O(1) memory.
+ *
+ * @param {() => number} randomFn A function returning a uniform random float in [0, 1).
+ * @param {ArrayLike<number>} weights Non-negative weights.
+ * @returns {number} A randomly selected index in `[0, weights.length)`.
+ */
+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; // floating-point guard
+}
+
+// Global default instance: mirrors the module-level functions in Python's `random` module.
+const _default = new Random();
+export const 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),
+});
+
+// Private helper function, used by LogitsSampler, but not exported as part of the public API.
+export const _weightedIndex = (weights) => _weightedIndexWith(random.random, weights);

package/src/utils/tensor.js

@@ -15,6 +15,8 @@ import { TensorOpRegistry } from '../ops/registry.js';
 
 import { DataTypeMap } from './dtypes.js';
 
+import { random } from './random.js';
+
 /**
  * @typedef {keyof typeof DataTypeMap} DataType
  * @typedef {import('./maths.js').AnyTypedArray | any[]} DataArray
@@ -504,11 +506,27 @@ export class Tensor {
         }
 
         const this_data = this.data;
-        const fn = (/** @type {number} */ a, /** @type {number} */ b) => a + b ** p;
+        const is_bigint = this_data instanceof BigInt64Array || this_data instanceof BigUint64Array;
+
+        if (is_bigint && p !== 1) {
+            throw Error(`Expected a floating point tensor as input. Got ${this.type}`);
+        }
+
+        let fn, zero;
+        if (is_bigint) {
+            fn = (/** @type {bigint} */ a, /** @type {bigint} */ b) => a + b;
+            zero = 0n;
+        } else {
+            fn = (/** @type {number} */ a, /** @type {number} */ b) => a + b ** p;
+            zero = 0;
+        }
 
         if (dim === null) {
             // @ts-ignore
-            const val = this_data.reduce(fn, 0) ** (1 / p);
+            let val = this_data.reduce(fn, zero);
+            if (p !== 1) {
+                val = val ** (1 / p);
+            }
             return new Tensor(this.type, [val], []);
         }
 
@@ -1591,7 +1609,7 @@ export function rand(size) {
     const length = size.reduce((a, b) => a * b, 1);
     return new Tensor(
         'float32',
-        Float32Array.from({ length }, () => Math.random()),
+        Float32Array.from({ length }, () => random.random()),
         size,
     );
 }
@@ -1603,26 +1621,11 @@ export function rand(size) {
  */
 export 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) {
-        // Box-Muller transform
-        const u = 1 - Math.random(); // Avoids log(0)
-        const v = Math.random();
-
-        const mag = Math.sqrt(-2.0 * Math.log(u));
-        const angle = 2.0 * Math.PI * v;
-
-        // Assign the first value
-        data[i] = mag * Math.cos(angle);
-
-        // Assign the second value (if valid index)
-        if (i + 1 < length) {
-            data[i + 1] = mag * Math.sin(angle);
-        }
-    }
-
-    return new Tensor('float32', data, size);
+    return new Tensor(
+        'float32',
+        Float32Array.from({ length }, () => random.gauss()),
+        size,
+    );
 }
 
 /**

package/src/utils/video.js

@@ -1,5 +1,5 @@
 import { RawImage } from './image.js';
-import { apis } from '../env.js';
+import { env, apis } from '../env.js';
 
 export class RawVideoFrame {
     /**
@@ -79,7 +79,7 @@ export async function load_video(src, { num_frames = null, fps = null } = {}) {
 
     if (video.seekable.start(0) === video.seekable.end(0)) {
         // Fallback: Download entire video if not seekable
-        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));

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

@@ -1 +1 @@
-{"version":3,"file":"onnx.d.ts","sourceRoot":"","sources":["../../src/backends/onnx.js"],"names":[],"mappings":"AAkHA;;;;GAIG;AACH,oDAHW,OAAO,qBAAqB,EAAE,UAAU,GAAC,MAAM,GAAC,IAAI,GAClD,sBAAsB,EAAE,CAmBpC;AAoFD;;;;;;GAMG;AACH,uDALW,UAAU,GAAC,MAAM,mBACjB,OAAO,oBAAoB,EAAE,gBAAgB,CAAC,cAAc,wBAE1D,OAAO,CAAC,OAAO,oBAAoB,EAAE,gBAAgB,GAAG;IAAE,MAAM,MAAQ;CAAE,CAAC,CAavF;AASD;;;;;GAKG;AACH,6CAJW,OAAO,oBAAoB,EAAE,gBAAgB,WAC7C,MAAM,CAAC,MAAM,EAAE,OAAO,oBAAoB,EAAE,MAAM,CAAC,GACjD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,oBAAoB,EAAE,MAAM,CAAC,CAAC,CAMxE;AAED;;;;GAIG;AACH,gCAHW,GAAG,GACD,OAAO,CAInB;AAsCD;;;GAGG;AACH,+BAFa,OAAO,CAKnB;;qCA3RY,OAAO,oBAAoB,EAAE,gBAAgB,CAAC,uBAAuB"}
+{"version":3,"file":"onnx.d.ts","sourceRoot":"","sources":["../../src/backends/onnx.js"],"names":[],"mappings":"AA2JA;;;;GAIG;AACH,oDAHW,OAAO,qBAAqB,EAAE,UAAU,GAAC,MAAM,GAAC,IAAI,GAClD,sBAAsB,EAAE,CAmBpC;AAqGD;;;;;;GAMG;AACH,uDALW,UAAU,GAAC,MAAM,mBACjB,OAAO,oBAAoB,EAAE,gBAAgB,CAAC,cAAc,wBAE1D,OAAO,CAAC,OAAO,oBAAoB,EAAE,gBAAgB,GAAG;IAAE,MAAM,MAAQ;CAAE,CAAC,CAcvF;AASD;;;;;GAKG;AACH,6CAJW,OAAO,oBAAoB,EAAE,gBAAgB,WAC7C,MAAM,CAAC,MAAM,EAAE,OAAO,oBAAoB,EAAE,MAAM,CAAC,GACjD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,oBAAoB,EAAE,MAAM,CAAC,CAAC,CAKxE;AAED;;;;GAIG;AACH,gCAHW,GAAG,GACD,OAAO,CAInB;AAID;;;GAGG;AACH,+BAFa,OAAO,CAKnB;;qCAjTY,OAAO,oBAAoB,EAAE,gBAAgB,CAAC,uBAAuB"}

package/types/backends/utils/cacheWasm.d.ts

@@ -5,24 +5,10 @@
  */
 export function loadWasmBinary(wasmURL: string): Promise<ArrayBuffer | null>;
 /**
- * Loads and caches the WASM Factory for ONNX Runtime.
+ * Loads and caches the WASM Factory (.mjs file) for ONNX Runtime.
+ * Creates a blob URL from cached content (when safe) to bridge Cache API with dynamic imports used in ORT.
  * @param {string} libURL The URL of the WASM Factory to load.
- * @returns {Promise<string|null>} The blob URL of the WASM Factory, or null if loading failed.
+ * @returns {Promise<string|null>} The blob URL (if enabled), original URL (if disabled), or null if loading failed.
  */
 export function loadWasmFactory(libURL: string): Promise<string | null>;
-/**
- * Checks if the given URL is a blob URL (created via URL.createObjectURL).
- * Blob URLs should not be cached as they are temporary in-memory references.
- * @param {string} url - The URL to check.
- * @returns {boolean} True if the URL is a blob URL, false otherwise.
- */
-export function isBlobURL(url: string): boolean;
-/**
- * Converts any URL to an absolute URL if needed.
- * If the URL is already absolute (http://, https://, or blob:), returns it unchanged (handled by new URL(...)).
- * Otherwise, resolves it relative to the current page location (browser) or module location (Node/Bun/Deno).
- * @param {string} url - The URL to convert (can be relative or absolute).
- * @returns {string} The absolute URL.
- */
-export function toAbsoluteURL(url: string): string;
 //# sourceMappingURL=cacheWasm.d.ts.map

package/types/backends/utils/cacheWasm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cacheWasm.d.ts","sourceRoot":"","sources":["../../../src/backends/utils/cacheWasm.js"],"names":[],"mappings":"AA8CA;;;;GAIG;AAEH,wCAJW,MAAM,GACJ,OAAO,CAAC,WAAW,GAAC,IAAI,CAAC,CAarC;AAED;;;;GAIG;AACH,wCAHW,MAAM,GACJ,OAAO,CAAC,MAAM,GAAC,IAAI,CAAC,CAiBhC;AAED;;;;;GAKG;AACH,+BAHW,MAAM,GACJ,OAAO,CAInB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAiBlB"}
+{"version":3,"file":"cacheWasm.d.ts","sourceRoot":"","sources":["../../../src/backends/utils/cacheWasm.js"],"names":[],"mappings":"AA+CA;;;;GAIG;AAEH,wCAJW,MAAM,GACJ,OAAO,CAAC,WAAW,GAAC,IAAI,CAAC,CAarC;AAED;;;;;GAKG;AACH,wCAHW,MAAM,GACJ,OAAO,CAAC,MAAM,GAAC,IAAI,CAAC,CA+BhC"}

package/types/cache_utils.d.ts

@@ -0,0 +1,29 @@
+export type DynamicCache = _DynamicCache & Record<string, Tensor>;
+/**
+ * @typedef {_DynamicCache & Record<string, Tensor>} DynamicCache
+ */
+export const DynamicCache: new (entries?: Record<string, Tensor>) => DynamicCache;
+/**
+ * A cache class that stores past key values as named tensors.
+ */
+declare class _DynamicCache {
+    /**
+     * Create a DynamicCache, optionally pre-populated with entries.
+     * @param {Record<string, Tensor>} [entries] Initial name→Tensor mappings.
+     */
+    constructor(entries?: Record<string, Tensor>);
+    /**
+     * Get the cached sequence length. This requires at least one attention cache entry to be present.
+     * @returns {number} The past sequence length.
+     */
+    get_seq_length(): number;
+    /**
+     * Dispose all contained tensors whose data resides on the GPU.
+     * Returns a promise that resolves when all disposals are complete.
+     * @returns {Promise<void>} Promise that resolves when all GPU tensors are disposed.
+     */
+    dispose(): Promise<void>;
+}
+import { Tensor } from './utils/tensor.js';
+export {};
+//# sourceMappingURL=cache_utils.d.ts.map

package/types/cache_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache_utils.d.ts","sourceRoot":"","sources":["../src/cache_utils.js"],"names":[],"mappings":"2BAwDa,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;AADnD;;GAEG;AAEH,2BAAuC,KAAK,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,YAAY,CAE3F;AA3DF;;GAEG;AACH;IACI;;;OAGG;IACH,sBAFW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAchC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAWlB;IAED;;;;OAIG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAUzB;CACJ;uBArDsB,mBAAmB"}

package/types/configs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../src/configs.js"],"names":[],"mappings":"AAuRA;;;;GAIG;AACH,uCAHW,gBAAgB,iBACd,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAiEpC;AA8ED;;;GAGG;AACH;IAwBI;;;;;;;;OAQG;IACH,sDANW,MAAM,yEACN,iBAAiB,GAGf,OAAO,CAAC,gBAAgB,CAAC,CAoBrC;IApCD;;;OAGG;IACH,6BAGC;IAnBD,0BAA0B;IAC1B,YADW,MAAM,GAAC,IAAI,CACJ;IAElB,sBAAsB;IACtB,oBADW,OAAO,CACS;IAE3B,qBAAqB;IACrB,yBADW,MAAM,CACO;IAExB,mCAAmC;IACnC,0BADW,oBAAoB,CACN;IAQrB,uBAAkD;CA+BzD;AAED;;;;;GAKG;AACH;IApCI;;;;;;;;OAQG;IACH,sDANW,MAAM,yEACN,iBAAiB,GAGf,OAAO,CAAC,gBAAgB,CAAC,CAoBrC;CAcJ;gCA9cY,OAAO,gBAAgB,EAAE,iBAAiB;+BAI1C,OAAO,iBAAiB,EAAE,gBAAgB;2BAI1C,OAAO,iBAAiB,EAAE,YAAY;;;;;;;;oBA2crC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,YAAY,CAAC;;;;qBAC7D,OAAO,mBAAmB,EAAE,QAAQ,GAAC,MAAM,CAAC,OAAO,mBAAmB,EAAE,QAAQ,EAAE,OAAO,mBAAmB,EAAE,QAAQ,CAAC,GAAC,OAAO;;;;;;+BAC/H,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;aAGtB,OAAO,oBAAoB,EAAE,UAAU;;;;YACvC,OAAO,mBAAmB,EAAE,QAAQ,GAAC,MAAM,CAAC,MAAM,EAAE,OAAO,mBAAmB,EAAE,QAAQ,CAAC;;;;+BACzF,OAAO,gBAAgB,EAAE,YAAY,GAAC,MAAM,CAAC,MAAM,EAAE,OAAO,gBAAgB,EAAE,YAAY,CAAC;;;;;2BAK5F,IAAI,CAAC,oBAAoB,EAAE,QAAQ,GAAG,eAAe,CAAC"}
+{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../src/configs.js"],"names":[],"mappings":"AAiUA;;;;GAIG;AACH,uCAHW,gBAAgB,iBACd,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CA2HpC;AA8ED;;;GAGG;AACH;IAwBI;;;;;;;;OAQG;IACH,sDANW,MAAM,yEACN,iBAAiB,GAGf,OAAO,CAAC,gBAAgB,CAAC,CAoBrC;IApCD;;;OAGG;IACH,6BAGC;IAnBD,0BAA0B;IAC1B,YADW,MAAM,GAAC,IAAI,CACJ;IAElB,sBAAsB;IACtB,oBADW,OAAO,CACS;IAE3B,qBAAqB;IACrB,yBADW,MAAM,CACO;IAExB,mCAAmC;IACnC,0BADW,oBAAoB,CACN;IAQrB,uBAAkD;CA+BzD;AAED;;;;;GAKG;AACH;IApCI;;;;;;;;OAQG;IACH,sDANW,MAAM,yEACN,iBAAiB,GAGf,OAAO,CAAC,gBAAgB,CAAC,CAoBrC;CAcJ;gCAljBY,OAAO,gBAAgB,EAAE,iBAAiB;+BAI1C,OAAO,iBAAiB,EAAE,gBAAgB;2BAI1C,OAAO,iBAAiB,EAAE,YAAY;;;;;;;;oBA+iBrC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,YAAY,CAAC;;;;qBAC7D,OAAO,mBAAmB,EAAE,QAAQ,GAAC,MAAM,CAAC,OAAO,mBAAmB,EAAE,QAAQ,EAAE,OAAO,mBAAmB,EAAE,QAAQ,CAAC,GAAC,OAAO;;;;;;+BAC/H,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;aAGtB,OAAO,oBAAoB,EAAE,UAAU;;;;YACvC,OAAO,mBAAmB,EAAE,QAAQ,GAAC,MAAM,CAAC,MAAM,EAAE,OAAO,mBAAmB,EAAE,QAAQ,CAAC;;;;+BACzF,OAAO,gBAAgB,EAAE,YAAY,GAAC,MAAM,CAAC,MAAM,EAAE,OAAO,gBAAgB,EAAE,YAAY,CAAC;;;;;2BAK5F,IAAI,CAAC,oBAAoB,EAAE,QAAQ,GAAG,eAAe,CAAC"}