@noverax/courier-build 0.0.0-stage → 0.5.0

package/lib/routes-rule-Pu1Tz8Xm.js

@@ -0,0 +1,108 @@
+import { t as packageFile } from "./package-file-CVAKY_Nu.js";
+import { t as RoutesReadError } from "./routes-read-error-DQhKIE2F.js";
+import { t as configFileOf } from "./config-file-of-Clf_dWUQ.js";
+import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
+import { realpathSync } from "node:fs";
+// src/webpack/routes-loader-file.ts
+/**
+* The loader this package ships, as webpack, Rspack and Turbopack load it:
+* a CommonJS module, by its absolute path.
+*
+* @returns The loader file
+* @throws Error when the package's own folder cannot be found
+* @example
+* ```ts
+* routesLoaderFile(); // "/app/node_modules/@noverax/courier-build/lib/webpack/loader.cjs"
+* ```
+*/
+function routesLoaderFile() {
+	const file = packageFile("lib/webpack/loader.cjs");
+	if (file === void 0) throw new Error("[courier] @noverax/courier-build cannot find the folder it is installed in: install it again.");
+	return file;
+}
+// src/webpack/config-in-page-rule.ts
+/**
+* The rule that fails a page's bundle where it takes the project's config
+* as a module: it would ship the server's settings and every API's
+* definition to the browser. Only for the bundles a browser runs; a server's
+* may import the config.
+*
+* @param project - The project, as `routesProject()` gives it
+* @returns The rule, for the `module.rules` of a page's bundle; none when the project has no config yet
+* @example
+* ```ts
+* const rule = configInPageRule(project);
+* if (rule && !isServer) config.module.rules.push(rule);
+* ```
+*/
+function configInPageRule(project) {
+	if (project.configFile === void 0) return void 0;
+	return {
+		test: project.configFile,
+		use: [{
+			loader: routesLoaderFile(),
+			options: {
+				root: project.root,
+				config: project.config,
+				refuse: "config-in-page"
+			}
+		}]
+	};
+}
+// src/webpack/routes-project.ts
+/**
+* The project a bundler builds, as its routes rules need it.
+*
+* @param root - The project's root, where the bundler resolves its packages from
+* @param options - The plugin's options
+* @returns The project
+* @throws RoutesReadError `CORE_NOT_FOUND` when `@noverax/courier` does not resolve from the root
+* @example
+* ```ts
+* routesProject("/app"); // { root: "/app", stubFile: "/app/node_modules/@noverax/courier/lib/routes/index.js", configFile: "/app/courier.config.ts" }
+* ```
+*/
+function routesProject(root, options = {}) {
+	const config = options.config === void 0 ? void 0 : resolve(root, options.config);
+	return {
+		root,
+		config,
+		stubFile: stubFileOf(root),
+		configFile: configFileOf(root, config)
+	};
+}
+function stubFileOf(root) {
+	try {
+		return realpathSync(createRequire(join(root, "package.json")).resolve("@noverax/courier/routes"));
+	} catch (error) {
+		throw new RoutesReadError("CORE_NOT_FOUND", `@noverax/courier does not resolve from ${root}, so there is no routes module to build the routes in place of. Install it in the project, beside @noverax/courier-build.`, { root }, { stack: error instanceof Error ? error.stack : void 0 });
+	}
+}
+// src/webpack/routes-rule.ts
+/**
+* The rule that builds the routes in place of the module
+* `@noverax/courier/routes` ships, for every bundle the bundler builds: a
+* page's and a server's alike.
+*
+* @param project - The project, as `routesProject()` gives it
+* @returns The rule, for the bundler's `module.rules`
+* @example
+* ```ts
+* config.module.rules.push(routesRule(routesProject(config.context)));
+* ```
+*/
+function routesRule(project) {
+	return {
+		test: project.stubFile,
+		enforce: "pre",
+		use: [{
+			loader: routesLoaderFile(),
+			options: {
+				root: project.root,
+				config: project.config
+			}
+		}]
+	};
+}
+export { routesLoaderFile as i, routesProject as n, configInPageRule as r, routesRule as t };

package/lib/rsbuild/index.d.ts

@@ -0,0 +1,41 @@
+import { t as CourierRoutesOptions } from "../courier-routes-options-BYF7Sfdf.js";
+/** What of an Rspack config the plugin adds its rules to. */
+interface RulesConfig {
+  module?: {
+    rules?: unknown[];
+  } | undefined;
+}
+/** What of Rsbuild's plugin API the plugin uses. */
+interface RoutesRsbuildApi {
+  readonly context: {
+    readonly rootPath: string;
+  };
+  modifyRspackConfig(modify: (config: RulesConfig, utils: {
+    readonly isServer: boolean;
+  }) => void): void;
+}
+/** An Rsbuild plugin, as Rsbuild takes it in `plugins`. */
+interface RoutesRsbuildPlugin {
+  readonly name: string;
+  setup(api: RoutesRsbuildApi): void;
+}
+/**
+ * The Rsbuild plugin that builds the routes a page's proxy client may call
+ * from `courier.config.ts`, in place of the module `@noverax/courier/routes`
+ * ships, for every environment Rsbuild builds: a page's and a server's
+ * alike. No routes file is written. A page's bundle that takes the config
+ * itself fails.
+ *
+ * @param options - Where the config is, when it is not found from the project's root
+ * @returns The plugin
+ * @example
+ * ```ts
+ * // rsbuild.config.ts
+ * import { courierRoutes } from "@noverax/courier-build/rsbuild";
+ * import { defineConfig } from "@rsbuild/core";
+ *
+ * export default defineConfig({ plugins: [courierRoutes()] });
+ * ```
+ */
+export declare function courierRoutes(options?: CourierRoutesOptions): RoutesRsbuildPlugin;
+export type { CourierRoutesOptions, RoutesRsbuildApi, RoutesRsbuildPlugin };

package/lib/rsbuild/index.js

@@ -0,0 +1,37 @@
+import { n as routesProject, r as configInPageRule, t as routesRule } from "../routes-rule-Pu1Tz8Xm.js";
+// src/rsbuild/courier-routes.ts
+/**
+* The Rsbuild plugin that builds the routes a page's proxy client may call
+* from `courier.config.ts`, in place of the module `@noverax/courier/routes`
+* ships, for every environment Rsbuild builds: a page's and a server's
+* alike. No routes file is written. A page's bundle that takes the config
+* itself fails.
+*
+* @param options - Where the config is, when it is not found from the project's root
+* @returns The plugin
+* @example
+* ```ts
+* // rsbuild.config.ts
+* import { courierRoutes } from "@noverax/courier-build/rsbuild";
+* import { defineConfig } from "@rsbuild/core";
+*
+* export default defineConfig({ plugins: [courierRoutes()] });
+* ```
+*/
+function courierRoutes(options = {}) {
+	return {
+		name: "courier-routes",
+		setup(api) {
+			const project = routesProject(api.context.rootPath, options);
+			api.modifyRspackConfig((config, { isServer }) => {
+				config.module ??= {};
+				config.module.rules ??= [];
+				const rules = config.module.rules;
+				rules.push(routesRule(project));
+				const guard = configInPageRule(project);
+				if (guard !== void 0 && !isServer) rules.push(guard);
+			});
+		}
+	};
+}
+export { courierRoutes };

package/lib/rspack/index.d.ts

@@ -0,0 +1,3 @@
+import { t as CourierRoutesOptions } from "../courier-routes-options-BYF7Sfdf.js";
+import { n as CourierRoutesPlugin, r as RoutesCompiler } from "../index-_VUU5N5v.js";
+export { type CourierRoutesOptions, CourierRoutesPlugin, type RoutesCompiler };

package/lib/rspack/index.js

@@ -0,0 +1 @@
+export { t as CourierRoutesPlugin } from "../webpack-BPxhBYGV.js";

package/lib/shared-engine-D0j7uXg8.js

@@ -0,0 +1,28 @@
+import { i as createRoutesEngine } from "./routes-module-code-DYtP7uj1.js";
+// src/engine/shared-engine.ts
+const engines = /* @__PURE__ */ new Map();
+/**
+* The engine for a project, made once per process for the same root, config
+* and env files, and shared by every plugin made for them.
+*
+* @param options - Where the project and its config are, and its env files
+* @returns The engine those options name
+* @example
+* ```ts
+* sharedEngine({ root: "/app", envFiles: ["/app/.env"] }) === sharedEngine({ root: "/app", envFiles: ["/app/.env"] }); // true
+* ```
+*/
+function sharedEngine(options) {
+	const key = JSON.stringify([
+		options.root,
+		options.config ?? null,
+		options.envFiles ?? []
+	]);
+	let engine = engines.get(key);
+	if (engine === void 0) {
+		engine = createRoutesEngine(options);
+		engines.set(key, engine);
+	}
+	return engine;
+}
+export { sharedEngine as t };

package/lib/vite/index.d.ts

@@ -0,0 +1,33 @@
+import { Plugin } from "vite";
+/** Options of the routes plugin. */
+interface CourierRoutesOptions {
+  /**
+   * The config file, from Vite's root or absolute, when it is not the
+   * `courier.config.*` in the root or the nearest folder above it.
+   */
+  config?: string | undefined;
+}
+/**
+ * The Vite plugin that hands every page, and every server rendering one,
+ * the routes its proxy client may call: read from `courier.config.ts` by
+ * the rules the proxy applies, in place of the module
+ * `@noverax/courier/routes` ships. No routes file is written, and the
+ * routes carry no address, path or middleware; a page that imports the
+ * config itself fails the build.
+ *
+ * A build that cannot read the config fails with why; the dev server reads
+ * it again whenever something it came from changes, and Vitest, which runs
+ * tests through Vite, reruns the tests that import the routes.
+ *
+ * @param options - Where the config is, when it is not found from the root
+ * @returns The plugin
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { courierRoutes } from "@noverax/courier-build/vite";
+ *
+ * export default defineConfig({ plugins: [courierRoutes()] });
+ * ```
+ */
+export declare function courierRoutes(options?: CourierRoutesOptions): Plugin;
+export type { CourierRoutesOptions };

package/lib/vite/index.js

@@ -0,0 +1,357 @@
+import { t as RoutesReadError } from "../routes-read-error-DQhKIE2F.js";
+import { n as routesModuleCode, r as unreadRoutesModuleCode } from "../routes-module-code-DYtP7uj1.js";
+import { n as isRecord } from "../errno-code-CNx_E80R.js";
+import { t as configInPageMessage } from "../config-in-page-message-DLd3f0Jd.js";
+import { T as configCandidates, h as localPath } from "../load-config-barNPfXN.js";
+import { t as sharedEngine } from "../shared-engine-D0j7uXg8.js";
+import { t as configFileOf } from "../config-file-of-Clf_dWUQ.js";
+import { n as ROUTES_PATTERN, r as ROUTES_SPECIFIER, t as ROUTES_MODULE_ID } from "../routes-module-id-CnUjQjYF.js";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { existsSync, statSync } from "node:fs";
+import { loadEnv } from "vite";
+// src/vite/config-in-page.ts
+/**
+* Refuse the project's config as a module of a page. It holds the server's
+* settings and the definition of every API — their addresses, their
+* middleware, what reads their secrets — and imported as a value it ships
+* all of them to the browser. A page needs its type alone, which an
+* `import type` gives without a byte of it.
+*
+* @param context - Vite's plugin context
+* @param id - The module Vite is transforming
+* @param options - What Vite before 6 says of the module: `ssr` for a server's
+* @param configFile - The project's config, absolute
+* @example
+* ```ts
+* transform(code, id, options) { refuseConfigInPage(this, id, options, configFile); }
+* ```
+*/
+function refuseConfigInPage(context, id, options, configFile) {
+	if (configFile === void 0 || !isPageModule(context, options)) return;
+	if (withSlashes(id.split("?")[0] ?? id) !== withSlashes(configFile)) return;
+	context.error(configInPageMessage(configFile));
+}
+function isPageModule(context, options) {
+	const consumer = context.environment?.config.consumer;
+	return consumer === void 0 ? options?.ssr !== true : consumer === "client";
+}
+function withSlashes(path) {
+	return path.split("\\").join("/");
+}
+// src/vite/watch-once.ts
+const given = /* @__PURE__ */ new WeakMap();
+/**
+* Hand a dev server's watcher each path it does not follow yet. The routes
+* module is loaded again on every edit, and follows the same paths each
+* time: each is given to each server once. A path the watcher follows
+* already, as it follows Vite's root, is not given at all: chokidar reads a
+* folder it is handed as one just added, and an entry made since the routes
+* were read would pass for one that was there, with no notice of it. A
+* watcher that stops at a depth lists the folders below it unread: it is
+* handed every path.
+*
+* @param server - The dev server
+* @param paths - The paths to watch, there or not
+* @example
+* ```ts
+* watchOnce(server, ["/app/courier.config.ts", "/app/.env.local"]);
+* ```
+*/
+function watchOnce(server, paths) {
+	let seen = given.get(server);
+	if (seen === void 0) {
+		seen = /* @__PURE__ */ new Set();
+		given.set(server, seen);
+	}
+	const fresh = [...paths].filter((path) => !seen.has(path));
+	for (const path of fresh) seen.add(path);
+	if (fresh.length === 0) return;
+	const watched = server.watcher.options.depth === void 0 ? server.watcher.getWatched() : {};
+	const unfollowed = fresh.filter((path) => {
+		const local = localPath(path);
+		return !watched[dirname(local)]?.includes(basename(local));
+	});
+	if (unfollowed.length > 0) server.watcher.add(unfollowed);
+}
+// src/vite/follow-routes-inputs.ts
+/**
+* Follow what a reading of the routes read, so that a change to it loads
+* the routes module again. Each file is watched for the module, and Vite
+* loads it again once one changes; every path, there or not, is followed by
+* each dev server's watcher, which loads it again once one appears or goes,
+* and so is every entry of a folder the reading listed. Installed packages
+* are left to the install.
+*
+* @param context - Vite's plugin context, loading the routes module
+* @param state - What the plugin knows, whose followed paths this replaces
+* @param inputs - What the reading read, whether it gave routes or failed
+* @example
+* ```ts
+* followRoutesInputs(this, state, snapshot);
+* ```
+*/
+function followRoutesInputs(context, state, inputs) {
+	const followed = /* @__PURE__ */ new Set();
+	for (const path of inputs.files) {
+		if (isInstalled(path)) continue;
+		followed.add(path);
+		if (isFile(path)) context.addWatchFile(path);
+	}
+	const listed = new Set((inputs.listed ?? []).filter((folder) => !isInstalled(folder)));
+	state.followed = followed;
+	state.listed = listed;
+	for (const server of state.servers) watchOnce(server, [...followed, ...listed]);
+}
+function isInstalled(path) {
+	return path.split(sep).includes("node_modules");
+}
+function isFile(path) {
+	try {
+		return statSync(path, { throwIfNoEntry: false })?.isFile() === true;
+	} catch {
+		return false;
+	}
+}
+// src/vite/load-routes-module.ts
+/**
+* The routes module for a page: the routes read from the config, with every
+* project path they came from followed, so a change loads the module again.
+*
+* When they cannot be read, what the failed reading read is followed
+* instead, so mending the config or a module it imports brings the routes
+* back, in a dev server and in a build that watches alike. A build then
+* fails with why. A dev server keeps the routes it read last, and reports
+* why in its terminal and on the page; with none read yet, the module fails
+* where it is imported, with the reason.
+*
+* @param context - Vite's plugin context, which watches files and fails builds
+* @param state - What the plugin knows of the Vite it runs in
+* @returns The module's code
+* @example
+* ```ts
+* load(id) { return id === ROUTES_MODULE_ID ? loadRoutesModule(this, state) : undefined; }
+* ```
+*/
+async function loadRoutesModule(context, state) {
+	const engine = state.engine;
+	if (engine === void 0) throw new RoutesReadError("ROUTES_NOT_READ", "The routes were asked for before Vite resolved its config", { root: process.cwd() });
+	try {
+		const snapshot = await engine.read();
+		followRoutesInputs(context, state, snapshot);
+		return routesModuleCode(snapshot);
+	} catch (error) {
+		const failure = asError(error);
+		const followed = (failure instanceof RoutesReadError ? failure.inputs : void 0) ?? engine.last;
+		if (followed !== void 0) followRoutesInputs(context, state, followed);
+		if (state.config?.command === "build") context.error(failure);
+		report(state, failure);
+		const last = engine.last;
+		return last === void 0 ? unreadRoutesModuleCode(failure.message) : routesModuleCode(last);
+	}
+}
+function report(state, error) {
+	const message = `[courier] ${error.message}`;
+	state.config?.logger.error(message, {
+		timestamp: true,
+		error
+	});
+	for (const server of state.servers) server.ws.send({
+		type: "error",
+		err: {
+			message,
+			stack: error.stack ?? ""
+		}
+	});
+}
+function asError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+// src/vite/vite-env-files.ts
+/**
+* The env files Vite reads for a mode, in the order the first to set a
+* variable wins: the mode's local file, the mode's, the local one, then
+* `.env` — the variables the app's own `import.meta.env` is given.
+*
+* @param settings - Vite's root, mode and env folder
+* @returns The files, absolute; none when the env folder is turned off
+* @example
+* ```ts
+* viteEnvFiles({ root: "/app", mode: "production" });
+* // → ["/app/.env.production.local", "/app/.env.production", "/app/.env.local", "/app/.env"]
+* ```
+*/
+function viteEnvFiles({ root, mode, envDir }) {
+	if (envDir === false) return [];
+	const dir = envDir ?? root;
+	return [
+		`.env.${mode}.local`,
+		`.env.${mode}`,
+		".env.local",
+		".env"
+	].map((name) => join(dir, name));
+}
+// src/vite/vite-env-values.ts
+/**
+* The variables Vite's env files give for a mode, with the values Vite gives
+* them — `${VAR}` and `${VAR:-default}` filled in as it fills them — for
+* each the process was not started with: what a reading of the routes puts
+* into `process.env` before the config runs, so it sees what the app sees.
+*
+* @param settings - Vite's root, mode and env folder
+* @returns The variables; none when the env folder is turned off
+* @example
+* ```ts
+* viteEnvValues({ root: "/app", mode: "production" }); // { API_URL: "https://api.example.com/v1" }
+* ```
+*/
+function viteEnvValues({ root, mode, envDir }) {
+	if (envDir === false) return {};
+	const loaded = loadEnv(mode, envDir ?? root, "");
+	return Object.fromEntries(Object.entries(loaded).filter(([key]) => !(key in process.env)));
+}
+// src/vite/watch-routes-inputs.ts
+const PATH_EVENTS = [
+	"add",
+	"unlink",
+	"addDir",
+	"unlinkDir"
+];
+/**
+* Load the routes module again when a path the routes depend on appears or
+* goes, which no change of a watched file reports: a config saved where one
+* is looked for, inside Vite's root or above it, or the config removed; an
+* env file or a module made where the latest reading looked for one; an
+* entry added to or removed from a folder it listed.
+*
+* Vite watches with chokidar 3, which reads a folder it was handed missing
+* files in no more than once a second, and then for the first of them
+* alone: a config saved there under another of its names was never
+* reported. Each raw event of a folder a config may be in looks at every
+* place there a config is looked for, and a config that appears or goes is
+* told once, however many events report it.
+*
+* @param server - A dev server the plugin serves
+* @param state - What the plugin knows: the paths the latest reading followed
+* @param config - Where the config may be, and what to do when it moves
+* @example
+* ```ts
+* configureServer(server) {
+*   watchRoutesInputs(server, state, { candidates: configCandidates(root), onChange });
+* }
+* ```
+*/
+function watchRoutesInputs(server, state, config) {
+	const candidates = new Set(config.candidates);
+	watchOnce(server, candidates);
+	const there = new Map([...candidates].map((path) => [path, existsSync(path)]));
+	const onPath = (path) => {
+		const isConfig = candidates.has(path);
+		if (!isConfig && !state.followed.has(path) && !state.listed.has(dirname(path))) return;
+		if (isConfig) {
+			const now = existsSync(path);
+			if (there.get(path) === now) return;
+			there.set(path, now);
+			config.onChange();
+		}
+		reloadRoutes(server);
+	};
+	for (const event of PATH_EVENTS) server.watcher.on(event, onPath);
+	const folders = new Set([...candidates].map((path) => dirname(path)));
+	server.watcher.on("raw", (_event, path, details) => {
+		const folder = eventFolder(path, details);
+		if (folder === void 0 || !folders.has(folder)) return;
+		for (const candidate of candidates) if (dirname(candidate) === folder) onPath(candidate);
+	});
+}
+function eventFolder(path, details) {
+	const watched = isRecord(details) ? details.watchedPath : void 0;
+	const folder = typeof watched === "string" ? watched : path;
+	return isAbsolute(folder) ? resolve(folder) : void 0;
+}
+function reloadRoutes(server) {
+	const environments = server.environments;
+	const graphs = environments === void 0 ? [] : Object.values(environments).map((each) => each.moduleGraph);
+	for (const graph of graphs) invalidateRoutes(graph);
+	if (environments === void 0) invalidateRoutes(server.moduleGraph);
+	server.ws.send({ type: "full-reload" });
+}
+function invalidateRoutes(graph) {
+	const module = graph.getModuleById(ROUTES_MODULE_ID);
+	if (module !== void 0) graph.invalidateModule(module);
+}
+// src/vite/courier-routes.ts
+/**
+* The Vite plugin that hands every page, and every server rendering one,
+* the routes its proxy client may call: read from `courier.config.ts` by
+* the rules the proxy applies, in place of the module
+* `@noverax/courier/routes` ships. No routes file is written, and the
+* routes carry no address, path or middleware; a page that imports the
+* config itself fails the build.
+*
+* A build that cannot read the config fails with why; the dev server reads
+* it again whenever something it came from changes, and Vitest, which runs
+* tests through Vite, reruns the tests that import the routes.
+*
+* @param options - Where the config is, when it is not found from the root
+* @returns The plugin
+* @example
+* ```ts
+* // vite.config.ts
+* import { courierRoutes } from "@noverax/courier-build/vite";
+*
+* export default defineConfig({ plugins: [courierRoutes()] });
+* ```
+*/
+function courierRoutes(options = {}) {
+	const state = {
+		servers: /* @__PURE__ */ new Set(),
+		followed: /* @__PURE__ */ new Set(),
+		listed: /* @__PURE__ */ new Set(),
+		underVitest: false
+	};
+	return {
+		name: "courier-routes",
+		enforce: "pre",
+		config: () => ({
+			resolve: { alias: [{
+				find: ROUTES_PATTERN,
+				replacement: ROUTES_MODULE_ID
+			}] },
+			optimizeDeps: { exclude: [ROUTES_SPECIFIER] }
+		}),
+		configResolved: (config) => resolveRoutes(state, config, options.config),
+		configureServer: (server) => serveRoutes(state, server, options.config),
+		resolveId: (id) => id === "@noverax/courier/routes" || id === "\0@noverax/courier/routes" ? ROUTES_MODULE_ID : void 0,
+		load(id) {
+			return id === "\0@noverax/courier/routes" ? loadRoutesModule(this, state) : void 0;
+		},
+		transform(_code, id, transformOptions) {
+			if (!state.underVitest) refuseConfigInPage(this, id, transformOptions, state.configFile);
+		},
+		configureVitest(context) {
+			state.underVitest = true;
+			(context.defineCacheKeyGenerator ?? context.experimental_defineCacheKeyGenerator)?.(({ id }) => id === "\0@noverax/courier/routes" ? false : void 0);
+		}
+	};
+}
+function resolveRoutes(state, config, named) {
+	state.config = config;
+	state.engine = sharedEngine({
+		root: config.root,
+		config: named,
+		envFiles: viteEnvFiles(config),
+		envValues: () => viteEnvValues(config)
+	});
+	state.configFile = configFileOf(config.root, named);
+}
+function serveRoutes(state, server, named) {
+	state.servers.add(server);
+	const root = server.config.root;
+	watchRoutesInputs(server, state, {
+		candidates: named === void 0 ? configCandidates(root) : [resolve(root, named)],
+		onChange: () => {
+			state.configFile = configFileOf(server.config.root, named);
+		}
+	});
+}
+export { courierRoutes };

package/lib/webpack/index.d.ts

@@ -0,0 +1,4 @@
+import { t as CourierRoutesOptions } from "../courier-routes-options-BYF7Sfdf.js";
+import { a as RoutesLoaderRule, c as RoutesProject, i as configInPageRule, l as routesProject, n as CourierRoutesPlugin, o as routesRule, r as RoutesCompiler, s as RoutesLoaderOptions, t as routesLoaderFile } from "../index-_VUU5N5v.js";
+import { t as RoutesLoaderContext } from "../routes-loader-context-40OKDrQp.js";
+export { type CourierRoutesOptions, CourierRoutesPlugin, type RoutesCompiler, type RoutesLoaderContext, type RoutesLoaderOptions, type RoutesLoaderRule, type RoutesProject, configInPageRule, routesLoaderFile, routesProject, routesRule };

package/lib/webpack/index.js

@@ -0,0 +1,3 @@
+import { i as routesLoaderFile, n as routesProject, r as configInPageRule, t as routesRule } from "../routes-rule-Pu1Tz8Xm.js";
+import { t as CourierRoutesPlugin } from "../webpack-BPxhBYGV.js";
+export { CourierRoutesPlugin, configInPageRule, routesLoaderFile, routesProject, routesRule };

package/lib/webpack/loader.cjs

@@ -0,0 +1,31 @@
+let node_path = require("node:path");
+let node_url = require("node:url");
+// src/webpack/loader.ts
+/**
+* The loader webpack, Rspack and Turbopack run on the module
+* `@noverax/courier/routes` ships, which they load as CommonJS: it hands the
+* work to the package's ES modules. Its result is never kept for the same
+* inputs, as the routes may follow a variable the config reads, which no
+* bundler sees; the engine reads them again only when what they came from
+* has changed.
+*
+* @example
+* ```ts
+* config.module.rules.push({ test: stubFile, use: [{ loader: routesLoaderFile(), options: { root } }] });
+* ```
+*/
+function courierRoutesLoader() {
+	this.cacheable(false);
+	const done = this.async();
+	import((0, node_url.pathToFileURL)((0, node_path.join)(__dirname, "run-routes-loader.js")).href).then((module) => runnerOf(module)(this)).then((code) => done(null, code), (error) => done(error instanceof Error ? error : new Error(String(error))));
+}
+function runnerOf(module) {
+	const run = typeof module === "object" && module !== null ? Reflect.get(module, "runRoutesLoader") : void 0;
+	if (typeof run !== "function") throw new Error("[courier] @noverax/courier-build is installed incompletely: install it again.");
+	return async (context) => {
+		const code = await Reflect.apply(run, void 0, [context]);
+		if (typeof code !== "string") throw new Error("[courier] The routes loader built no module.");
+		return code;
+	};
+}
+module.exports = courierRoutesLoader;