keepset 0.3.0 → 0.5.0

package/dist/{categories-BIZJUKUw.d.ts → categories-CUf1VecC.d.ts}

@@ -57,11 +57,11 @@ declare const CitationSchema: z.ZodObject<{
 type Citation = z.infer<typeof CitationSchema>;
 /** A relative path inside an archive or a catalogue: `/`-separated segments, none empty, `.` or `..`, so it can never climb out of the directory it is resolved against. */
 declare const RelativePathSchema: z.ZodString;
-/** Which file of an archive to read: a member path, matched against a member's whole path or its trailing segments (so `net.gml` finds `net/net.gml`), or the member whose name ends with an extension. Either must match exactly one member when the recipe runs; macOS resource-fork members (`__MACOSX/` and `._` files) never match. */
+/** 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 one of a list of extensions (a format can have several, such as Pajek's `.net` and `.paj`). Either must match exactly one member when the recipe runs; macOS resource-fork members (`__MACOSX/` and `._` files) never match. */
 declare const ArchiveMemberSchema: z.ZodUnion<readonly [z.ZodObject<{
   path: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
-  extension: z.ZodString;
+  extensions: z.ZodArray<z.ZodString>;
 }, z.core.$strict>]>;
 type ArchiveMember = z.infer<typeof ArchiveMemberSchema>;
 /** How the downloaded bytes unpack into the one file the parser reads. */
@@ -74,21 +74,21 @@ declare const ArchiveSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   member: z.ZodUnion<readonly [z.ZodObject<{
     path: z.ZodString;
   }, z.core.$strict>, z.ZodObject<{
-    extension: z.ZodString;
+    extensions: z.ZodArray<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;
+    extensions: z.ZodArray<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;
+    extensions: z.ZodArray<z.ZodString>;
   }, z.core.$strict>]>;
 }, z.core.$strict>], "kind">;
 type Archive = z.infer<typeof ArchiveSchema>;
@@ -143,21 +143,21 @@ declare const RecipeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     member: z.ZodUnion<readonly [z.ZodObject<{
       path: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
-      extension: z.ZodString;
+      extensions: z.ZodArray<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;
+      extensions: z.ZodArray<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;
+      extensions: z.ZodArray<z.ZodString>;
     }, z.core.$strict>]>;
   }, z.core.$strict>], "kind">;
   parser: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -261,21 +261,21 @@ declare const EntrySchema: z.ZodObject<{
       member: z.ZodUnion<readonly [z.ZodObject<{
         path: z.ZodString;
       }, z.core.$strict>, z.ZodObject<{
-        extension: z.ZodString;
+        extensions: z.ZodArray<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;
+        extensions: z.ZodArray<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;
+        extensions: z.ZodArray<z.ZodString>;
       }, z.core.$strict>]>;
     }, z.core.$strict>], "kind">;
     parser: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -367,21 +367,21 @@ declare const EntrySchema: z.ZodObject<{
         member: {
           path: string;
         } | {
-          extension: string;
+          extensions: string[];
         };
       } | {
         kind: "tar";
         member: {
           path: string;
         } | {
-          extension: string;
+          extensions: string[];
         };
       } | {
         kind: "tar.gz";
         member: {
           path: string;
         } | {
-          extension: string;
+          extensions: string[];
         };
       };
       parser: {
@@ -552,21 +552,21 @@ declare const CatalogueIndexSchema: z.ZodObject<{
         member: z.ZodUnion<readonly [z.ZodObject<{
           path: z.ZodString;
         }, z.core.$strict>, z.ZodObject<{
-          extension: z.ZodString;
+          extensions: z.ZodArray<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;
+          extensions: z.ZodArray<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;
+          extensions: z.ZodArray<z.ZodString>;
         }, z.core.$strict>]>;
       }, z.core.$strict>], "kind">;
       parser: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -658,21 +658,21 @@ declare const CatalogueIndexSchema: z.ZodObject<{
           member: {
             path: string;
           } | {
-            extension: string;
+            extensions: string[];
           };
         } | {
           kind: "tar";
           member: {
             path: string;
           } | {
-            extension: string;
+            extensions: string[];
           };
         } | {
           kind: "tar.gz";
           member: {
             path: string;
           } | {
-            extension: string;
+            extensions: string[];
           };
         };
         parser: {
@@ -762,21 +762,21 @@ declare const CatalogueIndexSchema: z.ZodObject<{
           member: {
             path: string;
           } | {
-            extension: string;
+            extensions: string[];
           };
         } | {
           kind: "tar";
           member: {
             path: string;
           } | {
-            extension: string;
+            extensions: string[];
           };
         } | {
           kind: "tar.gz";
           member: {
             path: string;
           } | {
-            extension: string;
+            extensions: string[];
           };
         };
         parser: {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as SnapshotSchema, A as SemVerSchema, B as Entry, C as Dataset, D as LineageSchema, E as Lineage, F as ArchiveSchema, G as LicenceSchema, H as HttpUrlSchema, I as Citation, J as RESERVED_META_KEYS, K as Parser, L as CitationSchema, M as Archive, N as ArchiveMember, O as Manifest, P as ArchiveMemberSchema, Q as Snapshot, R as CrosswalkReference, S as CatalogueIndexSchema, T as createCatalogue, U as IdSchema, V as EntrySchema, W as Licence, X as RecipeSchema, Y as Recipe, Z as RelativePathSchema, _ as GraphV1Schema, a as CategoryTargets, b as Catalogue, c as getCategory, d as listCategories, et as Source, f as GraphEdge, g as GraphV1, h as GraphNodeSchema, i as CategoryTarget, it as waybackUrl, j as parseManifest, k as ManifestSchema, l as getTarget, m as GraphNode, n as CategoryId, nt as WaybackTimestampSchema, o as CountedKey, p as GraphEdgeSchema, q as ParserSchema, r as CategoryIdSchema, rt as parseEntry, s as countTarget, t as Category, tt as SourceSchema, u as kindOf, v as JsonScalar, w as DatasetQuery, x as CatalogueIndex, y as JsonScalarSchema, z as CrosswalkReferenceSchema } from "./categories-BIZJUKUw.js";
+import { $ as SnapshotSchema, A as SemVerSchema, B as Entry, C as Dataset, D as LineageSchema, E as Lineage, F as ArchiveSchema, G as LicenceSchema, H as HttpUrlSchema, I as Citation, J as RESERVED_META_KEYS, K as Parser, L as CitationSchema, M as Archive, N as ArchiveMember, O as Manifest, P as ArchiveMemberSchema, Q as Snapshot, R as CrosswalkReference, S as CatalogueIndexSchema, T as createCatalogue, U as IdSchema, V as EntrySchema, W as Licence, X as RecipeSchema, Y as Recipe, Z as RelativePathSchema, _ as GraphV1Schema, a as CategoryTargets, b as Catalogue, c as getCategory, d as listCategories, et as Source, f as GraphEdge, g as GraphV1, h as GraphNodeSchema, i as CategoryTarget, it as waybackUrl, j as parseManifest, k as ManifestSchema, l as getTarget, m as GraphNode, n as CategoryId, nt as WaybackTimestampSchema, o as CountedKey, p as GraphEdgeSchema, q as ParserSchema, r as CategoryIdSchema, rt as parseEntry, s as countTarget, t as Category, tt as SourceSchema, u as kindOf, v as JsonScalar, w as DatasetQuery, x as CatalogueIndex, y as JsonScalarSchema, z as CrosswalkReferenceSchema } from "./categories-CUf1VecC.js";
 import { Crosswalk } from "twindex";
 //#region src/errors.d.ts
 /** The root of this package's error taxonomy: every error keepset throws is a `KeepsetError`, so callers can catch the family with one check. */
@@ -69,4 +69,12 @@ export declare function getManifest(): Manifest;
  */
 export declare function serialise(doc: Entry | Manifest | Crosswalk): string;
 //#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.
+ * @param dataset - The dataset.
+ * @returns Every issue found, with paths from the dataset's root (`entry.` or `crosswalk.`); empty when the dataset is valid.
+ */
+export declare function validateDataset(dataset: Dataset): SyntaxIssue[];
+//#endregion
 export { type Archive, type ArchiveMember, ArchiveMemberSchema, ArchiveSchema, type Catalogue, type CatalogueIndex, CatalogueIndexSchema, type Category, type CategoryId, CategoryIdSchema, type CategoryTarget, type CategoryTargets, type Citation, CitationSchema, type CountedKey, type CrosswalkReference, CrosswalkReferenceSchema, type Dataset, type DatasetQuery, type Entry, EntrySchema, type GraphEdge, GraphEdgeSchema, type GraphNode, GraphNodeSchema, type GraphV1, GraphV1Schema, HttpUrlSchema, IdSchema, type JsonScalar, JsonScalarSchema, type Licence, LicenceSchema, type Lineage, LineageSchema, type Manifest, ManifestSchema, type Parser, ParserSchema, RESERVED_META_KEYS, type Recipe, RecipeSchema, type RecipeStep, RelativePathSchema, SemVerSchema, type Snapshot, SnapshotSchema, type Source, SourceSchema, type SyntaxIssue, WaybackTimestampSchema, countTarget, createCatalogue, getCategory, getTarget, kindOf, listCategories, parseEntry, parseManifest, waybackUrl };

package/dist/index.js

@@ -1,4 +1,5 @@
-import { A as getCategory, B as DatasetNotFoundError, C as SnapshotSchema, D as waybackUrl, E as parseEntry, F as GraphNodeSchema, H as NativeParseError, I as GraphV1Schema, L as JsonScalarSchema, M as kindOf, N as listCategories, O as CategoryIdSchema, P as GraphEdgeSchema, R as ArchiveError, S as RelativePathSchema, T as WaybackTimestampSchema, U as RecipeError, V as KeepsetError, W as UnknownCategoryError, _ as IdSchema, a as createCatalogue, b as RESERVED_META_KEYS, c as ManifestSchema, d as ArchiveMemberSchema, f as ArchiveSchema, g as HttpUrlSchema, h as EntrySchema, i as CatalogueIndexSchema, j as getTarget, k as countTarget, l as SemVerSchema, m as CrosswalkReferenceSchema, n as getManifest, p as CitationSchema, r as listDatasets, s as LineageSchema, t as getDataset, u as parseManifest, v as LicenceSchema, w as SourceSchema, x as RecipeSchema, y as ParserSchema, z as CatalogueSyntaxError } from "./bundled--fOitQlP.js";
+import { A as countTarget, B as CatalogueSyntaxError, C as SnapshotSchema, D as toIssues, E as parseEntry, F as GraphEdgeSchema, G as UnknownCategoryError, H as KeepsetError, I as GraphNodeSchema, L as GraphV1Schema, M as getTarget, N as kindOf, O as waybackUrl, P as listCategories, R as JsonScalarSchema, S as RelativePathSchema, T as WaybackTimestampSchema, U as NativeParseError, V as DatasetNotFoundError, W as RecipeError, _ as IdSchema, a as createCatalogue, b as RESERVED_META_KEYS, c as ManifestSchema, d as ArchiveMemberSchema, f as ArchiveSchema, g as HttpUrlSchema, h as EntrySchema, i as CatalogueIndexSchema, j as getCategory, k as CategoryIdSchema, l as SemVerSchema, m as CrosswalkReferenceSchema, n as getManifest, p as CitationSchema, r as listDatasets, s as LineageSchema, t as getDataset, u as parseManifest, v as LicenceSchema, w as SourceSchema, x as RecipeSchema, y as ParserSchema, z as ArchiveError } from "./bundled-P_132GDn.js";
+import { validateCrosswalk } from "twindex";
 //#region src/serialise.ts
 /**
 * Copies a JSON value with every object's keys in ascending code-unit order, the order the house JSON lint (`json/sort-keys`) requires of committed JSON. `Object.fromEntries` defines each key as an own data property, so a key such as `__proto__` stays a key.
@@ -11,12 +12,49 @@ function sortKeys(value) {
 	return value;
 }
 /**
+* Serialises any JSON value in the committed form: two-space indented, keys in ascending order, with a trailing newline.
+* @param value - A JSON value.
+* @returns The file text.
+*/
+function canonicalJson(value) {
+	return `${JSON.stringify(sortKeys(value), void 0, 2)}\n`;
+}
+/**
 * Serialises a catalogue document (an entry, a manifest or a crosswalk file) as its file holds it: two-space indented JSON with keys in ascending order and a trailing newline. The form depends only on the document's content, so parsing a file written this way and serialising the result reproduces the file byte for byte.
 * @param doc - A parsed entry, manifest or crosswalk.
 * @returns The file text.
 */
 function serialise(doc) {
-	return `${JSON.stringify(sortKeys(doc), void 0, 2)}\n`;
+	return canonicalJson(doc);
+}
+//#endregion
+//#region src/validate.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.
+* @param dataset - The dataset.
+* @returns Every issue found, with paths from the dataset's root (`entry.` or `crosswalk.`); empty when the dataset is valid.
+*/
+function validateDataset(dataset) {
+	const issues = [];
+	const entry = EntrySchema.safeParse(dataset.entry);
+	if (!entry.success) issues.push(...toIssues(entry.error).map((issue) => ({
+		path: `entry.${issue.path}`,
+		message: issue.message
+	})));
+	const { rules, oneWay } = dataset.crosswalk;
+	for (const issue of validateCrosswalk(dataset.crosswalk)) {
+		const { ruleIndex } = issue;
+		const path = ruleIndex >= 0 && ruleIndex < rules.length ? `crosswalk.rules.${String(ruleIndex)}` : ruleIndex >= rules.length && ruleIndex < rules.length + oneWay.length ? `crosswalk.oneWay.${String(ruleIndex - rules.length)}` : "crosswalk";
+		issues.push({
+			path,
+			message: issue.message
+		});
+	}
+	if (dataset.crosswalk.target !== dataset.entry.category) issues.push({
+		path: "crosswalk.target",
+		message: `must be the entry's category, ${dataset.entry.category}`
+	});
+	return issues;
 }
 //#endregion
-export { ArchiveError, ArchiveMemberSchema, ArchiveSchema, CatalogueIndexSchema, CatalogueSyntaxError, CategoryIdSchema, CitationSchema, CrosswalkReferenceSchema, DatasetNotFoundError, EntrySchema, GraphEdgeSchema, GraphNodeSchema, GraphV1Schema, HttpUrlSchema, IdSchema, JsonScalarSchema, KeepsetError, LicenceSchema, LineageSchema, ManifestSchema, NativeParseError, ParserSchema, RESERVED_META_KEYS, RecipeError, RecipeSchema, RelativePathSchema, SemVerSchema, SnapshotSchema, SourceSchema, UnknownCategoryError, WaybackTimestampSchema, countTarget, createCatalogue, getCategory, getDataset, getManifest, getTarget, kindOf, listCategories, listDatasets, parseEntry, parseManifest, serialise, waybackUrl };
+export { ArchiveError, ArchiveMemberSchema, ArchiveSchema, CatalogueIndexSchema, CatalogueSyntaxError, CategoryIdSchema, CitationSchema, CrosswalkReferenceSchema, DatasetNotFoundError, EntrySchema, GraphEdgeSchema, GraphNodeSchema, GraphV1Schema, HttpUrlSchema, IdSchema, JsonScalarSchema, KeepsetError, LicenceSchema, LineageSchema, ManifestSchema, NativeParseError, ParserSchema, RESERVED_META_KEYS, RecipeError, RecipeSchema, RelativePathSchema, SemVerSchema, SnapshotSchema, SourceSchema, UnknownCategoryError, WaybackTimestampSchema, countTarget, createCatalogue, getCategory, getDataset, getManifest, getTarget, kindOf, listCategories, listDatasets, parseEntry, parseManifest, serialise, validateDataset, waybackUrl };

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

@@ -1,6 +1,6 @@
-import { B as Entry, C as Dataset, Q as Snapshot, et as Source, i as CategoryTarget } from "../categories-BIZJUKUw.js";
+import { B as Entry, C as Dataset, Q as Snapshot, et as Source, i as CategoryTarget } from "../categories-CUf1VecC.js";
 //#region src/node/fetch-dataset.d.ts
-/** The network port a recipe downloads through: the platform `fetch`, or a stand-in under test. */
+/** 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: {
   readonly signal?: AbortSignal;
 }) => Promise<Response>;
@@ -48,11 +48,37 @@ export declare function downloadUrl(source: Source): string;
  */
 export declare function fetchEntry(dataset: Dataset, options?: FetchOptions): Promise<FetchedDataset>;
 /**
- * Fetches a dataset of the bundled catalogue by id and resolves it to its category's target shape, so `fetchDataset("cora")` yields graph/v1 `{ meta, nodes, edges }` directly. Node-only: it downloads with the platform `fetch` and unpacks with Node's zlib.
+ * Fetches a dataset of the bundled catalogue by id and resolves it to its category's target shape, so `fetchDataset("cora")` yields graph/v1 `{ meta, nodes, edges }` directly. Node-only: it downloads with Node's http and https clients and unpacks with Node's zlib.
  * @param id - The entry id.
  * @param options - The network port, abort signal and clock.
  * @returns The resolved target with its provenance and any count warnings.
  * @throws DatasetNotFoundError when no entry has that id, and RecipeError naming the entry and the failing step when the recipe fails.
  */
 export declare function fetchDataset(id: string, options?: FetchOptions): Promise<FetchedDataset>;
+/** Whether decoding a dataset's encoded native document gives the native document back, with the provenance of the bytes it was checked on. */
+export type RoundTripReport = {
+  readonly holds: true;
+  readonly provenance: Provenance;
+} | {
+  readonly holds: false;
+  readonly path: string;
+  readonly message: string;
+  readonly provenance: Provenance;
+};
+/**
+ * Checks a dataset's crosswalk on its real data: runs the recipe to the native document, then twindex's `assertRoundTrip`, which encodes it, decodes the result and compares the two over every path the crosswalk promises to preserve.
+ * @param dataset - A dataset from any catalogue.
+ * @param options - The network port, abort signal and clock.
+ * @returns Whether the round trip holds, and where it first differs when it does not.
+ * @throws RecipeError naming the entry and the failing step when the recipe fails before the comparison, or when the crosswalk cannot run.
+ */
+export declare function roundTripEntry(dataset: Dataset, options?: FetchOptions): Promise<RoundTripReport>;
+/**
+ * Runs `roundTripEntry` on a dataset of the bundled catalogue by id.
+ * @param id - The entry id.
+ * @param options - The network port, abort signal and clock.
+ * @returns Whether the round trip holds.
+ * @throws DatasetNotFoundError when no entry has that id, and RecipeError as `roundTripEntry` does.
+ */
+export declare function roundTripDataset(id: string, options?: FetchOptions): Promise<RoundTripReport>;
 //#endregion

package/dist/node/fetch-dataset.js

@@ -1,8 +1,10 @@
-import { H as NativeParseError, R as ArchiveError, U as RecipeError, V as KeepsetError, j as getTarget, k as countTarget, o as getOwn, t as getDataset } from "../bundled--fOitQlP.js";
-import { encode } from "twindex";
+import { A as countTarget, H as KeepsetError, M as getTarget, U as NativeParseError, W as RecipeError, o as getOwn, t as getDataset, z as ArchiveError } from "../bundled-P_132GDn.js";
+import { RoundTripMismatchError, assertRoundTrip, encode } from "twindex";
 import { createHash } from "node:crypto";
 import { gunzipSync } from "node:zlib";
 import { unzipSync } from "fflate";
+import { request } from "node:http";
+import { request as request$1 } from "node:https";
 //#region src/parsers/native.ts
 /**
 * Collects node ids in order of first appearance, so a parser that learns its nodes from its edges emits them deterministically.
@@ -346,8 +348,9 @@ function parseMatrixMarket(text) {
 }
 //#endregion
 //#region src/parsers/pajek.ts
-/** Section keywords, lower-cased, mapped to how their lines are read. `*Partition` and `*Vector` hold node attributes this version does not carry, so their lines are skipped, as are the `*Vertices` lines inside them. */
+/** 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([
+	["*network", "network"],
 	["*vertices", "vertices"],
 	["*arcs", "pairs"],
 	["*edges", "pairs"],
@@ -358,6 +361,18 @@ const sections = /* @__PURE__ */ new Map([
 	["*vector", "attributes"]
 ]);
 /**
+* Resolves a section keyword, which Pajek reads case-insensitively and accepts abbreviated (`*net` for `*Network`, `*vert` for `*Vertices`): an exact keyword first, otherwise the shortest keyword it abbreviates, so `*edge` is `*Edges` rather than `*Edgeslist`.
+* @param keyword - The keyword as written.
+* @returns How its section is read, or undefined for a keyword that abbreviates none.
+*/
+function sectionOf(keyword) {
+	const name = keyword.toLowerCase();
+	const exact = sections.get(name);
+	if (exact !== void 0) return exact;
+	const [shortest] = [...sections.keys()].filter((candidate) => candidate.startsWith(name)).sort((left, right) => left.length - right.length);
+	return shortest === void 0 ? void 0 : sections.get(shortest);
+}
+/**
 * Reads a vertex number, which Pajek numbers from 1 to the declared vertex count.
 * @param token - The token.
 * @param count - The declared vertex count.
@@ -388,14 +403,13 @@ function parsePajek(text) {
 		const tokens = content.split(/\s+/);
 		const [keyword] = tokens;
 		if (keyword?.startsWith("*") === true) {
-			const name = keyword.toLowerCase();
-			if (name === "*network") {
+			const next = sectionOf(keyword);
+			if (next === void 0) throw new NativeParseError("pajek", lineNumber, `unknown section ${keyword}`);
+			if (next === "network") {
 				networks++;
 				if (networks > 1) throw new NativeParseError("pajek", lineNumber, "a project file holding more than one network is not supported");
 				continue;
 			}
-			const next = sections.get(name);
-			if (next === void 0) throw new NativeParseError("pajek", lineNumber, `unknown section ${keyword}`);
 			if (next === "vertices" && section !== "attributes") {
 				if (count !== void 0) throw new NativeParseError("pajek", lineNumber, "a network declares *Vertices twice");
 				const declared = tokens[1];
@@ -616,7 +630,7 @@ function isResourceFork(path) {
 	return path.startsWith("__MACOSX/") || path.split("/").some((segment) => segment.startsWith("._"));
 }
 /**
-* Whether a member path matches a selector: a path selector matches the whole member path or its trailing segments, an extension selector the end of the member's name.
+* Whether a member path matches a selector: a path selector matches the whole member path or its trailing segments, an extensions selector the end of the member's name, ignoring case.
 * @param path - The member path.
 * @param member - The recipe's selector.
 * @returns True on a match.
@@ -624,7 +638,7 @@ function isResourceFork(path) {
 function selects(path, member) {
 	if (isResourceFork(path) || path.endsWith("/")) return false;
 	if ("path" in member) return path === member.path || path.endsWith(`/${member.path}`);
-	return path.toLowerCase().endsWith(member.extension.toLowerCase());
+	return member.extensions.some((extension) => path.toLowerCase().endsWith(extension.toLowerCase()));
 }
 /**
 * Picks the one member a selector matches.
@@ -637,7 +651,7 @@ function pick(paths, member) {
 	const matched = paths.filter((path) => selects(path, member));
 	const [only] = matched;
 	if (matched.length !== 1 || only === void 0) {
-		const wanted = "path" in member ? `member ${member.path}` : `one member ending ${member.extension}`;
+		const wanted = "path" in member ? `member ${member.path}` : `one member ending ${member.extensions.join(" or ")}`;
 		throw new ArchiveError(`expected ${wanted}, found ${String(matched.length)} among: ${paths.join(", ")}`);
 	}
 	return only;
@@ -701,6 +715,82 @@ function unzip(bytes, filter) {
 	}
 }
 //#endregion
+//#region src/node/download.ts
+/** The most redirects one download follows: the Fetch Standard's own limit (https://fetch.spec.whatwg.org/#http-redirect-fetch, step 5). */
+const MAX_REDIRECTS = 20;
+const REDIRECTS = new Set(Object.values({
+	movedPermanently: 301,
+	found: 302,
+	seeOther: 303,
+	temporaryRedirect: 307,
+	permanentRedirect: 308
+}));
+/** What the downloader says it is, so a server operator can tell where the traffic comes from. */
+const USER_AGENT = "keepset (+https://github.com/ExaDev/keepset)";
+/**
+* Sends one GET and resolves with the response head, its body still unread.
+* @param url - The URL.
+* @param signal - Aborts the request.
+* @returns The response.
+*/
+async function get(url, signal) {
+	const send = url.protocol === "https:" ? request$1 : request;
+	return new Promise((resolve, reject) => {
+		const request = send(url, {
+			method: "GET",
+			headers: { "user-agent": USER_AGENT },
+			...signal === void 0 ? {} : { signal }
+		}, resolve);
+		request.on("error", reject);
+		request.end();
+	});
+}
+/**
+* Reads a response body to the end.
+* @param response - The response.
+* @returns The body's bytes.
+*/
+async function readBody(response) {
+	const chunks = [];
+	for await (const chunk of response) {
+		if (!(chunk instanceof Uint8Array)) throw new KeepsetError("the response body yielded a chunk that is not bytes");
+		chunks.push(chunk);
+	}
+	return Buffer.concat(chunks);
+}
+/**
+* Requests one URL, following its redirects by recursion.
+* @param url - The URL to request.
+* @param signal - Aborts the request.
+* @param redirects - How many redirects led here.
+* @returns The final response.
+*/
+async function follow(url, signal, redirects) {
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new KeepsetError(`${url.href} is not an http or https URL`);
+	const response = await get(url, signal);
+	const { statusCode: status, statusMessage } = response;
+	if (status === void 0 || statusMessage === void 0) throw new KeepsetError(`${url.href} answered without a status line`);
+	if (!REDIRECTS.has(status)) return new Response(await readBody(response), {
+		status,
+		statusText: statusMessage
+	});
+	response.resume();
+	const { location } = response.headers;
+	if (location === void 0) throw new KeepsetError(`${url.href} answered ${String(status)} without a location`);
+	if (redirects === MAX_REDIRECTS) throw new KeepsetError(`${url.href} redirected more than ${String(MAX_REDIRECTS)} times`);
+	return follow(new URL(location, url), signal, redirects + 1);
+}
+/**
+* Downloads a URL's bytes exactly as the server sends them, following redirects. Unlike the platform `fetch`, it never undoes a `Content-Encoding`: servers commonly label a `.gz` file `Content-Encoding: gzip`, and a recipe that unpacks gzip needs the file as published, which is also what its SHA-256 is recorded over. No `Accept-Encoding` is sent, so a server that compresses on the fly has no reason to.
+* @param url - An http or https URL.
+* @param init - The request options.
+* @returns A Response holding the raw bytes, with the final status.
+* @throws KeepsetError when a redirect has no location, leaves http and https, or passes the redirect limit.
+*/
+async function downloadRaw(url, init) {
+	return follow(new URL(url), init.signal, 0);
+}
+//#endregion
 //#region src/node/fetch-dataset.ts
 /**
 * The URL a recipe downloads a source from. A dead source is fetched from its pinned snapshot in the Wayback Machine's `id_` form, which serves the archived bytes as they were captured rather than wrapped in the archive's page chrome.
@@ -742,15 +832,14 @@ function metaOf(entry) {
 	};
 }
 /**
-* Runs a dataset's recipe: downloads the source (from its pinned snapshot when the source is dead), unpacks the archive, parses the native shape, applies the twindex crosswalk and validates the result against the category target. The native document the crosswalk receives is the parser's output with `meta` built from the entry.
-* @param dataset - A dataset from any catalogue.
+* Runs a recipe's download, extract and parse steps, and builds the native document the crosswalk receives: the parser's output with `meta` built from the entry.
+* @param dataset - The dataset.
 * @param options - The network port, abort signal and clock.
-* @returns The resolved target with its provenance and any count warnings.
-* @throws RecipeError naming the entry and the failing step; nothing partial or default-shaped is ever returned.
+* @returns The native document and the provenance of its bytes.
 */
-async function fetchEntry(dataset, options = {}) {
-	const { entry, crosswalk } = dataset;
-	const { fetch: fetchPort = globalThis.fetch, signal, now = () => /* @__PURE__ */ new Date() } = options;
+async function runToNative(dataset, options) {
+	const { entry } = dataset;
+	const { fetch: fetchPort = downloadRaw, signal, now = () => /* @__PURE__ */ new Date() } = options;
 	const { recipe } = entry;
 	if (recipe.status === "not-fetchable") throw new RecipeError(entry.id, "recipe", `the entry has no fetchable recipe: ${recipe.reason}`);
 	const source = entry.sources[recipe.source];
@@ -763,22 +852,13 @@ async function fetchEntry(dataset, options = {}) {
 		return new Uint8Array(await response.arrayBuffer());
 	});
 	const unpacked = await step(entry.id, "extract", () => unpack(bytes, recipe.archive));
-	const native = await step(entry.id, "parse", () => parseNative(unpacked.bytes, recipe.parser));
-	const encoded = await step(entry.id, "crosswalk", () => encode(crosswalk, {
-		meta: metaOf(entry),
-		nodes: native.nodes,
-		edges: native.edges
-	}));
-	const data = await step(entry.id, "validate", () => {
-		const result = getTarget(entry.category).safeParse(encoded);
-		if (!result.success) throw new KeepsetError(`the result is not ${entry.category}: ${result.error.issues.map((issue) => `${issue.path.map(String).join(".") || "(root)"}: ${issue.message}`).join("; ")}`);
-		return result.data;
-	});
-	const counts = countTarget(entry.category, data);
-	const warnings = Object.entries(entry.expectedCounts).filter(([key, expected]) => counts.get(key) !== expected).map(([key, expected]) => `${key}: the entry records ${String(expected)}, the fetched result has ${String(counts.get(key))}`);
+	const parsed = await step(entry.id, "parse", () => parseNative(unpacked.bytes, recipe.parser));
 	return {
-		dataset,
-		data,
+		native: {
+			meta: metaOf(entry),
+			nodes: parsed.nodes,
+			edges: parsed.edges
+		},
 		provenance: {
 			entryId: entry.id,
 			catalogue: dataset.catalogue,
@@ -793,12 +873,35 @@ async function fetchEntry(dataset, options = {}) {
 			sha256: createHash("sha256").update(bytes).digest("hex"),
 			byteLength: bytes.byteLength,
 			...unpacked.member === void 0 ? {} : { member: unpacked.member }
-		},
-		warnings
+		}
 	};
 }
 /**
-* Fetches a dataset of the bundled catalogue by id and resolves it to its category's target shape, so `fetchDataset("cora")` yields graph/v1 `{ meta, nodes, edges }` directly. Node-only: it downloads with the platform `fetch` and unpacks with Node's zlib.
+* Runs a dataset's recipe: downloads the source (from its pinned snapshot when the source is dead), unpacks the archive, parses the native shape, applies the twindex crosswalk and validates the result against the category target. The native document the crosswalk receives is the parser's output with `meta` built from the entry.
+* @param dataset - A dataset from any catalogue.
+* @param options - The network port, abort signal and clock.
+* @returns The resolved target with its provenance and any count warnings.
+* @throws RecipeError naming the entry and the failing step; nothing partial or default-shaped is ever returned.
+*/
+async function fetchEntry(dataset, options = {}) {
+	const { entry, crosswalk } = dataset;
+	const { native, provenance } = await runToNative(dataset, options);
+	const encoded = await step(entry.id, "crosswalk", () => encode(crosswalk, native));
+	const data = await step(entry.id, "validate", () => {
+		const result = getTarget(entry.category).safeParse(encoded);
+		if (!result.success) throw new KeepsetError(`the result is not ${entry.category}: ${result.error.issues.map((issue) => `${issue.path.map(String).join(".") || "(root)"}: ${issue.message}`).join("; ")}`);
+		return result.data;
+	});
+	const counts = countTarget(entry.category, data);
+	return {
+		dataset,
+		data,
+		provenance,
+		warnings: Object.entries(entry.expectedCounts).filter(([key, expected]) => counts.get(key) !== expected).map(([key, expected]) => `${key}: the entry records ${String(expected)}, the fetched result has ${String(counts.get(key))}`)
+	};
+}
+/**
+* Fetches a dataset of the bundled catalogue by id and resolves it to its category's target shape, so `fetchDataset("cora")` yields graph/v1 `{ meta, nodes, edges }` directly. Node-only: it downloads with Node's http and https clients and unpacks with Node's zlib.
 * @param id - The entry id.
 * @param options - The network port, abort signal and clock.
 * @returns The resolved target with its provenance and any count warnings.
@@ -807,5 +910,40 @@ async function fetchEntry(dataset, options = {}) {
 async function fetchDataset(id, options = {}) {
 	return fetchEntry(getDataset(id), options);
 }
+/**
+* Checks a dataset's crosswalk on its real data: runs the recipe to the native document, then twindex's `assertRoundTrip`, which encodes it, decodes the result and compares the two over every path the crosswalk promises to preserve.
+* @param dataset - A dataset from any catalogue.
+* @param options - The network port, abort signal and clock.
+* @returns Whether the round trip holds, and where it first differs when it does not.
+* @throws RecipeError naming the entry and the failing step when the recipe fails before the comparison, or when the crosswalk cannot run.
+*/
+async function roundTripEntry(dataset, options = {}) {
+	const { native, provenance } = await runToNative(dataset, options);
+	try {
+		assertRoundTrip(dataset.crosswalk, [native]);
+	} catch (error) {
+		if (error instanceof RoundTripMismatchError) return {
+			holds: false,
+			path: error.path,
+			message: error.message,
+			provenance
+		};
+		throw new RecipeError(dataset.entry.id, "crosswalk", error instanceof Error ? error.message : String(error), { cause: error });
+	}
+	return {
+		holds: true,
+		provenance
+	};
+}
+/**
+* Runs `roundTripEntry` on a dataset of the bundled catalogue by id.
+* @param id - The entry id.
+* @param options - The network port, abort signal and clock.
+* @returns Whether the round trip holds.
+* @throws DatasetNotFoundError when no entry has that id, and RecipeError as `roundTripEntry` does.
+*/
+async function roundTripDataset(id, options = {}) {
+	return roundTripEntry(getDataset(id), options);
+}
 //#endregion
-export { downloadUrl, fetchDataset, fetchEntry };
+export { downloadUrl, fetchDataset, fetchEntry, roundTripDataset, roundTripEntry };