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

package/types/models/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/models/registry.js"],"names":[],"mappings":"AA4KA,2EAKG;AAmDH,+EAUG;AAEH,oEAyDG;AA4CH,uEAIG;AA+JH,0EAwCE;AA6CF,oEAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAvZH,mFAqBG;AAEH,gFAgBG;AA/CH,+EAAuG;AAEvG,4EAIG;AAoHH,qEAmBG;AAEH,8EAiBG;AAmCH,gFAuBG;AAkBH,8EAIG;AAEH,iFASG;AAEH,kFAGG;AApCH,4EAQG;AAEH,sFAIG;AAwBH,2EAKG;AAEH,+DAQG;AAEH,gFAQG;AAEH,yEAAsF;AAEtF,sFAKG;AArGH,uFAEG;AAqGH,yEAAiG;AAOjG,0EAAwG;AAExG,4EAQG;AAEH,6EAAuG;AAEvG,2EAAmG;AAInG,oFAIG;AA3JH,8EAgBG;AAEH,8EAGG"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/models/registry.js"],"names":[],"mappings":"AAgLA,2EAKG;AAmDH,+EAUG;AAEH,oEAqEG;AA4CH,uEAIG;AAmKH,0EAwCE;AA2DF,4EAKG;AAMH,+CAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA3bjF,mFAqBG;AAEH,gFAgBG;AA/CH,+EAAuG;AAEvG,4EAIG;AAgIH,qEAmBG;AAEH,8EAiBG;AAuCH,gFAuBG;AAkBH,8EAIG;AAEH,iFASG;AAEH,kFAGG;AApCH,4EAQG;AAEH,sFAIG;AAwBH,2EAKG;AAEH,+DAQG;AAEH,gFAQG;AAEH,yEAAsF;AAEtF,sFAKG;AArGH,uFAEG;AAqGH,yEAAiG;AAOjG,0EAAwG;AAExG,4EAQG;AAEH,6EAAuG;AAEvG,2EAAmG;AAInG,oFAIG;AA/JH,8EAkBG;AAEH,8EAKG"}

package/types/models/sam/image_processing_sam.d.ts

@@ -1,5 +1,5 @@
 /**
- * @typedef {object} SamImageProcessorResult
+ * @typedef {Object} SamImageProcessorResult
  * @property {Tensor} pixel_values
  * @property {import("../../image_processors_utils.js").HeightWidth[]} original_sizes
  * @property {import("../../image_processors_utils.js").HeightWidth[]} reshaped_input_sizes

package/types/models/session.d.ts

@@ -4,11 +4,12 @@
  * @param {string} pretrained_model_name_or_path The path to the directory containing the model file.
  * @param {Record<string, string>} names The names of the model files to load.
  * @param {import('../utils/hub.js').PretrainedModelOptions} options Additional options for loading the model.
- * @param {string} [decoder_name] The name of the decoder model, if any.
+ * @param {Record<string, true>} [cache_sessions] A map from session name to `true`, indicating which
+ *   sessions should have GPU-pinned KV cache outputs.
  * @returns {Promise<Record<string, any>>} A Promise that resolves to a dictionary of InferenceSession objects.
  * @private
  */
-export function constructSessions(pretrained_model_name_or_path: string, names: Record<string, string>, options: import("../utils/hub.js").PretrainedModelOptions, decoder_name?: string): Promise<Record<string, any>>;
+export function constructSessions(pretrained_model_name_or_path: string, names: Record<string, string>, options: import("../utils/hub.js").PretrainedModelOptions, cache_sessions?: Record<string, true>): Promise<Record<string, any>>;
 /**
  * Executes an InferenceSession using the specified inputs.
  * NOTE: `inputs` must contain at least the input names of the model.

package/types/models/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/models/session.js"],"names":[],"mappings":"AA0IA;;;;;;;;;GASG;AACH,iEAPW,MAAM,SACN,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,WACtB,OAAO,iBAAiB,EAAE,sBAAsB,iBAChD,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAkBxC;AAmBD;;;;;;;;;;GAUG;AACH,uDAHa,OAAO,KAAQ,CA+C3B"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/models/session.js"],"names":[],"mappings":"AAkJA;;;;;;;;;;GAUG;AACH,iEARW,MAAM,SACN,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,WACtB,OAAO,iBAAiB,EAAE,sBAAsB,mBAChD,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAElB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAoBxC;AAmBD;;;;;;;;;;GAUG;AACH,uDAHa,OAAO,KAAQ,CA+C3B"}

package/types/models/smolvlm/modeling_smolvlm.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The SmolVLM Model with a language modeling head.
+ * It is made up a SigLIP vision encoder, with a language modeling head on top.
+ */
+export class SmolVLMForConditionalGeneration extends Idefics3ForConditionalGeneration {
+}
+import { Idefics3ForConditionalGeneration } from '../idefics3/modeling_idefics3.js';
+//# sourceMappingURL=modeling_smolvlm.d.ts.map

package/types/models/smolvlm/modeling_smolvlm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeling_smolvlm.d.ts","sourceRoot":"","sources":["../../../src/models/smolvlm/modeling_smolvlm.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;CAAwF;iDANvC,kCAAkC"}

package/types/models/ultravox/modeling_ultravox.d.ts

@@ -6,7 +6,5 @@ export class UltravoxModel extends UltravoxPreTrainedModel {
         attention_mask: any;
     };
 }
-export class VoxtralForConditionalGeneration extends UltravoxModel {
-}
 import { PreTrainedModel } from '../modeling_utils.js';
 //# sourceMappingURL=modeling_ultravox.d.ts.map

package/types/models/ultravox/modeling_ultravox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"modeling_ultravox.d.ts","sourceRoot":"","sources":["../../../src/models/ultravox/modeling_ultravox.js"],"names":[],"mappings":"AAEA;CAEC;AAED;IACI;;;MAUC;CACJ;AAED;CAAqE;gCApBQ,sBAAsB"}
+{"version":3,"file":"modeling_ultravox.d.ts","sourceRoot":"","sources":["../../../src/models/ultravox/modeling_ultravox.js"],"names":[],"mappings":"AAEA;CAEC;AAED;IACI;;;MAUC;CACJ;gCAlB4E,sBAAsB"}

package/types/models/voxtral/modeling_voxtral.d.ts

@@ -0,0 +1,4 @@
+export class VoxtralForConditionalGeneration extends UltravoxModel {
+}
+import { UltravoxModel } from '../ultravox/modeling_ultravox.js';
+//# sourceMappingURL=modeling_voxtral.d.ts.map

package/types/models/voxtral/modeling_voxtral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeling_voxtral.d.ts","sourceRoot":"","sources":["../../../src/models/voxtral/modeling_voxtral.js"],"names":[],"mappings":"AAEA;CAAqE;8BAFvC,kCAAkC"}

package/types/models/voxtral_realtime/feature_extraction_voxtral_realtime.d.ts

@@ -0,0 +1,28 @@
+export class VoxtralRealtimeFeatureExtractor extends FeatureExtractor {
+    constructor(config: any);
+    window: Float64Array<ArrayBufferLike>;
+    /**
+     * Computes the log-Mel spectrogram of the provided audio waveform.
+     * @param {Float32Array|Float64Array} waveform The audio waveform to process.
+     * @param {Object} [options]
+     * @param {boolean} [options.center=true] Whether to center-pad the waveform for STFT.
+     * @returns {Promise<import('../../utils/tensor.js').Tensor>} The log-Mel spectrogram tensor of shape [num_mel_bins, num_frames].
+     */
+    _extract_fbank_features(waveform: Float32Array | Float64Array, { center }?: {
+        center?: boolean;
+    }): Promise<import("../../utils/tensor.js").Tensor>;
+    /**
+     * Extract mel spectrogram features from audio.
+     * @param {Float32Array|Float64Array} audio The audio data.
+     * @param {Object} [options]
+     * @param {boolean} [options.center=true] Whether to center-pad the waveform.
+     * @returns {Promise<{ input_features: import('../../utils/tensor.js').Tensor }>}
+     */
+    _call(audio: Float32Array | Float64Array, { center }?: {
+        center?: boolean;
+    }): Promise<{
+        input_features: import("../../utils/tensor.js").Tensor;
+    }>;
+}
+import { FeatureExtractor } from '../../feature_extraction_utils.js';
+//# sourceMappingURL=feature_extraction_voxtral_realtime.d.ts.map

package/types/models/voxtral_realtime/feature_extraction_voxtral_realtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature_extraction_voxtral_realtime.d.ts","sourceRoot":"","sources":["../../../src/models/voxtral_realtime/feature_extraction_voxtral_realtime.js"],"names":[],"mappings":"AAGA;IACI,yBAcC;IADG,sCAAwD;IAG5D;;;;;;OAMG;IACH,kCALW,YAAY,GAAC,YAAY,eAEjC;QAA0B,MAAM,GAAxB,OAAO;KACf,GAAU,OAAO,CAAC,OAAO,uBAAuB,EAAE,MAAM,CAAC,CA2B3D;IAED;;;;;;OAMG;IACH,aALW,YAAY,GAAC,YAAY,eAEjC;QAA0B,MAAM,GAAxB,OAAO;KACf,GAAU,OAAO,CAAC;QAAE,cAAc,EAAE,OAAO,uBAAuB,EAAE,MAAM,CAAA;KAAE,CAAC,CAU/E;CACJ;iCAtEuD,mCAAmC"}

package/types/models/voxtral_realtime/modeling_voxtral_realtime.d.ts

@@ -0,0 +1,17 @@
+export class VoxtralRealtimePreTrainedModel extends PreTrainedModel {
+}
+export class VoxtralRealtimeForConditionalGeneration extends VoxtralRealtimePreTrainedModel {
+    forward({ input_ids, past_key_values, ...kwargs }: {
+        [x: string]: any;
+        input_ids: any;
+        past_key_values: any;
+    }): Promise<any>;
+    generate({ input_features, stopping_criteria: userStoppingCriteria, ...kwargs }: {
+        [x: string]: any;
+        input_features: any;
+        stopping_criteria: any;
+    }): Promise<Tensor | import("../modeling_outputs.js").ModelOutput>;
+}
+import { PreTrainedModel } from '../modeling_utils.js';
+import { Tensor } from '../../utils/tensor.js';
+//# sourceMappingURL=modeling_voxtral_realtime.d.ts.map

package/types/models/voxtral_realtime/modeling_voxtral_realtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeling_voxtral_realtime.d.ts","sourceRoot":"","sources":["../../../src/models/voxtral_realtime/modeling_voxtral_realtime.js"],"names":[],"mappings":"AA+LA;CAEC;AAED;IACI;;;;qBAoBC;IAED;;;;uEAmBC;CACJ;gCA9O+B,sBAAsB;uBAGzB,uBAAuB"}

package/types/models/voxtral_realtime/processing_voxtral_realtime.d.ts

@@ -0,0 +1,44 @@
+export class VoxtralRealtimeProcessor extends Processor {
+    static tokenizer_class: typeof AutoTokenizer;
+    static feature_extractor_class: typeof AutoFeatureExtractor;
+    /** Number of mel frames in the first audio chunk. */
+    get num_mel_frames_first_audio_chunk(): number;
+    /** Number of raw audio samples in the first audio chunk. */
+    get num_samples_first_audio_chunk(): number;
+    /** Number of raw audio samples per subsequent audio chunk. */
+    get num_samples_per_audio_chunk(): any;
+    /** Number of right-pad tokens for non-streaming mode. */
+    get num_right_pad_tokens(): number;
+    /** Number of mel frames per text token. */
+    get audio_length_per_tok(): number;
+    /** Number of raw audio samples per token. */
+    get raw_audio_length_per_tok(): number;
+    /**
+     * Process audio input for VoxtralRealtime.
+     *
+     * In streaming mode with `is_first_audio_chunk=true`, the audio is left-padded
+     * with silence and mel features are extracted with `center=true`.
+     * Returns `{ input_ids, input_features }`.
+     *
+     * In streaming mode with `is_first_audio_chunk=false`, the audio chunk is
+     * processed with `center=false` and only `{ input_features }` is returned.
+     *
+     * In non-streaming mode, the audio is right-padded to ensure the model
+     * transcribes the full audio, then processed with `center=true`.
+     * Returns `{ input_features }`.
+     *
+     * @param {Float32Array|Float64Array} audio The audio waveform.
+     * @param {Object} [options]
+     * @param {boolean} [options.is_streaming=false] Whether processing in streaming mode.
+     * @param {boolean} [options.is_first_audio_chunk=true] Whether this is the first audio chunk.
+     * @returns {Promise<Object>}
+     */
+    _call(audio: Float32Array | Float64Array, { is_streaming, is_first_audio_chunk }?: {
+        is_streaming?: boolean;
+        is_first_audio_chunk?: boolean;
+    }): Promise<any>;
+}
+import { Processor } from '../../processing_utils.js';
+import { AutoTokenizer } from '../auto/tokenization_auto.js';
+import { AutoFeatureExtractor } from '../auto/feature_extraction_auto.js';
+//# sourceMappingURL=processing_voxtral_realtime.d.ts.map

package/types/models/voxtral_realtime/processing_voxtral_realtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processing_voxtral_realtime.d.ts","sourceRoot":"","sources":["../../../src/models/voxtral_realtime/processing_voxtral_realtime.js"],"names":[],"mappings":"AAeA;IACI,6CAAuC;IACvC,4DAAsD;IAGtD,qDAAqD;IACrD,+CAEC;IAED,4DAA4D;IAC5D,4CAGC;IAED,8DAA8D;IAC9D,uCAGC;IAED,yDAAyD;IACzD,mCAEC;IAED,2CAA2C;IAC3C,mCAEC;IAED,6CAA6C;IAC7C,uCAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,aANW,YAAY,GAAC,YAAY,2CAEjC;QAA0B,YAAY,GAA9B,OAAO;QACW,oBAAoB,GAAtC,OAAO;KACf,GAAU,OAAO,KAAQ,CAyC3B;CACJ;0BA9GyB,2BAA2B;8BADvB,8BAA8B;qCADvB,oCAAoC"}

package/types/models/whisper/feature_extraction_whisper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature_extraction_whisper.d.ts","sourceRoot":"","sources":["../../../src/models/whisper/feature_extraction_whisper.js"],"names":[],"mappings":"AAMA;IACI,yBAeC;IADG,sCAAwD;IAG5D;;;;OAIG;IACH,kCAHW,YAAY,GAAC,YAAY,GACvB,OAAO,CAAC,MAAM,CAAC,CA6B3B;IAED;;;;OAIG;IACH,aAHW,YAAY,GAAC,YAAY;;QACvB,OAAO,CAAC;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CA2B/C;CACJ;iCAzFuD,mCAAmC;uBACpE,uBAAuB"}
+{"version":3,"file":"feature_extraction_whisper.d.ts","sourceRoot":"","sources":["../../../src/models/whisper/feature_extraction_whisper.js"],"names":[],"mappings":"AAKA;IACI,yBAeC;IADG,sCAAwD;IAG5D;;;;OAIG;IACH,kCAHW,YAAY,GAAC,YAAY,GACvB,OAAO,CAAC,MAAM,CAAC,CAoB3B;IAED;;;;OAIG;IACH,aAHW,YAAY,GAAC,YAAY;;QACvB,OAAO,CAAC;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CA2B/C;CACJ;iCA/EuD,mCAAmC;uBACpE,uBAAuB"}

package/types/pipelines/index.d.ts

@@ -1,6 +1,5 @@
 export const SUPPORTED_TASKS: Readonly<{
     'text-classification': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof TextClassificationPipeline;
         model: typeof AutoModelForSequenceClassification;
         default: {
@@ -9,7 +8,6 @@ export const SUPPORTED_TASKS: Readonly<{
         type: string;
     };
     'token-classification': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof TokenClassificationPipeline;
         model: typeof AutoModelForTokenClassification;
         default: {
@@ -18,7 +16,6 @@ export const SUPPORTED_TASKS: Readonly<{
         type: string;
     };
     'question-answering': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof QuestionAnsweringPipeline;
         model: typeof AutoModelForQuestionAnswering;
         default: {
@@ -27,7 +24,6 @@ export const SUPPORTED_TASKS: Readonly<{
         type: string;
     };
     'fill-mask': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof FillMaskPipeline;
         model: typeof AutoModelForMaskedLM;
         default: {
@@ -37,7 +33,6 @@ export const SUPPORTED_TASKS: Readonly<{
         type: string;
     };
     summarization: {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof SummarizationPipeline;
         model: typeof AutoModelForSeq2SeqLM;
         default: {
@@ -46,7 +41,6 @@ export const SUPPORTED_TASKS: Readonly<{
         type: string;
     };
     translation: {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof TranslationPipeline;
         model: typeof AutoModelForSeq2SeqLM;
         default: {
@@ -55,7 +49,6 @@ export const SUPPORTED_TASKS: Readonly<{
         type: string;
     };
     'text2text-generation': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof Text2TextGenerationPipeline;
         model: typeof AutoModelForSeq2SeqLM;
         default: {
@@ -64,7 +57,6 @@ export const SUPPORTED_TASKS: Readonly<{
         type: string;
     };
     'text-generation': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof TextGenerationPipeline;
         model: typeof AutoModelForCausalLM;
         default: {
@@ -74,7 +66,6 @@ export const SUPPORTED_TASKS: Readonly<{
         type: string;
     };
     'zero-shot-classification': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof ZeroShotClassificationPipeline;
         model: typeof AutoModelForSequenceClassification;
         default: {
@@ -85,37 +76,30 @@ export const SUPPORTED_TASKS: Readonly<{
     'audio-classification': {
         pipeline: typeof AudioClassificationPipeline;
         model: typeof AutoModelForAudioClassification;
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
         type: string;
     };
     'zero-shot-audio-classification': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof ZeroShotAudioClassificationPipeline;
         model: typeof AutoModel;
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
         type: string;
     };
     'automatic-speech-recognition': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof AutomaticSpeechRecognitionPipeline;
         model: (typeof AutoModelForSpeechSeq2Seq)[];
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
         type: string;
     };
     'text-to-audio': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof TextToAudioPipeline;
         model: (typeof AutoModelForTextToSpectrogram)[];
-        processor: (typeof AutoProcessor)[];
         default: {
             model: string;
             dtype: string;
@@ -123,10 +107,8 @@ export const SUPPORTED_TASKS: Readonly<{
         type: string;
     };
     'image-to-text': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof ImageToTextPipeline;
         model: typeof AutoModelForVision2Seq;
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
@@ -135,7 +117,6 @@ export const SUPPORTED_TASKS: Readonly<{
     'image-classification': {
         pipeline: typeof ImageClassificationPipeline;
         model: typeof AutoModelForImageClassification;
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
@@ -144,7 +125,6 @@ export const SUPPORTED_TASKS: Readonly<{
     'image-segmentation': {
         pipeline: typeof ImageSegmentationPipeline;
         model: (typeof AutoModelForImageSegmentation)[];
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
@@ -153,17 +133,14 @@ export const SUPPORTED_TASKS: Readonly<{
     'background-removal': {
         pipeline: typeof BackgroundRemovalPipeline;
         model: (typeof AutoModelForImageSegmentation)[];
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
         type: string;
     };
     'zero-shot-image-classification': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof ZeroShotImageClassificationPipeline;
         model: typeof AutoModel;
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
@@ -172,27 +149,22 @@ export const SUPPORTED_TASKS: Readonly<{
     'object-detection': {
         pipeline: typeof ObjectDetectionPipeline;
         model: typeof AutoModelForObjectDetection;
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
         type: string;
     };
     'zero-shot-object-detection': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof ZeroShotObjectDetectionPipeline;
         model: typeof AutoModelForZeroShotObjectDetection;
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
         type: string;
     };
     'document-question-answering': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof DocumentQuestionAnsweringPipeline;
         model: typeof AutoModelForDocumentQuestionAnswering;
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
@@ -201,7 +173,6 @@ export const SUPPORTED_TASKS: Readonly<{
     'image-to-image': {
         pipeline: typeof ImageToImagePipeline;
         model: typeof AutoModelForImageToImage;
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
@@ -210,14 +181,12 @@ export const SUPPORTED_TASKS: Readonly<{
     'depth-estimation': {
         pipeline: typeof DepthEstimationPipeline;
         model: typeof AutoModelForDepthEstimation;
-        processor: typeof AutoProcessor;
         default: {
             model: string;
         };
         type: string;
     };
     'feature-extraction': {
-        tokenizer: typeof AutoTokenizer;
         pipeline: typeof FeatureExtractionPipeline;
         model: typeof AutoModel;
         default: {
@@ -227,7 +196,6 @@ export const SUPPORTED_TASKS: Readonly<{
         type: string;
     };
     'image-feature-extraction': {
-        processor: typeof AutoProcessor;
         pipeline: typeof ImageFeatureExtractionPipeline;
         model: (typeof AutoModel)[];
         default: {
@@ -250,7 +218,6 @@ export type AliasType = keyof typeof TASK_ALIASES;
  * All possible pipeline types.
  */
 export type PipelineType = TaskType | AliasType;
-import { AutoTokenizer } from '../models/auto/tokenization_auto.js';
 import { TextClassificationPipeline } from './text-classification.js';
 import { AutoModelForSequenceClassification } from '../models/auto/modeling_auto.js';
 import { TokenClassificationPipeline } from './token-classification.js';
@@ -268,7 +235,6 @@ import { AutoModelForCausalLM } from '../models/auto/modeling_auto.js';
 import { ZeroShotClassificationPipeline } from './zero-shot-classification.js';
 import { AudioClassificationPipeline } from './audio-classification.js';
 import { AutoModelForAudioClassification } from '../models/auto/modeling_auto.js';
-import { AutoProcessor } from '../models/auto/processing_auto.js';
 import { ZeroShotAudioClassificationPipeline } from './zero-shot-audio-classification.js';
 import { AutoModel } from '../models/auto/modeling_auto.js';
 import { AutomaticSpeechRecognitionPipeline } from './automatic-speech-recognition.js';

package/types/pipelines/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pipelines/index.js"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+RG;AAIH;;;;;;GASG;uBA+BU,MAAM,OAAO,eAAe;wBAC5B,MAAM,OAAO,YAAY;;;;2BACzB,QAAQ,GAAG,SAAS;8BAnYH,qCAAqC;2CA4BxB,0BAA0B;mDAF9D,iCAAiC;4CAGI,2BAA2B;gDAHhE,iCAAiC;0CAIE,yBAAyB;8CAJ5D,iCAAiC;iCAKP,gBAAgB;qCAL1C,iCAAiC;sCAMF,oBAAoB;sCANnD,iCAAiC;oCAOJ,kBAAkB;4CACV,2BAA2B;uCAChC,sBAAsB;qCATtD,iCAAiC;+CAUO,+BAA+B;4CAClC,2BAA2B;gDAXhE,iCAAiC;8BAzBV,mCAAmC;oDAqCb,qCAAqC;0BAZlF,iCAAiC;mDAaW,mCAAmC;0CAb/E,iCAAiC;oCAcJ,oBAAoB;8CAdjD,iCAAiC;oCAeJ,oBAAoB;uCAfjD,iCAAiC;4CAgBI,2BAA2B;gDAhBhE,iCAAiC;0CAiBE,yBAAyB;8CAjB5D,iCAAiC;0CAkBE,yBAAyB;oDACf,qCAAqC;wCACjD,uBAAuB;4CApBxD,iCAAiC;gDAqBQ,iCAAiC;oDArB1E,iCAAiC;kDAsBU,kCAAkC;sDAtB7E,iCAAiC;qCAuBH,qBAAqB;yCAvBnD,iCAAiC;wCAwBA,uBAAuB;4CAxBxD,iCAAiC;0CAyBE,yBAAyB;+CACpB,+BAA+B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pipelines/index.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8MG;AAIH;;;;;;GASG;uBA+BU,MAAM,OAAO,eAAe;wBAC5B,MAAM,OAAO,YAAY;;;;2BACzB,QAAQ,GAAG,SAAS;2CAtRU,0BAA0B;mDAF9D,iCAAiC;4CAGI,2BAA2B;gDAHhE,iCAAiC;0CAIE,yBAAyB;8CAJ5D,iCAAiC;iCAKP,gBAAgB;qCAL1C,iCAAiC;sCAMF,oBAAoB;sCANnD,iCAAiC;oCAOJ,kBAAkB;4CACV,2BAA2B;uCAChC,sBAAsB;qCATtD,iCAAiC;+CAUO,+BAA+B;4CAClC,2BAA2B;gDAXhE,iCAAiC;oDAYY,qCAAqC;0BAZlF,iCAAiC;mDAaW,mCAAmC;0CAb/E,iCAAiC;oCAcJ,oBAAoB;8CAdjD,iCAAiC;oCAeJ,oBAAoB;uCAfjD,iCAAiC;4CAgBI,2BAA2B;gDAhBhE,iCAAiC;0CAiBE,yBAAyB;8CAjB5D,iCAAiC;0CAkBE,yBAAyB;oDACf,qCAAqC;wCACjD,uBAAuB;4CApBxD,iCAAiC;gDAqBQ,iCAAiC;oDArB1E,iCAAiC;kDAsBU,kCAAkC;sDAtB7E,iCAAiC;qCAuBH,qBAAqB;yCAvBnD,iCAAiC;wCAwBA,uBAAuB;4CAxBxD,iCAAiC;0CAyBE,yBAAyB;+CACpB,+BAA+B"}

package/types/pipelines.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../src/pipelines.js"],"names":[],"mappings":"AAkDA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yBA7B4B,CAAC,SAAf,YAAa,QAChB,CAAC,UAuBD,MAAM,gKACN,OAAO,gBAAgB,EAAE,sBAAsB,GAC7C,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAoHhC;uBAzJY,MAAM,OAAO,eAAe;wBAC5B,MAAM,OAAO,YAAY;;;;2BACzB,QAAQ,GAAG,SAAS;;;;6BACpB,GAAE,CAAC,IAAI,QAAQ,GAAG,YAAY,CAAC,CAAA,OAAO,eAAe,EAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,GAAC;;;;yBACtE,GAAE,CAAC,IAAI,SAAS,GAAG,YAAY,CAAC,CAAA,OAAO,eAAe;;;;;;MAAiB,CAAC,UAAU,CAAC,CAAC,GAAC;;;;uBACrF,cAAc,GAAG,UAAU;6BAoP3B,OAAO,0BAA0B,EAAE,cAAc;uCACjD,OAAO,oCAAoC,EAAE,wBAAwB;wCACrE,OAAO,qCAAqC,EAAE,yBAAyB;sCACvE,OAAO,mCAAmC,EAAE,uBAAuB;kCACnE,OAAO,8BAA8B,EAAE,mBAAmB;gCAC1D,OAAO,4BAA4B,EAAE,iBAAiB;wCACtD,OAAO,qCAAqC,EAAE,yBAAyB;mCACvE,OAAO,gCAAgC,EAAE,oBAAoB;yCAC7D,OAAO,gCAAgC,EAAE,0BAA0B;uCACnE,OAAO,gCAAgC,EAAE,wBAAwB;2CACjE,OAAO,yCAAyC,EAAE,4BAA4B;wCAC9E,OAAO,qCAAqC,EAAE,yBAAyB;gDACvE,OAAO,+CAA+C,EAAE,iCAAiC;+CACzF,OAAO,6CAA6C,EAAE,gCAAgC;gCACtF,OAAO,8BAA8B,EAAE,iBAAiB;wCACxD,OAAO,qCAAqC,EAAE,yBAAyB;sCACvE,OAAO,mCAAmC,EAAE,uBAAuB;gCACnE,OAAO,8BAA8B,EAAE,iBAAiB;oCACxD,OAAO,iCAAiC,EAAE,qBAAqB;4CAC/D,OAAO,2CAA2C,EAAE,6BAA6B;gDACjF,OAAO,+CAA+C,EAAE,iCAAiC;8CACzF,OAAO,4CAA4C,EAAE,+BAA+B;oCACpF,OAAO,iCAAiC,EAAE,qBAAqB;2CApRrE,sBAAsB;4CAAtB,sBAAsB;0CAAtB,sBAAsB;iCAAtB,sBAAsB;sCAAtB,sBAAsB;oCAAtB,sBAAsB;4CAAtB,sBAAsB;uCAAtB,sBAAsB;+CAAtB,sBAAsB;4CAAtB,sBAAsB;oDAAtB,sBAAsB;mDAAtB,sBAAsB;oCAAtB,sBAAsB;oCAAtB,sBAAsB;4CAAtB,sBAAsB;0CAAtB,sBAAsB;0CAAtB,sBAAsB;oDAAtB,sBAAsB;wCAAtB,sBAAsB;gDAAtB,sBAAsB;kDAAtB,sBAAsB;qCAAtB,sBAAsB;wCAAtB,sBAAsB;0CAAtB,sBAAsB;+CAAtB,sBAAsB;gCAAtB,sBAAsB;6BAAtB,sBAAsB"}
+{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../src/pipelines.js"],"names":[],"mappings":"AAsDA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yBA7B4B,CAAC,SAAf,YAAa,QAChB,CAAC,UAuBD,MAAM,gKACN,OAAO,gBAAgB,EAAE,sBAAsB,GAC7C,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CA2IhC;uBAhLY,MAAM,OAAO,eAAe;wBAC5B,MAAM,OAAO,YAAY;;;;2BACzB,QAAQ,GAAG,SAAS;;;;6BACpB,GAAE,CAAC,IAAI,QAAQ,GAAG,YAAY,CAAC,CAAA,OAAO,eAAe,EAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,GAAC;;;;yBACtE,GAAE,CAAC,IAAI,SAAS,GAAG,YAAY,CAAC,CAAA,OAAO,eAAe;;;;;;MAAiB,CAAC,UAAU,CAAC,CAAC,GAAC;;;;uBACrF,cAAc,GAAG,UAAU;6BA2M3B,OAAO,0BAA0B,EAAE,cAAc;uCACjD,OAAO,oCAAoC,EAAE,wBAAwB;wCACrE,OAAO,qCAAqC,EAAE,yBAAyB;sCACvE,OAAO,mCAAmC,EAAE,uBAAuB;kCACnE,OAAO,8BAA8B,EAAE,mBAAmB;gCAC1D,OAAO,4BAA4B,EAAE,iBAAiB;wCACtD,OAAO,qCAAqC,EAAE,yBAAyB;mCACvE,OAAO,gCAAgC,EAAE,oBAAoB;yCAC7D,OAAO,gCAAgC,EAAE,0BAA0B;uCACnE,OAAO,gCAAgC,EAAE,wBAAwB;2CACjE,OAAO,yCAAyC,EAAE,4BAA4B;wCAC9E,OAAO,qCAAqC,EAAE,yBAAyB;gDACvE,OAAO,+CAA+C,EAAE,iCAAiC;+CACzF,OAAO,6CAA6C,EAAE,gCAAgC;gCACtF,OAAO,8BAA8B,EAAE,iBAAiB;wCACxD,OAAO,qCAAqC,EAAE,yBAAyB;sCACvE,OAAO,mCAAmC,EAAE,uBAAuB;gCACnE,OAAO,8BAA8B,EAAE,iBAAiB;oCACxD,OAAO,iCAAiC,EAAE,qBAAqB;4CAC/D,OAAO,2CAA2C,EAAE,6BAA6B;gDACjF,OAAO,+CAA+C,EAAE,iCAAiC;8CACzF,OAAO,4CAA4C,EAAE,+BAA+B;oCACpF,OAAO,iCAAiC,EAAE,qBAAqB;2CA3OrE,sBAAsB;4CAAtB,sBAAsB;0CAAtB,sBAAsB;iCAAtB,sBAAsB;sCAAtB,sBAAsB;oCAAtB,sBAAsB;4CAAtB,sBAAsB;uCAAtB,sBAAsB;+CAAtB,sBAAsB;4CAAtB,sBAAsB;oDAAtB,sBAAsB;mDAAtB,sBAAsB;oCAAtB,sBAAsB;oCAAtB,sBAAsB;4CAAtB,sBAAsB;0CAAtB,sBAAsB;0CAAtB,sBAAsB;oDAAtB,sBAAsB;wCAAtB,sBAAsB;gDAAtB,sBAAsB;kDAAtB,sBAAsB;qCAAtB,sBAAsB;wCAAtB,sBAAsB;0CAAtB,sBAAsB;+CAAtB,sBAAsB;gCAAtB,sBAAsB;6BAAtB,sBAAsB"}

package/types/transformers.d.ts

@@ -14,6 +14,7 @@ export * from "./generation/stopping_criteria.js";
 export * from "./generation/logits_process.js";
 export * from "./utils/tensor.js";
 export { random } from "./utils/random.js";
+export { DynamicCache } from "./cache_utils.js";
 export { ModelRegistry } from "./utils/model_registry/ModelRegistry.js";
 export type PretrainedModelOptions = import("./utils/hub.js").PretrainedModelOptions;
 export type PretrainedProcessorOptions = import("./processing_utils.js").PretrainedProcessorOptions;

package/types/transformers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../src/transformers.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;qCA4Da,OAAO,gBAAgB,EAAE,sBAAsB;yCAC/C,OAAO,uBAAuB,EAAE,0BAA0B;sBAC1D,OAAO,yBAAyB,EAAE,OAAO;yCACzC,OAAO,yBAAyB,EAAE,0BAA0B;uBAC5D,OAAO,mBAAmB,EAAE,QAAQ;yBACpC,OAAO,oBAAoB,EAAE,UAAU;+BACvC,OAAO,iBAAiB,EAAE,gBAAgB;2BAC1C,OAAO,iBAAiB,EAAE,YAAY"}
+{"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../src/transformers.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;qCA8Da,OAAO,gBAAgB,EAAE,sBAAsB;yCAC/C,OAAO,uBAAuB,EAAE,0BAA0B;sBAC1D,OAAO,yBAAyB,EAAE,OAAO;yCACzC,OAAO,yBAAyB,EAAE,0BAA0B;uBAC5D,OAAO,mBAAmB,EAAE,QAAQ;yBACpC,OAAO,oBAAoB,EAAE,UAAU;+BACvC,OAAO,iBAAiB,EAAE,gBAAgB;2BAC1C,OAAO,iBAAiB,EAAE,YAAY"}

package/types/utils/audio.d.ts

@@ -76,8 +76,10 @@ export function mel_filter_bank(num_frequency_bins: number, num_mel_filters: num
  * If supplied, applies this filter bank to create a mel spectrogram.
  * @param {number} [options.mel_floor=1e-10] Minimum value of mel frequency banks.
  * @param {string} [options.log_mel=null] How to convert the spectrogram to log scale. Possible options are:
- * `null` (don't convert), `"log"` (take the natural logarithm) `"log10"` (take the base-10 logarithm), `"dB"` (convert to decibels).
+ * `null` (don't convert), `"log"` (take the natural logarithm), `"log10"` (take the base-10 logarithm), `"dB"` (convert to decibels),
+ * `"log10_max_norm"` (take `log10`, then apply `(max(x, maxVal - 8) + 4) / 4` normalization, where `maxVal` is computed from data or given by `max_log_mel`).
  * Can only be used when `power` is not `null`.
+ * @param {number} [options.max_log_mel=null] When `log_mel` is `"log10_max_norm"`, use this fixed value as the max instead of computing from data.
  * @param {number} [options.reference=1.0] Sets the input spectrogram value that corresponds to 0 dB. For example, use `max(spectrogram)[0]` to set
  * the loudest part to 0 dB. Must be greater than zero.
  * @param {number} [options.min_value=1e-10] The spectrogram will be clipped to this minimum value before conversion to decibels, to avoid taking `log(0)`.
@@ -94,7 +96,7 @@ export function mel_filter_bank(num_frequency_bins: number, num_mel_filters: num
  * @param {number} [options.mel_offset=0] Offset to add to the mel spectrogram to avoid taking the log of zero.
  * @returns {Promise<Tensor>} Spectrogram of shape `(num_frequency_bins, length)` (regular spectrogram) or shape `(num_mel_filters, length)` (mel spectrogram).
  */
-export function spectrogram(waveform: Float32Array | Float64Array, window: Float32Array | Float64Array, frame_length: number, hop_length: number, { fft_length, power, center, pad_mode, onesided, preemphasis, preemphasis_htk_flavor, mel_filters, mel_floor, log_mel, reference, min_value, db_range, remove_dc_offset, min_num_frames, max_num_frames, do_pad, transpose, mel_offset, }?: {
+export function spectrogram(waveform: Float32Array | Float64Array, window: Float32Array | Float64Array, frame_length: number, hop_length: number, { fft_length, power, center, pad_mode, onesided, preemphasis, preemphasis_htk_flavor, mel_filters, mel_floor, log_mel, max_log_mel, reference, min_value, db_range, remove_dc_offset, min_num_frames, max_num_frames, do_pad, transpose, mel_offset, }?: {
     fft_length?: number;
     power?: number;
     center?: boolean;
@@ -105,6 +107,7 @@ export function spectrogram(waveform: Float32Array | Float64Array, window: Float
     mel_filters?: number[][];
     mel_floor?: number;
     log_mel?: string;
+    max_log_mel?: number;
     reference?: number;
     min_value?: number;
     db_range?: number;

package/types/utils/audio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../src/utils/audio.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,gCAJW,MAAM,GAAC,GAAG,iBACV,MAAM,GACJ,OAAO,CAAC,YAAY,CAAC,CAsDjC;AA2BD;;;;;;GAMG;AACH,2BAHW,MAAM,GACJ,YAAY,CAIxB;AAED;;;;;;GAMG;AACH,2BAHW,MAAM,GACJ,YAAY,CAIxB;AAyGD;;;;;;;;;;;;;;;;;GAiBG;AACH,oDAbW,MAAM,mBAEN,MAAM,iBACN,MAAM,iBACN,MAAM,iBACN,MAAM,SACN,MAAM,GAAC,IAAI,cACX,MAAM,OAAO,oBAAoB,+BACjC,OAAO,GAEL,MAAM,EAAE,EAAE,CA4DtB;AAqHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,sCAvCW,YAAY,GAAC,YAAY,UACzB,YAAY,GAAC,YAAY,gBAEzB,MAAM,cACN,MAAM,8OAEd;IAAyB,UAAU,GAA3B,MAAM;IAEW,KAAK,GAAtB,MAAM;IACY,MAAM,GAAxB,OAAO;IAEU,QAAQ,GAAzB,MAAM;IAEY,QAAQ,GAA1B,OAAO;IAEU,WAAW,GAA5B,MAAM;IACY,sBAAsB,GAAxC,OAAO;IACc,WAAW,GAAhC,MAAM,EAAE,EAAE;IAEO,SAAS,GAA1B,MAAM;IACW,OAAO,GAAxB,MAAM;IAGW,SAAS,GAA1B,MAAM;IAEW,SAAS,GAA1B,MAAM;IAGW,QAAQ,GAAzB,MAAM;IAEY,gBAAgB,GAAlC,OAAO;IAEU,cAAc,GAA/B,MAAM;IACW,cAAc,GAA/B,MAAM;IACY,MAAM,GAAxB,OAAO;IACW,SAAS,GAA3B,OAAO;IACU,UAAU,GAA3B,MAAM;CACd,GAAU,OAAO,CAAC,MAAM,CAAC,CAwN3B;AAED;;;;;;;;;;GAUG;AACH,+CATW,MAAM,QACN,MAAM,uCAEd;IAA0B,QAAQ,GAA1B,OAAO;IACU,YAAY,GAA7B,MAAM;IAEY,MAAM,GAAxB,OAAO;CACf,GAAU,YAAY,CAmCxB;AAuDD;IACI;;;;OAIG;IACH,mBAHW,YAAY,GAAC,YAAY,EAAE,iBAC3B,MAAM,EAKhB;IAFG,uEAAkB;IAClB,sBAAkC;IAGtC;;;OAGG;IACH,YAFa,YAAY,CAsBxB;IAED;;;OAGG;IACH,UAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAIzB;CACJ;;IAzrBQ,mBAAY,MAAM,UAAqD;IACrE,qBAAY,MAAM,UAAqD;IACtE,sBAAY,MAAM,0EAC+E;;uBAzI9E,aAAa"}
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../src/utils/audio.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,gCAJW,MAAM,GAAC,GAAG,iBACV,MAAM,GACJ,OAAO,CAAC,YAAY,CAAC,CAsDjC;AA2BD;;;;;;GAMG;AACH,2BAHW,MAAM,GACJ,YAAY,CAIxB;AAED;;;;;;GAMG;AACH,2BAHW,MAAM,GACJ,YAAY,CAIxB;AAyGD;;;;;;;;;;;;;;;;;GAiBG;AACH,oDAbW,MAAM,mBAEN,MAAM,iBACN,MAAM,iBACN,MAAM,iBACN,MAAM,SACN,MAAM,GAAC,IAAI,cACX,MAAM,OAAO,oBAAoB,+BACjC,OAAO,GAEL,MAAM,EAAE,EAAE,CA4DtB;AAqHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,sCAzCW,YAAY,GAAC,YAAY,UACzB,YAAY,GAAC,YAAY,gBAEzB,MAAM,cACN,MAAM,2PAEd;IAAyB,UAAU,GAA3B,MAAM;IAEW,KAAK,GAAtB,MAAM;IACY,MAAM,GAAxB,OAAO;IAEU,QAAQ,GAAzB,MAAM;IAEY,QAAQ,GAA1B,OAAO;IAEU,WAAW,GAA5B,MAAM;IACY,sBAAsB,GAAxC,OAAO;IACc,WAAW,GAAhC,MAAM,EAAE,EAAE;IAEO,SAAS,GAA1B,MAAM;IACW,OAAO,GAAxB,MAAM;IAIW,WAAW,GAA5B,MAAM;IACW,SAAS,GAA1B,MAAM;IAEW,SAAS,GAA1B,MAAM;IAGW,QAAQ,GAAzB,MAAM;IAEY,gBAAgB,GAAlC,OAAO;IAEU,cAAc,GAA/B,MAAM;IACW,cAAc,GAA/B,MAAM;IACY,MAAM,GAAxB,OAAO;IACW,SAAS,GAA3B,OAAO;IACU,UAAU,GAA3B,MAAM;CACd,GAAU,OAAO,CAAC,MAAM,CAAC,CAsO3B;AAED;;;;;;;;;;GAUG;AACH,+CATW,MAAM,QACN,MAAM,uCAEd;IAA0B,QAAQ,GAA1B,OAAO;IACU,YAAY,GAA7B,MAAM;IAEY,MAAM,GAAxB,OAAO;CACf,GAAU,YAAY,CAmCxB;AAuDD;IACI;;;;OAIG;IACH,mBAHW,YAAY,GAAC,YAAY,EAAE,iBAC3B,MAAM,EAKhB;IAFG,uEAAkB;IAClB,sBAAkC;IAGtC;;;OAGG;IACH,YAFa,YAAY,CAsBxB;IAED;;;OAGG;IACH,UAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAIzB;CACJ;;IAzsBQ,mBAAY,MAAM,UAAqD;IACrE,qBAAY,MAAM,UAAqD;IACtE,sBAAY,MAAM,0EAC+E;;uBAzI9E,aAAa"}

package/types/utils/cache/CrossOriginStorageCache.d.ts

@@ -0,0 +1,120 @@
+/**
+ * A cache implementation backed by the experimental `navigator.crossOriginStorage` API,
+ * which allows sharing cached files (identified by content hash) across origins.
+ *
+ * Implements {@link import('../cache.js').CacheInterface}.
+ *
+ * @see https://github.com/explainers-by-googlers/cross-origin-storage
+ */
+export class CrossOriginStorage {
+    /**
+     * Returns whether the `navigator.crossOriginStorage` API is available in the current environment.
+     * @returns {boolean}
+     */
+    static isAvailable: () => boolean;
+    /**
+     * Returns (and lazily opens) the hash cache, reusing the same promise across concurrent callers.
+     * @returns {Promise<Cache>}
+     */
+    _getHashCache: () => Promise<Cache>;
+    /**
+     * Looks up a cached response for the given URL by resolving its SHA-256 hash and requesting
+     * the corresponding file handle from cross-origin storage.
+     *
+     * Implements `CacheInterface.match`.
+     *
+     * @param {string} request The URL of the resource to look up.
+     * @returns {Promise<Response|undefined>} The cached `Response`, or `undefined` if not found.
+     */
+    match: (request: string) => Promise<Response | undefined>;
+    /**
+     * Stores a response in cross-origin storage, keyed by its SHA-256 hash.
+     *
+     * For LFS-backed URLs the hash is resolved cheaply via `_getFileHash` (which checks
+     * `HASH_CACHE_NAME` first, then falls back to fetching the Git LFS pointer file)
+     * without reading the response body a second time.
+     *
+     * For non-LFS resources the hash is unknown upfront.  In that case the body is consumed
+     * in the background: the stream is read to compute the content hash, the file is written
+     * into cross-origin storage, and the computed hash is persisted to `HASH_CACHE_NAME`
+     * so that future `match` calls can resolve the file without a network round-trip.
+     *
+     * Implements `CacheInterface.put`.
+     *
+     * @param {string} request The URL of the resource (used as the hash-cache key).
+     * @param {Response} response The response whose body will be written to the cache.
+     * @returns {Promise<void>}
+     */
+    put: (request: string, response: Response) => Promise<void>;
+    /**
+     * Writes a blob into cross-origin storage using the given pre-computed hex hash string.
+     *
+     * @param {Blob} blob
+     * @param {string} hashHex Hex-encoded SHA-256 hash of `blob`.
+     * @returns {Promise<void>}
+     */
+    _storeBlobInCOS: (blob: Blob, hashHex: string) => Promise<void>;
+    /**
+     * Background task for non-LFS resources: consumes `stream`, computes the SHA-256 hash
+     * of the resulting blob, stores it in cross-origin storage, and persists the computed
+     * hash to `HASH_CACHE_NAME` keyed by `request` so future `match` calls can resolve the
+     * file without a network round-trip.
+     *
+     * Called fire-and-forget from `put` — errors are swallowed so failures never surface to
+     * the caller.
+     *
+     * @param {string} request The original resource URL.
+     * @param {ReadableStream} stream The response body stream to consume.
+     * @returns {Promise<void>}
+     */
+    _processAndStore: (request: string, stream: ReadableStream) => Promise<void>;
+    /**
+     * Deletes the cache entry for the given request.
+     *
+     * Removes the hash entry from `HASH_CACHE_NAME`. Note: cross-origin storage itself does not
+     * expose a delete API, so only the local hash mapping is removed. For non-LFS URLs this
+     * permanently prevents `match` from resolving the file. For LFS-backed URLs, `match` will
+     * re-fetch the LFS pointer file on the next call and repopulate the hash cache automatically.
+     *
+     * Implements `CacheInterface.delete`.
+     *
+     * @param {string} request
+     * @returns {Promise<boolean>} Resolves to `true` if the hash entry was deleted, `false` otherwise.
+     */
+    delete: (request: string) => Promise<boolean>;
+    /**
+     * Resolves the SHA-256 hash for a given URL.
+     *
+     * Returns the cached hash immediately if one has been persisted to `HASH_CACHE_NAME`.
+     * Otherwise falls back to `_getLfsFileHash` to retrieve the hash from the Hugging Face
+     * LFS pointer file, persisting the result to `HASH_CACHE_NAME` for future lookups.
+     *
+     * Returns `null` if the hash cannot be determined (e.g. non-LFS URL with no cached entry).
+     *
+     * @param {string} url The resource URL to resolve a hash for.
+     * @returns {Promise<string|null>} The hex-encoded SHA-256 hash, or `null` if unavailable.
+     */
+    _getFileHash: (url: string) => Promise<string | null>;
+    /**
+     * Attempts to retrieve the SHA-256 hash for a Hugging Face resource URL from its raw
+     * Git LFS pointer file.
+     *
+     * Only applicable to URLs containing `/resolve/` (i.e. Hugging Face resolved file URLs).
+     * The `/resolve/` segment is rewritten to `/raw/` to fetch the LFS pointer directly.
+     * Returns `null` for non-LFS URLs or when the network request fails.
+     *
+     * @see https://huggingface.co/docs/hub/en/storage-backends#xet
+     * @param {string} url The resolved Hugging Face URL of the resource.
+     * @returns {Promise<string|null>} The hex-encoded SHA-256 hash, or `null` if unavailable.
+     */
+    _getLfsFileHash: (url: string) => Promise<string | null>;
+    /**
+     * Computes the SHA-256 hash of a `Blob`'s contents.
+     *
+     * @param {Blob} blob The blob to hash.
+     * @returns {Promise<string>} The lowercase hex-encoded SHA-256 hash.
+     */
+    _getBlobHash: (blob: Blob) => Promise<string>;
+    #private;
+}
+//# sourceMappingURL=CrossOriginStorageCache.d.ts.map

package/types/utils/cache/CrossOriginStorageCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CrossOriginStorageCache.d.ts","sourceRoot":"","sources":["../../../src/utils/cache/CrossOriginStorageCache.js"],"names":[],"mappings":"AAiBA;;;;;;;GAOG;AACH;IAaI;;;OAGG;IACH,0BAFa,OAAO,CAE6E;IAbjG;;;OAGG;IACH,qBAFa,OAAO,CAAC,KAAK,CAAC,CAKzB;IAQF;;;;;;;;OAQG;IACH,QAAe,SAHJ,MAGW,KAFT,OAAO,CAAC,QAAQ,GAAC,SAAS,CAAC,CAkBtC;IAEF;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAa,SAJF,MAIS,EAAE,UAHX,QAGmB,KAFjB,OAAO,CAAC,IAAI,CAAC,CAexB;IAEF;;;;;;OAMG;IACH,kBAAyB,MAJd,IAIkB,EAAE,SAHpB,MAG2B,KAFzB,OAAO,CAAC,IAAI,CAAC,CASxB;IAEF;;;;;;;;;;;;OAYG;IACH,mBAA0B,SAJf,MAIsB,EAAE,QAHxB,cAG8B,KAF5B,OAAO,CAAC,IAAI,CAAC,CAuBxB;IAEF;;;;;;;;;;;;OAYG;IACH,SAAgB,SAHL,MAGY,KAFV,OAAO,CAAC,OAAO,CAAC,CAS3B;IAEF;;;;;;;;;;;OAWG;IACH,eAAsB,KAHX,MAGc,KAFZ,OAAO,CAAC,MAAM,GAAC,IAAI,CAAC,CAoB/B;IAEF;;;;;;;;;;;OAWG;IACH,kBAAyB,KAHd,MAGiB,KAFf,OAAO,CAAC,MAAM,GAAC,IAAI,CAAC,CAgB/B;IAEF;;;;;OAKG;IACH,eAAsB,MAHX,IAGe,KAFb,OAAO,CAAC,MAAM,CAAC,CAO1B;;CACL"}