keepset 0.2.0 → 0.3.0

package/dist/categories-BIZJUKUw.d.ts

@@ -0,0 +1,960 @@
+import { Crosswalk } from "twindex";
+import { z } from "zod";
+//#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. */
+declare const IdSchema: z.ZodString;
+/** An http or https URL: the only schemes a recipe may download from. Any host is allowed, an address or a single-label name included, so a fork can point a recipe at a server on its own network. */
+declare const HttpUrlSchema: z.ZodURL;
+/** A Wayback Machine timestamp, `YYYYMMDD` or `YYYYMMDDhhmmss`: the moment the snapshot is pinned to. */
+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.
+ */
+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. */
+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)`.
+ */
+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. */
+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. */
+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. */
+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. */
+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. */
+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. */
+declare const ParserSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  format: z.ZodLiteral<"edge-list">;
+  encoding: z.ZodEnum<{
+    "utf-8": "utf-8";
+    latin1: "latin1";
+  }>;
+  delimiter: z.ZodEnum<{
+    detect: "detect";
+    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. */
+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<{
+      detect: "detect";
+      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. */
+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>;
+/** The meta keys a fetched result takes from the entry's own descriptor, which its `properties` therefore may not also set. */
+declare const RESERVED_META_KEYS: readonly ["id", "name"];
+/**
+ * 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.
+ */
+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<{
+        detect: "detect";
+        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: "detect" | "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.
+ */
+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). */
+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. */
+declare const LineageSchema: z.ZodObject<{
+  catalogue: z.ZodString;
+  version: z.ZodString;
+  repository: z.ZodURL;
+}, z.core.$strict>;
+type Lineage = z.infer<typeof LineageSchema>;
+/**
+ * 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.
+ */
+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>;
+/**
+ * Parses an unknown value as a catalogue manifest.
+ * @param doc - The candidate manifest document.
+ * @returns The validated manifest.
+ * @throws CatalogueSyntaxError carrying every issue found.
+ */
+declare function parseManifest(doc: unknown): Manifest;
+//#endregion
+//#region src/catalogue.d.ts
+/**
+ * A catalogue index: the manifest, every entry, and every crosswalk file of the catalogue, keyed by its catalogue-relative path. The build assembles it from a catalogue directory; a consumer holding its own catalogue (a fork, say) can pass one to `createCatalogue`. Entry ids are unique, every crosswalk passes twindex's structural validation, every crosswalk file reference resolves, and every crosswalk's target is the category of each entry that uses it.
+ */
+declare const CatalogueIndexSchema: z.ZodObject<{
+  manifest: 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;
+    };
+  };
+  crosswalks: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodType<Crosswalk, unknown, z.core.$ZodTypeInternals<Crosswalk, unknown>> & {
+    is: (value: unknown) => value is Crosswalk;
+  }>, unknown>;
+  entries: z.ZodArray<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<{
+          detect: "detect";
+          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<Crosswalk, unknown, z.core.$ZodTypeInternals<Crosswalk, unknown>> & {
+      is: (value: unknown) => value is 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: "detect" | "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: Crosswalk | {
+        file: string;
+      };
+      expectedCounts: Record<string, number>;
+      properties: Record<string, string | number | boolean | null>;
+      description?: string | undefined;
+      domain?: string | undefined;
+    };
+  }>;
+}, z.core.$strict> & {
+  is: (value: unknown) => value is {
+    manifest: {
+      id: string;
+      name: string;
+      description: string;
+      version: string;
+      repository: string;
+      lineage?: {
+        catalogue: string;
+        version: string;
+        repository: string;
+      } | undefined;
+    };
+    crosswalks: Record<string, Crosswalk>;
+    entries: {
+      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: "detect" | "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: Crosswalk | {
+        file: string;
+      };
+      expectedCounts: Record<string, number>;
+      properties: Record<string, string | number | boolean | null>;
+      description?: string | undefined;
+      domain?: string | undefined;
+    }[];
+  };
+};
+type CatalogueIndex = z.infer<typeof CatalogueIndexSchema>;
+/** One dataset as the library returns it: the entry (descriptor, sources, licence, citations and recipe), the kind of data its category holds, its crosswalk resolved from a file reference where it has one, and the catalogue it came from. */
+interface Dataset {
+  readonly entry: Entry;
+  readonly kind: string;
+  readonly crosswalk: Crosswalk;
+  readonly catalogue: Pick<Manifest, "id" | "version">;
+}
+/** Filters for `listDatasets`. Every filter given must match; none given lists everything. */
+interface DatasetQuery {
+  /** The kind of data, such as `graph`: the part of the category id before the version. */
+  readonly kind?: string;
+  /** A category id, such as `graph/v1`. */
+  readonly category?: string;
+  /** The entry's domain, matched exactly. */
+  readonly domain?: string;
+  /** Text that must appear, ignoring case, in the entry's id, name, description, domain or one of its tags. */
+  readonly text?: string;
+}
+/** A queryable catalogue: the surface `listDatasets` and `getDataset` are bound to. */
+interface Catalogue {
+  readonly manifest: Manifest;
+  /**
+   * Lists the datasets matching a query, in entry id order.
+   * @param query - The filters; all must match.
+   * @returns The matching datasets.
+   */
+  readonly listDatasets: (query?: DatasetQuery) => Dataset[];
+  /**
+   * Returns one dataset by entry id.
+   * @param id - The entry id; untrusted, so lookup never reaches inherited properties.
+   * @returns The dataset.
+   * @throws DatasetNotFoundError when no entry has that id.
+   */
+  readonly getDataset: (id: string) => Dataset;
+}
+/**
+ * Builds a queryable catalogue from an index. Pure and synchronous: no filesystem, no network, so it runs the same in a browser as in Node.
+ * @param index - A candidate catalogue index.
+ * @returns The catalogue.
+ * @throws CatalogueSyntaxError carrying every issue when the index is not a valid catalogue.
+ */
+declare function createCatalogue(index: unknown): Catalogue;
+//#endregion
+//#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. */
+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. */
+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. */
+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.
+ */
+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. */
+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];
+/** The keys of a target whose values are arrays: the collections an entry's `expectedCounts` may name. */
+type CountedKey<Target> = { readonly [Key in keyof Target]: Target[Key] extends readonly unknown[] ? Key : never; }[keyof Target] & string;
+/** One category: its id, what it holds, the schema of its normalisation target, and which of the target's arrays an entry may record expected counts for. */
+interface Category<Id extends CategoryId = CategoryId> {
+  readonly id: Id;
+  readonly description: string;
+  readonly target: z.ZodType<CategoryTargets[Id]>;
+  readonly counted: readonly CountedKey<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.
+ */
+declare function getCategory<Id extends CategoryId>(id: Id): Category<Id>;
+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.
+ */
+declare function getTarget<Id extends CategoryId>(id: Id): z.ZodType<CategoryTargets[Id]>;
+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`.
+ */
+declare function kindOf(id: CategoryId): string;
+/** @returns Every registered category, in id order. */
+declare function listCategories(): readonly Category[];
+/**
+ * Counts the collections an entry may record expected counts for, in a resolved target.
+ * @param id - The target's category.
+ * @param target - A resolved target of that category.
+ * @returns The length of each counted array, by key.
+ */
+declare function countTarget(id: CategoryId, target: CategoryTarget): ReadonlyMap<string, number>;
+//#endregion
+export { SnapshotSchema as $, SemVerSchema as A, Entry as B, Dataset as C, LineageSchema as D, Lineage as E, ArchiveSchema as F, LicenceSchema as G, HttpUrlSchema as H, Citation as I, RESERVED_META_KEYS as J, Parser as K, CitationSchema as L, Archive as M, ArchiveMember as N, Manifest as O, ArchiveMemberSchema as P, Snapshot as Q, CrosswalkReference as R, CatalogueIndexSchema as S, createCatalogue as T, IdSchema as U, EntrySchema as V, Licence as W, RecipeSchema as X, Recipe as Y, RelativePathSchema as Z, GraphV1Schema as _, CategoryTargets as a, Catalogue as b, getCategory as c, listCategories as d, Source as et, GraphEdge as f, GraphV1 as g, GraphNodeSchema as h, CategoryTarget as i, waybackUrl as it, parseManifest as j, ManifestSchema as k, getTarget as l, GraphNode as m, CategoryId as n, WaybackTimestampSchema as nt, CountedKey as o, GraphEdgeSchema as p, ParserSchema as q, CategoryIdSchema as r, parseEntry as rt, countTarget as s, Category as t, SourceSchema as tt, kindOf as u, JsonScalar as v, DatasetQuery as w, CatalogueIndex as x, JsonScalarSchema as y, CrosswalkReferenceSchema as z };