@phenx-inc/ctlsurf 0.8.0 → 0.10.0

package/out/renderer/assets/{transformers.web-DtSCnG36.js → transformers.web-_PuZoIho.js}

@@ -11256,6 +11256,23 @@ function log_softmax(arr) {
     logSoftmaxArr
   );
 }
+function dot(arr1, arr2) {
+  let result = 0;
+  for (let i = 0; i < arr1.length; ++i) {
+    result += arr1[i] * arr2[i];
+  }
+  return result;
+}
+function cos_sim(arr1, arr2) {
+  const dotProduct = dot(arr1, arr2);
+  const magnitudeA = magnitude(arr1);
+  const magnitudeB = magnitude(arr2);
+  const cosineSimilarity = dotProduct / (magnitudeA * magnitudeB);
+  return cosineSimilarity;
+}
+function magnitude(arr) {
+  return Math.sqrt(arr.reduce((acc, val) => acc + val * val, 0));
+}
 function min2(arr) {
   if (arr.length === 0) throw Error("Array must not be empty");
   let min3 = arr[0];
@@ -14234,6 +14251,10 @@ async function matmul(a, b) {
   const op = await TensorOpRegistry.matmul;
   return await op({ a, b });
 }
+async function rfft(x, a) {
+  const op = await TensorOpRegistry.rfft;
+  return await op({ x, a });
+}
 async function topk(x, k2) {
   const op = await TensorOpRegistry.top_k;
   if (k2 == null) {
@@ -14254,7 +14275,7 @@ async function slice2(data, starts, ends, axes, steps) {
     s: arrayToIndexTensor(starts),
     e: arrayToIndexTensor(ends),
     a: arrayToIndexTensor(axes),
-    t: arrayToIndexTensor(new Array(axes.length).fill(1))
+    t: arrayToIndexTensor(steps ?? new Array(axes.length).fill(1))
   });
 }
 function mean_pooling(last_hidden_state, attention_mask) {
@@ -14282,6 +14303,37 @@ function mean_pooling(last_hidden_state, attention_mask) {
   }
   return new Tensor22(last_hidden_state.type, returnedData, shape);
 }
+function layer_norm(input, normalized_shape, { eps = 1e-5 } = {}) {
+  if (input.dims.length !== 2) {
+    throw new Error("`layer_norm` currently only supports 2D input.");
+  }
+  const [batchSize, featureDim] = input.dims;
+  if (normalized_shape.length !== 1 && normalized_shape[0] !== featureDim) {
+    throw new Error("`normalized_shape` must be a 1D array with shape `[input.dims[1]]`.");
+  }
+  const [std, mean2] = std_mean(input, 1, 0, true);
+  const stdData = (
+    /** @type {Float32Array} */
+    std.data
+  );
+  const meanData = (
+    /** @type {Float32Array} */
+    mean2.data
+  );
+  const inputData = (
+    /** @type {Float32Array} */
+    input.data
+  );
+  const returnedData = new inputData.constructor(inputData.length);
+  for (let i = 0; i < batchSize; ++i) {
+    const offset = i * featureDim;
+    for (let j = 0; j < featureDim; ++j) {
+      const offset2 = offset + j;
+      returnedData[offset2] = (inputData[offset2] - meanData[i]) / (stdData[i] + eps);
+    }
+  }
+  return new Tensor22(input.type, returnedData, input.dims);
+}
 function calc_squeeze_dims(dims, dim) {
   dims = dims.slice();
   if (dim === null) {
@@ -14497,6 +14549,14 @@ function zeros(size) {
 function zeros_like(tensor) {
   return zeros(tensor.dims);
 }
+function rand(size) {
+  const length = size.reduce((a, b) => a * b, 1);
+  return new Tensor22(
+    "float32",
+    Float32Array.from({ length }, () => random.random()),
+    size
+  );
+}
 function randn(size) {
   const length = size.reduce((a, b) => a * b, 1);
   return new Tensor22(
@@ -18627,7 +18687,7 @@ var RawImage = class _RawImage {
     });
   }
 };
-RawImage.read.bind(RawImage);
+var load_image = RawImage.read.bind(RawImage);
 function constraint_to_multiple_of(val, multiple, minVal = 0, maxVal = null) {
   const a = val / multiple;
   let x = bankers_round(a) * multiple;
@@ -23245,6 +23305,45 @@ var TemperatureLogitsWarper = class extends LogitsWarper {
     return logits;
   }
 };
+var TopPLogitsWarper = class extends LogitsWarper {
+  /**
+   * Create a `TopPLogitsWarper`.
+   * @param {number} top_p If set to < 1, only the smallest set of most probable tokens with
+   * probabilities that add up to `top_p` or higher are kept for generation.
+   * @param {Object} options Additional options for the top-p sampling.
+   * @param {number} [options.filter_value=-Infinity] All filtered values will be set to this float value.
+   * @param {number} [options.min_tokens_to_keep=1] Minimum number of tokens that cannot be filtered.
+   */
+  constructor(top_p, { filter_value = -Infinity, min_tokens_to_keep = 1 } = {}) {
+    super();
+    if (top_p < 0 || top_p > 1) {
+      throw new Error(`\`top_p\` must be a float > 0 and < 1, but is ${top_p}`);
+    }
+    if (!Number.isInteger(min_tokens_to_keep) || min_tokens_to_keep < 1) {
+      throw new Error(`\`min_tokens_to_keep\` must be a positive integer, but is ${min_tokens_to_keep}`);
+    }
+    this.top_p = top_p;
+    this.filter_value = filter_value;
+    this.min_tokens_to_keep = min_tokens_to_keep;
+  }
+};
+var TopKLogitsWarper = class extends LogitsWarper {
+  /**
+   * Create a `TopKLogitsWarper`.
+   * @param {number} top_k If set to > 0, only the top `top_k` tokens are kept for generation.
+   * @param {Object} options Additional options for the top-k sampling.
+   * @param {number} [options.filter_value=-Infinity] All filtered values will be set to this float value.
+   * @param {number} [options.min_tokens_to_keep=1] Minimum number of tokens that cannot be filtered.
+   */
+  constructor(top_k, { filter_value = -Infinity, min_tokens_to_keep = 1 } = {}) {
+    super();
+    if (!Number.isInteger(top_k) || top_k < 0) {
+      throw new Error(`\`top_k\` must be a positive integer, but is ${top_k}`);
+    }
+    this.top_k = Math.max(top_k, min_tokens_to_keep);
+    this.filter_value = filter_value;
+  }
+};
 var GenerationConfig = class {
   // Parameters that control the length of the output
   /**
@@ -23674,6 +23773,21 @@ var EosTokenCriteria = class extends StoppingCriteria {
     });
   }
 };
+var InterruptableStoppingCriteria = class extends StoppingCriteria {
+  constructor() {
+    super();
+    this.interrupted = false;
+  }
+  interrupt() {
+    this.interrupted = true;
+  }
+  reset() {
+    this.interrupted = false;
+  }
+  _call(input_ids, scores) {
+    return new Array(input_ids.length).fill(this.interrupted);
+  }
+};
 var LogitsSampler = class extends Callable {
   /**
    * Creates a new Sampler object with the specified generation config.
@@ -31064,48 +31178,48 @@ var AutoModelForObjectDetection = class extends PretrainedMixin {
 var AutoModelForZeroShotObjectDetection = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING_NAMES];
 };
-(class extends PretrainedMixin {
+var AutoModelForMaskGeneration = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_MASK_GENERATION_MAPPING_NAMES];
-});
+};
 var AutoModelForCTC = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_CTC_MAPPING_NAMES];
 };
 var AutoModelForAudioClassification = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES];
 };
-(class extends PretrainedMixin {
+var AutoModelForXVector = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_AUDIO_XVECTOR_MAPPING_NAMES];
-});
-(class extends PretrainedMixin {
+};
+var AutoModelForAudioFrameClassification = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING_NAMES];
-});
+};
 var AutoModelForDocumentQuestionAnswering = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES];
 };
-(class extends PretrainedMixin {
+var AutoModelForImageMatting = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_IMAGE_MATTING_MAPPING_NAMES];
-});
+};
 var AutoModelForImageToImage = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_IMAGE_TO_IMAGE_MAPPING_NAMES];
 };
 var AutoModelForDepthEstimation = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES];
 };
-(class extends PretrainedMixin {
+var AutoModelForNormalEstimation = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_NORMAL_ESTIMATION_MAPPING_NAMES];
-});
-(class extends PretrainedMixin {
+};
+var AutoModelForPoseEstimation = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_POSE_ESTIMATION_MAPPING_NAMES];
-});
+};
 var AutoModelForImageFeatureExtraction = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_IMAGE_FEATURE_EXTRACTION_MAPPING_NAMES];
 };
-(class extends PretrainedMixin {
+var AutoModelForImageTextToText = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES];
-});
-(class extends PretrainedMixin {
+};
+var AutoModelForAudioTextToText = class extends PretrainedMixin {
   static MODEL_CLASS_MAPPINGS = [MODEL_MAPPINGS.MODEL_FOR_AUDIO_TEXT_TO_TEXT_MAPPING_NAMES];
-});
+};
 async function prepareImages(images) {
   if (!Array.isArray(images)) {
     images = [images];
@@ -32752,7 +32866,674 @@ async function pipeline2(task, model = null, {
   const pipelineClass = pipelineInfo.pipeline;
   return new pipelineClass(results);
 }
-apis.IS_PROCESS_AVAILABLE ? (x) => process.stdout.write(x) : (x) => console.log(x);
+var is_chinese_char2 = (cp) => cp >= 19968 && cp <= 40959 || cp >= 13312 && cp <= 19903 || cp >= 131072 && cp <= 173791 || cp >= 173824 && cp <= 177983 || cp >= 177984 && cp <= 178207 || cp >= 178208 && cp <= 183983 || cp >= 63744 && cp <= 64255 || cp >= 194560 && cp <= 195103;
+var BaseStreamer = class {
+  /**
+   * Function that is called by `.generate()` to push new tokens
+   * @param {bigint[][]} value
+   */
+  put(value) {
+    throw Error("Not implemented");
+  }
+  /**
+   * Function that is called by `.generate()` to signal the end of generation
+   */
+  end() {
+    throw Error("Not implemented");
+  }
+};
+var stdout_write = apis.IS_PROCESS_AVAILABLE ? (x) => process.stdout.write(x) : (x) => console.log(x);
+var TextStreamer = class extends BaseStreamer {
+  /**
+   *
+   * @param {import('../tokenization_utils.js').PreTrainedTokenizer} tokenizer
+   * @param {Object} options
+   * @param {boolean} [options.skip_prompt=false] Whether to skip the prompt tokens
+   * @param {boolean} [options.skip_special_tokens=true] Whether to skip special tokens when decoding
+   * @param {function(string): void} [options.callback_function=null] Function to call when a piece of text is ready to display
+   * @param {function(bigint[]): void} [options.token_callback_function=null] Function to call when a new token is generated
+   * @param {Object} [options.decode_kwargs={}] Additional keyword arguments to pass to the tokenizer's decode method
+   */
+  constructor(tokenizer, {
+    skip_prompt = false,
+    callback_function = null,
+    token_callback_function = null,
+    skip_special_tokens = true,
+    decode_kwargs = {},
+    ...kwargs
+  } = {}) {
+    super();
+    this.tokenizer = tokenizer;
+    this.skip_prompt = skip_prompt;
+    this.callback_function = callback_function ?? stdout_write;
+    this.token_callback_function = token_callback_function;
+    this.decode_kwargs = { skip_special_tokens, ...decode_kwargs, ...kwargs };
+    this.token_cache = [];
+    this.print_len = 0;
+    this.next_tokens_are_prompt = true;
+    this.special_ids = new Set(this.tokenizer.all_special_ids.map(BigInt));
+  }
+  /**
+   * Receives tokens, decodes them, and prints them to stdout as soon as they form entire words.
+   * @param {bigint[][]} value
+   */
+  put(value) {
+    if (value.length > 1) {
+      throw Error("TextStreamer only supports batch size of 1");
+    }
+    const is_prompt = this.next_tokens_are_prompt;
+    if (is_prompt) {
+      this.next_tokens_are_prompt = false;
+      if (this.skip_prompt) return;
+    }
+    const tokens = value[0];
+    this.token_callback_function?.(tokens);
+    if (tokens.length === 1 && this.special_ids.has(tokens[0])) {
+      if (this.decode_kwargs.skip_special_tokens) return;
+      if (this.token_cache.length > 0) {
+        const text2 = this.tokenizer.decode(this.token_cache, this.decode_kwargs);
+        const printable_text2 = text2.slice(this.print_len);
+        this.on_finalized_text(printable_text2, false);
+        this.token_cache = [];
+        this.print_len = 0;
+      }
+      const special_text = this.tokenizer.decode(tokens, this.decode_kwargs);
+      this.on_finalized_text(special_text, false);
+      return;
+    }
+    this.token_cache = mergeArrays(this.token_cache, tokens);
+    const text = this.tokenizer.decode(this.token_cache, this.decode_kwargs);
+    let printable_text;
+    if (is_prompt || text.endsWith("\n")) {
+      printable_text = text.slice(this.print_len);
+      this.token_cache = [];
+      this.print_len = 0;
+    } else if (text.length > 0 && is_chinese_char2(text.charCodeAt(text.length - 1))) {
+      printable_text = text.slice(this.print_len);
+      this.print_len += printable_text.length;
+    } else {
+      printable_text = text.slice(this.print_len, text.lastIndexOf(" ") + 1);
+      this.print_len += printable_text.length;
+    }
+    this.on_finalized_text(printable_text, false);
+  }
+  /**
+   * Flushes any remaining cache and prints a newline to stdout.
+   */
+  end() {
+    let printable_text;
+    if (this.token_cache.length > 0) {
+      const text = this.tokenizer.decode(this.token_cache, this.decode_kwargs);
+      printable_text = text.slice(this.print_len);
+      this.token_cache = [];
+      this.print_len = 0;
+    } else {
+      printable_text = "";
+    }
+    this.next_tokens_are_prompt = true;
+    this.on_finalized_text(printable_text, true);
+  }
+  /**
+   * Prints the new text to stdout. If the stream is ending, also prints a newline.
+   * @param {string} text
+   * @param {boolean} stream_end
+   */
+  on_finalized_text(text, stream_end) {
+    if (text.length > 0) {
+      this.callback_function?.(text);
+    }
+    if (stream_end && this.callback_function === stdout_write && apis.IS_PROCESS_AVAILABLE) {
+      this.callback_function?.("\n");
+    }
+  }
+};
+var WhisperTextStreamer = class extends TextStreamer {
+  /**
+   * @param {import('../models/whisper/tokenization_whisper.js').WhisperTokenizer} tokenizer
+   * @param {Object} options
+   * @param {boolean} [options.skip_prompt=false] Whether to skip the prompt tokens
+   * @param {function(string): void} [options.callback_function=null] Function to call when a piece of text is ready to display
+   * @param {function(bigint[]): void} [options.token_callback_function=null] Function to call when a new token is generated
+   * @param {function(number): void} [options.on_chunk_start=null] Function to call when a new chunk starts
+   * @param {function(number): void} [options.on_chunk_end=null] Function to call when a chunk ends
+   * @param {function(): void} [options.on_finalize=null] Function to call when the stream is finalized
+   * @param {number} [options.time_precision=0.02] Precision of the timestamps
+   * @param {boolean} [options.skip_special_tokens=true] Whether to skip special tokens when decoding
+   * @param {Object} [options.decode_kwargs={}] Additional keyword arguments to pass to the tokenizer's decode method
+   */
+  constructor(tokenizer, {
+    skip_prompt = false,
+    callback_function = null,
+    token_callback_function = null,
+    on_chunk_start = null,
+    on_chunk_end = null,
+    on_finalize = null,
+    time_precision = 0.02,
+    skip_special_tokens = true,
+    decode_kwargs = {}
+  } = {}) {
+    super(tokenizer, {
+      skip_prompt,
+      skip_special_tokens,
+      callback_function,
+      token_callback_function,
+      decode_kwargs
+    });
+    this.timestamp_begin = tokenizer.timestamp_begin;
+    this.on_chunk_start = on_chunk_start;
+    this.on_chunk_end = on_chunk_end;
+    this.on_finalize = on_finalize;
+    this.time_precision = time_precision;
+    this.waiting_for_timestamp = false;
+  }
+  /**
+   * @param {bigint[][]} value
+   */
+  put(value) {
+    if (value.length > 1) {
+      throw Error("WhisperTextStreamer only supports batch size of 1");
+    }
+    const tokens = value[0];
+    if (tokens.length === 1) {
+      const offset = Number(tokens[0]) - this.timestamp_begin;
+      if (offset >= 0) {
+        const time = offset * this.time_precision;
+        if (this.waiting_for_timestamp) {
+          this.on_chunk_end?.(time);
+        } else {
+          this.on_chunk_start?.(time);
+        }
+        this.waiting_for_timestamp = !this.waiting_for_timestamp;
+        this.token_callback_function?.(tokens);
+        return;
+      }
+    }
+    return super.put(value);
+  }
+  end() {
+    super.end();
+    this.on_finalize?.();
+  }
+};
+var RawVideoFrame = class {
+  /**
+   * @param {RawImage} image
+   * @param {number} timestamp
+   */
+  constructor(image, timestamp) {
+    this.image = image;
+    this.timestamp = timestamp;
+  }
+};
+var RawVideo = class {
+  /**
+   * @param {RawVideoFrame[]|RawImage[]} frames
+   * @param {number} duration
+   */
+  constructor(frames, duration) {
+    if (frames.length > 0 && frames[0] instanceof RawImage) {
+      frames = frames.map((image, i) => new RawVideoFrame(image, (i + 1) / (frames.length + 1) * duration));
+    }
+    this.frames = /** @type {RawVideoFrame[]} */
+    frames;
+    this.duration = duration;
+  }
+  get width() {
+    return this.frames[0].image.width;
+  }
+  get height() {
+    return this.frames[0].image.height;
+  }
+  get fps() {
+    return this.frames.length / this.duration;
+  }
+};
+async function load_video(src, { num_frames = null, fps = null } = {}) {
+  if (!apis.IS_BROWSER_ENV) {
+    throw new Error("`load_video` is currently only supported in browser environments.");
+  }
+  if (num_frames == null && fps == null) {
+    throw new Error("Either num_frames or fps must be provided.");
+  }
+  const frames = [];
+  const video = document.createElement("video");
+  video.crossOrigin = "anonymous";
+  video.muted = true;
+  if (typeof src === "string") {
+    video.src = src;
+  } else if (src instanceof Blob) {
+    video.src = URL.createObjectURL(src);
+  } else if (src instanceof HTMLVideoElement) {
+    video.src = src.src;
+  } else {
+    throw new Error("Invalid URL or video element provided.");
+  }
+  await new Promise((resolve) => video.onloadedmetadata = resolve);
+  if (video.seekable.start(0) === video.seekable.end(0)) {
+    const response = await env.fetch(video.src);
+    const blob = await response.blob();
+    video.src = URL.createObjectURL(blob);
+    await new Promise((resolve) => video.onloadedmetadata = resolve);
+  }
+  const duration = video.duration;
+  let count2, step;
+  if (num_frames != null) {
+    count2 = num_frames;
+    step = num_frames === 1 ? 0 : duration / (num_frames - 1);
+  } else {
+    step = 1 / fps;
+    count2 = Math.floor(duration / step);
+  }
+  let sampleTimes = [];
+  for (let i = 0; i < count2; ++i) {
+    sampleTimes.push(num_frames === 1 ? duration / 2 : i * step);
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = video.videoWidth;
+  canvas.height = video.videoHeight;
+  const ctx = canvas.getContext("2d", { willReadFrequently: true });
+  for (const t of sampleTimes) {
+    video.currentTime = t;
+    await new Promise((resolve) => {
+      video.onseeked = resolve;
+    });
+    ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    const frameData = new RawImage(imageData.data, canvas.width, canvas.height, 4);
+    const frame = new RawVideoFrame(frameData, t);
+    frames.push(frame);
+  }
+  video.remove();
+  return new RawVideo(frames, duration);
+}
+async function check_files_cache(modelId, files, options = {}) {
+  const cache2 = await getCache(options?.cache_dir);
+  if (!cache2) {
+    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, cache2);
+      const cached = await checkCachedResource(cache2, localPath, proposedCacheKey);
+      return { file: filename, cached: !!cached };
+    })
+  );
+  return { allCached: fileStatuses.every((f) => f.cached), files: fileStatuses };
+}
+async function is_file_cached(modelId, filename, options = {}) {
+  const cache2 = await getCache(options?.cache_dir);
+  if (!cache2) return false;
+  const { localPath, proposedCacheKey } = buildResourcePaths(modelId, filename, options, cache2);
+  return !!await checkCachedResource(cache2, localPath, proposedCacheKey);
+}
+async function is_cached(modelId, options = {}) {
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  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;
+}
+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);
+}
+async function is_pipeline_cached(task, modelId, options = {}) {
+  if (!task) {
+    throw new Error("task is required");
+  }
+  if (!modelId) {
+    throw new Error("modelId is required");
+  }
+  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;
+}
+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);
+}
+async function clear_files_from_cache(modelId, files, options = {}) {
+  const cache2 = await getCache(options?.cache_dir);
+  if (!cache2) {
+    return {
+      filesDeleted: 0,
+      filesCached: 0,
+      files: files.map((filename) => ({ file: filename, deleted: false, wasCached: false }))
+    };
+  }
+  if (!cache2.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, cache2);
+      const cached = await checkCachedResource(cache2, localPath, proposedCacheKey);
+      const wasCached = !!cached;
+      let deleted = false;
+      if (wasCached) {
+        const deletedWithProposed = await cache2.delete(proposedCacheKey);
+        const deletedWithLocal = !deletedWithProposed && proposedCacheKey !== localPath ? await cache2.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);
+}
+var CONCRETE_DTYPES = Object.keys(DEFAULT_DTYPE_SUFFIX_MAPPING);
+async function get_available_dtypes(modelId, { config = null, model_file_name = null, revision = "main", cache_dir = null, local_files_only = false } = {}) {
+  config = await get_config(modelId, { config, cache_dir, local_files_only, revision });
+  const subfolder = "onnx";
+  const modelType = resolve_model_type(config);
+  const { sessions } = getSessionsConfig(modelType, config, { model_file_name });
+  const baseNames = Object.values(sessions);
+  const metadataOptions = { revision, cache_dir, local_files_only };
+  const probeResults = await Promise.all(
+    CONCRETE_DTYPES.map(async (dtype) => {
+      const suffix = DEFAULT_DTYPE_SUFFIX_MAPPING[dtype] ?? "";
+      const allExist = await Promise.all(
+        baseNames.map(async (baseName) => {
+          const filename = `${subfolder}/${baseName}${suffix}.onnx`;
+          const metadata = await get_file_metadata(modelId, filename, metadataOptions);
+          return metadata.exists;
+        })
+      );
+      return { dtype, available: allExist.every(Boolean) };
+    })
+  );
+  return probeResults.filter((r) => r.available).map((r) => r.dtype);
+}
+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);
+  }
+  /**
+   * Detects which quantization levels (dtypes) are available for a model
+   * by checking which ONNX files exist on the hub or locally.
+   *
+   * A dtype is considered available if all required model session files
+   * exist for that dtype.
+   *
+   * @param {string} modelId - The model id (e.g., "onnx-community/all-MiniLM-L6-v2-ONNX")
+   * @param {Object} [options] - Optional parameters
+   * @param {import('../../configs.js').PretrainedConfig} [options.config=null] - Pre-loaded config
+   * @param {string} [options.model_file_name=null] - Override the model file name (excluding .onnx suffix)
+   * @param {string} [options.revision='main'] - Model revision
+   * @param {string} [options.cache_dir=null] - Custom cache directory
+   * @param {boolean} [options.local_files_only=false] - Only check local files
+   * @returns {Promise<string[]>} Array of available dtype strings (e.g., ['fp32', 'fp16', 'q4', 'q8'])
+   *
+   * @example
+   * const dtypes = await ModelRegistry.get_available_dtypes('onnx-community/all-MiniLM-L6-v2-ONNX');
+   * console.log(dtypes); // ['fp32', 'fp16', 'int8', 'uint8', 'q8', 'q4']
+   */
+  static async get_available_dtypes(modelId, options = {}) {
+    return get_available_dtypes(modelId, options);
+  }
+  /**
+   * Quickly checks if a model is fully cached by verifying `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
+   * @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<boolean>} Whether all required files are cached
+   *
+   * @example
+   * const cached = await ModelRegistry.is_cached('onnx-community/bert-base-uncased-ONNX');
+   * console.log(cached); // true or false
+   */
+  static async is_cached(modelId, options = {}) {
+    return is_cached(modelId, options);
+  }
+  /**
+   * 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
+   * @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_cached_files('onnx-community/bert-base-uncased-ONNX');
+   * console.log(status.allCached); // true or false
+   * console.log(status.files); // [{ file: 'config.json', cached: true }, ...]
+   */
+  static async is_cached_files(modelId, options = {}) {
+    return is_cached_files(modelId, options);
+  }
+  /**
+   * Quickly checks if all files for a specific pipeline task are cached by verifying
+   * `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", "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<boolean>} Whether all required files are cached
+   *
+   * @example
+   * const cached = await ModelRegistry.is_pipeline_cached('text-generation', 'onnx-community/gpt2-ONNX');
+   * console.log(cached); // true or false
+   */
+  static async is_pipeline_cached(task, modelId, options = {}) {
+    return is_pipeline_cached(task, modelId, options);
+  }
+  /**
+   * 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", "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_files('text-generation', 'onnx-community/gpt2-ONNX');
+   * console.log(status.allCached); // true or false
+   * console.log(status.files); // [{ file: 'config.json', cached: true }, ...]
+   */
+  static async is_pipeline_cached_files(task, modelId, options = {}) {
+    return is_pipeline_cached_files(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,
@@ -32779,16 +33560,23 @@ export {
   AutoImageProcessor,
   AutoModel,
   AutoModelForAudioClassification,
+  AutoModelForAudioFrameClassification,
+  AutoModelForAudioTextToText,
   AutoModelForCTC,
   AutoModelForCausalLM,
   AutoModelForDepthEstimation,
   AutoModelForDocumentQuestionAnswering,
   AutoModelForImageClassification,
   AutoModelForImageFeatureExtraction,
+  AutoModelForImageMatting,
   AutoModelForImageSegmentation,
+  AutoModelForImageTextToText,
   AutoModelForImageToImage,
+  AutoModelForMaskGeneration,
   AutoModelForMaskedLM,
+  AutoModelForNormalEstimation,
   AutoModelForObjectDetection,
+  AutoModelForPoseEstimation,
   AutoModelForQuestionAnswering,
   AutoModelForSemanticSegmentation,
   AutoModelForSeq2SeqLM,
@@ -32799,6 +33587,7 @@ export {
   AutoModelForTokenClassification,
   AutoModelForUniversalSegmentation,
   AutoModelForVision2Seq,
+  AutoModelForXVector,
   AutoModelForZeroShotObjectDetection,
   AutoProcessor,
   AutoTokenizer,
@@ -32809,6 +33598,7 @@ export {
   BartModel,
   BartPretrainedModel,
   BartTokenizer,
+  BaseStreamer,
   BeitFeatureExtractor,
   BeitForImageClassification,
   BeitModel,
@@ -33124,6 +33914,7 @@ export {
   ImageSegmentationPipeline,
   ImageToImagePipeline,
   ImageToTextPipeline,
+  InterruptableStoppingCriteria,
   JAISLMHeadModel,
   JAISModel,
   JAISPreTrainedModel,
@@ -33259,6 +34050,7 @@ export {
   MobileViTV2ForImageClassification,
   MobileViTV2Model,
   MobileViTV2PreTrainedModel,
+  ModelRegistry,
   ModernBertDecoderForCausalLM,
   ModernBertDecoderModel,
   ModernBertDecoderPreTrainedModel,
@@ -33418,6 +34210,8 @@ export {
   RTDetrV2PreTrainedModel,
   RawAudio,
   RawImage,
+  RawVideo,
+  RawVideoFrame,
   RepetitionPenaltyLogitsProcessor,
   ResNetForImageClassification,
   ResNetModel,
@@ -33532,9 +34326,12 @@ export {
   Text2TextGenerationPipeline,
   TextClassificationPipeline,
   TextGenerationPipeline,
+  TextStreamer,
   TextToAudioPipeline,
   TokenClassificationPipeline,
   PreTrainedTokenizer as TokenizersBackend,
+  TopKLogitsWarper,
+  TopPLogitsWarper,
   TrOCRForCausalLM,
   TrOCRPreTrainedModel,
   TranslationPipeline,
@@ -33609,6 +34406,7 @@ export {
   WhisperModel,
   WhisperPreTrainedModel,
   WhisperProcessor,
+  WhisperTextStreamer,
   WhisperTimeStampLogitsProcessor,
   WhisperTokenizer,
   XLMForQuestionAnswering,
@@ -33640,12 +34438,17 @@ export {
   ZeroShotImageClassificationPipeline,
   ZeroShotObjectDetectionPipeline,
   cat,
+  cos_sim,
+  dot,
   env,
   full,
   full_like,
   interpolate,
   interpolate_4d,
+  layer_norm,
   load_audio,
+  load_image,
+  load_video,
   log_softmax,
   matmul,
   mean,
@@ -33655,9 +34458,11 @@ export {
   permute,
   pipeline2 as pipeline,
   quantize_embeddings,
+  rand,
   randn,
   random,
   read_audio,
+  rfft,
   slice2 as slice,
   softmax,
   stack,