@chartcoach/catalog 0.1.6 → 0.2.0

package/src/node.ts

@@ -0,0 +1,347 @@
+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";
+
+import { CatalogError } from "./catalog/errors";
+import { assertReleaseDigest, parseCatalogRelease, releaseArtifact } from "./catalog/artifacts";
+import { parseJson } from "./catalog/json";
+import { loadCatalogData } from "./catalog/parquet";
+import {
+  openCatalog as openRemoteCatalog,
+  type FetchLike,
+  type OpenCatalogOptions,
+} from "./catalog/open";
+import type { ArtifactOptions, Catalog } from "./catalog/model";
+
+type NodeContext = { cacheDirectory: string; fetch: FetchLike };
+
+const contexts = new WeakMap<Catalog, NodeContext>();
+
+export type NodeOpenCatalogOptions = OpenCatalogOptions & { cacheDirectory?: string };
+
+export type IndexPathOptions = ArtifactOptions & { directory?: string };
+
+/** Return a verified profile's extracted database directory for native LanceDB clients. */
+export async function indexPath(
+  catalog: Catalog,
+  profile: string,
+  options: IndexPathOptions = {},
+): Promise<string> {
+  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("./node/index-cache");
+
+  return extractIndex({
+    archive: () => artifactPath(catalog, path, options),
+    digest: artifact.sha256,
+    cacheDirectory: contexts.get(catalog)?.cacheDirectory ?? defaultCacheDirectory(),
+    directory: options.directory,
+    signal: options.signal,
+  });
+}
+
+export async function openCatalog(
+  location?: string | URL,
+  options: NodeOpenCatalogOptions = {},
+): Promise<Catalog> {
+  const cacheDirectory = options.cacheDirectory ?? defaultCacheDirectory();
+  const fetch = options.fetch ?? globalThis.fetch;
+  const uri = location === undefined ? undefined : 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: FetchLike = async (input, init) => {
+    const url = new URL(input);
+    init?.signal?.throwIfAborted();
+
+    if (url.protocol === "file:") {
+      // SAFETY: createReadStream emits Buffer chunks and toWeb preserves those byte chunks.
+      const body = Readable.toWeb(
+        createReadStream(fileURLToPath(url)),
+      ) as ReadableStream<Uint8Array>;
+
+      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 openRemoteCatalog(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;
+}
+
+export async function artifactPath(
+  catalog: Catalog,
+  path: string,
+  options: ArtifactOptions = {},
+): Promise<string> {
+  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(900_000);
+  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) {
+    void 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, new Uint8Array());
+
+    return target;
+  }
+
+  const temporary = `${target}.${randomUUID()}.tmp`;
+  const reader = response.body.getReader();
+
+  const abort = () => {
+    void 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);
+    void reader.cancel().catch(() => {});
+    reader.releaseLock();
+    await removeTemporary(temporary);
+  }
+}
+
+async function verifiedFile(
+  path: string,
+  digest: string,
+  bytes: number,
+  signal: AbortSignal,
+): Promise<boolean> {
+  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: string | URL): URL {
+  if (location instanceof URL) return location;
+
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(location)
+    ? new URL(location)
+    : pathToFileURL(resolve(location));
+}
+
+function defaultCacheDirectory(): string {
+  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: string): Promise<boolean> {
+  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: string, maximum: number, signal?: AbortSignal): Promise<Uint8Array> {
+  if ((await stat(path)).size > maximum) throw new CatalogError("Catalog file exceeds size limit.");
+  const chunks: Uint8Array[] = [];
+  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: string, maximum: number): Promise<Uint8Array | undefined> {
+  try {
+    return await readBytes(path, maximum);
+  } catch (error) {
+    if (
+      error instanceof CatalogError ||
+      (error instanceof Error && "code" in error && error.code === "ENOENT")
+    )
+      return undefined;
+    throw error;
+  }
+}
+
+async function atomicWrite(path: string, bytes: Uint8Array): Promise<void> {
+  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: string): Promise<void> {
+  try {
+    await unlink(path);
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+  }
+}

package/dist/catalog/artifacts.d.ts

@@ -1,28 +0,0 @@
-export { CHARTCOACH_DEFAULTS, type ChartCoachDefaults } from "./chartcoach-defaults.js";
-export declare const DEFAULT_CATALOG: {
-    readonly version: "0.1.6";
-    readonly digest: "7cfd43ee820be252b8ae9058c4c36109a9c8415c6b3a5ff8a9127117b4a10c19";
-    readonly releaseRootUrl: string;
-    readonly metadataUrl: string;
-    readonly entriesUrl: string;
-    readonly manifestUrl: string;
-};
-export type ArtifactKind = "manifest" | "entries" | "lancedb-index";
-export type ArtifactDescriptor = {
-    kind: ArtifactKind;
-    path: string;
-    digest: string;
-    bytes: number;
-    format?: string;
-    rows?: number;
-    [key: string]: unknown;
-};
-export type CatalogReleaseMetadata = {
-    version: string;
-    digest: string;
-    artifacts: ArtifactDescriptor[];
-};
-export declare function parseCatalogReleaseMetadata(value: unknown): CatalogReleaseMetadata;
-export declare function catalogArtifactUrl(baseUrl: string | URL, descriptor: ArtifactDescriptor): string;
-export declare function catalogArtifact(metadata: CatalogReleaseMetadata, kind: ArtifactKind): ArtifactDescriptor;
-//# sourceMappingURL=artifacts.d.ts.map

package/dist/catalog/artifacts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../src/catalog/artifacts.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAOrF,eAAO,MAAM,eAAe;;;;;;;CAOlB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,SAAS,GAAG,eAAe,CAAC;AAEpE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,kBAAkB,EAAE,CAAC;CACjC,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,sBAAsB,CAgBlF;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,EAAE,UAAU,EAAE,kBAAkB,GAAG,MAAM,CAEhG;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,sBAAsB,EAChC,IAAI,EAAE,YAAY,GACjB,kBAAkB,CAMpB"}

package/dist/catalog/artifacts.js

@@ -1,89 +0,0 @@
-import { CHARTCOACH_DEFAULTS } from "./chartcoach-defaults.js";
-import { CatalogError } from "./errors.js";
-export { CHARTCOACH_DEFAULTS } from "./chartcoach-defaults.js";
-const defaultCatalogReleaseRootUrl = new URL(`catalog/releases/${CHARTCOACH_DEFAULTS.catalogVersion}/${CHARTCOACH_DEFAULTS.catalogDigest}/`, `${CHARTCOACH_DEFAULTS.catalogArtifactBaseUrl}/`).toString();
-export const DEFAULT_CATALOG = {
-    version: CHARTCOACH_DEFAULTS.catalogVersion,
-    digest: CHARTCOACH_DEFAULTS.catalogDigest,
-    releaseRootUrl: defaultCatalogReleaseRootUrl,
-    metadataUrl: new URL("metadata.json", defaultCatalogReleaseRootUrl).toString(),
-    entriesUrl: new URL("entries.parquet", defaultCatalogReleaseRootUrl).toString(),
-    manifestUrl: new URL("MANIFEST.md", defaultCatalogReleaseRootUrl).toString(),
-};
-export function parseCatalogReleaseMetadata(value) {
-    if (!isRecord(value)) {
-        throw new CatalogError("Catalog release metadata must be an object.");
-    }
-    const artifacts = value.artifacts;
-    if (!Array.isArray(artifacts)) {
-        throw new CatalogError("Catalog release metadata artifacts must be a list.");
-    }
-    const metadata = {
-        version: requiredString(value, "version"),
-        digest: requiredString(value, "digest"),
-        artifacts: artifacts.map(parseArtifactDescriptor),
-    };
-    catalogArtifact(metadata, "manifest");
-    catalogArtifact(metadata, "entries");
-    return metadata;
-}
-export function catalogArtifactUrl(baseUrl, descriptor) {
-    return new URL(descriptor.path, baseUrl).toString();
-}
-export function catalogArtifact(metadata, kind) {
-    const descriptor = metadata.artifacts.find((item) => item.kind === kind);
-    if (!descriptor) {
-        throw new CatalogError(`Catalog release metadata is missing a ${kind} artifact.`);
-    }
-    return descriptor;
-}
-function parseArtifactDescriptor(value) {
-    if (!isRecord(value)) {
-        throw new CatalogError("Catalog artifact descriptor must be an object.");
-    }
-    const kind = value.kind;
-    if (kind !== "manifest" && kind !== "entries" && kind !== "lancedb-index") {
-        throw new CatalogError(`Unsupported catalog artifact kind: ${String(kind)}`);
-    }
-    const path = requiredString(value, "path");
-    validateRelativePath(path);
-    const descriptor = {
-        kind,
-        path,
-        digest: requiredString(value, "digest"),
-        bytes: requiredInteger(value, "bytes"),
-    };
-    if (typeof value.format === "string")
-        descriptor.format = value.format;
-    if (typeof value.rows === "number" && Number.isInteger(value.rows)) {
-        descriptor.rows = value.rows;
-    }
-    for (const [key, rawValue] of Object.entries(value)) {
-        if (!["kind", "path", "digest", "bytes", "format", "rows"].includes(key)) {
-            descriptor[key] = rawValue;
-        }
-    }
-    return descriptor;
-}
-function validateRelativePath(path) {
-    if (path.startsWith("/") || path.split("/").includes("..")) {
-        throw new CatalogError(`Catalog artifact path must be relative: ${path}`);
-    }
-}
-function requiredString(value, key) {
-    const raw = value[key];
-    if (typeof raw !== "string" || raw.length === 0) {
-        throw new CatalogError(`Catalog release metadata ${key} must be a string.`);
-    }
-    return raw;
-}
-function requiredInteger(value, key) {
-    const raw = value[key];
-    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) {
-        throw new CatalogError(`Catalog release metadata ${key} must be a non-negative integer.`);
-    }
-    return raw;
-}
-function isRecord(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}

package/dist/catalog/chartcoach-defaults.d.ts

@@ -1,17 +0,0 @@
-export type ChartCoachDefaults = {
-    catalogArtifactBaseUrl: string;
-    catalogDigest: string;
-    catalogVersion: string;
-    guidelineUrlTemplate: string;
-    indexTopK: number;
-    lanceDocumentTable: string;
-};
-export declare const CHARTCOACH_DEFAULTS: {
-    readonly catalogArtifactBaseUrl: "https://artifacts.chartcoach.dev";
-    readonly catalogDigest: "7cfd43ee820be252b8ae9058c4c36109a9c8415c6b3a5ff8a9127117b4a10c19";
-    readonly catalogVersion: "0.1.6";
-    readonly guidelineUrlTemplate: "https://chartcoach.dev/guidelines/{id}";
-    readonly indexTopK: 10;
-    readonly lanceDocumentTable: "catalog_documents";
-};
-//# sourceMappingURL=chartcoach-defaults.d.ts.map

package/dist/catalog/chartcoach-defaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chartcoach-defaults.d.ts","sourceRoot":"","sources":["../../src/catalog/chartcoach-defaults.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;CAOO,CAAC"}

package/dist/catalog/chartcoach-defaults.js

@@ -1,8 +0,0 @@
-export const CHARTCOACH_DEFAULTS = {
-    catalogArtifactBaseUrl: "https://artifacts.chartcoach.dev",
-    catalogDigest: "7cfd43ee820be252b8ae9058c4c36109a9c8415c6b3a5ff8a9127117b4a10c19",
-    catalogVersion: "0.1.6",
-    guidelineUrlTemplate: "https://chartcoach.dev/guidelines/{id}",
-    indexTopK: 10,
-    lanceDocumentTable: "catalog_documents",
-};

package/dist/catalog/errors.d.ts

@@ -1,4 +0,0 @@
-export declare class CatalogError extends Error {
-    constructor(message: string);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/catalog/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/catalog/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM;CAI5B"}

package/dist/catalog/errors.js

@@ -1,6 +0,0 @@
-export class CatalogError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "CatalogError";
-    }
-}

package/dist/catalog/labels.d.ts

@@ -1,9 +0,0 @@
-export type CatalogLabel = {
-    value: string;
-    family: string;
-    category: string;
-    modifier?: string;
-};
-export declare function parseLabel(value: unknown, context?: string): CatalogLabel;
-export declare function normalizeLabel(value: unknown, context?: string): string;
-//# sourceMappingURL=labels.d.ts.map

package/dist/catalog/labels.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../src/catalog/labels.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,SAAU,GAAG,YAAY,CAoB1E;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,SAAU,GAAG,MAAM,CAExE"}

package/dist/catalog/labels.js

@@ -1,23 +0,0 @@
-import { CatalogError } from "./errors.js";
-export function parseLabel(value, context = "label") {
-    if (typeof value !== "string") {
-        throw new CatalogError(`${context} must be a string.`);
-    }
-    const parts = value
-        .trim()
-        .split(":")
-        .map((part) => part.trim());
-    if ((parts.length !== 2 && parts.length !== 3) || parts.some((part) => part.length === 0)) {
-        throw new CatalogError(`${context} must use <family>:<category> or <family>:<category>:<modifier>.`);
-    }
-    const [family, category, modifier] = parts;
-    return {
-        value: modifier === undefined ? `${family}:${category}` : `${family}:${category}:${modifier}`,
-        family,
-        category,
-        modifier,
-    };
-}
-export function normalizeLabel(value, context = "label") {
-    return parseLabel(value, context).value;
-}

package/dist/catalog/load-parquet-core.d.ts

@@ -1,15 +0,0 @@
-import { Catalog } from "./model.js";
-import type { CatalogManifest } from "./manifest.js";
-export type AsyncBuffer = {
-    byteLength: number;
-    slice(start: number, end?: number): ArrayBuffer | Promise<ArrayBuffer>;
-};
-export type ParquetBytes = ArrayBuffer | ArrayBufferView;
-export type CatalogBytes = ParquetBytes | AsyncBuffer;
-export type LoadCatalogInput = CatalogBytes | {
-    entries: CatalogBytes;
-    manifest?: CatalogManifest;
-    manifestText?: string;
-};
-export declare function loadCatalog(input: LoadCatalogInput): Promise<Catalog>;
-//# sourceMappingURL=load-parquet-core.d.ts.map

package/dist/catalog/load-parquet-core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"load-parquet-core.d.ts","sourceRoot":"","sources":["../../src/catalog/load-parquet-core.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAkB,MAAM,SAAS,CAAC;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CACxE,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,eAAe,CAAC;AACzD,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,WAAW,CAAC;AACtD,MAAM,MAAM,gBAAgB,GACxB,YAAY,GACZ;IACE,OAAO,EAAE,YAAY,CAAC;IACtB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAWN,wBAAsB,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAiB3E"}

package/dist/catalog/load-parquet-core.js

@@ -1,45 +0,0 @@
-import { parquetReadObjects } from "hyparquet";
-import { compressors } from "hyparquet-compressors";
-import { Catalog } from "./model.js";
-import { CatalogError } from "./errors.js";
-import { parseCatalogManifest } from "./manifest.js";
-import { requireGuidelineFromWire } from "./wire.js";
-function normalizeParquetBytes(bytes) {
-    if (bytes instanceof ArrayBuffer)
-        return bytes;
-    // TypedArray/DataView may be a view into a larger ArrayBuffer (or SharedArrayBuffer).
-    // Copy to a standalone ArrayBuffer covering exactly the view range.
-    const u8 = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return u8.slice().buffer;
-}
-export async function loadCatalog(input) {
-    const { entries, manifest } = resolveLoadCatalogInput(input);
-    const normalizedFile = entries instanceof ArrayBuffer || ArrayBuffer.isView(entries)
-        ? normalizeParquetBytes(entries)
-        : entries;
-    const rows = (await parquetReadObjects({
-        file: normalizedFile,
-        compressors,
-    }));
-    const guidelines = rows.map((row, index) => requireGuidelineFromWire(row, `parquet row ${index}`));
-    return new Catalog(guidelines, { manifest });
-}
-function resolveLoadCatalogInput(input) {
-    if (isCatalogBytes(input))
-        return { entries: input };
-    if (input.manifest && input.manifestText !== undefined) {
-        throw new CatalogError("Pass manifest or manifestText, not both.");
-    }
-    return {
-        entries: input.entries,
-        manifest: input.manifestText === undefined ? input.manifest : parseCatalogManifest(input.manifestText),
-    };
-}
-function isCatalogBytes(value) {
-    return (value instanceof ArrayBuffer ||
-        ArrayBuffer.isView(value) ||
-        (typeof value === "object" &&
-            value !== null &&
-            typeof value.byteLength === "number" &&
-            typeof value.slice === "function"));
-}

package/dist/catalog/manifest.d.ts

@@ -1,15 +0,0 @@
-import type { Guideline } from "./model.js";
-export declare const REQUIRED_MANIFEST_HEADINGS: readonly ["Section Roles", "Label Families"];
-export type ManifestDefinition = {
-    name: string;
-    description: string;
-    examples: string[];
-};
-export type CatalogManifest = {
-    markdown: string;
-    sectionRoles: Record<string, ManifestDefinition>;
-    labelFamilies: Record<string, ManifestDefinition>;
-};
-export declare function parseCatalogManifest(markdown: string): CatalogManifest;
-export declare function validateManifestCoverage(guidelines: readonly Guideline[], manifest: CatalogManifest): void;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/catalog/manifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/catalog/manifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,eAAO,MAAM,0BAA0B,8CAA+C,CAAC;AAEvF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IACjD,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;CACnD,CAAC;AAKF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CA6FtE;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,SAAS,SAAS,EAAE,EAChC,QAAQ,EAAE,eAAe,QAmC1B"}