@sjcx/vorma 0.0.0-pre.0

package/dist/build/cli.js

@@ -0,0 +1,1256 @@
+#!/usr/bin/env node
+import { C as toContentDigest, S as encodeCanonicalJson, _ as compileServerApplication, a as acquireOutputOwnership, b as getClientViewEntries, c as writeAndCheckApplicationGeneration, d as withTypescriptProjects, f as inspectProjects, g as createClientPublicUrlPlugin, h as createCssPublicAssets, i as publishApplicationArtifacts, l as collectPublicAssets, m as resolveVormaConfig, n as loadApplicationSourceLayout, o as checkOutputPath, p as getGeneratedSourceDirectories, r as preparePublicOutput, s as assembleApplicationGeneration, t as buildApplication, u as readTypescriptProjectRoots, v as containsRelativePath, x as projectBrowserContracts, y as CLIENT_SHARED_PACKAGES } from "../build-JgARonaY.js";
+import { g as DEVELOPMENT_PROTOCOL, y as FRAMEWORK_IDENTITY_PROTOCOL } from "../value-transport-Bst4Hk-n.js";
+import { t as VORMA_BUILD_PLUGIN_NAME } from "../build-invocation-D7Fu8gBK.js";
+import { VormaConfigSchema } from "../server/config/index.js";
+import { NodeChildProcessSpawner, NodeCrypto, NodeFileSystem, NodePath, NodeRuntime, NodeSocketServer, NodeStdio, NodeTerminal } from "@effect/platform-node-shared";
+import { Cause, Console, Deferred, Effect, Exit, Fiber, FileSystem, Layer, Path, Queue, Result, Schedule, Schema, ScopedRef, Stream } from "effect";
+import { Command, Flag } from "effect/unstable/cli";
+import { createFilter, createServer, loadConfigFromFile, normalizePath } from "vite";
+import { dirname, isAbsolute, posix, relative, sep } from "node:path";
+import { RolldownMagicString } from "rolldown";
+import { createServer as createServer$1 } from "node:http";
+import { FetchHttpClient, HttpClient } from "effect/unstable/http";
+import { ChildProcess } from "effect/unstable/process";
+import { watch } from "chokidar";
+//#region package.json
+var version = "0.87.0-pre.0";
+//#endregion
+//#region src/build/development-artifacts.ts
+function toDevelopmentModuleUrl(input) {
+	const pathname = input.id.startsWith("\0") ? `/@id/__x00__${input.id.slice(1)}` : `/@fs/${normalizePath(input.id).replace(/^\//, "")}`;
+	return input.origin + pathname.split("/").map(encodeURIComponent).join("/").replaceAll("%40", "@").replaceAll("%3A", ":");
+}
+/** Keeps source URLs and browser contracts on the server; responses project only requested views. */
+function assembleDevelopmentArtifacts(input) {
+	const generation = input.build.generation.application;
+	function toModule(id) {
+		return {
+			importUrl: toDevelopmentModuleUrl({
+				origin: input.client.origin,
+				id
+			}),
+			depUrls: [],
+			cssBundleUrls: [],
+			staticAssetUrls: []
+		};
+	}
+	const clientViews = Object.fromEntries(getClientViewEntries(generation).map((view) => {
+		return [view.pattern, {
+			...toModule(view.id),
+			exportNames: view.exportNames
+		}];
+	}));
+	return { metadata: {
+		runtimeMode: "development",
+		clientBuildId: toContentDigest(encodeCanonicalJson({
+			contracts: projectBrowserContracts(generation.inspection),
+			clientTransport: generation.clientTransport.source,
+			views: clientViews,
+			publicFilemap: generation.publicAssets.publicFilemap
+		})).slice(0, 24),
+		clientEntry: toModule(generation.config.clientEntryFilePath),
+		clientViews,
+		criticalCss: input.build.stylesheet.css,
+		developmentHeadHtml: input.developmentHeadHtml,
+		publicFilemap: generation.publicAssets.publicFilemap,
+		publicFiles: generation.publicAssets.assets.map((asset) => {
+			return {
+				url: asset.url,
+				fileName: asset.fileName,
+				immutable: true
+			};
+		})
+	} };
+}
+//#endregion
+//#region src/build/development-protocol.ts
+function toDevelopmentClientInputs(generation, sources) {
+	return {
+		viteConfigFilePath: generation.config.viteConfigFilePath,
+		clientEntryFilePath: generation.config.clientEntryFilePath,
+		clientViewModules: generation.model.clientViewModules,
+		coordinatedResolutionFiles: sources.resolutionFiles,
+		generatedDirectories: [generation.config.serverGeneratedDirectory, generation.config.clientGeneratedDirectory],
+		clientTransport: generation.clientTransport,
+		views: getClientViewEntries(generation),
+		publicUrlSites: generation.inspection.publicUrlSites,
+		clientSourceTexts: Object.fromEntries(generation.inspection.clientSourceTexts),
+		publicAssets: generation.publicAssets.assets,
+		publicFilemap: generation.publicAssets.publicFilemap,
+		publicDirectory: generation.config.publicDirectory
+	};
+}
+//#endregion
+//#region src/build/development-stylesheet.ts
+/** Reads CSS and its dependency files from Vite's native direct-CSS pipeline. */
+function readDevelopmentStylesheet(input) {
+	return Effect.gen(function* () {
+		const environment = input.server.environments.client;
+		if (environment === void 0) return yield* Effect.fail({
+			_tag: "DevelopmentStylesheetIssue",
+			filePath: input.filePath,
+			cause: "Vite has no client environment"
+		});
+		const url = `/@fs/${normalizePath(input.filePath)}?direct`;
+		const transformed = yield* Effect.tryPromise({
+			try: async () => {
+				const previous = await environment.moduleGraph.getModuleByUrl(url);
+				if (previous !== void 0) environment.moduleGraph.invalidateModule(previous);
+				return {
+					result: await environment.transformRequest(url),
+					module: await environment.moduleGraph.getModuleByUrl(url)
+				};
+			},
+			catch: (cause) => {
+				return {
+					_tag: "DevelopmentStylesheetIssue",
+					filePath: input.filePath,
+					cause
+				};
+			}
+		});
+		if (transformed.result === null || transformed.module === void 0) return yield* Effect.fail({
+			_tag: "DevelopmentStylesheetIssue",
+			filePath: input.filePath,
+			cause: "Vite did not produce the requested stylesheet"
+		});
+		const visited = /* @__PURE__ */ new Set();
+		const pending = [transformed.module];
+		const files = /* @__PURE__ */ new Set();
+		while (pending.length > 0) {
+			const module = pending.pop();
+			if (module === void 0 || visited.has(module)) continue;
+			visited.add(module);
+			if (module.file !== null) files.add(module.file);
+			pending.push(...module.importedModules);
+		}
+		return {
+			css: transformed.result.code,
+			inputFilePaths: [...files]
+		};
+	});
+}
+//#endregion
+//#region src/build/development-build.ts
+/** Prepares server bytes and native CSS concurrently after their generated inputs exist. */
+function prepareDevelopmentBuild(input) {
+	return Effect.gen(function* () {
+		const { generation, client, previous } = input;
+		const { application } = generation;
+		const inputsChanged = previous === void 0 || previous.work.inspectSources || previous.work.capturePublicAssets;
+		return {
+			generation,
+			...yield* Effect.all({
+				server: previous === void 0 || previous.work.compileServer ? compileServerApplication({
+					generation: application,
+					sourcemap: "inline"
+				}) : Effect.succeed(previous.build.server),
+				stylesheet: Effect.gen(function* () {
+					if (previous !== void 0 && inputsChanged) client.updateInputsFn(toDevelopmentClientInputs(application, generation.sources));
+					if (previous !== void 0 && !previous.work.prepareCriticalCss) return previous.build.stylesheet;
+					const filePath = application.config.criticalCssEntryFilePath;
+					return filePath === void 0 ? {
+						css: "",
+						inputFilePaths: []
+					} : yield* readDevelopmentStylesheet({
+						server: client.server,
+						filePath
+					});
+				})
+			}, { concurrency: 2 })
+		};
+	});
+}
+/** Browser-only development controls use Vite's authenticated HMR connection. */
+function renderDevelopmentBrowserSource() {
+	return String.raw`
+let rebuilding;
+let buildState = "ready";
+let revalidations = 0;
+function showRebuilding(failed) {
+  if (!rebuilding) {
+    rebuilding = document.createElement("div");
+    rebuilding.id = "vorma-rebuilding-overlay";
+    rebuilding.style.cssText = "position:fixed;bottom:16px;right:16px;z-index:2147483647;color:white;padding:10px 16px;border-radius:4px;font:14px system-ui";
+    document.body.append(rebuilding);
+  }
+  rebuilding.textContent = failed ? "Build error. See the console for details." : "Rebuilding…";
+  rebuilding.setAttribute("role", failed ? "alert" : "status");
+  rebuilding.style.backgroundColor = failed ? "#700" : "#222";
+}
+function hideRebuilding() {
+  rebuilding?.remove();
+  rebuilding = undefined;
+}
+function updateRebuilding() {
+  if (buildState === "error") showRebuilding(true);
+  else if (buildState === "rebuilding" || revalidations > 0) showRebuilding(false);
+  else hideRebuilding();
+}
+if (import.meta.hot) {
+  import.meta.hot.on("vorma:development", (message) => {
+    if (message.kind === "rebuilding") {
+      buildState = "rebuilding";
+      updateRebuilding();
+    } else if (message.kind === "error") {
+      console.error("[vorma] Build error", message.message);
+      buildState = "error";
+      updateRebuilding();
+    } else if (message.kind === "ready") {
+      buildState = "ready";
+      updateRebuilding();
+    } else if (message.kind === "css") {
+      let style = document.getElementById("vorma-critical-css");
+      if (!style) {
+        style = document.createElement("style");
+        style.id = "vorma-critical-css";
+        document.head.append(style);
+      }
+      style.textContent = message.css;
+    } else if (message.kind === "revalidate") {
+      buildState = "ready";
+      revalidations++;
+      updateRebuilding();
+      // Vite awaits event handlers; a data request must not block later CSS or build messages.
+      Promise.resolve().then(() => window.__vorma_development?.revalidateFn()).then(
+        () => {},
+        (cause) => console.error("[vorma] Data revalidation failed", cause),
+      ).then(() => {
+        revalidations--;
+        updateRebuilding();
+      });
+    }
+  });
+  import.meta.hot.dispose(hideRebuilding);
+}
+`;
+}
+//#endregion
+//#region src/build/development-listener.ts
+/** Hosts only Vite middleware and its WebSocket; the application has its own server. */
+function createDevelopmentListener(port) {
+	return Effect.gen(function* () {
+		function refuseRequestFn(...[, response]) {
+			response.writeHead(503).end();
+		}
+		let handleRequestFn = refuseRequestFn;
+		const server = yield* Effect.acquireRelease(Effect.sync(() => {
+			return createServer$1((request, response) => handleRequestFn(request, response));
+		}), (server) => {
+			return Effect.callback((resume) => {
+				server.close(() => resume(Effect.void));
+				server.closeAllConnections();
+			});
+		});
+		return {
+			server,
+			listen: Effect.callback((resume) => {
+				function failFn(cause) {
+					resume(Effect.fail({
+						_tag: "DevelopmentListenerIssue",
+						cause
+					}));
+				}
+				server.once("error", failFn);
+				server.listen(port, "127.0.0.1", () => {
+					server.off("error", failFn);
+					resume(Effect.void);
+				});
+			}),
+			port,
+			origin: `http://127.0.0.1:${port}`,
+			setHandlerFn(next) {
+				handleRequestFn = next;
+			}
+		};
+	});
+}
+//#endregion
+//#region src/build/development-client.ts
+/** Starts Vite for one inspected application; the surrounding Effect scope closes it. */
+function startDevelopmentClient(inputs, port, recordChangeFn) {
+	return Effect.gen(function* () {
+		const listener = yield* createDevelopmentListener(port);
+		let activeServer;
+		let nativeRestart;
+		let configurationRevision = 0;
+		let coordinatedRestart = false;
+		let views = inputs.views;
+		const virtualSources = new Map(views.flatMap((view) => {
+			return view.source === void 0 ? [] : [[view.id, view.source]];
+		}));
+		let declared = false;
+		let inspection;
+		let finishInspectionFn;
+		function pauseInspectionFn(filePath) {
+			if (activeServer?.config.configFileDependencies.includes(normalizePath(filePath))) return;
+			if (inputs.clientSourceTexts[normalizePath(filePath)] !== void 0 && inspection === void 0) inspection = new Promise((resolve) => {
+				finishInspectionFn = resolve;
+			});
+		}
+		function resumeInspectionFn(reload) {
+			finishInspectionFn?.(reload);
+			inspection = void 0;
+			finishInspectionFn = void 0;
+		}
+		const integration = {
+			name: VORMA_BUILD_PLUGIN_NAME,
+			enforce: "pre",
+			api: { registerDeclarationFn: () => {
+				declared = true;
+			} },
+			config() {
+				declared = false;
+				return {
+					base: "/",
+					publicDir: false,
+					appType: "custom",
+					resolve: { dedupe: CLIENT_SHARED_PACKAGES },
+					oxc: {
+						jsxRefreshInclude: /\.[cm]?[jt]sx?(?:$|\?)/,
+						jsxRefreshExclude: [/\/node_modules\//, ...inputs.clientViewModules.map((file) => {
+							return new RegExp(`^${normalizePath(file).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:\\?.*)?$`);
+						})]
+					},
+					optimizeDeps: { entries: [inputs.clientEntryFilePath, ...inputs.clientViewModules] },
+					server: {
+						middlewareMode: true,
+						origin: listener.origin,
+						hmr: {
+							server: listener.server,
+							clientPort: listener.port
+						},
+						headers: { "cache-control": "no-store" },
+						watch: { ignored: (filePath) => {
+							const file = normalizePath(filePath);
+							return inputs.coordinatedResolutionFiles.has(file) || inputs.generatedDirectories.some((directory) => {
+								return file === normalizePath(directory) || file.startsWith(`${normalizePath(directory)}/`);
+							});
+						} }
+					}
+				};
+			},
+			configureServer(server) {
+				server.watcher.on("change", pauseInspectionFn);
+				server.watcher.on("unlink", pauseInspectionFn);
+				if (activeServer !== void 0 && !coordinatedRestart) {
+					nativeRestart = activeServer.restart();
+					nativeRestart.then(() => {
+						configurationRevision++;
+						recordChangeFn(inputs.viteConfigFilePath);
+					}, (cause) => {
+						server.config.logger.error(String(cause));
+					});
+				}
+			},
+			configResolved: {
+				order: "post",
+				handler() {
+					if (!declared) this.error("Vorma development requires vorma() from vorma/vite in the configured Vite plugins list.");
+				}
+			},
+			resolveId(source) {
+				if (source === "\0vorma:development-browser") return source;
+				if (virtualSources.has(source)) return source;
+				return source === FRAMEWORK_IDENTITY_PROTOCOL.moduleSpecifiers.clientTransportTypes ? inputs.clientTransport.filePath : null;
+			},
+			async load(id) {
+				if (id === "\0vorma:development-browser") return renderDevelopmentBrowserSource();
+				if (inputs.clientSourceTexts[id.split("?", 1)[0] ?? id] !== void 0) await inspection;
+				return virtualSources.get(id) ?? null;
+			},
+			async hotUpdate() {
+				if (await inspection) return [];
+			},
+			transform(code, id) {
+				if (!views.some((view) => view.id === id)) return null;
+				const source = new RolldownMagicString(code);
+				source.append("\nif (import.meta.hot) { import.meta.hot.accept((module) => { if (module) window.__vorma_development?.updateModuleFn(import.meta.url, module); }); }");
+				return {
+					code: source.toString(),
+					map: source.generateMap({ hires: true }).toString()
+				};
+			}
+		};
+		const publicCss = createCssPublicAssets(inputs);
+		function getPublicUrlInput(application) {
+			return {
+				sites: application.publicUrlSites,
+				sourceTexts: new Map(Object.entries(application.clientSourceTexts)),
+				publicAssets: application.publicAssets,
+				publicDirectory: application.publicDirectory,
+				referencedAssets: /* @__PURE__ */ new Map()
+			};
+		}
+		const publicUrls = createClientPublicUrlPlugin(getPublicUrlInput(inputs));
+		const server = yield* Effect.acquireRelease(Effect.tryPromise({
+			try: () => {
+				return createServer({
+					configFile: inputs.viteConfigFilePath,
+					plugins: [
+						integration,
+						publicCss.plugin,
+						publicUrls
+					]
+				});
+			},
+			catch: (cause) => {
+				return {
+					_tag: "DevelopmentClientIssue",
+					operation: "create",
+					cause
+				};
+			}
+		}), (server) => {
+			return Effect.tryPromise({
+				try: async () => {
+					await nativeRestart;
+					return Promise.all(Object.values(server.environments).map((environment) => {
+						return environment.waitForRequestsIdle();
+					}));
+				},
+				catch: (cause) => {
+					return {
+						_tag: "DevelopmentClientIssue",
+						operation: "close",
+						cause
+					};
+				}
+			}).pipe(Effect.ensuring(Effect.tryPromise(() => server.close()).pipe(Effect.catch((issue) => {
+				return Effect.logError("Could not close Vite", issue);
+			}))), Effect.catch((issue) => {
+				return Effect.logError("Could not close Vite development resources", issue);
+			}));
+		});
+		activeServer = server;
+		yield* Effect.addFinalizer(() => Effect.sync(() => resumeInspectionFn(true)));
+		listener.setHandlerFn((request, response) => {
+			server.middlewares(request, response, () => response.writeHead(404).end());
+		});
+		return {
+			server,
+			get configurationRevision() {
+				return configurationRevision;
+			},
+			restart: Effect.suspend(() => {
+				coordinatedRestart = true;
+				return Effect.tryPromise(() => server.restart()).pipe(Effect.ensuring(Effect.sync(() => {
+					coordinatedRestart = false;
+				})));
+			}).pipe(Effect.uninterruptible),
+			origin: listener.origin,
+			listen: listener.listen,
+			get views() {
+				return views;
+			},
+			resumeInspectionFn,
+			readHeadHtml: Effect.tryPromise({
+				try: async () => {
+					const html = await server.transformIndexHtml("/", "<head></head>");
+					return html.slice(html.indexOf("<head>") + 6, html.lastIndexOf("</head>")).replaceAll("\"/@vite/client\"", JSON.stringify(`${listener.origin}/@vite/client`)).replaceAll("\"/@react-refresh\"", JSON.stringify(`${listener.origin}/@react-refresh`)) + `<script type="module" src="${listener.origin}/@id/__x00__vorma:development-browser"><\/script>`;
+				},
+				catch: (cause) => {
+					return {
+						_tag: "DevelopmentClientIssue",
+						operation: "create",
+						cause
+					};
+				}
+			}),
+			/** Replaces inspected sources and asset references within the existing Vite configuration. */
+			updateInputsFn(next) {
+				const replacedFiles = /* @__PURE__ */ new Set([...Object.keys(inputs.clientSourceTexts), ...Object.keys(next.clientSourceTexts)]);
+				if (inputs.clientTransport.source !== next.clientTransport.source) replacedFiles.add(next.clientTransport.filePath);
+				const publicAssetsChanged = JSON.stringify(inputs.publicFilemap) !== JSON.stringify(next.publicFilemap);
+				inputs = next;
+				views = next.views;
+				const previousVirtualIds = new Set(virtualSources.keys());
+				virtualSources.clear();
+				for (const view of views) if (view.source !== void 0) virtualSources.set(view.id, view.source);
+				publicUrls.api.updateInputFn(getPublicUrlInput(next));
+				publicCss.updatePublicAssetsFn(next);
+				for (const environment of Object.values(server.environments)) {
+					const graph = environment.moduleGraph;
+					for (const filePath of replacedFiles) for (const module of graph.getModulesByFile(filePath) ?? []) graph.invalidateModule(module);
+					for (const id of previousVirtualIds) {
+						const module = graph.getModuleById(id);
+						if (module !== void 0) graph.invalidateModule(module);
+					}
+					if (publicAssetsChanged) {
+						for (const module of graph.idToModuleMap.values()) if (module.type === "css") graph.invalidateModule(module);
+					}
+				}
+			}
+		};
+	});
+}
+//#endregion
+//#region src/build/development-sources.ts
+/** Inspects declarations and records native compiler inputs without replacing filesystem behavior. */
+function inspectDevelopmentSources(layout) {
+	return Effect.suspend(() => {
+		const files = /* @__PURE__ */ new Set();
+		const directories = /* @__PURE__ */ new Set();
+		return withTypescriptProjects({
+			configDirectory: layout.configDirectory,
+			serverTsconfigFilePath: layout.serverTsconfigFilePath,
+			clientTsconfigFilePath: layout.clientTsconfigFilePath,
+			fileSystem: {
+				readFile(filePath) {
+					files.add(normalizePath(filePath));
+				},
+				getAccessibleEntries(directory) {
+					directories.add(normalizePath(directory));
+				}
+			},
+			useFn(projects) {
+				return Effect.gen(function* () {
+					const inspection = yield* inspectProjects({
+						projects,
+						layout
+					});
+					const sources = yield* Effect.try({
+						try: () => {
+							return {
+								serverRootFiles: new Set(projects.server.rootFiles.map(normalizePath)),
+								clientRootFiles: new Set(projects.client.rootFiles.map(normalizePath)),
+								serverFiles: new Set(projects.server.program.getSourceFileNames().map(normalizePath)),
+								clientFiles: new Set(projects.client.program.getSourceFileNames().map(normalizePath))
+							};
+						},
+						catch: (cause) => {
+							return {
+								_tag: "TypescriptProjectError",
+								message: "Could not read TypeScript development inputs",
+								cause
+							};
+						}
+					});
+					return {
+						inspection,
+						inputs: {
+							...sources,
+							resolutionFiles: new Set([...files].filter((file) => {
+								return !sources.serverFiles.has(file) && !sources.clientFiles.has(file);
+							})),
+							directories
+						}
+					};
+				});
+			}
+		});
+	});
+}
+/** Watches native compiler inputs while keeping generated writes out of the event stream. */
+function getDevelopmentSourceWatchPaths(input) {
+	return Effect.gen(function* () {
+		const path = yield* Path.Path;
+		const generatedDirectories = getGeneratedSourceDirectories(input.layout);
+		return [.../* @__PURE__ */ new Set([
+			...input.sources.serverFiles,
+			...input.sources.clientFiles,
+			...input.sources.serverRootFiles,
+			...input.sources.clientRootFiles,
+			...input.sources.resolutionFiles,
+			...input.sources.directories
+		])].filter((filePath) => {
+			return !generatedDirectories.some((directory) => {
+				const relativePath = path.relative(directory, filePath);
+				return containsRelativePath({
+					relativePath,
+					separator: path.sep,
+					absolute: path.isAbsolute(relativePath)
+				});
+			});
+		});
+	});
+}
+//#endregion
+//#region src/build/development-generation.ts
+/** Captures independent source and public inputs concurrently, without activating a runtime. */
+function prepareDevelopmentGeneration(input) {
+	return Effect.gen(function* () {
+		const previous = input.previous;
+		const prepared = yield* Effect.all({
+			sources: previous === void 0 || previous.work.inspectSources ? inspectDevelopmentSources(input.layout) : Effect.succeed({
+				inspection: previous.generation.application.inspection,
+				inputs: previous.generation.sources
+			}),
+			publicAssets: previous === void 0 || previous.work.capturePublicAssets ? collectPublicAssets(input.layout) : Effect.succeed(previous.generation.application.publicAssets)
+		}, { concurrency: "unbounded" });
+		const application = yield* assembleApplicationGeneration({
+			sourceLayout: input.layout,
+			inspection: prepared.sources.inspection,
+			publicAssets: prepared.publicAssets
+		});
+		if (previous === void 0 || previous.work.inspectSources || previous.work.capturePublicAssets) yield* writeAndCheckApplicationGeneration(application);
+		return {
+			application,
+			sources: prepared.sources.inputs
+		};
+	});
+}
+//#endregion
+//#region src/build/development-patterns.ts
+/** Ordered inclusion and exclusion rules use native Vite glob matching. */
+function compileDevelopmentPatterns(patterns) {
+	const rules = patterns.flatMap((raw) => {
+		const trimmed = raw.trim();
+		const excluded = trimmed.startsWith("!");
+		const source = excluded ? trimmed.slice(1).trim() : trimmed;
+		const anchored = source.startsWith("/") || source.startsWith("./");
+		let pattern = normalizePath(source);
+		if (pattern === "") return [];
+		const directory = pattern.endsWith("/");
+		pattern = pattern.replace(/\/$/, "");
+		pattern = pattern.replace(/^\.\//, "").replace(/^\//, "");
+		if (!anchored && !pattern.includes("/") && pattern !== ".") pattern = `**/${pattern}`;
+		const matchFn = createFilter(pattern, void 0, { resolve: false });
+		const prefix = pattern.split("/").filter((_segment, index, segments) => {
+			return segments.slice(0, index + 1).every((segment) => !/[*?{[]/.test(segment));
+		});
+		return [{
+			pattern,
+			directory,
+			excluded,
+			matchFn,
+			root: prefix.slice(0, -1).join("/") || "."
+		}];
+	});
+	return {
+		roots: rules.filter((rule) => !rule.excluded).map((rule) => rule.root),
+		matchesFn(relativePath) {
+			const segments = posix.normalize(normalizePath(relativePath)).split("/");
+			let matched = false;
+			for (const rule of rules) if (rule.pattern === "." || segments.some((_segment, index) => {
+				return (!rule.directory || index < segments.length - 1) && rule.matchFn(segments.slice(0, index + 1).join("/"));
+			})) matched = !rule.excluded;
+			return matched;
+		}
+	};
+}
+//#endregion
+//#region src/build/development-server-process.ts
+/** Reserves a port until the enclosing allocation scope closes. */
+function getDevelopmentServerPort() {
+	return NodeSocketServer.make({
+		host: "127.0.0.1",
+		port: 0
+	}).pipe(Effect.map(({ address }) => {
+		if (address._tag === "UnixPathAddress") throw new Error("A TCP port probe returned a Unix socket address");
+		return address.port;
+	}));
+}
+/** Runs the authored server entry; its Effect scope owns process termination. */
+function startDevelopmentServerProcess(input) {
+	return Effect.gen(function* () {
+		const process = yield* ChildProcess.make(globalThis.process.execPath, ["--enable-source-maps", input.layout.compiledServerEntryFilePath], {
+			env: { [DEVELOPMENT_PROTOCOL.serverPortEnvironmentVariable]: String(input.port) },
+			extendEnv: true,
+			stdin: "ignore",
+			stdout: "inherit",
+			stderr: "inherit",
+			forceKillAfter: "2 seconds"
+		});
+		const unexpectedExit = process.exitCode.pipe(Effect.flatMap((exitCode) => {
+			return Effect.fail({
+				_tag: "DevelopmentServerExit",
+				exitCode
+			});
+		}));
+		const origin = `http://127.0.0.1:${input.port}`;
+		const url = `${origin}${DEVELOPMENT_PROTOCOL.readinessPath}`;
+		yield* Effect.gen(function* () {
+			yield* (yield* HttpClient.HttpClient).pipe(HttpClient.filterStatus((status) => status === 200)).get(url).pipe(Effect.flatMap((response) => response.text), Effect.timeout("1 second"), Effect.retry(Schedule.forever.pipe(Schedule.modifyDelay(({ output }) => {
+				return Effect.succeed(Math.min((output + 1) * 20, 200));
+			}))));
+		}).pipe(Effect.provide(FetchHttpClient.layer), Effect.timeoutOrElse({
+			duration: "10 seconds",
+			orElse: () => {
+				return Effect.fail({
+					_tag: "DevelopmentServerReadinessIssue",
+					url
+				});
+			}
+		}), Effect.raceFirst(unexpectedExit));
+		return {
+			process,
+			origin,
+			unexpectedExit
+		};
+	});
+}
+//#endregion
+//#region src/build/development-changes.ts
+/**
+* Batches native watcher events after 30 ms without another event. Completed
+* batches accumulate while the consumer rebuilds; no changed path is discarded.
+*/
+function createDevelopmentChanges() {
+	return Effect.gen(function* () {
+		const notifications = yield* Queue.make();
+		const ready = yield* Queue.make({
+			capacity: 1,
+			strategy: "sliding"
+		});
+		let incoming = /* @__PURE__ */ new Set();
+		let pending = /* @__PURE__ */ new Set();
+		function recordChangeFn(filePath) {
+			Queue.offerUnsafe(notifications, normalizePath(filePath));
+		}
+		function recordErrorFn(cause) {
+			Queue.failCauseUnsafe(notifications, Cause.fail({
+				_tag: "DevelopmentWatchIssue",
+				cause
+			}));
+		}
+		yield* Stream.fromQueue(notifications).pipe(Stream.tap((filePath) => Effect.sync(() => incoming.add(filePath))), Stream.debounce("30 millis"), Stream.runForEach(() => {
+			return Effect.sync(() => {
+				for (const filePath of incoming) pending.add(filePath);
+				incoming = /* @__PURE__ */ new Set();
+				Queue.offerUnsafe(ready, void 0);
+			});
+		}), Effect.catch((issue) => Queue.fail(ready, issue)), Effect.forkScoped);
+		return {
+			take: Effect.gen(function* () {
+				while (true) {
+					yield* Queue.take(ready);
+					if (pending.size > 0) {
+						const batch = pending;
+						pending = /* @__PURE__ */ new Set();
+						return batch;
+					}
+				}
+			}),
+			recordChangeFn,
+			recordErrorFn
+		};
+	});
+}
+//#endregion
+//#region src/build/development-watcher.ts
+function containsPath(input) {
+	const relativePath = relative(input.directory, input.filePath);
+	return containsRelativePath({
+		relativePath,
+		separator: sep,
+		absolute: isAbsolute(relativePath)
+	});
+}
+/** Application watching survives Vite restarts and failed replacement builds. */
+function createDevelopmentWatcher(input) {
+	return Effect.gen(function* () {
+		const changes = yield* createDevelopmentChanges();
+		function matchesIgnoredPath(filePath) {
+			return /(?:^|[/\\])(?:node_modules|\.git)(?:[/\\]|$)/.test(filePath);
+		}
+		function acquireWatcher(plan) {
+			return Effect.gen(function* () {
+				const watcher = yield* Effect.acquireRelease(Effect.sync(() => {
+					return watch([...plan.paths], {
+						ignoreInitial: true,
+						ignored: (filePath) => {
+							return matchesIgnoredPath(filePath) || plan.generatedDirectories.some((directory) => {
+								return containsPath({
+									directory,
+									filePath
+								});
+							});
+						}
+					});
+				}), (watcher) => Effect.promise(() => watcher.close()));
+				watcher.on("all", (_event, filePath) => changes.recordChangeFn(filePath));
+				watcher.on("error", changes.recordErrorFn);
+				yield* Effect.callback((resume) => {
+					function onReady() {
+						resume(Effect.void);
+					}
+					function onError(cause) {
+						resume(Effect.fail({
+							_tag: "DevelopmentWatchIssue",
+							cause
+						}));
+					}
+					watcher.once("ready", onReady);
+					watcher.once("error", onError);
+					return Effect.sync(() => {
+						watcher.off("ready", onReady);
+						watcher.off("error", onError);
+					});
+				});
+				return plan;
+			});
+		}
+		const reference = yield* ScopedRef.fromAcquire(acquireWatcher({
+			paths: [dirname(input.configFilePath)],
+			generatedDirectories: input.generatedDirectories
+		}));
+		return {
+			...changes,
+			watchPathsFn(next) {
+				return Effect.gen(function* () {
+					const paths = [...new Set([dirname(input.configFilePath), ...next.paths].filter((filePath) => !matchesIgnoredPath(filePath)).map(normalizePath))].sort();
+					const plan = {
+						paths: paths.filter((filePath) => {
+							return !paths.some((directory) => {
+								return directory !== filePath && containsPath({
+									directory,
+									filePath
+								});
+							});
+						}),
+						generatedDirectories: [...next.generatedDirectories].sort()
+					};
+					if (JSON.stringify(yield* ScopedRef.get(reference)) !== JSON.stringify(plan)) yield* ScopedRef.set(reference, acquireWatcher(plan));
+				});
+			}
+		};
+	});
+}
+//#endregion
+//#region src/build/development-work.ts
+/** Classifies application work; ordinary browser modules remain Vite's HMR inputs. */
+function classifyDevelopmentChanges(input) {
+	return Effect.gen(function* () {
+		const path = yield* Path.Path;
+		const { layout, inputs } = input;
+		const generated = getGeneratedSourceDirectories(layout);
+		function matchesGeneratedPath(filePath) {
+			return generated.some((directory) => {
+				return containsFilePath({
+					path,
+					directory,
+					filePath
+				});
+			});
+		}
+		const changedPaths = [...input.changedPaths].map(normalizePath).filter((filePath) => !matchesGeneratedPath(filePath));
+		const revalidate = compileDevelopmentPatterns(layout.dev?.revalidateClientOnChange ?? []);
+		let restartConfiguration = false;
+		let inspectSources = false;
+		let compileServer = false;
+		let capturePublicAssets = false;
+		let prepareCriticalCss = false;
+		let revalidateClient = false;
+		let checkProjectMembership = false;
+		for (const filePath of changedPaths) {
+			restartConfiguration ||= inputs.configurationFiles.has(filePath) || filePath === normalizePath(layout.configFilePath);
+			if (!inputs.configurationFiles.has(filePath) && inputs.viteConfigurationFiles.has(filePath)) continue;
+			const serverSource = inputs.sources.serverFiles.has(filePath) || inputs.sources.serverRootFiles.has(filePath);
+			const clientSource = inputs.sources.clientFiles.has(filePath) || inputs.sources.clientRootFiles.has(filePath);
+			const resolutionSource = inputs.sources.resolutionFiles.has(filePath);
+			inspectSources ||= serverSource || clientSource || resolutionSource;
+			compileServer ||= serverSource || resolutionSource || inputs.serverFiles.has(filePath);
+			capturePublicAssets ||= containsFilePath({
+				path,
+				directory: layout.publicAssetsSourceDirectory,
+				filePath
+			});
+			prepareCriticalCss ||= inputs.criticalCssFiles.has(filePath) || filePath === layout.criticalCssEntryFilePath;
+			revalidateClient ||= (layout.dev?.revalidateClientOnChange?.length ?? 0) > 0 && revalidate.matchesFn(path.relative(layout.configDirectory, filePath));
+			checkProjectMembership ||= !serverSource && !clientSource && !resolutionSource;
+		}
+		if (checkProjectMembership && !restartConfiguration) {
+			const roots = yield* readTypescriptProjectRoots(layout);
+			function differsFromPreviousFiles(previous, files) {
+				const next = new Set(files.map(normalizePath).filter((file) => !matchesGeneratedPath(file)));
+				const old = [...previous].filter((file) => !matchesGeneratedPath(file));
+				return old.length !== next.size || old.some((file) => !next.has(file));
+			}
+			const serverMembershipChanged = differsFromPreviousFiles(inputs.sources.serverRootFiles, roots.server);
+			const clientMembershipChanged = differsFromPreviousFiles(inputs.sources.clientRootFiles, roots.client);
+			inspectSources ||= serverMembershipChanged || clientMembershipChanged;
+			compileServer ||= serverMembershipChanged;
+		}
+		return {
+			restartConfiguration,
+			inspectSources,
+			compileServer,
+			capturePublicAssets,
+			prepareCriticalCss: layout.criticalCssEntryFilePath !== void 0 && (prepareCriticalCss || capturePublicAssets),
+			revalidateClient
+		};
+	});
+}
+function containsFilePath(input) {
+	const relativePath = input.path.relative(input.directory, input.filePath);
+	return containsRelativePath({
+		relativePath,
+		separator: input.path.sep,
+		absolute: input.path.isAbsolute(relativePath)
+	});
+}
+//#endregion
+//#region src/build/load-config.ts
+/** Vite's configuration loader recompiles configuration dependencies on each development restart. */
+function loadDevelopmentConfig(configPath) {
+	return Effect.gen(function* () {
+		const configFilePath = (yield* Path.Path).resolve(configPath);
+		const loaded = yield* Effect.tryPromise({
+			try: () => {
+				return loadConfigFromFile({
+					command: "serve",
+					mode: "development"
+				}, configFilePath);
+			},
+			catch: (cause) => {
+				return {
+					_tag: "ConfigLoadError",
+					message: `Could not load Vorma config: ${configFilePath}`,
+					cause
+				};
+			}
+		});
+		return {
+			config: yield* Schema.decodeUnknownEffect(VormaConfigSchema)(loaded?.config),
+			configFilePath,
+			dependencies: loaded?.dependencies ?? []
+		};
+	});
+}
+/**
+* Imports the explicitly selected configuration using the CLI host's module
+* loader and reports the absolute path of the file it was loaded from,
+* because every configured path is relative to that file's directory.
+*/
+function loadVormaConfig(configPath) {
+	return Effect.gen(function* () {
+		const path = yield* Path.Path;
+		const absolutePath = path.resolve(configPath);
+		const url = yield* path.toFileUrl(absolutePath);
+		const module = yield* Effect.tryPromise({
+			try: () => import(url.href),
+			catch: (cause) => {
+				return {
+					_tag: "ConfigLoadError",
+					message: `Could not import Vorma config: ${absolutePath}`,
+					cause
+				};
+			}
+		});
+		return {
+			config: yield* Schema.decodeUnknownEffect(VormaConfigSchema)(module.default).pipe(Effect.mapError((cause) => {
+				return {
+					_tag: "ConfigLoadError",
+					message: `Expected a default-exported Vorma config in ${absolutePath}: ${cause.message}`,
+					cause
+				};
+			})),
+			configFilePath: absolutePath
+		};
+	});
+}
+//#endregion
+//#region src/build/development.ts
+/** Runs until interrupted; configuration replacement releases the complete previous session. */
+function developApplication(configFilePath) {
+	return Effect.gen(function* () {
+		const { port, vitePort } = yield* Effect.scoped(Effect.all({
+			port: getDevelopmentServerPort(),
+			vitePort: getDevelopmentServerPort()
+		}));
+		let loaded = yield* loadDevelopmentConfig(configFilePath);
+		const resolved = yield* resolveVormaConfig(loaded);
+		const watcher = yield* createDevelopmentWatcher({
+			configFilePath: loaded.configFilePath,
+			generatedDirectories: getGeneratedSourceDirectories(resolved)
+		});
+		let initialized = false;
+		while (true) {
+			let ready = false;
+			const next = yield* Effect.scoped(runDevelopmentSession({
+				loaded,
+				port,
+				vitePort,
+				watcher,
+				onReadyFn: () => {
+					ready = true;
+					initialized = true;
+				}
+			})).pipe(Effect.result);
+			if (Result.isSuccess(next)) {
+				loaded = next.success;
+				continue;
+			}
+			if (!initialized || ready) return yield* Effect.fail(next.failure);
+			yield* Effect.logError(next.failure);
+			while (true) {
+				yield* watcher.take;
+				const corrected = yield* loadDevelopmentConfig(configFilePath).pipe(Effect.result);
+				if (Result.isSuccess(corrected)) {
+					loaded = corrected.success;
+					break;
+				}
+				yield* Effect.logError(corrected.failure);
+			}
+		}
+	}).pipe(Effect.scoped);
+}
+function runDevelopmentSession(input) {
+	return Effect.gen(function* () {
+		const scope = yield* Effect.scope;
+		const path = yield* Path.Path;
+		const fileSystem = yield* FileSystem.FileSystem;
+		const resolved = yield* resolveVormaConfig(input.loaded);
+		yield* input.watcher.watchPathsFn({
+			paths: [
+				...input.loaded.dependencies,
+				path.dirname(resolved.serverEntryFilePath),
+				path.dirname(resolved.clientEntryFilePath),
+				path.dirname(resolved.serverTsconfigFilePath),
+				path.dirname(resolved.clientTsconfigFilePath),
+				resolved.publicAssetsSourceDirectory,
+				...resolved.criticalCssEntryFilePath === void 0 ? [] : [path.dirname(resolved.criticalCssEntryFilePath)]
+			],
+			generatedDirectories: getGeneratedSourceDirectories(resolved)
+		});
+		const layout = yield* loadApplicationSourceLayout(resolved);
+		yield* acquireOutputOwnership({
+			lockDirectory: layout.clientGeneratedDirectory,
+			boundaryDirectories: [layout.serverGeneratedDirectory],
+			kind: "dev"
+		});
+		let retiredDirectories = [];
+		yield* Effect.addFinalizer(() => {
+			return Effect.forEach(retiredDirectories, (directory) => {
+				return Effect.gen(function* () {
+					const names = yield* fileSystem.readDirectory(directory);
+					yield* Effect.forEach(names.filter((name) => {
+						return name !== "build.lock" && name !== ".gitignore";
+					}), (name) => {
+						const filePath = path.join(directory, name);
+						return checkOutputPath({
+							filePath,
+							rootDirectory: directory
+						}).pipe(Effect.andThen(fileSystem.remove(filePath, { recursive: true })));
+					}, {
+						concurrency: 16,
+						discard: true
+					});
+				});
+			}, { discard: true }).pipe(Effect.orDie);
+		});
+		yield* preparePublicOutput(layout);
+		const generation = yield* prepareDevelopmentGeneration({ layout });
+		const client = yield* startDevelopmentClient(toDevelopmentClientInputs(generation.application, generation.sources), input.vitePort, input.watcher.recordChangeFn);
+		let build = yield* prepareDevelopmentBuild({
+			generation,
+			client
+		});
+		let head = yield* client.readHeadHtml;
+		let clientConfigurationRevision = client.configurationRevision;
+		let artifacts = assembleDevelopmentArtifacts({
+			build,
+			client,
+			developmentHeadHtml: head
+		});
+		let inputs;
+		const pendingPaths = /* @__PURE__ */ new Set();
+		let revision = 0;
+		const restart = yield* Deferred.make();
+		const fatal = yield* Deferred.make();
+		let application;
+		const stopApplication = Effect.suspend(() => {
+			const previous = application;
+			application = void 0;
+			if (previous === void 0) return Effect.void;
+			previous.stopping = true;
+			return Fiber.interrupt(previous.fiber);
+		});
+		yield* Effect.addFinalizer(() => stopApplication);
+		const startApplication = Effect.gen(function* () {
+			const ready = yield* Deferred.make();
+			let announced = false;
+			const running = {
+				stopping: false,
+				fiber: void 0
+			};
+			const fiber = yield* Effect.scoped(Effect.gen(function* () {
+				const server = yield* startDevelopmentServerProcess({
+					layout,
+					port: input.port
+				});
+				announced = true;
+				yield* Deferred.succeed(ready, void 0);
+				return yield* server.unexpectedExit;
+			})).pipe(Effect.tapCause((cause) => {
+				return Deferred.failCause(ready, cause).pipe(Effect.andThen(() => {
+					return announced && !running.stopping ? Deferred.failCause(fatal, cause) : Effect.void;
+				}));
+			}), Effect.forkIn(scope));
+			running.fiber = fiber;
+			application = {
+				fiber,
+				get stopping() {
+					return running.stopping;
+				},
+				set stopping(value) {
+					running.stopping = value;
+				}
+			};
+			yield* Deferred.await(ready).pipe(Effect.onExit((exit) => Exit.isFailure(exit) ? stopApplication : Effect.void));
+		});
+		function notifyFn(message) {
+			client.server.ws.send({
+				type: "custom",
+				event: "vorma:development",
+				data: message
+			});
+		}
+		function watchInputs(next) {
+			return Effect.gen(function* () {
+				inputs = {
+					sources: next.generation.sources,
+					serverFiles: new Set(next.server.inputFilePaths.map(normalizePath)),
+					criticalCssFiles: new Set(next.stylesheet.inputFilePaths.map(normalizePath)),
+					configurationFiles: new Set(input.loaded.dependencies.map(normalizePath)),
+					viteConfigurationFiles: new Set(client.server.config.configFileDependencies)
+				};
+				const sourcePaths = yield* getDevelopmentSourceWatchPaths({
+					layout,
+					sources: inputs.sources
+				});
+				const dataRoots = compileDevelopmentPatterns(layout.dev?.revalidateClientOnChange ?? []).roots.map((root) => path.resolve(layout.configDirectory, root));
+				yield* input.watcher.watchPathsFn({
+					paths: [
+						...sourcePaths,
+						...inputs.serverFiles,
+						...inputs.criticalCssFiles,
+						...inputs.configurationFiles,
+						layout.configFilePath,
+						layout.viteConfigFilePath,
+						layout.publicAssetsSourceDirectory,
+						...dataRoots
+					],
+					generatedDirectories: getGeneratedSourceDirectories(layout)
+				});
+			});
+		}
+		yield* publishApplicationArtifacts({
+			generation: generation.application,
+			server: build.server,
+			artifacts
+		});
+		yield* startApplication;
+		yield* client.listen;
+		yield* watchInputs(build);
+		input.onReadyFn();
+		yield* Console.log(`Vorma development: http://127.0.0.1:${input.port}`);
+		const rebuild = Effect.suspend(() => {
+			const preparingRevision = revision;
+			return Effect.gen(function* () {
+				const incoming = yield* classifyDevelopmentChanges({
+					layout,
+					inputs: {
+						...inputs,
+						viteConfigurationFiles: new Set(client.server.config.configFileDependencies)
+					},
+					changedPaths: new Set(pendingPaths)
+				});
+				const work = {
+					...incoming,
+					prepareCriticalCss: incoming.prepareCriticalCss || client.configurationRevision !== clientConfigurationRevision
+				};
+				if (!Object.values(work).some(Boolean)) {
+					if (preparingRevision === revision) pendingPaths.clear();
+					return;
+				}
+				if (work.compileServer || work.restartConfiguration) notifyFn({ kind: "rebuilding" });
+				if (work.restartConfiguration) {
+					const next = yield* loadDevelopmentConfig(layout.configFilePath);
+					const nextLayout = yield* resolveVormaConfig(next).pipe(Effect.flatMap(loadApplicationSourceLayout));
+					const nextDirectories = new Set(getGeneratedSourceDirectories(nextLayout));
+					retiredDirectories = [...new Set(getGeneratedSourceDirectories(layout))].filter((directory) => !nextDirectories.has(directory));
+					yield* Deferred.succeed(restart, next);
+					return;
+				}
+				const [next] = yield* Effect.all([prepareDevelopmentGeneration({
+					layout,
+					previous: {
+						generation: build.generation,
+						work
+					}
+				}).pipe(Effect.flatMap((generation) => {
+					return prepareDevelopmentBuild({
+						generation,
+						client,
+						previous: {
+							build,
+							work
+						}
+					});
+				})), work.compileServer ? stopApplication : Effect.void], { concurrency: 2 });
+				const previousArtifacts = artifacts;
+				head = yield* client.readHeadHtml;
+				const nextArtifacts = assembleDevelopmentArtifacts({
+					build: next,
+					client,
+					developmentHeadHtml: head
+				});
+				const restartVite = work.compileServer || JSON.stringify(previousArtifacts.metadata.clientViews) !== JSON.stringify(nextArtifacts.metadata.clientViews);
+				const reload = restartVite || previousArtifacts.metadata.clientBuildId !== nextArtifacts.metadata.clientBuildId;
+				yield* publishApplicationArtifacts({
+					generation: next.generation.application,
+					artifacts: nextArtifacts,
+					...work.compileServer ? { server: next.server } : {}
+				});
+				if (work.compileServer) yield* startApplication;
+				client.resumeInspectionFn(reload);
+				if (restartVite) {
+					yield* client.restart;
+					head = yield* client.readHeadHtml;
+				}
+				yield* watchInputs(next);
+				if (preparingRevision !== revision) return;
+				build = next;
+				clientConfigurationRevision = client.configurationRevision;
+				artifacts = nextArtifacts;
+				pendingPaths.clear();
+				const retainedFiles = new Set(artifacts.metadata.publicFiles.map((file) => file.fileName));
+				yield* Effect.forEach(yield* fileSystem.readDirectory(layout.publicDirectory), (fileName) => {
+					return retainedFiles.has(fileName) ? Effect.void : fileSystem.remove(path.join(layout.publicDirectory, fileName));
+				}, {
+					concurrency: 16,
+					discard: true
+				});
+				if (!restartVite && reload) client.server.ws.send({ type: "full-reload" });
+				else {
+					if (previousArtifacts.metadata.criticalCss !== artifacts.metadata.criticalCss) notifyFn({
+						kind: "css",
+						css: artifacts.metadata.criticalCss
+					});
+					notifyFn({ kind: work.revalidateClient ? "revalidate" : "ready" });
+				}
+			}).pipe(Effect.catchCause((cause) => {
+				if (Cause.hasInterruptsOnly(cause)) return Effect.failCause(cause);
+				const message = Cause.pretty(cause);
+				notifyFn({
+					kind: "error",
+					message
+				});
+				return Effect.logError(message);
+			}));
+		});
+		const changes = Stream.fromEffectRepeat(input.watcher.take).pipe(Stream.tap((incoming) => {
+			return Effect.sync(() => {
+				for (const filePath of incoming) pendingPaths.add(filePath);
+				revision++;
+			});
+		}), Stream.switchMap(() => Stream.fromEffect(rebuild)), Stream.runDrain);
+		return yield* Deferred.await(restart).pipe(Effect.raceFirst(changes.pipe(Effect.andThen(Effect.never))), Effect.raceFirst(Deferred.await(fatal)));
+	});
+}
+//#endregion
+//#region src/build/cli.ts
+const buildCommand = Command.make("build", { config: Flag.File("config", { mustExist: true }).pipe(Flag.withDescription("Path to the application's default-exported Vorma configuration.")) }, ({ config }) => {
+	return Effect.gen(function* () {
+		const loaded = yield* loadVormaConfig(config);
+		const result = yield* buildApplication(loaded);
+		yield* Console.log(`Published Vorma build ${result.clientBuildId}`);
+	});
+}).pipe(Command.withDescription("Build and publish production application artifacts."));
+const nodeServices = Layer.provideMerge(NodeChildProcessSpawner.layer, Layer.mergeAll(NodeFileSystem.layer, NodeCrypto.layer, NodePath.layer, NodeStdio.layer, NodeTerminal.layer));
+const developmentCommand = Command.make("dev", { config: Flag.File("config", { mustExist: true }).pipe(Flag.withDescription("Path to the application's Vorma configuration.")) }, ({ config }) => developApplication(config)).pipe(Command.withDescription("Run application development with rebuilds and browser hot updates."));
+Command.make("vorma").pipe(Command.withSubcommands([buildCommand, developmentCommand]), Command.run({ version })).pipe(Effect.provide(nodeServices), NodeRuntime.runMain);
+//#endregion