@chartcoach/catalog 0.1.7 → 0.2.0

package/dist/open-Uu3-r8kp.js

@@ -0,0 +1,1244 @@
+import { a as CatalogError, i as parseJson, n as isJsonObject, r as isJsonString, t as isJsonNumber } from "./json-CBWjz9b4.js";
+import { a as citationRecords, c as catalogEntriesDigest, d as sha256Bytes, f as normalizeLabel, l as compareUnicode, n as catalogTableInfo, o as sourceRecords, p as parseLabel, s as canonicalJson, t as catalogTable, u as manifestDigest } from "./tables-DcgKnXwF.js";
+import { parquetReadObjects } from "hyparquet";
+import { compressors } from "hyparquet-compressors";
+//#region src/catalog/manifest.ts
+const REQUIRED_MANIFEST_HEADINGS = ["Section Roles", "Label Families"];
+const headingPattern = /^(#{1,6})[ \t]+(.+?)[ \t]*#*[ \t]*$/;
+const codeSpanPattern = /`([^`\n]+)`/g;
+function manifestDefinitions() {
+	return Object.create(null);
+}
+function parseCatalogManifest(markdown) {
+	const requiredSeen = /* @__PURE__ */ new Set();
+	const definitions = {
+		"Section Roles": manifestDefinitions(),
+		"Label Families": manifestDefinitions()
+	};
+	let currentHeading;
+	let currentName;
+	let currentLines = [];
+	function flushDefinition() {
+		if (currentHeading !== "Section Roles" && currentHeading !== "Label Families") {
+			currentLines = [];
+			return;
+		}
+		if (currentName === void 0) {
+			currentLines = [];
+			return;
+		}
+		const description = currentLines.join("\n").trim();
+		if (!description) throw new CatalogError(`Manifest definition ${currentHeading}/${currentName} must include prose.`);
+		definitions[currentHeading][currentName] = {
+			name: currentName,
+			description,
+			examples: Array.from(description.matchAll(codeSpanPattern), (match) => match[1] ?? "")
+		};
+		currentName = void 0;
+		currentLines = [];
+	}
+	for (const line of markdown.split("\n")) {
+		const match = headingPattern.exec(line);
+		if (!match) {
+			if (currentName !== void 0) currentLines.push(line);
+			continue;
+		}
+		const level = match[1].length;
+		const title = match[2].trim();
+		if (level === 2) {
+			flushDefinition();
+			currentHeading = title;
+			currentName = void 0;
+			currentLines = [];
+			if (title === "Section Roles" || title === "Label Families") requiredSeen.add(title);
+			continue;
+		}
+		if (level === 3 && (currentHeading === "Section Roles" || currentHeading === "Label Families")) {
+			flushDefinition();
+			if (!title) throw new CatalogError(`Manifest heading ${currentHeading} contains an empty subheading.`);
+			currentName = title;
+			currentLines = [];
+			continue;
+		}
+		if (currentName !== void 0) currentLines.push(line);
+	}
+	flushDefinition();
+	const missing = REQUIRED_MANIFEST_HEADINGS.filter((heading) => !requiredSeen.has(heading));
+	if (missing.length > 0) throw new CatalogError(`MANIFEST.md is missing required heading(s): ${missing.join(", ")}.`);
+	for (const heading of REQUIRED_MANIFEST_HEADINGS) if (Object.keys(definitions[heading]).length === 0) throw new CatalogError(`Manifest heading ${heading} must contain definitions.`);
+	validateLabelFamilyExamples(Object.values(definitions["Label Families"]));
+	return copyCatalogManifest({
+		markdown: markdown.endsWith("\n") ? markdown : `${markdown}\n`,
+		sectionRoles: definitions["Section Roles"],
+		labelFamilies: definitions["Label Families"]
+	});
+}
+function copyCatalogManifest(manifest) {
+	return Object.freeze({
+		markdown: manifest.markdown,
+		sectionRoles: copyDefinitions(manifest.sectionRoles),
+		labelFamilies: copyDefinitions(manifest.labelFamilies)
+	});
+}
+function validateManifestCoverage(guidelines, manifest) {
+	const usedRoles = /* @__PURE__ */ new Set();
+	const usedFamilies = /* @__PURE__ */ new Set();
+	for (const guideline of guidelines) {
+		for (const section of guideline.sections) {
+			const role = section.role.trim();
+			if (!role) throw new CatalogError("Section role values must not be empty.");
+			if (role === "__dangling__") continue;
+			usedRoles.add(role);
+		}
+		for (const label of guideline.labels) usedFamilies.add(parseLabel(label, `label ${JSON.stringify(label)}`).family);
+	}
+	const missingRoles = Array.from(usedRoles).filter((role) => !Object.hasOwn(manifest.sectionRoles, role)).sort();
+	const missingFamilies = Array.from(usedFamilies).filter((family) => !Object.hasOwn(manifest.labelFamilies, family)).sort();
+	const errors = [];
+	if (missingRoles.length > 0) errors.push(`undefined section role(s): ${missingRoles.join(", ")}`);
+	if (missingFamilies.length > 0) errors.push(`undefined label family/families: ${missingFamilies.join(", ")}`);
+	if (errors.length > 0) throw new CatalogError(`Catalog manifest validation failed: ${errors.join("; ")}.`);
+}
+function validateLabelFamilyExamples(definitions) {
+	for (const definition of definitions) {
+		const familyExamples = [];
+		const invalidExamples = [];
+		for (const example of definition.examples) {
+			let parsed;
+			try {
+				parsed = parseLabel(example, `manifest label example ${JSON.stringify(example)}`);
+			} catch {
+				continue;
+			}
+			if (parsed.family === definition.name) familyExamples.push(parsed.value);
+			else if (example.includes(":")) invalidExamples.push(example);
+		}
+		if (invalidExamples.length > 0) throw new CatalogError(`Label family ${definition.name} has example(s) from another family: ${invalidExamples.join(", ")}.`);
+		if (familyExamples.length === 0) throw new CatalogError(`Label family ${definition.name} must include at least one label example.`);
+	}
+}
+function copyDefinitions(definitions) {
+	const owned = manifestDefinitions();
+	for (const [name, definition] of Object.entries(definitions)) owned[name] = Object.freeze({
+		name: definition.name,
+		description: definition.description,
+		examples: Object.freeze([...definition.examples])
+	});
+	return Object.freeze(owned);
+}
+//#endregion
+//#region src/catalog/description.ts
+const identityCache = /* @__PURE__ */ new WeakMap();
+async function describeCatalog(catalog, context, options = {}) {
+	if (Object.prototype.toString.call(options) !== "[object Object]") throw new CatalogError("Description options must be an object.");
+	const identity = await catalogIdentity(catalog);
+	const selected = selectProfile(context.profiles, options.profile);
+	let profile = null;
+	if (selected) {
+		options.signal?.throwIfAborted();
+		const metadata = await loadProfile(context, selected, options.signal);
+		if (metadata.entries_digest !== identity.entriesDigest) throw new CatalogError("Profile entries digest does not match the catalog entries.", {
+			code: "incompatible_profile",
+			details: { profile: selected.name }
+		});
+		if (metadata.manifest_digest !== identity.manifestDigest) throw new CatalogError("Profile manifest digest does not match MANIFEST.md.", {
+			code: "incompatible_profile",
+			details: { profile: selected.name }
+		});
+		if (metadata.projection === null !== (selected.projection === null)) throw new CatalogError("Profile projection metadata does not match the release inventory.", {
+			code: "incompatible_profile",
+			details: { profile: selected.name }
+		});
+		context.profileCache.set(selected.name, metadata);
+		profile = profileInfo(selected.name, metadata);
+	}
+	return Object.freeze({
+		resolved_location: context.resolvedLocation,
+		release_digest: context.releaseDigest,
+		entries_digest: identity.entriesDigest,
+		manifest_digest: identity.manifestDigest,
+		tables: catalogTableInfo(catalog),
+		section_roles: vocabulary(Object.values(catalog.manifest.sectionRoles)),
+		label_families: vocabulary(Object.values(catalog.manifest.labelFamilies)),
+		profiles: Object.freeze(context.profiles.map((item) => item.name)),
+		profile
+	});
+}
+async function catalogIdentity(catalog) {
+	const cached = identityCache.get(catalog);
+	if (cached) return cached;
+	const [entriesDigest, catalogManifestDigest] = await Promise.all([catalogEntriesDigest(catalog.guidelines), manifestDigest(catalog.manifest.markdown)]);
+	const identity = Object.freeze({
+		entriesDigest,
+		manifestDigest: catalogManifestDigest
+	});
+	identityCache.set(catalog, identity);
+	return identity;
+}
+function selectProfile(profiles, name) {
+	if (name === void 0) return void 0;
+	if (!name) throw new CatalogError("Profile must be a non-empty string.");
+	const profile = profiles.find((item) => item.name === name);
+	if (profile) return profile;
+	throw new CatalogError(`Unknown profile: ${name}`, {
+		code: "lookup",
+		details: {
+			profile: name,
+			available: profiles.map((item) => item.name)
+		},
+		hints: [`Available profiles: ${profiles.map((item) => JSON.stringify(item.name)).join(", ") || "none"}.`]
+	});
+}
+async function loadProfile(context, profile, signal) {
+	const cached = context.profileCache.get(profile.name);
+	if (cached) return cached;
+	if (!context.profileLoader) throw new CatalogError("Profile metadata loading is unavailable for caller-provided bytes.", {
+		code: "unavailable_capability",
+		details: { profile: profile.name },
+		hints: ["Use openCatalog with an HTTP or HTTPS release URL."]
+	});
+	return context.profileLoader(profile, signal);
+}
+function profileInfo(name, metadata) {
+	return Object.freeze({
+		name,
+		profile_schema_version: metadata.schema_version,
+		documents_version: metadata.documents_version,
+		embedding_functions: metadata.embedding_functions,
+		dimensions: metadata.dimensions,
+		distance_metric: metadata.distance_metric,
+		python_requirements: metadata.python_requirements,
+		lancedb_version: metadata.lancedb_version,
+		projection: metadata.projection
+	});
+}
+function vocabulary(definitions) {
+	return Object.freeze(definitions.map((definition) => Object.freeze({
+		name: definition.name,
+		description: definition.description,
+		examples: Object.freeze([...definition.examples])
+	})));
+}
+//#endregion
+//#region src/catalog/query.ts
+function queryCatalog(catalog, options = {}) {
+	if (Object.prototype.toString.call(options) !== "[object Object]") throw new CatalogError("Query options must be an object.");
+	const ids = stringArray(options.ids, "ids");
+	const labels = stringArray(options.labels, "labels");
+	const labelPrefixes = stringArray(options.labelPrefixes, "labelPrefixes");
+	const limit = options.limit ?? 50;
+	if (!Number.isSafeInteger(limit) || limit < 1) throw new CatalogError("Query limit must be at least 1.");
+	validateLabels(catalog, labels);
+	validateLabelPrefixes(catalog, labelPrefixes);
+	const selected = ids.length > 0 ? ids.map((id) => catalog.require(id)) : [...catalog.guidelines];
+	let contains;
+	if (options.contains !== void 0) {
+		if (!isJsonString(options.contains)) throw new CatalogError("Query contains must be a string.");
+		if (options.contains.length > 0) {
+			contains = normalizeSearchText(options.contains);
+			if (!contains) throw new CatalogError("contains must not consist only of whitespace, hyphens, or underscores.");
+		}
+	}
+	return Object.freeze(selected.filter((guideline) => labels.every((label) => guideline.labels.includes(label))).filter((guideline) => labelPrefixes.every((prefix) => guideline.labels.some((label) => label.startsWith(prefix)))).filter((guideline) => contains === void 0 || matchesText(guideline, contains)).slice(0, limit).map((guideline) => Object.freeze({
+		id: guideline.id,
+		title: guideline.title,
+		description: guideline.description,
+		labels: Object.freeze([...guideline.labels])
+	})));
+}
+function validateLabels(catalog, labels) {
+	const available = new Set(catalog.labels());
+	const missing = Array.from(new Set(labels.filter((label) => !available.has(label)))).sort();
+	if (missing.length === 0) return;
+	throw new CatalogError(`Unknown label(s): ${missing.join(", ")}`, {
+		code: "lookup",
+		details: { labels: missing },
+		hints: ["Call `await catalog.describe()` to inspect label families."]
+	});
+}
+function validateLabelPrefixes(catalog, prefixes) {
+	const available = catalog.labels();
+	const missing = Array.from(new Set(prefixes.filter((prefix) => !available.some((label) => label.startsWith(prefix))))).sort();
+	if (missing.length === 0) return;
+	throw new CatalogError(`No labels match prefix(es): ${missing.join(", ")}`, {
+		code: "lookup",
+		details: { label_prefixes: missing },
+		hints: ["Call `await catalog.describe()` to inspect label families."]
+	});
+}
+function stringArray(value, name) {
+	if (value === void 0) return Object.freeze([]);
+	if (!Array.isArray(value) || !value.every(isJsonString)) throw new CatalogError(`${name} must be an array of strings.`);
+	return value;
+}
+function matchesText(guideline, contains) {
+	return [
+		guideline.id,
+		guideline.title,
+		guideline.description
+	].some((value) => normalizeSearchText(value).includes(contains));
+}
+function normalizeSearchText(value) {
+	return value.toLowerCase().replace(/[-_\s]+/g, " ").trim();
+}
+//#endregion
+//#region src/catalog/read.ts
+function readCatalog(catalog, options) {
+	if (Object.prototype.toString.call(options) !== "[object Object]") throw new CatalogError("Read options must be an object.");
+	if (!Array.isArray(options.ids) || !options.ids.every(isJsonString)) throw new CatalogError("ids must be an array of strings.");
+	const roles = options.roles ?? [];
+	if (!Array.isArray(roles) || !roles.every(isJsonString)) throw new CatalogError("roles must be an array of strings.");
+	const sourceDetail = options.sourceDetail ?? "minimal";
+	if (sourceDetail !== "none" && sourceDetail !== "minimal" && sourceDetail !== "full") throw new CatalogError(`Unknown source detail: ${JSON.stringify(sourceDetail)}.`, { hints: ["Choose one of: none, minimal, full."] });
+	const missingRoles = Array.from(new Set(roles.filter((role) => !Object.hasOwn(catalog.manifest.sectionRoles, role)))).sort();
+	if (missingRoles.length > 0) throw new CatalogError(`Unknown section role(s): ${missingRoles.join(", ")}`, {
+		code: "lookup",
+		details: { roles: missingRoles },
+		hints: ["Call `await catalog.describe()` to inspect section roles."]
+	});
+	if (options.ids.length === 0) return Object.freeze([]);
+	const roleSet = roles.length > 0 ? new Set(roles) : void 0;
+	return Object.freeze(options.ids.map((id) => {
+		const guideline = catalog.require(id);
+		const sections = Object.freeze(guideline.sections.filter((section) => roleSet === void 0 || roleSet.has(section.role)).map((section) => Object.freeze({
+			role: section.role,
+			title: section.title,
+			content: section.content
+		})));
+		const record = {
+			id: guideline.id,
+			title: guideline.title,
+			description: guideline.description,
+			labels: Object.freeze([...guideline.labels]),
+			sections,
+			sources: sourceDetail === "none" ? Object.freeze([]) : sourceRecords(catalog, guideline.id, sourceDetail)
+		};
+		return Object.freeze(sourceDetail === "full" ? {
+			...record,
+			references: Object.freeze([...guideline.references])
+		} : record);
+	}));
+}
+//#endregion
+//#region src/catalog/profile-layout.ts
+const profileFiles = /* @__PURE__ */ new Set([
+	"profile.json",
+	"index.tar.gz",
+	"documents.parquet",
+	"projection.parquet"
+]);
+const profileIdPattern = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/;
+const windowsDeviceNames = /* @__PURE__ */ new Set([
+	"CON",
+	"PRN",
+	"AUX",
+	"NUL",
+	"CONIN$",
+	"CONOUT$"
+]);
+function releaseProfiles(release) {
+	const profiles = /* @__PURE__ */ new Map();
+	for (const path of Object.keys(release.artifacts)) {
+		const parts = path.split("/");
+		if (parts[0] !== "profiles") continue;
+		if (parts.length < 3) throw new CatalogError(`Invalid profile artifact path: ${JSON.stringify(path)}.`);
+		const filename = parts.at(-1);
+		if (!profileFiles.has(filename)) throw new CatalogError(`Unknown profile artifact: ${JSON.stringify(path)}.`);
+		const profile = parts.slice(1, -1).join("/");
+		const artifacts = profiles.get(profile) ?? /* @__PURE__ */ new Set();
+		artifacts.add(filename);
+		profiles.set(profile, artifacts);
+	}
+	const result = [];
+	for (const [profile, artifacts] of profiles) {
+		if (!isProfileId(profile)) throw new CatalogError("Profile ID must be a lowercase portable single-component name.");
+		if (!artifacts.has("profile.json")) throw new CatalogError(`Profile ${JSON.stringify(profile)} is missing profile.json.`);
+		if (!artifacts.has("index.tar.gz")) throw new CatalogError(`Profile ${JSON.stringify(profile)} is missing index.tar.gz.`);
+		const root = `profiles/${profile}`;
+		result.push(Object.freeze({
+			name: profile,
+			metadata: `${root}/profile.json`,
+			index: `${root}/index.tar.gz`,
+			documents: artifacts.has("documents.parquet") ? `${root}/documents.parquet` : null,
+			projection: artifacts.has("projection.parquet") ? `${root}/projection.parquet` : null
+		}));
+	}
+	return Object.freeze(result.sort((left, right) => left.name < right.name ? -1 : 1));
+}
+function releaseProfileNames(release) {
+	return Object.freeze(releaseProfiles(release).map((profile) => profile.name));
+}
+function isProfileId(value) {
+	if (!profileIdPattern.test(value) || value.includes("/")) return false;
+	const basename = value.split(".", 1)[0].toUpperCase();
+	return !windowsDeviceNames.has(basename) && !/^(?:COM|LPT)[1-9]$/.test(basename);
+}
+//#endregion
+//#region src/catalog/artifacts.ts
+const CATALOG_ARTIFACT_BASE_URL = "https://artifacts.chartcoach.dev/";
+const RELEASE_SCHEMA_VERSION = 1;
+const REQUIRED_ARTIFACTS = ["MANIFEST.md", "entries.parquet"];
+const FORBIDDEN_PATH_CHARACTERS = /* @__PURE__ */ new Set("<>:\"\\|?*#%");
+const WINDOWS_DEVICE_NAMES = /* @__PURE__ */ new Set([
+	"CON",
+	"PRN",
+	"AUX",
+	"NUL",
+	"CONIN$",
+	"CONOUT$"
+]);
+function parseCatalogRelease(value) {
+	const record = requireRecord(value, "Catalog release");
+	requireExactKeys(record, [
+		"schema_version",
+		"digest",
+		"artifacts"
+	], "Catalog release");
+	requireSchemaVersion(record);
+	const artifactRecords = requireRecord(record.artifacts, "Catalog artifacts");
+	const artifacts = Object.create(null);
+	for (const [path, artifact] of Object.entries(artifactRecords).map(([path, value]) => [requireRelativePath(path, "Catalog artifact path"), parseReleaseArtifact(value)]).sort(([left], [right]) => compareUnicode(left, right))) artifacts[path] = artifact;
+	validateArtifactPaths(Object.keys(artifacts));
+	for (const path of REQUIRED_ARTIFACTS) if (!Object.hasOwn(artifacts, path)) throw new CatalogError(`Catalog release is missing artifact: ${path}.`);
+	return Object.freeze({
+		schema_version: RELEASE_SCHEMA_VERSION,
+		digest: requiredSha256(record, "digest", "Catalog release"),
+		artifacts: Object.freeze(artifacts)
+	});
+}
+function copyCatalogRelease(release) {
+	return parseCatalogRelease({
+		schema_version: release.schema_version,
+		digest: release.digest,
+		artifacts: Object.fromEntries(Object.entries(release.artifacts).map(([path, artifact]) => [path, {
+			sha256: artifact.sha256,
+			bytes: artifact.bytes
+		}]))
+	});
+}
+async function assertReleaseDigest(release, expected = release.digest, label = "Catalog release") {
+	const actual = await catalogReleaseDigest(release);
+	if (release.digest !== actual) throw new CatalogError(`${label} digest ${release.digest} does not match its artifact set.`, {
+		code: "integrity",
+		details: {
+			expected_digest: release.digest,
+			actual_digest: actual
+		}
+	});
+	if (release.digest !== expected) throw new CatalogError(`${label} digest ${release.digest} does not match ${expected}.`, {
+		code: "integrity",
+		details: {
+			expected_digest: expected,
+			actual_digest: release.digest
+		}
+	});
+}
+async function assertReleaseArtifactBytes(path, artifact, data) {
+	const bytes = bytesView(data);
+	if (bytes.byteLength !== artifact.bytes) throw new CatalogError(`Catalog artifact byte count mismatch: ${path}`, {
+		code: "integrity",
+		details: {
+			path,
+			expected_bytes: artifact.bytes,
+			actual_bytes: bytes.byteLength
+		}
+	});
+	const actual = await sha256Bytes(bytes);
+	if (actual !== artifact.sha256) throw new CatalogError(`Catalog artifact SHA-256 mismatch: ${path}`, {
+		code: "integrity",
+		details: {
+			path,
+			expected_sha256: artifact.sha256,
+			actual_sha256: actual
+		}
+	});
+}
+function catalogUrl() {
+	return new URL("catalog.json", CATALOG_ARTIFACT_BASE_URL).toString();
+}
+function releaseArtifact(release, path) {
+	const artifact = release.artifacts[path];
+	if (artifact === void 0) throw new CatalogError(`Catalog release is missing artifact: ${path}.`, {
+		code: "integrity",
+		details: { path }
+	});
+	return artifact;
+}
+function releaseArtifactUrl(releaseUrl, path) {
+	return new URL(path, releaseUrl).toString();
+}
+function assertReleaseLocation(releaseUrl, release) {
+	const url = requireReleaseUrl(releaseUrl);
+	if (url.pathname.split("/").at(-1) !== "release.json") return;
+	const parent = url.pathname.split("/").at(-2);
+	if (parent && /^[a-f0-9]{64}$/.test(parent) && parent !== release.digest) throw new CatalogError("Catalog release digest does not match its digest-addressed location.", {
+		code: "integrity",
+		details: {
+			expected_digest: parent,
+			actual_digest: release.digest
+		}
+	});
+}
+function sanitizeReleaseUrl(value) {
+	const url = requireReleaseUrl(value);
+	url.username = "";
+	url.password = "";
+	url.search = "";
+	url.hash = "";
+	return url.toString();
+}
+function requireReleaseUrl(value) {
+	try {
+		return new URL(value);
+	} catch {
+		throw new CatalogError("Catalog release URL must be absolute.");
+	}
+}
+function parseReleaseArtifact(value) {
+	const record = requireRecord(value, "Catalog release artifact");
+	requireExactKeys(record, ["sha256", "bytes"], "Catalog release artifact");
+	return Object.freeze({
+		sha256: requiredSha256(record, "sha256", "Catalog release artifact"),
+		bytes: requiredInteger(record, "bytes", "Catalog release artifact")
+	});
+}
+function validateArtifactPaths(paths) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const path of paths) {
+		const folded = asciiLower(path);
+		const previous = seen.get(folded);
+		if (previous !== void 0) throw new CatalogError(`Catalog artifact paths collide: ${previous}, ${path}.`);
+		seen.set(folded, path);
+	}
+	for (const [folded, path] of seen) {
+		const parts = folded.split("/");
+		if (folded === "release.json") throw new CatalogError(`Catalog artifact path is reserved: ${path}.`);
+		for (let length = 1; length < parts.length; length += 1) {
+			const ancestor = parts.slice(0, length).join("/");
+			const previous = seen.get(ancestor);
+			if (previous !== void 0) throw new CatalogError(`Catalog artifact paths collide: ${previous}, ${path}.`);
+		}
+	}
+}
+async function catalogReleaseDigest(release) {
+	return sha256Bytes(new TextEncoder().encode(canonicalJson({
+		schema_version: release.schema_version,
+		artifacts: release.artifacts
+	})));
+}
+function bytesView(data) {
+	if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+function requireRecord(value, label) {
+	if (!isJsonObject(value)) throw new CatalogError(`${label} must be an object.`);
+	return value;
+}
+function requireExactKeys(value, expected, label) {
+	const actual = Object.keys(value);
+	const missing = expected.filter((key) => !actual.includes(key)).sort();
+	const unexpected = actual.filter((key) => !expected.includes(key)).sort();
+	if (missing.length > 0) throw new CatalogError(`${label} is missing fields: ${missing.join(", ")}.`);
+	if (unexpected.length > 0) throw new CatalogError(`${label} has unsupported fields: ${unexpected.join(", ")}.`);
+}
+function requireSchemaVersion(value) {
+	if (requiredInteger(value, "schema_version", "Catalog release") !== RELEASE_SCHEMA_VERSION) throw new CatalogError(`Catalog release schema_version must be ${RELEASE_SCHEMA_VERSION}.`);
+}
+function requireRelativePath(path, label) {
+	const parts = path.split("/");
+	if (!pathIsAscii(path) || parts.some((part) => !isPortablePathSegment(part))) throw new CatalogError(`${label} must be relative: ${path}`);
+	return path;
+}
+function isPortablePathSegment(value) {
+	if (value === "" || value === "." || value === ".." || value.endsWith(".") || Array.from(value).some((character) => FORBIDDEN_PATH_CHARACTERS.has(character))) return false;
+	const basename = value.split(".", 1)[0].toUpperCase();
+	return !WINDOWS_DEVICE_NAMES.has(basename) && !/^(?:COM|LPT)[1-9]$/.test(basename);
+}
+function requiredString(value, key, label) {
+	const raw = value[key];
+	if (!isJsonString(raw) || raw.length === 0) throw new CatalogError(`${label} ${key} must be a string.`);
+	return raw;
+}
+function requiredInteger(value, key, label) {
+	const raw = value[key];
+	if (!isJsonNumber(raw) || !Number.isSafeInteger(raw) || raw < 0) throw new CatalogError(`${label} ${key} must be an integer from 0 through ${Number.MAX_SAFE_INTEGER}.`);
+	return raw;
+}
+function requiredSha256(value, key, label) {
+	const digest = requiredString(value, key, label);
+	requireSha256$1(digest, `${label} ${key}`);
+	return digest;
+}
+function requireSha256$1(value, label) {
+	if (!/^[a-f0-9]{64}$/.test(value)) throw new CatalogError(`${label} must be a lowercase SHA-256 digest.`);
+}
+function pathIsAscii(value) {
+	if (value.length === 0) return false;
+	for (const character of value) {
+		const code = character.charCodeAt(0);
+		if (code < 33 || code > 126) return false;
+	}
+	return true;
+}
+function asciiLower(value) {
+	return value.replace(/[A-Z]/g, (character) => character.toLowerCase());
+}
+//#endregion
+//#region src/catalog/model.ts
+const releaseByCatalog = /* @__PURE__ */ new WeakMap();
+const descriptionByCatalog = /* @__PURE__ */ new WeakMap();
+var Catalog = class {
+	guidelines;
+	manifest;
+	byId;
+	constructor(guidelines, manifest) {
+		const records = Array.from(guidelines, copyGuideline);
+		const ownedManifest = copyCatalogManifest(manifest);
+		const byId = /* @__PURE__ */ new Map();
+		for (const guideline of records) {
+			if (byId.has(guideline.id)) throw new CatalogError(`Catalog contains duplicate guideline entry ID: ${guideline.id}.`);
+			byId.set(guideline.id, guideline);
+		}
+		validateManifestCoverage(records, ownedManifest);
+		this.guidelines = Object.freeze(records);
+		this.manifest = ownedManifest;
+		this.byId = byId;
+		Object.freeze(this);
+	}
+	get release() {
+		return releaseByCatalog.get(this)?.release;
+	}
+	get releaseUrl() {
+		return releaseByCatalog.get(this)?.releaseUrl;
+	}
+	get length() {
+		return this.guidelines.length;
+	}
+	async artifact(path, options = {}) {
+		const context = releaseByCatalog.get(this);
+		if (!context) throw new CatalogError("Artifact access requires a catalog release.", { code: "unavailable_capability" });
+		if (!Object.hasOwn(context.release.artifacts, path)) throw new CatalogError(`Unknown release artifact: ${path}`, {
+			code: "lookup",
+			details: {
+				path,
+				available: Object.keys(context.release.artifacts)
+			}
+		});
+		return context.artifactLoader(path, options.signal);
+	}
+	get(id) {
+		return this.byId.get(id);
+	}
+	require(id) {
+		const guideline = this.get(id);
+		if (!guideline) throw new CatalogError(`Unknown guideline entry ID: ${id}`, {
+			code: "lookup",
+			details: { id },
+			hints: ["Call `catalog.query()` to inspect guideline entry IDs."]
+		});
+		return guideline;
+	}
+	query(options = {}) {
+		return queryCatalog(this, options);
+	}
+	read(options) {
+		return readCatalog(this, options);
+	}
+	cite(options) {
+		return citationRecords(this, options);
+	}
+	table(name) {
+		return catalogTable(this, name);
+	}
+	labels() {
+		return sortedUnique(this.guidelines.flatMap((guideline) => [...guideline.labels]));
+	}
+	sectionRoles() {
+		return sortedUnique(this.guidelines.flatMap((guideline) => guideline.sections.map((section) => section.role).filter((role) => role !== "__dangling__")));
+	}
+	describe(options = {}) {
+		return describeCatalog(this, descriptionByCatalog.get(this) ?? emptyDescriptionContext(), options);
+	}
+	[Symbol.iterator]() {
+		return this.guidelines[Symbol.iterator]();
+	}
+};
+function catalogWithRelease(catalog, context) {
+	const release = copyCatalogRelease(context.release);
+	const profiles = releaseProfiles(release);
+	releaseByCatalog.set(catalog, Object.freeze({
+		release,
+		releaseUrl: context.releaseUrl,
+		artifactLoader: context.artifactLoader
+	}));
+	descriptionByCatalog.set(catalog, Object.freeze({
+		resolvedLocation: context.releaseUrl,
+		releaseDigest: release.digest,
+		profiles,
+		profileLoader: context.profileLoader,
+		profileCache: /* @__PURE__ */ new Map()
+	}));
+	return catalog;
+}
+function emptyDescriptionContext() {
+	return Object.freeze({
+		resolvedLocation: null,
+		releaseDigest: null,
+		profiles: Object.freeze([]),
+		profileCache: /* @__PURE__ */ new Map()
+	});
+}
+function isGuidelineInput(value) {
+	if (!isJsonObject(value)) return false;
+	const { description, id, labels, references, sections, title } = value;
+	if (!isJsonString(id) || id.length === 0) return false;
+	if (!isJsonString(title) || !isJsonString(description)) return false;
+	if (!isStringArray(labels) || !isStringArray(references)) return false;
+	if (!Array.isArray(sections) || sections.length === 0 || !sections.every(isGuidelineSection)) return false;
+	const dangling = sections.flatMap((section, index) => section.role === "__dangling__" ? [index] : []);
+	if (dangling.length > 0 && (dangling.length !== 1 || dangling[0] !== 0)) return false;
+	try {
+		return labels.every((label) => normalizeLabel(label) === label);
+	} catch {
+		return false;
+	}
+}
+function copyGuideline(value) {
+	if (!isGuidelineInput(value)) throw new CatalogError("Invalid guideline record.");
+	const sections = Object.freeze(value.sections.map((section) => Object.freeze({
+		role: section.role,
+		title: section.title,
+		content: section.content
+	})));
+	return Object.freeze({
+		id: value.id,
+		title: value.title,
+		description: value.description,
+		labels: Object.freeze([...value.labels]),
+		body: bodyFromSections(sections),
+		sections,
+		references: Object.freeze([...value.references])
+	});
+}
+function isGuidelineSection(value) {
+	if (!isJsonObject(value)) return false;
+	const { content, role, title } = value;
+	return isJsonString(role) && role.length > 0 && role === role.trim() && isJsonString(title) && title === title.trim() && isJsonString(content) && content === content.trim() && (role === "__dangling__" ? title.length === 0 && content.length > 0 : title.length > 0);
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every(isJsonString);
+}
+function bodyFromSections(sections) {
+	return sections.map((section) => {
+		if (section.role === "__dangling__") return section.content;
+		return `## ${section.title} <!-- role: ${section.role} -->\n\n${section.content}`;
+	}).join("\n\n");
+}
+function sortedUnique(values) {
+	return Array.from(new Set(values)).sort();
+}
+//#endregion
+//#region src/catalog/wire.ts
+const catalogRowFields = [
+	"id",
+	"title",
+	"description",
+	"labels",
+	"sections",
+	"references"
+];
+const sectionFields = [
+	"role",
+	"title",
+	"content"
+];
+function hasFields(value, fields) {
+	return Object.keys(value).length === fields.length && fields.every((field) => Object.hasOwn(value, field));
+}
+function isCatalogRowWire(value) {
+	if (!isJsonObject(value) || !hasFields(value, catalogRowFields)) return false;
+	const sections = value.sections;
+	if (!Array.isArray(sections) || !sections.every(sectionHasExactFields)) return false;
+	return isGuidelineInput(value);
+}
+function guidelineFromWire(value) {
+	if (!isCatalogRowWire(value)) return null;
+	const sections = value.sections.map((section) => ({ ...section }));
+	return {
+		id: value.id,
+		title: value.title,
+		description: value.description,
+		labels: [...value.labels],
+		sections,
+		references: [...value.references]
+	};
+}
+function requireGuidelineFromWire(value, context) {
+	const guideline = guidelineFromWire(value);
+	if (guideline) return guideline;
+	const suffix = context ? ` (${context})` : "";
+	throw new CatalogError(`Invalid catalog row format${suffix}.`);
+}
+function sectionHasExactFields(value) {
+	return isJsonObject(value) && hasFields(value, sectionFields);
+}
+//#endregion
+//#region src/catalog/parquet.ts
+const MAX_CORE_ARTIFACT_BYTES$1 = 67108864;
+function normalizeParquetBytes(bytes) {
+	if (bytes instanceof ArrayBuffer) return bytes;
+	return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength).slice().buffer;
+}
+function isParquetBytes(bytes) {
+	return bytes instanceof ArrayBuffer || ArrayBuffer.isView(bytes);
+}
+async function loadCatalog(input) {
+	return loadCatalogWithProfileLoader(input);
+}
+async function loadCatalogWithProfileLoader(input, profileLoader, artifactLoader) {
+	const release = copyCatalogRelease(input.release);
+	await assertReleaseDigest(release);
+	assertReleaseLocation(input.releaseUrl, release);
+	releaseProfileNames(release);
+	assertCoreArtifactSize(release, "entries.parquet", input.entries.byteLength);
+	assertCoreArtifactSize(release, "MANIFEST.md", input.manifest.byteLength);
+	await Promise.all([assertReleaseArtifactBytes("entries.parquet", releaseArtifact(release, "entries.parquet"), input.entries), assertReleaseArtifactBytes("MANIFEST.md", releaseArtifact(release, "MANIFEST.md"), input.manifest)]);
+	let manifestText;
+	try {
+		manifestText = new TextDecoder("utf-8", { fatal: true }).decode(normalizeParquetBytes(input.manifest));
+	} catch {
+		throw new CatalogError("Catalog manifest must contain valid UTF-8.");
+	}
+	return parseCatalogData({
+		entries: input.entries,
+		manifestText
+	}, {
+		release,
+		releaseUrl: sanitizeReleaseUrl(input.releaseUrl),
+		profileLoader,
+		artifactLoader: artifactLoader ?? suppliedArtifacts(input)
+	});
+}
+function suppliedArtifacts(input) {
+	const entries = new Uint8Array(normalizeParquetBytes(input.entries)).slice();
+	const manifest = new Uint8Array(normalizeParquetBytes(input.manifest)).slice();
+	return async (path, signal) => {
+		signal?.throwIfAborted();
+		if (path === "entries.parquet") return entries.slice();
+		if (path === "MANIFEST.md") return manifest.slice();
+		throw new CatalogError(`Artifact bytes were not supplied: ${path}`, { code: "unavailable_capability" });
+	};
+}
+function assertCoreArtifactSize(release, path, receivedBytes) {
+	if (releaseArtifact(release, path).bytes > MAX_CORE_ARTIFACT_BYTES$1 || receivedBytes > MAX_CORE_ARTIFACT_BYTES$1) throw new CatalogError(`Catalog artifact exceeds size limit: ${path}`);
+}
+async function loadCatalogData(input) {
+	return parseCatalogData(input);
+}
+async function parseCatalogData(input, releaseContext) {
+	const manifest = parseCatalogManifest(input.manifestText);
+	const normalizedFile = isParquetBytes(input.entries) ? normalizeParquetBytes(input.entries) : input.entries;
+	const catalog = new Catalog((await parquetReadObjects({
+		file: normalizedFile,
+		compressors
+	})).map((row, index) => requireGuidelineFromWire(row, `parquet row ${index}`)), manifest);
+	return releaseContext ? catalogWithRelease(catalog, releaseContext) : catalog;
+}
+//#endregion
+//#region src/catalog/profile.ts
+const profileFields = [
+	"schema_version",
+	"documents_version",
+	"entries_digest",
+	"manifest_digest",
+	"embedding_functions",
+	"dimensions",
+	"distance_metric",
+	"python_requirements",
+	"lancedb_version",
+	"projection"
+];
+const bindingFields = [
+	"name",
+	"model",
+	"source_column",
+	"vector_column"
+];
+const projectionFields = ["algorithm", "options"];
+const sha256Pattern = /^[a-f0-9]{64}$/;
+const distributionPattern = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
+const versionPattern = /^[A-Za-z0-9][A-Za-z0-9.!+_-]*$/;
+const variablePattern = /^\$var:[^:]+$/;
+const sensitiveNamePattern = /(?:^|[_-])(?:access[_-]?key|api[_-]?key|authorization|client[_-]?secret|cookie|credential|password|private[_-]?key|secret|signature|token)(?:$|[_-])/i;
+const sensitiveQueryNames = /* @__PURE__ */ new Set([
+	"access_key",
+	"api_key",
+	"apikey",
+	"authorization",
+	"credential",
+	"password",
+	"secret",
+	"signature",
+	"sig",
+	"token"
+]);
+function parseProfileMetadata(value) {
+	const record = requireObject(value, "Profile metadata");
+	requireExactFields(record, profileFields, "Profile metadata");
+	if (record.schema_version !== 1) throw new CatalogError("Profile schema_version must be 1.");
+	if (record.documents_version !== 1) throw new CatalogError("Profile documents_version must be 1.");
+	const entriesDigest = requireSha256(record.entries_digest, "Profile entries_digest");
+	const manifestDigest = requireSha256(record.manifest_digest, "Profile manifest_digest");
+	if (!Array.isArray(record.embedding_functions) || record.embedding_functions.length !== 1) throw new CatalogError("Profile must contain exactly one embedding binding.");
+	const binding = parseBinding(record.embedding_functions[0]);
+	const dimensions = record.dimensions;
+	if (!isJsonNumber(dimensions) || !Number.isSafeInteger(dimensions) || dimensions < 1) throw new CatalogError("Profile dimensions must be a positive safe integer.");
+	const distanceMetric = record.distance_metric;
+	if (distanceMetric !== "cosine" && distanceMetric !== "l2" && distanceMetric !== "dot") throw new CatalogError("Profile distance_metric must be cosine, l2, or dot.");
+	const pythonRequirements = parseRequirements(record.python_requirements);
+	const lancedbVersion = requireVersion(record.lancedb_version, "Profile lancedb_version");
+	const projection = record.projection === null ? null : parseProjection(record.projection);
+	return Object.freeze({
+		schema_version: 1,
+		documents_version: 1,
+		entries_digest: entriesDigest,
+		manifest_digest: manifestDigest,
+		embedding_functions: Object.freeze([binding]),
+		dimensions,
+		distance_metric: distanceMetric,
+		python_requirements: pythonRequirements,
+		lancedb_version: lancedbVersion,
+		projection
+	});
+}
+function parseBinding(value) {
+	const record = requireObject(value, "Profile embedding binding");
+	requireExactFields(record, bindingFields, "Profile embedding binding");
+	const name = record.name;
+	if (!isJsonString(name) || !name || name !== name.trim()) throw new CatalogError("Profile embedding name must be a non-empty string.");
+	if (record.source_column !== "text" || record.vector_column !== "vector") throw new CatalogError("Profile embedding binding must map text to vector.");
+	const model = requireObject(record.model, "Profile embedding model");
+	validateModel(model);
+	return Object.freeze({
+		name,
+		model: freezeJsonObject(model),
+		source_column: "text",
+		vector_column: "vector"
+	});
+}
+function parseProjection(value) {
+	const record = requireObject(value, "Profile projection");
+	requireExactFields(record, projectionFields, "Profile projection");
+	const algorithm = record.algorithm;
+	if (algorithm !== "empty" && algorithm !== "linear" && algorithm !== "umap") throw new CatalogError("Profile projection algorithm is unsupported.");
+	return Object.freeze({
+		algorithm,
+		options: freezeJsonObject(requireObject(record.options, "Profile projection options"))
+	});
+}
+function parseRequirements(value) {
+	const record = requireObject(value, "Profile Python requirements");
+	const requirements = Object.create(null);
+	for (const [name, requirement] of Object.entries(record)) {
+		if (!distributionPattern.test(name) || !isJsonString(requirement) || !versionPattern.test(requirement) || !/[0-9]/.test(requirement)) throw new CatalogError("Profile python_requirements must map distribution names to exact versions.");
+		requirements[name] = requirement;
+	}
+	return Object.freeze(requirements);
+}
+function validateModel(model) {
+	for (const [key, value] of Object.entries(model)) {
+		const variables = variableValues(value);
+		if (variables.some((variable) => !variablePattern.test(variable)) || variables.length > 0 && !isJsonString(value)) throw new CatalogError(`Profile embedding setting ${JSON.stringify(key)} has an invalid variable.`);
+		if (sensitiveNamePattern.test(key) && value !== null && (!isJsonString(value) || !variablePattern.test(value))) throw new CatalogError(`Profile embedding setting ${JSON.stringify(key)} must use a registry variable.`);
+		if (key === "default_headers" && value !== null && (!isJsonObject(value) || Object.keys(value).length > 0)) throw new CatalogError("Profile embedding default_headers must be empty.");
+		if (containsSensitiveKey(value)) throw new CatalogError(`Profile embedding setting ${JSON.stringify(key)} contains authentication data.`);
+		rejectCredentialUrls(value, key);
+	}
+	if (Object.hasOwn(model, "trust_remote_code") && model.trust_remote_code !== false) throw new CatalogError("Profile embedding must disable remote model code.");
+}
+function containsSensitiveKey(value) {
+	if (Array.isArray(value)) return value.some(containsSensitiveKey);
+	if (!isJsonObject(value)) return false;
+	return Object.entries(value).some(([key, item]) => sensitiveNamePattern.test(key) || containsSensitiveKey(item));
+}
+function rejectCredentialUrls(value, path) {
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => rejectCredentialUrls(item, `${path}[${index}]`));
+		return;
+	}
+	if (isJsonObject(value)) {
+		for (const [key, item] of Object.entries(value)) rejectCredentialUrls(item, `${path}.${key}`);
+		return;
+	}
+	if (!isJsonString(value)) return;
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch {
+		return;
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
+	if (parsed.username || parsed.password) throw new CatalogError(`Profile embedding URL setting ${JSON.stringify(path)} contains credentials.`);
+	if (Array.from(parsed.searchParams.keys()).some((name) => sensitiveQueryNames.has(name.toLowerCase()) || sensitiveNamePattern.test(name))) throw new CatalogError(`Profile embedding URL setting ${JSON.stringify(path)} contains authentication parameters.`);
+}
+function variableValues(value) {
+	if (isJsonString(value)) return value.startsWith("$var:") ? [value] : [];
+	if (Array.isArray(value)) return value.flatMap(variableValues);
+	if (!isJsonObject(value)) return [];
+	return Object.values(value).flatMap(variableValues);
+}
+function freezeJsonObject(value) {
+	const result = Object.create(null);
+	for (const [key, item] of Object.entries(value)) result[key] = freezeJson(item);
+	return Object.freeze(result);
+}
+function freezeJson(value) {
+	if (Object.prototype.toString.call(value) === "[object Number]" && !isJsonNumber(value)) throw new CatalogError("Profile metadata must contain finite JSON numbers.");
+	if (Array.isArray(value)) return Object.freeze(value.map(freezeJson));
+	if (isJsonObject(value)) return freezeJsonObject(value);
+	return value;
+}
+function requireObject(value, label) {
+	if (!isJsonObject(value)) throw new CatalogError(`${label} must be a JSON object.`);
+	return value;
+}
+function requireExactFields(value, fields, label) {
+	const actual = Object.keys(value);
+	const missing = fields.filter((field) => !Object.hasOwn(value, field));
+	const unknown = actual.filter((field) => !fields.includes(field));
+	if (missing.length > 0) throw new CatalogError(`${label} is missing fields: ${missing.join(", ")}.`);
+	if (unknown.length > 0) throw new CatalogError(`${label} has unsupported fields: ${unknown.join(", ")}.`);
+}
+function requireSha256(value, label) {
+	if (!isJsonString(value) || !sha256Pattern.test(value)) throw new CatalogError(`${label} must be a lowercase SHA-256 digest.`);
+	return value;
+}
+function requireVersion(value, label) {
+	if (!isJsonString(value) || !versionPattern.test(value) || !/[0-9]/.test(value)) throw new CatalogError(`${label} must be a non-empty exact version.`);
+	return value;
+}
+//#endregion
+//#region src/catalog/open.ts
+const CATALOG_REQUEST_TIMEOUT_MS = 9e5;
+const CATALOG_BODY_READ_ERROR = "Failed to read catalog resource body.";
+const MAX_CATALOG_JSON_BYTES = 1048576;
+const MAX_CORE_ARTIFACT_BYTES = 67108864;
+const MAX_PROFILE_METADATA_BYTES = 65536;
+async function openCatalog(location = catalogUrl(), options = {}) {
+	const fetch = options.fetch ?? globalThis.fetch;
+	const descriptor = requireDescriptorUrl(location, options.fetch !== void 0);
+	const release = parseCatalogRelease(await fetchJson(descriptor.url, fetch, options.signal, descriptor.kind === "catalog" ? "no-cache" : void 0));
+	await assertReleaseDigest(release);
+	if (descriptor.kind === "release") assertReleaseLocation(descriptor.url, release);
+	return loadCatalogFromRelease(fetch, descriptor.kind === "catalog" ? new URL(`catalog/releases/${release.digest}/`, descriptor.url).toString() : new URL(".", descriptor.url).toString(), descriptor.kind === "catalog" ? new URL(`catalog/releases/${release.digest}/release.json`, descriptor.url).toString() : descriptor.url, release, options);
+}
+async function loadCatalogFromRelease(fetch, artifactBase, releaseUrl, release, options) {
+	const signal = options.signal;
+	const artifacts = /* @__PURE__ */ new Map();
+	const loadArtifact = async (path, signal) => {
+		const timeout = AbortSignal.timeout(CATALOG_REQUEST_TIMEOUT_MS);
+		signal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+		signal?.throwIfAborted();
+		const descriptor = releaseArtifact(release, path);
+		const maximum = path === "entries.parquet" || path === "MANIFEST.md" ? MAX_CORE_ARTIFACT_BYTES : 1024 ** 3;
+		if (descriptor.bytes > maximum) throw new CatalogError(`Catalog artifact exceeds size limit: ${path}`);
+		const retain = path === "entries.parquet" || path === "MANIFEST.md" || descriptor.bytes <= MAX_PROFILE_METADATA_BYTES;
+		const memory = artifacts.get(path);
+		if (memory) return memory.slice();
+		const cached = await options.cache?.get(descriptor.sha256, descriptor.bytes);
+		if (cached) try {
+			await assertReleaseArtifactBytes(path, descriptor, cached);
+			signal?.throwIfAborted();
+			if (retain) artifacts.set(path, cached.slice());
+			return cached.slice();
+		} catch (error) {
+			if (!(error instanceof CatalogError) || error.code !== "integrity") throw error;
+		}
+		const bytes = new Uint8Array(await fetchReleaseArtifact(fetch, artifactBase, path, descriptor, signal));
+		await assertReleaseArtifactBytes(path, descriptor, bytes);
+		signal?.throwIfAborted();
+		await options.cache?.put(descriptor.sha256, bytes.slice());
+		signal?.throwIfAborted();
+		if (retain) artifacts.set(path, bytes);
+		return bytes.slice();
+	};
+	const controller = new AbortController();
+	const requestSignal = signal ? AbortSignal.any([controller.signal, signal]) : controller.signal;
+	try {
+		const [entries, manifest] = await Promise.all([loadArtifact("entries.parquet", requestSignal), loadArtifact("MANIFEST.md", requestSignal)]);
+		return loadCatalogWithProfileLoader({
+			entries,
+			manifest,
+			release,
+			releaseUrl
+		}, profileLoader(loadArtifact, release), loadArtifact);
+	} catch (error) {
+		controller.abort(error);
+		throw error;
+	}
+}
+async function fetchJson(url, fetch, signal, cache) {
+	const timeout = AbortSignal.timeout(CATALOG_REQUEST_TIMEOUT_MS);
+	signal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+	const data = await readResponseBytes(await fetchCatalogResource(url, fetch, signal, cache), MAX_CATALOG_JSON_BYTES, "Catalog JSON exceeds size limit.", signal);
+	try {
+		const text = new TextDecoder("utf-8", { fatal: true }).decode(data);
+		return parseJson(text);
+	} catch {
+		throw new CatalogError("Catalog JSON must contain valid UTF-8 JSON.");
+	}
+}
+async function fetchReleaseArtifact(fetch, artifactBase, path, artifact, signal) {
+	return readArtifactBytes(await fetchCatalogResource(releaseArtifactUrl(artifactBase, path), fetch, signal), path, artifact, signal);
+}
+async function readArtifactBytes(response, path, artifact, signal) {
+	const maximum = path === "entries.parquet" || path === "MANIFEST.md" ? MAX_CORE_ARTIFACT_BYTES : 1024 ** 3;
+	const absoluteLimitApplies = artifact.bytes > maximum;
+	return readResponseBytes(response, Math.min(artifact.bytes, maximum), absoluteLimitApplies ? `Catalog artifact exceeds size limit: ${path}` : `Catalog artifact byte count mismatch: ${path}`, signal);
+}
+async function readResponseBytes(response, limit, limitError, signal) {
+	signal?.throwIfAborted();
+	let reader;
+	try {
+		reader = response.body?.getReader();
+	} catch {
+		throw new CatalogError(CATALOG_BODY_READ_ERROR);
+	}
+	if (!reader) return /* @__PURE__ */ new ArrayBuffer(0);
+	const activeReader = reader;
+	const abort = () => {
+		activeReader.cancel(signal?.reason).catch(() => {});
+	};
+	signal?.addEventListener("abort", abort, { once: true });
+	if (signal?.aborted) abort();
+	const chunks = [];
+	let size = 0;
+	let failure;
+	while (!failure) try {
+		const result = await reader.read();
+		signal?.throwIfAborted();
+		if (result.done) break;
+		const { value } = result;
+		size += value.byteLength;
+		if (size > limit) {
+			reader.cancel().catch(() => {});
+			failure = new CatalogError(limitError);
+			break;
+		}
+		chunks.push(value);
+	} catch {
+		failure = signal?.aborted ? abortReason(signal) : new CatalogError(CATALOG_BODY_READ_ERROR);
+	}
+	signal?.removeEventListener("abort", abort);
+	try {
+		reader.releaseLock();
+	} catch {
+		failure ??= new CatalogError(CATALOG_BODY_READ_ERROR);
+	}
+	if (failure) throw failure;
+	try {
+		const data = new Uint8Array(size);
+		let offset = 0;
+		for (const chunk of chunks) {
+			data.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return data.buffer;
+	} catch {
+		throw new CatalogError(CATALOG_BODY_READ_ERROR);
+	}
+}
+async function fetchCatalogResource(url, fetch, signal, cache) {
+	const timeout = AbortSignal.timeout(CATALOG_REQUEST_TIMEOUT_MS);
+	const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+	const init = cache ? {
+		signal: requestSignal,
+		cache
+	} : { signal: requestSignal };
+	let response;
+	try {
+		response = await fetch(url, init);
+	} catch {
+		if (signal?.aborted) throw abortReason(signal);
+		throw new CatalogError("Failed to load catalog resource.");
+	}
+	let ok;
+	let status;
+	try {
+		ok = response.ok;
+		status = response.status;
+	} catch {
+		throw new CatalogError("Failed to load catalog resource.");
+	}
+	if (!ok) {
+		try {
+			await response.body?.cancel();
+		} catch {}
+		const message = Number.isInteger(status) ? `Failed to load catalog resource: HTTP ${status}.` : "Failed to load catalog resource.";
+		throw new CatalogError(message);
+	}
+	return response;
+}
+function profileLoader(loadArtifact, release) {
+	return async (profile, signal) => {
+		const path = profile.metadata;
+		if (releaseArtifact(release, path).bytes > MAX_PROFILE_METADATA_BYTES) throw new CatalogError("Profile metadata exceeds the 64 KiB limit.", {
+			code: "incompatible_profile",
+			details: { profile: profile.name }
+		});
+		let data;
+		try {
+			data = await loadArtifact(path, signal);
+		} catch (error) {
+			if (signal?.aborted) throw abortReason(signal);
+			throw new CatalogError(error instanceof CatalogError ? error.message : `Profile metadata could not be loaded: ${profile.name}.`, {
+				code: "integrity",
+				details: { profile: profile.name }
+			});
+		}
+		let value;
+		try {
+			const text = new TextDecoder("utf-8", { fatal: true }).decode(data);
+			value = parseJson(text);
+		} catch {
+			throw new CatalogError(`Profile metadata is not valid UTF-8 JSON: ${profile.name}.`, {
+				code: "incompatible_profile",
+				details: { profile: profile.name }
+			});
+		}
+		try {
+			return parseProfileMetadata(value);
+		} catch (error) {
+			if (error instanceof CatalogError) throw new CatalogError(error.message, {
+				code: "incompatible_profile",
+				details: { profile: profile.name }
+			});
+			throw error;
+		}
+	};
+}
+function abortReason(signal) {
+	return signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted.", "AbortError");
+}
+function requireDescriptorUrl(input, customFetch) {
+	const value = input.toString();
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new CatalogError("Catalog location must be an absolute HTTP or HTTPS URL.");
+	}
+	if (!customFetch && url.protocol !== "http:" && url.protocol !== "https:") throw new CatalogError("Catalog location must use HTTP or HTTPS.");
+	const name = url.pathname.split("/").at(-1);
+	if (name === "catalog.json") return {
+		kind: "catalog",
+		url: url.toString()
+	};
+	if (name === "release.json") return {
+		kind: "release",
+		url: url.toString()
+	};
+	throw new CatalogError("Catalog location URL must name catalog.json or release.json.");
+}
+//#endregion
+export { Catalog as a, releaseArtifact as c, loadCatalogData as i, parseCatalogManifest as l, parseProfileMetadata as n, assertReleaseDigest as o, loadCatalog as r, parseCatalogRelease as s, openCatalog as t };