keepset 0.13.1 → 0.14.1

package/README.md

@@ -63,7 +63,7 @@ The catalogue itself is a manifest (`catalogue/manifest.json`: id, version, repo
 
 ## Categories and normalisation targets
 
-A category names a normalisation target: the shape every entry in that category resolves to, whatever its native shape. `graph/v1` is the first, `{ meta, nodes, edges }` with unique node ids and edges whose endpoints name nodes, seeded from 823 graph datasets surveyed from about forty upstream collections (SuiteSparse, Netzschleuder, SNAP, KONECT, OGB and others). A new category starts by defining its target schema in `src/targets/` and registering it in the category registry; an entry cannot name a category that does not exist. The statically generated site renders every entry with schema.org Dataset JSON-LD, so the catalogue surfaces in the dataset discovery layers.
+A category names a normalisation target: the shape every entry in that category resolves to, whatever its native shape. `graph/v1` is the first, `{ meta, nodes, edges }` with unique node ids and edges whose endpoints name nodes, seeded from 823 graph datasets surveyed from about forty upstream collections (SuiteSparse, Netzschleuder, SNAP, KONECT, OGB and others). `or/v1` is the second: `{ meta, nodes }`, an operations-research instance as the nodes it offers to visit, each flat with optional coordinates, prize, prize probability, duration, travel time, skill, territory, lifecycle status and times, and deadline, read from tabular sources by the `csv-table` parser. A new category starts by defining its target schema in `src/targets/` and registering it in the category registry; an entry cannot name a category that does not exist. The statically generated site renders every entry with schema.org Dataset JSON-LD, so the catalogue surfaces in the dataset discovery layers.
 
 ## Licensing
 

package/dist/{bundled-DNLiwEcd.js → bundled-D9eVvy1i.js}

@@ -99,14 +99,40 @@ function recordOf(key, value) {
 	}, 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. */
+//#region src/targets/json-scalar.ts
+/** A JSON scalar: the only values a target's 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()
 ]);
+//#endregion
+//#region src/targets/node-ids.ts
+/**
+* Reports each node whose id an earlier node already has, as an issue on that node's id.
+* @param nodes - The nodes of a target document, in order.
+* @param ctx - The refinement context to report to.
+* @returns The set of ids the nodes carry.
+*/
+function addDuplicateIdIssues(nodes, ctx) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const [index, node] of 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);
+	}
+	return ids;
+}
+//#endregion
+//#region src/targets/graph-v1.ts
 /** 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),
@@ -126,19 +152,7 @@ const GraphV1Schema = define(z.object({
 	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);
-	}
+	const ids = addDuplicateIdIssues(graph.nodes, ctx);
 	for (const [index, edge] of graph.edges.entries()) for (const end of ["source", "target"]) if (!ids.has(edge[end])) ctx.addIssue({
 		code: "custom",
 		path: [
@@ -150,16 +164,62 @@ const GraphV1Schema = define(z.object({
 	});
 }));
 //#endregion
+//#region src/targets/or-v1.ts
+/** The largest latitude and longitude, in degrees, either side of zero. */
+const LATITUDE_LIMIT = 90;
+const LONGITUDE_LIMIT = 180;
+/** A value a node may not have: every field below is optional and nullable, null being what a source's empty cell becomes. */
+function maybe(schema) {
+	return schema.nullable().optional();
+}
+/**
+* A node of an operations-research instance: a place or case a route may visit, flat so a twindex crosswalk can map a table's columns onto it (a wildcard path must keep the same shape on both sides). The target fixes only what the datasets share and lets a crosswalk map any further column through under its own name, as graph/v1 does. `lat` and `lon` are WGS84 degrees and `x` and `y` are planar coordinates in the dataset's own system; `duration` and `travelTime` are seconds, `prize` is the dataset's own reward measure, and `prizeProbability` is the chance the reward is collected. `skill` and `territory` name what is needed to serve the node and where it sits, `status` is where it is in its lifecycle, and `opened`, `closed` and `deadline` are its lifecycle times as the source writes them, a deadline being a number where the source gives a time of day.
+*/
+const OrNodeSchema = z.looseObject({
+	id: z.string().min(1),
+	lat: maybe(z.number().min(-90).max(LATITUDE_LIMIT)),
+	lon: maybe(z.number().min(-180).max(LONGITUDE_LIMIT)),
+	x: maybe(z.number()),
+	y: maybe(z.number()),
+	prize: maybe(z.number()),
+	prizeProbability: maybe(z.number().min(0).max(1)),
+	duration: maybe(z.number().min(0)),
+	travelTime: maybe(z.number().min(0)),
+	skill: maybe(z.string().min(1)),
+	territory: maybe(z.string().min(1)),
+	status: maybe(z.string().min(1)),
+	opened: maybe(z.string().min(1)),
+	closed: maybe(z.string().min(1)),
+	deadline: maybe(z.union([z.string().min(1), z.number()]))
+});
+/**
+* The or/v1 normalisation target: `{ meta, nodes }`, an operations-research instance as the nodes it offers to visit. It describes the result `fetchDataset` resolves an entry to, not what a source file may contain. Beyond the field shapes it checks that node ids are unique. It has no arcs: a source that carries a travel matrix or arc list keeps it out of this version.
+*/
+const OrV1Schema = define(z.object({
+	meta: recordOf(z.string().min(1), JsonScalarSchema),
+	nodes: z.array(OrNodeSchema)
+}).strict().superRefine((instance, ctx) => {
+	addDuplicateIdIssues(instance.nodes, ctx);
+}));
+//#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"]);
+const CategoryIdSchema = z.enum(["graph/v1", "or/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,
-	counted: ["nodes", "edges"]
-} };
+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,
+		counted: ["nodes", "edges"]
+	},
+	"or/v1": {
+		id: "or/v1",
+		description: "An operations-research instance as { meta, nodes }: a flat record of scalar metadata and nodes carrying at least an id, with optional coordinates, prize, prize probability, duration, travel time, skill, territory, lifecycle status and times, and deadline.",
+		target: OrV1Schema,
+		counted: ["nodes"]
+	}
+};
 function getCategory(id) {
 	const parsed = CategoryIdSchema.safeParse(id);
 	if (!parsed.success) throw new UnknownCategoryError(id, CategoryIdSchema.options);
@@ -181,6 +241,18 @@ function listCategories() {
 	return CategoryIdSchema.options.map((id) => getCategory(id));
 }
 /**
+* The length of one of a target's collections.
+* @param target - A resolved target.
+* @param key - A key its category counts, so one that holds an array.
+* @returns The collection's length.
+* @throws TypeError when the key holds no array, which a registry entry's `counted` never names.
+*/
+function countOf(target, key) {
+	const collection = Object.entries(target).find(([name]) => name === key)?.[1];
+	if (!Array.isArray(collection)) throw new TypeError(`the target has no collection ${key}`);
+	return collection.length;
+}
+/**
 * 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.
@@ -188,7 +260,7 @@ function listCategories() {
 */
 function countTarget(id, target) {
 	const category = getCategory(id);
-	return new Map(category.counted.map((key) => [key, target[key].length]));
+	return new Map(category.counted.map((key) => [key, countOf(target, key)]));
 }
 //#endregion
 //#region src/own.ts
@@ -358,6 +430,8 @@ const ArchiveSchema = z.discriminatedUnion("kind", [
 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"]);
+/** A column of a table as the table parser names it: the header with every run of characters outside letters, digits and underscore replaced by one underscore, so it is a valid segment of a twindex path. */
+const ColumnNameSchema = z.string().regex(/^[A-Za-z](?:[A-Za-z0-9_]*[A-Za-z0-9])?$/, { message: "must be a column name as the parser spells it: letters, digits and underscores, starting with a letter and not ending with an underscore" });
 /** 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({
@@ -389,7 +463,25 @@ const ParserSchema = z.discriminatedUnion("format", [
 	z.object({
 		format: z.literal("pajek"),
 		encoding: EncodingSchema
-	}).strict()
+	}).strict(),
+	z.object({
+		format: z.literal("csv-table"),
+		encoding: EncodingSchema,
+		delimiter: z.enum([
+			"comma",
+			"tab",
+			"semicolon"
+		]),
+		skipLines: z.int().min(0),
+		idColumn: ColumnNameSchema.nullable(),
+		numericColumns: z.array(z.object({
+			column: ColumnNameSchema,
+			factor: z.number().positive()
+		}).strict())
+	}).strict().refine((parser) => new Set(parser.numericColumns.map((numeric) => numeric.column)).size === parser.numericColumns.length, {
+		message: "a column may be declared numeric once",
+		path: ["numericColumns"]
+	})
 ]);
 /** 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({
@@ -47817,4 +47909,4 @@ function getManifest() {
 	return catalogue().manifest;
 }
 //#endregion
-export { waybackUrl as A, listCategories as B, RecipeSchema as C, WaybackTimestampSchema as D, SourceSchema as E, CategoryIdSchema as F, ArchiveError as G, GraphNodeSchema as H, countTarget as I, DatasetNotFoundError as J, CatalogueSyntaxError as K, getCategory as L, groupsOf as M, namesOf as N, parseEntry as O, getOwn as P, UnknownCategoryError as Q, getTarget as R, RESERVED_META_KEYS as S, SnapshotSchema as T, GraphV1Schema as U, GraphEdgeSchema as V, JsonScalarSchema as W, NativeParseError as X, KeepsetError as Y, RecipeError as Z, HttpUrlSchema as _, CatalogueIndexSchema as a, NamespaceSchema as b, ManifestSchema as c, AliasSchema as d, ArchiveMemberSchema as f, EntrySchema as g, CrosswalkReferenceSchema as h, listNamespaces as i, NAME_SEPARATOR as j, toIssues as k, SemVerSchema as l, CitationSchema as m, getManifest as n, createCatalogue as o, ArchiveSchema as p, DatasetAmbiguousError as q, listDatasets as r, LineageSchema as s, getDataset as t, parseManifest as u, IdSchema as v, RelativePathSchema as w, ParserSchema as x, LicenceSchema as y, kindOf as z };
+export { RecipeError as $, waybackUrl as A, listCategories as B, RecipeSchema as C, WaybackTimestampSchema as D, SourceSchema as E, CategoryIdSchema as F, GraphV1Schema as G, OrV1Schema as H, countTarget as I, CatalogueSyntaxError as J, JsonScalarSchema as K, getCategory as L, groupsOf as M, namesOf as N, parseEntry as O, getOwn as P, NativeParseError as Q, getTarget as R, RESERVED_META_KEYS as S, SnapshotSchema as T, GraphEdgeSchema as U, OrNodeSchema as V, GraphNodeSchema as W, DatasetNotFoundError as X, DatasetAmbiguousError as Y, KeepsetError as Z, HttpUrlSchema as _, CatalogueIndexSchema as a, NamespaceSchema as b, ManifestSchema as c, AliasSchema as d, UnknownCategoryError as et, ArchiveMemberSchema as f, EntrySchema as g, CrosswalkReferenceSchema as h, listNamespaces as i, NAME_SEPARATOR as j, toIssues as k, SemVerSchema as l, CitationSchema as m, getManifest as n, createCatalogue as o, ArchiveSchema as p, ArchiveError as q, listDatasets as r, LineageSchema as s, getDataset as t, parseManifest as u, IdSchema as v, RelativePathSchema as w, ParserSchema as x, LicenceSchema as y, kindOf as z };

package/dist/{categories-DzjLQ_fp.d.ts → categories-B4hhikbr.d.ts}

@@ -134,6 +134,23 @@ declare const ParserSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     "utf-8": "utf-8";
     latin1: "latin1";
   }>;
+}, z.core.$strict>, z.ZodObject<{
+  format: z.ZodLiteral<"csv-table">;
+  encoding: z.ZodEnum<{
+    "utf-8": "utf-8";
+    latin1: "latin1";
+  }>;
+  delimiter: z.ZodEnum<{
+    tab: "tab";
+    comma: "comma";
+    semicolon: "semicolon";
+  }>;
+  skipLines: z.ZodInt;
+  idColumn: z.ZodNullable<z.ZodString>;
+  numericColumns: z.ZodArray<z.ZodObject<{
+    column: z.ZodString;
+    factor: z.ZodNumber;
+  }, z.core.$strict>>;
 }, 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. */
@@ -201,6 +218,23 @@ declare const RecipeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
       "utf-8": "utf-8";
       latin1: "latin1";
     }>;
+  }, z.core.$strict>, z.ZodObject<{
+    format: z.ZodLiteral<"csv-table">;
+    encoding: z.ZodEnum<{
+      "utf-8": "utf-8";
+      latin1: "latin1";
+    }>;
+    delimiter: z.ZodEnum<{
+      tab: "tab";
+      comma: "comma";
+      semicolon: "semicolon";
+    }>;
+    skipLines: z.ZodInt;
+    idColumn: z.ZodNullable<z.ZodString>;
+    numericColumns: z.ZodArray<z.ZodObject<{
+      column: z.ZodString;
+      factor: z.ZodNumber;
+    }, z.core.$strict>>;
   }, z.core.$strict>], "format">;
 }, z.core.$strict>, z.ZodObject<{
   status: z.ZodLiteral<"not-fetchable">;
@@ -229,6 +263,7 @@ declare const EntrySchema: z.ZodObject<{
   tags: z.ZodArray<z.ZodString>;
   category: z.ZodEnum<{
     "graph/v1": "graph/v1";
+    "or/v1": "or/v1";
   }>;
   sources: z.ZodArray<z.ZodObject<{
     url: z.ZodURL;
@@ -321,6 +356,23 @@ declare const EntrySchema: z.ZodObject<{
         "utf-8": "utf-8";
         latin1: "latin1";
       }>;
+    }, z.core.$strict>, z.ZodObject<{
+      format: z.ZodLiteral<"csv-table">;
+      encoding: z.ZodEnum<{
+        "utf-8": "utf-8";
+        latin1: "latin1";
+      }>;
+      delimiter: z.ZodEnum<{
+        tab: "tab";
+        comma: "comma";
+        semicolon: "semicolon";
+      }>;
+      skipLines: z.ZodInt;
+      idColumn: z.ZodNullable<z.ZodString>;
+      numericColumns: z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        factor: z.ZodNumber;
+      }, z.core.$strict>>;
     }, z.core.$strict>], "format">;
   }, z.core.$strict>, z.ZodObject<{
     status: z.ZodLiteral<"not-fetchable">;
@@ -338,7 +390,7 @@ declare const EntrySchema: z.ZodObject<{
     id: string;
     name: string;
     tags: string[];
-    category: "graph/v1";
+    category: "graph/v1" | "or/v1";
     sources: {
       url: string;
       retrieved: string;
@@ -400,6 +452,16 @@ declare const EntrySchema: z.ZodObject<{
         commentPrefixes: string[];
         sourceColumn: number;
         targetColumn: number;
+      } | {
+        format: "csv-table";
+        encoding: "utf-8" | "latin1";
+        delimiter: "tab" | "comma" | "semicolon";
+        skipLines: number;
+        idColumn: string | null;
+        numericColumns: {
+          column: string;
+          factor: number;
+        }[];
       } | {
         format: "matrix-market";
         encoding: "utf-8" | "latin1";
@@ -528,6 +590,7 @@ declare const CatalogueIndexSchema: z.ZodObject<{
     tags: z.ZodArray<z.ZodString>;
     category: z.ZodEnum<{
       "graph/v1": "graph/v1";
+      "or/v1": "or/v1";
     }>;
     sources: z.ZodArray<z.ZodObject<{
       url: z.ZodURL;
@@ -620,6 +683,23 @@ declare const CatalogueIndexSchema: z.ZodObject<{
           "utf-8": "utf-8";
           latin1: "latin1";
         }>;
+      }, z.core.$strict>, z.ZodObject<{
+        format: z.ZodLiteral<"csv-table">;
+        encoding: z.ZodEnum<{
+          "utf-8": "utf-8";
+          latin1: "latin1";
+        }>;
+        delimiter: z.ZodEnum<{
+          tab: "tab";
+          comma: "comma";
+          semicolon: "semicolon";
+        }>;
+        skipLines: z.ZodInt;
+        idColumn: z.ZodNullable<z.ZodString>;
+        numericColumns: z.ZodArray<z.ZodObject<{
+          column: z.ZodString;
+          factor: z.ZodNumber;
+        }, z.core.$strict>>;
       }, z.core.$strict>], "format">;
     }, z.core.$strict>, z.ZodObject<{
       status: z.ZodLiteral<"not-fetchable">;
@@ -637,7 +717,7 @@ declare const CatalogueIndexSchema: z.ZodObject<{
       id: string;
       name: string;
       tags: string[];
-      category: "graph/v1";
+      category: "graph/v1" | "or/v1";
       sources: {
         url: string;
         retrieved: string;
@@ -699,6 +779,16 @@ declare const CatalogueIndexSchema: z.ZodObject<{
           commentPrefixes: string[];
           sourceColumn: number;
           targetColumn: number;
+        } | {
+          format: "csv-table";
+          encoding: "utf-8" | "latin1";
+          delimiter: "tab" | "comma" | "semicolon";
+          skipLines: number;
+          idColumn: string | null;
+          numericColumns: {
+            column: string;
+            factor: number;
+          }[];
         } | {
           format: "matrix-market";
           encoding: "utf-8" | "latin1";
@@ -744,7 +834,7 @@ declare const CatalogueIndexSchema: z.ZodObject<{
       id: string;
       name: string;
       tags: string[];
-      category: "graph/v1";
+      category: "graph/v1" | "or/v1";
       sources: {
         url: string;
         retrieved: string;
@@ -806,6 +896,16 @@ declare const CatalogueIndexSchema: z.ZodObject<{
           commentPrefixes: string[];
           sourceColumn: number;
           targetColumn: number;
+        } | {
+          format: "csv-table";
+          encoding: "utf-8" | "latin1";
+          delimiter: "tab" | "comma" | "semicolon";
+          skipLines: number;
+          idColumn: string | null;
+          numericColumns: {
+            column: string;
+            factor: number;
+          }[];
         } | {
           format: "matrix-market";
           encoding: "utf-8" | "latin1";
@@ -892,9 +992,6 @@ interface 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;
@@ -940,27 +1037,100 @@ declare const GraphV1Schema: z.ZodObject<{
 };
 type GraphV1 = z.infer<typeof GraphV1Schema>;
 //#endregion
+//#region src/targets/or-v1.d.ts
+/**
+ * A node of an operations-research instance: a place or case a route may visit, flat so a twindex crosswalk can map a table's columns onto it (a wildcard path must keep the same shape on both sides). The target fixes only what the datasets share and lets a crosswalk map any further column through under its own name, as graph/v1 does. `lat` and `lon` are WGS84 degrees and `x` and `y` are planar coordinates in the dataset's own system; `duration` and `travelTime` are seconds, `prize` is the dataset's own reward measure, and `prizeProbability` is the chance the reward is collected. `skill` and `territory` name what is needed to serve the node and where it sits, `status` is where it is in its lifecycle, and `opened`, `closed` and `deadline` are its lifecycle times as the source writes them, a deadline being a number where the source gives a time of day.
+ */
+declare const OrNodeSchema: z.ZodObject<{
+  id: z.ZodString;
+  lat: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  lon: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  x: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  y: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  prize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  prizeProbability: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  travelTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  skill: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  territory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  opened: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  closed: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  deadline: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$loose>;
+type OrNode = z.infer<typeof OrNodeSchema>;
+/**
+ * The or/v1 normalisation target: `{ meta, nodes }`, an operations-research instance as the nodes it offers to visit. It describes the result `fetchDataset` resolves an entry to, not what a source file may contain. Beyond the field shapes it checks that node ids are unique. It has no arcs: a source that carries a travel matrix or arc list keeps it out of this version.
+ */
+declare const OrV1Schema: 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;
+    lat: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    lon: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    x: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    y: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    prize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    prizeProbability: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    travelTime: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    skill: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    territory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    opened: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    closed: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    deadline: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  }, z.core.$loose>>;
+}, z.core.$strict> & {
+  is: (value: unknown) => value is {
+    meta: Record<string, string | number | boolean | null>;
+    nodes: {
+      [x: string]: unknown;
+      id: string;
+      lat?: number | null | undefined;
+      lon?: number | null | undefined;
+      x?: number | null | undefined;
+      y?: number | null | undefined;
+      prize?: number | null | undefined;
+      prizeProbability?: number | null | undefined;
+      duration?: number | null | undefined;
+      travelTime?: number | null | undefined;
+      skill?: string | null | undefined;
+      territory?: string | null | undefined;
+      status?: string | null | undefined;
+      opened?: string | null | undefined;
+      closed?: string | null | undefined;
+      deadline?: string | number | null | undefined;
+    }[];
+  };
+};
+type OrV1 = z.infer<typeof OrV1Schema>;
+//#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";
+  "or/v1": "or/v1";
 }>;
 type CategoryId = z.infer<typeof CategoryIdSchema>;
 /** The normalisation target each category resolves to, keyed by category id. */
 interface CategoryTargets {
   readonly "graph/v1": GraphV1;
+  readonly "or/v1": OrV1;
 }
 /** 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> {
+interface CategoryOf<Id extends CategoryId> {
   readonly id: Id;
   readonly description: string;
   readonly target: z.ZodType<CategoryTargets[Id]>;
   readonly counted: readonly CountedKey<CategoryTargets[Id]>[];
 }
+/** A category, or with no argument any of them: a union over the ids, so each category keeps its own target and counted keys. */
+type Category<Id extends CategoryId = CategoryId> = Id extends CategoryId ? CategoryOf<Id> : never;
 /**
  * Looks up a category by id.
  * @param id - Any string; category ids usually come from entry documents, so the argument is untrusted.
@@ -993,4 +1163,4 @@ declare function listCategories(): readonly Category[];
  */
 declare function countTarget(id: CategoryId, target: CategoryTarget): ReadonlyMap<string, number>;
 //#endregion
-export { Recipe as $, ManifestSchema as A, CrosswalkReference as B, Dataset as C, Lineage as D, createCatalogue as E, ArchiveMember as F, IdSchema as G, Entry as H, ArchiveMemberSchema as I, Namespace as J, Licence as K, ArchiveSchema as L, parseManifest as M, AliasSchema as N, LineageSchema as O, Archive as P, RESERVED_META_KEYS as Q, Citation as R, CatalogueIndexSchema as S, NamespaceNode as T, EntrySchema as U, CrosswalkReferenceSchema as V, HttpUrlSchema as W, Parser as X, NamespaceSchema as Y, ParserSchema as Z, GraphV1Schema as _, CategoryTargets as a, SourceSchema as at, Catalogue as b, getCategory as c, waybackUrl as ct, listCategories as d, RecipeSchema as et, GraphEdge as f, GraphV1 as g, GraphNodeSchema as h, CategoryTarget as i, Source as it, SemVerSchema as j, Manifest as k, getTarget as l, GraphNode as m, CategoryId as n, Snapshot as nt, CountedKey as o, WaybackTimestampSchema as ot, GraphEdgeSchema as p, LicenceSchema as q, CategoryIdSchema as r, SnapshotSchema as rt, countTarget as s, parseEntry as st, Category as t, RelativePathSchema as tt, kindOf as u, JsonScalar as v, DatasetQuery as w, CatalogueIndex as x, JsonScalarSchema as y, CitationSchema as z };
+export { ParserSchema as $, LineageSchema as A, Citation as B, CatalogueIndex as C, NamespaceNode as D, DatasetQuery as E, AliasSchema as F, EntrySchema as G, CrosswalkReference as H, Archive as I, Licence as J, HttpUrlSchema as K, ArchiveMember as L, ManifestSchema as M, SemVerSchema as N, createCatalogue as O, parseManifest as P, Parser as Q, ArchiveMemberSchema as R, Catalogue as S, Dataset as T, CrosswalkReferenceSchema as U, CitationSchema as V, Entry as W, Namespace as X, LicenceSchema as Y, NamespaceSchema as Z, GraphEdgeSchema as _, CategoryTargets as a, SnapshotSchema as at, GraphV1 as b, getCategory as c, WaybackTimestampSchema as ct, listCategories as d, RESERVED_META_KEYS as et, OrNode as f, GraphEdge as g, OrV1Schema as h, CategoryTarget as i, Snapshot as it, Manifest as j, Lineage as k, getTarget as l, parseEntry as lt, OrV1 as m, CategoryId as n, RecipeSchema as nt, CountedKey as o, Source as ot, OrNodeSchema as p, IdSchema as q, CategoryIdSchema as r, RelativePathSchema as rt, countTarget as s, SourceSchema as st, Category as t, Recipe as tt, kindOf as u, waybackUrl as ut, GraphNode as v, CatalogueIndexSchema as w, GraphV1Schema as x, GraphNodeSchema as y, ArchiveSchema as z };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { $ as Recipe, A as ManifestSchema, B as CrosswalkReference, C as Dataset, D as Lineage, E as createCatalogue, F as ArchiveMember, G as IdSchema, H as Entry, I as ArchiveMemberSchema, J as Namespace, K as Licence, L as ArchiveSchema, M as parseManifest, N as AliasSchema, O as LineageSchema, P as Archive, Q as RESERVED_META_KEYS, R as Citation, S as CatalogueIndexSchema, T as NamespaceNode, U as EntrySchema, V as CrosswalkReferenceSchema, W as HttpUrlSchema, X as Parser, Y as NamespaceSchema, Z as ParserSchema, _ as GraphV1Schema, a as CategoryTargets, at as SourceSchema, b as Catalogue, c as getCategory, ct as waybackUrl, d as listCategories, et as RecipeSchema, f as GraphEdge, g as GraphV1, h as GraphNodeSchema, i as CategoryTarget, it as Source, j as SemVerSchema, k as Manifest, l as getTarget, m as GraphNode, n as CategoryId, nt as Snapshot, o as CountedKey, ot as WaybackTimestampSchema, p as GraphEdgeSchema, q as LicenceSchema, r as CategoryIdSchema, rt as SnapshotSchema, s as countTarget, st as parseEntry, t as Category, tt as RelativePathSchema, u as kindOf, v as JsonScalar, w as DatasetQuery, x as CatalogueIndex, y as JsonScalarSchema, z as CitationSchema } from "./categories-DzjLQ_fp.js";
+import { $ as ParserSchema, A as LineageSchema, B as Citation, C as CatalogueIndex, D as NamespaceNode, E as DatasetQuery, F as AliasSchema, G as EntrySchema, H as CrosswalkReference, I as Archive, J as Licence, K as HttpUrlSchema, L as ArchiveMember, M as ManifestSchema, N as SemVerSchema, O as createCatalogue, P as parseManifest, Q as Parser, R as ArchiveMemberSchema, S as Catalogue, T as Dataset, U as CrosswalkReferenceSchema, V as CitationSchema, W as Entry, X as Namespace, Y as LicenceSchema, Z as NamespaceSchema, _ as GraphEdgeSchema, a as CategoryTargets, at as SnapshotSchema, b as GraphV1, c as getCategory, ct as WaybackTimestampSchema, d as listCategories, et as RESERVED_META_KEYS, f as OrNode, g as GraphEdge, h as OrV1Schema, i as CategoryTarget, it as Snapshot, j as Manifest, k as Lineage, l as getTarget, lt as parseEntry, m as OrV1, n as CategoryId, nt as RecipeSchema, o as CountedKey, ot as Source, p as OrNodeSchema, q as IdSchema, r as CategoryIdSchema, rt as RelativePathSchema, s as countTarget, st as SourceSchema, t as Category, tt as Recipe, u as kindOf, ut as waybackUrl, v as GraphNode, w as CatalogueIndexSchema, x as GraphV1Schema, y as GraphNodeSchema, z as ArchiveSchema } from "./categories-B4hhikbr.js";
 import { Crosswalk } from "twindex";
+import { z } from "zod";
 //#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 {
@@ -109,6 +110,11 @@ export declare function namesOf(entry: Addressed, segmentAliases?: SegmentAliase
  */
 export declare function serialise(doc: Entry | Manifest | Crosswalk): string;
 //#endregion
+//#region src/targets/json-scalar.d.ts
+/** A JSON scalar: the only values a target's 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>;
+//#endregion
 //#region src/validate.d.ts
 /**
  * Checks a dataset as the catalogue holds it: the entry against the entry schema, and its crosswalk against twindex's structural validation and the entry's category. A catalogue index is checked the same way when it is built, so a bundled dataset is valid unless the package itself is broken; the check is what a contributor runs on an entry they are writing.
@@ -117,4 +123,4 @@ export declare function serialise(doc: Entry | Manifest | Crosswalk): string;
  */
 export declare function validateDataset(dataset: Dataset): SyntaxIssue[];
 //#endregion
-export { AliasSchema, 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, type EntryNames, 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 Namespace, type NamespaceNode, NamespaceSchema, type Parser, ParserSchema, RESERVED_META_KEYS, type Recipe, RecipeSchema, type RecipeStep, RelativePathSchema, type SegmentAliases, SemVerSchema, type Snapshot, SnapshotSchema, type Source, SourceSchema, type SyntaxIssue, WaybackTimestampSchema, countTarget, createCatalogue, getCategory, getTarget, kindOf, listCategories, parseEntry, parseManifest, waybackUrl };
+export { AliasSchema, 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, type EntryNames, EntrySchema, type GraphEdge, GraphEdgeSchema, type GraphNode, GraphNodeSchema, type GraphV1, GraphV1Schema, HttpUrlSchema, IdSchema, type JsonScalar, type Licence, LicenceSchema, type Lineage, LineageSchema, type Manifest, ManifestSchema, type Namespace, type NamespaceNode, NamespaceSchema, type OrNode, OrNodeSchema, type OrV1, OrV1Schema, type Parser, ParserSchema, RESERVED_META_KEYS, type Recipe, RecipeSchema, type RecipeStep, RelativePathSchema, type SegmentAliases, SemVerSchema, type Snapshot, SnapshotSchema, type Source, SourceSchema, type SyntaxIssue, WaybackTimestampSchema, countTarget, createCatalogue, getCategory, getTarget, kindOf, listCategories, parseEntry, parseManifest, waybackUrl };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as waybackUrl, B as listCategories, C as RecipeSchema, D as WaybackTimestampSchema, E as SourceSchema, F as CategoryIdSchema, G as ArchiveError, H as GraphNodeSchema, I as countTarget, J as DatasetNotFoundError, K as CatalogueSyntaxError, L as getCategory, M as groupsOf, N as namesOf, O as parseEntry, Q as UnknownCategoryError, R as getTarget, S as RESERVED_META_KEYS, T as SnapshotSchema, U as GraphV1Schema, V as GraphEdgeSchema, W as JsonScalarSchema, X as NativeParseError, Y as KeepsetError, Z as RecipeError, _ as HttpUrlSchema, a as CatalogueIndexSchema, b as NamespaceSchema, c as ManifestSchema, d as AliasSchema, f as ArchiveMemberSchema, g as EntrySchema, h as CrosswalkReferenceSchema, i as listNamespaces, j as NAME_SEPARATOR, k as toIssues, l as SemVerSchema, m as CitationSchema, n as getManifest, o as createCatalogue, p as ArchiveSchema, q as DatasetAmbiguousError, r as listDatasets, s as LineageSchema, t as getDataset, u as parseManifest, v as IdSchema, w as RelativePathSchema, x as ParserSchema, y as LicenceSchema, z as kindOf } from "./bundled-DNLiwEcd.js";
+import { $ as RecipeError, A as waybackUrl, B as listCategories, C as RecipeSchema, D as WaybackTimestampSchema, E as SourceSchema, F as CategoryIdSchema, G as GraphV1Schema, H as OrV1Schema, I as countTarget, J as CatalogueSyntaxError, K as JsonScalarSchema, L as getCategory, M as groupsOf, N as namesOf, O as parseEntry, Q as NativeParseError, R as getTarget, S as RESERVED_META_KEYS, T as SnapshotSchema, U as GraphEdgeSchema, V as OrNodeSchema, W as GraphNodeSchema, X as DatasetNotFoundError, Y as DatasetAmbiguousError, Z as KeepsetError, _ as HttpUrlSchema, a as CatalogueIndexSchema, b as NamespaceSchema, c as ManifestSchema, d as AliasSchema, et as UnknownCategoryError, f as ArchiveMemberSchema, g as EntrySchema, h as CrosswalkReferenceSchema, i as listNamespaces, j as NAME_SEPARATOR, k as toIssues, l as SemVerSchema, m as CitationSchema, n as getManifest, o as createCatalogue, p as ArchiveSchema, q as ArchiveError, r as listDatasets, s as LineageSchema, t as getDataset, u as parseManifest, v as IdSchema, w as RelativePathSchema, x as ParserSchema, y as LicenceSchema, z as kindOf } from "./bundled-D9eVvy1i.js";
 import { validateCrosswalk } from "twindex";
 //#region src/serialise.ts
 /**
@@ -57,4 +57,4 @@ function validateDataset(dataset) {
 	return issues;
 }
 //#endregion
-export { AliasSchema, ArchiveError, ArchiveMemberSchema, ArchiveSchema, CatalogueIndexSchema, CatalogueSyntaxError, CategoryIdSchema, CitationSchema, CrosswalkReferenceSchema, DatasetAmbiguousError, DatasetNotFoundError, EntrySchema, GraphEdgeSchema, GraphNodeSchema, GraphV1Schema, HttpUrlSchema, IdSchema, JsonScalarSchema, KeepsetError, LicenceSchema, LineageSchema, ManifestSchema, NAME_SEPARATOR, NamespaceSchema, NativeParseError, ParserSchema, RESERVED_META_KEYS, RecipeError, RecipeSchema, RelativePathSchema, SemVerSchema, SnapshotSchema, SourceSchema, UnknownCategoryError, WaybackTimestampSchema, countTarget, createCatalogue, getCategory, getDataset, getManifest, getTarget, groupsOf, kindOf, listCategories, listDatasets, listNamespaces, namesOf, parseEntry, parseManifest, serialise, validateDataset, waybackUrl };
+export { AliasSchema, ArchiveError, ArchiveMemberSchema, ArchiveSchema, CatalogueIndexSchema, CatalogueSyntaxError, CategoryIdSchema, CitationSchema, CrosswalkReferenceSchema, DatasetAmbiguousError, DatasetNotFoundError, EntrySchema, GraphEdgeSchema, GraphNodeSchema, GraphV1Schema, HttpUrlSchema, IdSchema, JsonScalarSchema, KeepsetError, LicenceSchema, LineageSchema, ManifestSchema, NAME_SEPARATOR, NamespaceSchema, NativeParseError, OrNodeSchema, OrV1Schema, ParserSchema, RESERVED_META_KEYS, RecipeError, RecipeSchema, RelativePathSchema, SemVerSchema, SnapshotSchema, SourceSchema, UnknownCategoryError, WaybackTimestampSchema, countTarget, createCatalogue, getCategory, getDataset, getManifest, getTarget, groupsOf, kindOf, listCategories, listDatasets, listNamespaces, namesOf, parseEntry, parseManifest, serialise, validateDataset, waybackUrl };

package/dist/node/fetch-dataset.d.ts

@@ -1,4 +1,4 @@
-import { C as Dataset, H as Entry, i as CategoryTarget, it as Source, nt as Snapshot } from "../categories-DzjLQ_fp.js";
+import { T as Dataset, W as Entry, i as CategoryTarget, it as Snapshot, ot as Source } from "../categories-B4hhikbr.js";
 //#region src/node/fetch-dataset.d.ts
 /** The network port a recipe downloads through: `downloadRaw` by default, which returns the bytes exactly as served, or a stand-in under test. */
 export type FetchPort = (url: string, init: {

package/dist/node/fetch-dataset.js

@@ -1,4 +1,4 @@
-import { G as ArchiveError, I as countTarget, P as getOwn, R as getTarget, X as NativeParseError, Y as KeepsetError, Z as RecipeError, t as getDataset } from "../bundled-DNLiwEcd.js";
+import { $ as RecipeError, I as countTarget, P as getOwn, Q as NativeParseError, R as getTarget, Z as KeepsetError, q as ArchiveError, t as getDataset } from "../bundled-D9eVvy1i.js";
 import { RoundTripMismatchError, assertRoundTrip, encode } from "twindex";
 import { createHash } from "node:crypto";
 import { gunzipSync } from "node:zlib";
@@ -347,6 +347,151 @@ function parseMatrixMarket(text) {
 	};
 }
 //#endregion
+//#region src/parsers/csv-table.ts
+/** The character each delimiter option splits fields on. */
+const DELIMITERS = {
+	comma: ",",
+	tab: "	",
+	semicolon: ";"
+};
+/** A number as a decimal literal, with an optional sign and exponent. `Number` alone would also accept hex, binary, `Infinity` and the empty string. */
+const DECIMAL = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+/** The byte order mark some exporters put before the first header. */
+const BYTE_ORDER_MARK = "";
+/**
+* The name the parser gives a column: the header with every run of characters outside letters, digits and underscore replaced by one underscore, leading and trailing underscores dropped, and a name starting with a digit prefixed with `c_`. The rule depends on the header alone, so a crosswalk written against a file's headers reads the same wherever it runs.
+* @param header - A header cell.
+* @returns The column name, or undefined when nothing of the header is left.
+*/
+function columnName(header) {
+	const name = header.trim().replaceAll(/[^A-Za-z0-9_]+/g, "_").replaceAll(/^_+|_+$/g, "");
+	if (name === "") return;
+	return /^\d/.test(name) ? `c_${name}` : name;
+}
+/**
+* Splits text into records and fields by RFC 4180: a field may be quoted, a quoted field may hold the delimiter, line breaks and doubled quotes, and a record ends at an unquoted LF, CRLF or CR.
+* @param text - The file text, after the lines the recipe skips.
+* @param delimiter - The field delimiter.
+* @param firstLine - The 1-based line of the file the text starts on.
+* @returns The records, blank lines included as a record of one empty field.
+* @throws NativeParseError when a quoted field is never closed or a quote opens inside an unquoted field.
+*/
+function records(text, delimiter, firstLine) {
+	const out = [];
+	let fields = [];
+	let field = "";
+	let quoted = false;
+	let started = firstLine;
+	let line = firstLine;
+	let index = 0;
+	const endRecord = () => {
+		fields.push(field);
+		out.push({
+			line: started,
+			fields
+		});
+		fields = [];
+		field = "";
+		started = line;
+	};
+	while (index < text.length) {
+		const char = text.charAt(index);
+		if (quoted) {
+			if (char === "\"") {
+				if (text.charAt(index + 1) === "\"") {
+					field += "\"";
+					index += 1;
+				} else quoted = false;
+			} else {
+				if (char === "\n") line += 1;
+				field += char;
+			}
+		} else if (char === "\"") {
+			if (field !== "") throw new NativeParseError("csv-table", line, "a quote opens inside an unquoted field");
+			quoted = true;
+		} else if (char === delimiter) {
+			fields.push(field);
+			field = "";
+		} else if (char === "\n" || char === "\r") {
+			if (char === "\r" && text.charAt(index + 1) === "\n") index += 1;
+			line += 1;
+			endRecord();
+		} else field += char;
+		index += 1;
+	}
+	if (quoted) throw new NativeParseError("csv-table", started, "a quoted field is never closed");
+	if (field !== "" || fields.length > 0) endRecord();
+	return out;
+}
+/**
+* Drops the first lines of a file.
+* @param text - The file text.
+* @param count - How many physical lines to drop.
+* @returns The rest of the text.
+* @throws NativeParseError when the file has fewer lines than that.
+*/
+function afterLines(text, count) {
+	let index = 0;
+	for (let dropped = 0; dropped < count; dropped += 1) {
+		const next = text.slice(index).search(/\n/);
+		if (next === -1) throw new NativeParseError("csv-table", dropped + 1, `the file has fewer than ${String(count)} lines to skip before the header`);
+		index += next + 1;
+	}
+	return text.slice(index);
+}
+/**
+* Reads a numeric cell.
+* @param cell - The trimmed cell.
+* @param factor - What the recipe multiplies the value by, to put it in the target's unit.
+* @param column - The column, for the error.
+* @param line - The 1-based line, for the error.
+* @returns The number, or null for an empty cell.
+* @throws NativeParseError when the cell is not a decimal number.
+*/
+function numeric$1(cell, factor, column, line) {
+	if (cell === "") return null;
+	if (!DECIMAL.test(cell)) throw new NativeParseError("csv-table", line, `column ${column} is declared numeric but holds ${JSON.stringify(cell)}`);
+	return Number(cell) * factor;
+}
+/**
+* Parses a delimited table into rows: the first record after `skipLines` lines is the header, each later record is a row, and every row carries every column but the id column, an empty cell being null. Cells are trimmed. A column the recipe declares numeric is read as a decimal number times its factor and any other column stays a string. A row's id is the cell of the recipe's id column, which is then not also a column, or its 1-based row number when the recipe names none. Blank lines are skipped; a row with a different number of fields than the header, a header cell with no name, two columns with the same name, and an id cell that is empty are errors.
+* @param text - The file text.
+* @param options - The recipe's table parser.
+* @returns The rows, in file order.
+* @throws NativeParseError naming the line of the first problem.
+*/
+function parseCsvTable(text, options) {
+	const [header, ...rows] = records(afterLines(text.startsWith(BYTE_ORDER_MARK) ? text.slice(1) : text, options.skipLines), DELIMITERS[options.delimiter], options.skipLines + 1).filter((record) => record.fields.length > 1 || record.fields[0]?.trim() !== "");
+	if (header === void 0) throw new NativeParseError("csv-table", options.skipLines + 1, "the file has no header row");
+	const names = [];
+	for (const [position, cell] of header.fields.entries()) {
+		const name = columnName(cell);
+		if (name === void 0) throw new NativeParseError("csv-table", header.line, `header cell ${String(position + 1)} (${JSON.stringify(cell)}) has no name left once its characters other than letters, digits and underscores are removed`);
+		const clash = names.indexOf(name);
+		if (clash !== -1) throw new NativeParseError("csv-table", header.line, `header cells ${String(clash + 1)} and ${String(position + 1)} both become the column ${name}`);
+		names.push(name);
+	}
+	const { idColumn, numericColumns } = options;
+	for (const wanted of [...idColumn === null ? [] : [idColumn], ...numericColumns.map((entry) => entry.column)]) if (!names.includes(wanted)) throw new NativeParseError("csv-table", header.line, `the recipe names the column ${wanted}, which the header does not have`);
+	if (idColumn === null && names.includes("id")) throw new NativeParseError("csv-table", header.line, "the file has a column named id, which would be shadowed by the row number; the recipe names it as its idColumn");
+	const factors = new Map(numericColumns.map((entry) => [entry.column, entry.factor]));
+	return { nodes: rows.map((record, rowIndex) => {
+		if (record.fields.length !== names.length) throw new NativeParseError("csv-table", record.line, `the row has ${String(record.fields.length)} fields, the header has ${String(names.length)}`);
+		const cells = new Map(names.map((name, position) => [name, (record.fields[position] ?? "").trim()]));
+		const id = idColumn === null ? String(rowIndex + 1) : cells.get(idColumn) ?? "";
+		if (id === "") throw new NativeParseError("csv-table", record.line, `the id column ${idColumn ?? ""} is empty`);
+		const columns = names.filter((name) => name !== idColumn).map((name) => {
+			const cell = cells.get(name) ?? "";
+			const factor = factors.get(name);
+			return [name, factor === void 0 ? cell === "" ? null : cell : numeric$1(cell, factor, name, record.line)];
+		});
+		return {
+			...Object.fromEntries(columns),
+			id
+		};
+	}) };
+}
+//#endregion
 //#region src/parsers/pajek.ts
 /** Section keywords, lower-cased, mapped to how their lines are read. `*Network` names the network and starts no section. `*Partition` and `*Vector` hold node attributes this version does not carry, so their lines are skipped, as are the `*Vertices` lines inside them. */
 const sections = /* @__PURE__ */ new Map([
@@ -480,18 +625,12 @@ function decode(bytes, parser) {
 		throw new NativeParseError(parser.format, 1, `the file is not valid utf-8 (${error instanceof Error ? error.message : String(error)}); a recipe for a latin1 file states encoding latin1`);
 	}
 }
-/**
-* Reads a file into the native graph shape with the recipe's parser.
-* @param bytes - The unpacked file.
-* @param parser - The recipe's parser.
-* @returns The native graph.
-* @throws NativeParseError when the bytes are not valid in the stated encoding or the text is not in the stated format.
-*/
 function parseNative(bytes, parser) {
 	const text = decode(bytes, parser);
 	if (parser.format === "edge-list") return parseEdgeList(text, parser);
 	if (parser.format === "matrix-market") return parseMatrixMarket(text);
 	if (parser.format === "gml") return parseGml(text);
+	if (parser.format === "csv-table") return parseCsvTable(text, parser);
 	return parsePajek(text);
 }
 /** The ustar header layout (POSIX.1-1988, pax(1) "ustar Interchange Format"): each field's byte offset and length. */
@@ -856,8 +995,7 @@ async function runToNative(dataset, options) {
 	return {
 		native: {
 			meta: metaOf(entry),
-			nodes: parsed.nodes,
-			edges: parsed.edges
+			...parsed
 		},
 		provenance: {
 			entryId: entry.id,

package/dist-cli/keepset.mjs

@@ -4,7 +4,7 @@ import { KeepsetError, NAME_SEPARATOR, countTarget, getDataset, listDatasets, li
 import { fetchDataset, roundTripDataset } from "keepset/node";
 import { parseArgs } from "node:util";
 //#region package.json
-var version = "0.13.1";
+var version = "0.14.1";
 const usage = `Usage: keepset <command> [options]
 
 Commands:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "keepset",
   "description": "Library, CLI and statically generated catalogue for dataset fetch-and-normalise recipes",
-  "version": "0.13.1",
+  "version": "0.14.1",
   "bin": {
     "keepset": "./dist-cli/keepset.mjs"
   },
@@ -28,7 +28,7 @@
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",
     "@vanilla-extract/esbuild-plugin": "2.3.22",
-    "@vitest/coverage-v8": "5.0.3",
+    "@vitest/coverage-v8": "5.0.4",
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",
     "canonicalize": "5.1.0",
@@ -44,7 +44,7 @@
     "tsx": "4.23.15",
     "typescript": "6.0.3",
     "typescript-eslint": "8.71.1",
-    "vitest": "5.0.3"
+    "vitest": "5.0.4"
   },
   "engines": {
     "node": ">=22"

package/schemas/entry.schema.json

@@ -1 +1 @@
-{"$defs":{"Crosswalk":{"$ref":"https://cdn.jsdelivr.net/npm/twindex@0.1.4/schemas/twindex.schema.json"},"Entry":{"additionalProperties":false,"properties":{"aliases":{"items":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*(?:\\/[A-Za-z0-9][A-Za-z0-9._-]*)*$","type":"string"},"minItems":1,"type":"array"},"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"},"namespace":{"items":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*$","type":"string"},"minItems":1,"type":"array"},"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":{"extensions":{"items":{"pattern":"^\\.[A-Za-z0-9][A-Za-z0-9.]*$","type":"string"},"minItems":1,"type":"array"}},"required":["extensions"],"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":{"extensions":{"items":{"pattern":"^\\.[A-Za-z0-9][A-Za-z0-9.]*$","type":"string"},"minItems":1,"type":"array"}},"required":["extensions"],"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":{"extensions":{"items":{"pattern":"^\\.[A-Za-z0-9][A-Za-z0-9.]*$","type":"string"},"minItems":1,"type":"array"}},"required":["extensions"],"type":"object"}]}},"required":["kind","member"],"type":"object"}]},"parser":{"oneOf":[{"additionalProperties":false,"properties":{"commentPrefixes":{"items":{"minLength":1,"type":"string"},"type":"array"},"delimiter":{"enum":["detect","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.13.1/schemas/entry.schema.json","$ref":"#/$defs/Entry","$schema":"https://json-schema.org/draft/2020-12/schema"}
+{"$defs":{"Crosswalk":{"$ref":"https://cdn.jsdelivr.net/npm/twindex@0.1.4/schemas/twindex.schema.json"},"Entry":{"additionalProperties":false,"properties":{"aliases":{"items":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*(?:\\/[A-Za-z0-9][A-Za-z0-9._-]*)*$","type":"string"},"minItems":1,"type":"array"},"category":{"enum":["graph/v1","or/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"},"namespace":{"items":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*$","type":"string"},"minItems":1,"type":"array"},"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":{"extensions":{"items":{"pattern":"^\\.[A-Za-z0-9][A-Za-z0-9.]*$","type":"string"},"minItems":1,"type":"array"}},"required":["extensions"],"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":{"extensions":{"items":{"pattern":"^\\.[A-Za-z0-9][A-Za-z0-9.]*$","type":"string"},"minItems":1,"type":"array"}},"required":["extensions"],"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":{"extensions":{"items":{"pattern":"^\\.[A-Za-z0-9][A-Za-z0-9.]*$","type":"string"},"minItems":1,"type":"array"}},"required":["extensions"],"type":"object"}]}},"required":["kind","member"],"type":"object"}]},"parser":{"oneOf":[{"additionalProperties":false,"properties":{"commentPrefixes":{"items":{"minLength":1,"type":"string"},"type":"array"},"delimiter":{"enum":["detect","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"},{"additionalProperties":false,"properties":{"delimiter":{"enum":["comma","tab","semicolon"],"type":"string"},"encoding":{"enum":["utf-8","latin1"],"type":"string"},"format":{"const":"csv-table","type":"string"},"idColumn":{"anyOf":[{"pattern":"^[A-Za-z](?:[A-Za-z0-9_]*[A-Za-z0-9])?$","type":"string"},{"type":"null"}]},"numericColumns":{"items":{"additionalProperties":false,"properties":{"column":{"pattern":"^[A-Za-z](?:[A-Za-z0-9_]*[A-Za-z0-9])?$","type":"string"},"factor":{"exclusiveMinimum":0,"type":"number"}},"required":["column","factor"],"type":"object"},"type":"array"},"skipLines":{"maximum":9007199254740991,"minimum":0,"type":"integer"}},"required":["format","encoding","delimiter","skipLines","idColumn","numericColumns"],"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.14.1/schemas/entry.schema.json","$ref":"#/$defs/Entry","$schema":"https://json-schema.org/draft/2020-12/schema"}

package/schemas/manifest.schema.json

@@ -1 +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"},"namespaceAliases":{"additionalProperties":{"items":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*$","type":"string"},"minItems":1,"type":"array"},"propertyNames":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*$","type":"string"},"type":"object"},"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.13.1/schemas/manifest.schema.json","$ref":"#/$defs/Manifest","$schema":"https://json-schema.org/draft/2020-12/schema"}
+{"$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"},"namespaceAliases":{"additionalProperties":{"items":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*$","type":"string"},"minItems":1,"type":"array"},"propertyNames":{"pattern":"^[A-Za-z0-9][A-Za-z0-9._-]*$","type":"string"},"type":"object"},"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.14.1/schemas/manifest.schema.json","$ref":"#/$defs/Manifest","$schema":"https://json-schema.org/draft/2020-12/schema"}