@noverax/courier-build 0.0.0-stage → 0.4.0

package/lib/routes-file-DcpgxYb1.js

@@ -0,0 +1,206 @@
+import { t as RoutesReadError } from "./routes-read-error-DQhKIE2F.js";
+import { n as routesModuleCode, r as unreadRoutesModuleCode } from "./routes-module-code-DO3aII6v.js";
+import { t as errnoCode } from "./errno-code-CNx_E80R.js";
+import { t as sharedEngine } from "./shared-engine-CCu7vP_0.js";
+import { t as configFileOf } from "./config-file-of-Zkwyi9zf.js";
+import { dirname, join, sep } from "node:path";
+import { mkdirSync, readFileSync, renameSync, rmSync, watch, writeFileSync } from "node:fs";
+// src/routes-file/follow-routes-inputs.ts
+/**
+* Watch what a reading of the routes read, so a change to any of it reads
+* them again and rewrites the module, which the bundler then builds anew:
+* the folder of each file — an edit saved by replacing the file, as editors
+* save, is seen there, where a watcher on the file itself loses it — and
+* each folder whose entries the reading listed. Packages under
+* `node_modules` are not watched: the bundler is restarted when they
+* change. The watchers hold no process open, and a folder watched already
+* gets no second one.
+*
+* @param routes - The project's routes
+* @param inputs - What the reading read, whether it gave routes or failed
+* @param onChange - Called on each change to any of it
+* @returns Whether a folder is watched now that was not before
+* @example
+* ```ts
+* followRoutesInputs(routes, snapshot, () => refreshSoon(routes));
+* ```
+*/
+function followRoutesInputs(routes, inputs, onChange) {
+	const listed = new Set(inputs.listed ?? []);
+	let added = false;
+	for (const path of [...inputs.files, ...listed]) {
+		if (path === routes.file || isPackaged(path)) continue;
+		routes.inputs.add(path);
+		added = watchFolder(routes, listed.has(path) ? path : dirname(path), onChange) || added;
+	}
+	return added;
+}
+function watchFolder(routes, folder, onChange) {
+	if (routes.watchers.has(folder)) return false;
+	let watcher;
+	try {
+		watcher = watch(folder, { persistent: false }, (_event, name) => {
+			const path = name === null ? folder : join(folder, name);
+			if (routes.inputs.has(path) || routes.inputs.has(folder)) onChange();
+		});
+	} catch {
+		return false;
+	}
+	watcher.on("error", () => {
+		watcher.close();
+		routes.watchers.delete(folder);
+	});
+	routes.watchers.set(folder, watcher);
+	return true;
+}
+function isPackaged(path) {
+	return path.includes(`${sep}node_modules${sep}`);
+}
+// src/routes-file/write-routes-file.ts
+const NOT_WRITABLE = /* @__PURE__ */ new Set([
+	"EACCES",
+	"EPERM",
+	"EROFS",
+	"ENOTDIR"
+]);
+/**
+* Write the routes module a bundler takes from disk, when it would change:
+* whole, under a name of its own first, so the bundler never reads it half
+* written, and not at all when it holds the code already, so an unchanged
+* reading builds nothing again.
+*
+* @param file - The module, absolute
+* @param code - Its code
+* @param root - The project's root, for the error
+* @param elsewhere - How the plugin is told to write it elsewhere, for the error
+* @returns Whether the file changed
+* @throws RoutesReadError `ROUTES_NOT_WRITTEN` when its folder cannot hold it
+* @example
+* ```ts
+* writeRoutesFile(file, routesModuleCode(snapshot), "/app", "withCourier(config, { outDir })");
+* ```
+*/
+function writeRoutesFile(file, code, root, elsewhere) {
+	if (contentOf(file) === code) return false;
+	const temporary = `${file}.${process.pid}.tmp`;
+	try {
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(temporary, code);
+		renameSync(temporary, file);
+		return true;
+	} catch (error) {
+		rmSync(temporary, { force: true });
+		const reason = errnoCode(error);
+		if (reason === void 0 || !NOT_WRITABLE.has(reason)) throw error;
+		throw new RoutesReadError("ROUTES_NOT_WRITTEN", `The routes module cannot be written to ${dirname(file)} (${reason}). Name a folder it can be written to with ${elsewhere}.`, { root });
+	}
+}
+function contentOf(file) {
+	try {
+		return readFileSync(file, "utf8");
+	} catch {
+		return;
+	}
+}
+// src/routes-file/routes-file.ts
+const REGISTRY = Symbol.for("@noverax/courier-build/routes-file");
+const holder = globalThis;
+const SETTLE_MS = 30;
+const STARTING_MS = [250, 2e3];
+const settling = /* @__PURE__ */ new WeakMap();
+/**
+* The routes of a project written to a module, made once per process for
+* the same module and read again on every call: a config the bundler loads
+* again reads them anew, and adds no watcher a folder has already.
+*
+* @param root - The project's root
+* @param config - The config, from the root or absolute, when it is not the one found
+* @param file - The module the bundler takes, absolute
+* @param elsewhere - How the plugin is told to write it elsewhere, for the error
+* @returns The routes, read and written
+* @throws RoutesReadError `ROUTES_NOT_WRITTEN` when the module cannot be written
+* @example
+* ```ts
+* const routes = await routesFile("/app", undefined, "/app/node_modules/.cache/@noverax/courier/routes.js", "withCourier(config, { outDir })");
+* ```
+*/
+async function routesFile(root, config, file, elsewhere) {
+	const registry = registryOf();
+	let routes = registry.get(file);
+	if (routes === void 0) {
+		routes = {
+			root,
+			config,
+			file,
+			elsewhere,
+			engine: sharedEngine({
+				root,
+				config,
+				envFiles: []
+			}),
+			configFile: void 0,
+			failure: void 0,
+			inputs: /* @__PURE__ */ new Set(),
+			watchers: /* @__PURE__ */ new Map()
+		};
+		registry.set(file, routes);
+	}
+	await refreshRoutes(routes);
+	return routes;
+}
+/**
+* Read the routes again and write the module when they changed. The
+* engine's readings end in the order they began, so the module is left as
+* the last one read it. When the routes cannot be read, those read last
+* stay, and why is kept, for a build to fail with, and told in the
+* bundler's terminal; with none read yet, the module fails where it is
+* imported, saying why.
+*
+* @param routes - The project's routes
+* @throws RoutesReadError `ROUTES_NOT_WRITTEN` when the module cannot be written
+* @example
+* ```ts
+* await refreshRoutes(routes);
+* ```
+*/
+async function refreshRoutes(routes) {
+	const follow = (inputs) => {
+		if (!followRoutesInputs(routes, inputs, () => refreshSoon(routes))) return;
+		for (const ms of STARTING_MS) setTimeout(() => refreshSoon(routes), ms).unref();
+	};
+	try {
+		const snapshot = await routes.engine.read();
+		routes.failure = void 0;
+		writeRoutesFile(routes.file, routesModuleCode(snapshot), routes.root, routes.elsewhere);
+		follow(snapshot);
+	} catch (error) {
+		if (error instanceof RoutesReadError && error.code === "ROUTES_NOT_WRITTEN") throw error;
+		const failure = error instanceof Error ? error : new Error(String(error));
+		routes.failure = failure;
+		const followed = (failure instanceof RoutesReadError ? failure.inputs : void 0) ?? routes.engine.last;
+		if (followed !== void 0) follow(followed);
+		if (routes.engine.last === void 0) {
+			const code = unreadRoutesModuleCode(failure.message);
+			writeRoutesFile(routes.file, code, routes.root, routes.elsewhere);
+		}
+		console.error(`[courier] ${failure.message}`);
+	}
+	routes.configFile = configFileOf(routes.root, routes.config);
+}
+function refreshSoon(routes) {
+	clearTimeout(settling.get(routes));
+	const timer = setTimeout(() => {
+		settling.delete(routes);
+		if (registryOf().get(routes.file) !== routes) return;
+		refreshRoutes(routes).catch((error) => {
+			console.error(`[courier] ${error instanceof Error ? error.message : String(error)}`);
+		});
+	}, SETTLE_MS);
+	timer.unref();
+	settling.set(routes, timer);
+}
+function registryOf() {
+	holder[REGISTRY] ??= /* @__PURE__ */ new Map();
+	return holder[REGISTRY];
+}
+export { routesFile as t };

package/lib/routes-loader-context-40OKDrQp.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What of a loader's context the routes loader uses. webpack and Rspack give
+ * all of it; Turbopack runs webpack loaders with a part of it, so what it may
+ * lack is optional and used only where it is there.
+ */
+interface RoutesLoaderContext {
+  /** The module the loader runs on, absolute. */
+  readonly resourcePath: string;
+  /** `"production"` in a build, `"development"` under a dev server; Turbopack names none. */
+  readonly mode?: string | undefined;
+  /** The options the rule hands the loader. */
+  getOptions(): unknown;
+  /** Whether the loader's result may be kept for the same inputs: never for the routes. */
+  cacheable(flag?: boolean): void;
+  /** Mark the loader asynchronous; the callback ends it with an error or the module's code. */
+  async(): (error: Error | null, content?: string) => void;
+  /** Build the module again when this file changes. */
+  addDependency(file: string): void;
+  /** Build the module again when an entry of this folder is added or removed. */
+  addContextDependency?(folder: string): void;
+  /** Build the module again once this path, absent now, appears. */
+  addMissingDependency?(path: string): void;
+  /** Report an error while the module still builds: what a dev server shows over the page. */
+  emitError?(error: Error): void;
+}
+export { RoutesLoaderContext as t };

package/lib/routes-module-code-DO3aII6v.js

@@ -0,0 +1,402 @@
+import { t as packageFile } from "./package-file-CVAKY_Nu.js";
+import { t as RoutesReadError } from "./routes-read-error-DQhKIE2F.js";
+import { n as isRecord, t as errnoCode } from "./errno-code-CNx_E80R.js";
+import { t as workerMessages } from "./worker-messages-BT2vvNQJ.js";
+import { isAbsolute, resolve } from "node:path";
+import { fork } from "node:child_process";
+import { readdirSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+// src/engine/supervise-child.ts
+/** How long a process is given to end once let go, before it is killed. */
+const GRACE_MS = 2e3;
+const running = /* @__PURE__ */ new Set();
+let exitWatched = false;
+/**
+* Watch over a reading's process for as long as it runs. Let go, it no
+* longer holds this process open: the channel to it closes, which ends it,
+* one that never answered is asked to end, and one still running after a
+* grace period is killed — a config may ignore SIGTERM, or block the
+* process's loop. One still running when this process exits is killed then.
+*
+* @param child - The process, just started
+* @returns How to let it go, saying whether it answered
+* @example
+* ```ts
+* const release = superviseChild(fork(worker));
+* release(false); // gave up waiting for it
+* ```
+*/
+function superviseChild(child) {
+	watchExit();
+	running.add(child);
+	child.once("exit", () => running.delete(child));
+	return (answered) => {
+		if (!isRunning(child)) return;
+		if (child.connected) child.disconnect();
+		child.unref();
+		if (!answered) child.kill("SIGTERM");
+		setTimeout(() => {
+			if (isRunning(child)) child.kill("SIGKILL");
+		}, GRACE_MS).unref();
+	};
+}
+function watchExit() {
+	if (exitWatched) return;
+	exitWatched = true;
+	process.on("exit", () => {
+		for (const child of running) child.kill("SIGKILL");
+	});
+}
+function isRunning(child) {
+	return child.exitCode === null && child.signalCode === null;
+}
+// src/engine/evaluate-in-child.ts
+/** How long a reading may take before it is given up: a config that waits on the network never ends. */
+const READ_LIMIT_MS = 6e4;
+/** The package this module ships in, by the name its manifest gives. */
+const PACKAGE_NAME = "@noverax/courier-build";
+/**
+* Read a project's routes in a process of its own, started for this reading
+* alone: the config runs there, never in the bundler's process, so a module
+* it reaches is read as it is now, and nothing it leaves behind lingers.
+*
+* @param request - Where the project is, and which env files it reads
+* @param limitMs - How long the reading may take
+* @returns The routes, and what they depended on
+* @throws RoutesReadError for a config that would not load, and
+*   `ROUTES_NOT_READ` when the process ran out of time or ended unanswered
+* @example
+* ```ts
+* const snapshot = await evaluateInChild({ root: "/app", envFiles: [] });
+* ```
+*/
+function evaluateInChild(request, limitMs = READ_LIMIT_MS) {
+	return new Promise((resolve, reject) => {
+		const unread = (message) => new RoutesReadError("ROUTES_NOT_READ", message, {
+			root: request.root,
+			configFile: request.configFile
+		});
+		const worker = packageFile("lib/engine/worker.js");
+		if (worker === void 0) {
+			reject(unread(`${PACKAGE_NAME} cannot find the folder it is installed in: install it again`));
+			return;
+		}
+		const child = fork(worker, [], {
+			execArgv: [],
+			stdio: [
+				"ignore",
+				"inherit",
+				"inherit",
+				"ipc"
+			]
+		});
+		const settle = settleOnce(superviseChild(child), resolve, reject);
+		const timer = setTimeout(() => {
+			settle(unread(`The config was still being read after ${limitMs / 1e3} s, and was given up`));
+		}, limitMs);
+		settle.onSettled(() => clearTimeout(timer));
+		ask(child, request, settle, unread);
+	});
+}
+function ask(child, request, settle, unread) {
+	child.on("message", (message) => {
+		if (workerMessages.isReply(message)) settle(outcomeOf$1(message.reply), true);
+	});
+	child.once("error", (error) => settle(unread(`The process that reads the config did not start: ${error.message}`)));
+	child.once("close", (code, signal) => settle(unread(`The process that reads the config ended (${signal ?? code}) before it answered`)));
+	child.once("spawn", () => child.send(workerMessages.request(request)));
+}
+function outcomeOf$1(reply) {
+	if (reply.ok) return reply.snapshot;
+	return new RoutesReadError(reply.code, reply.message, reply.context, {
+		stack: reply.stack,
+		inputs: reply.inputs
+	});
+}
+function settleOnce(release, resolve, reject) {
+	let settled = false;
+	const after = [];
+	const settle = (outcome, answered = false) => {
+		if (settled) return;
+		settled = true;
+		for (const then of after) then();
+		release(answered);
+		if (outcome instanceof RoutesReadError) reject(outcome);
+		else resolve(outcome);
+	};
+	return Object.assign(settle, { onSettled: (then) => after.push(then) });
+}
+// src/engine/fingerprint.ts
+/** What no file and no variable can digest to: a fingerprint nothing matches. */
+const UNSETTLED = "unsettled";
+/**
+* How far before a reading began a file system that keeps whole seconds or
+* coarser (HFS+, FAT, some network ones) may date a change made after it:
+* FAT counts in two-second steps.
+*/
+const COARSE_CLOCK_MS = 2e3;
+/**
+* How far before a reading began a file system that keeps finer times may
+* date a change made after it: Linux and Windows date a change by a clock
+* that moves once a tick, every 1 to 10 milliseconds on Linux and about 16
+* on Windows, while the reading's start is taken from a precise one.
+*/
+const TICK_MS = 100;
+/**
+* A digest of what a reading of the routes depended on, as it is now: the
+* size and the time of the last change of every file it read, whether a
+* path it looked at is there and is a folder, the entries of every folder
+* it listed, and the value of every variable it looked at. Equal digests
+* mean the same routes.
+*
+* A file changed after the reading began may have been read before or after
+* the change, so the digest is then {@link UNSETTLED}, which nothing equals,
+* and the next reading reads the routes again. The system may date such a
+* change before the reading began: by up to a tick of the clock it dates
+* changes by, and by up to two seconds where it keeps whole milliseconds or
+* coarser. A change that close to the start counts as made after it.
+*
+* @param inputs - What the reading depended on
+* @param since - When the reading began, in milliseconds since the epoch; omitted, every change counts as before it
+* @returns The digest
+* @example
+* ```ts
+* fingerprintOf(snapshot) === fingerprintOf(snapshot); // true while nothing it read changed
+* ```
+*/
+function fingerprintOf(inputs, since) {
+	const hash = createHash("sha256").update(inputs.configFile ?? "\0none");
+	const parts = [...inputs.files.map((file) => filePart(file, since)), ...(inputs.listed ?? []).map((folder) => folderPart(folder, since))];
+	for (const part of parts) {
+		if (part === "unsettled") return UNSETTLED;
+		hash.update(part);
+	}
+	for (const [name, value] of variablesOf(inputs.env)) hash.update(`\n${name}=${value ?? "\0unset"}`);
+	return hash.digest("hex");
+}
+function filePart(file, since) {
+	const stats = statOf(file);
+	if (typeof stats === "string") return `\n${file}\0${stats}`;
+	if (stats.isDirectory()) return `\n${file}\0folder`;
+	if (since !== void 0 && changedSince(stats.mtimeMs, since)) return UNSETTLED;
+	return `\n${file}\0${stats.size}\0${stats.mtimeMs}`;
+}
+function folderPart(folder, since) {
+	const stats = statOf(folder);
+	if (since !== void 0 && typeof stats !== "string" && changedSince(stats.mtimeMs, since)) return UNSETTLED;
+	return `\n${folder}/\0${entriesOf(folder)}`;
+}
+function changedSince(mtimeMs, since) {
+	return mtimeMs >= since - (mtimeMs % 1 === 0 ? COARSE_CLOCK_MS : TICK_MS);
+}
+function statOf(path) {
+	try {
+		return statSync(path, { throwIfNoEntry: false }) ?? "absent";
+	} catch (error) {
+		return errnoCode(error) ?? "unreadable";
+	}
+}
+function entriesOf(folder) {
+	try {
+		return readdirSync(folder).sort().join("\0");
+	} catch (error) {
+		return `\0${errnoCode(error) ?? "unreadable"}`;
+	}
+}
+function variablesOf(names) {
+	return (names === "*" ? Object.keys(process.env).sort() : names).map((name) => [name, process.env[name]]);
+}
+// src/engine/routes-readings.ts
+/**
+* Make the readings of a project's routes one at a time. Callers that ask
+* while one runs share it, unless something it read changed while it ran:
+* a caller that asked after it began then gets the next reading, which
+* begins after the change, so an edit saved mid-reading is never served
+* stale. A failure is not kept: the next caller reads again.
+*
+* @param read - One reading
+* @returns The readings
+* @example
+* ```ts
+* const readings = createReadings(() => evaluateInChild(request));
+* const outcome = await readings.next();
+* ```
+*/
+function createReadings(read) {
+	const state = {
+		begun: 0,
+		running: false,
+		waiting: []
+	};
+	return {
+		next() {
+			const kept = state.kept;
+			if (kept !== void 0 && isCurrent(kept)) return Promise.resolve({
+				ok: true,
+				snapshot: kept.snapshot
+			});
+			return new Promise((settle) => {
+				state.waiting.push({
+					seen: state.begun,
+					settle
+				});
+				if (!state.running) run(state, read);
+			});
+		},
+		get kept() {
+			return state.kept;
+		}
+	};
+}
+async function run(state, read) {
+	state.running = true;
+	try {
+		while (state.waiting.length > 0) await readOnce(state, read);
+	} catch (error) {
+		const stranded = state.waiting;
+		state.waiting = [];
+		for (const waiter of stranded) waiter.settle({
+			ok: false,
+			error
+		});
+	} finally {
+		state.running = false;
+	}
+}
+async function readOnce(state, read) {
+	state.begun += 1;
+	const reading = state.begun;
+	const since = Date.now();
+	const outcome = await outcomeOf(read);
+	const inputs = inputsOf(outcome);
+	const fingerprint = inputs === void 0 ? UNSETTLED : fingerprintOf(inputs, since);
+	if (outcome.ok) state.kept = {
+		snapshot: outcome.snapshot,
+		fingerprint
+	};
+	const settled = fingerprint !== "unsettled" || inputs === void 0;
+	const served = state.waiting.filter((waiter) => settled || waiter.seen < reading);
+	state.waiting = state.waiting.filter((waiter) => !served.includes(waiter));
+	for (const waiter of served) waiter.settle(outcome);
+}
+function isCurrent(kept) {
+	return kept.fingerprint !== "unsettled" && fingerprintOf(kept.snapshot) === kept.fingerprint;
+}
+async function outcomeOf(read) {
+	try {
+		return {
+			ok: true,
+			snapshot: await read()
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error
+		};
+	}
+}
+function inputsOf(outcome) {
+	if (outcome.ok) return outcome.snapshot;
+	return outcome.error instanceof RoutesReadError ? outcome.error.inputs : void 0;
+}
+// src/engine/routes-engine.ts
+/**
+* Create the engine that reads a project's routes for a bundler plugin.
+*
+* @param options - Where the project and its config are
+* @param evaluate - How one reading runs: in a process of its own
+* @returns The engine
+* @example
+* ```ts
+* const engine = createRoutesEngine({ root: process.cwd(), envFiles: [".env.local", ".env"] });
+* const { routes } = await engine.read();
+* ```
+*/
+function createRoutesEngine(options, evaluate = evaluateInChild) {
+	const request = requestOf(options);
+	const readings = createReadings(() => evaluate({
+		...request,
+		env: options.envValues?.()
+	}));
+	return {
+		async read() {
+			const outcome = await readings.next();
+			if (outcome.ok) return outcome.snapshot;
+			throw outcome.error;
+		},
+		get last() {
+			return readings.kept?.snapshot;
+		},
+		fingerprint() {
+			const kept = readings.kept;
+			return kept === void 0 || kept.fingerprint === "unsettled" ? void 0 : fingerprintOf(kept.snapshot);
+		}
+	};
+}
+function requestOf(options) {
+	const root = resolve(options.root);
+	const fromRoot = (path) => isAbsolute(path) ? path : resolve(root, path);
+	return {
+		root,
+		configFile: options.config === void 0 ? void 0 : fromRoot(options.config),
+		envFiles: (options.envFiles ?? []).map(fromRoot)
+	};
+}
+// src/engine/routes-module-code.ts
+/**
+* The module a page's bundle takes in place of `@noverax/courier/routes`:
+* the routes of every source of the config, as data alone, written as an
+* object literal that keeps every name its own — `__proto__` too, which a
+* literal would otherwise take for the object's prototype.
+*
+* @param snapshot - The routes as the config gave them
+* @returns The module's code
+* @example
+* ```ts
+* routesModuleCode(snapshot); // 'export const routes = {"shop":{"source":"shop","endpoints":{…}}};\n'
+* ```
+*/
+function routesModuleCode(snapshot) {
+	return `export const routes = ${literalOf(snapshot.routes)};\n`;
+}
+/**
+* The same module, as CommonJS, for a host that requires it and transforms
+* nothing it takes: Jest, outside its ES module mode. It exports `routes`
+* as an ES module would, so an import compiled to a `require` takes it by
+* name.
+*
+* @param snapshot - The routes as the config gave them
+* @returns The module's code
+* @example
+* ```ts
+* routesCommonJsCode(snapshot); // '"use strict";\nObject.defineProperty(exports, "__esModule", …);\nexports.routes = {…};\n'
+* ```
+*/
+function routesCommonJsCode(snapshot) {
+	return `"use strict";\nObject.defineProperty(exports, "__esModule", { value: true });\nexports.routes = ${literalOf(snapshot.routes)};\n`;
+}
+function literalOf(value) {
+	if (Array.isArray(value)) return `[${value.map(literalOf).join(",")}]`;
+	if (!isRecord(value)) return JSON.stringify(value) ?? "null";
+	return `{${Object.entries(value).filter(([, member]) => member !== void 0).map(([key, member]) => `${keyOf(key)}:${literalOf(member)}`).join(",")}}`;
+}
+function keyOf(key) {
+	return key === "__proto__" ? "[\"__proto__\"]" : JSON.stringify(key);
+}
+/**
+* The module a page's bundle takes when the routes were never read: one
+* that fails where it is imported, saying why, as a build fails with it.
+* It still exports `routes`, so a module that imports it links, and the
+* reason is the error the page shows.
+*
+* @param message - Why the routes were not read
+* @returns The module's code
+* @example
+* ```ts
+* unreadRoutesModuleCode("courier.config.ts did not load: …");
+* ```
+*/
+function unreadRoutesModuleCode(message) {
+	return `throw new Error(${JSON.stringify(`[courier] ${message}`)});\nexport const routes = {};\n`;
+}
+export { createRoutesEngine as i, routesModuleCode as n, unreadRoutesModuleCode as r, routesCommonJsCode as t };

package/lib/routes-module-id-CnUjQjYF.js

@@ -0,0 +1,12 @@
+// src/util/routes-module-id.ts
+/** What a page imports its routes by: the module the package ships, which the plugin answers. */
+const ROUTES_SPECIFIER = "@noverax/courier/routes";
+/**
+* The module the plugin answers it with. A virtual id, so no environment
+* takes it for an installed file to load as it is, and a server's bundle
+* builds it in as the page's does.
+*/
+const ROUTES_MODULE_ID = "\0@noverax/courier/routes";
+/** Exactly the specifier: a path that merely begins with it is another module. */
+const ROUTES_PATTERN = /^@noverax\/courier\/routes$/;
+export { ROUTES_PATTERN as n, ROUTES_SPECIFIER as r, ROUTES_MODULE_ID as t };

package/lib/routes-read-error-DQhKIE2F.js

@@ -0,0 +1,30 @@
+import { CourierError } from "@noverax/courier";
+// src/engine/routes-read-error.ts
+/**
+* A project's routes could not be read from its config. A build fails with
+* it; a dev server keeps the routes it read last and reports it.
+*
+* @example
+* ```ts
+* throw new RoutesReadError("CONFIG_NOT_FOUND", "No courier.config.* in /app or above it", { root: "/app" });
+* ```
+*/
+var RoutesReadError = class extends CourierError {
+	/** What the reading had read when it failed, when it answered at all. */
+	inputs;
+	/**
+	* @param code - Why the routes were not read
+	* @param message - What went wrong, and what to do about it
+	* @param context - The project's root, and the config file once found
+	* @param details - The stack of what the config threw, and what the reading had read
+	*/
+	constructor(code, message, context, { stack, inputs } = {}) {
+		super(message, {
+			code,
+			context
+		});
+		if (stack !== void 0) this.stack = stack;
+		this.inputs = inputs;
+	}
+};
+export { RoutesReadError as t };