emdash 0.41.0 → 0.42.0

package/dist/artifact-fetch-B9W4CEST.mjs

@@ -1,659 +0,0 @@
-import { a as UNSUPPORTED_AUTH_MESSAGE, i as verificationError, n as multihashFromBlobCid, o as unsupportedAuthDetails, r as verifyMultihash } from "./checksum-CClweQzI.mjs";
-import { i as resolveAndValidateExternalUrlTarget, t as SsrfError } from "./ssrf-Dv0_tRpo.mjs";
-import { RECORD_SCOPED_BLOB_CACHE_TYPE } from "@emdash-cms/registry-lexicons";
-
-//#region ../registry-verification/dist/fetch-B66dZAfm.js
-const DIGITS = /^\d+$/;
-const IPV4_LITERAL = /^\d{1,3}(?:\.\d{1,3}){3}$/;
-const IPV4_PART = /^\d{1,3}$/;
-const IPV6_PART = /^[0-9a-f]{1,4}$/i;
-const TRAILING_DOT$1 = /\.+$/;
-const DEFAULT_FETCH_LIMITS = {
-	headerTimeoutMs: 1e4,
-	totalTimeoutMs: 3e4,
-	maxBytes: 25 * 1024 * 1024,
-	maxRedirects: 3
-};
-async function fetchVerifiedResource(value, options) {
-	const limits = {
-		headerTimeoutMs: options.headerTimeoutMs ?? DEFAULT_FETCH_LIMITS.headerTimeoutMs,
-		totalTimeoutMs: options.totalTimeoutMs ?? DEFAULT_FETCH_LIMITS.totalTimeoutMs,
-		maxBytes: options.maxBytes ?? DEFAULT_FETCH_LIMITS.maxBytes,
-		maxRedirects: options.maxRedirects ?? DEFAULT_FETCH_LIMITS.maxRedirects
-	};
-	if (!areValidLimits(limits)) return verificationError("INVALID_URL", "Fetch limits must be positive integers.");
-	const startedAt = Date.now();
-	let currentUrl = parseAndValidateUrl(value, void 0, options.allowHttpLocalhost === true);
-	if (!currentUrl.success) return currentUrl;
-	for (let redirects = 0;; redirects += 1) {
-		const remaining = limits.totalTimeoutMs - (Date.now() - startedAt);
-		if (remaining <= 0) return verificationError("RESOURCE_TIMEOUT", "The resource fetch exceeded its total timeout.");
-		const host = isAllowedLoopback(currentUrl.value, options.allowHttpLocalhost === true) ? {
-			success: true,
-			value: true
-		} : await validateHost(currentUrl.value, options.resolveHostname, remaining);
-		if (!host.success) return host;
-		const remainingAfterResolution = limits.totalTimeoutMs - (Date.now() - startedAt);
-		if (remainingAfterResolution <= 0) return verificationError("RESOURCE_TIMEOUT", "The resource fetch exceeded its total timeout.");
-		const response = await fetchResponse(options.fetch, currentUrl.value, Math.min(remainingAfterResolution, limits.headerTimeoutMs));
-		if (!response.success) return response;
-		if (isRedirect(response.value.status)) {
-			if (redirects >= limits.maxRedirects) return verificationError("REDIRECT_LIMIT_EXCEEDED", "The resource exceeded the redirect limit.");
-			const location = response.value.headers.get("location");
-			if (location === null) return verificationError("REDIRECT_LOCATION_MISSING", "The redirect response has no location header.");
-			currentUrl = parseAndValidateUrl(location, currentUrl.value, options.allowHttpLocalhost === true);
-			if (!currentUrl.success) return currentUrl;
-			continue;
-		}
-		if (!response.value.ok && !options.allowedStatuses?.includes(response.value.status)) return verificationError("RESOURCE_STATUS_ERROR", `The resource returned HTTP ${response.value.status}.`);
-		const contentLength = response.value.headers.get("content-length");
-		if (contentLength !== null && (!DIGITS.test(contentLength) || Number(contentLength) > limits.maxBytes)) return verificationError("RESOURCE_SIZE_EXCEEDED", "The resource exceeds the byte limit.");
-		const bytes = await readResponse(response.value, limits.maxBytes, startedAt, limits.totalTimeoutMs);
-		if (!bytes.success) return bytes;
-		return {
-			success: true,
-			value: {
-				bytes: bytes.value,
-				url: currentUrl.value,
-				status: response.value.status,
-				headers: response.value.headers
-			}
-		};
-	}
-}
-function parseAndValidateUrl(value, base, allowHttpLocalhost = false) {
-	let url;
-	try {
-		url = new URL(value, base);
-	} catch {
-		return verificationError("INVALID_URL", "The resource URL is invalid.");
-	}
-	if (url.protocol !== "https:" && !isAllowedLoopback(url, allowHttpLocalhost) || url.username !== "" || url.password !== "") return verificationError("INVALID_URL", "Resource URLs must use HTTPS and cannot include credentials.");
-	if (!isAllowedLoopback(url, allowHttpLocalhost) && (isIpLiteral(url.hostname) || isLocalHostname(url.hostname))) return verificationError("HOST_REJECTED", "The resource host is not permitted.");
-	return {
-		success: true,
-		value: url
-	};
-}
-function isAllowedLoopback(url, enabled) {
-	if (!enabled || url.protocol !== "http:" && url.protocol !== "https:") return false;
-	const hostname = url.hostname.toLowerCase().replace(TRAILING_DOT$1, "");
-	return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
-}
-async function validateHost(url, resolver, timeoutMs) {
-	try {
-		const addresses = await withTimeout(Promise.resolve().then(() => resolver(url.hostname)), timeoutMs);
-		if (addresses.length === 0 || addresses.some(isForbiddenAddress)) return verificationError("HOST_REJECTED", "The resource host resolved to a forbidden address.");
-		return {
-			success: true,
-			value: true
-		};
-	} catch (error) {
-		if (isAbortError(error)) return verificationError("RESOURCE_TIMEOUT", "The resource fetch exceeded its total timeout.");
-		return verificationError("HOST_REJECTED", "The resource host could not be validated.");
-	}
-}
-async function fetchResponse(fetchImplementation, url, timeoutMs) {
-	const controller = new AbortController();
-	try {
-		return {
-			success: true,
-			value: await withTimeout(Promise.resolve().then(() => fetchImplementation(url, {
-				method: "GET",
-				redirect: "manual",
-				signal: controller.signal
-			})), timeoutMs, () => controller.abort())
-		};
-	} catch (error) {
-		if (controller.signal.aborted || isAbortError(error)) return verificationError("RESOURCE_TIMEOUT", "The resource response headers timed out.");
-		return verificationError("FETCH_FAILED", "The resource request failed.");
-	}
-}
-async function readResponse(response, maximumBytes, startedAt, totalTimeoutMs) {
-	if (response.body === null) return {
-		success: true,
-		value: new Uint8Array()
-	};
-	const reader = response.body.getReader();
-	const chunks = [];
-	let length = 0;
-	try {
-		for (;;) {
-			const remaining = totalTimeoutMs - (Date.now() - startedAt);
-			if (remaining <= 0) {
-				await reader.cancel();
-				return verificationError("RESOURCE_TIMEOUT", "The resource fetch exceeded its total timeout.");
-			}
-			const chunk = await readWithTimeout(reader, remaining);
-			if (!chunk.success) {
-				await reader.cancel();
-				return chunk;
-			}
-			if (chunk.value.done) break;
-			const value = chunk.value.value;
-			length += value.length;
-			if (length > maximumBytes) {
-				await reader.cancel();
-				return verificationError("RESOURCE_SIZE_EXCEEDED", "The resource exceeds the byte limit.");
-			}
-			chunks.push(value);
-		}
-	} catch {
-		return verificationError("FETCH_FAILED", "The resource response could not be read.");
-	} finally {
-		reader.releaseLock();
-	}
-	const output = new Uint8Array(length);
-	let offset = 0;
-	for (const chunk of chunks) {
-		output.set(chunk, offset);
-		offset += chunk.length;
-	}
-	return {
-		success: true,
-		value: output
-	};
-}
-async function readWithTimeout(reader, timeoutMs) {
-	try {
-		return {
-			success: true,
-			value: await withTimeout(Promise.resolve().then(() => reader.read()), timeoutMs)
-		};
-	} catch (error) {
-		if (isAbortError(error)) return verificationError("RESOURCE_TIMEOUT", "The resource fetch exceeded its total timeout.");
-		return verificationError("FETCH_FAILED", "The resource response could not be read.");
-	}
-}
-/**
-* Every operation has both fulfillment and rejection handlers, so an operation
-* that loses the timeout race cannot later become an unhandled rejection.
-*/
-function withTimeout(operation, timeoutMs, onTimeout) {
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		const timeout = setTimeout(() => {
-			if (settled) return;
-			settled = true;
-			onTimeout?.();
-			reject(new DOMException("Timed out", "AbortError"));
-		}, timeoutMs);
-		operation.then((value) => {
-			if (settled) return void 0;
-			settled = true;
-			clearTimeout(timeout);
-			resolve(value);
-		}, (error) => {
-			if (settled) return void 0;
-			settled = true;
-			clearTimeout(timeout);
-			reject(error);
-		});
-	});
-}
-function areValidLimits(limits) {
-	return Object.values(limits).every((value) => Number.isSafeInteger(value) && value > 0);
-}
-function isRedirect(status) {
-	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
-}
-function isAbortError(error) {
-	return error instanceof DOMException && error.name === "AbortError";
-}
-function isIpLiteral(hostname) {
-	return IPV4_LITERAL.test(hostname) || hostname.includes(":");
-}
-function isLocalHostname(hostname) {
-	const normalized = hostname.toLowerCase();
-	return normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || normalized.endsWith(".internal");
-}
-function isForbiddenAddress(address) {
-	const ipv4 = parseIpv4(address);
-	if (ipv4 !== null) {
-		const [a, b] = ipv4;
-		return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && (b === 0 || b === 168) || a === 198 && (b === 18 || b === 19) || a >= 224;
-	}
-	const ipv6 = parseIpv6(address);
-	if (ipv6 === null) return true;
-	const first = ipv6[0];
-	const isUnspecified = ipv6.every((part) => part === 0);
-	const isLoopback = ipv6.slice(0, 7).every((part) => part === 0) && ipv6[7] === 1;
-	const isPrivate = (first & 65024) === 64512;
-	const isLinkLocal = (first & 65472) === 65152;
-	const isMulticast = (first & 65280) === 65280;
-	if (ipv6.slice(0, 5).every((part) => part === 0) && ipv6[5] === 65535) return isForbiddenAddress(`${ipv6[6] >>> 8}.${ipv6[6] & 255}.${ipv6[7] >>> 8}.${ipv6[7] & 255}`);
-	return isUnspecified || isLoopback || isPrivate || isLinkLocal || isMulticast;
-}
-function parseIpv4(value) {
-	const parts = value.split(".");
-	if (parts.length !== 4) return null;
-	const numbers = parts.map((part) => IPV4_PART.test(part) ? Number(part) : NaN);
-	if (numbers.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return null;
-	return [
-		numbers[0],
-		numbers[1],
-		numbers[2],
-		numbers[3]
-	];
-}
-function parseIpv6(value) {
-	if (value.includes(":::") || value.split("::").length > 2) return null;
-	const [before = "", after = ""] = value.split("::");
-	const head = before === "" ? [] : before.split(":");
-	const tail = after === "" ? [] : after.split(":");
-	const parts = [...head, ...tail];
-	if (parts.some((part) => !IPV6_PART.test(part)) || parts.length > 8) return null;
-	if (!value.includes("::") && parts.length !== 8) return null;
-	const zeroes = value.includes("::") ? 8 - parts.length : 0;
-	return [
-		...head,
-		...Array.from({ length: zeroes }).fill("0"),
-		...tail
-	].map((part) => Number.parseInt(part, 16));
-}
-
-//#endregion
-//#region ../registry-verification/dist/artifact.js
-const DID_DOCUMENT_MAX_BYTES = 256 * 1024;
-const PLC_DID_PATTERN = /^did:plc:[a-z2-7]{24}$/;
-const CID_PATTERN = /^b[a-z2-7]+$/;
-const UNSAFE_PATH_SEGMENT = /[/\\?#]/;
-async function fetchReleaseArtifact(input, options) {
-	const deadline = Date.now() + (options.totalTimeoutMs ?? DEFAULT_FETCH_LIMITS.totalTimeoutMs);
-	const { artifact } = input;
-	if (!artifact.blob && !artifact.url) return verificationError("RELEASE_ARTIFACT_SOURCE_MISSING", "The release artifact must provide a blob or URL.");
-	if (artifact.requiresAuth === true || input.auth !== void 0) return unsupportedAuth(input.auth);
-	const blobCid = modernBlobCid(artifact.blob);
-	const blobMetadata = blobCid && artifact.blob && "ref" in artifact.blob ? artifact.blob : void 0;
-	if (artifact.blob && !blobCid) return verificationError("BLOB_REF_INVALID", "Legacy blob references are not supported.");
-	if (blobCid) {
-		const expected = multihashFromBlobCid(blobCid);
-		if (!expected.success) return expected;
-		if (expected.value !== artifact.checksum) return verificationError("CHECKSUM_MISMATCH", "The artifact checksum does not match its blob reference CID.");
-	}
-	let lastError;
-	for (const cache of input.artifactCaches ?? []) {
-		const serviceEndpoint = recordScopedCacheEndpoint(cache);
-		if (!serviceEndpoint || !blobCid) continue;
-		const cacheUrl = recordScopedBlobCacheUrl(serviceEndpoint, input.record, blobCid);
-		if (!cacheUrl.success) {
-			lastError = cacheUrl.error;
-			continue;
-		}
-		const attemptOptions = withinDeadline(options, deadline);
-		if (!attemptOptions) return timedOut();
-		const result = await fetchAndVerify("artifact-cache", cacheUrl.value, artifact.checksum, withBlobSizeLimit(attemptOptions, blobMetadata), blobMetadata);
-		if (result.success) return result;
-		lastError = result.error;
-	}
-	if (blobCid) {
-		const resolutionOptions = withinDeadline(options, deadline);
-		if (!resolutionOptions) return timedOut();
-		const pds = input.pdsEndpoint ? {
-			success: true,
-			value: input.pdsEndpoint
-		} : await resolvePublisherPdsEndpoint(input.record.did, resolutionOptions);
-		if (pds.success) {
-			const url = blobUrl(pds.value, input.record.did, blobCid);
-			if (url.success) {
-				const attemptOptions = withinDeadline(options, deadline);
-				if (!attemptOptions) return timedOut();
-				const result = await fetchAndVerify("blob", url.value, artifact.checksum, withBlobSizeLimit(attemptOptions, blobMetadata), blobMetadata);
-				if (result.success) return result;
-				lastError = result.error;
-			} else lastError = url.error;
-		} else lastError = pds.error;
-	}
-	if (artifact.url) {
-		const attemptOptions = withinDeadline(options, deadline);
-		if (!attemptOptions) return timedOut();
-		const result = await fetchAndVerify("url", artifact.url, artifact.checksum, withBlobSizeLimit(attemptOptions, blobMetadata), blobMetadata);
-		if (result.success) return result;
-		lastError = result.error;
-	}
-	return lastError ? {
-		success: false,
-		error: lastError
-	} : verificationError("FETCH_FAILED", "The release artifact could not be fetched.");
-}
-function recordScopedBlobCacheUrl(serviceEndpoint, record, blobCid) {
-	try {
-		const endpoint = new URL(serviceEndpoint);
-		if (endpoint.protocol !== "https:" || endpoint.username || endpoint.password || endpoint.pathname !== "/" || endpoint.search || endpoint.hash) throw new Error();
-		const segments = [
-			"r",
-			record.did,
-			record.collection,
-			record.rkey,
-			record.cid,
-			blobCid
-		];
-		if (!CID_PATTERN.test(record.cid) || !CID_PATTERN.test(blobCid) || segments.some((segment) => !isSafePathSegment(segment))) throw new Error();
-		return {
-			success: true,
-			value: new URL(segments.join("/"), endpoint)
-		};
-	} catch {
-		return verificationError("INVALID_URL", "The record-scoped blob cache endpoint is invalid.");
-	}
-}
-function recordScopedImageCacheUrl(serviceEndpoint, preset, record, blobCid) {
-	const raw = recordScopedBlobCacheUrl(serviceEndpoint, record, blobCid);
-	if (!raw.success) return raw;
-	const url = new URL(raw.value);
-	url.pathname = `/img/${preset}${url.pathname}`;
-	return {
-		success: true,
-		value: url
-	};
-}
-async function resolvePublisherPdsEndpoint(publisherDid, options) {
-	const documentUrl = didDocumentUrl(publisherDid);
-	if (!documentUrl) return verificationError("PDS_RESOLUTION_FAILED", "The publisher DID is not supported.");
-	const fetched = await fetchVerifiedResource(documentUrl, {
-		...options,
-		maxBytes: DID_DOCUMENT_MAX_BYTES
-	});
-	if (!fetched.success) return verificationError("PDS_RESOLUTION_FAILED", "The publisher DID document could not be fetched.");
-	let document;
-	try {
-		document = JSON.parse(new TextDecoder().decode(fetched.value.bytes));
-	} catch {
-		return verificationError("PDS_RESOLUTION_FAILED", "The publisher DID document is malformed.");
-	}
-	if (!isRecord(document) || document.id !== publisherDid || !Array.isArray(document.service)) return verificationError("PDS_RESOLUTION_FAILED", "The publisher DID document has no valid PDS service.");
-	const service = document.service.find((value) => isRecord(value) && (value.id === `${publisherDid}#atproto_pds` || value.id === "#atproto_pds") && value.type === "AtprotoPersonalDataServer" && typeof value.serviceEndpoint === "string");
-	if (!isRecord(service) || typeof service.serviceEndpoint !== "string") return verificationError("PDS_RESOLUTION_FAILED", "The publisher DID document has no valid PDS service.");
-	try {
-		const endpoint = new URL(service.serviceEndpoint);
-		if (!(options.allowHttpLocalhost === true && endpoint.protocol === "http:" && (endpoint.hostname === "localhost" || endpoint.hostname === "127.0.0.1")) && endpoint.protocol !== "https:" || endpoint.username || endpoint.password) throw new Error();
-		return {
-			success: true,
-			value: endpoint.href
-		};
-	} catch {
-		return verificationError("PDS_RESOLUTION_FAILED", "The publisher DID document has no valid PDS service.");
-	}
-}
-async function fetchAndVerify(source, url, checksum, options, blobMetadata) {
-	const fetched = await fetchVerifiedResource(url, options);
-	if (!fetched.success) return blobMetadata && fetched.error.code === "RESOURCE_SIZE_EXCEEDED" ? verificationError("BLOB_METADATA_MISMATCH", "The fetched artifact size does not match its signed blob metadata.") : fetched;
-	const verified = await verifyMultihash(fetched.value.bytes, checksum);
-	if (!verified.success) return verified;
-	const contentType = fetched.value.headers.get("content-type")?.split(";", 1)[0]?.trim();
-	if (blobMetadata && (fetched.value.bytes.byteLength !== blobMetadata.size || contentType !== void 0 && contentType !== blobMetadata.mimeType)) return verificationError("BLOB_METADATA_MISMATCH", "The fetched artifact does not match its signed blob metadata.");
-	return {
-		success: true,
-		value: {
-			bytes: fetched.value.bytes,
-			source,
-			url: fetched.value.url
-		}
-	};
-}
-function withBlobSizeLimit(options, blobMetadata) {
-	if (!blobMetadata) return options;
-	return {
-		...options,
-		maxBytes: Math.min(options.maxBytes ?? DEFAULT_FETCH_LIMITS.maxBytes, blobMetadata.size)
-	};
-}
-function blobUrl(pdsEndpoint, publisherDid, cid) {
-	try {
-		const url = new URL("/xrpc/com.atproto.sync.getBlob", pdsEndpoint);
-		url.searchParams.set("did", publisherDid);
-		url.searchParams.set("cid", cid);
-		return {
-			success: true,
-			value: url
-		};
-	} catch {
-		return verificationError("PDS_RESOLUTION_FAILED", "The publisher PDS endpoint is invalid.");
-	}
-}
-function didDocumentUrl(did) {
-	if (PLC_DID_PATTERN.test(did)) return `https://plc.directory/${encodeURIComponent(did)}`;
-	if (!did.startsWith("did:web:")) return null;
-	try {
-		const parts = did.slice(8).split(":").map(decodeURIComponent);
-		const host = parts.shift();
-		if (!host || parts.some((part) => part === "" || part === "." || part === "..")) return null;
-		const path = parts.length === 0 ? "/.well-known/did.json" : `/${parts.join("/")}/did.json`;
-		return new URL(path, `https://${host}`).href;
-	} catch {
-		return null;
-	}
-}
-function unsupportedAuth(auth) {
-	return verificationError("AUTH_METHOD_UNSUPPORTED", UNSUPPORTED_AUTH_MESSAGE, unsupportedAuthDetails(auth));
-}
-function withinDeadline(options, deadline) {
-	const remaining = deadline - Date.now();
-	if (remaining <= 0) return null;
-	return {
-		...options,
-		totalTimeoutMs: remaining
-	};
-}
-function timedOut() {
-	return verificationError("RESOURCE_TIMEOUT", "Artifact retrieval exceeded its total timeout.");
-}
-function isRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function modernBlobCid(blob) {
-	if (!blob || !("ref" in blob) || typeof blob.ref?.$link !== "string") return null;
-	return blob.ref.$link;
-}
-function recordScopedCacheEndpoint(value) {
-	if (!isRecord(value) || value.$type !== RECORD_SCOPED_BLOB_CACHE_TYPE) return null;
-	return typeof value.serviceEndpoint === "string" ? value.serviceEndpoint : null;
-}
-function isSafePathSegment(value) {
-	if (value.length === 0 || UNSAFE_PATH_SEGMENT.test(value)) return false;
-	for (const character of value) {
-		const codePoint = character.codePointAt(0);
-		if (codePoint !== void 0 && (codePoint <= 31 || codePoint === 127)) return false;
-	}
-	return true;
-}
-
-//#endregion
-//#region src/registry/artifact-fetch.ts
-const TRAILING_DOT = /\.+$/;
-const LOCALHOST_HOSTNAMES = new Set([
-	"localhost",
-	"localhost.localdomain",
-	"ip6-localhost",
-	"ip6-loopback"
-]);
-let defaultTransport = null;
-function isLocalhostHostname(hostname) {
-	const normalized = hostname.toLowerCase().replace(TRAILING_DOT, "");
-	return LOCALHOST_HOSTNAMES.has(normalized) || normalized.endsWith(".localhost") || normalized === "127.0.0.1" || normalized === "::1" || normalized === "[::1]" || normalized.startsWith("::ffff:127.") || normalized.startsWith("::ffff:7f00:");
-}
-async function resolveSafeArtifactTarget(urlString) {
-	let url;
-	try {
-		url = new URL(urlString);
-	} catch {
-		throw new Error(`Invalid artifact URL: ${urlString}`);
-	}
-	if (url.protocol !== "https:" && url.protocol !== "http:") throw new Error(`Artifact URL protocol not allowed: ${url.protocol}`);
-	if (url.username || url.password) throw new Error("Artifact URL must not contain embedded credentials");
-	const hostname = stripIpv6Brackets(url.hostname.toLowerCase().replace(TRAILING_DOT, ""));
-	const localhost = isLocalhostHostname(hostname);
-	if (!import.meta.env.DEV) {
-		if (url.protocol === "http:") throw new Error("Artifact URL must use https");
-		if (localhost) throw new Error(`Artifact URL points to localhost: ${hostname}`);
-	} else if (url.protocol === "http:" && !localhost) throw new Error("Artifact URL must use https (http allowed only for localhost in dev)");
-	if (localhost) return {
-		url,
-		addresses: []
-	};
-	try {
-		return await resolveAndValidateExternalUrlTarget(url.href);
-	} catch (error) {
-		if (error instanceof SsrfError) throw new Error(`Artifact URL rejected: ${error.message}`, { cause: error });
-		throw error;
-	}
-}
-async function fetchRegistryArtifactUrl(urlString, options) {
-	if (!Number.isSafeInteger(options.maxResponseBytes) || options.maxResponseBytes < 0) throw new TypeError("Registry artifact response limit is invalid");
-	const target = await resolveSafeArtifactTarget(urlString);
-	if (target.addresses.length === 0) return globalThis.fetch(target.url, {
-		redirect: "manual",
-		signal: options.signal
-	});
-	const result = await (defaultTransport ?? await createRuntimeRegistryArtifactTransport()).fetch({
-		url: target.url,
-		allowedAddresses: target.addresses,
-		signal: options.signal,
-		maxResponseBytes: options.maxResponseBytes
-	});
-	if (result.connectedAddress !== null && !target.addresses.includes(result.connectedAddress)) {
-		await result.response.body?.cancel().catch(() => void 0);
-		throw new Error("Registry artifact transport connected outside the validated address set");
-	}
-	return result.response;
-}
-async function createRuntimeRegistryArtifactTransport() {
-	return isCloudflareWorkersRuntime() ? createWorkersRegistryArtifactTransport() : createNodeRegistryArtifactTransport();
-}
-function createWorkersRegistryArtifactTransport(workerFetch = globalThis.fetch) {
-	return { async fetch(input) {
-		return {
-			response: limitResponseBody(await workerFetch(input.url, {
-				redirect: "manual",
-				signal: input.signal,
-				headers: { "Accept-Encoding": "identity" }
-			}), input.maxResponseBytes),
-			connectedAddress: null
-		};
-	} };
-}
-function isCloudflareWorkersRuntime() {
-	return typeof navigator !== "undefined" && typeof navigator.userAgent === "string" && navigator.userAgent.includes("Cloudflare-Workers");
-}
-function limitResponseBody(response, maxBytes) {
-	if (!response.body) return response;
-	let received = 0;
-	const body = response.body.pipeThrough(new TransformStream({ transform(chunk, controller) {
-		received += chunk.byteLength;
-		if (received > maxBytes) {
-			controller.error(/* @__PURE__ */ new RangeError("Registry artifact response exceeds its byte limit"));
-			return;
-		}
-		controller.enqueue(chunk);
-	} }));
-	return new Response(body, {
-		status: response.status,
-		statusText: response.statusText,
-		headers: response.headers
-	});
-}
-async function createNodeRegistryArtifactTransport(nodeRequest) {
-	const request = nodeRequest ?? (await import("node:https")).request;
-	return { async fetch(input) {
-		let lastError;
-		for (const address of input.allowedAddresses) try {
-			return {
-				response: await new Promise((resolve, reject) => {
-					const chunks = [];
-					let total = 0;
-					const req = request({
-						protocol: "https:",
-						hostname: stripIpv6Brackets(input.url.hostname),
-						port: parseHttpsPort(input.url),
-						path: `${input.url.pathname}${input.url.search}`,
-						method: "GET",
-						agent: false,
-						headers: {
-							Host: input.url.host,
-							Connection: "close",
-							"Accept-Encoding": "identity"
-						},
-						lookup: (_hostname, options, callback) => {
-							const family = address.includes(":") ? 6 : 4;
-							if (options.all) callback(null, [{
-								address,
-								family
-							}]);
-							else callback(null, address, family);
-						},
-						signal: input.signal
-					}, (upstream) => {
-						const contentEncoding = upstream.headers["content-encoding"];
-						if (contentEncoding && contentEncoding.toLowerCase() !== "identity") {
-							upstream.destroy(/* @__PURE__ */ new Error("Registry artifact response content encoding is unsupported"));
-							return;
-						}
-						upstream.on("data", (chunk) => {
-							total += chunk.byteLength;
-							if (total > input.maxResponseBytes) {
-								upstream.destroy(/* @__PURE__ */ new RangeError("Registry artifact response exceeds its byte limit"));
-								return;
-							}
-							chunks.push(new Uint8Array(chunk));
-						});
-						upstream.once("error", reject);
-						upstream.once("end", () => {
-							const bytes = concatBytes(chunks, total);
-							const headers = new Headers();
-							for (let index = 0; index < upstream.rawHeaders.length; index += 2) headers.append(upstream.rawHeaders[index], upstream.rawHeaders[index + 1]);
-							resolve(parsedResponseToWebResponse({
-								status: upstream.statusCode ?? 502,
-								headers,
-								body: bytes
-							}));
-						});
-					});
-					req.once("error", reject);
-					req.end();
-				}),
-				connectedAddress: address
-			};
-		} catch (error) {
-			if (input.signal.aborted) throw error;
-			lastError = error;
-		}
-		throw new Error("Registry artifact transport could not connect to an approved address", { cause: lastError });
-	} };
-}
-function parsedResponseToWebResponse(parsed) {
-	const bodyAllowed = ![
-		204,
-		205,
-		304
-	].includes(parsed.status);
-	let body = null;
-	if (bodyAllowed) {
-		body = new ArrayBuffer(parsed.body.byteLength);
-		new Uint8Array(body).set(parsed.body);
-	}
-	return new Response(body, {
-		status: parsed.status,
-		headers: parsed.headers
-	});
-}
-function concatBytes(chunks, total) {
-	const bytes = new Uint8Array(total);
-	let offset = 0;
-	for (const chunk of chunks) {
-		bytes.set(chunk, offset);
-		offset += chunk.byteLength;
-	}
-	return bytes;
-}
-function parseHttpsPort(url) {
-	const port = url.port === "" ? 443 : Number(url.port);
-	if (!Number.isSafeInteger(port) || port < 1 || port > 65535) throw new TypeError("Registry artifact HTTPS port is invalid");
-	return port;
-}
-function stripIpv6Brackets(hostname) {
-	return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
-}
-
-//#endregion
-export { fetchVerifiedResource as a, resolvePublisherPdsEndpoint as i, fetchReleaseArtifact as n, recordScopedImageCacheUrl as r, fetchRegistryArtifactUrl as t };
-//# sourceMappingURL=artifact-fetch-B9W4CEST.mjs.map