keepset 0.1.0 → 0.3.0

package/dist/bundled--fOitQlP.js

@@ -0,0 +1,621 @@
+import { CrosswalkSchema, validateCrosswalk } from "twindex";
+import { z } from "zod";
+//#region src/errors.ts
+/** The root of this package's error taxonomy: every error keepset throws is a `KeepsetError`, so callers can catch the family with one check. */
+var KeepsetError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+	}
+};
+/** Thrown when a category id names no category in the registry. Carries the ids that do exist, so the message says what would have been accepted. */
+var UnknownCategoryError = class extends KeepsetError {
+	categoryId;
+	knownIds;
+	constructor(categoryId, knownIds) {
+		super(`unknown category ${JSON.stringify(categoryId)}: known categories are ${knownIds.join(", ")}`);
+		this.categoryId = categoryId;
+		this.knownIds = knownIds;
+	}
+};
+/** Thrown when an entry, a catalogue manifest or a catalogue index fails its schema. Carries every issue found, not just the first, so one failed parse reports the whole document. */
+var CatalogueSyntaxError = class extends KeepsetError {
+	document;
+	issues;
+	constructor(document, issues) {
+		super(`${document} syntax error: ${issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+		this.document = document;
+		this.issues = issues;
+	}
+};
+/** Thrown by a parser when a file does not have the format its recipe names. `line` is 1-based, counting every line of the file, so it points at the offending line in an editor. */
+var NativeParseError = class extends KeepsetError {
+	format;
+	line;
+	constructor(format, line, message) {
+		super(`${format} line ${String(line)}: ${message}`);
+		this.format = format;
+		this.line = line;
+	}
+};
+/** Thrown when an archive does not hold exactly one member the recipe's member selector matches, or is not a well-formed archive of its stated kind. */
+var ArchiveError = class extends KeepsetError {};
+/** Thrown when no entry in the catalogue has the requested id. */
+var DatasetNotFoundError = class extends KeepsetError {
+	datasetId;
+	constructor(datasetId) {
+		super(`no dataset ${JSON.stringify(datasetId)} in the catalogue`);
+		this.datasetId = datasetId;
+	}
+};
+/** Thrown when running an entry's recipe fails. Names the entry and the failing step, and carries the underlying error as `cause`; a recipe never resolves to a partial or default-shaped result. */
+var RecipeError = class extends KeepsetError {
+	entryId;
+	step;
+	constructor(entryId, step, message, options) {
+		super(`${entryId}: ${step} failed: ${message}`, options);
+		this.entryId = entryId;
+		this.step = step;
+	}
+};
+//#endregion
+//#region src/define.ts
+/**
+* Attaches a type guard to a Zod schema (the schema-attached guard pattern: validation, inference and narrowing share one definition, so the three cannot drift). This module is isolated because it is the one place in the package that augments an object in place with Object.assign, which the house lint rule that eslint.config.ts turns off for this file alone would otherwise reject: object spread is no alternative, as it copies own properties only and drops the Zod prototype's parse/refine methods.
+* @param schema - The schema to augment.
+* @returns The same schema object, now also carrying `is`.
+*/
+function define(schema) {
+	return Object.assign(schema, { is(value) {
+		return schema.safeParse(value).success;
+	} });
+}
+//#endregion
+//#region src/record.ts
+/**
+* A record whose every key must satisfy `key`. Zod's own record silently drops an own `__proto__` key (which `JSON.parse` creates as an ordinary property) before the key schema sees it, so this checks the raw input first and rejects such a key loudly instead of losing the value.
+* @param key - The key schema.
+* @param value - The value schema.
+* @returns The record schema.
+*/
+function recordOf(key, value) {
+	return z.preprocess((input, ctx) => {
+		if (typeof input === "object" && input !== null && Object.hasOwn(input, "__proto__")) ctx.issues.push({
+			code: "custom",
+			input,
+			message: "__proto__ is not a valid key"
+		});
+		return input;
+	}, z.record(key, value));
+}
+//#endregion
+//#region src/targets/graph-v1.ts
+/** A JSON scalar: the only values graph/v1 metadata may hold, so `meta` stays a flat record any consumer can tabulate. `z.number()` already rejects NaN and the infinities, which JSON cannot carry. */
+const JsonScalarSchema = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+/** A node: an id, an optional type, and whatever else the dataset carries. The target fixes only what every graph consumer needs, so extra fields pass through untouched. */
+const GraphNodeSchema = z.looseObject({
+	id: z.string().min(1),
+	type: z.string().min(1).optional()
+});
+/** An edge: source and target node ids, an optional type, and whatever else the dataset carries. Direction is the dataset's own: graph/v1 records it in `meta`, never by duplicating edges. */
+const GraphEdgeSchema = z.looseObject({
+	source: z.string().min(1),
+	target: z.string().min(1),
+	type: z.string().min(1).optional()
+});
+/**
+* The graph/v1 normalisation target: `{ meta, nodes, edges }`, the shape the thesis pipeline's benchmark cache already uses. It describes the result `fetchDataset` resolves a graph entry to, not what a source file may contain. Beyond the field shapes it checks the two properties every consumer relies on: node ids are unique, and every edge endpoint names a node.
+*/
+const GraphV1Schema = define(z.object({
+	meta: recordOf(z.string().min(1), JsonScalarSchema),
+	nodes: z.array(GraphNodeSchema),
+	edges: z.array(GraphEdgeSchema)
+}).strict().superRefine((graph, ctx) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const [index, node] of graph.nodes.entries()) {
+		if (ids.has(node.id)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"nodes",
+				index,
+				"id"
+			],
+			message: `duplicate node id ${JSON.stringify(node.id)}`
+		});
+		ids.add(node.id);
+	}
+	for (const [index, edge] of graph.edges.entries()) for (const end of ["source", "target"]) if (!ids.has(edge[end])) ctx.addIssue({
+		code: "custom",
+		path: [
+			"edges",
+			index,
+			end
+		],
+		message: `edge ${end} ${JSON.stringify(edge[end])} names no node`
+	});
+}));
+//#endregion
+//#region src/categories.ts
+/** Every category id the registry knows. A category id is `<kind>/v<version>`: the kind of data, and the version of its normalisation target, so a breaking change to a target is a new category rather than an edit to an old one. */
+const CategoryIdSchema = z.enum(["graph/v1"]);
+/** The registry. Adding a category is adding its id to `CategoryIdSchema` and its entry here, with its target schema beside graph/v1's in src/targets/: the mapped type makes the compiler reject a registry that misses an id or has one too many. */
+const registry = { "graph/v1": {
+	id: "graph/v1",
+	description: "A graph as { meta, nodes, edges }: a flat record of scalar metadata, nodes carrying at least an id, and edges carrying at least source and target node ids, with optional node and edge types.",
+	target: GraphV1Schema,
+	counted: ["nodes", "edges"]
+} };
+function getCategory(id) {
+	const parsed = CategoryIdSchema.safeParse(id);
+	if (!parsed.success) throw new UnknownCategoryError(id, CategoryIdSchema.options);
+	return registry[parsed.data];
+}
+function getTarget(id) {
+	return getCategory(id).target;
+}
+/**
+* The kind of data a category holds: the part of its id before the version.
+* @param id - A category id.
+* @returns The kind, such as `graph`.
+*/
+function kindOf(id) {
+	return id.slice(0, id.indexOf("/"));
+}
+/** @returns Every registered category, in id order. */
+function listCategories() {
+	return CategoryIdSchema.options.map((id) => getCategory(id));
+}
+/**
+* Counts the collections an entry may record expected counts for, in a resolved target.
+* @param id - The target's category.
+* @param target - A resolved target of that category.
+* @returns The length of each counted array, by key.
+*/
+function countTarget(id, target) {
+	const category = getCategory(id);
+	return new Map(category.counted.map((key) => [key, target[key].length]));
+}
+//#endregion
+//#region src/entry.ts
+/** A stable identifier: an entry id, a catalogue id. It starts with a letter or digit, so no id can be `__proto__` or any other name that begins with an underscore. Entry ids stay the same across forks, which is what lets two catalogues be compared entry by entry. */
+const IdSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, { message: "must start with a letter or digit and contain only letters, digits, '.', '_' and '-'" });
+/** A key of an entry's `properties` or `expectedCounts` record: an identifier that starts with a letter, so it can never be `__proto__` or another name Object.prototype reacts to on assignment. */
+const RecordKeySchema = z.string().regex(/^[A-Za-z][A-Za-z0-9]*$/, { message: "must be a letter followed by letters or digits" });
+/** A calendar date, `YYYY-MM-DD`. */
+const IsoDateSchema = z.iso.date();
+/** An http or https URL: the only schemes a recipe may download from. Any host is allowed, an address or a single-label name included, so a fork can point a recipe at a server on its own network. */
+const HttpUrlSchema = z.url({ protocol: /^https?$/ });
+/** A Wayback Machine timestamp, `YYYYMMDD` or `YYYYMMDDhhmmss`: the moment the snapshot is pinned to. */
+const WaybackTimestampSchema = z.string().regex(/^\d{8}(?:\d{6})?$/, { message: "must be a Wayback timestamp, YYYYMMDD or YYYYMMDDhhmmss" });
+/**
+* The Wayback Machine URL of a snapshot of `url` at `timestamp`: the page form a person follows. The raw bytes a recipe downloads come from the `id_` form, which `fetchDataset` derives from this one.
+* @param timestamp - A Wayback timestamp.
+* @param url - The original URL.
+* @returns The snapshot URL.
+*/
+function waybackUrl(timestamp, url) {
+	return `https://web.archive.org/web/${timestamp}/${url}`;
+}
+/** A pinned Wayback Machine snapshot of a source. The timestamp is part of the recipe's reproducibility, not incidental metadata, so it travels with the URL and the two are checked against each other. */
+const SnapshotSchema = z.object({
+	url: HttpUrlSchema,
+	timestamp: WaybackTimestampSchema
+}).strict();
+/**
+* Where a dataset's bytes come from. A `dead` source no longer serves the bytes the recipe was written against and must carry the snapshot the recipe fetches instead; a `live` source may also carry one, as the pinned record of what it served. The snapshot URL must be exactly `waybackUrl(timestamp, url)`.
+*/
+const SourceSchema = z.object({
+	url: HttpUrlSchema,
+	retrieved: IsoDateSchema,
+	status: z.enum(["live", "dead"]),
+	snapshot: SnapshotSchema.optional()
+}).strict().superRefine((source, ctx) => {
+	if (source.status === "dead" && source.snapshot === void 0) ctx.addIssue({
+		code: "custom",
+		path: ["snapshot"],
+		message: "a dead source must pin the Wayback snapshot its recipe fetches"
+	});
+	if (source.snapshot !== void 0 && source.snapshot.url !== waybackUrl(source.snapshot.timestamp, source.url)) ctx.addIssue({
+		code: "custom",
+		path: ["snapshot", "url"],
+		message: `must be ${waybackUrl(source.snapshot.timestamp, source.url)}, the snapshot of this source's url at this timestamp`
+	});
+});
+/** The licence a dataset is published under: an SPDX identifier, a named licence with the URL of its terms, or a statement that the source records none. A licence the source does not state is recorded as unrecorded rather than guessed. */
+const LicenceSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("spdx"),
+		id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9.+-]*$/, { message: "must be an SPDX licence identifier" })
+	}).strict(),
+	z.object({
+		kind: z.literal("custom"),
+		name: z.string().min(1),
+		url: HttpUrlSchema
+	}).strict(),
+	z.object({ kind: z.literal("unrecorded") }).strict()
+]);
+/** A work to cite for the dataset: a formatted reference, with its DOI or URL where the source records one. */
+const CitationSchema = z.object({
+	text: z.string().min(1),
+	doi: z.string().regex(/^10\.\d{4,9}\/\S+$/, { message: "must be a bare DOI, 10.<registrant>/<suffix>" }).optional(),
+	url: HttpUrlSchema.optional()
+}).strict();
+/** A relative path inside an archive or a catalogue: `/`-separated segments, none empty, `.` or `..`, so it can never climb out of the directory it is resolved against. */
+const RelativePathSchema = z.string().refine((path) => path.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".."), { message: "must be a relative path of non-empty segments with no '.' or '..'" });
+/** Which file of an archive to read: a member path, matched against a member's whole path or its trailing segments (so `net.gml` finds `net/net.gml`), or the member whose name ends with an extension. Either must match exactly one member when the recipe runs; macOS resource-fork members (`__MACOSX/` and `._` files) never match. */
+const ArchiveMemberSchema = z.union([z.object({ path: RelativePathSchema }).strict(), z.object({ extension: z.string().regex(/^\.[A-Za-z0-9][A-Za-z0-9.]*$/, { message: "must be a file extension such as .mtx" }) }).strict()]);
+/** How the downloaded bytes unpack into the one file the parser reads. */
+const ArchiveSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("none") }).strict(),
+	z.object({ kind: z.literal("gzip") }).strict(),
+	z.object({
+		kind: z.literal("zip"),
+		member: ArchiveMemberSchema
+	}).strict(),
+	z.object({
+		kind: z.literal("tar"),
+		member: ArchiveMemberSchema
+	}).strict(),
+	z.object({
+		kind: z.literal("tar.gz"),
+		member: ArchiveMemberSchema
+	}).strict()
+]);
+const ColumnSchema = z.int().min(0);
+/** The text encoding of the unpacked file. Decoding is strict: bytes that are not valid in the stated encoding fail the recipe rather than turning into replacement characters. */
+const EncodingSchema = z.enum(["utf-8", "latin1"]);
+/** The parser that reads the unpacked file into the dataset's native JSON shape, with the options that format needs. Every option is stated in the entry, so a recipe reads the same way wherever it runs. */
+const ParserSchema = z.discriminatedUnion("format", [
+	z.object({
+		format: z.literal("edge-list"),
+		encoding: EncodingSchema,
+		delimiter: z.enum([
+			"detect",
+			"whitespace",
+			"tab",
+			"comma",
+			"space"
+		]),
+		skipLines: z.int().min(0),
+		commentPrefixes: z.array(z.string().min(1)),
+		sourceColumn: ColumnSchema,
+		targetColumn: ColumnSchema
+	}).strict().refine((parser) => parser.sourceColumn !== parser.targetColumn, {
+		message: "sourceColumn and targetColumn must differ",
+		path: ["targetColumn"]
+	}),
+	z.object({
+		format: z.literal("matrix-market"),
+		encoding: EncodingSchema
+	}).strict(),
+	z.object({
+		format: z.literal("gml"),
+		encoding: EncodingSchema
+	}).strict(),
+	z.object({
+		format: z.literal("pajek"),
+		encoding: EncodingSchema
+	}).strict()
+]);
+/** How to obtain the dataset: a fetchable recipe naming the source (by index into `sources`), the archive layout and the parser, or a statement that no declarative recipe exists yet and why. */
+const RecipeSchema = z.discriminatedUnion("status", [z.object({
+	status: z.literal("fetchable"),
+	source: z.int().min(0),
+	archive: ArchiveSchema,
+	parser: ParserSchema
+}).strict(), z.object({
+	status: z.literal("not-fetchable"),
+	reason: z.string().min(1)
+}).strict()]);
+/** The twindex crosswalk from the native shape to the category target: the document inline, or a `.json` file path relative to the catalogue root, so entries that share a native shape share one crosswalk. */
+const CrosswalkReferenceSchema = z.union([CrosswalkSchema, z.object({ file: RelativePathSchema.refine((path) => path.endsWith(".json"), { message: "must name a .json file" }) }).strict()]);
+/** The meta keys a fetched result takes from the entry's own descriptor, which its `properties` therefore may not also set. */
+const RESERVED_META_KEYS = ["id", "name"];
+/**
+* One catalogue entry: the descriptor (id, name, description, domain, tags), the category whose target the entry resolves to, where the bytes come from, the licence and citations, the recipe, the crosswalk, the counts a fetched result is expected to have and the dataset's recorded properties. The kind of data is the category's (`kindOf(category)`), never a second field that could disagree with it.
+*/
+const EntrySchema = define(z.object({
+	id: IdSchema,
+	name: z.string().min(1),
+	description: z.string().min(1).optional(),
+	domain: z.string().min(1).optional(),
+	tags: z.array(z.string().min(1)).refine((tags) => new Set(tags).size === tags.length, { message: "tags must be unique" }),
+	category: CategoryIdSchema,
+	sources: z.array(SourceSchema).min(1),
+	licence: LicenceSchema,
+	citations: z.array(CitationSchema),
+	recipe: RecipeSchema,
+	crosswalk: CrosswalkReferenceSchema,
+	expectedCounts: recordOf(RecordKeySchema, z.int().min(0)),
+	properties: recordOf(RecordKeySchema, JsonScalarSchema)
+}).strict().superRefine((entry, ctx) => {
+	if (entry.recipe.status === "fetchable" && entry.recipe.source >= entry.sources.length) ctx.addIssue({
+		code: "custom",
+		path: ["recipe", "source"],
+		message: `names source ${String(entry.recipe.source)} but the entry has ${String(entry.sources.length)}`
+	});
+	if ("target" in entry.crosswalk && entry.crosswalk.target !== entry.category) ctx.addIssue({
+		code: "custom",
+		path: ["crosswalk", "target"],
+		message: `must be the entry's category, ${entry.category}`
+	});
+	const counted = getCategory(entry.category).counted;
+	for (const key of Object.keys(entry.expectedCounts)) if (!counted.includes(key)) ctx.addIssue({
+		code: "custom",
+		path: ["expectedCounts", key],
+		message: `${entry.category} counts only ${counted.join(", ")}`
+	});
+	for (const key of RESERVED_META_KEYS) if (Object.hasOwn(entry.properties, key)) ctx.addIssue({
+		code: "custom",
+		path: ["properties", key],
+		message: `${key} is set from the entry itself in a fetched result's meta, so it cannot be a property`
+	});
+}));
+/**
+* Collapses Zod issues into the package's own issue shape, so the public error surface stays stable across Zod versions.
+* @param error - A Zod error.
+* @returns One issue per Zod issue, with its path written as dotted text.
+*/
+function toIssues(error) {
+	return error.issues.map((issue) => ({
+		path: issue.path.map(String).join(".") || "(root)",
+		message: issue.message
+	}));
+}
+/**
+* Parses an unknown value as a catalogue entry.
+* @param doc - The candidate entry document.
+* @returns The validated entry.
+* @throws CatalogueSyntaxError carrying every issue found.
+*/
+function parseEntry(doc) {
+	const result = EntrySchema.safeParse(doc);
+	if (!result.success) throw new CatalogueSyntaxError("entry", toIssues(result.error));
+	return result.data;
+}
+//#endregion
+//#region src/manifest.ts
+/** A semantic version, `MAJOR.MINOR.PATCH` with optional pre-release and build parts (https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string). */
+const SemVerSchema = z.string().regex(/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/, { message: "must be a semantic version, MAJOR.MINOR.PATCH" });
+/** Where a forked catalogue came from: the catalogue it was forked from, the version it forked at and the repository that holds it, which together are what lets a fork's entries be compared with, and brought back to, their origin. */
+const LineageSchema = z.object({
+	catalogue: IdSchema,
+	version: SemVerSchema,
+	repository: HttpUrlSchema
+}).strict();
+/**
+* A catalogue manifest: the catalogue's own id and version, where it lives, and, for a fork, its lineage. A catalogue is a self-contained set of entry documents beside its manifest, and a fork is its own catalogue with its own id, so lineage may never name the catalogue itself.
+*/
+const ManifestSchema = define(z.object({
+	id: IdSchema,
+	name: z.string().min(1),
+	description: z.string().min(1),
+	version: SemVerSchema,
+	repository: HttpUrlSchema,
+	lineage: LineageSchema.optional()
+}).strict().superRefine((manifest, ctx) => {
+	if (manifest.lineage?.catalogue === manifest.id) ctx.addIssue({
+		code: "custom",
+		path: ["lineage", "catalogue"],
+		message: "a fork is its own catalogue: lineage must name the catalogue it was forked from, not itself"
+	});
+}));
+/**
+* Parses an unknown value as a catalogue manifest.
+* @param doc - The candidate manifest document.
+* @returns The validated manifest.
+* @throws CatalogueSyntaxError carrying every issue found.
+*/
+function parseManifest(doc) {
+	const result = ManifestSchema.safeParse(doc);
+	if (!result.success) throw new CatalogueSyntaxError("manifest", toIssues(result.error));
+	return result.data;
+}
+//#endregion
+//#region src/own.ts
+/**
+* Reads an own property of a record keyed by strings that come from data. A plain `record[key]` read follows the prototype chain, so a key such as `constructor` would find an inherited function instead of reporting absence.
+* @param record - The record to read.
+* @param key - Any string.
+* @returns The own property's value, or `undefined` when the record has no such own property.
+*/
+function getOwn(record, key) {
+	return Object.hasOwn(record, key) ? record[key] : void 0;
+}
+//#endregion
+//#region src/catalogue.ts
+/**
+* A catalogue index: the manifest, every entry, and every crosswalk file of the catalogue, keyed by its catalogue-relative path. The build assembles it from a catalogue directory; a consumer holding its own catalogue (a fork, say) can pass one to `createCatalogue`. Entry ids are unique, every crosswalk passes twindex's structural validation, every crosswalk file reference resolves, and every crosswalk's target is the category of each entry that uses it.
+*/
+const CatalogueIndexSchema = define(z.object({
+	manifest: ManifestSchema,
+	crosswalks: recordOf(RelativePathSchema, CrosswalkSchema),
+	entries: z.array(EntrySchema)
+}).strict().superRefine((index, ctx) => {
+	for (const [file, crosswalk] of Object.entries(index.crosswalks)) for (const issue of validateCrosswalk(crosswalk)) ctx.addIssue({
+		code: "custom",
+		path: ["crosswalks", file],
+		message: `rule ${String(issue.ruleIndex)}: ${issue.message}`
+	});
+	const seen = /* @__PURE__ */ new Set();
+	for (const [position, entry] of index.entries.entries()) {
+		if (seen.has(entry.id)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"entries",
+				position,
+				"id"
+			],
+			message: `duplicate entry id ${entry.id}`
+		});
+		seen.add(entry.id);
+		if (!("file" in entry.crosswalk)) for (const issue of validateCrosswalk(entry.crosswalk)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"entries",
+				position,
+				"crosswalk"
+			],
+			message: `rule ${String(issue.ruleIndex)}: ${issue.message}`
+		});
+		else {
+			const crosswalk = getOwn(index.crosswalks, entry.crosswalk.file);
+			if (crosswalk === void 0) ctx.addIssue({
+				code: "custom",
+				path: [
+					"entries",
+					position,
+					"crosswalk",
+					"file"
+				],
+				message: `no crosswalk file ${entry.crosswalk.file} in the catalogue`
+			});
+			else if (crosswalk.target !== entry.category) ctx.addIssue({
+				code: "custom",
+				path: [
+					"entries",
+					position,
+					"crosswalk",
+					"file"
+				],
+				message: `${entry.crosswalk.file} targets ${crosswalk.target}, not the entry's category ${entry.category}`
+			});
+		}
+	}
+}));
+/**
+* Whether a dataset matches a query.
+* @param dataset - The dataset.
+* @param query - The filters.
+* @returns True when every given filter matches.
+*/
+function matches(dataset, query) {
+	const { entry } = dataset;
+	if (query.kind !== void 0 && dataset.kind !== query.kind) return false;
+	if (query.category !== void 0 && entry.category !== query.category) return false;
+	if (query.domain !== void 0 && entry.domain !== query.domain) return false;
+	if (query.text !== void 0) {
+		const needle = query.text.toLowerCase();
+		return [
+			entry.id,
+			entry.name,
+			entry.description,
+			entry.domain,
+			...entry.tags
+		].filter((field) => field !== void 0).some((field) => field.toLowerCase().includes(needle));
+	}
+	return true;
+}
+/**
+* Builds a queryable catalogue from an index. Pure and synchronous: no filesystem, no network, so it runs the same in a browser as in Node.
+* @param index - A candidate catalogue index.
+* @returns The catalogue.
+* @throws CatalogueSyntaxError carrying every issue when the index is not a valid catalogue.
+*/
+function createCatalogue(index) {
+	const parsed = CatalogueIndexSchema.safeParse(index);
+	if (!parsed.success) throw new CatalogueSyntaxError("catalogue", toIssues(parsed.error));
+	const { manifest, crosswalks, entries } = parsed.data;
+	const catalogue = {
+		id: manifest.id,
+		version: manifest.version
+	};
+	const datasets = /* @__PURE__ */ new Map();
+	for (const entry of [...entries].sort((left, right) => left.id < right.id ? -1 : 1)) {
+		const crosswalk = "file" in entry.crosswalk ? getOwn(crosswalks, entry.crosswalk.file) : entry.crosswalk;
+		if (crosswalk === void 0) throw new CatalogueSyntaxError("catalogue", [{
+			path: `entries.${entry.id}.crosswalk.file`,
+			message: "the crosswalk file does not resolve"
+		}]);
+		datasets.set(entry.id, {
+			entry,
+			kind: kindOf(entry.category),
+			crosswalk,
+			catalogue
+		});
+	}
+	return {
+		manifest,
+		listDatasets: (query = {}) => [...datasets.values()].filter((dataset) => matches(dataset, query)),
+		getDataset: (id) => {
+			const dataset = datasets.get(id);
+			if (dataset === void 0) throw new DatasetNotFoundError(id);
+			return dataset;
+		}
+	};
+}
+//#endregion
+//#region src/generated/catalogue.json
+var catalogue_default = {
+	manifest: {
+		"id": "keepset",
+		"name": "keepset",
+		"description": "The keepset catalogue: datasets with machine-readable recipes that fetch each one and normalise it into its category's target shape.",
+		"version": "0.1.0",
+		"repository": "https://github.com/ExaDev/keepset"
+	},
+	crosswalks: { "crosswalks/graph-v1/topology.json": {
+		"source": "keepset/topology",
+		"target": "graph/v1",
+		"rules": [
+			{
+				"op": "move",
+				"from": "meta",
+				"to": "meta"
+			},
+			{
+				"op": "move",
+				"from": "nodes[].id",
+				"to": "nodes[].id"
+			},
+			{
+				"op": "move",
+				"from": "edges[].source",
+				"to": "edges[].source"
+			},
+			{
+				"op": "move",
+				"from": "edges[].target",
+				"to": "edges[].target"
+			}
+		],
+		"oneWay": []
+	} },
+	entries: []
+};
+//#endregion
+//#region src/bundled.ts
+let bundled;
+/** The catalogue shipped in this package, assembled from catalogue/ by the build and parsed on first use, so importing the package costs nothing until a query runs. */
+function catalogue() {
+	bundled ??= createCatalogue(catalogue_default);
+	return bundled;
+}
+/**
+* Lists the datasets in the bundled catalogue that match a query. Browser-safe: a pure read over the index bundled with the package.
+* @param query - The filters; all must match, and none given lists everything.
+* @returns The matching datasets, in entry id order.
+*/
+function listDatasets(query) {
+	return catalogue().listDatasets(query);
+}
+/**
+* Returns one dataset of the bundled catalogue: its entry (metadata and recipe) and its resolved crosswalk. Browser-safe.
+* @param id - The entry id.
+* @returns The dataset.
+* @throws DatasetNotFoundError when no entry has that id.
+*/
+function getDataset(id) {
+	return catalogue().getDataset(id);
+}
+/** @returns The bundled catalogue's manifest: its id, version and repository. */
+function getManifest() {
+	return catalogue().manifest;
+}
+//#endregion
+export { getCategory as A, DatasetNotFoundError as B, SnapshotSchema as C, waybackUrl as D, parseEntry as E, GraphNodeSchema as F, NativeParseError as H, GraphV1Schema as I, JsonScalarSchema as L, kindOf as M, listCategories as N, CategoryIdSchema as O, GraphEdgeSchema as P, ArchiveError as R, RelativePathSchema as S, WaybackTimestampSchema as T, RecipeError as U, KeepsetError as V, UnknownCategoryError as W, IdSchema as _, createCatalogue as a, RESERVED_META_KEYS as b, ManifestSchema as c, ArchiveMemberSchema as d, ArchiveSchema as f, HttpUrlSchema as g, EntrySchema as h, CatalogueIndexSchema as i, getTarget as j, countTarget as k, SemVerSchema as l, CrosswalkReferenceSchema as m, getManifest as n, getOwn as o, CitationSchema as p, listDatasets as r, LineageSchema as s, getDataset as t, parseManifest as u, LicenceSchema as v, SourceSchema as w, RecipeSchema as x, ParserSchema as y, CatalogueSyntaxError as z };