@camstack/addon-pipeline 1.2.137 → 1.2.138

package/dist/addon-utils-C8KTuPdE.mjs

@@ -1,583 +0,0 @@
-import "node:crypto";
-import * as fs from "node:fs";
-import { createReadStream, promises } from "node:fs";
-import * as path$1 from "node:path";
-import path from "node:path";
-import { promisify } from "node:util";
-import { brotliCompress, constants, gzip } from "node:zlib";
-//#region ../system/dist/file-data-plane-BhKdxJgf.mjs
-function isNonEmptyFile(filePath) {
-	return fs.existsSync(filePath) && fs.statSync(filePath).size > 0;
-}
-/**
-* Sibling files of a single-file (non-directory) format — extra files the
-* format needs, fetched from the same remote directory as `url` and stored
-* flat alongside the main file in `modelsDir`. Catalog-declared via
-* `formatEntry.files`, e.g. OpenVINO IR lists its `.bin` weights next to the
-* `.xml`. The downloader stays format-agnostic; the convention lives in the
-* catalog data (like `MLPACKAGE_FILES` for the directory case).
-*/
-function siblingFilesFor(formatEntry) {
-	return formatEntry.isDirectory ? [] : formatEntry.files ?? [];
-}
-/** Resolve a sibling's remote URL relative to the main file's directory. */
-function siblingUrl(mainUrl, sibling) {
-	return mainUrl.replace(/[^/]+$/, sibling);
-}
-/** Build fetch headers, including HF auth token for huggingface.co URLs */
-function buildHeaders(url) {
-	const headers = { "User-Agent": "CamStack/1.0" };
-	const hfToken = process.env["HF_TOKEN"] ?? process.env["HUGGING_FACE_HUB_TOKEN"];
-	if (hfToken && url.includes("huggingface.co")) headers["Authorization"] = `Bearer ${hfToken}`;
-	return headers;
-}
-var DEFAULT_MAX_REDIRECTS = 5;
-function normalizeDownloadOptions(third) {
-	if (typeof third === "function") return { onProgress: third };
-	return third ?? {};
-}
-function isRedirectStatus(status) {
-	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
-}
-function resolveRedirectUrl(current, location) {
-	return new URL(location, current);
-}
-async function downloadFile(url, destPath, onProgressOrOptions) {
-	if (fs.existsSync(destPath)) return destPath;
-	const opts = normalizeDownloadOptions(onProgressOrOptions);
-	const fetchImpl = opts.fetchImpl ?? fetch;
-	const maxRedirects = opts.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
-	fs.mkdirSync(path$1.dirname(destPath), { recursive: true });
-	const tmpPath = destPath + ".downloading";
-	try {
-		let current = url;
-		const seen = /* @__PURE__ */ new Set();
-		let response;
-		const manual = opts.redirectPolicy !== void 0;
-		for (let hop = 0; hop <= maxRedirects; hop++) {
-			const parsed = new URL(current);
-			if (opts.redirectPolicy) opts.redirectPolicy(parsed, hop);
-			if (seen.has(parsed.href)) throw new Error(`Redirect loop detected at ${parsed.href}`);
-			seen.add(parsed.href);
-			const controller = opts.timeoutMs !== void 0 ? new AbortController() : void 0;
-			const timer = controller && opts.timeoutMs !== void 0 ? setTimeout(() => controller.abort(), opts.timeoutMs) : void 0;
-			try {
-				response = await fetchImpl(current, {
-					redirect: manual ? "manual" : "follow",
-					headers: buildHeaders(current),
-					...controller ? { signal: controller.signal } : {}
-				});
-			} finally {
-				if (timer) clearTimeout(timer);
-			}
-			if (manual && isRedirectStatus(response.status)) {
-				const location = response.headers.get("location");
-				if (!location) throw new Error(`Redirect ${response.status} missing Location header`);
-				if (hop >= maxRedirects) throw new Error(`Too many redirects (max ${maxRedirects}) downloading ${url}`);
-				current = resolveRedirectUrl(current, location).href;
-				continue;
-			}
-			break;
-		}
-		if (!response) throw new Error(`No response downloading ${url}`);
-		if (manual && isRedirectStatus(response.status)) throw new Error(`Too many redirects (max ${maxRedirects}) downloading ${url}`);
-		if (!response.ok) throw new Error(`HTTP ${response.status} downloading ${url}`);
-		if (!response.body) throw new Error(`No response body from ${url}`);
-		const total = parseInt(response.headers.get("content-length") ?? "0", 10);
-		let downloaded = 0;
-		const fileStream = fs.createWriteStream(tmpPath);
-		const reader = response.body.getReader();
-		try {
-			for (;;) {
-				const { done, value } = await reader.read();
-				if (done || !value) break;
-				downloaded += value.length;
-				if (opts.maxBytes !== void 0 && downloaded > opts.maxBytes) throw new Error(`Downloaded ${downloaded} bytes exceeds the ${opts.maxBytes}-byte limit`);
-				fileStream.write(value);
-				opts.onProgress?.(downloaded, total);
-			}
-		} finally {
-			fileStream.end();
-			await new Promise((resolve, reject) => {
-				fileStream.on("finish", resolve);
-				fileStream.on("error", reject);
-			});
-		}
-		fs.renameSync(tmpPath, destPath);
-		return destPath;
-	} catch (err) {
-		try {
-			fs.unlinkSync(tmpPath);
-		} catch {}
-		throw err;
-	}
-}
-/**
-* Download every file in a HuggingFace directory bundle (e.g.,
-* `.mlpackage` / OpenVINO IR pair) atomically. `knownFiles` lists the
-* relative paths inside the directory; the function fetches each from
-* `${url}/${file}` and renames the staging directory only on full
-* success. Mirrors `ModelDownloadService.downloadDirectory` but
-* exposed as a standalone for catalog-less callers.
-*/
-async function downloadDirectory(url, destDir, knownFiles, onProgress) {
-	const match = url.match(/huggingface\.co\/([^/]+\/[^/]+)\/resolve\/main\/(.+)/);
-	if (!match) throw new Error(`Cannot parse HuggingFace URL: ${url}`);
-	const [, repo, dirPath] = match;
-	const files = (knownFiles ?? []).map((f) => ({
-		relativePath: f,
-		fileUrl: `https://huggingface.co/${repo}/resolve/main/${dirPath}/${f}`
-	}));
-	if (files.length === 0) throw new Error(`Directory bundle requires explicit \`files\` list (got none for ${url})`);
-	const tmpDir = destDir + ".downloading";
-	fs.rmSync(tmpDir, {
-		recursive: true,
-		force: true
-	});
-	fs.mkdirSync(tmpDir, { recursive: true });
-	let totalDownloaded = 0;
-	try {
-		for (const file of files) {
-			const destPath = path$1.join(tmpDir, file.relativePath);
-			fs.mkdirSync(path$1.dirname(destPath), { recursive: true });
-			await downloadFile(file.fileUrl, destPath, (downloaded, _total) => {
-				onProgress?.(totalDownloaded + downloaded, void 0);
-			});
-			totalDownloaded += fs.statSync(destPath).size;
-		}
-		fs.rmSync(destDir, {
-			recursive: true,
-			force: true
-		});
-		fs.renameSync(tmpDir, destDir);
-	} catch (err) {
-		fs.rmSync(tmpDir, {
-			recursive: true,
-			force: true
-		});
-		throw err;
-	}
-}
-/**
-* Resolve a `ModelCatalogEntry` against `modelsDir`: download model file
-* (or directory bundle) + extra files (labels JSON, charset dict, …),
-* skip if already on disk. Returns the local model path.
-*/
-async function ensureModel(modelsDir, entry, format, onProgress) {
-	const formatEntry = entry.formats[format];
-	if (!formatEntry) throw new Error(`Model "${entry.id}" has no ${format} format. Available: ${Object.keys(entry.formats).join(", ")}`);
-	if (entry.extraFiles) for (const extra of entry.extraFiles) await downloadFile(extra.url, path$1.join(modelsDir, extra.filename));
-	const filename = formatEntry.url.split("/").pop() ?? `${entry.id}.${format}`;
-	const modelPath = path$1.join(modelsDir, filename);
-	const siblings = siblingFilesFor(formatEntry);
-	if (fs.existsSync(modelPath)) if (formatEntry.isDirectory && !fs.existsSync(path$1.join(modelPath, "Manifest.json"))) fs.rmSync(modelPath, {
-		recursive: true,
-		force: true
-	});
-	else if (siblings.some((f) => !isNonEmptyFile(path$1.join(modelsDir, f)))) {} else return modelPath;
-	fs.mkdirSync(modelsDir, { recursive: true });
-	if (formatEntry.isDirectory) await downloadDirectory(formatEntry.url, modelPath, formatEntry.files, onProgress);
-	else {
-		await downloadFile(formatEntry.url, modelPath, (downloaded, total) => onProgress?.(downloaded, total === 0 ? void 0 : total));
-		for (const sibling of siblings) await downloadFile(siblingUrl(formatEntry.url, sibling), path$1.join(modelsDir, sibling));
-	}
-	return modelPath;
-}
-/** Compute the on-disk path for a given model + format, even when not yet downloaded. */
-function getModelFilePath(modelsDir, entry, format) {
-	const formatEntry = entry.formats[format];
-	if (!formatEntry) return null;
-	const filename = formatEntry.url.split("/").pop() ?? `${entry.id}.${format}`;
-	return path$1.join(modelsDir, filename);
-}
-/** True iff the model file (or `Manifest.json` for directory bundles) exists and is non-empty. */
-function isModelDownloaded(modelsDir, entry, format) {
-	const formatEntry = entry.formats[format];
-	if (!formatEntry) return false;
-	const modelPath = getModelFilePath(modelsDir, entry, format);
-	if (!modelPath || !fs.existsSync(modelPath)) return false;
-	if (formatEntry.isDirectory) return fs.existsSync(path$1.join(modelPath, "Manifest.json"));
-	if (fs.statSync(modelPath).size <= 0) return false;
-	return siblingFilesFor(formatEntry).every((f) => isNonEmptyFile(path$1.join(modelsDir, f)));
-}
-/** Remove the on-disk model file/directory. Returns true if something was deleted. */
-function deleteModelFromDisk(modelsDir, entry, format) {
-	const modelPath = getModelFilePath(modelsDir, entry, format);
-	if (!modelPath || !fs.existsSync(modelPath)) return false;
-	const formatEntry = entry.formats[format];
-	if (formatEntry?.isDirectory) fs.rmSync(modelPath, {
-		recursive: true,
-		force: true
-	});
-	else {
-		fs.unlinkSync(modelPath);
-		if (formatEntry) for (const sibling of siblingFilesFor(formatEntry)) {
-			const sibPath = path$1.join(modelsDir, sibling);
-			if (fs.existsSync(sibPath)) fs.unlinkSync(sibPath);
-		}
-	}
-	return true;
-}
-/**
-* Map a rel path to one candidate absolute path PER root, keeping only roots the
-* path stays within (traversal guard). The handler serves the first candidate
-* that exists. Rejects a path that escapes every root.
-*/
-function resolveFilePath(roots, rel) {
-	if (rel.length === 0) return { error: "forbidden" };
-	const candidates = [];
-	for (const rootDir of roots) {
-		const root = path.resolve(rootDir);
-		const abs = path.resolve(root, rel);
-		if (abs === root || abs.startsWith(root + path.sep)) candidates.push(abs);
-	}
-	if (candidates.length === 0) return { error: "forbidden" };
-	return { candidates };
-}
-var DEFAULT_CONTENT_TYPES = {
-	".m3u8": "application/vnd.apple.mpegurl",
-	".m4s": "video/mp4",
-	".mp4": "video/mp4",
-	".idx": "application/octet-stream",
-	".html": "text/html; charset=utf-8",
-	".js": "application/javascript; charset=utf-8",
-	".mjs": "application/javascript; charset=utf-8",
-	".css": "text/css; charset=utf-8",
-	".json": "application/json; charset=utf-8",
-	".map": "application/json; charset=utf-8",
-	".svg": "image/svg+xml",
-	".png": "image/png",
-	".jpg": "image/jpeg",
-	".jpeg": "image/jpeg",
-	".ico": "image/x-icon",
-	".woff2": "font/woff2",
-	".woff": "font/woff",
-	".ttf": "font/ttf"
-};
-function contentTypeFor(filePath, overrides) {
-	const ext = path.extname(filePath).toLowerCase();
-	return overrides?.[ext] ?? DEFAULT_CONTENT_TYPES[ext] ?? "application/octet-stream";
-}
-/** Parse an HTTP `Range` header against a known size. Null = serve whole file. */
-function parseRangeHeader(header, size) {
-	if (!header) return null;
-	const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
-	if (!m) return null;
-	const [, rawStart, rawEnd] = m;
-	if (rawStart === "" && rawEnd === "") return null;
-	let start;
-	let end;
-	if (rawStart === "") {
-		const n = Number(rawEnd);
-		if (n <= 0) return null;
-		start = Math.max(0, size - n);
-		end = size - 1;
-	} else {
-		start = Number(rawStart);
-		end = rawEnd === "" ? size - 1 : Number(rawEnd);
-	}
-	if (!Number.isFinite(start) || !Number.isFinite(end) || start > end || start >= size) return null;
-	return {
-		start,
-		end: Math.min(end, size - 1)
-	};
-}
-/**
-* Content-coding for addon-served static assets: `Accept-Encoding` negotiation,
-* an eligibility rule, and a BOUNDED cache of the compressed bytes.
-*
-* ## Why the ADDON owns the encoding
-*
-* The hub's `/addon/:addonId/*` bridge is registered `{ compress: false }`. That
-* is not an oversight — on 2026-07-16 the global `@fastify/compress` was found
-* emitting an EMPTY brotli stream (`content-encoding: br`, `content-length: 0`)
-* for any compressible body over its 1 KiB threshold once the body had crossed
-* the UDS route bridge of a FORKED addon. It silently broke the notifier SVG
-* icons; the deploy-bundle pull route had already dodged the same class with
-* `compress: false`. The resolution then, and the contract now, is that an addon
-* route owns its content-coding END TO END: it negotiates, it compresses, it
-* stamps `content-encoding` + `Vary`, and the hub pipes those bytes through
-* untouched (`proxyToUpstream` replays the upstream headers verbatim).
-*
-* So compression belongs HERE, in the shared file data-plane, and nowhere above
-* it. Anything that re-compresses on top of this reintroduces the empty-brotli
-* bug rather than doubling the ratio.
-*
-* ## Why the bytes are cached, and why the cache is bounded
-*
-* Measured on the stream-broker embed bundle (`index-<hash>.js`, 1,443,142 B):
-* gzip-6 → 360,868 B, brotli-5 → 327,419 B in 27 ms, brotli-11 → 293,677 B in
-* 2,233 ms. Quality 5 is the request-path choice: 77% off the wire for 27 ms
-* paid ONCE. Quality 11 buys another 2.3% for eighty times the CPU, on a path
-* where a real client is waiting.
-*
-* The cache is an LRU bounded by BOTH entry count and total bytes, and it
-* refuses assets over {@link COMPRESSION_MAX_ASSET_BYTES} outright. An unbounded
-* `Map` keyed by URL is how a long-lived process walks into an OOM, and this
-* repo has already spent a session on one.
-*
-* The key carries `mtimeMs` and `size`, so a rebuild that rewrites an asset in
-* place under an UNCHANGED name (an SPA shell, a service worker) can never be
-* served from the previous build's bytes.
-*/
-var brotliAsync = promisify(brotliCompress);
-var gzipAsync = promisify(gzip);
-/** LRU bounds. Both are enforced; whichever binds first evicts. */
-var MAX_CACHE_ENTRIES = 64;
-var MAX_CACHE_BYTES = 32 * 1024 * 1024;
-/** Brotli quality — see the file header for the measured trade. */
-var BROTLI_QUALITY = 5;
-/**
-* Content types worth compressing. An ALLOW-list, not a deny-list: an unknown
-* type (`application/octet-stream`) is assumed to be opaque binary. This is what
-* keeps jpeg/png/webp/mp4/m4s/woff2 out — running brotli over them burns CPU to
-* make the body marginally BIGGER.
-*/
-var COMPRESSIBLE_EXACT = new Set([
-	"application/javascript",
-	"application/ecmascript",
-	"application/json",
-	"application/manifest+json",
-	"application/wasm",
-	"application/xml",
-	"application/xhtml+xml",
-	"application/vnd.apple.mpegurl",
-	"image/svg+xml"
-]);
-/** Is a body of this content type worth compressing at all? */
-function isCompressibleContentType(contentType) {
-	const base = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
-	if (base.length === 0) return false;
-	if (base.startsWith("text/")) return true;
-	if (base.endsWith("+json") || base.endsWith("+xml")) return true;
-	return COMPRESSIBLE_EXACT.has(base);
-}
-/** Parse `Accept-Encoding` into tokens with their q-values (default 1). */
-function parseAcceptEncoding(header) {
-	if (header === void 0 || header.trim().length === 0) return [];
-	const out = [];
-	for (const part of header.split(",")) {
-		const [rawToken, ...params] = part.split(";");
-		const token = rawToken?.trim().toLowerCase() ?? "";
-		if (token.length === 0) continue;
-		let q = 1;
-		for (const param of params) {
-			const [name, value] = param.split("=");
-			if (name?.trim().toLowerCase() !== "q") continue;
-			const parsed = Number(value?.trim());
-			q = Number.isFinite(parsed) ? parsed : 1;
-		}
-		out.push({
-			token,
-			q
-		});
-	}
-	return out;
-}
-function accepts(prefs, token) {
-	const exact = prefs.find((p) => p.token === token);
-	if (exact) return exact.q > 0;
-	const wildcard = prefs.find((p) => p.token === "*");
-	return wildcard !== void 0 && wildcard.q > 0;
-}
-/**
-* Pick a coding for this request: brotli when offered, else gzip, else identity.
-*
-* Returns `null` for identity — including when the header is ABSENT. A client
-* that offers nothing gets the raw bytes; guessing on its behalf is how a
-* non-negotiating consumer (a native fetch, a probe, an OTA puller) ends up with
-* a body it cannot read.
-*/
-function negotiateContentEncoding(acceptEncoding) {
-	const prefs = parseAcceptEncoding(acceptEncoding);
-	if (prefs.length === 0) return null;
-	if (accepts(prefs, "br")) return "br";
-	if (accepts(prefs, "gzip")) return "gzip";
-	return null;
-}
-var cache = /* @__PURE__ */ new Map();
-var inFlight = /* @__PURE__ */ new Map();
-var compressions = 0;
-var hits = 0;
-var cachedBytes = 0;
-function cacheKey(key) {
-	return `${key.encoding}|${String(key.mtimeMs)}|${String(key.size)}|${key.path}`;
-}
-/** Evict least-recently-used entries until both bounds hold. */
-function evictToBounds() {
-	for (const [k, buf] of cache) {
-		if (cache.size <= MAX_CACHE_ENTRIES && cachedBytes <= MAX_CACHE_BYTES) return;
-		cache.delete(k);
-		cachedBytes -= buf.byteLength;
-	}
-}
-async function compressBody(raw, encoding) {
-	if (encoding === "gzip") return await gzipAsync(raw);
-	return await brotliAsync(raw, { params: {
-		[constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY,
-		[constants.BROTLI_PARAM_SIZE_HINT]: raw.byteLength
-	} });
-}
-/**
-* Compressed bytes for one asset, compressing at most once per key.
-*
-* `null` means "send the original" — the asset is too large to buffer, the
-* source could not be read, or compression did not actually shrink it. Every
-* failure degrades to identity, so this can only ever be an optimisation.
-*
-* Concurrent callers for the same key share ONE compression: a cold cache hit by
-* a dozen parallel asset requests must not run zlib a dozen times.
-*/
-async function getCompressedAsset(key, readSource) {
-	if (key.size > 8388608) return null;
-	const id = cacheKey(key);
-	const cached = cache.get(id);
-	if (cached) {
-		cache.delete(id);
-		cache.set(id, cached);
-		hits += 1;
-		return cached;
-	}
-	const pending = inFlight.get(id) ?? (async () => {
-		let raw;
-		try {
-			raw = await readSource();
-		} catch {
-			return null;
-		}
-		const out = await compressBody(raw, key.encoding);
-		compressions += 1;
-		if (out.byteLength >= raw.byteLength) return null;
-		cache.set(id, out);
-		cachedBytes += out.byteLength;
-		evictToBounds();
-		return out;
-	})();
-	inFlight.set(id, pending);
-	try {
-		return await pending;
-	} catch {
-		return null;
-	} finally {
-		inFlight.delete(id);
-	}
-}
-/**
-* A ready-made data-plane request handler that serves files from a set of roots
-* with HTTP `Range`, for addons whose data-plane is "stream files off disk"
-* (recording playback, scrub-frame stores, exported clips).
-*
-* This is the addon-side handler the addon hands to `ctx.dataPlane.serve({ handler })`.
-* It receives the REAL Node `req`/`res`, resolves the request path against the
-* addon's roots (traversal-guarded), and streams the file. NO token and NO CORS:
-* the hub already authenticated the caller and the data plane is same-origin
-* through the hub's port. Reuses the shared Range/content-type/traversal helpers
-* so there is one implementation across the standalone file-server and this.
-*
-* It also owns its own CONTENT-CODING. The hub bridge is `{ compress: false }`
-* because the global compressor emits an empty brotli stream over the forked-
-* addon route bridge, so nothing above this layer will ever compress an addon
-* body — see `asset-compression.ts` for the incident and the contract.
-*/
-/** Build a `(req, res)` handler that serves `getRoots()` files with Range. */
-function createFileDataPlaneHandler(opts) {
-	return async (req, res) => {
-		if (req.method !== "GET" && req.method !== "HEAD") {
-			res.writeHead(405).end();
-			return;
-		}
-		const urlPath = (req.url ?? "/").split("?")[0] ?? "/";
-		let rel;
-		try {
-			rel = decodeURIComponent(urlPath.replace(/^\/+/, ""));
-		} catch {
-			res.writeHead(400).end();
-			return;
-		}
-		if (rel.length === 0) {
-			res.writeHead(404).end();
-			return;
-		}
-		const resolved = resolveFilePath(opts.getRoots(), rel);
-		if ("error" in resolved) {
-			res.writeHead(403).end();
-			return;
-		}
-		let absPath = null;
-		let size = 0;
-		let mtimeMs = 0;
-		for (const candidate of resolved.candidates) try {
-			const st = await promises.stat(candidate);
-			if (st.isFile()) {
-				absPath = candidate;
-				size = st.size;
-				mtimeMs = st.mtimeMs;
-				break;
-			}
-		} catch {}
-		if (absPath === null) {
-			res.writeHead(404).end();
-			return;
-		}
-		const contentType = contentTypeFor(absPath, opts.contentTypes);
-		const compressible = isCompressibleContentType(contentType);
-		const baseHeaders = {
-			"content-type": contentType,
-			"accept-ranges": "bytes",
-			"cache-control": opts.cacheControl?.(rel) ?? "no-cache",
-			...compressible ? { vary: "accept-encoding" } : {}
-		};
-		const range = parseRangeHeader(req.headers.range, size);
-		if (range) {
-			res.writeHead(206, {
-				...baseHeaders,
-				"content-range": `bytes ${range.start}-${range.end}/${size}`,
-				"content-length": String(range.end - range.start + 1)
-			});
-			if (req.method === "HEAD") {
-				res.end();
-				return;
-			}
-			createReadStream(absPath, {
-				start: range.start,
-				end: range.end
-			}).pipe(res);
-			return;
-		}
-		const encoding = compressible ? negotiateContentEncoding(req.headers["accept-encoding"]) : null;
-		if (encoding !== null && size >= 1024) {
-			const filePath = absPath;
-			const body = await getCompressedAsset({
-				path: filePath,
-				mtimeMs,
-				size,
-				encoding
-			}, () => promises.readFile(filePath));
-			if (body !== null) {
-				res.writeHead(200, {
-					...baseHeaders,
-					"content-encoding": encoding,
-					"accept-ranges": "none",
-					"content-length": String(body.byteLength)
-				});
-				if (req.method === "HEAD") {
-					res.end();
-					return;
-				}
-				res.end(body);
-				return;
-			}
-		}
-		res.writeHead(200, {
-			...baseHeaders,
-			"content-length": String(size)
-		});
-		if (req.method === "HEAD") {
-			res.end();
-			return;
-		}
-		createReadStream(absPath).pipe(res);
-	};
-}
-//#endregion
-export { ensureModel as a, downloadFile as i, createFileDataPlaneHandler as n, isModelDownloaded as o, deleteModelFromDisk as r, parseRangeHeader as s, contentTypeFor as t };