keepset 0.38.0 → 0.40.0

package/dist/node/fetch-dataset.js

@@ -1,4 +1,4 @@
-import { $ as ArchiveError, H as getCollectionTarget, L as getOwn, U as getTarget, at as RecipeError, it as NativeParseError, rt as KeepsetError, t as getDataset, z as countTarget } from "../bundled-U2l4WT5T.js";
+import { J as getTarget, K as getCollectionTarget, U as countTarget, V as getOwn, Y as isStreamable, dt as NativeParseError, ft as RecipeError, ot as ArchiveError, q as getStreamedShape, t as getDataset, ut as KeepsetError } from "../bundled-CL1eRNRR.js";
 import { RoundTripMismatchError, assertRoundTrip, encode } from "crossmap";
 import { z } from "zod";
 import { createHash } from "node:crypto";
@@ -127,6 +127,15 @@ function endpoint$1(fields, column, lineNumber) {
 	return value.trim();
 }
 /**
+* Whether a line meets one of the recipe's `where` conditions.
+* @param fields - The line's fields, at least as many as the highest column the recipe names.
+* @param condition - The condition.
+* @returns True when the condition's column, trimmed, equals its value.
+*/
+function meets(fields, condition) {
+	return fields[condition.column]?.trim() === condition.equals;
+}
+/**
 * Resolves `detect` to a fixed delimiter from the first data line: tab when it holds a tab, comma when it holds a comma, whitespace otherwise. The rule is a function of the file's bytes, so a recipe that detects still reads the same way every time.
 * @param dataLine - The first line that is neither skipped, blank nor a comment.
 * @returns The fixed delimiter.
@@ -149,31 +158,33 @@ function multiplicity(fields, column, lineNumber) {
 	return Number(value);
 }
 /**
-* Parses a delimited edge list: one edge per line, source and target in the configured columns, after `skipLines` header lines, with blank lines and lines whose first non-blank characters are a comment prefix skipped. A `detect` delimiter is fixed from the first data line. A recipe that names a `keep` column reads only the lines whose field there is one of its values; one that names a `multiplicityColumn` emits as many edges for a line as the field says, none for a zero; one that says `mirrored` emits each pair of mirror-image lines once. Nodes are the endpoints of the lines read, in order of first appearance.
-* @param text - The file text.
+* Parses a delimited edge list: one edge per line, source and target in the configured columns, after `skipLines` header lines, with blank lines and lines whose first non-blank characters are a comment prefix skipped. A `detect` delimiter is fixed from the first data line. A recipe that names a `keep` column reads only the lines whose field there is one of its values, and one that states `where` reads only the lines whose listed columns, trimmed, equal their values, so a file that records several kinds of row (an interaction file listing genetic beside physical interactions) is read for the rows the dataset is made of; a line that is not read is still checked for the fields it needs. A recipe that names a `multiplicityColumn` emits as many edges for a line as the field says, none for a zero; one that says `mirrored` emits each pair of mirror-image lines once. Nodes are the endpoints of the lines read, in order of first appearance. The text is read line by line, so a file longer than the engine's longest string is read too.
+* @param text - The file text, whole or in pieces.
 * @param options - The recipe's edge-list parser.
 * @returns The native graph.
-* @throws NativeParseError naming the line when a data line has too few fields, an empty endpoint or a multiplicity that is not a whole number, when a mirrored table has a line without its mirror, or when the file holds no edges.
+* @throws NativeParseError naming the line when a data line has too few fields, an empty endpoint or a multiplicity that is not a whole number, when a mirrored table has a line without its mirror, or when no line is an edge.
 */
 function parseEdgeList(text, options) {
 	let split = options.delimiter === "detect" ? void 0 : splitters[options.delimiter];
-	const needed = Math.max(options.sourceColumn, options.targetColumn, options.keep?.column ?? 0, options.multiplicityColumn ?? 0) + 1;
+	const { where } = options;
+	const needed = Math.max(options.sourceColumn, options.targetColumn, options.keep?.column ?? 0, options.multiplicityColumn ?? 0, ...where === void 0 ? [] : where.map((condition) => condition.column)) + 1;
 	const order = new NodeOrder();
 	const edges = [];
 	const awaiting = /* @__PURE__ */ new Map();
-	const all = lines(text);
-	for (const [index, line] of all.entries()) {
-		const lineNumber = index + 1;
+	let lastLine = 0;
+	forEachLine(typeof text === "string" ? [text] : text, (line, lineNumber) => {
+		lastLine = lineNumber;
 		const content = line.trimStart();
-		if (index < options.skipLines || content === "" || options.commentPrefixes.some((prefix) => content.startsWith(prefix))) continue;
+		if (lineNumber <= options.skipLines || content === "" || options.commentPrefixes.some((prefix) => content.startsWith(prefix))) return;
 		split ??= splitters[detect(line)];
 		const fields = split(line);
 		if (fields.length < needed) throw new NativeParseError("edge-list", lineNumber, `expected at least ${String(needed)} fields, found ${String(fields.length)}`);
-		if (options.keep !== void 0 && !options.keep.values.includes(fields[options.keep.column]?.trim() ?? "")) continue;
+		if (options.keep !== void 0 && !options.keep.values.includes(fields[options.keep.column]?.trim() ?? "")) return;
+		if (where !== void 0 && !where.every((condition) => meets(fields, condition))) return;
 		const source = endpoint$1(fields, options.sourceColumn, lineNumber);
 		const target = endpoint$1(fields, options.targetColumn, lineNumber);
 		const count = options.multiplicityColumn === void 0 ? 1 : multiplicity(fields, options.multiplicityColumn, lineNumber);
-		if (count === 0) continue;
+		if (count === 0) return;
 		order.add(source);
 		order.add(target);
 		if (options.mirrored === true && source !== target) {
@@ -185,7 +196,7 @@ function parseEdgeList(text, options) {
 			const waiting = awaiting.get(key);
 			if (waiting !== void 0 && waiting.length > 0) {
 				waiting.shift();
-				continue;
+				return;
 			}
 			const mirror = JSON.stringify([
 				target,
@@ -198,12 +209,12 @@ function parseEdgeList(text, options) {
 			source,
 			target
 		});
-	}
+	});
 	for (const [key, waiting] of awaiting) {
 		const [first] = waiting;
 		if (first !== void 0) throw new NativeParseError("edge-list", first, `the table is mirrored but this line has no mirror image (${key} is never listed)`);
 	}
-	if (edges.length === 0) throw new NativeParseError("edge-list", all.length, "the file holds no edges");
+	if (edges.length === 0) throw new NativeParseError("edge-list", lastLine, where === void 0 ? "the file holds no edges" : "no line of the file meets the recipe's where conditions");
 	return {
 		nodes: order.nodes(),
 		edges
@@ -211,8 +222,8 @@ function parseEdgeList(text, options) {
 }
 //#endregion
 //#region src/parsers/gd-contest.ts
-const FORMAT$14 = "gd-contest";
-const NUMBER$9 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?$/;
+const FORMAT$18 = "gd-contest";
+const NUMBER$10 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?$/;
 /**
 * Reads a vertex number, which the format numbers from 0 to N - 1.
 * @param token - The token.
@@ -220,7 +231,7 @@ const NUMBER$9 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?$/;
 * @returns The vertex id as text.
 */
 function vertex$1(token, count) {
-	if (!/^(?:0|[1-9]\d*)$/.test(token.text) || Number(token.text) >= count) throw new NativeParseError(FORMAT$14, token.line, `expected a vertex number from 0 to ${String(count - 1)}, found ${JSON.stringify(token.text)}`);
+	if (!/^(?:0|[1-9]\d*)$/.test(token.text) || Number(token.text) >= count) throw new NativeParseError(FORMAT$18, token.line, `expected a vertex number from 0 to ${String(count - 1)}, found ${JSON.stringify(token.text)}`);
 	return token.text;
 }
 /**
@@ -240,17 +251,17 @@ function parseGdContest(text) {
 		});
 	}
 	const [first] = tokens;
-	if (first === void 0) throw new NativeParseError(FORMAT$14, 1, "the file holds no vertex count");
-	if (!/^(?:0|[1-9]\d*)$/.test(first.text)) throw new NativeParseError(FORMAT$14, first.line, `the vertex count must be a non-negative integer, found ${JSON.stringify(first.text)}`);
+	if (first === void 0) throw new NativeParseError(FORMAT$18, 1, "the file holds no vertex count");
+	if (!/^(?:0|[1-9]\d*)$/.test(first.text)) throw new NativeParseError(FORMAT$18, first.line, `the vertex count must be a non-negative integer, found ${JSON.stringify(first.text)}`);
 	const count = Number(first.text);
 	const coordinates = tokens.slice(1, 1 + 2 * count);
-	if (coordinates.length < 2 * count) throw new NativeParseError(FORMAT$14, lines(text).length, `expected ${String(2 * count)} coordinates for ${String(count)} vertices, found ${String(coordinates.length)}`);
-	for (const coordinate of coordinates) if (!NUMBER$9.test(coordinate.text)) throw new NativeParseError(FORMAT$14, coordinate.line, `coordinate ${JSON.stringify(coordinate.text)} is not a number`);
+	if (coordinates.length < 2 * count) throw new NativeParseError(FORMAT$18, lines(text).length, `expected ${String(2 * count)} coordinates for ${String(count)} vertices, found ${String(coordinates.length)}`);
+	for (const coordinate of coordinates) if (!NUMBER$10.test(coordinate.text)) throw new NativeParseError(FORMAT$18, coordinate.line, `coordinate ${JSON.stringify(coordinate.text)} is not a number`);
 	const ends = tokens.slice(1 + 2 * count);
 	const edges = [];
 	for (let source = ends.shift(); source !== void 0; source = ends.shift()) {
 		const target = ends.shift();
-		if (target === void 0) throw new NativeParseError(FORMAT$14, source.line, `edge from vertex ${source.text} has no second vertex`);
+		if (target === void 0) throw new NativeParseError(FORMAT$18, source.line, `edge from vertex ${source.text} has no second vertex`);
 		edges.push({
 			source: vertex$1(source, count),
 			target: vertex$1(target, count)
@@ -264,7 +275,7 @@ function parseGdContest(text) {
 //#endregion
 //#region src/parsers/gml.ts
 const KEY = /[A-Za-z_][A-Za-z0-9_]*/y;
-const NUMBER$8 = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?/y;
+const NUMBER$9 = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?/y;
 /**
 * Matches a sticky pattern at a position.
 * @param pattern - A sticky regular expression.
@@ -315,7 +326,7 @@ function tokenise(text) {
 			position = end + 1;
 		} else {
 			const key = matchAt(KEY, text, position);
-			const number = key === void 0 ? matchAt(NUMBER$8, text, position) : void 0;
+			const number = key === void 0 ? matchAt(NUMBER$9, text, position) : void 0;
 			const match = key ?? number;
 			if (match === void 0) throw new NativeParseError("gml", line, `unexpected character ${JSON.stringify(char)}`);
 			tokens.push({
@@ -420,7 +431,7 @@ function parseGml(text) {
 }
 //#endregion
 //#region src/parsers/hgb.ts
-const FORMAT$13 = "hgb";
+const FORMAT$17 = "hgb";
 /** A type code or node id as the HGB files write them: a non-negative decimal integer with no sign or leading zero. */
 const CODE = /^(?:0|[1-9]\d*)$/;
 /** A number as a decimal literal with an optional sign and exponent, so `Number` cannot read hex, an empty string or infinity. */
@@ -440,7 +451,7 @@ const LINK_FIELDS = 4;
 */
 function resolve(field, types, where) {
 	const type = types[CODE.test(field) ? Number(field) : -1];
-	if (type === void 0) throw new NativeParseError(FORMAT$13, where.line, `${where.file}: the ${where.kind} type ${JSON.stringify(field)} is not one of the ${String(types.length)} the recipe names`);
+	if (type === void 0) throw new NativeParseError(FORMAT$17, where.line, `${where.file}: the ${where.kind} type ${JSON.stringify(field)} is not one of the ${String(types.length)} the recipe names`);
 	return type;
 }
 /**
@@ -458,9 +469,9 @@ function parseHgb(parts, options) {
 	forEachLine(parts.nodes, (line, number) => {
 		const fields = line.split("	");
 		const [id, , type] = fields;
-		if (fields.length !== NODE_FIELDS && fields.length !== NODE_FIELDS_WITH_ATTRIBUTES || id === void 0 || type === void 0) throw new NativeParseError(FORMAT$13, number, `node.dat: expected ${String(NODE_FIELDS)} or ${String(NODE_FIELDS_WITH_ATTRIBUTES)} fields separated by tabs, found ${String(fields.length)}`);
-		if (!CODE.test(id)) throw new NativeParseError(FORMAT$13, number, `node.dat: the node id ${JSON.stringify(id)} is not a non-negative integer`);
-		if (typeOf.has(id)) throw new NativeParseError(FORMAT$13, number, `node.dat: the node id ${id} is repeated`);
+		if (fields.length !== NODE_FIELDS && fields.length !== NODE_FIELDS_WITH_ATTRIBUTES || id === void 0 || type === void 0) throw new NativeParseError(FORMAT$17, number, `node.dat: expected ${String(NODE_FIELDS)} or ${String(NODE_FIELDS_WITH_ATTRIBUTES)} fields separated by tabs, found ${String(fields.length)}`);
+		if (!CODE.test(id)) throw new NativeParseError(FORMAT$17, number, `node.dat: the node id ${JSON.stringify(id)} is not a non-negative integer`);
+		if (typeOf.has(id)) throw new NativeParseError(FORMAT$17, number, `node.dat: the node id ${id} is repeated`);
 		const nodeType = resolve(type, options.nodeTypes, {
 			file: "node.dat",
 			line: number,
@@ -472,12 +483,12 @@ function parseHgb(parts, options) {
 			type: nodeType
 		});
 	});
-	if (nodes.length === 0) throw new NativeParseError(FORMAT$13, 1, "node.dat: the file holds no nodes");
+	if (nodes.length === 0) throw new NativeParseError(FORMAT$17, 1, "node.dat: the file holds no nodes");
 	const edges = [];
 	forEachLine(parts.links, (line, number) => {
 		const fields = line.split("	");
 		const [source, target, type, weight] = fields;
-		if (fields.length !== LINK_FIELDS || source === void 0 || target === void 0 || type === void 0 || weight === void 0) throw new NativeParseError(FORMAT$13, number, `link.dat: expected ${String(LINK_FIELDS)} fields separated by tabs, found ${String(fields.length)}`);
+		if (fields.length !== LINK_FIELDS || source === void 0 || target === void 0 || type === void 0 || weight === void 0) throw new NativeParseError(FORMAT$17, number, `link.dat: expected ${String(LINK_FIELDS)} fields separated by tabs, found ${String(fields.length)}`);
 		const linkType = resolve(type, options.linkTypes, {
 			file: "link.dat",
 			line: number,
@@ -493,17 +504,17 @@ function parseHgb(parts, options) {
 			linkType.target
 		]]) {
 			const actual = typeOf.get(id);
-			if (actual === void 0) throw new NativeParseError(FORMAT$13, number, `link.dat: the ${end} ${JSON.stringify(id)} is not a node of node.dat`);
-			if (actual !== expected) throw new NativeParseError(FORMAT$13, number, `link.dat: a ${linkType.name} link's ${end} must be a ${expected} node, and ${id} is a ${actual} node`);
+			if (actual === void 0) throw new NativeParseError(FORMAT$17, number, `link.dat: the ${end} ${JSON.stringify(id)} is not a node of node.dat`);
+			if (actual !== expected) throw new NativeParseError(FORMAT$17, number, `link.dat: a ${linkType.name} link's ${end} must be a ${expected} node, and ${id} is a ${actual} node`);
 		}
-		if (!DECIMAL$5.test(weight) || Number(weight) !== 1) throw new NativeParseError(FORMAT$13, number, `link.dat: the weight ${JSON.stringify(weight)} is not 1; a weighted HGB file would lose its weights`);
+		if (!DECIMAL$5.test(weight) || Number(weight) !== 1) throw new NativeParseError(FORMAT$17, number, `link.dat: the weight ${JSON.stringify(weight)} is not 1; a weighted HGB file would lose its weights`);
 		edges.push({
 			source,
 			target,
 			type: linkType.name
 		});
 	});
-	if (edges.length === 0) throw new NativeParseError(FORMAT$13, 1, "link.dat: the file holds no links");
+	if (edges.length === 0) throw new NativeParseError(FORMAT$17, 1, "link.dat: the file holds no links");
 	return {
 		nodes,
 		edges
@@ -511,7 +522,7 @@ function parseHgb(parts, options) {
 }
 //#endregion
 //#region src/parsers/kg-triples.ts
-const FORMAT$12 = "kg-triples";
+const FORMAT$16 = "kg-triples";
 /** The character each delimiter option splits a line on. A line is split on exactly that character, so a field cannot hide a second delimiter. */
 const DELIMITERS$1 = {
 	tab: "	",
@@ -533,8 +544,8 @@ const QUOTE$2 = "\"";
 */
 function value(field, quoted, where) {
 	const inner = quoted ? field.slice(1, -1) : field;
-	if (quoted && (field.length < 2 || !field.startsWith(QUOTE$2) || !field.endsWith(QUOTE$2) || inner.includes(QUOTE$2))) throw new NativeParseError(FORMAT$12, where.line, `${where.part}the field ${JSON.stringify(field)} is not one value wrapped in double quotes`);
-	if (inner === "") throw new NativeParseError(FORMAT$12, where.line, `${where.part}a field is empty`);
+	if (quoted && (field.length < 2 || !field.startsWith(QUOTE$2) || !field.endsWith(QUOTE$2) || inner.includes(QUOTE$2))) throw new NativeParseError(FORMAT$16, where.line, `${where.part}the field ${JSON.stringify(field)} is not one value wrapped in double quotes`);
+	if (inner === "") throw new NativeParseError(FORMAT$16, where.line, `${where.part}a field is empty`);
 	return inner;
 }
 /**
@@ -558,16 +569,16 @@ function parseKgTriples(parts, options) {
 		let lastLine = 0;
 		forEachLine(part.pieces, (line, number) => {
 			lastLine = number;
-			if (line.trim() === "") throw new NativeParseError(FORMAT$12, number, `${label}the line is blank`);
+			if (line.trim() === "") throw new NativeParseError(FORMAT$16, number, `${label}the line is blank`);
 			if (number === 1 && options.header === "names") return;
 			if (number === 1 && options.header === "count") {
-				if (!COUNT$1.test(line)) throw new NativeParseError(FORMAT$12, number, `${label}expected the number of triples on the first line, found ${JSON.stringify(line)}`);
+				if (!COUNT$1.test(line)) throw new NativeParseError(FORMAT$16, number, `${label}expected the number of triples on the first line, found ${JSON.stringify(line)}`);
 				declared = Number(line);
 				return;
 			}
 			const fields = line.split(delimiter);
 			const [head, middle, last] = fields;
-			if (fields.length !== TRIPLE_FIELDS || head === void 0 || middle === void 0 || last === void 0) throw new NativeParseError(FORMAT$12, number, `${label}expected ${String(TRIPLE_FIELDS)} fields separated by ${options.delimiter}, found ${String(fields.length)}`);
+			if (fields.length !== TRIPLE_FIELDS || head === void 0 || middle === void 0 || last === void 0) throw new NativeParseError(FORMAT$16, number, `${label}expected ${String(TRIPLE_FIELDS)} fields separated by ${options.delimiter}, found ${String(fields.length)}`);
 			const where = {
 				line: number,
 				part: label
@@ -593,8 +604,8 @@ function parseKgTriples(parts, options) {
 			});
 			triples += 1;
 		});
-		if (triples === 0) throw new NativeParseError(FORMAT$12, lastLine, `${label}the file holds no triples`);
-		if (declared !== void 0 && declared !== triples) throw new NativeParseError(FORMAT$12, lastLine, `${label}the first line declares ${String(declared)} triples, the file holds ${String(triples)}`);
+		if (triples === 0) throw new NativeParseError(FORMAT$16, lastLine, `${label}the file holds no triples`);
+		if (declared !== void 0 && declared !== triples) throw new NativeParseError(FORMAT$16, lastLine, `${label}the first line declares ${String(declared)} triples, the file holds ${String(triples)}`);
 	}
 	return {
 		nodes: order.nodes(),
@@ -603,7 +614,7 @@ function parseKgTriples(parts, options) {
 }
 //#endregion
 //#region src/parsers/konect.ts
-const FORMAT$11 = "konect";
+const FORMAT$15 = "konect";
 /** The network formats of KONECT's first line (Kunegis, "The KONECT Handbook", table 1): undirected, directed and bipartite. */
 const NETWORK_FORMATS = /* @__PURE__ */ new Set([
 	"sym",
@@ -678,9 +689,9 @@ function parseKonect(pieces, options) {
 		}));
 	});
 	const { header } = state;
-	if (header === void 0) throw new NativeParseError(FORMAT$11, lastLine, "the file has no first line naming its format and weights");
-	if (edges.length === 0) throw new NativeParseError(FORMAT$11, lastLine, "the file holds no edges");
-	if (header.counts !== void 0 && header.counts.edges !== edges.length) throw new NativeParseError(FORMAT$11, lastLine, `the second line declares ${String(header.counts.edges)} edges, the file holds ${String(edges.length)}`);
+	if (header === void 0) throw new NativeParseError(FORMAT$15, lastLine, "the file has no first line naming its format and weights");
+	if (edges.length === 0) throw new NativeParseError(FORMAT$15, lastLine, "the file holds no edges");
+	if (header.counts !== void 0 && header.counts.edges !== edges.length) throw new NativeParseError(FORMAT$15, lastLine, `the second line declares ${String(header.counts.edges)} edges, the file holds ${String(edges.length)}`);
 	return {
 		nodes: order.nodes(),
 		edges
@@ -698,9 +709,9 @@ function readHeader(content, number, options) {
 	const match = FORMAT_LINE.exec(content);
 	const network = match?.[1];
 	const weights = match?.[2];
-	if (network === void 0 || weights === void 0 || !NETWORK_FORMATS.has(network)) throw new NativeParseError(FORMAT$11, number, `expected a first line "% FORMAT WEIGHTS" with FORMAT one of ${[...NETWORK_FORMATS].join(", ")}, found ${JSON.stringify(content)}`);
-	if (!WEIGHTED_TYPES.has(weights) && !UNWEIGHTED_TYPES.has(weights)) throw new NativeParseError(FORMAT$11, number, `the weight type ${JSON.stringify(weights)} is not one this parser reads (its third column is not an edge weight or a repetition count)`);
-	if (options.weighted !== WEIGHTED_TYPES.has(weights)) throw new NativeParseError(FORMAT$11, number, `the file's weight type is ${weights}, so a recipe with weighted ${String(WEIGHTED_TYPES.has(weights))} reads it, not one with weighted ${String(options.weighted)}`);
+	if (network === void 0 || weights === void 0 || !NETWORK_FORMATS.has(network)) throw new NativeParseError(FORMAT$15, number, `expected a first line "% FORMAT WEIGHTS" with FORMAT one of ${[...NETWORK_FORMATS].join(", ")}, found ${JSON.stringify(content)}`);
+	if (!WEIGHTED_TYPES.has(weights) && !UNWEIGHTED_TYPES.has(weights)) throw new NativeParseError(FORMAT$15, number, `the weight type ${JSON.stringify(weights)} is not one this parser reads (its third column is not an edge weight or a repetition count)`);
+	if (options.weighted !== WEIGHTED_TYPES.has(weights)) throw new NativeParseError(FORMAT$15, number, `the file's weight type is ${weights}, so a recipe with weighted ${String(WEIGHTED_TYPES.has(weights))} reads it, not one with weighted ${String(options.weighted)}`);
 	return {
 		line: number,
 		network
@@ -720,15 +731,15 @@ function readEdge(content, number, context) {
 	const [from, to, third, time] = fields;
 	const expected = options.timestamped ? TIMESTAMPED_COLUMNS : options.weighted ? WEIGHTED_COLUMNS : void 0;
 	const fits = expected === void 0 ? fields.length === ENDPOINT_COLUMNS || fields.length === WEIGHTED_COLUMNS : fields.length === expected;
-	if (from === void 0 || to === void 0 || !fits) throw new NativeParseError(FORMAT$11, number, `expected ${expected === void 0 ? `${String(ENDPOINT_COLUMNS)} or ${String(WEIGHTED_COLUMNS)}` : String(expected)} columns for this recipe, found ${String(fields.length)}`);
+	if (from === void 0 || to === void 0 || !fits) throw new NativeParseError(FORMAT$15, number, `expected ${expected === void 0 ? `${String(ENDPOINT_COLUMNS)} or ${String(WEIGHTED_COLUMNS)}` : String(expected)} columns for this recipe, found ${String(fields.length)}`);
 	const bipartite = header.network === "bip";
 	const source = endpoint(from, bipartite ? LEFT_PREFIX : "", header.counts?.left, number);
 	const target = endpoint(to, bipartite ? RIGHT_PREFIX : "", header.counts?.right, number);
 	order.add(source);
 	order.add(target);
-	if (third !== void 0 && !options.weighted && (!DECIMAL$4.test(third) || Number(third) !== 1)) throw new NativeParseError(FORMAT$11, number, `the third column ${JSON.stringify(third)} is not 1; an edge that stands for several would be read as one`);
-	if (third !== void 0 && options.weighted && !DECIMAL$4.test(third)) throw new NativeParseError(FORMAT$11, number, `the weight ${JSON.stringify(third)} is not a number`);
-	if (time !== void 0 && !DECIMAL$4.test(time)) throw new NativeParseError(FORMAT$11, number, `the time ${JSON.stringify(time)} is not a number`);
+	if (third !== void 0 && !options.weighted && (!DECIMAL$4.test(third) || Number(third) !== 1)) throw new NativeParseError(FORMAT$15, number, `the third column ${JSON.stringify(third)} is not 1; an edge that stands for several would be read as one`);
+	if (third !== void 0 && options.weighted && !DECIMAL$4.test(third)) throw new NativeParseError(FORMAT$15, number, `the weight ${JSON.stringify(third)} is not a number`);
+	if (time !== void 0 && !DECIMAL$4.test(time)) throw new NativeParseError(FORMAT$15, number, `the time ${JSON.stringify(time)} is not a number`);
 	const edge = {
 		source,
 		target
@@ -747,10 +758,215 @@ function readEdge(content, number, context) {
 * @throws NativeParseError when the token is not a positive integer or exceeds the set's size.
 */
 function endpoint(token, prefix, size, number) {
-	if (!NODE_ID.test(token) || size !== void 0 && Number(token) > size) throw new NativeParseError(FORMAT$11, number, `${JSON.stringify(token)} is not a node id from 1${size === void 0 ? "" : ` to ${String(size)}`}`);
+	if (!NODE_ID.test(token) || size !== void 0 && Number(token) > size) throw new NativeParseError(FORMAT$15, number, `${JSON.stringify(token)} is not a node id from 1${size === void 0 ? "" : ` to ${String(size)}`}`);
 	return `${prefix}${token}`;
 }
 //#endregion
+//#region src/parsers/ogb.ts
+const FORMAT$14 = "ogb";
+/** The files of an OGB raw directory this reader takes, by their path under the dataset's root directory. A relation's files sit in `raw/relations/<head>___<relation>___<tail>/`. */
+const RAW = /^(?<root>(?:[^/]+\/)*?)raw\/(?<name>num-node-list|num-node-dict|edge|num-edge-list|triplet-type-list|relations\/[^/]+\/(?:edge|num-edge-list))\.csv\.gz$/u;
+const INDEX = /^(?:0|[1-9]\d*)$/;
+/** The fields of a line of `triplet-type-list.csv.gz`: a head type, a relation and a tail type. */
+const TRIPLET_PARTS = 3;
+/**
+* Orders two names by code point, the order Python's `sorted` gives the ASCII type and relation names OGB uses.
+* @param left - A name.
+* @param right - Another.
+* @returns Negative, zero or positive.
+*/
+function compare(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+/**
+* Visits the non-blank lines of a file, read a piece at a time.
+* @param file - The file.
+* @param visit - Called with each non-blank line and its number.
+*/
+function forEachRow(file, visit) {
+	forEachLine(file.text(), (text, line) => {
+		if (text.trim() !== "") visit({
+			text,
+			line
+		});
+	});
+}
+/**
+* The non-blank lines of a small file, such as a count or the triplet list.
+* @param file - The file.
+* @returns Each non-blank line and its number.
+*/
+function rows(file) {
+	const all = [];
+	forEachRow(file, (row) => {
+		all.push(row);
+	});
+	return all;
+}
+/**
+* Reads a file that holds one line, such as a count.
+* @param file - The file.
+* @returns The line's text.
+* @throws NativeParseError when the file holds no line or more than one.
+*/
+function onlyLine(file) {
+	const all = rows(file);
+	const [only] = all;
+	if (all.length !== 1 || only === void 0) throw new NativeParseError(FORMAT$14, all[1]?.line ?? 1, `${file.path} must hold one line, found ${String(all.length)}`);
+	return only.text.trim();
+}
+/**
+* Reads a non-negative integer.
+* @param text - The field.
+* @param file - The file, for the error.
+* @param line - The 1-based line, for the error.
+* @returns The integer.
+* @throws NativeParseError when the field is not a non-negative integer.
+*/
+function index(text, file, line) {
+	const trimmed = text.trim();
+	if (!INDEX.test(trimmed)) throw new NativeParseError(FORMAT$14, line, `${file.path}: expected a non-negative integer, found ${JSON.stringify(text)}`);
+	return Number(trimmed);
+}
+/**
+* Reads an `edge.csv.gz` file, one `<source>,<target>` pair of node indices per line, checking each index against its node type's count and the line count against the relation's `num-edge-list.csv.gz`.
+* @param edges - The edge file.
+* @param count - The relation's `num-edge-list.csv.gz`.
+* @param ends - The source and target node types' counts and how each index is named.
+* @param emit - Called with each edge, in file order, so a large file is never held twice.
+* @throws NativeParseError naming the file and line for a line that is not a pair of indices, an index outside its type's nodes, or a line count other than the recorded one.
+*/
+function readEdges(edges, count, ends, emit) {
+	const recorded = index(onlyLine(count), count, 1);
+	let read = 0;
+	forEachRow(edges, ({ text, line }) => {
+		const fields = text.split(",");
+		const [first, second] = fields;
+		if (fields.length !== 2 || first === void 0 || second === void 0) throw new NativeParseError(FORMAT$14, line, `${edges.path}: expected a source and a target index, found ${JSON.stringify(text)}`);
+		const source = index(first, edges, line);
+		const target = index(second, edges, line);
+		if (source >= ends.sources || target >= ends.targets) throw new NativeParseError(FORMAT$14, line, `${edges.path}: edge ${text} names a node outside the ${String(ends.sources)} sources and ${String(ends.targets)} targets the dataset records`);
+		emit({
+			source: ends.source(source),
+			target: ends.target(target)
+		});
+		read += 1;
+	});
+	if (read !== recorded) throw new NativeParseError(FORMAT$14, read, `${edges.path} holds ${String(read)} edges, but ${count.path} records ${String(recorded)}`);
+}
+/**
+* Takes one file of the dataset directory by its name under `raw/`.
+* @param files - The files by name.
+* @param name - The name, such as `edge` or `relations/paper___cites___paper/edge`.
+* @param root - The dataset's root directory, for the error.
+* @returns The file.
+* @throws NativeParseError when the archive's selection holds no such file.
+*/
+function required$1(files, name, root) {
+	const file = files.get(name);
+	if (file === void 0) throw new NativeParseError(FORMAT$14, 1, `the dataset directory ${root} has no raw/${name}.csv.gz among the files the recipe selects`);
+	return file;
+}
+/**
+* Parses an Open Graph Benchmark dataset from the files of its raw directory, as OGB's own `read_csv_graph_raw` and `read_csv_heterograph_raw` read them (ogb/io/read_graph_raw.py in snap-stanford/ogb). A homogeneous dataset has `raw/num-node-list.csv.gz` (its one graph's node count), `raw/edge.csv.gz` (one `<source>,<target>` pair of node indices per line, no header) and `raw/num-edge-list.csv.gz`: its nodes are `0` to `N - 1`, isolated ones included, and its edges the pairs in file order. A heterogeneous dataset has `raw/num-node-dict.csv.gz` (a header of node types over one row of their counts), `raw/triplet-type-list.csv.gz` (one `<head>,<relation>,<tail>` type triplet per line) and, per triplet, `raw/relations/<head>___<relation>___<tail>/edge.csv.gz` and `num-edge-list.csv.gz`, whose indices count within the head and tail types: its nodes are `<type>:<index>` for each type in sorted order and each index from 0, and its edges are each relation's pairs in file order, relations in the sorted order of their triplets, which is the order OGB reads them in. Edges keep the file's direction. Relation names, node features, labels and splits are not carried, as no graph parser in this version carries more than topology.
+* @param files - The files the recipe's archive selects, gunzipped and decoded: every one must be a file of one dataset's raw directory named above.
+* @returns The native graph.
+* @throws NativeParseError naming the file and line for a file outside the raw layout, files of two datasets, a dataset with neither or both node-count files, a missing file, a graph count other than one, a malformed count or triplet, a relation directory the triplet list does not name, an edge that is not a pair of indices of the dataset's nodes, or an edge file whose line count differs from its recorded count.
+*/
+function parseOgb(files) {
+	const byName = /* @__PURE__ */ new Map();
+	const roots = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		const match = RAW.exec(file.path);
+		const name = match?.groups?.["name"];
+		const root = match?.groups?.["root"];
+		if (name === void 0 || root === void 0) throw new NativeParseError(FORMAT$14, 1, `${file.path} is not a file of an OGB raw directory this reader takes`);
+		roots.add(root);
+		byName.set(name, file);
+	}
+	const [root] = roots;
+	if (roots.size !== 1 || root === void 0) throw new NativeParseError(FORMAT$14, 1, `the recipe must select the raw files of one dataset, found ${roots.size === 0 ? "none" : `the directories ${[...roots].join(", ")}`}`);
+	const homogeneous = byName.get("num-node-list");
+	const heterogeneous = byName.get("num-node-dict");
+	const neitherOrBoth = `the dataset directory ${root} must have exactly one of raw/num-node-list.csv.gz (one node type) and raw/num-node-dict.csv.gz (several)`;
+	const edges = [];
+	if (homogeneous !== void 0) {
+		if (heterogeneous !== void 0) throw new NativeParseError(FORMAT$14, 1, neitherOrBoth);
+		const [relation] = [...byName.keys()].filter((name) => name.startsWith("relations/"));
+		if (relation !== void 0 || byName.has("triplet-type-list")) throw new NativeParseError(FORMAT$14, 1, `the dataset directory ${root} has raw/num-node-list.csv.gz, so it has one node type, but the recipe selects ${relation === void 0 ? "raw/triplet-type-list.csv.gz" : `raw/${relation}.csv.gz`} as well`);
+		const count = index(onlyLine(homogeneous), homogeneous, 1);
+		const name = (node) => String(node);
+		readEdges(required$1(byName, "edge", root), required$1(byName, "num-edge-list", root), {
+			sources: count,
+			targets: count,
+			source: name,
+			target: name
+		}, (edge) => {
+			edges.push(edge);
+		});
+		return {
+			nodes: Array.from({ length: count }, (_, node) => ({ id: String(node) })),
+			edges
+		};
+	}
+	if (heterogeneous === void 0) throw new NativeParseError(FORMAT$14, 1, neitherOrBoth);
+	for (const stray of ["edge", "num-edge-list"]) if (byName.has(stray)) throw new NativeParseError(FORMAT$14, 1, `the dataset directory ${root} has raw/num-node-dict.csv.gz, so its edges are in raw/relations/, but the recipe selects raw/${stray}.csv.gz as well`);
+	const header = rows(heterogeneous);
+	const [types, counts] = header;
+	if (header.length !== 2 || types === void 0 || counts === void 0) throw new NativeParseError(FORMAT$14, header[2]?.line ?? 1, `${heterogeneous.path} must hold a header of node types and one row of their counts, found ${String(header.length)} lines`);
+	const typeNames = types.text.split(",").map((type) => type.trim());
+	const typeCounts = counts.text.split(",");
+	if (typeNames.length !== typeCounts.length || typeNames.some((type) => type === "") || new Set(typeNames).size !== typeNames.length) throw new NativeParseError(FORMAT$14, counts.line, `${heterogeneous.path} must name each node type once, over one count per type`);
+	const nodeTypes = typeNames.map((type, position) => {
+		const count = typeCounts[position];
+		if (count === void 0) throw new NativeParseError(FORMAT$14, counts.line, `${heterogeneous.path} gives node type ${type} no count`);
+		return {
+			type,
+			count: index(count, heterogeneous, counts.line)
+		};
+	});
+	nodeTypes.sort((left, right) => compare(left.type, right.type));
+	const nodeCounts = new Map(nodeTypes.map(({ type, count }) => [type, count]));
+	const triplets = required$1(byName, "triplet-type-list", root);
+	const relations = [];
+	for (const { text, line } of rows(triplets)) {
+		const parts = text.split(",").map((part) => part.trim());
+		const [head, relation, tail] = parts;
+		if (parts.length !== TRIPLET_PARTS || head === void 0 || relation === void 0 || tail === void 0 || relation === "") throw new NativeParseError(FORMAT$14, line, `${triplets.path}: expected a head type, a relation and a tail type, found ${JSON.stringify(text)}`);
+		const sources = nodeCounts.get(head);
+		const targets = nodeCounts.get(tail);
+		if (sources === void 0 || targets === void 0) throw new NativeParseError(FORMAT$14, line, `${triplets.path}: ${text} names a node type that ${heterogeneous.path} does not count`);
+		relations.push({
+			head,
+			relation,
+			tail,
+			sources,
+			targets
+		});
+	}
+	relations.sort((left, right) => compare(left.head, right.head) || compare(left.relation, right.relation) || compare(left.tail, right.tail));
+	const listed = new Set(relations.map(({ head, relation, tail }) => `relations/${head}___${relation}___${tail}`));
+	for (const name of byName.keys()) {
+		const directory = name.slice(0, name.lastIndexOf("/"));
+		if (name.startsWith("relations/") && !listed.has(directory)) throw new NativeParseError(FORMAT$14, 1, `raw/${directory}/ is not one of the relations ${triplets.path} lists`);
+	}
+	for (const { head, relation, tail, sources, targets } of relations) {
+		const directory = `relations/${head}___${relation}___${tail}`;
+		readEdges(required$1(byName, `${directory}/edge`, root), required$1(byName, `${directory}/num-edge-list`, root), {
+			sources,
+			targets,
+			source: (node) => `${head}:${String(node)}`,
+			target: (node) => `${tail}:${String(node)}`
+		}, (edge) => {
+			edges.push(edge);
+		});
+	}
+	return {
+		nodes: nodeTypes.flatMap(({ type, count }) => Array.from({ length: count }, (_, node) => ({ id: `${type}:${String(node)}` }))),
+		edges
+	};
+}
+//#endregion
 //#region src/parsers/matrix-market.ts
 /** How many tokens an entry line of each field type holds: the coordinates, then the value's parts (none for a pattern, a real and an imaginary part for a complex value). */
 const tokensPerEntry = /* @__PURE__ */ new Map([
@@ -985,69 +1201,71 @@ var RecordScanner = class {
 	}
 };
 /**
-* Splits text into records and fields by RFC 4180 as the text arrives in pieces, one piece's records at a time, so neither the whole file nor every cell is held at once: 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. A piece may end anywhere, even between the two quotes of a doubled quote or between a CR and its LF.
-* @param pieces - The file text in order, 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 in order, 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$1(pieces, delimiter, firstLine) {
-	const scanner = new RecordScanner(delimiter.charCodeAt(0), firstLine);
-	let carry = "";
-	for (const piece of pieces) {
-		const scanned = scanner.scan(carry + piece, false);
-		carry = scanned.carry;
-		yield* scanned.completed;
+* Reads a table file's records as its text arrives in pieces, so neither the whole file nor every cell is held at once: a leading byte order mark is removed, the physical lines the recipe skips are dropped, and the rest is split 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). Blank lines are not records. A piece may end anywhere, even between the two quotes of a doubled quote or between a CR and its LF.
+*/
+var RecordReader = class {
+	options;
+	scanner;
+	carry = "";
+	first = true;
+	toSkip;
+	constructor(options) {
+		this.options = options;
+		this.scanner = new RecordScanner(DELIMITERS[options.delimiter].charCodeAt(0), options.skipLines + 1);
+		this.toSkip = options.skipLines;
 	}
-	yield* scanner.scan(carry, true).completed;
-	const last = scanner.finish();
-	if (last !== void 0) yield last;
-}
+	/**
+	* Reads the next piece of the file's text.
+	* @param piece - The text, which follows the pieces read before it.
+	* @returns The records the piece completes, in order.
+	* @throws NativeParseError when a quote opens inside an unquoted field.
+	*/
+	push(piece) {
+		let rest = this.first && piece.startsWith(BYTE_ORDER_MARK) ? piece.slice(1) : piece;
+		this.first = false;
+		while (this.toSkip > 0) {
+			const next = rest.indexOf("\n");
+			if (next === -1) return [];
+			rest = rest.slice(next + 1);
+			this.toSkip -= 1;
+		}
+		if (rest === "") return [];
+		const scanned = this.scanner.scan(this.carry + rest, false);
+		this.carry = scanned.carry;
+		return scanned.completed.filter(isNotBlank);
+	}
+	/**
+	* Ends the file.
+	* @returns The records left when the text ends, in order.
+	* @throws NativeParseError when a quoted field is never closed, a quote opens inside an unquoted field, or the file has fewer lines than the recipe skips.
+	*/
+	end() {
+		if (this.toSkip > 0) throw new NativeParseError("csv-table", this.options.skipLines - this.toSkip + 1, `the file has fewer than ${String(this.options.skipLines)} lines to skip before the header`);
+		const completed = this.scanner.scan(this.carry, true).completed;
+		this.carry = "";
+		const last = this.scanner.finish();
+		return [...completed, ...last === void 0 ? [] : [last]].filter(isNotBlank);
+	}
+};
 /**
-* Splits comma-separated text into its records' fields by RFC 4180, as `records` does, keeping every record (blank lines included) at its position: the grid a workbook sheet's CSV makes, for a parser that reads a layout of blocks and not one table.
+* Splits comma-separated text into its records' fields by RFC 4180, as the record reader does, keeping every record (blank lines included) at its position: the grid a workbook sheet's CSV makes, for a parser that reads a layout of blocks and not one table.
 * @param text - The text.
 * @returns Each record's fields, in order.
 * @throws NativeParseError when a quoted field is never closed or a quote opens inside an unquoted field.
 */
 function csvGrid(text) {
-	return [...records$1([text], ",", 1)].map((record) => record.fields);
-}
-/**
-* Drops the first physical lines of a file given in pieces.
-* @param pieces - The file text in order.
-* @param count - How many physical lines to drop.
-* @returns The rest of the text, in pieces.
-* @throws NativeParseError when the file has fewer lines than that.
-*/
-function* afterLines(pieces, count) {
-	let remaining = count;
-	for (const piece of pieces) {
-		let rest = piece;
-		while (remaining > 0) {
-			const next = rest.indexOf("\n");
-			if (next === -1) {
-				rest = "";
-				break;
-			}
-			rest = rest.slice(next + 1);
-			remaining -= 1;
-		}
-		if (remaining === 0 && rest !== "") yield rest;
-	}
-	if (remaining > 0) throw new NativeParseError("csv-table", count - remaining + 1, `the file has fewer than ${String(count)} lines to skip before the header`);
+	const scanner = new RecordScanner(DELIMITERS.comma.charCodeAt(0), 1);
+	const { completed } = scanner.scan(text, true);
+	const last = scanner.finish();
+	return [...completed, ...last === void 0 ? [] : [last]].map((record) => record.fields);
 }
 /**
-* The text of a file as its pieces, with a leading byte order mark removed.
-* @param text - The file text, or its pieces in order.
-* @returns The pieces.
+* Whether a record holds anything: a blank line is a record of one empty field.
+* @param record - The record.
+* @returns False for a blank line.
 */
-function* withoutByteOrderMark(text) {
-	let first = true;
-	for (const piece of typeof text === "string" ? [text] : text) {
-		yield first && piece.startsWith(BYTE_ORDER_MARK) ? piece.slice(1) : piece;
-		first = false;
-	}
+function isNotBlank(record) {
+	return record.fields.length > 1 || record.fields[0]?.trim() !== "";
 }
 /**
 * Reads a numeric cell.
@@ -1064,27 +1282,81 @@ function numeric$1(cell, factor, column, line) {
 	return Number(cell) * factor;
 }
 /**
-* The records of a table file after the lines the recipe skips and without its blank lines: the header first, then the rows, one at a time.
-* @param text - The file text, or its pieces in order, which may begin with a byte order mark.
-* @param options - The recipe's table parser, of which the delimiter and the lines to skip are read.
-* @returns Each record.
-* @throws NativeParseError when a quote is never closed or opens inside an unquoted field, or the file has fewer lines than the recipe skips.
+* Reads a delimited table into rows as its text arrives in pieces, holding only the record in progress between pieces, so a caller that hands each row on as it is returned holds no more of the table than that. The rows are exactly those `parseCsvTable` gives, in order, with the same errors on the same lines however the text is cut.
 */
-function* tableRecords(text, options) {
-	const body = afterLines(withoutByteOrderMark(text), options.skipLines);
-	for (const record of records$1(body, DELIMITERS[options.delimiter], options.skipLines + 1)) if (record.fields.length > 1 || record.fields[0]?.trim() !== "") yield record;
-}
+var TableReader = class {
+	options;
+	records;
+	layout;
+	rows = 0;
+	missing;
+	constructor(options) {
+		this.options = options;
+		this.records = new RecordReader(options);
+		this.missing = new Set(options.nullValues ?? []);
+	}
+	/**
+	* Reads the next piece of the file's text.
+	* @param piece - The text, which follows the pieces read before it.
+	* @returns The rows the piece completes, in file order.
+	* @throws NativeParseError as `parseCsvTable` does, naming the line of the problem.
+	*/
+	push(piece) {
+		return this.rowsOf(this.records.push(piece));
+	}
+	/**
+	* Ends the file.
+	* @returns The rows left when the text ends, in file order.
+	* @throws NativeParseError as `parseCsvTable` does, including for a file with no header row.
+	*/
+	end() {
+		const rows = this.rowsOf(this.records.end());
+		if (this.layout === void 0) throw new NativeParseError("csv-table", this.options.skipLines + 1, "the file has no header row");
+		return rows;
+	}
+	/**
+	* Builds the rows of records, the first record of the file being its header.
+	* @param records - Records in file order.
+	* @returns The rows among them.
+	*/
+	rowsOf(records) {
+		const rows = [];
+		for (const record of records) if (this.layout === void 0) this.layout = layoutOf(record, this.options);
+		else rows.push(this.rowOf(record, this.layout));
+		return rows;
+	}
+	/**
+	* Builds one row.
+	* @param record - A record after the header.
+	* @param layout - The header's layout.
+	* @returns The row.
+	* @throws NativeParseError when the record's width differs from the header's, its id is empty or a numeric cell is not a number.
+	*/
+	rowOf(record, layout) {
+		const { idColumn } = this.options;
+		if (record.fields.length !== layout.width) throw new NativeParseError("csv-table", record.line, `the row has ${String(record.fields.length)} fields, the header has ${String(layout.width)}`);
+		this.rows += 1;
+		const id = idColumn === null ? String(this.rows) : (record.fields[layout.idPosition] ?? "").trim();
+		if (id === "") throw new NativeParseError("csv-table", record.line, `the id column ${idColumn ?? ""} is empty`);
+		const cells = layout.kept.map(({ name, position, factor }) => {
+			const trimmed = (record.fields[position] ?? "").trim();
+			const cell = this.missing.has(trimmed) ? "" : trimmed;
+			return [name, factor === void 0 ? cell === "" ? null : cell : numeric$1(cell, factor, name, record.line)];
+		});
+		return {
+			...Object.fromEntries(cells),
+			id
+		};
+	}
+};
 /**
-* Parses a delimited table into rows (a cell whose text is one of the recipe's `nullValues` is empty, so null): 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 (or, when the recipe lists `columns`, exactly those, so a wide table is not held cell for cell), 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. `id` is the row's id, so a column of that name which is not the id column is named by its position. 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, two columns with the same name, and an id cell that is empty are errors.
-* @param text - The file text, or its pieces in order.
+* Reads a table's header into the layout its rows are built by, checking the recipe against it.
+* @param header - The header record.
 * @param options - The recipe's table parser.
-* @returns The rows, in file order.
-* @throws NativeParseError naming the line of the first problem, including a listed or numeric column the header lacks or a numeric column that is not listed.
+* @returns The layout.
+* @throws NativeParseError when two header cells get the same name, the recipe names a column the header lacks, lists the id column among the columns, or declares numeric a column it does not keep.
 */
-function parseCsvTable(text, options) {
-	const table = tableRecords(text, options);
-	const { value: header } = table.next();
-	if (header === void 0) throw new NativeParseError("csv-table", options.skipLines + 1, "the file has no header row");
+function layoutOf(header, options) {
 	const names = columnNames(header.fields, options.idColumn, header.line);
 	const { idColumn, numericColumns, columns } = options;
 	const wanted = new Set(columns ?? names.filter((name) => name !== idColumn));
@@ -1096,28 +1368,28 @@ function parseCsvTable(text, options) {
 	if (idColumn !== null && wanted.has(idColumn)) throw new NativeParseError("csv-table", header.line, `the id column ${idColumn} is the row's id, so it is not listed among the columns`);
 	for (const { column } of numericColumns) if (!wanted.has(column)) throw new NativeParseError("csv-table", header.line, `the column ${column} is declared numeric but is not among the columns kept`);
 	const factors = new Map(numericColumns.map((entry) => [entry.column, entry.factor]));
-	const missing = new Set(options.nullValues ?? []);
-	const idPosition = idColumn === null ? -1 : names.indexOf(idColumn);
-	const kept = names.flatMap((name, position) => name !== idColumn && wanted.has(name) ? [{
-		name,
-		position,
-		factor: factors.get(name)
-	}] : []);
+	return {
+		width: names.length,
+		idPosition: idColumn === null ? -1 : names.indexOf(idColumn),
+		kept: names.flatMap((name, position) => name !== idColumn && wanted.has(name) ? [{
+			name,
+			position,
+			factor: factors.get(name)
+		}] : [])
+	};
+}
+/**
+* Parses a delimited table into rows (a cell whose text is one of the recipe's `nullValues` is empty, so null): 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 (or, when the recipe lists `columns`, exactly those, so a wide table is not held cell for cell), 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. `id` is the row's id, so a column of that name which is not the id column is named by its position. 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, two columns with the same name, and an id cell that is empty are errors.
+* @param text - The file text, or its pieces in order.
+* @param options - The recipe's table parser.
+* @returns The rows, in file order.
+* @throws NativeParseError naming the line of the first problem, including a listed or numeric column the header lacks or a numeric column that is not listed.
+*/
+function parseCsvTable(text, options) {
+	const reader = new TableReader(options);
 	const nodes = [];
-	for (const record of table) {
-		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 id = idColumn === null ? String(nodes.length + 1) : (record.fields[idPosition] ?? "").trim();
-		if (id === "") throw new NativeParseError("csv-table", record.line, `the id column ${idColumn ?? ""} is empty`);
-		const cells = kept.map(({ name, position, factor }) => {
-			const trimmed = (record.fields[position] ?? "").trim();
-			const cell = missing.has(trimmed) ? "" : trimmed;
-			return [name, factor === void 0 ? cell === "" ? null : cell : numeric$1(cell, factor, name, record.line)];
-		});
-		nodes.push({
-			...Object.fromEntries(cells),
-			id
-		});
-	}
+	for (const piece of typeof text === "string" ? [text] : text) for (const row of reader.push(piece)) nodes.push(row);
+	for (const row of reader.end()) nodes.push(row);
 	return { nodes };
 }
 //#endregion
@@ -1222,7 +1494,7 @@ function parseGeojson(text, options) {
 }
 //#endregion
 //#region src/parsers/hhcrsp.ts
-const FORMAT$10 = "hhcrsp";
+const FORMAT$13 = "hhcrsp";
 /** The labels of the sheet's blocks, each the top-left cell of a block whose header runs to its right and whose rows run below it. */
 const LABEL = {
 	patients: "Patients",
@@ -1234,9 +1506,9 @@ const LABEL = {
 };
 /** A service's header, `Service <k>`, a patient's row label and a caregiver's. */
 const SERVICE = /^Service (\d+)$/;
-const NUMBER$7 = /^-?\d+(?:\.\d+)?$/;
+const NUMBER$8 = /^-?\d+(?:\.\d+)?$/;
 /** How many required services a patient may have: the instances ask for one, or two that must be synchronised, and the parser has a duration column for each. */
-const MOST_SERVICES = 2;
+const MOST_SERVICES$1 = 2;
 /**
 * Finds a block by its label: the one cell of the sheet that holds it, its header the cells to its right up to the first empty one, and its rows those below it up to the first whose label and cells are all empty. Past its header a block has an empty column, so the cell there must be empty in every row and a value the header does not label is refused rather than left unread; `Pat / Ser` instead keeps its count there, with the next block starting right after it, and its count is checked on its own.
 * @param grid - The sheet's cells by row.
@@ -1251,7 +1523,7 @@ function blockOf(grid, label, pastHeader = "empty") {
 		column
 	}] : []));
 	const [only] = found;
-	if (only === void 0 || found.length !== 1) throw new NativeParseError(FORMAT$10, 1, `expected one block labelled ${JSON.stringify(label)}, found ${String(found.length)}`);
+	if (only === void 0 || found.length !== 1) throw new NativeParseError(FORMAT$13, 1, `expected one block labelled ${JSON.stringify(label)}, found ${String(found.length)}`);
 	const headerRow = grid[only.line] ?? [];
 	const end = headerRow.findIndex((cell, column) => column > only.column && cell.trim() === "");
 	const header = headerRow.slice(only.column + 1, end === -1 ? headerRow.length : end).map((cell) => cell.trim());
@@ -1260,7 +1532,7 @@ function blockOf(grid, label, pastHeader = "empty") {
 		const cells = (grid[line] ?? []).slice(only.column, only.column + 1 + header.length).map((cell) => cell.trim());
 		if (cells.every((cell) => cell === "")) break;
 		const past = (grid[line] ?? [])[only.column + 1 + header.length]?.trim();
-		if (pastHeader === "empty" && past !== void 0 && past !== "") throw new NativeParseError(FORMAT$10, line + 1, `the ${label} block's row holds ${JSON.stringify(past)} past its header ${JSON.stringify(header)}, which does not label it`);
+		if (pastHeader === "empty" && past !== void 0 && past !== "") throw new NativeParseError(FORMAT$13, line + 1, `the ${label} block's row holds ${JSON.stringify(past)} past its header ${JSON.stringify(header)}, which does not label it`);
 		rows.push({
 			line: line + 1,
 			label: cells[0] ?? "",
@@ -1283,7 +1555,7 @@ function blockOf(grid, label, pastHeader = "empty") {
 * @throws NativeParseError when the cell is not a decimal number.
 */
 function numberOf$4(cell, line, what) {
-	if (cell === void 0 || !NUMBER$7.test(cell)) throw new NativeParseError(FORMAT$10, line, `expected ${what}, found ${JSON.stringify(cell)}`);
+	if (cell === void 0 || !NUMBER$8.test(cell)) throw new NativeParseError(FORMAT$13, line, `expected ${what}, found ${JSON.stringify(cell)}`);
 	return Number(cell);
 }
 /**
@@ -1295,7 +1567,7 @@ function numberOf$4(cell, line, what) {
 */
 function checkNumbered(block, noun, label) {
 	block.rows.forEach((row, index) => {
-		if (row.label !== `${noun} ${String(index + 1)}`) throw new NativeParseError(FORMAT$10, row.line, `the ${label} block's row ${String(index + 1)} is labelled ${JSON.stringify(row.label)}, not ${noun} ${String(index + 1)}`);
+		if (row.label !== `${noun} ${String(index + 1)}`) throw new NativeParseError(FORMAT$13, row.line, `the ${label} block's row ${String(index + 1)} is labelled ${JSON.stringify(row.label)}, not ${noun} ${String(index + 1)}`);
 	});
 }
 /**
@@ -1307,7 +1579,7 @@ function checkNumbered(block, noun, label) {
 */
 function serviceCount(block, label) {
 	block.header.forEach((cell, index) => {
-		if (SERVICE.exec(cell)?.[1] !== String(index + 1)) throw new NativeParseError(FORMAT$10, block.line, `the ${label} block's header cell ${String(index + 1)} is ${JSON.stringify(cell)}, not Service ${String(index + 1)}`);
+		if (SERVICE.exec(cell)?.[1] !== String(index + 1)) throw new NativeParseError(FORMAT$13, block.line, `the ${label} block's header cell ${String(index + 1)} is ${JSON.stringify(cell)}, not Service ${String(index + 1)}`);
 	});
 	return block.header.length;
 }
@@ -1326,7 +1598,7 @@ function parseHhcrsp(text) {
 	const caregiverWindows = blockOf(grid, LABEL.caregiverWindows);
 	const windows = blockOf(grid, LABEL.patientWindows);
 	const serviceKinds = serviceCount(requests, LABEL.requests);
-	if (serviceCount(times, LABEL.times) !== serviceKinds || serviceCount(skills, LABEL.skills) !== serviceKinds) throw new NativeParseError(FORMAT$10, times.line, `the ${LABEL.requests}, ${LABEL.times} and ${LABEL.skills} blocks name different numbers of services`);
+	if (serviceCount(times, LABEL.times) !== serviceKinds || serviceCount(skills, LABEL.skills) !== serviceKinds) throw new NativeParseError(FORMAT$13, times.line, `the ${LABEL.requests}, ${LABEL.times} and ${LABEL.skills} blocks name different numbers of services`);
 	checkNumbered(requests, "Patient", LABEL.requests);
 	checkNumbered(windows, "Patient", LABEL.patientWindows);
 	checkNumbered(skills, "Caregiver", LABEL.skills);
@@ -1341,11 +1613,11 @@ function parseHhcrsp(text) {
 		"",
 		"center",
 		"centre"
-	].includes(centreTimes.label.toLowerCase()) || windows.rows.length !== patients || patientTimes.length !== patients || skills.rows.length !== caregiverWindows.rows.length) throw new NativeParseError(FORMAT$10, requests.line, `the blocks disagree: ${String(patients)} patients requesting services, ${String(patientTimes.length)} with durations after the centre's row, ${String(windows.rows.length)} with time windows, and ${String(skills.rows.length)} caregivers with skills against ${String(caregiverWindows.rows.length)} with windows`);
-	if (positions.header.join(",") !== "X,Y" || positions.rows.length !== patients + 2 || positions.rows.some((row, index) => row.label !== String(index))) throw new NativeParseError(FORMAT$10, positions.line, `the ${LABEL.patients} block must give X and Y for nodes 0 to ${String(patients + 1)}, the centre, ${String(patients)} patients and the centre again`);
+	].includes(centreTimes.label.toLowerCase()) || windows.rows.length !== patients || patientTimes.length !== patients || skills.rows.length !== caregiverWindows.rows.length) throw new NativeParseError(FORMAT$13, requests.line, `the blocks disagree: ${String(patients)} patients requesting services, ${String(patientTimes.length)} with durations after the centre's row, ${String(windows.rows.length)} with time windows, and ${String(skills.rows.length)} caregivers with skills against ${String(caregiverWindows.rows.length)} with windows`);
+	if (positions.header.join(",") !== "X,Y" || positions.rows.length !== patients + 2 || positions.rows.some((row, index) => row.label !== String(index))) throw new NativeParseError(FORMAT$13, positions.line, `the ${LABEL.patients} block must give X and Y for nodes 0 to ${String(patients + 1)}, the centre, ${String(patients)} patients and the centre again`);
 	const position = (index) => {
 		const row = positions.rows[index];
-		if (row === void 0) throw new NativeParseError(FORMAT$10, positions.line, `the ${LABEL.patients} block has no node ${String(index)}`);
+		if (row === void 0) throw new NativeParseError(FORMAT$13, positions.line, `the ${LABEL.patients} block has no node ${String(index)}`);
 		return {
 			x: numberOf$4(row.cells[0], row.line, "an X"),
 			y: numberOf$4(row.cells[1], row.line, "a Y"),
@@ -1354,7 +1626,7 @@ function parseHhcrsp(text) {
 	};
 	const { x, y } = position(0);
 	const closing = position(patients + 1);
-	if (closing.x !== x || closing.y !== y) throw new NativeParseError(FORMAT$10, closing.line, `the last node of the ${LABEL.patients} block is not at the centre's position, so it is not the route's end`);
+	if (closing.x !== x || closing.y !== y) throw new NativeParseError(FORMAT$13, closing.line, `the last node of the ${LABEL.patients} block is not at the centre's position, so it is not the route's end`);
 	const windowColumn = (name) => {
 		const index = windows.header.indexOf(name);
 		return index === -1 ? void 0 : index;
@@ -1365,7 +1637,7 @@ function parseHhcrsp(text) {
 		earliest2: windowColumn("ETW 2"),
 		latest2: windowColumn("LTW 2")
 	};
-	if (columns.earliest1 === void 0 || columns.latest1 === void 0 || columns.earliest2 === void 0 !== (columns.latest2 === void 0) || windows.header.length !== (columns.earliest2 === void 0 ? 2 : 4)) throw new NativeParseError(FORMAT$10, windows.line, `the ${LABEL.patientWindows} header ${JSON.stringify(windows.header)} is not ETW 1 and LTW 1, with or without ETW 2 and LTW 2`);
+	if (columns.earliest1 === void 0 || columns.latest1 === void 0 || columns.earliest2 === void 0 !== (columns.latest2 === void 0) || windows.header.length !== (columns.earliest2 === void 0 ? 2 : 4)) throw new NativeParseError(FORMAT$13, windows.line, `the ${LABEL.patientWindows} header ${JSON.stringify(windows.header)} is not ETW 1 and LTW 1, with or without ETW 2 and LTW 2`);
 	const nodes = [{
 		id: "0",
 		role: "centre",
@@ -1381,15 +1653,15 @@ function parseHhcrsp(text) {
 	}];
 	requests.rows.forEach((request, index) => {
 		const required = request.cells.flatMap((cell, service) => {
-			if (cell !== "0" && cell !== "1" && cell !== "") throw new NativeParseError(FORMAT$10, request.line, `${request.label} has ${JSON.stringify(cell)} for Service ${String(service + 1)}, not 0, 1 or empty`);
+			if (cell !== "0" && cell !== "1" && cell !== "") throw new NativeParseError(FORMAT$13, request.line, `${request.label} has ${JSON.stringify(cell)} for Service ${String(service + 1)}, not 0, 1 or empty`);
 			return cell === "1" ? [service] : [];
 		});
 		const stated = (grid[request.line - 1] ?? [])[requests.column + serviceKinds + 1]?.trim();
-		if (stated !== String(required.length)) throw new NativeParseError(FORMAT$10, request.line, `${request.label} requires ${String(required.length)} services by its marks, and the count beside them is ${JSON.stringify(stated)}`);
-		if (required.length === 0 || required.length > MOST_SERVICES) throw new NativeParseError(FORMAT$10, request.line, `${request.label} requires ${String(required.length)} services, and a patient requires one or two`);
+		if (stated !== String(required.length)) throw new NativeParseError(FORMAT$13, request.line, `${request.label} requires ${String(required.length)} services by its marks, and the count beside them is ${JSON.stringify(stated)}`);
+		if (required.length === 0 || required.length > MOST_SERVICES$1) throw new NativeParseError(FORMAT$13, request.line, `${request.label} requires ${String(required.length)} services, and a patient requires one or two`);
 		const timeRow = patientTimes[index];
 		const windowRow = windows.rows[index];
-		if (timeRow === void 0 || windowRow === void 0) throw new NativeParseError(FORMAT$10, request.line, `${request.label} has no durations or time windows`);
+		if (timeRow === void 0 || windowRow === void 0) throw new NativeParseError(FORMAT$13, request.line, `${request.label} has no durations or time windows`);
 		const duration = (which) => {
 			const service = required[which];
 			return service === void 0 ? null : numberOf$4(timeRow.cells[service], timeRow.line, `the duration of Service ${String(service + 1)}`);
@@ -1420,6 +1692,433 @@ function parseHhcrsp(text) {
 	};
 }
 //#endregion
+//#region src/parsers/mankowska.ts
+const FORMAT$12 = "mankowska";
+/** The sections of the file, each a keyword on a line of its own followed by its numbers. */
+const SECTIONS$1 = [
+	"nbNodes",
+	"nbVehi",
+	"nbServi",
+	"r",
+	"DS",
+	"a",
+	"x",
+	"y",
+	"d",
+	"p",
+	"mind",
+	"maxd",
+	"e",
+	"l"
+];
+/** How many patients a double service has, and so the most required services a patient can have. */
+const MOST_SERVICES = 2;
+/** The depot copies: the first and the last node. */
+const DEPOTS = 2;
+const NUMBER$7 = /^-?\d+(?:\.\d+)?$/;
+const KEYWORD = /^[A-Za-z]+$/;
+/**
+* Splits the file into its sections: a line holding one word starts a section, and every number on the lines after it, up to the next such line, is the section's.
+* @param text - The file text.
+* @returns Each section by its keyword.
+* @throws NativeParseError for a keyword the format does not have, one given twice, a value that is not a number, or a number before the first keyword.
+*/
+function sectionsOf$1(text) {
+	const sections = /* @__PURE__ */ new Map();
+	let current;
+	for (const [index, raw] of lines(text).entries()) {
+		const tokens = raw.trim().split(/\s+/).filter((token) => token !== "");
+		const [only] = tokens;
+		if (tokens.length === 1 && only !== void 0 && KEYWORD.test(only)) {
+			const name = SECTIONS$1.find((section) => section === only);
+			if (name === void 0 || sections.has(name)) throw new NativeParseError(FORMAT$12, index + 1, name === void 0 ? `the section ${JSON.stringify(only)} is not one of ${SECTIONS$1.join(", ")}` : `the section ${name} is given twice`);
+			current = [];
+			sections.set(name, {
+				line: index + 1,
+				values: current
+			});
+			continue;
+		}
+		for (const token of tokens) {
+			if (current === void 0 || !NUMBER$7.test(token)) throw new NativeParseError(FORMAT$12, index + 1, current === void 0 ? "a number comes before the first section" : `expected a number, found ${JSON.stringify(token)}`);
+			current.push(Number(token));
+		}
+	}
+	return sections;
+}
+/**
+* Reads a section that must hold a given count of numbers.
+* @param sections - The sections.
+* @param name - The section.
+* @param count - How many numbers it must hold.
+* @returns Its numbers.
+* @throws NativeParseError when the section is missing or holds another count.
+*/
+function sized(sections, name, count) {
+	const section = sections.get(name);
+	if (section === void 0) throw new NativeParseError(FORMAT$12, 1, `the file has no ${name} section`);
+	if (section.values.length !== count) throw new NativeParseError(FORMAT$12, section.line, `the ${name} section holds ${String(section.values.length)} numbers where ${String(count)} are due`);
+	return section.values;
+}
+/**
+* Reads a count section (`nbNodes`, `nbVehi`, `nbServi`): one whole number of at least a least value.
+* @param sections - The sections.
+* @param name - The section.
+* @param least - The smallest count that makes an instance.
+* @returns The count.
+* @throws NativeParseError when the section is missing, holds more than one number, or the count is not a whole number of at least `least`.
+*/
+function countOf(sections, name, least) {
+	const [count] = sized(sections, name, 1);
+	if (count === void 0 || !Number.isInteger(count) || count < least) throw new NativeParseError(FORMAT$12, sections.get(name)?.line ?? 1, `${name} must be a whole number of at least ${String(least)}, found ${String(count)}`);
+	return count;
+}
+/**
+* Reads one cell of a row-major matrix section.
+* @param values - The section's numbers.
+* @param columns - The matrix's width.
+* @param row - The row.
+* @param column - The column.
+* @returns The cell.
+* @throws NativeParseError when the cell is outside the section, which `sized` has already ruled out.
+*/
+function cell(values, columns, row, column) {
+	const value = values[row * columns + column];
+	if (value === void 0) throw new NativeParseError(FORMAT$12, 1, `cell ${String(row)}, ${String(column)} is outside its section`);
+	return value;
+}
+/**
+* Parses a home health care routing and scheduling instance in the keyword text format of Mankowska, Meisel and Bierwirth (2014), as the OVIG generator writes it: the counts of nodes (`nbNodes`, the patients and two copies of the depot, the first and the last), vehicles (`nbVehi`, the caregivers) and services (`nbServi`); the services each node requires (`r`, a node by service matrix of zeros and ones), the double service nodes (`DS`, node numbers from one), the services each caregiver can give (`a`), the positions (`x`, `y`), the travel matrix (`d`), the processing time of each service at each node by each caregiver (`p`, a row per node and caregiver), the least and most time between a double service's two services (`mind`, `maxd`), and the time windows (`e`, `l`). A node's id is its number from zero. The depot copies are marked as requiring every service, which is the format's convention and not a visit, so they carry no services or processing times. A patient's required services are their numbers from one, joined by spaces, and its first and second processing time are those of its required services in that order. The travel matrix and the caregivers' qualifications are not node fields and are not kept; the processing times must not differ between caregivers, since a node column holds one value. The gaps are kept for a double service node only. The units of time are the generator's own.
+* @param text - The file text.
+* @returns The instance: its patient, caregiver and service kind counts as `meta`, and its nodes in node order.
+* @throws NativeParseError naming the line for a section that is missing, given twice or of the wrong size, a value that is not a number, a requirement that is not zero or one, a node with more than two required services, a double service node with fewer than two or out of range, or processing times that differ between caregivers.
+*/
+function parseMankowska(text) {
+	const sections = sectionsOf$1(text);
+	const nodeCount = countOf(sections, "nbNodes", DEPOTS);
+	const caregivers = countOf(sections, "nbVehi", 1);
+	const serviceKinds = countOf(sections, "nbServi", 1);
+	const required = sized(sections, "r", nodeCount * serviceKinds);
+	sized(sections, "a", caregivers * serviceKinds);
+	const xs = sized(sections, "x", nodeCount);
+	const ys = sized(sections, "y", nodeCount);
+	sized(sections, "d", nodeCount * nodeCount);
+	const times = sized(sections, "p", nodeCount * caregivers * serviceKinds);
+	const least = sized(sections, "mind", nodeCount);
+	const most = sized(sections, "maxd", nodeCount);
+	const earliest = sized(sections, "e", nodeCount);
+	const latest = sized(sections, "l", nodeCount);
+	const line = (name) => sections.get(name)?.line ?? 1;
+	const doubles = new Set((sections.get("DS")?.values ?? []).map((number) => {
+		if (!Number.isInteger(number) || number < 1 || number > nodeCount) throw new NativeParseError(FORMAT$12, line("DS"), `the double service node ${String(number)} is not a node number from 1 to ${String(nodeCount)}`);
+		return number - 1;
+	}));
+	const nodes = Array.from({ length: nodeCount }, (_, node) => {
+		const at = (values) => cell(values, 1, node, 0);
+		if (node === 0 || node === nodeCount - 1) return {
+			id: String(node),
+			role: "depot",
+			x: at(xs),
+			y: at(ys),
+			services: null,
+			duration1: null,
+			duration2: null,
+			earliest: at(earliest),
+			latest: at(latest),
+			minGap: null,
+			maxGap: null
+		};
+		const services = Array.from({ length: serviceKinds }, (__, service) => service).filter((service) => {
+			const flag = cell(required, serviceKinds, node, service);
+			if (flag !== 0 && flag !== 1) throw new NativeParseError(FORMAT$12, line("r"), `node ${String(node)} has the requirement ${String(flag)} for service ${String(service + 1)}, not 0 or 1`);
+			return flag === 1;
+		});
+		if (services.length > MOST_SERVICES || doubles.has(node) && services.length !== MOST_SERVICES) throw new NativeParseError(FORMAT$12, line("r"), `node ${String(node)} requires ${String(services.length)} services${doubles.has(node) ? " but is a double service node" : ""}`);
+		const [first, second] = services.map((service) => {
+			const byCaregiver = Array.from({ length: caregivers }, (__, caregiver) => cell(times, serviceKinds, node * caregivers + caregiver, service));
+			const [time] = byCaregiver;
+			if (time === void 0 || byCaregiver.some((other) => other !== time)) throw new NativeParseError(FORMAT$12, line("p"), `node ${String(node)} has processing times for service ${String(service + 1)} that differ between caregivers (${byCaregiver.join(", ")})`);
+			return time;
+		});
+		return {
+			id: String(node),
+			role: "patient",
+			x: at(xs),
+			y: at(ys),
+			services: services.length === 0 ? null : services.map((service) => String(service + 1)).join(" "),
+			duration1: first ?? null,
+			duration2: second ?? null,
+			earliest: at(earliest),
+			latest: at(latest),
+			minGap: doubles.has(node) ? at(least) : null,
+			maxGap: doubles.has(node) ? at(most) : null
+		};
+	});
+	return {
+		meta: {
+			patients: nodeCount - DEPOTS,
+			caregivers,
+			serviceKinds
+		},
+		nodes
+	};
+}
+//#endregion
+//#region src/parsers/tdc.ts
+const FORMAT$11 = "tdc";
+/** A technician line: its id, skills, time window and whether it is an investment option. */
+const TECHNICIAN = /^Technician id \d+, skills \[[^\]]*\], time window \[[^\]]*\], investment option (?:true|false)$/;
+/** A task line, with the fields the parser keeps captured: id, skills, duration, window opening and closing, priority, penalty, creation, modification (or `nothing`) and cancellation; its relevant technicians follow and are not kept. */
+const TASK = /^Task id (\d+), skills \[([^\]]*)\], duration (\d+), time window \[([^,\]]+), ([^\]]+)\], priority (\d+), penalty (-?\d+(?:\.\d+)?), created ([^,]+), modified ([^,]+), cancelled (true|false), relevant technician ids (?:Int64)?\[[\d, ]*\]$/;
+/** A travel time line, between two tasks or between a technician and a task, in either direction. */
+const TRAVEL = /^(?:task|technician)\d+(?:task|technician)\d+: -?\d+(?:\.\d+)?$/;
+/** The section headings, in the order the file gives them. */
+const HEADINGS = [
+	"Technicians:",
+	"Tasks:",
+	"Travel time:"
+];
+/** What a line before any heading and a line of each section is, for errors: indexed by the section's position plus one, so the lines before the first heading are first. */
+const SECTION_NOUNS = [
+	"heading",
+	"technician",
+	"task",
+	"travel time"
+];
+/**
+* Names what a position's lines are, for an error.
+* @param position - A section's position plus one.
+* @returns The noun.
+*/
+function nounOf(position) {
+	return SECTION_NOUNS[position] ?? `section ${String(position)}`;
+}
+/** Where the task pattern captures each field it keeps. */
+const TASK_AT = {
+	id: 1,
+	skills: 2,
+	duration: 3,
+	earliest: 4,
+	latest: 5,
+	priority: 6,
+	penalty: 7,
+	created: 8,
+	modified: 9,
+	cancelled: 10
+};
+/** How much of a refused line an error shows. */
+const SHOWN = 120;
+/**
+* Parses a technician routing and scheduling instance in the sectioned text format of Gamst and Pisinger (2024): a `Technicians:` heading and a line per technician, a `Tasks:` heading and a line per task (`Task id <n>, skills ["<skill>", ...], duration <minutes>, time window [<opening>, <closing>], priority <n>, penalty <n>, created <time>, modified <time or nothing>, cancelled <true or false>, relevant technician ids [<ids>]`), then a `Travel time:` heading and a line per pair, the travel minutes between two tasks or between a technician and a task. The file is read a line at a time and the travel time lines, almost all of a file, are checked and let go, as the tasks/v1 target has no arcs; a technician's line is counted. A task's id is its id, and a modification of `nothing` is null. Times are as the file writes them.
+* @param pieces - The file's text, in pieces.
+* @returns The instance: its technician count as `meta`, and its tasks in file order.
+* @throws NativeParseError naming the line for a heading out of order or missing, a line that is not of its section's shape, or a task id given twice.
+*/
+function parseTdc(pieces) {
+	let section = -1;
+	let technicians = 0;
+	const nodes = [];
+	const ids = /* @__PURE__ */ new Set();
+	forEachLine(pieces, (raw, line) => {
+		const text = raw.trim();
+		if (text === "") return;
+		const heading = HEADINGS.findIndex((candidate) => candidate === text);
+		if (heading !== -1) {
+			if (heading !== section + 1) throw new NativeParseError(FORMAT$11, line, `the heading ${text} is out of order`);
+			section = heading;
+			return;
+		}
+		if (section === 0 && TECHNICIAN.test(text)) {
+			technicians += 1;
+			return;
+		}
+		if (section === 2 && TRAVEL.test(text)) return;
+		const task = section === 1 ? TASK.exec(text) : null;
+		if (task === null) throw new NativeParseError(FORMAT$11, line, `the line is not a ${nounOf(section + 1)} line: ${JSON.stringify(text.slice(0, SHOWN))}`);
+		const field = (index) => {
+			const value = task[index];
+			if (value === void 0) throw new NativeParseError(FORMAT$11, line, `the task line has no field ${String(index)}`);
+			return value;
+		};
+		const id = field(TASK_AT.id);
+		if (ids.has(id)) throw new NativeParseError(FORMAT$11, line, `the task ${id} is given twice`);
+		ids.add(id);
+		const skills = field(TASK_AT.skills).split(",").map((skill) => skill.trim().replace(/^"|"$/g, "")).filter((skill) => skill !== "");
+		const modified = field(TASK_AT.modified);
+		nodes.push({
+			id,
+			skills: skills.length === 0 ? null : skills.join(" "),
+			durationMinutes: Number(field(TASK_AT.duration)),
+			earliest: field(TASK_AT.earliest).trim(),
+			latest: field(TASK_AT.latest).trim(),
+			priority: Number(field(TASK_AT.priority)),
+			penalty: Number(field(TASK_AT.penalty)),
+			created: field(TASK_AT.created),
+			modified: modified === "nothing" ? null : modified,
+			cancelled: field(TASK_AT.cancelled)
+		});
+	});
+	if (section !== HEADINGS.length - 1) throw new NativeParseError(FORMAT$11, 1, `the file has no ${nounOf(section + 2)} heading`);
+	return {
+		meta: { technicians },
+		nodes
+	};
+}
+//#endregion
+//#region src/parsers/verolog-2017.ts
+const FORMAT$10 = "verolog-2017";
+/** The header lines, with the key of `meta` each fills and whether its value is text. */
+const HEADER$3 = /* @__PURE__ */ new Map([
+	["DATASET", ["dataset", "text"]],
+	["NAME", ["name", "text"]],
+	["DAYS", ["days", "number"]],
+	["CAPACITY", ["capacity", "number"]],
+	["MAX_TRIP_DISTANCE", ["maxTripDistance", "number"]],
+	["DEPOT_COORDINATE", ["depotCoordinate", "number"]],
+	["VEHICLE_COST", ["vehicleCost", "number"]],
+	["VEHICLE_DAY_COST", ["vehicleDayCost", "number"]],
+	["DISTANCE_COST", ["distanceCost", "number"]]
+]);
+/** The sections that hold rows, and how many numbers each row has. */
+const SECTION_WIDTHS = {
+	TOOLS: 4,
+	COORDINATES: 3,
+	REQUESTS: 7
+};
+/** Where a request row keeps its fields. */
+const REQUEST_AT$1 = {
+	id: 0,
+	location: 1,
+	fromDay: 2,
+	toDay: 3,
+	stayDays: 4,
+	tool: 5,
+	amount: 6
+};
+const WHOLE$3 = /^-?\d+$/;
+/**
+* Reads a field of a row.
+* @param row - The row.
+* @param index - The field's position.
+* @returns The number.
+* @throws NativeParseError when the row has no such field.
+*/
+function at(row, index) {
+	const value = row.values[index];
+	if (value === void 0) throw new NativeParseError(FORMAT$10, row.line, `the row has no field ${String(index + 1)}`);
+	return value;
+}
+/**
+* Parses an instance of the ORTEC VeRoLog Solver Challenge 2016 to 2017 (Kheiri et al. 2019): `KEY = value` header lines (the dataset and instance names, the planning days, the vehicle capacity, the longest trip, the depot's coordinate id and the three costs), then three sections each opened by `NAME = <count>` and followed by that many rows of whole numbers: `TOOLS` (id, size, how many are available, cost a day), `COORDINATES` (id, x, y) and `REQUESTS` (id, location, first day, last day, days the tools stay, tool kind, how many). Fields are separated by runs of spaces or tabs, and blank lines are skipped. The nodes are the depot, at its coordinate, with the id `depot`, then one node per request under the request's id at the position of its location. The tool table's sizes, availability and costs are not node fields and are not kept; its row count is.
+* @param text - The file text.
+* @returns The instance: its header values and tool count as `meta`, and its nodes, the depot first and the requests in file order.
+* @throws NativeParseError naming the line for an unknown or repeated key, a header value that is not a number where one is due, a missing header line or section, a section with a different number of rows than it says, a row that is not its section's count of whole numbers, a coordinate given twice, a request at a location the file does not give, or a request id given twice.
+*/
+function parseVerolog2017(text) {
+	const meta = /* @__PURE__ */ new Map();
+	const sections = /* @__PURE__ */ new Map();
+	let open;
+	const close = () => {
+		if (open !== void 0 && open.rows.length !== open.count) throw new NativeParseError(FORMAT$10, open.line, `the ${open.name} section says ${String(open.count)} rows and has ${String(open.rows.length)}`);
+		open = void 0;
+	};
+	for (const [index, raw] of lines(text).entries()) {
+		const line = index + 1;
+		const trimmed = raw.trim();
+		if (trimmed === "") continue;
+		const keyed = /^([A-Z_]+)\s*=\s*(.*)$/.exec(trimmed);
+		if (keyed?.[1] !== void 0 && keyed[2] !== void 0) {
+			close();
+			const [, key, value] = keyed;
+			const section = Object.keys(SECTION_WIDTHS).find((name) => name === key);
+			if (section !== void 0) {
+				if (sections.has(section) || !WHOLE$3.test(value)) throw new NativeParseError(FORMAT$10, line, sections.has(section) ? `the ${section} section is given twice` : `the ${section} section's count ${JSON.stringify(value)} is not a whole number`);
+				const rows = [];
+				sections.set(section, rows);
+				open = {
+					name: section,
+					rows,
+					count: Number(value),
+					line
+				};
+				continue;
+			}
+			const header = HEADER$3.get(key);
+			if (header === void 0 || meta.has(header[0])) throw new NativeParseError(FORMAT$10, line, header === void 0 ? `the key ${key} is not one this format has` : `the key ${key} is given twice`);
+			const [name, kind] = header;
+			if (kind === "number" && !/^-?\d+(?:\.\d+)?$/.test(value)) throw new NativeParseError(FORMAT$10, line, `${key} must be a number, found ${JSON.stringify(value)}`);
+			meta.set(name, kind === "number" ? Number(value) : value);
+			continue;
+		}
+		const tokens = trimmed.split(/\s+/);
+		if (open === void 0 || tokens.length !== SECTION_WIDTHS[open.name] || !tokens.every((token) => WHOLE$3.test(token))) throw new NativeParseError(FORMAT$10, line, open === void 0 ? `the row ${JSON.stringify(trimmed)} is outside any section` : `a ${open.name} row is ${String(SECTION_WIDTHS[open.name])} whole numbers, found ${JSON.stringify(trimmed)}`);
+		open.rows.push({
+			line,
+			values: tokens.map(Number)
+		});
+	}
+	close();
+	for (const [key, [name]] of HEADER$3) if (!meta.has(name)) throw new NativeParseError(FORMAT$10, 1, `the file has no ${key} line`);
+	const rowsOf = (name) => {
+		const rows = sections.get(name);
+		if (rows === void 0) throw new NativeParseError(FORMAT$10, 1, `the file has no ${name} section`);
+		return rows;
+	};
+	const tools = rowsOf("TOOLS").length;
+	const positions = /* @__PURE__ */ new Map();
+	for (const row of rowsOf("COORDINATES")) {
+		const id = at(row, 0);
+		if (positions.has(id)) throw new NativeParseError(FORMAT$10, row.line, `the coordinate ${String(id)} is given twice`);
+		positions.set(id, [at(row, 1), at(row, 2)]);
+	}
+	const positionOf = (location, line) => {
+		const position = positions.get(location);
+		if (position === void 0) throw new NativeParseError(FORMAT$10, line, `the location ${String(location)} is not among the coordinates`);
+		return position;
+	};
+	const depot = Number(meta.get("depotCoordinate"));
+	const [depotX, depotY] = positionOf(depot, 1);
+	const nodes = [{
+		id: "depot",
+		x: depotX,
+		y: depotY,
+		kind: "depot",
+		location: depot,
+		fromDay: null,
+		toDay: null,
+		stayDays: null,
+		tool: null,
+		amount: null
+	}];
+	const ids = /* @__PURE__ */ new Set();
+	for (const row of rowsOf("REQUESTS")) {
+		const id = String(at(row, REQUEST_AT$1.id));
+		if (ids.has(id)) throw new NativeParseError(FORMAT$10, row.line, `the request ${id} is given twice`);
+		ids.add(id);
+		const location = at(row, REQUEST_AT$1.location);
+		const [x, y] = positionOf(location, row.line);
+		nodes.push({
+			id,
+			x,
+			y,
+			kind: "request",
+			location,
+			fromDay: at(row, REQUEST_AT$1.fromDay),
+			toDay: at(row, REQUEST_AT$1.toDay),
+			stayDays: at(row, REQUEST_AT$1.stayDays),
+			tool: String(at(row, REQUEST_AT$1.tool)),
+			amount: at(row, REQUEST_AT$1.amount)
+		});
+	}
+	return {
+		meta: {
+			...Object.fromEntries(meta),
+			tools
+		},
+		nodes
+	};
+}
+//#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([
@@ -2945,28 +3644,60 @@ const KIBIBYTE = 1024;
 /** Bytes decoded at a time for a format that is read in pieces. The decoder holds only a piece's text at once, so this bounds what a large table costs beyond its bytes; it is large enough that the per-piece work is small beside the piece. */
 const DECODE_PIECE_BYTES = 8 * KIBIBYTE * KIBIBYTE;
 /**
-* Decodes a file's bytes in the recipe's encoding a piece at a time, as strictly as `decode`, so a file whose text would not fit in one string can still be read.
-* @param bytes - The unpacked file.
-* @param parser - The recipe's parser, which names the encoding.
-* @param pieceBytes - How many bytes to decode at a time.
-* @returns The text of each piece, in order; a character that spans two pieces is yielded whole with the later one.
-* @throws NativeParseError when the bytes are not valid in the stated encoding.
+* Decodes a file's bytes in the recipe's encoding as they arrive in pieces, as strictly as `decode`: a character whose bytes span two pieces is decoded whole with the later one, and bytes that are not valid in the stated encoding fail.
 */
-function* decodePieces(bytes, parser, pieceBytes = DECODE_PIECE_BYTES) {
-	const decoder = parser.encoding === "latin1" ? void 0 : new TextDecoder("utf-8", { fatal: true });
-	try {
-		for (let start = 0; start < bytes.length; start += pieceBytes) {
-			const piece = bytes.subarray(start, start + pieceBytes);
-			yield decoder === void 0 ? decode(piece, parser) : decoder.decode(piece, { stream: true });
-		}
-		if (decoder !== void 0) {
-			const rest = decoder.decode();
-			if (rest !== "") yield rest;
+var PieceDecoder = class {
+	parser;
+	utf8;
+	constructor(parser) {
+		this.parser = parser;
+		this.utf8 = parser.encoding === "latin1" ? void 0 : new TextDecoder("utf-8", { fatal: true });
+	}
+	/**
+	* Decodes the next piece.
+	* @param piece - Bytes that follow the pieces decoded before them.
+	* @returns Their text, without a character the piece ends partway through.
+	* @throws NativeParseError when the bytes are not valid in the stated encoding.
+	*/
+	decode(piece) {
+		const { utf8 } = this;
+		return utf8 === void 0 ? decode(piece, this.parser) : this.strictly(() => utf8.decode(piece, { stream: true }));
+	}
+	/**
+	* Ends the file.
+	* @returns The text of any bytes still held.
+	* @throws NativeParseError when the file ends partway through a character.
+	*/
+	end() {
+		const { utf8 } = this;
+		return utf8 === void 0 ? "" : this.strictly(() => utf8.decode());
+	}
+	/**
+	* Runs a utf-8 decode, rethrowing its failure in the package's taxonomy: TextDecoder reports invalid bytes only as a TypeError with no position.
+	* @param run - The decode.
+	* @returns Its text.
+	*/
+	strictly(run) {
+		try {
+			return run();
+		} catch (error) {
+			throw new NativeParseError(this.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`);
 		}
-	} catch (error) {
-		if (error instanceof NativeParseError) throw error;
-		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`);
 	}
+};
+/**
+* Decodes a file's bytes in the recipe's encoding a piece at a time, as strictly as `decode`, so a file whose text would not fit in one string can still be read.
+* @param bytes - The unpacked file.
+* @param parser - The recipe's parser, which names the encoding.
+* @param pieceBytes - How many bytes to decode at a time.
+* @returns The text of each piece, in order; a character that spans two pieces is yielded whole with the later one.
+* @throws NativeParseError when the bytes are not valid in the stated encoding.
+*/
+function* decodePieces(bytes, parser, pieceBytes = DECODE_PIECE_BYTES) {
+	const decoder = new PieceDecoder(parser);
+	for (let start = 0; start < bytes.length; start += pieceBytes) yield decoder.decode(bytes.subarray(start, start + pieceBytes));
+	const rest = decoder.end();
+	if (rest !== "") yield rest;
 }
 function parseNative(bytes, parser) {
 	if (parser.format === "csv-table") return parseCsvTable(decodePieces(bytes, parser), parser);
@@ -2977,10 +3708,10 @@ function parseNative(bytes, parser) {
 		split: void 0,
 		pieces: decodePieces(bytes, parser)
 	}], parser);
-	if (parser.format === "hgb") throw new NativeParseError(parser.format, 1, "an HGB dataset is two files, nodes and links, which a recipe reads from a parts archive");
+	if (parser.format === "tdc") return parseTdc(decodePieces(bytes, parser));
+	if (parser.format === "edge-list") return parseEdgeList(decodePieces(bytes, parser), parser);
 	const text = decode(bytes, parser);
 	if (parser.format === "geojson") return parseGeojson(text, 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 === "ucinet-dl") return parseUcinetDl(text, parser);
@@ -2994,6 +3725,9 @@ function parseNative(bytes, parser) {
 	if (parser.format === "verolog-2019") return parseVerolog2019(text);
 	if (parser.format === "vrp-rep") return parseVrpRep(text);
 	if (parser.format === "hhcrsp") return parseHhcrsp(text);
+	if (parser.format === "ogb") throw new NativeParseError(parser.format, 1, "the format reads the several files a files archive selects, not one file");
+	if (parser.format === "mankowska") return parseMankowska(text);
+	if (parser.format === "verolog-2017") return parseVerolog2017(text);
 	return parsePajek(text);
 }
 /**
@@ -3019,6 +3753,20 @@ function parseNativeParts(parts, parser) {
 	}
 	throw new NativeParseError(parser.format, 1, `the ${parser.format} parser reads one file, not named parts`);
 }
+/**
+* Reads the several files of a multi-file format into the one native document they make together.
+* @param files - The files a `files` archive selects, each with its path in the archive, in path order.
+* @param parser - The recipe's parser, which must be a multi-file format.
+* @returns The native graph.
+* @throws NativeParseError when a file is not valid in the stated encoding or the files are not in the stated format, or when the parser reads one file and not several.
+*/
+function parseNativeFiles(files, parser) {
+	if (parser.format !== "ogb") throw new NativeParseError(parser.format, 1, "the format reads one file, not the several a files archive selects");
+	return parseOgb(files.map((file) => ({
+		path: file.path,
+		text: () => decodePieces(file.bytes, parser)
+	})));
+}
 //#endregion
 //#region src/node/bzip2.ts
 /** The four bytes every bzip2 stream starts with, as ASCII: `BZh` and the block size digit, `1` to `9`. */
@@ -4798,18 +5546,20 @@ function unpackShapefile(bytes, member) {
 	};
 }
 /**
-* Unpacks downloaded bytes into every file a collection's selector matches, or, with an `xlsx` inner layout, into every sheet of every matched workbook that its `sheets` pattern matches as the sheet's CSV, at the member's path and the sheet's name joined by `/`, members in path order and sheets in the workbook's order.
+* Unpacks downloaded bytes into every file a collection's selector matches, or, with an `xlsx` inner layout, into every sheet of every matched workbook that its `sheets` pattern matches as the sheet's CSV, at the member's path and the sheet's name joined by `/`, members in path order and sheets in the workbook's order. The files are given one at a time: a zip member is inflated only when it is reached, so a reader that lets each file go before taking the next holds one member's bytes beside the archive, never every member at once.
 * @param bytes - The downloaded bytes.
 * @param archive - The recipe's archive layout, which selects members with `members`.
 * @returns Each file.
-* @throws ArchiveError when the bytes are not a well-formed archive of the stated kind, the selector matches no member, or a member an `xlsx` layout reads is not a workbook or has no sheet the pattern matches.
+* @throws ArchiveError when the bytes are not a well-formed archive of the stated kind, the selector matches no member (at the first file taken), or a member an `xlsx` layout reads is not a workbook or has no sheet the pattern matches (at that member).
 */
-function unpackMembers(bytes, archive) {
-	const members = selectMembers(bytes, archive);
-	if (archive.inner === void 0) return members;
-	const { sheets } = archive.inner;
+function* unpackMembers(bytes, archive) {
+	const { sheets } = archive.inner ?? {};
 	const wanted = sheets === void 0 ? void 0 : new RegExp(`^(?:${sheets})$`, "u");
-	return members.flatMap((member) => {
+	for (const member of selectMembers(bytes, archive)) {
+		if (archive.inner === void 0) {
+			yield member;
+			continue;
+		}
 		let names;
 		try {
 			names = sheetNames(member.bytes).filter((sheet) => wanted === void 0 || wanted.test(sheet));
@@ -4817,24 +5567,24 @@ function unpackMembers(bytes, archive) {
 			throw new ArchiveError(`member ${member.path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
 		}
 		if (names.length === 0) throw new ArchiveError(`member ${member.path} has no sheet matching ${sheets ?? ""}`);
-		return names.map((sheet) => ({
+		yield* names.map((sheet) => ({
 			path: `${member.path}/${sheet}`,
 			bytes: sheetToCsv(member.bytes, {
 				kind: "xlsx",
 				sheet
 			})
 		}));
-	});
+	}
 }
 /**
-* Unpacks every member a collection's selector matches.
+* Unpacks every member a collection's selector matches, one at a time.
 * @param bytes - The downloaded bytes.
 * @param archive - The recipe's archive layout.
 * @returns Each matching member, in path order.
-* @throws ArchiveError when the bytes are not a well-formed archive of the stated kind or the selector matches no member.
+* @throws ArchiveError when the bytes are not a well-formed archive of the stated kind or the selector matches no member, at the first member taken.
 */
-function selectMembers(bytes, archive) {
-	return readMembers(bytes, archive.kind, (paths) => pickAll(paths, archive.members).map((path) => ({ path })));
+function* selectMembers(bytes, archive) {
+	yield* readMembers(bytes, archive.kind, (paths) => pickAll(paths, archive.members).map((path) => ({ path })));
 }
 /**
 * Unpacks downloaded bytes into the files a parts archive names, each the one member its selector matches.
@@ -4844,57 +5594,45 @@ function selectMembers(bytes, archive) {
 * @throws ArchiveError when the bytes are not a well-formed archive of the stated kind or a part's selector does not match exactly one member.
 */
 function unpackParts(bytes, archive) {
-	return readMembers(bytes, archive.kind, (paths) => archive.parts.map((part) => ({
+	return [...readMembers(bytes, archive.kind, (paths) => archive.parts.map((part) => ({
 		name: part.name,
 		path: pick(paths, part.member)
-	})));
+	})))];
 }
 /**
-* Reads the members of a file archive that a choice makes from its member paths, listing the archive once and decompressing it once however many members are chosen.
-* @param bytes - The downloaded bytes.
+* Reads the members of a file archive that a choice makes from its member paths, one at a time: the archive is listed once and a zip member is inflated only when it is reached, so a reader that lets each member go before taking the next holds one member's bytes beside the archive.
+* @param bytes - The archive's bytes.
 * @param kind - The archive kind.
 * @param choose - Given every member path, the members to read, in the order wanted, each naming its path.
 * @returns Each choice with the bytes of the member it names, in the order chosen.
 * @throws ArchiveError when the bytes are not a well-formed archive of the stated kind or a chosen member cannot be read; whatever `choose` throws.
 */
-function readMembers(bytes, kind, choose) {
+function* readMembers(bytes, kind, choose) {
 	if (kind === "zip") {
 		const names = [];
 		unzip(bytes, (file) => {
 			names.push(file.name);
 			return false;
 		});
-		const choices = choose(names);
-		const chosen = new Set(choices.map((choice) => choice.path));
-		const files = unzip(bytes, (candidate) => chosen.has(candidate.name));
-		return choices.map((choice) => {
-			const file = getOwn(files, choice.path);
+		for (const choice of choose(names)) {
+			const file = getOwn(unzip(bytes, (candidate) => candidate.name === choice.path), choice.path);
 			if (file === void 0) throw new ArchiveError(`zip member ${choice.path} could not be read`);
-			return {
+			yield {
 				...choice,
 				bytes: file
 			};
-		});
+		}
+		return;
 	}
 	const members = readTar(untarred(bytes, kind));
-	return choose(members.map((member) => member.path)).map((choice) => {
+	for (const choice of choose(members.map((member) => member.path))) {
 		const found = members.find((member) => member.path === choice.path);
 		if (found === void 0) throw new ArchiveError(`tar member ${choice.path} could not be read`);
-		return {
+		yield {
 			...choice,
 			bytes: found.data
 		};
-	});
-}
-/**
-* Removes the compression a tar archive kind states, leaving the tar bytes.
-* @param bytes - The downloaded bytes.
-* @param kind - The tar archive kind: `tar` is uncompressed, `tar.gz` is gzip and `tar.bz2` is bzip2.
-* @returns The tar archive.
-*/
-function untarred(bytes, kind) {
-	if (kind === "tar") return bytes;
-	return kind === "tar.gz" ? gunzip(bytes) : bunzip2(bytes);
+	}
 }
 /**
 * Reads one sheet of a spreadsheet as CSV text, by the spreadsheet's format.
@@ -4912,6 +5650,41 @@ function sheetToCsv(bytes, archive) {
 	return gridToCsv(read(bytes, archive.sheet));
 }
 /**
+* Unpacks downloaded bytes into every file a multi-file format's selector matches, gunzipping each when the layout's `inner` says so. The paths stay the archive's own, so a gunzipped `edge.csv.gz` keeps its name.
+* @param bytes - The downloaded bytes.
+* @param archive - The recipe's archive layout, which selects files with `files`.
+* @returns Each matching file, in path order.
+* @throws ArchiveError when the bytes, or a file `inner` gunzips, are not well-formed, or the selector matches no member.
+*/
+function unpackFiles(bytes, archive) {
+	const files = [...unpackMembers(bytes, {
+		kind: archive.kind,
+		members: archive.files
+	})];
+	if (archive.inner === void 0) return files;
+	return files.map((file) => {
+		try {
+			return {
+				path: file.path,
+				bytes: gunzip(file.bytes)
+			};
+		} catch (error) {
+			throw new ArchiveError(`member ${file.path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+	});
+}
+/**
+* Unpacks a tar archive's bytes, which may be compressed: `tar.gz` is gunzipped and `tar.bz2` bunzipped first, `tar` read as it is.
+* @param bytes - The archive's bytes.
+* @param kind - The archive kind.
+* @returns The tar's bytes.
+* @throws ArchiveError when the bytes are not valid gzip or bzip2 data, as `gunzip` and `bunzip2` report.
+*/
+function untarred(bytes, kind) {
+	if (kind === "tar") return bytes;
+	return kind === "tar.gz" ? gunzip(bytes) : bunzip2(bytes);
+}
+/**
 * Gunzips bytes, rethrowing zlib's failure in the package's taxonomy.
 * @param bytes - Gzip data.
 * @returns The decompressed bytes.
@@ -5177,15 +5950,25 @@ async function getBytes(port, url, signal) {
 	return new Uint8Array(await response.arrayBuffer());
 }
 /**
-* Reads a source's pages, each starting where the rows held so far end, and checks each holds exactly the rows it should, so a response cut short is an error and not a table with rows missing.
+* Reads a source's pages in order, each starting where the rows read so far end, and checks each holds exactly the rows it should, so a response cut short is an error and not a table with rows missing. Only the page being read and the first page's header are held, so a caller that hands each page on holds no more of the source than that.
 * @param read - The source read.
-* @param held - The pages read so far, each after the first without its header record.
-* @param offset - How many rows the pages hold.
-* @returns Every page.
-* @throws KeepsetError when a page holds a different number of rows than the count says it should, or its header differs from the first page's.
+* @returns Each page, the first with its header record and every later one without it.
+* @throws KeepsetError when the source has no rows, a page holds a different number of rows than the count says it should, or its header differs from the first page's.
 */
-async function readResourcePages(read, held, offset) {
-	if (offset >= read.count) return held;
+async function* resourcePages(read) {
+	if (read.count === 0) throw new KeepsetError(`${read.resource} has no rows`);
+	yield* pagesFrom(read, 0, void 0);
+}
+/**
+* Reads one page and then, by recursion, the pages after it.
+* @param read - The source read.
+* @param offset - The row the page starts at.
+* @param header - The first page's header record, or undefined when this is the first page.
+* @returns This page and every page after it.
+* @throws KeepsetError as `resourcePages` does.
+*/
+async function* pagesFrom(read, offset, header) {
+	if (offset >= read.count) return;
 	const expected = Math.min(read.pageSize, read.count - offset);
 	const page = await withAttempts(async () => {
 		const bytes = await getBytes(read.port, read.pageUrl(offset), read.signal);
@@ -5193,10 +5976,15 @@ async function readResourcePages(read, held, offset) {
 		if (rows !== expected) throw new KeepsetError(`${read.resource} gave ${String(rows)} rows at offset ${String(offset)} where ${String(expected)} of its ${String(read.count)} were due, so a response was cut short or the table changed during the download`);
 		return bytes;
 	}, read.signal);
-	const first = held[0];
 	const headerEnd = page.indexOf(LINE_FEED) + 1;
-	if (first !== void 0 && !page.subarray(0, headerEnd).every((byte, index) => byte === first[index])) throw new KeepsetError(`${read.resource} gave a different header at offset ${String(offset)} than at the start`);
-	return readResourcePages(read, [...held, first === void 0 ? page : page.subarray(headerEnd)], offset + expected);
+	if (header === void 0) {
+		yield page;
+		yield* pagesFrom(read, offset + expected, page.slice(0, headerEnd));
+		return;
+	}
+	if (headerEnd !== header.length || !page.subarray(0, headerEnd).every((byte, index) => byte === header[index])) throw new KeepsetError(`${read.resource} gave a different header at offset ${String(offset)} than at the start`);
+	yield page.subarray(headerEnd);
+	yield* pagesFrom(read, offset + expected, header);
 }
 /**
 * Downloads a CSV source a page at a time and joins the pages under the first header.
@@ -5205,42 +5993,44 @@ async function readResourcePages(read, held, offset) {
 * @throws KeepsetError when the source has no rows or a page is not what it should be.
 */
 async function downloadPages(read) {
-	const pages = await readResourcePages(read, [], 0);
-	if (pages.length === 0) throw new KeepsetError(`${read.resource} has no rows`);
+	const pages = [];
+	for await (const page of resourcePages(read)) pages.push(page);
 	return Buffer.concat(pages);
 }
 /**
-* Downloads a whole Socrata resource as one CSV: the row count is read first, then pages of `pageSize` rows in the order of the rows' ids, each checked to hold the rows it should, and joined under the first page's header.
+* How a Socrata resource is read: its row count is read first, then pages of `pageSize` rows in the order of the rows' ids, with only the `select` columns when the recipe lists them, so the columns a parser drops are never transferred.
 * @param resource - The resource's URL, such as `https://data.example.org/resource/abcd-1234.csv`, without a query.
-* @param pageSize - How many rows a page holds.
+* @param paging - The recipe's paging.
 * @param port - The network port.
 * @param signal - Aborts the download.
-* @returns The bytes of one CSV, which is what the parser reads and what the provenance hashes.
-* @throws KeepsetError when the resource does not report a count, or a page is not what it should be.
+* @returns The source read.
+* @throws KeepsetError when the resource does not report a count.
 */
-async function downloadSocrataResource(resource, pageSize, port, signal) {
+async function socrataRead(resource, paging, port, signal) {
 	const reported = /^"count"\r?\n"(\d+)"/.exec(new TextDecoder("utf-8").decode(await getBytes(port, `${resource}?%24select=count(*)`, signal)));
 	if (reported?.[1] === void 0) throw new KeepsetError(`${resource} did not report a row count`);
-	return downloadPages({
+	const { pageSize, select } = paging;
+	const columns = select === void 0 ? "" : `%24select=${encodeURIComponent(select.join(","))}&`;
+	return {
 		resource,
-		pageUrl: (offset) => `${resource}?%24order=%3Aid&%24limit=${String(pageSize)}&%24offset=${String(offset)}`,
+		pageUrl: (offset) => `${resource}?${columns}%24order=%3Aid&%24limit=${String(pageSize)}&%24offset=${String(offset)}`,
 		pageSize,
 		count: Number(reported[1]),
 		port,
 		signal
-	});
+	};
 }
 const CountResultSchema = z.object({ result: z.object({ total: z.int().min(0) }) });
 /**
-* Downloads a whole CKAN datastore table as one CSV: the row count is read from the portal's datastore API, then pages of `pageSize` rows of the table's CSV dump, each checked to hold the rows it should, and joined under the first page's header.
+* How a CKAN datastore table is read: the row count is read from the portal's datastore API, then pages of `pageSize` rows of the table's CSV dump.
 * @param dump - The dump's URL, such as `https://data.example.org/datastore/dump/<resource id>`, without a query; a portal that serves CKAN under a path prefix keeps it before `/datastore/dump/`.
 * @param pageSize - How many rows a page holds.
 * @param port - The network port.
 * @param signal - Aborts the download.
-* @returns The bytes of one CSV, which is what the parser reads and what the provenance hashes.
-* @throws KeepsetError when the URL is not a datastore dump, the table does not report a count, or a page is not what it should be.
+* @returns The source read.
+* @throws KeepsetError when the URL is not a datastore dump or the table does not report a count.
 */
-async function downloadCkanDatastore(dump, pageSize, port, signal) {
+async function ckanRead(dump, pageSize, port, signal) {
 	const parsed = /^(.*)\/datastore\/dump\/([^/?#]+)$/.exec(dump);
 	if (parsed?.[1] === void 0 || parsed[2] === void 0) throw new KeepsetError(`${dump} is not a CKAN datastore dump URL`);
 	const url = `${parsed[1]}/api/3/action/datastore_search?resource_id=${parsed[2]}&limit=0`;
@@ -5252,26 +6042,26 @@ async function downloadCkanDatastore(dump, pageSize, port, signal) {
 	}
 	const count = CountResultSchema.safeParse(body);
 	if (!count.success) throw new KeepsetError(`${dump} did not report a row count`);
-	return downloadPages({
+	return {
 		resource: dump,
 		pageUrl: (offset) => `${dump}?format=csv&limit=${String(pageSize)}&offset=${String(offset)}`,
 		pageSize,
 		count: count.data.result.total,
 		port,
 		signal
-	});
+	};
 }
 const OpenFemaCountSchema = z.object({ metadata: z.object({ count: z.int().min(0) }) });
 /**
-* Downloads a whole OpenFEMA entity, or the rows of it the source URL selects, as one CSV: the row count is read from the API's own metadata, then pages of `pageSize` rows in the order of the entity's id, each checked to hold the rows it should, and joined under the first page's header.
+* How an OpenFEMA entity, or the rows of it the source URL selects, is read: the row count is read from the API's own metadata, then pages of `pageSize` rows in the order of the entity's id.
 * @param entity - The entity's URL with any `$select` or `$filter` but no `$top`, `$skip`, `$orderby` or `$format`, such as `https://www.fema.gov/api/open/v3/NfipClaims?$select=id,state`.
 * @param pageSize - How many rows a page holds.
 * @param port - The network port.
 * @param signal - Aborts the download.
-* @returns The bytes of one CSV, which is what the parser reads and what the provenance hashes.
-* @throws KeepsetError when the source URL sets a paging parameter, the entity does not report a count, or a page is not what it should be.
+* @returns The source read.
+* @throws KeepsetError when the source URL sets a paging parameter or the entity does not report a count.
 */
-async function downloadOpenFema(entity, pageSize, port, signal) {
+async function openFemaRead(entity, pageSize, port, signal) {
 	const base = new URL(entity);
 	for (const name of [
 		"$top",
@@ -5297,7 +6087,7 @@ async function downloadOpenFema(entity, pageSize, port, signal) {
 	}
 	const count = OpenFemaCountSchema.safeParse(body);
 	if (!count.success) throw new KeepsetError(`${entity} did not report a row count`);
-	return downloadPages({
+	return {
 		resource: entity,
 		pageUrl: (offset) => withParameters({
 			$format: "csv",
@@ -5309,10 +6099,34 @@ async function downloadOpenFema(entity, pageSize, port, signal) {
 		count: count.data.metadata.count,
 		port,
 		signal
-	});
+	};
 }
 /**
-* Downloads a paged source as the one file its pages make, in the way its recipe's paging says.
+* How a CSV paged source is read, in the way its recipe's paging says.
+* @param url - The source's URL.
+* @param paging - How the source is paged.
+* @param port - The network port.
+* @param signal - Aborts the download.
+* @returns The source read.
+*/
+async function csvRead(url, paging, port, signal) {
+	if (paging.kind === "socrata-resource") return socrataRead(url, paging, port, signal);
+	return paging.kind === "ckan-datastore" ? ckanRead(url, paging.pageSize, port, signal) : openFemaRead(url, paging.pageSize, port, signal);
+}
+/**
+* Reads a CSV paged source a page at a time: the first page with its header and every later page without it, so the pages in order are the one CSV `downloadPaged` joins them into. Only the page being read is held.
+* @param url - The source's URL.
+* @param paging - How the source is paged.
+* @param port - The network port.
+* @param signal - Aborts the download.
+* @returns Each page's bytes, in order.
+* @throws KeepsetError when the source does not report a count, has no rows, or a page is not what it should be.
+*/
+async function* csvPages(url, paging, port, signal) {
+	yield* resourcePages(await csvRead(url, paging, port, signal));
+}
+/**
+* Downloads a paged source as the one file its pages make, in the way its recipe's paging says: an ArcGIS layer as one GeoJSON feature collection, any other source as one CSV of its pages joined under the first page's header.
 * @param url - The source's URL.
 * @param paging - How the source is paged.
 * @param port - The network port.
@@ -5322,17 +6136,16 @@ async function downloadOpenFema(entity, pageSize, port, signal) {
 */
 async function downloadPaged(url, paging, port, signal) {
 	if (paging.kind === "arcgis-query") return downloadArcgisLayer(url, paging.orderBy, port, signal);
-	if (paging.kind === "socrata-resource") return downloadSocrataResource(url, paging.pageSize, port, signal);
-	return paging.kind === "ckan-datastore" ? downloadCkanDatastore(url, paging.pageSize, port, signal) : downloadOpenFema(url, paging.pageSize, port, signal);
+	return downloadPages(await csvRead(url, paging, port, signal));
 }
 //#endregion
-//#region src/node/fetch-dataset.ts
+//#region src/node/recipe-run.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.
+* The URL a recipe downloads a source from, as `downloadUrl` gives it. 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.
 * @param source - The source.
 * @returns The URL to request.
 */
-function downloadUrl(source) {
+function sourceUrl(source) {
 	if (source.status === "dead") {
 		if (source.snapshot === void 0) throw new KeepsetError(`dead source ${source.url} has no snapshot`);
 		return `https://web.archive.org/web/${source.snapshot.timestamp}id_/${source.url}`;
@@ -5340,6 +6153,18 @@ function downloadUrl(source) {
 	return source.url;
 }
 /**
+* The source record a provenance carries: the entry's source as recorded.
+* @param source - The source.
+* @returns Its URL, status and any snapshot.
+*/
+function sourceRecord(source) {
+	return {
+		url: source.url,
+		status: source.status,
+		...source.snapshot === void 0 ? {} : { snapshot: source.snapshot }
+	};
+}
+/**
 * Runs one step, rethrowing any failure as a RecipeError naming the entry and the step, with the original error as its cause.
 * @param entryId - The entry.
 * @param name - The step.
@@ -5366,6 +6191,373 @@ function metaOf(entry) {
 		...entry.properties
 	};
 }
+//#endregion
+//#region src/node/id-set.ts
+/** The first table size, in slots: 2 to the 16th, a power of two, so a hash is reduced to a slot by masking (and every doubling keeps it one). */
+const INITIAL_SLOTS = 65536;
+/** The first arena size, in bytes: a mebibyte, which a stream of a few tens of thousands of short ids fills before the arena first doubles. */
+const INITIAL_ARENA_BYTES = 1048576;
+/** The table grows when more than this share of its slots hold an id, which keeps linear probing short. */
+const MAX_LOAD = .7;
+/** The bytes before each id in the arena: its length, as an unsigned 32-bit integer. */
+const LENGTH_BYTES = 4;
+/** The largest arena, 2 to the 31st less one: slots hold an arena offset plus one in a signed 32-bit integer. */
+const MAX_ARENA_BYTES = 2147483647;
+/** The FNV-1a 32-bit offset basis and prime (http://www.isthe.com/chongo/tech/comp/fnv/). */
+const FNV_OFFSET = 2166136261;
+const FNV_PRIME = 16777619;
+const encoder = new TextEncoder();
+/**
+* The FNV-1a hash of bytes.
+* @param bytes - The bytes.
+* @returns The 32-bit hash.
+*/
+function fnv1a(bytes) {
+	let hash = FNV_OFFSET;
+	for (const byte of bytes) hash = Math.imul(hash ^ byte, FNV_PRIME);
+	return hash >>> 0;
+}
+/**
+* Reads a slot of a table.
+* @param slots - The table.
+* @param slot - A slot index, always masked into the table's range.
+* @returns What the slot holds.
+* @throws RangeError when the index is outside the table, which masking never gives.
+*/
+function slotOf(slots, slot) {
+	const held = slots[slot];
+	if (held === void 0) throw new RangeError(`slot ${String(slot)} is outside a table of ${String(slots.length)}`);
+	return held;
+}
+/**
+* A set of ids that holds each id as its UTF-8 bytes in one growing arena, indexed by an open-addressed table of arena offsets, so a stream of millions of ids is checked for repeats exactly while holding a few bytes beyond each id's own and no JavaScript string or object per id. Membership compares the bytes themselves, so two different ids are never taken for one.
+*/
+var IdSet = class {
+	arena = new Uint8Array(INITIAL_ARENA_BYTES);
+	view = new DataView(this.arena.buffer);
+	used = 0;
+	/** Each slot holds an id's arena offset plus one, or zero when empty. */
+	slots = new Int32Array(INITIAL_SLOTS);
+	count = 0;
+	/** @returns How many ids the set holds. */
+	get size() {
+		return this.count;
+	}
+	/**
+	* Adds an id.
+	* @param id - The id.
+	* @returns True when the id was new, false when the set already held it.
+	* @throws KeepsetError when the ids held would pass the largest arena.
+	*/
+	add(id) {
+		const bytes = encoder.encode(id);
+		const hash = fnv1a(bytes);
+		const mask = this.slots.length - 1;
+		for (let slot = hash & mask;; slot = slot + 1 & mask) {
+			const held = slotOf(this.slots, slot);
+			if (held === 0) {
+				this.slots[slot] = this.store(bytes) + 1;
+				this.count += 1;
+				if (this.count > this.slots.length * MAX_LOAD) this.grow();
+				return true;
+			}
+			if (this.equals(held - 1, bytes)) return false;
+		}
+	}
+	/**
+	* Whether the id stored at an offset is these bytes.
+	* @param offset - The id's arena offset.
+	* @param bytes - The bytes.
+	* @returns True when they are the same.
+	*/
+	equals(offset, bytes) {
+		if (this.lengthAt(offset) !== bytes.length) return false;
+		const start = offset + LENGTH_BYTES;
+		return bytes.every((byte, index) => this.arena[start + index] === byte);
+	}
+	/**
+	* The length of the id stored at an offset.
+	* @param offset - The id's arena offset.
+	* @returns Its byte length.
+	*/
+	lengthAt(offset) {
+		return this.view.getUint32(offset, true);
+	}
+	/**
+	* Appends an id's bytes to the arena.
+	* @param bytes - The bytes.
+	* @returns Their offset.
+	*/
+	store(bytes) {
+		const needed = this.used + LENGTH_BYTES + bytes.length;
+		if (needed > MAX_ARENA_BYTES) throw new KeepsetError(`the ids of the stream pass ${String(MAX_ARENA_BYTES)} bytes, more than one id set holds`);
+		if (needed > this.arena.length) {
+			const grown = new Uint8Array(Math.min(MAX_ARENA_BYTES, Math.max(needed, this.arena.length * 2)));
+			grown.set(this.arena.subarray(0, this.used));
+			this.arena = grown;
+			this.view = new DataView(grown.buffer);
+		}
+		const offset = this.used;
+		this.view.setUint32(offset, bytes.length, true);
+		this.arena.set(bytes, offset + LENGTH_BYTES);
+		this.used = needed;
+		return offset;
+	}
+	/** Doubles the table, placing every id again by its hash, which is recomputed from the arena so the table holds nothing but offsets. */
+	grow() {
+		const slots = new Int32Array(this.slots.length * 2);
+		const mask = slots.length - 1;
+		for (const held of this.slots) if (held !== 0) {
+			const start = held - 1 + LENGTH_BYTES;
+			let slot = fnv1a(this.arena.subarray(start, start + this.lengthAt(held - 1))) & mask;
+			while (slotOf(slots, slot) !== 0) slot = slot + 1 & mask;
+			slots[slot] = held;
+		}
+		this.slots = slots;
+	}
+};
+//#endregion
+//#region src/node/stream-dataset.ts
+/**
+* The parts of a recipe a stream reads, checked to be a streamed recipe: the entry schema refuses a `stream` recipe that is not a CSV paged source read by the csv-table parser with no archive, so this only fails for an entry whose recipe does not stream.
+* @param entry - The entry.
+* @returns The recipe's source, paging and parser, and the category.
+* @throws RecipeError when the recipe is not fetchable, does not stream, or its category has no streamed form.
+*/
+function streamedRecipe(entry) {
+	const { recipe, category } = entry;
+	if (recipe.status === "not-fetchable") throw new RecipeError(entry.id, "recipe", `the entry has no fetchable recipe: ${recipe.reason}`);
+	if ("files" in recipe || recipe.stream !== true) throw new RecipeError(entry.id, "recipe", "the recipe is not streamed, so fetchDataset reads it as one document");
+	const { paging, parser } = recipe;
+	if (paging === void 0 || paging.kind === "arcgis-query" || parser.format !== "csv-table" || !isStreamable(category)) throw new RecipeError(entry.id, "recipe", "a streamed recipe reads a CSV paged source through the csv-table parser, for a category with a streamed form");
+	return {
+		source: recipe.source,
+		paging,
+		parser,
+		category
+	};
+}
+/**
+* Whether a recipe is streamed, so `fetchDataset` refuses it and `streamDataset` reads it.
+* @param recipe - A recipe.
+* @returns True for a streamed recipe.
+*/
+function isStreamed(recipe) {
+	return recipe.status === "fetchable" && !("files" in recipe) && recipe.stream === true;
+}
+/**
+* What a crosswalk path addresses, for the separability check: the document's meta, a field of every node, or anything else.
+* @param path - A crosswalk path.
+* @returns Its class.
+*/
+function pathClass(path) {
+	if (path === "meta" || path.startsWith("meta.")) return "meta";
+	return path === "nodes[]" || path.startsWith("nodes[].") ? "node" : "other";
+}
+/**
+* Why a crosswalk cannot be applied a page of nodes at a time, if it cannot: every rule must read and write the meta alone or one node's fields alone, with no `when`, so encoding a page's nodes under the document's meta gives exactly that page's part of encoding the whole document, and a round trip that holds on every page holds on the whole.
+* @param crosswalk - The crosswalk.
+* @returns The first rule that breaks this, described, or undefined when every rule keeps to it.
+*/
+function inseparableRule(crosswalk) {
+	for (const [index, rule] of [...crosswalk.rules, ...crosswalk.oneWay].entries()) {
+		if ("when" in rule && rule.when !== void 0) return `rule ${String(index)} (${rule.op}) has a when, which may read the whole document`;
+		const paths = ["from" in rule ? rule.from : void 0, "to" in rule ? rule.to : void 0].filter((path) => path !== void 0);
+		const classes = new Set(paths.map(pathClass));
+		const [only] = classes;
+		if (classes.size !== 1 || only === "other") return `rule ${String(index)} (${rule.op}) reads or writes ${paths.join(" and ")}, not the meta alone or one node's fields alone`;
+	}
+}
+/**
+* Passes on what an async iterable yields, rethrowing its failure as a RecipeError naming the entry and the step, as `step` does for one call.
+* @param entryId - The entry.
+* @param name - The step.
+* @param source - What the step yields.
+* @returns The same items, in order.
+*/
+async function* inStep(entryId, name, source) {
+	try {
+		yield* source;
+	} catch (error) {
+		if (error instanceof RecipeError) throw error;
+		throw new RecipeError(entryId, name, error instanceof Error ? error.message : String(error), { cause: error });
+	}
+}
+/**
+* Runs a streamed recipe's download and parse steps a page at a time: each page's bytes are hashed, decoded and read into rows, and then let go.
+* @param dataset - The dataset.
+* @param recipe - Its streamed recipe.
+* @param options - The network port, abort signal and clock.
+* @returns The stream.
+*/
+function openNative(dataset, recipe, options) {
+	const { entry } = dataset;
+	const { fetch: port = downloadRaw, signal, now = () => /* @__PURE__ */ new Date() } = options;
+	const source = entry.sources[recipe.source];
+	if (source === void 0) throw new RecipeError(entry.id, "recipe", `the recipe names source ${String(recipe.source)}, which the entry does not have`);
+	const fetchedUrl = sourceUrl(source);
+	const retrievedAt = now().toISOString();
+	const hash = createHash("sha256");
+	let byteLength = 0;
+	async function* pages() {
+		const decoder = new PieceDecoder(recipe.parser);
+		const reader = new TableReader(recipe.parser);
+		for await (const page of inStep(entry.id, "download", csvPages(fetchedUrl, recipe.paging, port, signal))) {
+			hash.update(page);
+			byteLength += page.byteLength;
+			const rows = await step(entry.id, "parse", () => reader.push(decoder.decode(page)));
+			if (rows.length > 0) yield rows;
+		}
+		const rows = await step(entry.id, "parse", () => [...reader.push(decoder.end()), ...reader.end()]);
+		if (rows.length > 0) yield rows;
+	}
+	return {
+		meta: metaOf(entry),
+		pages: pages(),
+		provenance: () => ({
+			entryId: entry.id,
+			catalogue: dataset.catalogue,
+			category: entry.category,
+			source: sourceRecord(source),
+			fetchedUrl,
+			retrievedAt,
+			sha256: hash.copy().digest("hex"),
+			byteLength
+		})
+	};
+}
+/**
+* The nodes of an encoded page: the crosswalk writes only the meta and the nodes, so the result is an object with a `nodes` array.
+* @param encoded - The crosswalk's output for a page.
+* @returns Its nodes.
+* @throws KeepsetError when the output is not an object with a nodes array and nothing beyond meta.
+*/
+function nodesOf(encoded) {
+	if (typeof encoded !== "object" || encoded === null || Array.isArray(encoded) || !("nodes" in encoded) || !Array.isArray(encoded.nodes)) throw new KeepsetError("the crosswalk's output is not an object with a nodes array");
+	const extra = Object.keys(encoded).filter((key) => key !== "meta" && key !== "nodes");
+	if (extra.length > 0) throw new KeepsetError(`the crosswalk's output has ${extra.join(", ")} beside meta and nodes`);
+	return encoded.nodes;
+}
+/**
+* Checks a crosswalk can run a page at a time, or fails the crosswalk step.
+* @param entry - The entry.
+* @param crosswalk - Its crosswalk.
+* @throws RecipeError when a rule reaches beyond the meta or one node's fields.
+*/
+function assertSeparable(entry, crosswalk) {
+	const reason = inseparableRule(crosswalk);
+	if (reason !== void 0) throw new RecipeError(entry.id, "crosswalk", `a streamed crosswalk must apply to a page of nodes on its own: ${reason}`);
+}
+/**
+* Streams a table, as `streamEntry` describes.
+* @param dataset - A dataset whose recipe streams.
+* @param sink - Where the meta and the nodes go.
+* @param options - The network port, abort signal and clock.
+* @returns The meta, the provenance, the node count and any count warnings, once every node has been handed on.
+* @throws RecipeError naming the entry and the failing step, after which the sink has had the nodes of the pages before the failure and no more; a recipe that does not stream, or a crosswalk that cannot run a page at a time, fails before anything is downloaded.
+*/
+async function streamTable(dataset, sink, options) {
+	const { entry, crosswalk } = dataset;
+	const recipe = streamedRecipe(entry);
+	assertSeparable(entry, crosswalk);
+	const shape = getStreamedShape(recipe.category);
+	const native = openNative(dataset, recipe, options);
+	const meta = await step(entry.id, "validate", async () => {
+		const encoded = await step(entry.id, "crosswalk", () => encode(crosswalk, {
+			meta: native.meta,
+			nodes: []
+		}));
+		const parsed = shape.meta.safeParse(typeof encoded === "object" && encoded !== null && !Array.isArray(encoded) && "meta" in encoded ? encoded.meta : void 0);
+		if (!parsed.success) throw new KeepsetError(`the result's meta is not ${entry.category} meta: ${parsed.error.issues.map((issue) => `${["meta", ...issue.path.map(String)].join(".")}: ${issue.message}`).join("; ")}`);
+		return parsed.data;
+	});
+	await sink.meta(meta);
+	const ids = new IdSet();
+	for await (const rows of native.pages) {
+		const offset = ids.size;
+		const encoded = await step(entry.id, "crosswalk", () => nodesOf(encode(crosswalk, {
+			meta: native.meta,
+			nodes: rows
+		})));
+		const nodes = await step(entry.id, "validate", () => encoded.map((candidate, index) => {
+			const parsed = shape.node.safeParse(candidate);
+			if (!parsed.success) throw new KeepsetError(`the result is not ${entry.category}: ${parsed.error.issues.map((issue) => `${[
+				"nodes",
+				String(offset + index),
+				...issue.path.map(String)
+			].join(".")}: ${issue.message}`).join("; ")}`);
+			if (!ids.add(parsed.data.id)) throw new KeepsetError(`the result is not ${entry.category}: nodes.${String(offset + index)}.id: duplicate node id ${JSON.stringify(parsed.data.id)}`);
+			return parsed.data;
+		}));
+		await sink.nodes(nodes);
+	}
+	const counts = /* @__PURE__ */ new Map([["nodes", ids.size]]);
+	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))}`);
+	return {
+		dataset,
+		meta,
+		provenance: native.provenance(),
+		counts,
+		warnings
+	};
+}
+/**
+* Checks a streamed dataset's crosswalk on its real data a page at a time: crossmap's `assertRoundTrip` on the meta alone and then on each page's rows under the meta. The crosswalk applies to a page on its own, so the round trip holds on the whole table exactly when it holds on every page. It stops at the first page that differs and reports the path in the whole document.
+* @param dataset - A dataset whose recipe streams.
+* @param options - The network port, abort signal and clock.
+* @returns Whether the round trip holds, and where it first differs when it does not, with the provenance of the bytes it was checked on: every byte when it holds, those read up to the page that differs when it does not.
+* @throws RecipeError naming the entry and the failing step when the recipe fails before the comparison or the crosswalk cannot run.
+*/
+async function roundTripTable(dataset, options) {
+	const { entry, crosswalk } = dataset;
+	const recipe = streamedRecipe(entry);
+	assertSeparable(entry, crosswalk);
+	const native = openNative(dataset, recipe, options);
+	const check = (nodes, offset) => {
+		try {
+			assertRoundTrip(crosswalk, [{
+				meta: native.meta,
+				nodes
+			}]);
+		} catch (error) {
+			if (error instanceof RoundTripMismatchError) {
+				const path = error.path.replace(/^nodes\[(\d+)\]/, (_, index) => `nodes[${String(offset + Number(index))}]`);
+				return {
+					holds: false,
+					path,
+					message: error.message.replaceAll(error.path, path),
+					provenance: native.provenance()
+				};
+			}
+			throw new RecipeError(entry.id, "crosswalk", error instanceof Error ? error.message : String(error), { cause: error });
+		}
+	};
+	const metaMismatch = check([], 0);
+	if (metaMismatch !== void 0) return metaMismatch;
+	let offset = 0;
+	for await (const rows of native.pages) {
+		const mismatch = check(rows, offset);
+		if (mismatch !== void 0) {
+			await native.pages.return();
+			return mismatch;
+		}
+		offset += rows.length;
+	}
+	return {
+		holds: true,
+		provenance: native.provenance()
+	};
+}
+//#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.
+* @param source - The source.
+* @returns The URL to request.
+*/
+function downloadUrl(source) {
+	return sourceUrl(source);
+}
 /**
 * Puts an instance's id beside the fields of its encoded document. A document that is not an object is left as it is, for the collection schema to refuse.
 * @param document - The crosswalk's output for one member.
@@ -5379,6 +6571,139 @@ function withId(document, id) {
 	} : document;
 }
 /**
+* Downloads one URL's bytes through the network port.
+* @param port - The network port.
+* @param url - The URL.
+* @param signal - Aborts the download.
+* @returns The bytes.
+* @throws KeepsetError when the server does not answer successfully.
+*/
+async function downloadBytes(port, url, signal) {
+	const response = await port(url, signal === void 0 ? {} : { signal });
+	if (!response.ok) throw new KeepsetError(`${url} answered ${String(response.status)} ${response.statusText}`);
+	return new Uint8Array(await response.arrayBuffer());
+}
+/**
+* The record of one download: the source, the URL requested and a hash of exactly the bytes that arrived.
+* @param source - The entry's source.
+* @param fetchedUrl - The URL requested.
+* @param bytes - The bytes.
+* @returns The download record.
+*/
+function downloadOf(source, fetchedUrl, bytes) {
+	return {
+		source: sourceRecord(source),
+		fetchedUrl,
+		sha256: createHash("sha256").update(bytes).digest("hex"),
+		byteLength: bytes.byteLength
+	};
+}
+/**
+* Parses one file of a collection into its native document, naming the file when it fails.
+* @param id - The instance's id.
+* @param bytes - The file's bytes.
+* @param parser - The recipe's parser.
+* @returns The instance's native document, with only its own header values as `meta`.
+* @throws KeepsetError naming the instance when the file does not parse.
+*/
+function parseInstance(id, bytes, parser) {
+	try {
+		const parsed = parseNative(bytes, parser);
+		return {
+			id,
+			native: {
+				...parsed,
+				meta: "meta" in parsed ? parsed.meta : {}
+			}
+		};
+	} catch (error) {
+		throw new KeepsetError(`member ${id}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+}
+/**
+* Unpacks and parses the bytes of one archive or file into instances, each member let go once it is parsed.
+* @param bytes - The bytes.
+* @param archive - Their archive layout.
+* @param parser - The recipe's parser.
+* @param prefix - The path the instance ids are filed under, joined to each member's path, or undefined to use the member's path alone.
+* @returns The instances, in member order.
+*/
+function instancesOf(bytes, archive, parser, prefix) {
+	const named = (member) => {
+		if (prefix === void 0) {
+			if (member === void 0) throw new KeepsetError("an instance of a collection has no path");
+			return member;
+		}
+		return member === void 0 ? prefix : `${prefix}/${member}`;
+	};
+	if ("members" in archive) return Array.from(unpackMembers(bytes, archive), (member) => parseInstance(named(member.path), member.bytes, parser));
+	if ("parts" in archive) throw new ArchiveError(`an instance is read from one file or from matching members, not from the named parts ${archive.parts.map((part) => part.name).join(", ")}`);
+	if ("files" in archive) throw new ArchiveError("an instance is read from one file or from matching members, not from every file a multi-file format's files selector matches");
+	const unpacked = unpack(bytes, archive);
+	return [parseInstance(named(unpacked.member), unpacked.bytes, parser)];
+}
+/**
+* Unpacks and parses instances as `instancesOf` does, failing at the extract step when the archive cannot be read or its selector matches nothing, and at the parse step when a member does not parse: the members are unpacked one at a time as they are parsed, so the two steps interleave.
+* @param entryId - The entry.
+* @param run - The unpacking and parsing.
+* @returns The instances.
+* @throws RecipeError naming the entry and the step that failed.
+*/
+function extractAndParse(entryId, run) {
+	try {
+		return run();
+	} catch (error) {
+		throw new RecipeError(entryId, error instanceof ArchiveError ? "extract" : "parse", error instanceof Error ? error.message : String(error), { cause: error });
+	}
+}
+/**
+* Runs a files recipe: downloads each file in turn (a dead file from its own pinned snapshot), unpacks it and parses it into its instances, so only one file's bytes are held at a time.
+* @param dataset - The dataset.
+* @param recipe - Its files recipe.
+* @param options - The network port, abort signal and clock.
+* @returns The instances and the provenance of every file.
+*/
+async function runFiles(dataset, recipe, options) {
+	const { entry } = dataset;
+	const { fetch: port = downloadRaw, signal, now = () => /* @__PURE__ */ new Date() } = options;
+	const retrievedAt = now().toISOString();
+	const read = async (index) => {
+		const file = recipe.files[index];
+		if (file === void 0) return [];
+		const source = entry.sources[file.source];
+		if (source === void 0) throw new RecipeError(entry.id, "recipe", `file ${file.path} names source ${String(file.source)}, which the entry does not have`);
+		const fetchedUrl = sourceUrl(source);
+		const bytes = await step(entry.id, "download", async () => downloadBytes(port, fetchedUrl, signal));
+		const documents = extractAndParse(entry.id, () => instancesOf(bytes, file.archive, recipe.parser, file.path));
+		return [{
+			documents,
+			download: {
+				...downloadOf(source, fetchedUrl, bytes),
+				path: file.path,
+				instances: documents.map((document) => document.id)
+			}
+		}, ...await read(index + 1)];
+	};
+	const files = await read(0);
+	const documents = files.flatMap((file) => file.documents);
+	const ids = /* @__PURE__ */ new Set();
+	for (const { id } of documents) {
+		if (ids.has(id)) throw new RecipeError(entry.id, "extract", `two files give the instance ${id}`);
+		ids.add(id);
+	}
+	return {
+		collection: true,
+		documents,
+		provenance: {
+			entryId: entry.id,
+			catalogue: dataset.catalogue,
+			category: entry.category,
+			retrievedAt,
+			files: files.map((file) => file.download)
+		}
+	};
+}
+/**
 * Runs a recipe's download, extract and parse steps, and builds the native documents the crosswalk receives.
 * @param dataset - The dataset.
 * @param options - The network port, abort signal and clock.
@@ -5389,51 +6714,28 @@ async function runToNative(dataset, options) {
 	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}`);
+	if ("files" in recipe) return runFiles(dataset, recipe, options);
+	if (recipe.stream === true) throw new RecipeError(entry.id, "recipe", "the table is too large to hold as one document, so its recipe streams: read it with streamDataset, which hands its nodes on a page at a time");
 	const source = entry.sources[recipe.source];
 	if (source === void 0) throw new RecipeError(entry.id, "recipe", `the recipe names source ${String(recipe.source)}, which the entry does not have`);
-	const fetchedUrl = downloadUrl(source);
+	const fetchedUrl = sourceUrl(source);
 	const retrievedAt = now().toISOString();
-	const bytes = await step(entry.id, "download", async () => {
-		if (recipe.paging !== void 0) return downloadPaged(fetchedUrl, recipe.paging, fetchPort, signal);
-		const response = await fetchPort(fetchedUrl, signal === void 0 ? {} : { signal });
-		if (!response.ok) throw new KeepsetError(`${fetchedUrl} answered ${String(response.status)} ${response.statusText}`);
-		return new Uint8Array(await response.arrayBuffer());
-	});
+	const bytes = await step(entry.id, "download", async () => recipe.paging === void 0 ? downloadBytes(fetchPort, fetchedUrl, signal) : downloadPaged(fetchedUrl, recipe.paging, fetchPort, signal));
 	const provenanceOf = (extra) => ({
 		entryId: entry.id,
 		catalogue: dataset.catalogue,
 		category: entry.category,
-		source: {
-			url: source.url,
-			status: source.status,
-			...source.snapshot === void 0 ? {} : { snapshot: source.snapshot }
-		},
-		fetchedUrl,
 		retrievedAt,
-		sha256: createHash("sha256").update(bytes).digest("hex"),
-		byteLength: bytes.byteLength,
+		...downloadOf(source, fetchedUrl, bytes),
 		...extra
 	});
 	const { archive } = recipe;
 	if ("members" in archive) {
-		const files = await step(entry.id, "extract", () => unpackMembers(bytes, archive));
+		const documents = extractAndParse(entry.id, () => instancesOf(bytes, archive, recipe.parser, void 0));
 		return {
 			collection: true,
-			documents: await step(entry.id, "parse", () => files.map((file) => {
-				try {
-					const parsed = parseNative(file.bytes, recipe.parser);
-					return {
-						id: file.path,
-						native: {
-							...parsed,
-							meta: "meta" in parsed ? parsed.meta : {}
-						}
-					};
-				} catch (error) {
-					throw new KeepsetError(`member ${file.path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-				}
-			})),
-			provenance: provenanceOf({ members: files.map((file) => file.path) })
+			documents,
+			provenance: provenanceOf({ members: documents.map((document) => document.id) })
 		};
 	}
 	if ("parts" in archive) {
@@ -5450,6 +6752,20 @@ async function runToNative(dataset, options) {
 			provenance: provenanceOf({ members: parts.map((part) => part.path) })
 		};
 	}
+	if ("files" in archive) {
+		const files = await step(entry.id, "extract", () => unpackFiles(bytes, archive));
+		return {
+			collection: false,
+			documents: [{
+				id: void 0,
+				native: {
+					...await step(entry.id, "parse", () => parseNativeFiles(files, recipe.parser)),
+					meta: metaOf(entry)
+				}
+			}],
+			provenance: provenanceOf({ members: files.map((file) => file.path) })
+		};
+	}
 	const unpacked = await step(entry.id, "extract", () => unpack(bytes, archive));
 	const parsed = await step(entry.id, "parse", () => parseNative(unpacked.bytes, recipe.parser));
 	return {
@@ -5472,7 +6788,7 @@ async function runToNative(dataset, options) {
 * @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.
+* @throws RecipeError naming the entry and the failing step, including for a recipe that streams, which `streamEntry` reads; nothing partial or default-shaped is ever returned.
 */
 async function fetchEntry(dataset, options = {}) {
 	const { entry, crosswalk } = dataset;
@@ -5513,13 +6829,14 @@ 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 crossmap's `assertRoundTrip`, which encodes it, decodes the result and compares the two over every path the crosswalk promises to preserve.
+* Checks a dataset's crosswalk on its real data: runs the recipe to the native document, then crossmap's `assertRoundTrip`, which encodes it, decodes the result and compares the two over every path the crosswalk promises to preserve. A streamed recipe is checked a page at a time, with the round trip holding on the whole table exactly when it holds on every page, so the table is never held.
 * @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 = {}) {
+	if (isStreamed(dataset.entry.recipe)) return roundTripTable(dataset, options);
 	const { documents, provenance } = await runToNative(dataset, options);
 	try {
 		assertRoundTrip(dataset.crosswalk, documents.map(({ native }) => native));
@@ -5538,6 +6855,28 @@ async function roundTripEntry(dataset, options = {}) {
 	};
 }
 /**
+* Streams a dataset of the bundled catalogue by id, as `streamEntry` does: for a table too large to hold as one document, whose recipe streams.
+* @param id - The entry id.
+* @param sink - Where the meta and the nodes go.
+* @param options - The network port, abort signal and clock.
+* @returns The meta, the provenance, the node count and any count warnings, once every node has been handed on.
+* @throws DatasetNotFoundError when no entry has that id, and RecipeError as `streamEntry` does.
+*/
+async function streamDataset(id, sink, options = {}) {
+	return streamEntry(getDataset(id), sink, options);
+}
+/**
+* Streams a dataset whose table is too large to hold as one document: reads its paged source a page at a time, applies the crosswalk to each page's rows under the document's meta, checks the meta once and each node against the category's node shape and for an id no earlier node had, and hands the nodes on to the sink before reading the next page. What it holds at once is one page's bytes and rows and the ids seen so far (as bytes, not strings), never the table, so the result is the category target `{ meta, nodes }` delivered in order rather than held: the same nodes `fetchEntry` would give, checked by the same rules.
+* @param dataset - A dataset whose recipe streams.
+* @param sink - Where the meta and the nodes go.
+* @param options - The network port, abort signal and clock.
+* @returns The meta, the provenance, the node count and any count warnings, once every node has been handed on.
+* @throws RecipeError naming the entry and the failing step, after which the sink has had the nodes of the pages before the failure and no more; a recipe that does not stream, or a crosswalk that cannot run a page at a time, fails before anything is downloaded.
+*/
+async function streamEntry(dataset, sink, options = {}) {
+	return streamTable(dataset, sink, options);
+}
+/**
 * 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.
@@ -5548,4 +6887,4 @@ async function roundTripDataset(id, options = {}) {
 	return roundTripEntry(getDataset(id), options);
 }
 //#endregion
-export { downloadUrl, fetchDataset, fetchEntry, roundTripDataset, roundTripEntry };
+export { downloadUrl, fetchDataset, fetchEntry, roundTripDataset, roundTripEntry, streamDataset, streamEntry };