@chartcoach/catalog 0.1.6 → 0.2.0

package/dist/duckdb.js

@@ -0,0 +1,9 @@
+import { t as registrationPlan } from "./registration-DXhS7vgr.js";
+//#region src/duckdb.ts
+/** Create or replace canonical catalog tables in a caller-owned DuckDB connection. */
+async function registerCatalog(connection, catalog, options = {}) {
+	for (const { sql, rows } of registrationPlan(catalog, options, "parameter")) await connection.run(sql, [rows]);
+	return connection;
+}
+//#endregion
+export { registerCatalog };

package/dist/index-cache-Cx1gIK6N.js

@@ -0,0 +1,280 @@
+import { a as CatalogError, i as parseJson, n as isJsonObject, r as isJsonString } from "./json-CBWjz9b4.js";
+import { randomUUID } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { chmod, lstat, mkdir, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { Transform, Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+import { Parser } from "tar";
+//#region src/node/index-cache.ts
+const pending = /* @__PURE__ */ new Map();
+async function extractIndex(options) {
+	if (options.directory !== void 0) {
+		const target = resolve(options.directory);
+		const archive = await options.archive();
+		await mkdir(dirname(target), { recursive: true });
+		return unpack(archive, target, options.signal);
+	}
+	if (process.platform === "win32") throw new CatalogError("Protected shared index extraction is unavailable on this platform.", {
+		code: "unavailable_capability",
+		hints: ["Pass a new caller-owned directory to indexPath(...)."]
+	});
+	await mkdir(options.cacheDirectory, { recursive: true });
+	const cache = await realpath(options.cacheDirectory);
+	const root = join(cache, "indexes-v2", options.digest);
+	const previous = pending.get(root) ?? Promise.resolve("");
+	let active = false;
+	const operation = (async () => {
+		await previous.catch(() => "");
+		active = true;
+		options.signal?.throwIfAborted();
+		return cachedIndex(root, options);
+	})();
+	pending.set(root, operation);
+	const settled = () => {
+		if (pending.get(root) === operation) pending.delete(root);
+	};
+	operation.then(settled, settled);
+	return wait(operation, () => active, options.signal);
+}
+async function cachedIndex(root, options) {
+	await safeDirectory(dirname(root));
+	await safeDirectory(root);
+	const generations = join(root, "generations");
+	await safeDirectory(generations);
+	const current = await currentGeneration(root, options.digest, options.signal);
+	if (current) return current;
+	const archive = await options.archive();
+	const generation = randomUUID().replaceAll("-", "");
+	const staged = join(root, `.${generation}.tmp`);
+	const published = join(generations, generation);
+	const pointer = join(root, `.current.${generation}.tmp`);
+	let committed = false;
+	try {
+		await unpack(archive, staged, options.signal);
+		await writeFile(join(staged, ".complete"), options.digest, { flag: "wx" });
+		options.signal?.throwIfAborted();
+		await rename(staged, published);
+		await seal(published, options.signal);
+		await writeFile(pointer, JSON.stringify({
+			digest: options.digest,
+			generation
+		}), { flag: "wx" });
+		options.signal?.throwIfAborted();
+		await rename(pointer, join(root, "current.json"));
+		committed = true;
+		return published;
+	} finally {
+		await rm(pointer, { force: true });
+		await discard(staged);
+		if (!committed) await discard(published);
+	}
+}
+async function currentGeneration(root, digest, signal) {
+	try {
+		const pointer = join(root, "current.json");
+		const status = await lstat(pointer);
+		if (!status.isFile() || status.size > 1024) return void 0;
+		const value = parseJson(await readFile(pointer, "utf8"));
+		if (!isJsonObject(value)) return void 0;
+		if (value.digest !== digest || !isJsonString(value.generation) || !/^[a-f0-9]{32}$/.test(value.generation)) return void 0;
+		const target = join(root, "generations", value.generation);
+		if (!await validTree(target, signal)) return void 0;
+		const marker = join(target, ".complete");
+		const markerStatus = await lstat(marker);
+		if (!markerStatus.isFile() || markerStatus.size !== digest.length || await readFile(marker, "utf8") !== digest) return void 0;
+		if (!(await lstat(join(target, "documents.lance"))).isDirectory()) return void 0;
+		return target;
+	} catch (error) {
+		signal?.throwIfAborted();
+		if (error instanceof SyntaxError || error instanceof Error && isMissing(error)) return void 0;
+		throw error;
+	}
+}
+async function validTree(root, signal) {
+	let count = 0;
+	const visit = async (path) => {
+		signal?.throwIfAborted();
+		const status = await lstat(path);
+		if (++count > 100002 || (status.mode & 146) !== 0) return false;
+		if (status.isFile()) return true;
+		if (!status.isDirectory()) return false;
+		for (const name of await readdir(path)) if (!await visit(join(path, name))) return false;
+		return true;
+	};
+	return (await lstat(root)).isDirectory() && visit(root);
+}
+async function unpack(archive, target, signal) {
+	signal?.throwIfAborted();
+	try {
+		await mkdir(target);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "EEXIST") throw new CatalogError("Index directory already exists. Pass a new directory.");
+		throw error;
+	}
+	const members = /* @__PURE__ */ new Map();
+	let count = 0;
+	let total = 0;
+	let expanded = 0;
+	let ended = false;
+	const cancellation = new AbortController();
+	const extractionSignal = signal ? AbortSignal.any([signal, cancellation.signal]) : cancellation.signal;
+	const jobs = [];
+	const extractor = new Parser({
+		strict: true,
+		maxMetaEntrySize: 1048576,
+		maxDecompressionRatio: 0,
+		brotli: false,
+		zstd: false,
+		onReadEntry(entry) {
+			const job = writeEntry(entry);
+			jobs.push(job);
+			job.catch((error) => cancellation.abort(error));
+		}
+	});
+	async function writeEntry(entry) {
+		extractionSignal.throwIfAborted();
+		const directory = entry.type === "Directory";
+		if (!directory && entry.type !== "File") throw integrity("Index archive must contain regular files and directories.");
+		if (++count > 1e5) throw integrity("Index archive contains too many members.");
+		if (!Number.isSafeInteger(entry.size) || entry.size < 0 || entry.size > 2 * 1024 ** 3) throw integrity("Index archive member exceeds the 2 GiB limit.");
+		total += entry.size;
+		if (total > 8 * 1024 ** 3) throw integrity("Index archive expands beyond the 8 GiB limit.");
+		const parts = portablePath(entry.path, directory);
+		for (let length = 1; length <= parts.length; length += 1) {
+			const name = parts.slice(0, length).join("/");
+			const key = name.normalize("NFKC").toUpperCase();
+			const previous = members.get(key);
+			const leaf = length === parts.length;
+			if (previous && (previous.path !== name || !previous.directory || leaf && (!directory || previous.explicit))) throw integrity("Index archive members collide.");
+			if (!previous && members.size >= 1e5) throw integrity("Index archive contains too many filesystem entries.");
+			members.set(key, {
+				path: name,
+				directory: !leaf || directory,
+				explicit: leaf || previous?.explicit === true
+			});
+		}
+		const output = join(target, ...parts);
+		if (directory) {
+			await mkdir(output, {
+				recursive: true,
+				mode: 448
+			});
+			entry.resume();
+		} else {
+			await mkdir(dirname(output), {
+				recursive: true,
+				mode: 448
+			});
+			await pipeline(entry, createWriteStream(output, {
+				flags: "wx",
+				mode: 384
+			}), { signal: extractionSignal });
+		}
+	}
+	const destination = new Writable({
+		write(chunk, _encoding, callback) {
+			if (ended) {
+				callback();
+				return;
+			}
+			try {
+				if (extractor.write(chunk)) callback();
+				else extractor.once("drain", callback);
+			} catch (error) {
+				callback(error instanceof Error ? error : new Error(String(error)));
+			}
+		},
+		final(callback) {
+			extractor.once("end", callback);
+			try {
+				extractor.end();
+			} catch (error) {
+				callback(error instanceof Error ? error : new Error(String(error)));
+			}
+		}
+	});
+	extractor.on("eof", () => {
+		ended = true;
+	});
+	extractor.on("error", (error) => destination.destroy(error));
+	extractor.on("ignoredEntry", () => destination.destroy(integrity("Index archive contains an unsupported or oversized member.")));
+	const limit = new Transform({ transform(chunk, _encoding, callback) {
+		expanded += chunk.length;
+		callback(expanded > 8 * 1024 ** 3 + 1024e5 ? integrity("Index archive decompression exceeds the size limit.") : null, chunk);
+	} });
+	try {
+		await pipeline(createReadStream(archive), createGunzip(), limit, destination, { signal: extractionSignal });
+		await Promise.all(jobs);
+		if (!(await lstat(join(target, "documents.lance"))).isDirectory()) throw integrity("Index archive must contain the documents LanceDB table.");
+		signal?.throwIfAborted();
+		return target;
+	} catch (error) {
+		cancellation.abort(error);
+		await Promise.allSettled(jobs);
+		await discard(target);
+		signal?.throwIfAborted();
+		if (cancellation.signal.reason instanceof CatalogError) throw cancellation.signal.reason;
+		if (error instanceof CatalogError) throw error;
+		throw integrity("Index archive could not be extracted as a complete LanceDB database.");
+	}
+}
+function portablePath(path, directory) {
+	const normalized = directory && path.endsWith("/") ? path.slice(0, -1) : path;
+	const parts = normalized.split("/");
+	if (Buffer.byteLength(normalized) > 4096 || parts.length > 64 || parts.some((part) => !part || Buffer.byteLength(part) > 255 || part === "." || part === ".." || /[\p{Cc}\\:<>"|?*]/u.test(part) || /[. ]$/.test(part) || /^(?:CON|PRN|AUX|NUL|CONIN\$|CONOUT\$|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(part.normalize("NFKC"))) || parts[0]?.normalize("NFKC").toUpperCase() === ".COMPLETE") throw integrity("Index archive contains an unsafe path.");
+	return parts;
+}
+async function safeDirectory(path) {
+	try {
+		await mkdir(path);
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+	}
+	if (!(await lstat(path)).isDirectory()) throw integrity("Index cache path must be a directory, not a link.");
+}
+async function seal(root, signal) {
+	signal?.throwIfAborted();
+	if ((await lstat(root)).isDirectory()) {
+		for (const name of await readdir(root)) await seal(join(root, name), signal);
+		await chmod(root, 365);
+	} else await chmod(root, 292);
+}
+async function discard(root) {
+	try {
+		if ((await lstat(root)).isDirectory()) {
+			await chmod(root, 448);
+			for (const name of await readdir(root)) await discard(join(root, name));
+		}
+		await rm(root, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		if (!(error instanceof Error && isMissing(error))) throw error;
+	}
+}
+function isMissing(error) {
+	return "code" in error && error.code === "ENOENT";
+}
+function integrity(message) {
+	return new CatalogError(message, { code: "integrity" });
+}
+async function wait(operation, active, signal) {
+	if (!signal) return operation;
+	signal.throwIfAborted();
+	let abort = () => {};
+	try {
+		return await Promise.race([operation, new Promise((_resolve, reject) => {
+			abort = () => {
+				if (!active()) reject(signal.reason);
+			};
+			signal.addEventListener("abort", abort, { once: true });
+		})]);
+	} finally {
+		signal.removeEventListener("abort", abort);
+	}
+}
+//#endregion
+export { extractIndex };

package/dist/index.d.ts

@@ -1,8 +1,40 @@
-export { Catalog, type CatalogOptions, type Guideline, type GuidelineSection, } from "./catalog/model.js";
-export { CatalogError } from "./catalog/errors.js";
-export { CHARTCOACH_DEFAULTS, DEFAULT_CATALOG, catalogArtifact, catalogArtifactUrl, parseCatalogReleaseMetadata, type ArtifactDescriptor, type ArtifactKind, type CatalogReleaseMetadata, type ChartCoachDefaults, } from "./catalog/artifacts.js";
-export { loadCatalog, type AsyncBuffer, type CatalogBytes, type LoadCatalogInput, type ParquetBytes, } from "./catalog/load-parquet-core.js";
-export { type CatalogManifest, type ManifestDefinition, parseCatalogManifest, } from "./catalog/manifest.js";
-export { parseLabel, type CatalogLabel } from "./catalog/labels.js";
-export { toMarkdown } from "./catalog/markdown.js";
-//# sourceMappingURL=index.d.ts.map
+import { A as parseProfileMetadata, C as CatalogRelease, D as EmbeddingBinding, E as DistanceMetric, F as JsonValue, M as ManifestDefinition, N as parseCatalogManifest, O as ProfileMetadata, P as JsonObject, S as TableName, T as parseCatalogRelease, _ as DescribeOptions, a as GuidelineSection, b as TableColumnInfo, c as SourceDetail, d as CiteOptions, f as FullSourceRecord, g as CatalogInfo, h as QueryOptions, i as GuidelineInput, j as CatalogManifest, k as ProjectionMetadata, l as CitationRecord, m as EntryCandidate, n as Catalog, o as GuidelineEntryRecord, p as MinimalSourceRecord, r as Guideline, s as ReadOptions, t as ArtifactOptions, u as CitationSource, v as ProfileInfo, w as ReleaseArtifact, x as TableInfo, y as CatalogTables } from "./model-De0MF-zg.js";
+import { i as openCatalog, n as FetchLike, r as OpenCatalogOptions, t as ArtifactCache } from "./open-Nnzkr_bE.js";
+//#region src/catalog/errors.d.ts
+type CatalogErrorCode = "lookup" | "invalid_input" | "integrity" | "unavailable_capability" | "incompatible_profile" | "embedding_failure" | "operation_failed" | "response_too_large";
+type CatalogErrorOptions = Readonly<{
+  code?: CatalogErrorCode;
+  details?: JsonObject;
+  hints?: readonly string[];
+}>;
+declare class CatalogError extends Error {
+  readonly code: CatalogErrorCode;
+  readonly details: Readonly<JsonObject>;
+  readonly hints: readonly string[];
+  constructor(message: string, options?: CatalogErrorOptions);
+}
+//#endregion
+//#region src/catalog/parquet.d.ts
+type AsyncBuffer = {
+  byteLength: number;
+  slice(start: number, end?: number): ArrayBuffer | Promise<ArrayBuffer>;
+};
+type ParquetBytes = ArrayBuffer | ArrayBufferView;
+type CatalogBytes = ParquetBytes | AsyncBuffer;
+type LoadCatalogDataInput = {
+  entries: CatalogBytes;
+  manifestText: string;
+};
+type LoadCatalogInput = {
+  entries: ParquetBytes;
+  manifest: ParquetBytes;
+  release: CatalogRelease;
+  releaseUrl: string | URL;
+};
+declare function loadCatalog(input: LoadCatalogInput): Promise<Catalog>;
+declare function loadCatalogData(input: LoadCatalogDataInput): Promise<Catalog>;
+//#endregion
+//#region src/catalog/markdown.d.ts
+declare function toMarkdown(guideline: Pick<Guideline, "id" | "title" | "description" | "labels" | "body">): string;
+//#endregion
+export { type ArtifactCache, type ArtifactOptions, Catalog, CatalogError, type CatalogErrorCode, type CatalogErrorOptions, type CatalogInfo, type CatalogManifest, type CatalogRelease, type CatalogTables, type CitationRecord, type CitationSource, type CiteOptions, type DescribeOptions, type DistanceMetric, type EmbeddingBinding, type EntryCandidate, type FetchLike, type FullSourceRecord, type Guideline, type GuidelineEntryRecord, type GuidelineInput, type GuidelineSection, type JsonObject, type JsonValue, type LoadCatalogDataInput, type LoadCatalogInput, type ManifestDefinition, type MinimalSourceRecord, type OpenCatalogOptions, type ProfileInfo, type ProfileMetadata, type ProjectionMetadata, type QueryOptions, type ReadOptions, type ReleaseArtifact, type SourceDetail, type TableColumnInfo, type TableInfo, type TableName, loadCatalog, loadCatalogData, openCatalog, parseCatalogManifest, parseCatalogRelease, parseProfileMetadata, toMarkdown };

package/dist/index.js

@@ -1,7 +1,22 @@
-export { Catalog, } from "./catalog/model.js";
-export { CatalogError } from "./catalog/errors.js";
-export { CHARTCOACH_DEFAULTS, DEFAULT_CATALOG, catalogArtifact, catalogArtifactUrl, parseCatalogReleaseMetadata, } from "./catalog/artifacts.js";
-export { loadCatalog, } from "./catalog/load-parquet-core.js";
-export { parseCatalogManifest, } from "./catalog/manifest.js";
-export { parseLabel } from "./catalog/labels.js";
-export { toMarkdown } from "./catalog/markdown.js";
+import { a as CatalogError } from "./json-CBWjz9b4.js";
+import { a as Catalog, i as loadCatalogData, l as parseCatalogManifest, n as parseProfileMetadata, r as loadCatalog, s as parseCatalogRelease, t as openCatalog } from "./open-Uu3-r8kp.js";
+import { stringify } from "yaml";
+//#region src/catalog/markdown.ts
+function toMarkdown(guideline) {
+	const frontmatter = {
+		id: guideline.id,
+		title: guideline.title,
+		description: guideline.description,
+		labels: [...guideline.labels]
+	};
+	return [
+		"---",
+		stringify(frontmatter, { sortMapEntries: false }).trim(),
+		"---",
+		"",
+		guideline.body.trim(),
+		""
+	].join("\n");
+}
+//#endregion
+export { Catalog, CatalogError, loadCatalog, loadCatalogData, openCatalog, parseCatalogManifest, parseCatalogRelease, parseProfileMetadata, toMarkdown };

package/dist/json-CBWjz9b4.js

@@ -0,0 +1,29 @@
+//#region src/catalog/errors.ts
+var CatalogError = class extends Error {
+	code;
+	details;
+	hints;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "CatalogError";
+		this.code = options.code ?? "invalid_input";
+		this.details = Object.freeze({ ...options.details });
+		this.hints = Object.freeze([...options.hints ?? []]);
+	}
+};
+//#endregion
+//#region src/catalog/json.ts
+function parseJson(text) {
+	return JSON.parse(text);
+}
+function isJsonObject(value) {
+	return value !== null && value !== void 0 && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+function isJsonNumber(value) {
+	return Object.prototype.toString.call(value) === "[object Number]" && value === value?.valueOf() && Number.isFinite(value);
+}
+function isJsonString(value) {
+	return Object.prototype.toString.call(value) === "[object String]" && value === value?.valueOf();
+}
+//#endregion
+export { CatalogError as a, parseJson as i, isJsonObject as n, isJsonString as r, isJsonNumber as t };

package/dist/model-De0MF-zg.d.ts

@@ -0,0 +1,255 @@
+//#region src/catalog/json.d.ts
+type JsonScalar = boolean | null | number | string;
+interface JsonObject {
+  [key: string]: JsonValue;
+}
+type JsonValue = JsonScalar | JsonObject | readonly JsonValue[];
+//#endregion
+//#region src/catalog/manifest.d.ts
+type ManifestDefinition = {
+  readonly name: string;
+  readonly description: string;
+  readonly examples: readonly string[];
+};
+type CatalogManifest = {
+  readonly markdown: string;
+  readonly sectionRoles: Readonly<Record<string, ManifestDefinition>>;
+  readonly labelFamilies: Readonly<Record<string, ManifestDefinition>>;
+};
+declare function parseCatalogManifest(markdown: string): CatalogManifest;
+//#endregion
+//#region src/catalog/profile.d.ts
+type DistanceMetric = "cosine" | "l2" | "dot";
+type EmbeddingBinding = Readonly<{
+  name: string;
+  model: Readonly<JsonObject>;
+  source_column: "text";
+  vector_column: "vector";
+}>;
+type ProjectionMetadata = Readonly<{
+  algorithm: "empty" | "linear" | "umap";
+  options: Readonly<JsonObject>;
+}>;
+type ProfileMetadata = Readonly<{
+  schema_version: 1;
+  documents_version: 1;
+  entries_digest: string;
+  manifest_digest: string;
+  embedding_functions: readonly [EmbeddingBinding];
+  dimensions: number;
+  distance_metric: DistanceMetric;
+  python_requirements: Readonly<Record<string, string>>;
+  lancedb_version: string;
+  projection: ProjectionMetadata | null;
+}>;
+declare function parseProfileMetadata(value: JsonValue): ProfileMetadata;
+//#endregion
+//#region src/catalog/artifacts.d.ts
+type ReleaseArtifact = Readonly<{
+  sha256: string;
+  bytes: number;
+}>;
+type CatalogRelease = Readonly<{
+  schema_version: 1;
+  digest: string;
+  artifacts: Readonly<Record<string, ReleaseArtifact>>;
+}>;
+declare function parseCatalogRelease(value: JsonValue): CatalogRelease;
+//#endregion
+//#region src/catalog/tables.d.ts
+type ReferenceRow = Readonly<{
+  id: string;
+  source_type: string | null;
+  authors: readonly string[];
+  authors_text: string | null;
+  year: string | null;
+  title: string | null;
+  journal: string | null;
+  booktitle: string | null;
+  publisher: string | null;
+  url: string | null;
+  doi: string | null;
+  bibtex: string;
+}>;
+type GuidelineReferenceRow = Readonly<{
+  guideline_id: string;
+  reference_id: string;
+}>;
+type CatalogTables = Readonly<{
+  guidelines: readonly Omit<Guideline, "references">[];
+  sections: readonly Readonly<GuidelineSection & {
+    guideline_id: string;
+  }>[];
+  guideline_labels: readonly Readonly<{
+    guideline_id: string;
+    label: string;
+    family: string;
+    category: string;
+    modifier: string | null;
+  }>[];
+  references: readonly ReferenceRow[];
+  guideline_references: readonly GuidelineReferenceRow[];
+  guideline_sources: readonly Readonly<Omit<ReferenceRow, "id" | "title"> & GuidelineReferenceRow & {
+    source_title: string | null;
+  }>[];
+}>;
+type TableName = keyof CatalogTables;
+type TableColumnInfo = Readonly<{
+  name: string;
+  type: "String" | "List(String)" | "List(Struct({'role': String, 'title': String, 'content': String}))";
+}>;
+type TableInfo = Readonly<{
+  name: TableName;
+  rows: number;
+  columns: readonly TableColumnInfo[];
+}>;
+//#endregion
+//#region src/catalog/description.d.ts
+type DescribeOptions = Readonly<{
+  profile?: string;
+  signal?: AbortSignal;
+}>;
+type ProfileInfo = Readonly<{
+  name: string;
+  profile_schema_version: 1;
+  documents_version: 1;
+  embedding_functions: ProfileMetadata["embedding_functions"];
+  dimensions: number;
+  distance_metric: ProfileMetadata["distance_metric"];
+  python_requirements: ProfileMetadata["python_requirements"];
+  lancedb_version: string;
+  projection: ProfileMetadata["projection"];
+}>;
+type CatalogInfo = Readonly<{
+  resolved_location: string | null;
+  release_digest: string | null;
+  entries_digest: string;
+  manifest_digest: string;
+  tables: readonly TableInfo[];
+  section_roles: readonly ManifestDefinition[];
+  label_families: readonly ManifestDefinition[];
+  profiles: readonly string[];
+  profile: ProfileInfo | null;
+}>;
+//#endregion
+//#region src/catalog/query.d.ts
+type QueryOptions = Readonly<{
+  ids?: readonly string[];
+  labels?: readonly string[];
+  labelPrefixes?: readonly string[];
+  contains?: string;
+  limit?: number;
+}>;
+type EntryCandidate = Readonly<{
+  id: string;
+  title: string;
+  description: string;
+  labels: readonly string[];
+}>;
+//#endregion
+//#region src/catalog/references.d.ts
+type MinimalSourceRecord = Readonly<{
+  reference_id: string;
+  authors_text: string | null;
+  year: string | null;
+  source_title: string | null;
+  doi: string | null;
+  url: string | null;
+}>;
+type FullSourceRecord = Readonly<{
+  guideline_id: string;
+  reference_id: string;
+  source_type: string | null;
+  authors: readonly string[];
+  authors_text: string | null;
+  year: string | null;
+  source_title: string | null;
+  journal: string | null;
+  booktitle: string | null;
+  publisher: string | null;
+  url: string | null;
+  doi: string | null;
+}>;
+type CitationSource = Readonly<{
+  reference_id: string;
+  source_type: string | null;
+  authors_text: string | null;
+  year: string | null;
+  source_title: string | null;
+  journal: string | null;
+  booktitle: string | null;
+  publisher: string | null;
+  doi: string | null;
+  url: string | null;
+  citation: string;
+}>;
+type CiteOptions = Readonly<{
+  ids: readonly string[];
+  urlTemplate?: string;
+}>;
+type CitationRecord = Readonly<{
+  id: string;
+  title: string;
+  url: string;
+  guideline_citation: string;
+  sources: readonly CitationSource[];
+}>;
+//#endregion
+//#region src/catalog/read.d.ts
+type SourceDetail = "none" | "minimal" | "full";
+type ReadOptions = Readonly<{
+  ids: readonly string[];
+  roles?: readonly string[];
+  sourceDetail?: SourceDetail;
+}>;
+type GuidelineEntryRecord = Readonly<{
+  id: string;
+  title: string;
+  description: string;
+  labels: readonly string[];
+  sections: readonly GuidelineSection[];
+  sources: readonly (MinimalSourceRecord | FullSourceRecord)[];
+  references?: readonly string[];
+}>;
+//#endregion
+//#region src/catalog/model.d.ts
+type GuidelineSection = Readonly<{
+  role: string;
+  title: string;
+  content: string;
+}>;
+type Guideline = Readonly<{
+  id: string;
+  title: string;
+  description: string;
+  labels: readonly string[];
+  body: string;
+  sections: readonly GuidelineSection[];
+  references: readonly string[];
+}>;
+type GuidelineInput = Omit<Guideline, "body">;
+type ArtifactOptions = Readonly<{
+  signal?: AbortSignal;
+}>;
+declare class Catalog implements Iterable<Guideline> {
+  readonly guidelines: readonly Guideline[];
+  readonly manifest: CatalogManifest;
+  private readonly byId;
+  constructor(guidelines: Iterable<GuidelineInput>, manifest: CatalogManifest);
+  get release(): CatalogRelease | undefined;
+  get releaseUrl(): string | undefined;
+  get length(): number;
+  artifact(path: string, options?: ArtifactOptions): Promise<Uint8Array>;
+  get(id: string): Guideline | undefined;
+  require(id: string): Guideline;
+  query(options?: QueryOptions): readonly EntryCandidate[];
+  read(options: ReadOptions): readonly GuidelineEntryRecord[];
+  cite(options: CiteOptions): readonly CitationRecord[];
+  table<Name extends TableName>(name: Name): CatalogTables[Name];
+  labels(): string[];
+  sectionRoles(): string[];
+  describe(options?: DescribeOptions): Promise<CatalogInfo>;
+  [Symbol.iterator](): IterableIterator<Guideline>;
+}
+//#endregion
+export { parseProfileMetadata as A, CatalogRelease as C, EmbeddingBinding as D, DistanceMetric as E, JsonValue as F, ManifestDefinition as M, parseCatalogManifest as N, ProfileMetadata as O, JsonObject as P, TableName as S, parseCatalogRelease as T, DescribeOptions as _, GuidelineSection as a, TableColumnInfo as b, SourceDetail as c, CiteOptions as d, FullSourceRecord as f, CatalogInfo as g, QueryOptions as h, GuidelineInput as i, CatalogManifest as j, ProjectionMetadata as k, CitationRecord as l, EntryCandidate as m, Catalog as n, GuidelineEntryRecord as o, MinimalSourceRecord as p, Guideline as r, ReadOptions as s, ArtifactOptions as t, CitationSource as u, ProfileInfo as v, ReleaseArtifact as w, TableInfo as x, CatalogTables as y };

package/dist/node.d.ts

@@ -0,0 +1,15 @@
+import { n as Catalog, t as ArtifactOptions } from "./model-De0MF-zg.js";
+import { r as OpenCatalogOptions } from "./open-Nnzkr_bE.js";
+//#region src/node.d.ts
+type NodeOpenCatalogOptions = OpenCatalogOptions & {
+  cacheDirectory?: string;
+};
+type IndexPathOptions = ArtifactOptions & {
+  directory?: string;
+};
+/** Return a verified profile's extracted database directory for native LanceDB clients. */
+declare function indexPath(catalog: Catalog, profile: string, options?: IndexPathOptions): Promise<string>;
+declare function openCatalog(location?: string | URL, options?: NodeOpenCatalogOptions): Promise<Catalog>;
+declare function artifactPath(catalog: Catalog, path: string, options?: ArtifactOptions): Promise<string>;
+//#endregion
+export { IndexPathOptions, NodeOpenCatalogOptions, artifactPath, indexPath, openCatalog };