keepset 0.0.4 → 0.2.0

package/dist/index.d.ts

@@ -1 +1,589 @@
-export {}
+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
+//#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);
+}
+/** 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 {
+  readonly categoryId: string;
+  readonly knownIds: readonly string[];
+  constructor(categoryId: string, knownIds: readonly string[]);
+}
+/** One reason a catalogue document failed its schema: the dotted path of the offending value and what is wrong with it. Zod's own issue objects are collapsed into these so the public error surface stays stable across Zod versions. */
+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. */
+export declare class CatalogueSyntaxError extends KeepsetError {
+  readonly document: "entry" | "manifest";
+  readonly issues: readonly SyntaxIssue[];
+  constructor(document: "entry" | "manifest", issues: readonly SyntaxIssue[]);
+}
+//#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>;
+/**
+ * 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.
+ */
+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>;
+/**
+ * Parses an unknown value as a catalogue manifest.
+ * @param doc - The candidate manifest document.
+ * @returns The validated manifest.
+ * @throws CatalogueSyntaxError carrying every issue found.
+ */
+export declare function parseManifest(doc: unknown): 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.
+ * @returns The file text.
+ */
+export declare function serialise(doc: Entry | Manifest): 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 };

package/dist/index.js

@@ -0,0 +1,375 @@
+import { z } from "zod";
+import { CrosswalkSchema } from "twindex";
+//#region src/errors.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. */
+var KeepsetError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = new.target.name;
+	}
+};
+/** 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. */
+var UnknownCategoryError = class extends KeepsetError {
+	categoryId;
+	knownIds;
+	constructor(categoryId, knownIds) {
+		super(`unknown category ${JSON.stringify(categoryId)}: known categories are ${knownIds.join(", ")}`);
+		this.categoryId = categoryId;
+		this.knownIds = knownIds;
+	}
+};
+/** 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. */
+var CatalogueSyntaxError = class extends KeepsetError {
+	document;
+	issues;
+	constructor(document, issues) {
+		super(`${document} syntax error: ${issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+		this.document = document;
+		this.issues = issues;
+	}
+};
+//#endregion
+//#region src/define.ts
+/**
+* Attaches a type guard to a Zod schema (the schema-attached guard pattern: validation, inference and narrowing share one definition, so the three cannot drift). This module is isolated because it is the one place in the package that augments an object in place with Object.assign, which the house lint rule that eslint.config.ts turns off for this file alone would otherwise reject: object spread is no alternative, as it copies own properties only and drops the Zod prototype's parse/refine methods.
+* @param schema - The schema to augment.
+* @returns The same schema object, now also carrying `is`.
+*/
+function define(schema) {
+	return Object.assign(schema, { is(value) {
+		return schema.safeParse(value).success;
+	} });
+}
+//#endregion
+//#region src/record.ts
+/**
+* A record whose every key must satisfy `key`. Zod's own record silently drops an own `__proto__` key (which `JSON.parse` creates as an ordinary property) before the key schema sees it, so this checks the raw input first and rejects such a key loudly instead of losing the value.
+* @param key - The key schema.
+* @param value - The value schema.
+* @returns The record schema.
+*/
+function recordOf(key, value) {
+	return z.preprocess((input, ctx) => {
+		if (typeof input === "object" && input !== null && Object.hasOwn(input, "__proto__")) ctx.issues.push({
+			code: "custom",
+			input,
+			message: "__proto__ is not a valid key"
+		});
+		return input;
+	}, z.record(key, value));
+}
+//#endregion
+//#region src/targets/graph-v1.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. */
+const JsonScalarSchema = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+/** 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. */
+const GraphNodeSchema = z.looseObject({
+	id: z.string().min(1),
+	type: z.string().min(1).optional()
+});
+/** 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. */
+const GraphEdgeSchema = z.looseObject({
+	source: z.string().min(1),
+	target: z.string().min(1),
+	type: z.string().min(1).optional()
+});
+/**
+* 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.
+*/
+const GraphV1Schema = define(z.object({
+	meta: recordOf(z.string().min(1), JsonScalarSchema),
+	nodes: z.array(GraphNodeSchema),
+	edges: z.array(GraphEdgeSchema)
+}).strict().superRefine((graph, ctx) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const [index, node] of graph.nodes.entries()) {
+		if (ids.has(node.id)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"nodes",
+				index,
+				"id"
+			],
+			message: `duplicate node id ${JSON.stringify(node.id)}`
+		});
+		ids.add(node.id);
+	}
+	for (const [index, edge] of graph.edges.entries()) for (const end of ["source", "target"]) if (!ids.has(edge[end])) ctx.addIssue({
+		code: "custom",
+		path: [
+			"edges",
+			index,
+			end
+		],
+		message: `edge ${end} ${JSON.stringify(edge[end])} names no node`
+	});
+}));
+//#endregion
+//#region src/categories.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. */
+const CategoryIdSchema = z.enum(["graph/v1"]);
+/** The registry. Adding a category is adding its id to `CategoryIdSchema` and its entry here, with its target schema beside graph/v1's in src/targets/: the mapped type makes the compiler reject a registry that misses an id or has one too many. */
+const registry = { "graph/v1": {
+	id: "graph/v1",
+	description: "A graph as { meta, nodes, edges }: a flat record of scalar metadata, nodes carrying at least an id, and edges carrying at least source and target node ids, with optional node and edge types.",
+	target: GraphV1Schema
+} };
+function getCategory(id) {
+	const parsed = CategoryIdSchema.safeParse(id);
+	if (!parsed.success) throw new UnknownCategoryError(id, CategoryIdSchema.options);
+	return registry[parsed.data];
+}
+function getTarget(id) {
+	return getCategory(id).target;
+}
+/**
+* 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`.
+*/
+function kindOf(id) {
+	return id.slice(0, id.indexOf("/"));
+}
+/** @returns Every registered category, in id order. */
+function listCategories() {
+	return CategoryIdSchema.options.map((id) => getCategory(id));
+}
+//#endregion
+//#region src/entry.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. */
+const IdSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, { message: "must start with a letter or digit and contain only letters, digits, '.', '_' and '-'" });
+/** A key of an entry's `properties` or `expectedCounts` record: an identifier that starts with a letter, so it can never be `__proto__` or another name Object.prototype reacts to on assignment. */
+const RecordKeySchema = z.string().regex(/^[A-Za-z][A-Za-z0-9]*$/, { message: "must be a letter followed by letters or digits" });
+/** A calendar date, `YYYY-MM-DD`. */
+const IsoDateSchema = z.iso.date();
+/** An http or https URL: the only schemes a recipe may download from. */
+const HttpUrlSchema = z.httpUrl();
+/** A Wayback Machine timestamp, `YYYYMMDD` or `YYYYMMDDhhmmss`: the moment the snapshot is pinned to. */
+const WaybackTimestampSchema = z.string().regex(/^\d{8}(?:\d{6})?$/, { message: "must be a Wayback timestamp, YYYYMMDD or YYYYMMDDhhmmss" });
+/**
+* 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.
+*/
+function waybackUrl(timestamp, url) {
+	return `https://web.archive.org/web/${timestamp}/${url}`;
+}
+/** 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. */
+const SnapshotSchema = z.object({
+	url: HttpUrlSchema,
+	timestamp: WaybackTimestampSchema
+}).strict();
+/**
+* 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)`.
+*/
+const SourceSchema = z.object({
+	url: HttpUrlSchema,
+	retrieved: IsoDateSchema,
+	status: z.enum(["live", "dead"]),
+	snapshot: SnapshotSchema.optional()
+}).strict().superRefine((source, ctx) => {
+	if (source.status === "dead" && source.snapshot === void 0) ctx.addIssue({
+		code: "custom",
+		path: ["snapshot"],
+		message: "a dead source must pin the Wayback snapshot its recipe fetches"
+	});
+	if (source.snapshot !== void 0 && source.snapshot.url !== waybackUrl(source.snapshot.timestamp, source.url)) ctx.addIssue({
+		code: "custom",
+		path: ["snapshot", "url"],
+		message: `must be ${waybackUrl(source.snapshot.timestamp, source.url)}, the snapshot of this source's url at this timestamp`
+	});
+});
+/** 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. */
+const LicenceSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("spdx"),
+		id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9.+-]*$/, { message: "must be an SPDX licence identifier" })
+	}).strict(),
+	z.object({
+		kind: z.literal("custom"),
+		name: z.string().min(1),
+		url: HttpUrlSchema
+	}).strict(),
+	z.object({ kind: z.literal("unrecorded") }).strict()
+]);
+/** A work to cite for the dataset: a formatted reference, with its DOI or URL where the source records one. */
+const CitationSchema = z.object({
+	text: z.string().min(1),
+	doi: z.string().regex(/^10\.\d{4,9}\/\S+$/, { message: "must be a bare DOI, 10.<registrant>/<suffix>" }).optional(),
+	url: HttpUrlSchema.optional()
+}).strict();
+/** 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. */
+const RelativePathSchema = z.string().refine((path) => path.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".."), { message: "must be a relative path of non-empty segments with no '.' or '..'" });
+/** 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. */
+const ArchiveMemberSchema = z.union([z.object({ path: RelativePathSchema }).strict(), z.object({ extension: z.string().regex(/^\.[A-Za-z0-9][A-Za-z0-9.]*$/, { message: "must be a file extension such as .mtx" }) }).strict()]);
+/** How the downloaded bytes unpack into the one file the parser reads. */
+const ArchiveSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("none") }).strict(),
+	z.object({ kind: z.literal("gzip") }).strict(),
+	z.object({
+		kind: z.literal("zip"),
+		member: ArchiveMemberSchema
+	}).strict(),
+	z.object({
+		kind: z.literal("tar"),
+		member: ArchiveMemberSchema
+	}).strict(),
+	z.object({
+		kind: z.literal("tar.gz"),
+		member: ArchiveMemberSchema
+	}).strict()
+]);
+const ColumnSchema = z.int().min(0);
+/** The text encoding of the unpacked file. Decoding is strict: bytes that are not valid in the stated encoding fail the recipe rather than turning into replacement characters. */
+const EncodingSchema = z.enum(["utf-8", "latin1"]);
+/** 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. */
+const ParserSchema = z.discriminatedUnion("format", [
+	z.object({
+		format: z.literal("edge-list"),
+		encoding: EncodingSchema,
+		delimiter: z.enum([
+			"whitespace",
+			"tab",
+			"comma",
+			"space"
+		]),
+		skipLines: z.int().min(0),
+		commentPrefixes: z.array(z.string().min(1)),
+		sourceColumn: ColumnSchema,
+		targetColumn: ColumnSchema
+	}).strict().refine((parser) => parser.sourceColumn !== parser.targetColumn, {
+		message: "sourceColumn and targetColumn must differ",
+		path: ["targetColumn"]
+	}),
+	z.object({
+		format: z.literal("matrix-market"),
+		encoding: EncodingSchema
+	}).strict(),
+	z.object({
+		format: z.literal("gml"),
+		encoding: EncodingSchema
+	}).strict(),
+	z.object({
+		format: z.literal("pajek"),
+		encoding: EncodingSchema
+	}).strict()
+]);
+/** 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. */
+const RecipeSchema = z.discriminatedUnion("status", [z.object({
+	status: z.literal("fetchable"),
+	source: z.int().min(0),
+	archive: ArchiveSchema,
+	parser: ParserSchema
+}).strict(), z.object({
+	status: z.literal("not-fetchable"),
+	reason: z.string().min(1)
+}).strict()]);
+/** 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. */
+const CrosswalkReferenceSchema = z.union([CrosswalkSchema, z.object({ file: RelativePathSchema.refine((path) => path.endsWith(".json"), { message: "must name a .json file" }) }).strict()]);
+/**
+* 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.
+*/
+const EntrySchema = define(z.object({
+	id: IdSchema,
+	name: z.string().min(1),
+	description: z.string().min(1).optional(),
+	domain: z.string().min(1).optional(),
+	tags: z.array(z.string().min(1)).refine((tags) => new Set(tags).size === tags.length, { message: "tags must be unique" }),
+	category: CategoryIdSchema,
+	sources: z.array(SourceSchema).min(1),
+	licence: LicenceSchema,
+	citations: z.array(CitationSchema),
+	recipe: RecipeSchema,
+	crosswalk: CrosswalkReferenceSchema,
+	expectedCounts: recordOf(RecordKeySchema, z.int().min(0)),
+	properties: recordOf(RecordKeySchema, JsonScalarSchema)
+}).strict().superRefine((entry, ctx) => {
+	if (entry.recipe.status === "fetchable" && entry.recipe.source >= entry.sources.length) ctx.addIssue({
+		code: "custom",
+		path: ["recipe", "source"],
+		message: `names source ${String(entry.recipe.source)} but the entry has ${String(entry.sources.length)}`
+	});
+	if ("target" in entry.crosswalk && entry.crosswalk.target !== entry.category) ctx.addIssue({
+		code: "custom",
+		path: ["crosswalk", "target"],
+		message: `must be the entry's category, ${entry.category}`
+	});
+}));
+/**
+* Collapses Zod issues into the package's own issue shape, so the public error surface stays stable across Zod versions.
+* @param error - A Zod error.
+* @returns One issue per Zod issue, with its path written as dotted text.
+*/
+function toIssues(error) {
+	return error.issues.map((issue) => ({
+		path: issue.path.map(String).join(".") || "(root)",
+		message: issue.message
+	}));
+}
+/**
+* Parses an unknown value as a catalogue entry.
+* @param doc - The candidate entry document.
+* @returns The validated entry.
+* @throws CatalogueSyntaxError carrying every issue found.
+*/
+function parseEntry(doc) {
+	const result = EntrySchema.safeParse(doc);
+	if (!result.success) throw new CatalogueSyntaxError("entry", toIssues(result.error));
+	return result.data;
+}
+//#endregion
+//#region src/manifest.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). */
+const SemVerSchema = z.string().regex(/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/, { message: "must be a semantic version, MAJOR.MINOR.PATCH" });
+/** 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. */
+const LineageSchema = z.object({
+	catalogue: IdSchema,
+	version: SemVerSchema,
+	repository: z.httpUrl()
+}).strict();
+/**
+* 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.
+*/
+const ManifestSchema = define(z.object({
+	id: IdSchema,
+	name: z.string().min(1),
+	description: z.string().min(1),
+	version: SemVerSchema,
+	repository: z.httpUrl(),
+	lineage: LineageSchema.optional()
+}).strict().superRefine((manifest, ctx) => {
+	if (manifest.lineage?.catalogue === manifest.id) ctx.addIssue({
+		code: "custom",
+		path: ["lineage", "catalogue"],
+		message: "a fork is its own catalogue: lineage must name the catalogue it was forked from, not itself"
+	});
+}));
+/**
+* Parses an unknown value as a catalogue manifest.
+* @param doc - The candidate manifest document.
+* @returns The validated manifest.
+* @throws CatalogueSyntaxError carrying every issue found.
+*/
+function parseManifest(doc) {
+	const result = ManifestSchema.safeParse(doc);
+	if (!result.success) throw new CatalogueSyntaxError("manifest", toIssues(result.error));
+	return result.data;
+}
+//#endregion
+//#region src/serialise.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.
+* @returns The file text.
+*/
+function serialise(doc) {
+	return `${JSON.stringify(doc, void 0, 2)}\n`;
+}
+//#endregion
+export { ArchiveMemberSchema, ArchiveSchema, CatalogueSyntaxError, CategoryIdSchema, CitationSchema, CrosswalkReferenceSchema, EntrySchema, GraphEdgeSchema, GraphNodeSchema, GraphV1Schema, IdSchema, JsonScalarSchema, KeepsetError, LicenceSchema, LineageSchema, ManifestSchema, ParserSchema, RecipeSchema, RelativePathSchema, SemVerSchema, SnapshotSchema, SourceSchema, UnknownCategoryError, WaybackTimestampSchema, getCategory, getTarget, kindOf, listCategories, parseEntry, parseManifest, serialise, waybackUrl };

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "keepset",
   "description": "Library, CLI and statically generated catalogue for dataset fetch-and-normalise recipes",
-  "version": "0.0.4",
+  "version": "0.2.0",
   "dependencies": {
-    "zod": "4.6.6"
+    "twindex": "0.1.1",
+    "zod": "4.6.5"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.5",
@@ -15,6 +16,8 @@
     "@semantic-release/git": "11.0.1",
     "@types/node": "26.6.5",
     "@vitest/coverage-v8": "5.0.3",
+    "ajv": "8.20.0",
+    "ajv-formats": "3.0.1",
     "canonicalize": "5.1.0",
     "conventional-changelog-conventionalcommits": "10.4.1",
     "eslint": "10.12.0",
@@ -65,13 +68,13 @@
     "url": "git+https://github.com/ExaDev/keepset.git"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsdown && tsx scripts/generate-json-schema.ts",
     "lint": "eslint . --fix --cache --max-warnings 0",
     "lint:check": "eslint . --cache --max-warnings 0",
     "prepare": "husky",
-    "prepublishOnly": "pnpm run lint:check && pnpm run typecheck && pnpm run test && pnpm run build && publint && attw --pack --profile esm-only",
+    "prepublishOnly": "pnpm run lint:check && pnpm run build && pnpm run typecheck && pnpm run test && publint && attw --pack --profile esm-only",
     "test": "vitest run",
-    "typecheck": "tsc -p tsconfig.json"
+    "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.node.json"
   },
   "sideEffects": false,
   "type": "module",

package/schemas/entry.schema.json

@@ -0,0 +1 @@
+{"$defs":{"Crosswalk":{"$ref":"https://cdn.jsdelivr.net/npm/twindex@0.1.1/schemas/twindex.schema.json"},"Entry":{"additionalProperties":false,"properties":{"category":{"enum":["graph/v1"],"type":"string"},"citations":{"items":{"additionalProperties":false,"properties":{"doi":{"pattern":"^10\\.\\d{4,9}\\/\\S+$","type":"string"},"text":{"minLength":1,"type":"string"},"url":{"format":"uri","type":"string"}},"required":["text"],"type":"object"},"type":"array"},"crosswalk":{"anyOf":[{"$ref":"#/$defs/Crosswalk"},{"additionalProperties":false,"properties":{"file":{"type":"string"}},"required":["file"],"type":"object"}]},"description":{"minLength":1,"type":"string"},"domain":{"minLength":1,"type":"string"},"expectedCounts":{"additionalProperties":{"maximum":9007199254740991,"minimum":0,"type":"integer"},"propertyNames":{"pattern":"^[A-Za-z][A-Za-z0-9]*$","type":"string"},"type":"object"},"id":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*$","type":"string"},"licence":{"oneOf":[{"additionalProperties":false,"properties":{"id":{"pattern":"^[A-Za-z0-9][A-Za-z0-9.+-]*$","type":"string"},"kind":{"const":"spdx","type":"string"}},"required":["kind","id"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"custom","type":"string"},"name":{"minLength":1,"type":"string"},"url":{"format":"uri","type":"string"}},"required":["kind","name","url"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"unrecorded","type":"string"}},"required":["kind"],"type":"object"}]},"name":{"minLength":1,"type":"string"},"properties":{"additionalProperties":{"type":["string","number","boolean","null"]},"propertyNames":{"pattern":"^[A-Za-z][A-Za-z0-9]*$","type":"string"},"type":"object"},"recipe":{"oneOf":[{"additionalProperties":false,"properties":{"archive":{"oneOf":[{"additionalProperties":false,"properties":{"kind":{"const":"none","type":"string"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"gzip","type":"string"}},"required":["kind"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"zip","type":"string"},"member":{"anyOf":[{"additionalProperties":false,"properties":{"path":{"type":"string"}},"required":["path"],"type":"object"},{"additionalProperties":false,"properties":{"extension":{"pattern":"^\\.[A-Za-z0-9][A-Za-z0-9.]*$","type":"string"}},"required":["extension"],"type":"object"}]}},"required":["kind","member"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"tar","type":"string"},"member":{"anyOf":[{"additionalProperties":false,"properties":{"path":{"type":"string"}},"required":["path"],"type":"object"},{"additionalProperties":false,"properties":{"extension":{"pattern":"^\\.[A-Za-z0-9][A-Za-z0-9.]*$","type":"string"}},"required":["extension"],"type":"object"}]}},"required":["kind","member"],"type":"object"},{"additionalProperties":false,"properties":{"kind":{"const":"tar.gz","type":"string"},"member":{"anyOf":[{"additionalProperties":false,"properties":{"path":{"type":"string"}},"required":["path"],"type":"object"},{"additionalProperties":false,"properties":{"extension":{"pattern":"^\\.[A-Za-z0-9][A-Za-z0-9.]*$","type":"string"}},"required":["extension"],"type":"object"}]}},"required":["kind","member"],"type":"object"}]},"parser":{"oneOf":[{"additionalProperties":false,"properties":{"commentPrefixes":{"items":{"minLength":1,"type":"string"},"type":"array"},"delimiter":{"enum":["whitespace","tab","comma","space"],"type":"string"},"encoding":{"enum":["utf-8","latin1"],"type":"string"},"format":{"const":"edge-list","type":"string"},"skipLines":{"maximum":9007199254740991,"minimum":0,"type":"integer"},"sourceColumn":{"maximum":9007199254740991,"minimum":0,"type":"integer"},"targetColumn":{"maximum":9007199254740991,"minimum":0,"type":"integer"}},"required":["format","encoding","delimiter","skipLines","commentPrefixes","sourceColumn","targetColumn"],"type":"object"},{"additionalProperties":false,"properties":{"encoding":{"enum":["utf-8","latin1"],"type":"string"},"format":{"const":"matrix-market","type":"string"}},"required":["format","encoding"],"type":"object"},{"additionalProperties":false,"properties":{"encoding":{"enum":["utf-8","latin1"],"type":"string"},"format":{"const":"gml","type":"string"}},"required":["format","encoding"],"type":"object"},{"additionalProperties":false,"properties":{"encoding":{"enum":["utf-8","latin1"],"type":"string"},"format":{"const":"pajek","type":"string"}},"required":["format","encoding"],"type":"object"}]},"source":{"maximum":9007199254740991,"minimum":0,"type":"integer"},"status":{"const":"fetchable","type":"string"}},"required":["status","source","archive","parser"],"type":"object"},{"additionalProperties":false,"properties":{"reason":{"minLength":1,"type":"string"},"status":{"const":"not-fetchable","type":"string"}},"required":["status","reason"],"type":"object"}]},"sources":{"items":{"additionalProperties":false,"properties":{"retrieved":{"format":"date","pattern":"^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))$","type":"string"},"snapshot":{"additionalProperties":false,"properties":{"timestamp":{"pattern":"^\\d{8}(?:\\d{6})?$","type":"string"},"url":{"format":"uri","type":"string"}},"required":["url","timestamp"],"type":"object"},"status":{"enum":["live","dead"],"type":"string"},"url":{"format":"uri","type":"string"}},"required":["url","retrieved","status"],"type":"object"},"minItems":1,"type":"array"},"tags":{"items":{"minLength":1,"type":"string"},"type":"array"}},"required":["id","name","tags","category","sources","licence","citations","recipe","crosswalk","expectedCounts","properties"],"type":"object"}},"$id":"https://cdn.jsdelivr.net/npm/keepset@0.2.0/schemas/entry.schema.json","$ref":"#/$defs/Entry","$schema":"https://json-schema.org/draft/2020-12/schema"}

package/schemas/manifest.schema.json

@@ -0,0 +1 @@
+{"$defs":{"Manifest":{"additionalProperties":false,"properties":{"description":{"minLength":1,"type":"string"},"id":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*$","type":"string"},"lineage":{"additionalProperties":false,"properties":{"catalogue":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*$","type":"string"},"repository":{"format":"uri","type":"string"},"version":{"pattern":"^(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$","type":"string"}},"required":["catalogue","version","repository"],"type":"object"},"name":{"minLength":1,"type":"string"},"repository":{"format":"uri","type":"string"},"version":{"pattern":"^(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$","type":"string"}},"required":["id","name","description","version","repository"],"type":"object"}},"$id":"https://cdn.jsdelivr.net/npm/keepset@0.2.0/schemas/manifest.schema.json","$ref":"#/$defs/Manifest","$schema":"https://json-schema.org/draft/2020-12/schema"}