keepset 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,100 +1,9 @@
-import { z } from "zod";
-//#region src/targets/graph-v1.d.ts
-/** A JSON scalar: the only values graph/v1 metadata may hold, so `meta` stays a flat record any consumer can tabulate. `z.number()` already rejects NaN and the infinities, which JSON cannot carry. */
-export declare const JsonScalarSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
-type JsonScalar = z.infer<typeof JsonScalarSchema>;
-/** A node: an id, an optional type, and whatever else the dataset carries. The target fixes only what every graph consumer needs, so extra fields pass through untouched. */
-export declare const GraphNodeSchema: z.ZodObject<{
-  id: z.ZodString;
-  type: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-type GraphNode = z.infer<typeof GraphNodeSchema>;
-/** An edge: source and target node ids, an optional type, and whatever else the dataset carries. Direction is the dataset's own: graph/v1 records it in `meta`, never by duplicating edges. */
-export declare const GraphEdgeSchema: z.ZodObject<{
-  source: z.ZodString;
-  target: z.ZodString;
-  type: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-type GraphEdge = z.infer<typeof GraphEdgeSchema>;
-/**
- * The graph/v1 normalisation target: `{ meta, nodes, edges }`, the shape the thesis pipeline's benchmark cache already uses. It describes the result `fetchDataset` resolves a graph entry to, not what a source file may contain. Beyond the field shapes it checks the two properties every consumer relies on: node ids are unique, and every edge endpoint names a node.
- */
-export declare const GraphV1Schema: z.ZodObject<{
-  meta: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>, unknown>;
-  nodes: z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodOptional<z.ZodString>;
-  }, z.core.$loose>>;
-  edges: z.ZodArray<z.ZodObject<{
-    source: z.ZodString;
-    target: z.ZodString;
-    type: z.ZodOptional<z.ZodString>;
-  }, z.core.$loose>>;
-}, z.core.$strict> & {
-  is: (value: unknown) => value is {
-    meta: Record<string, string | number | boolean | null>;
-    nodes: {
-      [x: string]: unknown;
-      id: string;
-      type?: string | undefined;
-    }[];
-    edges: {
-      [x: string]: unknown;
-      source: string;
-      target: string;
-      type?: string | undefined;
-    }[];
-  };
-};
-type GraphV1 = z.infer<typeof GraphV1Schema>;
-//#endregion
-//#region src/categories.d.ts
-/** Every category id the registry knows. A category id is `<kind>/v<version>`: the kind of data, and the version of its normalisation target, so a breaking change to a target is a new category rather than an edit to an old one. */
-export declare const CategoryIdSchema: z.ZodEnum<{
-  "graph/v1": "graph/v1";
-}>;
-type CategoryId = z.infer<typeof CategoryIdSchema>;
-/** The normalisation target each category resolves to, keyed by category id. */
-interface CategoryTargets {
-  readonly "graph/v1": GraphV1;
-}
-/** The normalised shape of any category: what `fetchDataset` can resolve to. */
-type CategoryTarget = CategoryTargets[CategoryId];
-/** One category: its id, what it holds, and the schema of its normalisation target. */
-interface Category<Id extends CategoryId = CategoryId> {
-  readonly id: Id;
-  readonly description: string;
-  readonly target: z.ZodType<CategoryTargets[Id]>;
-}
-/**
- * Looks up a category by id.
- * @param id - Any string; category ids usually come from entry documents, so the argument is untrusted.
- * @returns The category.
- * @throws UnknownCategoryError when no category has that id.
- */
-export declare function getCategory<Id extends CategoryId>(id: Id): Category<Id>;
-export declare function getCategory(id: string): Category;
-/**
- * Returns the schema of a category's normalisation target.
- * @param id - Any string, as for `getCategory`.
- * @returns The target schema.
- * @throws UnknownCategoryError when no category has that id.
- */
-export declare function getTarget<Id extends CategoryId>(id: Id): z.ZodType<CategoryTargets[Id]>;
-export declare function getTarget(id: string): z.ZodType<CategoryTarget>;
-/**
- * The kind of data a category holds: the part of its id before the version.
- * @param id - A category id.
- * @returns The kind, such as `graph`.
- */
-export declare function kindOf(id: CategoryId): string;
-/** @returns Every registered category, in id order. */
-export declare function listCategories(): readonly Category[];
-//#endregion
+import { $ as SnapshotSchema, A as SemVerSchema, B as Entry, C as Dataset, D as LineageSchema, E as Lineage, F as ArchiveSchema, G as LicenceSchema, H as HttpUrlSchema, I as Citation, J as RESERVED_META_KEYS, K as Parser, L as CitationSchema, M as Archive, N as ArchiveMember, O as Manifest, P as ArchiveMemberSchema, Q as Snapshot, R as CrosswalkReference, S as CatalogueIndexSchema, T as createCatalogue, U as IdSchema, V as EntrySchema, W as Licence, X as RecipeSchema, Y as Recipe, Z as RelativePathSchema, _ as GraphV1Schema, a as CategoryTargets, b as Catalogue, c as getCategory, d as listCategories, et as Source, f as GraphEdge, g as GraphV1, h as GraphNodeSchema, i as CategoryTarget, it as waybackUrl, j as parseManifest, k as ManifestSchema, l as getTarget, m as GraphNode, n as CategoryId, nt as WaybackTimestampSchema, o as CountedKey, p as GraphEdgeSchema, q as ParserSchema, r as CategoryIdSchema, rt as parseEntry, s as countTarget, t as Category, tt as SourceSchema, u as kindOf, v as JsonScalar, w as DatasetQuery, x as CatalogueIndex, y as JsonScalarSchema, z as CrosswalkReferenceSchema } from "./categories-CUf1VecC.js";
+import { Crosswalk } from "twindex";
 //#region src/errors.d.ts
 /** The root of this package's error taxonomy: every error keepset throws is a `KeepsetError`, so callers can catch the family with one check. */
 export declare class KeepsetError extends Error {
-  constructor(message: string);
+  constructor(message: string, options?: ErrorOptions);
 }
 /** Thrown when a category id names no category in the registry. Carries the ids that do exist, so the message says what would have been accepted. */
 export declare class UnknownCategoryError extends KeepsetError {
@@ -107,483 +16,57 @@ interface SyntaxIssue {
   readonly path: string;
   readonly message: string;
 }
-/** Thrown when an entry or a catalogue manifest fails its schema. Carries every issue found, not just the first, so one failed parse reports the whole document. */
+/** Thrown when an entry, a catalogue manifest or a catalogue index fails its schema. Carries every issue found, not just the first, so one failed parse reports the whole document. */
 export declare class CatalogueSyntaxError extends KeepsetError {
-  readonly document: "entry" | "manifest";
+  readonly document: "entry" | "manifest" | "catalogue";
   readonly issues: readonly SyntaxIssue[];
-  constructor(document: "entry" | "manifest", issues: readonly SyntaxIssue[]);
+  constructor(document: "entry" | "manifest" | "catalogue", issues: readonly SyntaxIssue[]);
+}
+/** Thrown by a parser when a file does not have the format its recipe names. `line` is 1-based, counting every line of the file, so it points at the offending line in an editor. */
+export declare class NativeParseError extends KeepsetError {
+  readonly format: string;
+  readonly line: number;
+  constructor(format: string, line: number, message: string);
+}
+/** Thrown when an archive does not hold exactly one member the recipe's member selector matches, or is not a well-formed archive of its stated kind. */
+export declare class ArchiveError extends KeepsetError {}
+/** Thrown when no entry in the catalogue has the requested id. */
+export declare class DatasetNotFoundError extends KeepsetError {
+  readonly datasetId: string;
+  constructor(datasetId: string);
+}
+/** The step of a recipe that failed: the recipe itself (not fetchable), downloading the source, unpacking the archive, parsing the native shape, applying the crosswalk, or validating the result against the category target. */
+type RecipeStep = "recipe" | "download" | "extract" | "parse" | "crosswalk" | "validate";
+/** Thrown when running an entry's recipe fails. Names the entry and the failing step, and carries the underlying error as `cause`; a recipe never resolves to a partial or default-shaped result. */
+export declare class RecipeError extends KeepsetError {
+  readonly entryId: string;
+  readonly step: RecipeStep;
+  constructor(entryId: string, step: RecipeStep, message: string, options?: ErrorOptions);
 }
 //#endregion
-//#region src/entry.d.ts
-/** A stable identifier: an entry id, a catalogue id. It starts with a letter or digit, so no id can be `__proto__` or any other name that begins with an underscore. Entry ids stay the same across forks, which is what lets two catalogues be compared entry by entry. */
-export declare const IdSchema: z.ZodString;
-/** A Wayback Machine timestamp, `YYYYMMDD` or `YYYYMMDDhhmmss`: the moment the snapshot is pinned to. */
-export declare const WaybackTimestampSchema: z.ZodString;
-/**
- * The Wayback Machine URL of a snapshot of `url` at `timestamp`: the page form a person follows. The raw bytes a recipe downloads come from the `id_` form, which `fetchDataset` derives from this one.
- * @param timestamp - A Wayback timestamp.
- * @param url - The original URL.
- * @returns The snapshot URL.
- */
-export declare function waybackUrl(timestamp: string, url: string): string;
-/** A pinned Wayback Machine snapshot of a source. The timestamp is part of the recipe's reproducibility, not incidental metadata, so it travels with the URL and the two are checked against each other. */
-export declare const SnapshotSchema: z.ZodObject<{
-  url: z.ZodURL;
-  timestamp: z.ZodString;
-}, z.core.$strict>;
-type Snapshot = z.infer<typeof SnapshotSchema>;
-/**
- * Where a dataset's bytes come from. A `dead` source no longer serves the bytes the recipe was written against and must carry the snapshot the recipe fetches instead; a `live` source may also carry one, as the pinned record of what it served. The snapshot URL must be exactly `waybackUrl(timestamp, url)`.
- */
-export declare const SourceSchema: z.ZodObject<{
-  url: z.ZodURL;
-  retrieved: z.ZodISODate;
-  status: z.ZodEnum<{
-    live: "live";
-    dead: "dead";
-  }>;
-  snapshot: z.ZodOptional<z.ZodObject<{
-    url: z.ZodURL;
-    timestamp: z.ZodString;
-  }, z.core.$strict>>;
-}, z.core.$strict>;
-type Source = z.infer<typeof SourceSchema>;
-/** The licence a dataset is published under: an SPDX identifier, a named licence with the URL of its terms, or a statement that the source records none. A licence the source does not state is recorded as unrecorded rather than guessed. */
-export declare const LicenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  kind: z.ZodLiteral<"spdx">;
-  id: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-  kind: z.ZodLiteral<"custom">;
-  name: z.ZodString;
-  url: z.ZodURL;
-}, z.core.$strict>, z.ZodObject<{
-  kind: z.ZodLiteral<"unrecorded">;
-}, z.core.$strict>], "kind">;
-type Licence = z.infer<typeof LicenceSchema>;
-/** A work to cite for the dataset: a formatted reference, with its DOI or URL where the source records one. */
-export declare const CitationSchema: z.ZodObject<{
-  text: z.ZodString;
-  doi: z.ZodOptional<z.ZodString>;
-  url: z.ZodOptional<z.ZodURL>;
-}, z.core.$strict>;
-type Citation = z.infer<typeof CitationSchema>;
-/** A relative path inside an archive or a catalogue: `/`-separated segments, none empty, `.` or `..`, so it can never climb out of the directory it is resolved against. */
-export declare const RelativePathSchema: z.ZodString;
-/** Which file of an archive to read: a member path, matched against a member's whole path or its trailing segments (so `net.gml` finds `net/net.gml`), or the member whose name ends with an extension. Either must match exactly one member when the recipe runs; macOS resource-fork members (`__MACOSX/` and `._` files) never match. */
-export declare const ArchiveMemberSchema: z.ZodUnion<readonly [z.ZodObject<{
-  path: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-  extension: z.ZodString;
-}, z.core.$strict>]>;
-type ArchiveMember = z.infer<typeof ArchiveMemberSchema>;
-/** How the downloaded bytes unpack into the one file the parser reads. */
-export declare const ArchiveSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  kind: z.ZodLiteral<"none">;
-}, z.core.$strict>, z.ZodObject<{
-  kind: z.ZodLiteral<"gzip">;
-}, z.core.$strict>, z.ZodObject<{
-  kind: z.ZodLiteral<"zip">;
-  member: z.ZodUnion<readonly [z.ZodObject<{
-    path: z.ZodString;
-  }, z.core.$strict>, z.ZodObject<{
-    extension: z.ZodString;
-  }, z.core.$strict>]>;
-}, z.core.$strict>, z.ZodObject<{
-  kind: z.ZodLiteral<"tar">;
-  member: z.ZodUnion<readonly [z.ZodObject<{
-    path: z.ZodString;
-  }, z.core.$strict>, z.ZodObject<{
-    extension: z.ZodString;
-  }, z.core.$strict>]>;
-}, z.core.$strict>, z.ZodObject<{
-  kind: z.ZodLiteral<"tar.gz">;
-  member: z.ZodUnion<readonly [z.ZodObject<{
-    path: z.ZodString;
-  }, z.core.$strict>, z.ZodObject<{
-    extension: z.ZodString;
-  }, z.core.$strict>]>;
-}, z.core.$strict>], "kind">;
-type Archive = z.infer<typeof ArchiveSchema>;
-/** The parser that reads the unpacked file into the dataset's native JSON shape, with the options that format needs. Every option is stated in the entry, so a recipe reads the same way wherever it runs. */
-export declare const ParserSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  format: z.ZodLiteral<"edge-list">;
-  encoding: z.ZodEnum<{
-    "utf-8": "utf-8";
-    latin1: "latin1";
-  }>;
-  delimiter: z.ZodEnum<{
-    whitespace: "whitespace";
-    tab: "tab";
-    comma: "comma";
-    space: "space";
-  }>;
-  skipLines: z.ZodInt;
-  commentPrefixes: z.ZodArray<z.ZodString>;
-  sourceColumn: z.ZodInt;
-  targetColumn: z.ZodInt;
-}, z.core.$strict>, z.ZodObject<{
-  format: z.ZodLiteral<"matrix-market">;
-  encoding: z.ZodEnum<{
-    "utf-8": "utf-8";
-    latin1: "latin1";
-  }>;
-}, z.core.$strict>, z.ZodObject<{
-  format: z.ZodLiteral<"gml">;
-  encoding: z.ZodEnum<{
-    "utf-8": "utf-8";
-    latin1: "latin1";
-  }>;
-}, z.core.$strict>, z.ZodObject<{
-  format: z.ZodLiteral<"pajek">;
-  encoding: z.ZodEnum<{
-    "utf-8": "utf-8";
-    latin1: "latin1";
-  }>;
-}, z.core.$strict>], "format">;
-type Parser = z.infer<typeof ParserSchema>;
-/** How to obtain the dataset: a fetchable recipe naming the source (by index into `sources`), the archive layout and the parser, or a statement that no declarative recipe exists yet and why. */
-export declare const RecipeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  status: z.ZodLiteral<"fetchable">;
-  source: z.ZodInt;
-  archive: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"none">;
-  }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"gzip">;
-  }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"zip">;
-    member: z.ZodUnion<readonly [z.ZodObject<{
-      path: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-      extension: z.ZodString;
-    }, z.core.$strict>]>;
-  }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"tar">;
-    member: z.ZodUnion<readonly [z.ZodObject<{
-      path: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-      extension: z.ZodString;
-    }, z.core.$strict>]>;
-  }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"tar.gz">;
-    member: z.ZodUnion<readonly [z.ZodObject<{
-      path: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-      extension: z.ZodString;
-    }, z.core.$strict>]>;
-  }, z.core.$strict>], "kind">;
-  parser: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    format: z.ZodLiteral<"edge-list">;
-    encoding: z.ZodEnum<{
-      "utf-8": "utf-8";
-      latin1: "latin1";
-    }>;
-    delimiter: z.ZodEnum<{
-      whitespace: "whitespace";
-      tab: "tab";
-      comma: "comma";
-      space: "space";
-    }>;
-    skipLines: z.ZodInt;
-    commentPrefixes: z.ZodArray<z.ZodString>;
-    sourceColumn: z.ZodInt;
-    targetColumn: z.ZodInt;
-  }, z.core.$strict>, z.ZodObject<{
-    format: z.ZodLiteral<"matrix-market">;
-    encoding: z.ZodEnum<{
-      "utf-8": "utf-8";
-      latin1: "latin1";
-    }>;
-  }, z.core.$strict>, z.ZodObject<{
-    format: z.ZodLiteral<"gml">;
-    encoding: z.ZodEnum<{
-      "utf-8": "utf-8";
-      latin1: "latin1";
-    }>;
-  }, z.core.$strict>, z.ZodObject<{
-    format: z.ZodLiteral<"pajek">;
-    encoding: z.ZodEnum<{
-      "utf-8": "utf-8";
-      latin1: "latin1";
-    }>;
-  }, z.core.$strict>], "format">;
-}, z.core.$strict>, z.ZodObject<{
-  status: z.ZodLiteral<"not-fetchable">;
-  reason: z.ZodString;
-}, z.core.$strict>], "status">;
-type Recipe = z.infer<typeof RecipeSchema>;
-/** The twindex crosswalk from the native shape to the category target: the document inline, or a `.json` file path relative to the catalogue root, so entries that share a native shape share one crosswalk. */
-export declare const CrosswalkReferenceSchema: z.ZodUnion<readonly [z.ZodType<import("twindex").Crosswalk, unknown, z.core.$ZodTypeInternals<import("twindex").Crosswalk, unknown>> & {
-  is: (value: unknown) => value is import("twindex").Crosswalk;
-}, z.ZodObject<{
-  file: z.ZodString;
-}, z.core.$strict>]>;
-type CrosswalkReference = z.infer<typeof CrosswalkReferenceSchema>;
-/**
- * One catalogue entry: the descriptor (id, name, description, domain, tags), the category whose target the entry resolves to, where the bytes come from, the licence and citations, the recipe, the crosswalk, the counts a fetched result is expected to have and the dataset's recorded properties. The kind of data is the category's (`kindOf(category)`), never a second field that could disagree with it.
- */
-export declare const EntrySchema: z.ZodObject<{
-  id: z.ZodString;
-  name: z.ZodString;
-  description: z.ZodOptional<z.ZodString>;
-  domain: z.ZodOptional<z.ZodString>;
-  tags: z.ZodArray<z.ZodString>;
-  category: z.ZodEnum<{
-    "graph/v1": "graph/v1";
-  }>;
-  sources: z.ZodArray<z.ZodObject<{
-    url: z.ZodURL;
-    retrieved: z.ZodISODate;
-    status: z.ZodEnum<{
-      live: "live";
-      dead: "dead";
-    }>;
-    snapshot: z.ZodOptional<z.ZodObject<{
-      url: z.ZodURL;
-      timestamp: z.ZodString;
-    }, z.core.$strict>>;
-  }, z.core.$strict>>;
-  licence: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"spdx">;
-    id: z.ZodString;
-  }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"custom">;
-    name: z.ZodString;
-    url: z.ZodURL;
-  }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"unrecorded">;
-  }, z.core.$strict>], "kind">;
-  citations: z.ZodArray<z.ZodObject<{
-    text: z.ZodString;
-    doi: z.ZodOptional<z.ZodString>;
-    url: z.ZodOptional<z.ZodURL>;
-  }, z.core.$strict>>;
-  recipe: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    status: z.ZodLiteral<"fetchable">;
-    source: z.ZodInt;
-    archive: z.ZodDiscriminatedUnion<[z.ZodObject<{
-      kind: z.ZodLiteral<"none">;
-    }, z.core.$strict>, z.ZodObject<{
-      kind: z.ZodLiteral<"gzip">;
-    }, z.core.$strict>, z.ZodObject<{
-      kind: z.ZodLiteral<"zip">;
-      member: z.ZodUnion<readonly [z.ZodObject<{
-        path: z.ZodString;
-      }, z.core.$strict>, z.ZodObject<{
-        extension: z.ZodString;
-      }, z.core.$strict>]>;
-    }, z.core.$strict>, z.ZodObject<{
-      kind: z.ZodLiteral<"tar">;
-      member: z.ZodUnion<readonly [z.ZodObject<{
-        path: z.ZodString;
-      }, z.core.$strict>, z.ZodObject<{
-        extension: z.ZodString;
-      }, z.core.$strict>]>;
-    }, z.core.$strict>, z.ZodObject<{
-      kind: z.ZodLiteral<"tar.gz">;
-      member: z.ZodUnion<readonly [z.ZodObject<{
-        path: z.ZodString;
-      }, z.core.$strict>, z.ZodObject<{
-        extension: z.ZodString;
-      }, z.core.$strict>]>;
-    }, z.core.$strict>], "kind">;
-    parser: z.ZodDiscriminatedUnion<[z.ZodObject<{
-      format: z.ZodLiteral<"edge-list">;
-      encoding: z.ZodEnum<{
-        "utf-8": "utf-8";
-        latin1: "latin1";
-      }>;
-      delimiter: z.ZodEnum<{
-        whitespace: "whitespace";
-        tab: "tab";
-        comma: "comma";
-        space: "space";
-      }>;
-      skipLines: z.ZodInt;
-      commentPrefixes: z.ZodArray<z.ZodString>;
-      sourceColumn: z.ZodInt;
-      targetColumn: z.ZodInt;
-    }, z.core.$strict>, z.ZodObject<{
-      format: z.ZodLiteral<"matrix-market">;
-      encoding: z.ZodEnum<{
-        "utf-8": "utf-8";
-        latin1: "latin1";
-      }>;
-    }, z.core.$strict>, z.ZodObject<{
-      format: z.ZodLiteral<"gml">;
-      encoding: z.ZodEnum<{
-        "utf-8": "utf-8";
-        latin1: "latin1";
-      }>;
-    }, z.core.$strict>, z.ZodObject<{
-      format: z.ZodLiteral<"pajek">;
-      encoding: z.ZodEnum<{
-        "utf-8": "utf-8";
-        latin1: "latin1";
-      }>;
-    }, z.core.$strict>], "format">;
-  }, z.core.$strict>, z.ZodObject<{
-    status: z.ZodLiteral<"not-fetchable">;
-    reason: z.ZodString;
-  }, z.core.$strict>], "status">;
-  crosswalk: z.ZodUnion<readonly [z.ZodType<import("twindex").Crosswalk, unknown, z.core.$ZodTypeInternals<import("twindex").Crosswalk, unknown>> & {
-    is: (value: unknown) => value is import("twindex").Crosswalk;
-  }, z.ZodObject<{
-    file: z.ZodString;
-  }, z.core.$strict>]>;
-  expectedCounts: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodInt>, unknown>;
-  properties: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>, unknown>;
-}, z.core.$strict> & {
-  is: (value: unknown) => value is {
-    id: string;
-    name: string;
-    tags: string[];
-    category: "graph/v1";
-    sources: {
-      url: string;
-      retrieved: string;
-      status: "live" | "dead";
-      snapshot?: {
-        url: string;
-        timestamp: string;
-      } | undefined;
-    }[];
-    licence: {
-      kind: "spdx";
-      id: string;
-    } | {
-      kind: "custom";
-      name: string;
-      url: string;
-    } | {
-      kind: "unrecorded";
-    };
-    citations: {
-      text: string;
-      doi?: string | undefined;
-      url?: string | undefined;
-    }[];
-    recipe: {
-      status: "fetchable";
-      source: number;
-      archive: {
-        kind: "none";
-      } | {
-        kind: "gzip";
-      } | {
-        kind: "zip";
-        member: {
-          path: string;
-        } | {
-          extension: string;
-        };
-      } | {
-        kind: "tar";
-        member: {
-          path: string;
-        } | {
-          extension: string;
-        };
-      } | {
-        kind: "tar.gz";
-        member: {
-          path: string;
-        } | {
-          extension: string;
-        };
-      };
-      parser: {
-        format: "edge-list";
-        encoding: "utf-8" | "latin1";
-        delimiter: "whitespace" | "tab" | "comma" | "space";
-        skipLines: number;
-        commentPrefixes: string[];
-        sourceColumn: number;
-        targetColumn: number;
-      } | {
-        format: "matrix-market";
-        encoding: "utf-8" | "latin1";
-      } | {
-        format: "gml";
-        encoding: "utf-8" | "latin1";
-      } | {
-        format: "pajek";
-        encoding: "utf-8" | "latin1";
-      };
-    } | {
-      status: "not-fetchable";
-      reason: string;
-    };
-    crosswalk: import("twindex").Crosswalk | {
-      file: string;
-    };
-    expectedCounts: Record<string, number>;
-    properties: Record<string, string | number | boolean | null>;
-    description?: string | undefined;
-    domain?: string | undefined;
-  };
-};
-type Entry = z.infer<typeof EntrySchema>;
-/**
- * Parses an unknown value as a catalogue entry.
- * @param doc - The candidate entry document.
- * @returns The validated entry.
- * @throws CatalogueSyntaxError carrying every issue found.
- */
-export declare function parseEntry(doc: unknown): Entry;
-//#endregion
-//#region src/manifest.d.ts
-/** A semantic version, `MAJOR.MINOR.PATCH` with optional pre-release and build parts (https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string). */
-export declare const SemVerSchema: z.ZodString;
-/** Where a forked catalogue came from: the catalogue it was forked from, the version it forked at and the repository that holds it, which together are what lets a fork's entries be compared with, and brought back to, their origin. */
-export declare const LineageSchema: z.ZodObject<{
-  catalogue: z.ZodString;
-  version: z.ZodString;
-  repository: z.ZodURL;
-}, z.core.$strict>;
-type Lineage = z.infer<typeof LineageSchema>;
+//#region src/bundled.d.ts
 /**
- * A catalogue manifest: the catalogue's own id and version, where it lives, and, for a fork, its lineage. A catalogue is a self-contained set of entry documents beside its manifest, and a fork is its own catalogue with its own id, so lineage may never name the catalogue itself.
+ * Lists the datasets in the bundled catalogue that match a query. Browser-safe: a pure read over the index bundled with the package.
+ * @param query - The filters; all must match, and none given lists everything.
+ * @returns The matching datasets, in entry id order.
  */
-export declare const ManifestSchema: z.ZodObject<{
-  id: z.ZodString;
-  name: z.ZodString;
-  description: z.ZodString;
-  version: z.ZodString;
-  repository: z.ZodURL;
-  lineage: z.ZodOptional<z.ZodObject<{
-    catalogue: z.ZodString;
-    version: z.ZodString;
-    repository: z.ZodURL;
-  }, z.core.$strict>>;
-}, z.core.$strict> & {
-  is: (value: unknown) => value is {
-    id: string;
-    name: string;
-    description: string;
-    version: string;
-    repository: string;
-    lineage?: {
-      catalogue: string;
-      version: string;
-      repository: string;
-    } | undefined;
-  };
-};
-type Manifest = z.infer<typeof ManifestSchema>;
+export declare function listDatasets(query?: DatasetQuery): Dataset[];
 /**
- * Parses an unknown value as a catalogue manifest.
- * @param doc - The candidate manifest document.
- * @returns The validated manifest.
- * @throws CatalogueSyntaxError carrying every issue found.
+ * Returns one dataset of the bundled catalogue: its entry (metadata and recipe) and its resolved crosswalk. Browser-safe.
+ * @param id - The entry id.
+ * @returns The dataset.
+ * @throws DatasetNotFoundError when no entry has that id.
  */
-export declare function parseManifest(doc: unknown): Manifest;
+export declare function getDataset(id: string): Dataset;
+/** @returns The bundled catalogue's manifest: its id, version and repository. */
+export declare function getManifest(): Manifest;
 //#endregion
 //#region src/serialise.d.ts
 /**
- * Serialises a catalogue document as its file holds it: two-space indented JSON in the schema's key order with a trailing newline. A parsed document keeps the schema's key order, so parsing a file written this way and serialising the result reproduces the file byte for byte.
- * @param doc - A parsed entry or manifest.
+ * Serialises a catalogue document (an entry, a manifest or a crosswalk file) as its file holds it: two-space indented JSON with keys in ascending order and a trailing newline. The form depends only on the document's content, so parsing a file written this way and serialising the result reproduces the file byte for byte.
+ * @param doc - A parsed entry, manifest or crosswalk.
  * @returns The file text.
  */
-export declare function serialise(doc: Entry | Manifest): string;
+export declare function serialise(doc: Entry | Manifest | Crosswalk): string;
 //#endregion
-export type { Archive, ArchiveMember, Category, CategoryId, CategoryTarget, CategoryTargets, Citation, CrosswalkReference, Entry, GraphEdge, GraphNode, GraphV1, JsonScalar, Licence, Lineage, Manifest, Parser, Recipe, Snapshot, Source, SyntaxIssue };
+export { type Archive, type ArchiveMember, ArchiveMemberSchema, ArchiveSchema, type Catalogue, type CatalogueIndex, CatalogueIndexSchema, type Category, type CategoryId, CategoryIdSchema, type CategoryTarget, type CategoryTargets, type Citation, CitationSchema, type CountedKey, type CrosswalkReference, CrosswalkReferenceSchema, type Dataset, type DatasetQuery, type Entry, EntrySchema, type GraphEdge, GraphEdgeSchema, type GraphNode, GraphNodeSchema, type GraphV1, GraphV1Schema, HttpUrlSchema, IdSchema, type JsonScalar, JsonScalarSchema, type Licence, LicenceSchema, type Lineage, LineageSchema, type Manifest, ManifestSchema, type Parser, ParserSchema, RESERVED_META_KEYS, type Recipe, RecipeSchema, type RecipeStep, RelativePathSchema, SemVerSchema, type Snapshot, SnapshotSchema, type Source, SourceSchema, type SyntaxIssue, WaybackTimestampSchema, countTarget, createCatalogue, getCategory, getTarget, kindOf, listCategories, parseEntry, parseManifest, waybackUrl };