videobook-engine 4.2.0 → 5.3.2

package/dist/model-cache-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-cache-paths.js","sourceRoot":"","sources":["../src/model-cache-paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE3C,MAAM,UAAU,qBAAqB,CAAC,QAAgB,EAAE,UAAkB;IACxE,OAAO,IAAI,CAAC,QAAQ,EAAE,oBAAoB,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;AACpE,CAAC"}

package/dist/model-checksums.json

@@ -0,0 +1,338 @@
+{
+    "Xenova/clip-vit-base-patch32/d15189d7028b43f1d3e65039190477f6af591c2a": {
+        ".gitattributes": {
+            "algorithm": "git-sha1",
+            "digest": "c7d9f3332a950355d5a77d85000f05e6f45435ea",
+            "size": 1477
+        },
+        "README.md": {
+            "algorithm": "git-sha1",
+            "digest": "408169643667155a04db6336ba636c52de2ecaad",
+            "size": 1404
+        },
+        "config.json": {
+            "algorithm": "git-sha1",
+            "digest": "e79bad158b04c235740f9b2ec320b17f4030f7a5",
+            "size": 4524
+        },
+        "merges.txt": {
+            "algorithm": "git-sha1",
+            "digest": "76e821f1b6f0a9709293c3b6b51ed90980b3166b",
+            "size": 524619
+        },
+        "onnx/model.onnx": {
+            "algorithm": "sha256",
+            "digest": "8ac34fc990f890b4bec8d197de81f956fb135a65067e77fadbf8f053656ed711",
+            "size": 605799029
+        },
+        "onnx/model_bnb4.onnx": {
+            "algorithm": "sha256",
+            "digest": "3e70d5ff773c939a1fcfbe135a344141a8711c617af1914cee33c278649cea15",
+            "size": 181695925
+        },
+        "onnx/model_fp16.onnx": {
+            "algorithm": "sha256",
+            "digest": "b33a72860c26713ff564d36a162be4e968ee1e50b2418f449076c067735d4fab",
+            "size": 303515168
+        },
+        "onnx/model_q4.onnx": {
+            "algorithm": "sha256",
+            "digest": "1f518bedb1851294737a141e06149883cb289160760224f2da5498886e49d5cb",
+            "size": 189403477
+        },
+        "onnx/model_q4f16.onnx": {
+            "algorithm": "sha256",
+            "digest": "0fa5651801a45889d15576d445b23172f706be5b5d17f6d96a61b486cf4a5252",
+            "size": 125818295
+        },
+        "onnx/model_quantized.onnx": {
+            "algorithm": "sha256",
+            "digest": "0898a3facfdb27f0a041e57649b4989cfd094e4a0040d6ae75ed69917dfc7328",
+            "size": 153695702
+        },
+        "onnx/model_uint8.onnx": {
+            "algorithm": "sha256",
+            "digest": "4ac011172c8c022937bb83dad2e8fc207f52f19972b36e14808cc3c8042c4e60",
+            "size": 152738540
+        },
+        "onnx/text_model.onnx": {
+            "algorithm": "sha256",
+            "digest": "3f6571f5bad13a97c469c1622e1cfc4d9aef78b79fdbfcff804ca357bfada8cc",
+            "size": 254058553
+        },
+        "onnx/text_model_bnb4.onnx": {
+            "algorithm": "sha256",
+            "digest": "b7c2b531428f0a71a0510252ce9157b2c0fd2400dd0e21aed2e2313cc0e36164",
+            "size": 123367012
+        },
+        "onnx/text_model_fp16.onnx": {
+            "algorithm": "sha256",
+            "digest": "df587ffbf248bf20d44fa6e16adc5ebc27ead691860e5333dbdaab5fd6bf3f6e",
+            "size": 127339794
+        },
+        "onnx/text_model_int8.onnx": {
+            "algorithm": "sha256",
+            "digest": "18845f2ccc35223bb7fec403383a131154b11ac0918df25cf51986df5efd3a21",
+            "size": 64070791
+        },
+        "onnx/text_model_q4.onnx": {
+            "algorithm": "sha256",
+            "digest": "e4ccd15d806b8af841a036884b42034535d58e04c52df00f56e73f72d3c166d5",
+            "size": 125742108
+        },
+        "onnx/text_model_q4f16.onnx": {
+            "algorithm": "sha256",
+            "digest": "7640460b1389da7d4fa3b3ebcc80299fbe6850b209a009b5067d25c4a9d027d2",
+            "size": 72531963
+        },
+        "onnx/text_model_quantized.onnx": {
+            "algorithm": "sha256",
+            "digest": "73baab855d406190da9faa498cfedf65f15cf309f4cc7385b7b032e6d08e5c3a",
+            "size": 64504507
+        },
+        "onnx/text_model_uint8.onnx": {
+            "algorithm": "sha256",
+            "digest": "cbe64fd9eaa6324d49006ce99c104107fdf6b26d25bebff96ecbb5d8a24c5e54",
+            "size": 64070835
+        },
+        "onnx/vision_model.onnx": {
+            "algorithm": "sha256",
+            "digest": "fd6e1402a588279d1723c7534d4bcba5bc0b14b47dfab0e46f8c47b8270d7d40",
+            "size": 351685709
+        },
+        "onnx/vision_model_bnb4.onnx": {
+            "algorithm": "sha256",
+            "digest": "d37c9d4463a3ade0bd069e2d35af22f6cbe71ca6e64ad922dbd4f5b2cba9243e",
+            "size": 58310402
+        },
+        "onnx/vision_model_fp16.onnx": {
+            "algorithm": "sha256",
+            "digest": "35c4e0fb0aeee527dcde1693520b214a34424a786babd530f35366bad5844efd",
+            "size": 176080659
+        },
+        "onnx/vision_model_int8.onnx": {
+            "algorithm": "sha256",
+            "digest": "0ab0c1b3ace708e539633af1744d5a95247fe4e14d3e08ff197ef82a6cb9bd93",
+            "size": 88648877
+        },
+        "onnx/vision_model_q4.onnx": {
+            "algorithm": "sha256",
+            "digest": "0769eb1d2f6f68927bbfa6e5330df4c4c3c112f89cd43eae28baafa9e6bd34b4",
+            "size": 63642858
+        },
+        "onnx/vision_model_q4f16.onnx": {
+            "algorithm": "sha256",
+            "digest": "d238c4e0afe798c47c5991a046b923c5bcbeed19c2d75d7c0db845ba73bb7b87",
+            "size": 53267374
+        },
+        "onnx/vision_model_quantized.onnx": {
+            "algorithm": "sha256",
+            "digest": "583fd1110a514667812fee7d684952aaf82a99b959760c8d7dca7e0ab9839299",
+            "size": 89117001
+        },
+        "onnx/vision_model_uint8.onnx": {
+            "algorithm": "sha256",
+            "digest": "b95448754a6ae56964ec80c570c80bb9863787ee85f51b664abed8c0e5f22a7a",
+            "size": 88648915
+        },
+        "preprocessor_config.json": {
+            "algorithm": "git-sha1",
+            "digest": "e0675735fd0052745f2f7b7291e4aa7859389998",
+            "size": 520
+        },
+        "special_tokens_map.json": {
+            "algorithm": "git-sha1",
+            "digest": "2c2130b544c0c5a72d5d00da071ba130a9800fb2",
+            "size": 472
+        },
+        "tokenizer.json": {
+            "algorithm": "git-sha1",
+            "digest": "bc1f77d20440541dd073ebae6f6c401087c7d34e",
+            "size": 2224119
+        },
+        "tokenizer_config.json": {
+            "algorithm": "git-sha1",
+            "digest": "c9b2a711cbdd039529fa5a66f1965e13eb14451d",
+            "size": 775
+        },
+        "vocab.json": {
+            "algorithm": "git-sha1",
+            "digest": "182766ce89b439768edadda342519f33802f5364",
+            "size": 862328
+        }
+    },
+    "Xenova/clap-htsat-unfused/c28f2883575e590e04d3146ff0713c2448d691ba": {
+        ".gitattributes": {
+            "algorithm": "git-sha1",
+            "digest": "a6344aac8c09253b3b630fb776ae94478aa0275b",
+            "size": 1519
+        },
+        "README.md": {
+            "algorithm": "git-sha1",
+            "digest": "5af08cd935c160e0670761f0c069620f32e3fdab",
+            "size": 2963
+        },
+        "config.json": {
+            "algorithm": "git-sha1",
+            "digest": "21aedc3f9eccb0504cea9e2a68b931ca5853ce3d",
+            "size": 699
+        },
+        "merges.txt": {
+            "algorithm": "git-sha1",
+            "digest": "226b0752cac7789c48f0cb3ec53eda48b7be36cc",
+            "size": 456318
+        },
+        "onnx/audio_model.onnx": {
+            "algorithm": "sha256",
+            "digest": "a1c2b43c44f71e0fa841a4b86700886c199bf87699ea45632c4d831bc6c88957",
+            "size": 117528416
+        },
+        "onnx/audio_model_fp16.onnx": {
+            "algorithm": "sha256",
+            "digest": "65963cfa5e903e0a8df475137252d618663df88ecf0b55a3fb327e6c1ca63a97",
+            "size": 60414065
+        },
+        "onnx/audio_model_quantized.onnx": {
+            "algorithm": "sha256",
+            "digest": "3fcff2c8824e7bcb83a983f2a49edab3b60cbcf4872ac70efee517355173bd1f",
+            "size": 34301667
+        },
+        "onnx/model.onnx": {
+            "algorithm": "sha256",
+            "digest": "a8cbfb96dda10259964e678c1557466f925001f66b8cd1b24c84bd88b0f84345",
+            "size": 619128635
+        },
+        "onnx/model_fp16.onnx": {
+            "algorithm": "sha256",
+            "digest": "9ec27913c473d8ce6367cc40376c27b79899248009d8f6f2ad62110abdcf6124",
+            "size": 311602756
+        },
+        "onnx/model_quantized.onnx": {
+            "algorithm": "sha256",
+            "digest": "3f559313ec268518193101007fc0569ee4b2cfac03e369091c50adb4795f5c5d",
+            "size": 161024085
+        },
+        "onnx/text_model.onnx": {
+            "algorithm": "sha256",
+            "digest": "6df7c51f2d78e236a03f2b816e613d538c815639d13644fe7c2124f439da9648",
+            "size": 501513769
+        },
+        "onnx/text_model_fp16.onnx": {
+            "algorithm": "sha256",
+            "digest": "c1fd1e4cdd02acbcacaafe7a8e608dcfc8f84a00bfea3e2ca7df710957b4c3a5",
+            "size": 251029088
+        },
+        "onnx/text_model_quantized.onnx": {
+            "algorithm": "sha256",
+            "digest": "1a3df8b197e249816e08415fd040434c44762b2eea7eb7bf8a48a0f0bf3c14e5",
+            "size": 126603263
+        },
+        "preprocessor_config.json": {
+            "algorithm": "git-sha1",
+            "digest": "e8636819eeb1b19f1e5b6f572eca1a101144062e",
+            "size": 541
+        },
+        "quantize_config.json": {
+            "algorithm": "git-sha1",
+            "digest": "746b5b26413f609d069f50d602cf2f6efa525570",
+            "size": 3044
+        },
+        "special_tokens_map.json": {
+            "algorithm": "git-sha1",
+            "digest": "d5698132694f4f1bcff08fa7d937b1701812598e",
+            "size": 280
+        },
+        "tokenizer.json": {
+            "algorithm": "git-sha1",
+            "digest": "15cffb1a334cf27ccef68b0b6e2bc6f74f1be219",
+            "size": 2108774
+        },
+        "tokenizer_config.json": {
+            "algorithm": "git-sha1",
+            "digest": "1a6efe5c59e166ece942ce95dad22c72f9850b78",
+            "size": 1392
+        },
+        "vocab.json": {
+            "algorithm": "git-sha1",
+            "digest": "4ebe4bb3f3114daf2e4cc349f24873a1175a35d7",
+            "size": 798293
+        }
+    },
+    "onnx-community/all-MiniLM-L6-v2-ONNX/aff7a1dc4e8a1ea593e6ea21e95c22ef0a25966f": {
+        ".gitattributes": {
+            "algorithm": "git-sha1",
+            "digest": "64b13564f7941eb0782c057efbbd78c3f9593b74",
+            "size": 1761
+        },
+        "README.md": {
+            "algorithm": "git-sha1",
+            "digest": "ba95261ef2a1a479a01e40d5107b7fead1747513",
+            "size": 1972
+        },
+        "config.json": {
+            "algorithm": "git-sha1",
+            "digest": "ebe38151e286579f65078db2a2efafc79278fe50",
+            "size": 794
+        },
+        "onnx/model.onnx": {
+            "algorithm": "sha256",
+            "digest": "2f019cf6217537cc4bfc7f5192f21dea1e18445177edaab0bc6163a813e5c7a1",
+            "size": 56796
+        },
+        "onnx/model.onnx_data": {
+            "algorithm": "sha256",
+            "digest": "60c758432aa596c30a122942dfe594c457d4d713f890926f1c5f920bd496c8de",
+            "size": 90261504
+        },
+        "onnx/model_fp16.onnx": {
+            "algorithm": "sha256",
+            "digest": "6bf4044cd8469cdb93c19f42c5c547fdd8bd4c50409145ba75ed1f80cf3f5e5e",
+            "size": 96443
+        },
+        "onnx/model_fp16.onnx_data": {
+            "algorithm": "sha256",
+            "digest": "68486e80f360c88c72cdcc555a60bec94bc74fdf69ba4140dac8c15fcff661f7",
+            "size": 45087744
+        },
+        "onnx/model_q4.onnx": {
+            "algorithm": "sha256",
+            "digest": "e4dcb918111189b7686147e309379832fce83d4ecbf17c395961749b5788c786",
+            "size": 69663
+        },
+        "onnx/model_q4.onnx_data": {
+            "algorithm": "sha256",
+            "digest": "56fb7a55115e900196115a74e399beb45c2f41ae00b99525d46fb52935c4ee2a",
+            "size": 54429696
+        },
+        "onnx/model_q4f16.onnx": {
+            "algorithm": "sha256",
+            "digest": "6297f8bb2f10987bad6f36d06022bb4b4ff5289247654843d599389630fd53dd",
+            "size": 109149
+        },
+        "onnx/model_q4f16.onnx_data": {
+            "algorithm": "sha256",
+            "digest": "e37a0ad962e125f02213afef98d52a606331a1c95a56c6e01d320fefb83892a2",
+            "size": 29826048
+        },
+        "special_tokens_map.json": {
+            "algorithm": "git-sha1",
+            "digest": "9bbecc17cabbcbd3112c14d6982b51403b264bfa",
+            "size": 695
+        },
+        "tokenizer.json": {
+            "algorithm": "git-sha1",
+            "digest": "b3d7c5709c06ce20b82f8f240b3b2c5545f449cb",
+            "size": 533808
+        },
+        "tokenizer_config.json": {
+            "algorithm": "git-sha1",
+            "digest": "99b96f0727e44fef7241b392cc75014313205609",
+            "size": 1463
+        },
+        "vocab.txt": {
+            "algorithm": "git-sha1",
+            "digest": "fb140275c155a9c7c5a3b3e0e77a9e839594a938",
+            "size": 231508
+        }
+    }
+}

package/dist/model-file-resolver.d.ts

@@ -0,0 +1,30 @@
+import type { ModelWorkerConfiguration } from "./model-worker-protocol.js";
+import { EngineFault } from "./store.js";
+interface ModelFileOptions {
+    revision?: string;
+    cache_dir?: string | null;
+    local_files_only?: boolean;
+}
+export declare class ModelFileResolver {
+    private readonly config;
+    private readonly workspace;
+    failure?: EngineFault;
+    private readonly active;
+    private readonly network;
+    private stopped;
+    private readonly pending;
+    private readonly verified;
+    private readonly staging;
+    constructor(config: ModelWorkerConfiguration, workspace: string);
+    get(modelId: string, filename: string, fatal?: boolean, options?: ModelFileOptions, returnPath?: boolean): Promise<string | Uint8Array | null>;
+    drainAfterFailure(): Promise<EngineFault | undefined>;
+    private getVerified;
+    private downloadAllowed;
+    private resolveFile;
+    private receipt;
+    private download;
+    private snapshot;
+    private publish;
+}
+export {};
+//# sourceMappingURL=model-file-resolver.d.ts.map

package/dist/model-file-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-file-resolver.d.ts","sourceRoot":"","sources":["../src/model-file-resolver.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzC,UAAU,gBAAgB;IAAG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE;AAOvG,qBAAa,iBAAiB;IAShB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAA4B,OAAO,CAAC,QAAQ,CAAC,SAAS;IARzF,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkD;IACzE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6C;IACrE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAEJ,MAAM,EAAE,wBAAwB,EAAmB,SAAS,EAAE,MAAM;IAIjG,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,UAAO,EAAE,OAAO,GAAE,gBAAqB,EAAE,UAAU,UAAQ,GAAG,OAAO,CAAC,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IAWvI,iBAAiB,IAAI,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;YAO7C,WAAW;IAqCzB,OAAO,CAAC,eAAe;YAIT,WAAW;YAyCX,OAAO;YAaP,QAAQ;YAuCR,QAAQ;YAkCR,OAAO;CAiBtB"}

package/dist/model-file-resolver.js

@@ -0,0 +1,304 @@
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream, constants } from "node:fs";
+import { copyFile, mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import checksums from "./model-checksums.json" with { type: "json" };
+import { modelCacheStagingRoot } from "./model-cache-paths.js";
+import { EngineFault } from "./store.js";
+const pinned = checksums;
+const MAX_FILE_BYTES = 2 * 1024 ** 3;
+const MAX_BUFFER_BYTES = 16 * 1024 ** 2;
+export class ModelFileResolver {
+    config;
+    workspace;
+    failure;
+    active = new Set();
+    network = new AbortController();
+    stopped = false;
+    pending = new Map();
+    verified = new Map();
+    staging;
+    constructor(config, workspace) {
+        this.config = config;
+        this.workspace = workspace;
+        this.staging = modelCacheStagingRoot(config.modelCacheDir, workspace);
+    }
+    get(modelId, filename, fatal = true, options = {}, returnPath = false) {
+        if (this.stopped)
+            return Promise.reject(new EngineFault({ code: "CANCELLED", message: "Model loading stopped after a failure" }));
+        const operation = this.getVerified(modelId, filename, fatal, options, returnPath).catch((error) => {
+            if (error instanceof EngineFault && ["MODEL_UNAVAILABLE", "RESOURCE_EXHAUSTED"].includes(error.error.code))
+                this.failure = error;
+            throw error;
+        });
+        this.active.add(operation);
+        void operation.then(() => this.active.delete(operation), () => this.active.delete(operation));
+        return operation;
+    }
+    async drainAfterFailure() {
+        this.stopped = true;
+        this.network.abort();
+        await Promise.allSettled([...this.active]);
+        return this.failure;
+    }
+    async getVerified(modelId, filename, fatal, options, returnPath) {
+        safeRelative(filename);
+        const revision = options.revision ?? "main";
+        safeRelative(revision);
+        if ((this.config.modelId !== undefined && modelId !== this.config.modelId)
+            || (this.config.modelRevision !== undefined && revision !== this.config.modelRevision)) {
+            throw unavailable("Model file request does not match its worker repository and immutable revision");
+        }
+        if (options.cache_dir && resolve(options.cache_dir) !== resolve(this.config.modelCacheDir))
+            throw unavailable("Model cache scope does not match its worker");
+        const key = JSON.stringify([modelId, revision, filename, options.local_files_only === true]);
+        let file = this.verified.get(key);
+        if (!file) {
+            let pending = this.pending.get(key);
+            if (!pending) {
+                pending = this.resolveFile(modelId, revision, filename, options).then(async (file) => {
+                    if (!file)
+                        return null;
+                    const directory = createHash("sha256").update(JSON.stringify([modelId, revision])).digest("hex");
+                    const sealed = join(this.workspace, "models", directory, filename);
+                    await mkdir(dirname(sealed), { recursive: true });
+                    await rename(file, sealed);
+                    return sealed;
+                }).finally(() => this.pending.delete(key));
+                this.pending.set(key, pending);
+            }
+            file = (await pending) ?? undefined;
+            if (file)
+                this.verified.set(key, file);
+        }
+        if (!file) {
+            if (!fatal)
+                return null;
+            if (!this.downloadAllowed(options))
+                throw new EngineFault({ code: "OFFLINE", message: "Required model file is missing. Model downloads are disabled; explicitly prepare the model, then retry." });
+            throw new EngineFault({ code: "FEATURE_UNAVAILABLE", message: "Required model file is unavailable from the configured snapshot" });
+        }
+        if (returnPath)
+            return file;
+        if ((await stat(file)).size > MAX_BUFFER_BYTES)
+            throw exhausted("Model metadata exceeds the buffer limit");
+        return new Uint8Array(await readFile(file));
+    }
+    downloadAllowed(options) {
+        return this.config.allowModelDownload && this.config.allowRemoteModels && options.local_files_only !== true;
+    }
+    async resolveFile(modelId, revision, filename, options) {
+        if (isAbsolute(modelId)) {
+            if (!this.config.allowLocalModels)
+                return null;
+            const path = join(modelId, filename);
+            return await exists(path) ? (await this.snapshot(createReadStream(path))).path : null;
+        }
+        safeRelative(modelId);
+        if (!/^[\w.-]+(?:\/[\w.-]+)?$/u.test(modelId))
+            throw unavailable("Invalid model repository identifier");
+        const known = pinned[`${modelId}/${revision}`];
+        const expected = known?.[filename];
+        const cachePath = join(this.config.modelCacheDir, modelId, ...(revision === "main" ? [] : [revision]), filename);
+        if (known && !expected) {
+            if (await exists(cachePath))
+                throw unavailable("Unrecognized file in a pinned model snapshot");
+            return null;
+        }
+        if (await exists(cachePath)) {
+            const receipt = expected ? undefined : await this.receipt(cachePath, modelId, revision, filename);
+            if (expected || receipt)
+                return (await this.snapshot(createReadStream(cachePath), expected ?? receipt)).path;
+            if (!this.downloadAllowed(options))
+                throw new EngineFault({ code: "OFFLINE", message: "Cached model has no integrity metadata. Model downloads are disabled; explicitly prepare the model to verify it." });
+        }
+        if (this.config.allowLocalModels && this.config.modelRevision === undefined) {
+            const localPath = join(this.config.localModelPath, modelId, filename);
+            if (await exists(localPath))
+                return (await this.snapshot(createReadStream(localPath), expected)).path;
+        }
+        if (!this.downloadAllowed(options))
+            return null;
+        const remote = new URL(`${this.config.remoteHost.replace(/\/$/u, "")}/${this.config.remotePathTemplate
+            .replaceAll("{model}", modelId).replaceAll("{revision}", encodeURIComponent(revision)).replace(/^\//u, "").replace(/\/$/u, "")}/${filename.split("/").map(encodeURIComponent).join("/")}`);
+        const downloaded = await this.download(remote, expected);
+        if (!downloaded)
+            return null;
+        try {
+            const metadata = { version: 1, modelId, revision, filename,
+                ...(downloaded.expected ?? { algorithm: "sha256", digest: downloaded.sha256 }), size: downloaded.size,
+                source: downloaded.expected ? "hub-etag" : "transport" };
+            await this.publish(cachePath, downloaded.path, metadata);
+            return downloaded.path;
+        }
+        catch (error) {
+            await rm(downloaded.path, { force: true });
+            throw error;
+        }
+    }
+    async receipt(path, modelId, revision, filename) {
+        const receiptPath = `${path}.videobook-integrity.json`;
+        if (!await exists(receiptPath))
+            return undefined;
+        if ((await stat(receiptPath)).size > 16_384)
+            throw unavailable("Invalid model integrity metadata");
+        let record;
+        try {
+            record = JSON.parse(await readFile(receiptPath, "utf8"));
+        }
+        catch {
+            throw unavailable("Invalid model integrity metadata");
+        }
+        if (!record || record.version !== 1 || record.modelId !== modelId || record.revision !== revision || record.filename !== filename
+            || !validDigest(record) || !Number.isSafeInteger(record.size) || record.size < 0 || record.size > MAX_FILE_BYTES
+            || !["hub-etag", "transport"].includes(record.source))
+            throw unavailable("Invalid model integrity metadata");
+        return record;
+    }
+    async download(initial, expected) {
+        let url = initial;
+        let upstream;
+        for (let redirects = 0; redirects <= 5; redirects++) {
+            if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+                throw unavailable("Unsupported model download URL");
+            const headers = new Headers({ "Accept-Encoding": "identity" });
+            const token = process.env.HF_TOKEN ?? process.env.HUGGING_FACE_HUB_TOKEN;
+            if (token && url.origin === "https://huggingface.co")
+                headers.set("Authorization", `Bearer ${token}`);
+            const response = await fetch(url, { headers, redirect: "manual", signal: this.network.signal });
+            if (redirects === 0)
+                upstream = headerDigest(response.headers, response.status === 200);
+            if ([301, 302, 303, 307, 308].includes(response.status)) {
+                await response.body?.cancel();
+                const location = response.headers.get("location");
+                if (!location)
+                    throw unavailable("Model download redirect is missing its location");
+                const next = new URL(location, url);
+                if (url.protocol === "https:" && next.protocol !== "https:")
+                    throw unavailable("Model download cannot redirect to an insecure connection");
+                url = next;
+                continue;
+            }
+            if (response.status !== 200 || !response.body) {
+                await response.body?.cancel();
+                if (response.status === 404)
+                    return null;
+                throw unavailable("Model download did not return a complete file");
+            }
+            if (expected && upstream && (expected.algorithm !== upstream.algorithm || expected.digest !== upstream.digest)) {
+                await response.body.cancel();
+                throw unavailable("Model metadata does not match the pinned checksum");
+            }
+            const digest = expected ?? upstream;
+            const length = Number(response.headers.get("content-length"));
+            if ((digest?.size ?? 0) > MAX_FILE_BYTES || length > MAX_FILE_BYTES) {
+                await response.body.cancel();
+                throw exhausted("Model download exceeds the file limit");
+            }
+            return { ...await this.snapshot(response.body, digest), expected: digest };
+        }
+        throw unavailable("Model download exceeded its redirect limit");
+    }
+    async snapshot(source, expected) {
+        await mkdir(join(this.workspace, "models"), { recursive: true });
+        const path = join(this.workspace, "models", randomUUID());
+        let size = 0;
+        const sha256 = createHash("sha256");
+        const output = await open(path, "wx", 0o600);
+        try {
+            for await (const chunk of source) {
+                size += chunk.byteLength;
+                if (size > MAX_FILE_BYTES)
+                    throw exhausted("Model file exceeds the supported size");
+                sha256.update(chunk);
+                await output.writeFile(chunk);
+            }
+            await output.sync();
+            await output.close();
+            const digest = sha256.digest("hex");
+            if (expected) {
+                if (expected.size !== undefined && expected.size !== size)
+                    throw unavailable("Model file size does not match its integrity metadata");
+                let actual = digest;
+                if (expected.algorithm === "git-sha1") {
+                    const hash = createHash("sha1").update(`blob ${size}\0`);
+                    for await (const chunk of createReadStream(path))
+                        hash.update(chunk);
+                    actual = hash.digest("hex");
+                }
+                if (actual !== expected.digest)
+                    throw unavailable("Model checksum verification failed");
+            }
+            return { path, sha256: digest, size };
+        }
+        catch (error) {
+            await output.close().catch(() => undefined);
+            await rm(path, { force: true });
+            throw error;
+        }
+    }
+    async publish(destination, snapshot, receipt) {
+        await mkdir(this.staging, { recursive: true });
+        await mkdir(dirname(destination), { recursive: true });
+        const temporary = join(this.staging, randomUUID());
+        const metadata = `${temporary}.json`;
+        try {
+            await copyFile(snapshot, temporary, constants.COPYFILE_FICLONE);
+            const output = await open(temporary, "r+");
+            try {
+                await output.sync();
+            }
+            finally {
+                await output.close();
+            }
+            const record = await open(metadata, "wx", 0o600);
+            try {
+                await record.writeFile(JSON.stringify(receipt));
+                await record.sync();
+            }
+            finally {
+                await record.close();
+            }
+            await rename(temporary, destination);
+            await rename(metadata, `${destination}.videobook-integrity.json`);
+        }
+        finally {
+            await Promise.all([rm(temporary, { force: true }), rm(metadata, { force: true })]);
+        }
+    }
+}
+function safeRelative(path) {
+    if (!path || isAbsolute(path) || path.includes("\\") || path.includes("\0") || path.split("/").some((part) => !part || part === "." || part === ".."))
+        throw unavailable("Invalid model file path");
+}
+async function exists(path) {
+    try {
+        const file = await stat(path);
+        if (!file.isFile())
+            throw unavailable("Model path is not a regular file");
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function validDigest(value) {
+    return value.algorithm === "sha256" ? /^[a-f0-9]{64}$/u.test(value.digest)
+        : value.algorithm === "git-sha1" && /^[a-f0-9]{40}$/u.test(value.digest);
+}
+function headerDigest(headers, complete) {
+    const tag = (headers.get("x-linked-etag") ?? headers.get("etag"))?.replace(/^"|"$/gu, "");
+    if (!tag)
+        return undefined;
+    const algorithm = /^[a-f0-9]{64}$/iu.test(tag) ? "sha256" : /^[a-f0-9]{40}$/iu.test(tag) ? "git-sha1" : undefined;
+    if (!algorithm)
+        return undefined;
+    const rawSize = headers.get("x-linked-size") ?? (complete && !headers.get("content-encoding") ? headers.get("content-length") : null);
+    const size = rawSize === null ? undefined : Number(rawSize);
+    return { algorithm, digest: tag.toLowerCase(), ...(Number.isSafeInteger(size) && size >= 0 ? { size } : {}) };
+}
+function unavailable(message) { return new EngineFault({ code: "MODEL_UNAVAILABLE", message }); }
+function exhausted(message) { return new EngineFault({ code: "RESOURCE_EXHAUSTED", message }); }
+//# sourceMappingURL=model-file-resolver.js.map