@chartcoach/catalog 0.1.7 → 0.2.0

package/dist/node.js

@@ -0,0 +1,218 @@
+import { a as CatalogError, i as parseJson } from "./json-CBWjz9b4.js";
+import { c as releaseArtifact, i as loadCatalogData, o as assertReleaseDigest, s as parseCatalogRelease, t as openCatalog$1 } from "./open-Uu3-r8kp.js";
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir, open, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { Readable } from "node:stream";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/node.ts
+const contexts = /* @__PURE__ */ new WeakMap();
+/** Return a verified profile's extracted database directory for native LanceDB clients. */
+async function indexPath(catalog, profile, options = {}) {
+	options.signal?.throwIfAborted();
+	if (!catalog.release) throw new CatalogError("Index access requires a catalog release.", { code: "unavailable_capability" });
+	await catalog.describe({
+		profile,
+		signal: options.signal
+	});
+	const path = `profiles/${profile}/index.tar.gz`;
+	const artifact = releaseArtifact(catalog.release, path);
+	const { extractIndex } = await import("./index-cache-Cx1gIK6N.js");
+	return extractIndex({
+		archive: () => artifactPath(catalog, path, options),
+		digest: artifact.sha256,
+		cacheDirectory: contexts.get(catalog)?.cacheDirectory ?? defaultCacheDirectory(),
+		directory: options.directory,
+		signal: options.signal
+	});
+}
+async function openCatalog(location, options = {}) {
+	const cacheDirectory = options.cacheDirectory ?? defaultCacheDirectory();
+	const fetch = options.fetch ?? globalThis.fetch;
+	const uri = location === void 0 ? void 0 : locationUrl(location);
+	if (uri?.protocol === "file:") {
+		const local = fileURLToPath(uri);
+		if ((await stat(local)).isDirectory()) {
+			const selection = await existingFile(join(local, "catalog.json"));
+			const release = await existingFile(join(local, "release.json"));
+			if (selection && release) throw new CatalogError("Catalog directory contains both descriptors.");
+			if (selection || release) return openCatalog(pathToFileURL(join(local, selection ? "catalog.json" : "release.json")), options);
+			const [entries, manifest] = await Promise.all([readBytes(join(local, "entries.parquet"), 64 * 1024 ** 2, options.signal), readBytes(join(local, "MANIFEST.md"), 64 * 1024 ** 2, options.signal)]);
+			return loadCatalogData({
+				entries,
+				manifestText: new TextDecoder("utf-8", { fatal: true }).decode(manifest)
+			});
+		}
+	}
+	const fetchResource = async (input, init) => {
+		const url = new URL(input);
+		init?.signal?.throwIfAborted();
+		if (url.protocol === "file:") {
+			const body = Readable.toWeb(createReadStream(fileURLToPath(url)));
+			return new Response(body);
+		}
+		const parent = url.pathname.split("/").at(-2) ?? "";
+		if (url.pathname.endsWith("/release.json") && /^[a-f0-9]{64}$/.test(parent)) {
+			const cached = await readCached(join(cacheDirectory, "descriptors", `${parent}.json`), 1024 ** 2);
+			if (cached) try {
+				const release = parseCatalogRelease(parseJson(new TextDecoder().decode(cached)));
+				await assertReleaseDigest(release, parent);
+				return new Response(Uint8Array.from(cached));
+			} catch (error) {
+				if (!(error instanceof CatalogError) && !(error instanceof SyntaxError)) throw error;
+			}
+		}
+		return fetch(input, init);
+	};
+	const catalog = await openCatalog$1(uri, {
+		signal: options.signal,
+		cache: options.cache ?? {
+			get: async (digest, bytes) => readCached(join(cacheDirectory, "artifacts", digest), bytes),
+			put: async (digest, bytes) => atomicWrite(join(cacheDirectory, "artifacts", digest), bytes)
+		},
+		fetch: fetchResource
+	});
+	if (catalog.release) await atomicWrite(join(cacheDirectory, "descriptors", `${catalog.release.digest}.json`), new TextEncoder().encode(JSON.stringify(catalog.release)));
+	contexts.set(catalog, {
+		cacheDirectory,
+		fetch: fetchResource
+	});
+	return catalog;
+}
+async function artifactPath(catalog, path, options = {}) {
+	if (!catalog.release) throw new CatalogError("Artifact access requires a catalog release.", { code: "unavailable_capability" });
+	const artifact = releaseArtifact(catalog.release, path);
+	if (artifact.bytes > 1024 ** 3) throw new CatalogError("Catalog artifact exceeds 1 GiB.");
+	const context = contexts.get(catalog);
+	const target = join(context?.cacheDirectory ?? defaultCacheDirectory(), "artifacts", artifact.sha256);
+	const timeout = AbortSignal.timeout(9e5);
+	const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+	signal.throwIfAborted();
+	if (await verifiedFile(target, artifact.sha256, artifact.bytes, signal)) return target;
+	if (!context || !catalog.releaseUrl) {
+		await atomicWrite(target, await catalog.artifact(path, { signal }));
+		signal.throwIfAborted();
+		return target;
+	}
+	const response = await context.fetch(new URL(path, catalog.releaseUrl), { signal });
+	if (!response.ok) {
+		response.body?.cancel().catch(() => {});
+		throw new CatalogError("Artifact could not be loaded.");
+	}
+	if (!response.body) {
+		if (artifact.bytes !== 0 || artifact.sha256 !== createHash("sha256").digest("hex")) throw new CatalogError("Artifact integrity check failed.", { code: "integrity" });
+		signal.throwIfAborted();
+		await atomicWrite(target, /* @__PURE__ */ new Uint8Array());
+		return target;
+	}
+	const temporary = `${target}.${randomUUID()}.tmp`;
+	const reader = response.body.getReader();
+	const abort = () => {
+		reader.cancel(signal.reason).catch(() => {});
+	};
+	signal.addEventListener("abort", abort, { once: true });
+	if (signal.aborted) abort();
+	try {
+		await mkdir(dirname(target), { recursive: true });
+		const file = await open(temporary, "wx");
+		const hash = createHash("sha256");
+		let size = 0;
+		try {
+			while (true) {
+				const chunk = await reader.read();
+				signal.throwIfAborted();
+				if (chunk.done) break;
+				size += chunk.value.byteLength;
+				if (size > artifact.bytes) throw new CatalogError("Artifact byte count mismatch.", { code: "integrity" });
+				hash.update(chunk.value);
+				await file.writeFile(chunk.value);
+			}
+		} finally {
+			await file.close();
+		}
+		if (size !== artifact.bytes || hash.digest("hex") !== artifact.sha256) throw new CatalogError("Artifact integrity check failed.", { code: "integrity" });
+		signal.throwIfAborted();
+		await rename(temporary, target);
+		return target;
+	} finally {
+		signal.removeEventListener("abort", abort);
+		reader.cancel().catch(() => {});
+		reader.releaseLock();
+		await removeTemporary(temporary);
+	}
+}
+async function verifiedFile(path, digest, bytes, signal) {
+	try {
+		if ((await stat(path)).size !== bytes) return false;
+		const hash = createHash("sha256");
+		let size = 0;
+		for await (const chunk of createReadStream(path, { signal })) {
+			size += chunk.length;
+			if (size > bytes) return false;
+			hash.update(chunk);
+		}
+		signal.throwIfAborted();
+		return size === bytes && hash.digest("hex") === digest;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function locationUrl(location) {
+	if (location instanceof URL) return location;
+	return /^[a-z][a-z0-9+.-]*:\/\//i.test(location) ? new URL(location) : pathToFileURL(resolve(location));
+}
+function defaultCacheDirectory() {
+	if (process.platform === "darwin") return join(homedir(), "Library", "Caches", "chartcoach");
+	if (process.platform === "win32") return join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "chartcoach", "Cache");
+	return join(process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "chartcoach");
+}
+async function existingFile(path) {
+	try {
+		return (await stat(path)).isFile();
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+async function readBytes(path, maximum, signal) {
+	if ((await stat(path)).size > maximum) throw new CatalogError("Catalog file exceeds size limit.");
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of createReadStream(path, { signal })) {
+		size += chunk.length;
+		if (size > maximum) throw new CatalogError("Catalog file exceeds size limit.");
+		chunks.push(chunk);
+	}
+	signal?.throwIfAborted();
+	return Buffer.concat(chunks);
+}
+async function readCached(path, maximum) {
+	try {
+		return await readBytes(path, maximum);
+	} catch (error) {
+		if (error instanceof CatalogError || error instanceof Error && "code" in error && error.code === "ENOENT") return void 0;
+		throw error;
+	}
+}
+async function atomicWrite(path, bytes) {
+	await mkdir(dirname(path), { recursive: true });
+	const temporary = `${path}.${randomUUID()}.tmp`;
+	try {
+		await writeFile(temporary, bytes, { flag: "wx" });
+		await rename(temporary, path);
+	} finally {
+		await removeTemporary(temporary);
+	}
+}
+async function removeTemporary(path) {
+	try {
+		await unlink(path);
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+	}
+}
+//#endregion
+export { artifactPath, indexPath, openCatalog };

package/dist/open-Nnzkr_bE.d.ts

@@ -0,0 +1,15 @@
+import { n as Catalog } from "./model-De0MF-zg.js";
+//#region src/catalog/open.d.ts
+type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+interface ArtifactCache {
+  get(sha256: string, bytes: number): Promise<Uint8Array | undefined>;
+  put(sha256: string, bytes: Uint8Array): Promise<void>;
+}
+type OpenCatalogOptions = {
+  fetch?: FetchLike;
+  signal?: AbortSignal;
+  cache?: ArtifactCache;
+};
+declare function openCatalog(location?: string | URL, options?: OpenCatalogOptions): Promise<Catalog>;
+//#endregion
+export { openCatalog as i, FetchLike as n, OpenCatalogOptions as r, ArtifactCache as t };