@kosmojs/dev 0.4.4 → 0.5.2

package/pkg/chassis.js

@@ -1,309 +1,714 @@
-import{createRequire as e}from"node:module";import{basename as t,dirname as n,join as r,relative as i,resolve as a,sep as o}from"node:path";import{styleText as s}from"node:util";import{defaults as c}from"@kosmojs/core";import{collectVirtualModules as l,mergeConfigs as u,pathExists as d,pathResolver as f,renderToFile as p,routesFactory as m,spinnerFactory as h,vitePlugins as g}from"@kosmojs/lib";import _ from"crc/crc32";import{build as v,createServer as y,transformWithOxc as b}from"vite";import{mkdir as x,readFile as S,writeFile as C}from"node:fs/promises";import w from"node:http";import T from"node:net";import{readFileSync as E}from"node:fs";import{spawn as D}from"node:child_process";import{watch as O}from"chokidar";var k=JSON.parse(E(e(import.meta.url).resolve(`@kosmojs/dev/package.json`),`utf-8`)),A=(e,t,r)=>{let i=f(t).createPath.libApi(n(e.file),`cache.json`),o=async n=>{if(!n?.hash||!n.typeDeclarations||!n.referencedFiles)return;let i=await j(e.fileFullpath,{...r});if(M(n.hash,i)){for(let[e,r]of Object.entries(n.referencedFiles))if(!M(r,await j(a(t.root,e))))return;return n}};return{async get(e){if(await d(i))try{let t=JSON.parse(await S(i,`utf8`));return e?.validate?o(t):t}catch{}},async set(n){let a=await j(e.fileFullpath,{...r}),o={};for(let e of n.referencedFiles)o[e.replace(`${t.root}/`,``)]=await j(e);let s={...n,hash:a,referencedFiles:o};return await p(i,JSON.stringify(s,void 0,2),{},{render:e=>e}),s}}},j=async(e,t)=>{let n;try{n=await S(e,`utf8`)}catch{return 0}return n?_(JSON.stringify({...t,[k.cacheVersion]:n})):0},M=(e,t)=>e===t,N=`#!/usr/bin/env node
-
+import { createRequire } from "node:module";
+import { styleText } from "node:util";
+import { createAliasPatterns, mergeConfigs, pathExists, pathResolver, renderToFile, routesFactory, spinnerFactory, vitePlugins } from "@kosmojs/lib";
+import { basename, dirname, join, posix, relative, resolve } from "node:path";
+import { defaults } from "@kosmojs/core";
+import crc from "crc/crc32";
+import { build, createServer, transformWithOxc } from "vite";
+import { pathToRegexp } from "path-to-regexp";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import http from "node:http";
+import net from "node:net";
+import { readFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { watch } from "chokidar";
+//#region src/cache.ts
 /**
- * Serves every built source folder from a single process.
- *
- * Written by \`kosmo build\` into the dist directory; \`kosmo preview\` restarts it after each rebuild.
- *
- *   node dist/run.js -p 4556
- *   node dist/run.js -s /tmp/app.sock
- *
- * Folders are discovered at startup from \`dist/<folder>/kosmo.json\`,
- * so a partial build (\`kosmo build admin\`) never leaves a stale folder table behind,
- * and removing a folder's dist directory is enough to stop serving it.
- *
- * Per folder:
- *   - SSR folders mount \`ssr/server.js\` - one listener for pages, assets and the bundled API.
- *   - CSR folders mount \`api/listener.js\` for the API and serve \`client/\` statically from memory,
- *     with the SPA fallback to index.html for unmatched page URLs.
- *
- * Authored as TypeScript, deployed with types stripped;
- * only node builtins are used here: \`node:http\` runs unchanged on Node, Bun and Deno.
- * */
-
-import { chmod, readdir, readFile, unlink } from "node:fs/promises";
-import type { IncomingMessage, Server, ServerResponse } from "node:http";
-import { createServer } from "node:http";
-import { extname, join, posix } from "node:path";
-import { pathToFileURL } from "node:url";
-import { parseArgs } from "node:util";
-
-import { MIME_TYPES } from "@kosmojs/core";
-
-type NodeListener = (req: IncomingMessage, res: ServerResponse) => void;
-
-// the shape \`kosmo build\` writes to dist/<folder>/kosmo.json
-type FolderManifest = {
-  name: string;
-  base: string;
-  apiBase: string;
-  api: boolean;
-  client: boolean;
-  ssr: boolean;
+* Read the installed package.json at runtime to get the actual version.
+* A static `import ... with { type: "json" }` would be inlined by the
+* bundler with the pre-bump version, defeating the point.
+* */
+var self = JSON.parse(readFileSync(createRequire(import.meta.url).resolve("@kosmojs/dev/package.json"), "utf-8"));
+var cacheFactory = (route, sourceFolder, extraContext) => {
+	const cacheFile = pathResolver(sourceFolder).createPath.libApi(dirname(route.file), "cache.json");
+	const validateCache = async (cache) => {
+		if (!cache?.hash) return;
+		if (!cache.typeDeclarations || !cache.referencedFiles) return;
+		const hash = await generateFileHash(route.fileFullpath, { ...extraContext });
+		if (!identicalHashSum(cache.hash, hash)) return;
+		for (const [file, hash] of Object.entries(cache.referencedFiles)) if (!identicalHashSum(hash, await generateFileHash(resolve(sourceFolder.root, file)))) return;
+		return cache;
+	};
+	return {
+		async get(opt) {
+			if (await pathExists(cacheFile)) try {
+				const cache = JSON.parse(await readFile(cacheFile, "utf8"));
+				return opt?.validate ? validateCache(cache) : cache;
+			} catch (_e) {}
+		},
+		async set(cache) {
+			const hash = await generateFileHash(route.fileFullpath, { ...extraContext });
+			const referencedFiles = {};
+			for (const file of cache.referencedFiles) referencedFiles[file.replace(`${sourceFolder.root}/`, "")] = await generateFileHash(file);
+			const value = {
+				...cache,
+				hash,
+				referencedFiles
+			};
+			/**
+			* use renderToFile to skip the write when nothing changed.
+			* Two kosmo processes on one project resolve the same routes to the same bytes,
+			* so this keeps them from rewriting each other's cache files.
+			* */
+			await renderToFile(cacheFile, JSON.stringify(value, void 0, 2), {}, { render: (content) => content });
+			return value;
+		}
+	};
 };
-
-type Folder = FolderManifest & {
-  dir: string;
+var generateFileHash = async (file, extraContext) => {
+	let fileContent;
+	try {
+		fileContent = await readFile(file, "utf8");
+	} catch (_e) {
+		return 0;
+	}
+	return fileContent ? crc(JSON.stringify({
+		...extraContext,
+		[self.cacheVersion]: fileContent
+	})) : 0;
 };
-
-type Handler = {
-  name: string;
-  segments: [base: string, api?: string];
-  listener: NodeListener;
+var identicalHashSum = (a, b) => {
+	return a === b;
 };
-
-type StaticFile = {
-  buffer: Buffer;
-  headers: Record<string, string>;
+//#endregion
+//#region src/templates/run.ts?raw
+var run_default = "#!/usr/bin/env node\n\n/**\n * Serves every built source folder from a single process.\n *\n * Written by `kosmo build` into the dist directory; `kosmo preview` restarts it after each rebuild.\n *\n *   node dist/run.js -p 4556\n *   node dist/run.js -s /tmp/app.sock\n *\n * Folders are discovered at startup from `dist/<folder>/kosmo.json`,\n * so a partial build (`kosmo build admin`) never leaves a stale folder table behind,\n * and removing a folder's dist directory is enough to stop serving it.\n *\n * Per folder:\n *   - SSR folders mount `ssr/server.js` - one listener for pages, assets and the bundled API.\n *   - CSR folders mount `api/listener.js` for the API and serve `client/` statically from memory,\n *     with the SPA fallback to index.html for unmatched page URLs.\n *\n * Authored as TypeScript, deployed with types stripped;\n * */\n\nimport {\n  access,\n  chmod,\n  constants,\n  readdir,\n  readFile,\n  unlink,\n} from \"node:fs/promises\";\nimport type { IncomingMessage, Server, ServerResponse } from \"node:http\";\nimport { createServer } from \"node:http\";\nimport { extname, join, posix, resolve } from \"node:path\";\nimport { parseArgs } from \"node:util\";\n\nimport { pathToRegexp } from \"path-to-regexp\";\n\nimport { MIME_TYPES, type SourceFolderManifest } from \"@kosmojs/core\";\n\ntype NodeListener = (req: IncomingMessage, res: ServerResponse) => void;\n\ntype Folder = SourceFolderManifest & {\n  dir: string;\n};\n\ntype Handler = {\n  name: string;\n  base: string;\n  aliasPatterns: Array<RegExp>;\n  listener: NodeListener;\n};\n\ntype StaticFile = {\n  buffer: Buffer;\n  headers: Record<string, string>;\n};\n\nconst ROOT = import.meta.dirname;\n\nconst contentTypeFor = (file: string): string => {\n  return MIME_TYPES[extname(file).toLowerCase()] || \"application/octet-stream\";\n};\n\nconst handlerWeight = ({ base }: Handler): number => {\n  return base.length + base.split(\"/\").filter(Boolean).length;\n};\n\nconst readFolders = async (): Promise<Array<Folder>> => {\n  const folders: Array<Folder> = [];\n\n  for (const entry of await readdir(ROOT, { withFileTypes: true })) {\n    if (!entry.isDirectory()) {\n      continue;\n    }\n\n    const dir = join(ROOT, entry.name);\n    const manifestFile = join(dir, \"kosmo.json\");\n\n    const manifestFileExists = await access(manifestFile, constants.F_OK).then(\n      () => true,\n      () => false,\n    );\n\n    if (!manifestFileExists) {\n      // not a kosmo folder, ignore\n      continue;\n    }\n\n    const { default: manifest } = await import(manifestFile, {\n      with: { type: \"json\" },\n    });\n\n    folders.push({ dir, ...(manifest as SourceFolderManifest) });\n  }\n\n  return folders;\n};\n\n/**\n * In-memory static server for a CSR folder's `client/` output.\n * Everything is read once at startup; Vite hashes the files under `assets/`,\n * so those are served as immutable, the rest as revalidate-always.\n * */\nconst createStaticListener = async (\n  dir: string,\n  base: string,\n): Promise<NodeListener> => {\n  const files = new Map<string, StaticFile>();\n\n  const walk = async (path: string, prefix: string) => {\n    for (const entry of await readdir(path, { withFileTypes: true })) {\n      // Vite's build manifest is not a public file\n      if (entry.name === \".vite\") {\n        continue;\n      }\n\n      const file = join(path, entry.name);\n      const url = posix.join(prefix, entry.name);\n\n      if (entry.isDirectory()) {\n        await walk(file, url);\n        continue;\n      }\n\n      const buffer = await readFile(file);\n\n      files.set(url, {\n        buffer,\n        headers: {\n          \"Content-Type\": contentTypeFor(entry.name),\n          \"Content-Length\": String(buffer.length),\n          \"Cache-Control\": url.startsWith(posix.join(base, \"assets/\"))\n            ? \"public, max-age=31536000, immutable\"\n            : \"no-cache\",\n        },\n      });\n    }\n  };\n\n  await walk(dir, base);\n\n  const index = files.get(posix.join(base, \"index.html\"));\n\n  return (req, res) => {\n    const { pathname } = new URL(req.url ?? \"/\", \"http://localhost\");\n\n    if (![\"GET\", \"HEAD\"].includes(req.method ?? \"\")) {\n      res.writeHead(405, { Allow: \"GET, HEAD\" });\n      res.end();\n      return;\n    }\n\n    // a real file wins; anything else is a client route, resolved by the client router\n    const file = files.get(pathname) || index;\n\n    if (!file) {\n      res.writeHead(404, { \"Content-Type\": \"text/plain\" });\n      res.end(\"404: Not Found\");\n      return;\n    }\n\n    res.writeHead(200, file.headers);\n    res.end(req.method === \"HEAD\" ? undefined : file.buffer);\n  };\n};\n\nconst mountFolders = async (\n  folders: Array<Folder>,\n): Promise<Array<Handler>> => {\n  const handlers: Array<Handler> = [];\n\n  for (const { dir, name, frontend, backend } of folders) {\n    const aliasPatterns =\n      backend?.aliasPatterns.map((alias) => {\n        return pathToRegexp(posix.join(\"/\", alias)).regexp;\n      }) || [];\n\n    if (frontend?.ssr) {\n      // ssr/server.js bundles the backend\n      const { createListener } = (await import(\n        resolve(dir, \"ssr\", \"server.js\")\n      )) as { createListener: () => Promise<NodeListener> };\n\n      const listener = await createListener();\n\n      handlers.push({\n        name,\n        base: frontend.base as string,\n        aliasPatterns: [],\n        listener,\n      });\n\n      if (backend) {\n        handlers.push({\n          name,\n          base: backend.base,\n          aliasPatterns: aliasPatterns,\n          listener,\n        });\n      }\n\n      continue;\n    }\n\n    if (backend) {\n      const { default: listener } = (await import(\n        join(dir, \"api\", \"listener.js\")\n      )) as { default: NodeListener };\n      handlers.push({\n        name,\n        base: backend.base,\n        aliasPatterns: aliasPatterns,\n        listener,\n      });\n    }\n\n    if (frontend) {\n      const listener = await createStaticListener(\n        join(dir, \"client\"),\n        frontend.base,\n      );\n      handlers.push({ name, base: frontend.base, aliasPatterns: [], listener });\n    }\n  }\n\n  return handlers.sort((a, b) => handlerWeight(b) - handlerWeight(a));\n};\n\nexport const createListener = async (): Promise<NodeListener> => {\n  const folders = await readFolders();\n\n  if (!folders.length) {\n    throw new Error(`No built source folders found in ${ROOT}`);\n  }\n\n  const handlers = await mountFolders(folders);\n\n  for (const { name, base } of handlers) {\n    console.log(`  ${base.padEnd(24)} -> ${name}`);\n  }\n\n  return (req, res) => {\n    const { pathname } = new URL(req.url ?? \"/\", \"http://localhost\");\n\n    for (const { base, aliasPatterns, listener } of handlers) {\n      if (\n        pathname === base ||\n        pathname.startsWith(posix.join(base, \"/\")) ||\n        aliasPatterns.some((r) => r.test(pathname))\n      ) {\n        listener(req, res);\n        return;\n      }\n    }\n\n    res.writeHead(404, { \"Content-Type\": \"text/html\" });\n    res.end(\"<h1>404: Not Found</h1>\");\n  };\n};\n\nexport const startServer = async ({\n  port,\n  sock,\n}: {\n  port?: string | number | undefined;\n  sock?: string | undefined;\n}): Promise<Server> => {\n  if (![port, sock].some(Boolean)) {\n    throw new Error(\"Please provide either -p/--port or -s/--sock\");\n  }\n\n  if (sock) {\n    await unlink(sock).catch((error) => {\n      if ((error as NodeJS.ErrnoException).code !== \"ENOENT\") {\n        throw error;\n      }\n    });\n  }\n\n  console.log(\n    `\\n  -> Starting server [ ${sock ? `sock: ${sock}` : `port: ${port}`} ]\\n`,\n  );\n\n  const server = createServer(await createListener());\n\n  server.listen(sock || Number(port), async () => {\n    if (sock) {\n      // let a reverse proxy running as another user connect\n      await chmod(sock, 0o777);\n    }\n    console.log(\"\\n  -> Server Started\\n\");\n  });\n\n  return server;\n};\n\nif (process.argv[1] === import.meta.url) {\n  const {\n    values: { port, sock },\n  } = parseArgs({\n    options: {\n      port: { type: \"string\", short: \"p\" },\n      sock: { type: \"string\", short: \"s\" },\n    },\n  });\n\n  try {\n    await startServer({ port, sock });\n  } catch (error) {\n    console.error(\"Failed starting server\");\n    console.error(error);\n    process.exit(1);\n  }\n}\n";
+//#endregion
+//#region src/runner.ts
+var folderManifestFactory = (sourceFolder) => {
+	const { name, config: { frontend, backend } } = sourceFolder;
+	return {
+		name,
+		...frontend?.base ? { frontend: {
+			base: frontend.base,
+			ssr: frontend?.ssr ? true : false
+		} } : {},
+		...backend?.base ? { backend: {
+			base: backend.base,
+			aliasPatterns: createAliasPatterns(backend?.alias)
+		} } : {}
+	};
 };
-
-const ROOT = import.meta.dirname;
-
-const contentTypeFor = (file: string): string => {
-  return MIME_TYPES[extname(file).toLowerCase()] || "application/octet-stream";
+var writeFolderManifest = async (sourceFolder) => {
+	const { createPath } = pathResolver(sourceFolder);
+	const dir = createPath.distDir();
+	await mkdir(dir, { recursive: true });
+	await writeFile(resolve(dir, "kosmo.json"), JSON.stringify(folderManifestFactory(sourceFolder), void 0, 2), "utf8");
 };
-
-const escapeRegex = (text: string): string => {
-  return text.replace(/[.*+?^\${}()|[\\]\\\\]/g, "\\\\$&").replace(/\\/+$/, "");
+var runnerPath = ({ root, distDir }) => {
+	return resolve(root, distDir, "run.js");
 };
-
-// matches \`prefix\` itself and anything nested under it, never a sibling sharing the text
-const prefixMatcher = (prefix: string): ((pathname: string) => boolean) => {
-  const pattern = new RegExp(\`^\${escapeRegex(prefix)}(?=$|/)\`);
-  return (pathname) => pattern.test(pathname);
+var runnerCode;
+/**
+* The template is authored as TypeScript so it typechecks with the package;
+* the deployed file is plain JS. Stripping runs through the oxc transform
+* that vite already ships, once per process - preview redeploys after every rebuild.
+* */
+var runnerCodeFactory = async () => {
+	if (!runnerCode) {
+		const { code } = await transformWithOxc(run_default, "run.ts", { sourcemap: false });
+		runnerCode = code;
+	}
+	return runnerCode;
 };
-
 /**
- * Sorting mirrors the dev server: more specific prefixes first, API prefixes ahead of page prefixes.
- *
- *   /admin/api  weight 6
- *   /api        weight 5
- *   /admin      weight 1
- *   /           weight 0
- * */
-const weightOf = ([base, api]: Handler["segments"]): number => {
-  const weight = base.split("/").filter(Boolean).length;
-  return api ? weight + 5 : weight;
+* run.js is static - it holds no folder-specific data -
+* so rewriting it on every build, partial builds included, is idempotent.
+* */
+var deployRunner = async (projectSettings) => {
+	const file = runnerPath(projectSettings);
+	await mkdir(resolve(file, ".."), { recursive: true });
+	await writeFile(file, await runnerCodeFactory(), "utf8");
+	return file;
 };
-
-const readFolders = async (): Promise<Array<Folder>> => {
-  const folders: Array<Folder> = [];
-
-  for (const entry of await readdir(ROOT, { withFileTypes: true })) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-
-    const dir = join(ROOT, entry.name);
-
-    const manifest = await readFile(join(dir, "kosmo.json"), "utf8").catch(
-      () => undefined,
-    );
-
-    if (manifest) {
-      folders.push({ dir, ...(JSON.parse(manifest) as FolderManifest) });
-    }
-  }
-
-  return folders;
+//#endregion
+//#region src/preview.ts
+var DEBOUNCE_MS = 300;
+var IGNORED_FILE = /(^\.|~$|\.swp$|\.tmp$)/;
+/**
+* Preview = production build + watcher + `dist/run.js`.
+*
+* The runner is a child process rather than an in-process import:
+* a fresh process is the only way to reload an ESM graph,
+* and it is exactly what production does - `node dist/run.js`.
+*
+* Watching is chokidar over the `src/<folder>` trees - no Vite server,
+* no module graph: the unit of work is "rebuild this folder", so folder-level
+* granularity is all the watcher needs to provide.
+* */
+var previewFactory = async (projectSettings, build) => {
+	const { root, previewPort, sourceFolders } = projectSettings;
+	const runner = runnerPath(projectSettings);
+	const log = (...args) => {
+		console.log(styleText("dim", "[preview]"), ...args);
+	};
+	let child;
+	const startRunner = () => {
+		const proc = spawn(process.execPath, [
+			"--enable-source-maps",
+			runner,
+			"--port",
+			String(previewPort)
+		], {
+			cwd: root,
+			stdio: "inherit"
+		});
+		proc.on("exit", (code, signal) => {
+			if (child === proc) {
+				child = void 0;
+				log(styleText("red", `runner exited (${signal ?? code})`));
+			}
+		});
+		child = proc;
+	};
+	const stopRunner = () => {
+		return new Promise((resolve) => {
+			const proc = child;
+			if (!proc || proc.exitCode !== null) {
+				child = void 0;
+				resolve();
+				return;
+			}
+			child = void 0;
+			proc.once("exit", () => resolve());
+			proc.kill("SIGTERM");
+		});
+	};
+	const restartRunner = async () => {
+		await stopRunner();
+		startRunner();
+	};
+	const dirty = /* @__PURE__ */ new Set();
+	let building = false;
+	let timer;
+	const rebuild = async () => {
+		if (building) return;
+		building = true;
+		try {
+			while (dirty.size) {
+				const folders = [...dirty];
+				dirty.clear();
+				let failed = false;
+				for (const sourceFolder of folders) {
+					log(`rebuilding ${styleText("blue", sourceFolder.name)}`);
+					try {
+						await build(sourceFolder);
+						await writeFolderManifest(sourceFolder);
+					} catch (error) {
+						failed = true;
+						console.error(styleText("red", `${sourceFolder.name}: build failed`));
+						console.error(error);
+					}
+				}
+				await deployRunner(projectSettings);
+				if (failed) log(styleText("yellow", "keeping previous build running"));
+				else await restartRunner();
+			}
+		} finally {
+			building = false;
+		}
+	};
+	const schedule = (sourceFolder, file) => {
+		if (process.env.DEBUG) log(`event ${sourceFolder.name}: ${file} (building: ${building})`);
+		if (IGNORED_FILE.test(basename(file))) return;
+		dirty.add(sourceFolder);
+		clearTimeout(timer);
+		timer = setTimeout(rebuild, DEBOUNCE_MS);
+	};
+	const watchedFolders = sourceFolders.flatMap((sourceFolder) => {
+		if (sourceFolder.config.frontend || sourceFolder.config.backend) {
+			const { createPath } = pathResolver(sourceFolder);
+			return [{
+				dir: createPath.src(),
+				sourceFolder
+			}];
+		}
+		return [];
+	});
+	if (!watchedFolders.length) return async () => {};
+	const watcher = watch(watchedFolders.map(({ dir }) => dir), { ignoreInitial: true });
+	watcher.on("all", (_event, path) => {
+		const { sourceFolder } = watchedFolders.find(({ dir }) => {
+			return path === dir || path.startsWith(posix.join(dir, "/"));
+		}) || {};
+		if (sourceFolder) schedule(sourceFolder, path);
+	});
+	watcher.on("error", (error) => {
+		console.error(styleText("red", "watcher failed"));
+		console.error(error);
+	});
+	for (const { dir } of watchedFolders) log(`watching ${styleText("blue", relative(root, dir))}`);
+	startRunner();
+	const teardown = async () => {
+		clearTimeout(timer);
+		await watcher.close();
+		await stopRunner();
+	};
+	for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, async () => {
+		await teardown();
+		process.exit(0);
+	});
+	return teardown;
+};
+//#endregion
+//#region src/chassis.ts
+var chassis_default = async (projectSettings) => {
+	const { devPort, command } = projectSettings;
+	for (const sourceFolder of projectSettings.sourceFolders) for (const generator of sourceFolder.generators) {
+		if (!generator.meta?.name || typeof generator.factory !== "function") throw new Error(`${sourceFolder.name}: Unrecognized generator - must be created via defineGenerator()`);
+		try {
+			await generator.factory(sourceFolder).seed();
+		} catch (error) {
+			console.error(styleText("red", `${sourceFolder.name}: ${generator.meta.name} generator failed to seed`));
+			throw error;
+		}
+	}
+	if (command === "build" || command === "preview") {
+		for (const sourceFolder of projectSettings.sourceFolders) {
+			await buildSourceFolder(sourceFolder);
+			if (sourceFolder.config.frontend || sourceFolder.config.backend) await writeFolderManifest(sourceFolder);
+		}
+		await deployRunner(projectSettings);
+		if (command === "build") return async () => {};
+		return previewFactory(projectSettings, buildSourceFolder);
+	}
+	const requestHandlers = [];
+	const teardownHandlers = [];
+	const eventMap = {};
+	for (const sourceFolder of projectSettings.sourceFolders) if (sourceFolder.config.frontend || sourceFolder.config.backend) eventMap[sourceFolder.name] = await eventFactory(sourceFolder);
+	let port = await findFreePort(devPort);
+	for (const sourceFolder of projectSettings.sourceFolders) {
+		const { createPath } = pathResolver(sourceFolder);
+		const { frontend, backend, sidecar } = sourceFolder.config;
+		const requestMatchers = matchersFactory(sourceFolder);
+		const plugins = [
+			vitePlugins.tsconfigPaths(sourceFolder),
+			vitePlugins.nodePrefix(),
+			vitePlugins.virtualModules(sourceFolder, {
+				kind: "csr",
+				command
+			})
+		];
+		if (frontend) {
+			const generator = sourceFolder.generators.find((e) => e.meta.slot === "frontend");
+			const viteServer = await createServer(mergeConfigs(frontend?.viteConfig, generator?.factory(sourceFolder).viteConfig?.({
+				kind: "frontend",
+				command
+			}), {
+				base: frontend.base,
+				root: createPath.src(),
+				cacheDir: cacheDir(sourceFolder, command, "client"),
+				plugins,
+				server: {
+					port: port++,
+					middlewareMode: true,
+					hmr: { port: port++ }
+				}
+			}));
+			for (const [evt, handler] of Object.entries(eventMap[sourceFolder.name])) viteServer.watcher.on(evt, handler);
+			requestHandlers.push([
+				frontend.base,
+				() => requestMatchers.frontend,
+				() => viteServer.middlewares
+			]);
+			teardownHandlers.push(viteServer.close);
+		}
+		if (backend) {
+			const generator = sourceFolder.generators.find((e) => e.meta.slot === "backend");
+			const viteServer = await createServer(mergeConfigs(backend.viteConfig, generator?.factory(sourceFolder).viteConfig?.({
+				kind: "backend",
+				command
+			}), {
+				root: createPath.src(),
+				appType: "custom",
+				cacheDir: cacheDir(sourceFolder, command, "backend"),
+				plugins,
+				server: {
+					port: port++,
+					middlewareMode: true,
+					hmr: { port: port++ }
+				},
+				resolve: { conditions: ["node"] },
+				environments: { backend: { resolve: { conditions: ["node"] } } }
+			}));
+			const env = viteServer.environments.backend;
+			const loadDevSetup = async () => {
+				env.runner.clearCache();
+				return env.runner.import(join(defaults.apiDir, "dev.ts")).then((e) => e.default);
+			};
+			let devSetup = await loadDevSetup();
+			for (const [evt, handler] of Object.entries(eventMap[sourceFolder.name])) viteServer.watcher.on(evt, async (file) => {
+				if (env.moduleGraph.getModulesByFile(file)?.size) try {
+					await handler(file);
+					await devSetup?.teardownHandler?.();
+					devSetup = await loadDevSetup();
+				} catch (error) {
+					console.error(styleText("red", `${sourceFolder.name}: backend reload failed`));
+					console.error(error);
+				}
+			});
+			requestHandlers.push([
+				backend.base,
+				() => devSetup.requestMatcher || requestMatchers.backend,
+				() => devSetup.requestHandler()
+			]);
+			teardownHandlers.push(viteServer.close);
+		}
+		if (sidecar?.serve) {
+			/**
+			* Assigned once the service is up; the reload plugin below is installed during `createServer`,
+			* so the hook has to reach it through a binding rather than a closure over something that does not exist yet.
+			* */
+			let reload = async () => {};
+			/**
+			* Restarting on a raw `watcher.on("change")` reads the module graph before Vite has invalidated it,
+			* and the service comes back up running the source as it was before the save.
+			*
+			* `hotUpdate` is called after that invalidation.
+			* Returning `[]` says the update is handled and leaves Vite nothing to propagate.
+			*
+			* The hook runs once per environment; nothing but `sidecar` resolves a module on this server.
+			* */
+			const reloadPlugin = {
+				name: "kosmo:sidecar-reload",
+				hotUpdate({ modules }) {
+					if (modules.length) reload();
+					return [];
+				}
+			};
+			const viteServer = await createServer(mergeConfigs(sidecar.viteConfig, {
+				root: createPath.src(),
+				appType: "custom",
+				cacheDir: cacheDir(sourceFolder, command, "sidecar"),
+				plugins: [...plugins, reloadPlugin],
+				server: { hmr: true },
+				resolve: { conditions: ["node"] },
+				environments: { sidecar: { resolve: { conditions: ["node"] } } }
+			}));
+			const env = viteServer.environments.sidecar;
+			const loadService = async () => {
+				env.runner.clearCache();
+				return env.runner.import(sidecar.entry).then((e) => e.default);
+			};
+			let service = await loadService();
+			let close = await service.start();
+			reload = async () => {
+				try {
+					/**
+					* Load before tearing anything down: a save that cannot compile throws here,
+					* and the running service is left untouched rather than closed with nothing to replace it -
+					* which is unrecoverable for a service whose close function cannot run twice.
+					*
+					* Starting still happens after closing, so a service holding a port frees it before the new one binds.
+					* */
+					const next = await loadService();
+					await service.teardown?.();
+					await close();
+					/**
+					* Nothing is running between here and `start()`, so drop the closer:
+					* a `start()` that throws would otherwise leave the next reload calling it a second time,
+					* which for a real one throws too - and the sidecar never comes back.
+					* */
+					close = async () => {};
+					service = next;
+					close = await service.start();
+				} catch (error) {
+					console.error(styleText("red", `${sourceFolder.name}: sidecar reload failed`));
+					console.error(error);
+				}
+			};
+			teardownHandlers.push(viteServer.close);
+		}
+	}
+	/**
+	* Sorting is essential to ensure more specific paths are matched before broader ones.
+	*
+	* Correct sort order:
+	*   1. /admin/api - 10 + 3, most specific
+	*   3. /admin     - 6  + 2
+	*   2. /api       - 4  + 2
+	*   4. /          - 1  + 2
+	* */
+	const requestHandlerWeight = ([path]) => {
+		return path.length + path.split("/").filter(Boolean).length;
+	};
+	const handlers = requestHandlers.sort((a, b) => requestHandlerWeight(b) - requestHandlerWeight(a));
+	const httpServer = http.createServer((req, res) => {
+		for (const [, matcherFactory, handlerFactory] of handlers) {
+			const [matcher, handler] = [matcherFactory(), handlerFactory()];
+			if (matcher(req)) {
+				handler(req, res);
+				return;
+			}
+		}
+		res.writeHead(404, { "Content-Type": "text/html" });
+		res.end("<h1>404: Not Found</h1>");
+	});
+	httpServer.on("error", (error) => {
+		console.error(styleText("red", `Failed to start dev server on port ${devPort}`));
+		console.error(error.message);
+		process.exit(1);
+	});
+	httpServer.listen(devPort);
+	teardownHandlers.push(async () => {
+		httpServer.close();
+	});
+	return async () => {
+		for (const handler of teardownHandlers) await handler();
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	};
+};
+var cacheDir = ({ root, name }, command, mode) => {
+	return resolve(root, `var/.vite/${name}/${command}/${mode}`);
 };
-
 /**
- * In-memory static server for a CSR folder's \`client/\` output.
- * Everything is read once at startup; Vite hashes the files under \`assets/\`,
- * so those are served as immutable, the rest as revalidate-always.
- * */
-const createStaticListener = async (
-  dir: string,
-  base: string,
-): Promise<NodeListener> => {
-  const files = new Map<string, StaticFile>();
-
-  const walk = async (path: string, prefix: string) => {
-    for (const entry of await readdir(path, { withFileTypes: true })) {
-      // Vite's build manifest is not a public file
-      if (entry.name === ".vite") {
-        continue;
-      }
-
-      const file = join(path, entry.name);
-      const url = posix.join(prefix, entry.name);
-
-      if (entry.isDirectory()) {
-        await walk(file, url);
-        continue;
-      }
-
-      const buffer = await readFile(file);
-
-      files.set(url, {
-        buffer,
-        headers: {
-          "Content-Type": contentTypeFor(entry.name),
-          "Content-Length": String(buffer.length),
-          "Cache-Control": url.startsWith(posix.join(base, "assets/"))
-            ? "public, max-age=31536000, immutable"
-            : "no-cache",
-        },
-      });
-    }
-  };
-
-  await walk(dir, base);
-
-  const index = files.get(posix.join(base, "index.html"));
-
-  return (req, res) => {
-    const { pathname } = new URL(req.url ?? "/", "http://localhost");
-
-    if (!["GET", "HEAD"].includes(req.method ?? "")) {
-      res.writeHead(405, { Allow: "GET, HEAD" });
-      res.end();
-      return;
-    }
-
-    // a real file wins; anything else is a client route, resolved by the client router
-    const file = files.get(pathname) || index;
-
-    if (!file) {
-      res.writeHead(404, { "Content-Type": "text/plain" });
-      res.end("404: Not Found");
-      return;
-    }
-
-    res.writeHead(200, file.headers);
-    res.end(req.method === "HEAD" ? undefined : file.buffer);
-  };
+* Production build of one source folder - generators, client bundle, api bundle,
+* then the generators' post-build steps (ssr, ssg).
+* Shared by `build` and `preview`: preview is a production build that reruns on change,
+* so generators are told `command: "build"` and the build cache is the same.
+* */
+var buildSourceFolder = async (sourceFolder) => {
+	const command = "build";
+	const { createPath } = pathResolver(sourceFolder);
+	const { frontend, backend, sidecar } = sourceFolder.config;
+	const resolvedRoutes = [];
+	if (!sidecar) {
+		const { resolvers } = await routesFactory(sourceFolder, cacheFactory);
+		const spinner = spinnerFactory(`${sourceFolder.name}: resolving routes`);
+		for (const { name, handler } of resolvers.values()) {
+			spinner.append(`[ ${resolvedRoutes.length + 1} of ${resolvers.size} ] ${name}`);
+			resolvedRoutes.push(await handler());
+		}
+		spinner.succeed("ready ✨");
+	}
+	const plugins = [
+		vitePlugins.tsconfigPaths(sourceFolder),
+		vitePlugins.nodePrefix(),
+		vitePlugins.virtualModules(sourceFolder, {
+			kind: "csr",
+			command
+		})
+	];
+	for (const generator of sourceFolder.generators) await generator.factory(sourceFolder).build?.(resolvedRoutes);
+	if (frontend) {
+		const generator = sourceFolder.generators.find((e) => e.meta.slot === "frontend");
+		await build(mergeConfigs(frontend.viteConfig, generator?.factory(sourceFolder).viteConfig?.({
+			kind: "frontend",
+			command
+		}), {
+			base: frontend.base,
+			root: createPath.src(),
+			cacheDir: cacheDir(sourceFolder, command, "client"),
+			plugins,
+			build: {
+				outDir: createPath.distDir("client"),
+				manifest: true,
+				emptyOutDir: true
+			}
+		}));
+	}
+	if (backend) {
+		const generator = sourceFolder.generators.find((e) => e.meta.slot === "backend");
+		await build(mergeConfigs(backend.viteConfig, generator?.factory(sourceFolder).viteConfig?.({
+			kind: "backend",
+			command
+		}), {
+			base: "./",
+			root: createPath.src(),
+			appType: "custom",
+			plugins,
+			resolve: { conditions: ["node"] },
+			build: {
+				ssr: true,
+				target: "esnext",
+				sourcemap: true,
+				emptyOutDir: true,
+				rolldownOptions: {
+					input: [
+						createPath.api("app.ts"),
+						createPath.api("server.ts"),
+						createPath.lib("@api/listener.ts")
+					],
+					output: {
+						dir: createPath.distDir("api"),
+						format: "esm"
+					}
+				}
+			},
+			cacheDir: cacheDir(sourceFolder, command, "backend")
+		}));
+	}
+	if (sidecar) await build(mergeConfigs(sidecar.viteConfig, {
+		base: "./",
+		root: createPath.src(),
+		appType: "custom",
+		plugins,
+		resolve: { conditions: ["node"] },
+		build: {
+			ssr: true,
+			target: "esnext",
+			sourcemap: true,
+			emptyOutDir: true,
+			rolldownOptions: {
+				input: {
+					entry: createPath.src(sidecar.entry),
+					...sidecar.run ? { run: sidecar.run } : {}
+				},
+				output: {
+					dir: createPath.distDir("sidecar"),
+					format: "esm"
+				}
+			}
+		},
+		cacheDir: cacheDir(sourceFolder, command, "sidecar")
+	}));
+	for (const generator of sourceFolder.generators) await generator.factory(sourceFolder).postBuild?.(resolvedRoutes);
 };
-
-const mountFolders = async (folders: Array<Folder>) => {
-  const handlers: Array<Handler> = [];
-
-  for (const { dir, name, base, apiBase, api, client, ssr } of folders) {
-    const apiPrefix = posix.join(base, apiBase);
-
-    if (ssr) {
-      // ssr/server.js bundles the backend; its listener already splits API from pages
-      const { createListener } = (await import(
-        pathToFileURL(join(dir, "ssr", "server.js")).href
-      )) as { createListener: () => Promise<NodeListener> };
-
-      const listener = await createListener();
-
-      handlers.push({ name, segments: [base, apiPrefix], listener });
-      handlers.push({ name, segments: [base], listener });
-
-      continue;
-    }
-
-    if (api) {
-      const { default: listener } = (await import(
-        pathToFileURL(join(dir, "api", "listener.js")).href
-      )) as { default: NodeListener };
-
-      handlers.push({ name, segments: [base, apiPrefix], listener });
-    }
-
-    if (client) {
-      const listener = await createStaticListener(join(dir, "client"), base);
-      handlers.push({ name, segments: [base], listener });
-    }
-  }
-
-  return handlers
-    .sort((a, b) => weightOf(b.segments) - weightOf(a.segments))
-    .map(({ name, segments, listener }) => {
-      const [base, api] = segments;
-      return {
-        name,
-        prefix: api || base,
-        match: prefixMatcher(api || base),
-        listener,
-      };
-    });
+var eventFactory = async (sourceFolder) => {
+	const { resolvers, resolversFactory } = await routesFactory(sourceFolder, cacheFactory);
+	const { createPath } = pathResolver(sourceFolder);
+	const generators = [];
+	for (const generator of sourceFolder.generators) {
+		const factory = generator.factory(sourceFolder);
+		generators.push({
+			name: generator.meta.name,
+			factory
+		});
+	}
+	const resolvedRoutes = /* @__PURE__ */ new Map();
+	const runGenerators = async (event) => {
+		/**
+		* Watch handlers receive the full list of entries
+		* and should process only those whose source file or dependencies were updated.
+		* */
+		const entries = Array.from(resolvedRoutes.values());
+		for (const { name, factory } of generators) try {
+			await factory.watch?.(entries, event);
+		} catch (error) {
+			console.error(styleText("red", `${sourceFolder.name}: ${name} generator failed`));
+			if (event) console.error(event);
+			console.error(error);
+		}
+	};
+	const updateResolvedEntry = async (file) => {
+		const resolver = resolvers.get(file);
+		if (!resolver) return;
+		try {
+			const resolvedEntry = await resolver.handler(file);
+			resolvedRoutes.set(resolvedEntry.entry.fileFullpath, resolvedEntry);
+			return resolvedEntry;
+		} catch (error) {
+			const route = file.replace(`${createPath.api()}/`, "");
+			console.error(styleText("red", `${sourceFolder.name}: ${route} route resolution failed`));
+			console.error(error);
+			return;
+		}
+	};
+	{
+		const spinner = spinnerFactory(`${sourceFolder.name}: resolving routes`);
+		for (const { name, handler } of resolvers.values()) {
+			spinner.append(`[ ${resolvedRoutes.size + 1} of ${resolvers.size} ] ${name}`);
+			const route = await handler();
+			resolvedRoutes.set(route.entry.fileFullpath, route);
+		}
+		spinner.succeed("ready ✨");
+	}
+	await runGenerators();
+	return {
+		async add(file) {
+			const [resolver] = resolversFactory([file]).values();
+			if (!resolver) return;
+			resolvers.set(file, resolver);
+			if (await updateResolvedEntry(file)) await runGenerators({
+				kind: "create",
+				file
+			});
+		},
+		async change(file) {
+			if (resolvedRoutes.has(file)) await updateResolvedEntry(file);
+			else {
+				const relatedRoutes = resolvedRoutes.values().flatMap(({ kind, entry }) => {
+					return kind === "apiRoute" ? entry.referencedFiles.includes(file) ? [entry] : [] : [];
+				});
+				for (const route of relatedRoutes) await updateResolvedEntry(route.fileFullpath);
+			}
+			await runGenerators({
+				kind: "update",
+				file
+			});
+		},
+		async unlink(file) {
+			resolvers.delete(file);
+			resolvedRoutes.delete(file);
+			await runGenerators({
+				kind: "delete",
+				file
+			});
+		}
+	};
 };
-
-export const createListener = async (): Promise<NodeListener> => {
-  const folders = await readFolders();
-
-  if (!folders.length) {
-    throw new Error(\`No built source folders found in \${ROOT}\`);
-  }
-
-  const handlers = await mountFolders(folders);
-
-  for (const { name, prefix } of handlers) {
-    console.log(\`  \${prefix.padEnd(24)} -> \${name}\`);
-  }
-
-  return (req, res) => {
-    const { pathname } = new URL(req.url ?? "/", "http://localhost");
-
-    for (const { match, listener } of handlers) {
-      if (match(pathname)) {
-        listener(req, res);
-        return;
-      }
-    }
-
-    res.writeHead(404, { "Content-Type": "text/html" });
-    res.end("<h1>404: Not Found</h1>");
-  };
+var matchersFactory = ({ config }) => {
+	const [frontendBase, backendBase] = [config.frontend?.base, config.backend?.base];
+	const backendAliasPatterns = backendBase ? createAliasPatterns(config.backend?.alias).map((pattern) => {
+		return pathToRegexp(posix.join("/", pattern)).regexp;
+	}) : [];
+	const prefixMatch = (base, path) => {
+		return path === base || path.startsWith(posix.join(base, "/"));
+	};
+	const backendMatch = (path) => {
+		if (!backendBase) return false;
+		return prefixMatch(backendBase, path) ? true : backendAliasPatterns.some((r) => r.test(path) || false);
+	};
+	return {
+		frontend(req) {
+			if (!frontendBase) return false;
+			const { pathname } = new URL(req.url ?? "/", "http://localhost");
+			return backendMatch(pathname) ? false : prefixMatch(frontendBase, pathname);
+		},
+		backend(req) {
+			const { pathname } = new URL(req.url ?? "/", "http://localhost");
+			return backendMatch(pathname);
+		}
+	};
 };
-
-export const startServer = async ({
-  port,
-  sock,
-}: {
-  port?: string | number | undefined;
-  sock?: string | undefined;
-}): Promise<Server> => {
-  if (![port, sock].some(Boolean)) {
-    throw new Error("Please provide either -p/--port or -s/--sock");
-  }
-
-  if (sock) {
-    await unlink(sock).catch((error) => {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-        throw error;
-      }
-    });
-  }
-
-  console.log(
-    \`\\n  -> Starting server [ \${sock ? \`sock: \${sock}\` : \`port: \${port}\`} ]\\n\`,
-  );
-
-  const server = createServer(await createListener());
-
-  server.listen(sock || Number(port), async () => {
-    if (sock) {
-      // let a reverse proxy running as another user connect
-      await chmod(sock, 0o777);
-    }
-    console.log("\\n  -> Server Started\\n");
-  });
-
-  return server;
+var findFreePort = async (devPort) => {
+	let minPort = 0;
+	let maxPort = 0;
+	for (const n of [
+		3,
+		2,
+		1,
+		""
+	]) {
+		minPort = Number(`${n}${devPort}`) + 100;
+		maxPort = minPort + 100;
+		if (maxPort < 65e3) break;
+	}
+	if (maxPort >= 65e3) throw new Error("the devPort in package.json should be less than 64000");
+	const range = maxPort - minPort + 1;
+	const startOffset = Math.floor(Math.random() * range);
+	const freePort = await Array.from({ length: range }, (_, i) => {
+		return minPort + (startOffset + i) % range;
+	}).reduce(async (prevPromise, port) => {
+		const freePort = await prevPromise;
+		if (freePort) return freePort;
+		return await isPortFree(port) ? port : void 0;
+	}, Promise.resolve(void 0));
+	if (!freePort) throw new Error(`No free ports found in range ${minPort}-${maxPort}`);
+	return freePort;
 };
+var isPortFree = (port) => {
+	return new Promise((resolve) => {
+		const server = net.createServer();
+		server.once("error", () => resolve(false));
+		server.once("listening", () => {
+			server.close();
+			resolve(true);
+		});
+		server.listen(port, "127.0.0.1");
+	});
+};
+//#endregion
+export { chassis_default as default };
 
-if (pathToFileURL(process.argv[1] || "").href === import.meta.url) {
-  const {
-    values: { port, sock },
-  } = parseArgs({
-    options: {
-      port: { type: "string", short: "p" },
-      sock: { type: "string", short: "s" },
-    },
-  });
-
-  try {
-    await startServer({ port, sock });
-  } catch (error) {
-    console.error("Failed starting server");
-    console.error(error);
-    process.exit(1);
-  }
-}
-`,P=e=>{let{generators:t}=e.config,n=e=>t.some(t=>t.meta.slot===e),r=n(`frontend`);return{name:e.name,base:e.config.base,apiBase:e.config.apiBase,api:n(`backend`),client:r,ssr:r&&n(`ssr`)}},F=async e=>{let{createPath:t}=f(e),n=t.distDir();await x(n,{recursive:!0}),await C(a(n,`kosmo.json`),JSON.stringify(P(e),void 0,2),`utf8`)},I=({root:e,distDir:t})=>a(e,t,`run.js`),L,R=async()=>{if(!L){let{code:e}=await b(N,`run.ts`,{sourcemap:!1});L=e}return L},z=async e=>{let t=I(e);return await x(a(t,`..`),{recursive:!0}),await C(t,await R(),`utf8`),t},B=300,V=/(^\.|~$|\.swp$|\.tmp$)/,H=async(e,n)=>{let{root:r,previewPort:a,sourceFolders:c}=e,l=I(e),u=(...e)=>{console.log(s(`dim`,`[preview]`),...e)},d,p=()=>{let e=D(process.execPath,[`--enable-source-maps`,l,`--port`,String(a)],{cwd:r,stdio:`inherit`});e.on(`exit`,(t,n)=>{d===e&&(d=void 0,u(s(`red`,`runner exited (${n??t})`)))}),d=e},m=()=>new Promise(e=>{let t=d;if(!t||t.exitCode!==null){d=void 0,e();return}d=void 0,t.once(`exit`,()=>e()),t.kill(`SIGTERM`)}),h=async()=>{await m(),p()},g=new Set,_=!1,v,y=async()=>{if(!_){_=!0;try{for(;g.size;){let t=[...g];g.clear();let r=!1;for(let e of t){u(`rebuilding ${s(`blue`,e.name)}`);try{await n(e),await F(e)}catch(t){r=!0,console.error(s(`red`,`${e.name}: build failed`)),console.error(t)}}await z(e),r?u(s(`yellow`,`keeping previous build running`)):await h()}}finally{_=!1}}},b=(e,n)=>{process.env.DEBUG&&u(`event ${e.name}: ${n} (building: ${_})`),!V.test(t(n))&&(g.add(e),clearTimeout(v),v=setTimeout(y,B))},x=c.map(e=>{let{createPath:t}=f(e);return{dir:t.src(),sourceFolder:e}}),S=e=>x.find(({dir:t})=>e===t||e.startsWith(t+o))?.sourceFolder,C=O(x.map(({dir:e})=>e),{ignoreInitial:!0});C.on(`all`,(e,t)=>{let n=S(t);n&&b(n,t)}),C.on(`error`,e=>{console.error(s(`red`,`watcher failed`)),console.error(e)});for(let{dir:e}of x)u(`watching ${s(`blue`,i(r,e))}`);p();let w=async()=>{clearTimeout(v),await C.close(),await m()};for(let e of[`SIGINT`,`SIGTERM`])process.once(e,async()=>{await w(),process.exit(0)});return w},U=async e=>{let{devPort:t,command:n}=e;for(let t of e.sourceFolders)for(let e of t.config.generators){if(!e.meta?.name||typeof e.factory!=`function`)throw Error(`${t.name}: Unrecognized generator - must be created via defineGenerator()`);try{await e.factory(t).start?.()}catch(n){throw console.error(s(`red`,`${t.name}: ${e.meta.name} generator failed to initialize`)),n}}if(n===`build`||n===`preview`){for(let t of e.sourceFolders)await G(t),await F(t);return await z(e),n===`build`?async()=>{}:H(e,G)}let i=[],a=[],o={};for(let t of e.sourceFolders)o[t.name]=await K(t);let d=await Y(t);for(let t of e.sourceFolders){let{createPath:e}=f(t),{generators:p}=t.config,m=J(t),h=[g.tsconfigPaths(t),g.nodePrefix(),g.virtualModules(l(t,p),{kind:`csr`,command:n})],_=p.find(e=>e.meta.slot===`frontend`),v=p.find(e=>e.meta.slot===`backend`);if(_){let r=await y(u(t.config,...p.map(({factory:e})=>e(t).config?.({kind:`client`,command:n})),{root:e.src(),cacheDir:W(t,n,`client`),plugins:h,server:{port:d++,middlewareMode:!0,hmr:{port:d++}}}));for(let[e,n]of Object.entries(o[t.name]))r.watcher.on(e,n);i.push([[t.config.base],()=>m.base,()=>r.middlewares]),a.push(r.close)}if(v){let l=await y(u(v.options,v.factory(t).config?.({kind:`backend`,command:n}),{root:e.src(),appType:`custom`,cacheDir:W(t,n,`backend`),plugins:h,server:{port:d++,middlewareMode:!0,hmr:{port:d++}},resolve:{conditions:[`node`]},environments:{api:{resolve:{conditions:[`node`]}}}})),f=l.environments.api,p=async()=>(f.runner.clearCache(),f.runner.import(r(c.apiDir,`dev.ts`)).then(e=>e.default)),g=await p();for(let[e,n]of Object.entries(o[t.name]))l.watcher.on(e,async e=>{if(f.moduleGraph.getModulesByFile(e)?.size)try{await n(e),await g?.teardownHandler?.(),g=await p()}catch(e){console.error(s(`red`,`${t.name}: api reload failed - keeping previous api program`)),console.error(e)}});i.push([[t.config.base,t.config.apiBase],()=>g.requestMatcher||m.api,()=>g.requestHandler()]),a.push(l.close)}}let p=([e])=>{let[t,n]=e,r=t.split(`/`).filter(Boolean).length;return n?r+5:r},m=i.sort((e,t)=>p(t)-p(e)),h=w.createServer((e,t)=>{for(let[,n,r]of m){let[i,a]=[n(),r()];if(i(e)){a(e,t);return}}t.writeHead(404,{"Content-Type":`text/html`}),t.end(`<h1>404: Not Found</h1>`)});return h.on(`error`,e=>{console.error(s(`red`,`Failed to start dev server on port ${t}`)),console.error(e.message),process.exit(1)}),h.listen(t),a.push(async()=>{h.close()}),async()=>{for(let e of a)await e();await new Promise(e=>setTimeout(e,100))}},W=({root:e,name:t},n,r)=>a(e,`var/.vite/${t}/${n}/${r}`),G=async e=>{let t=`build`,{createPath:n}=f(e),{generators:r}=e.config,i=[];{let{resolvers:t}=await m(e,A),n=h(`${e.name}: resolving routes`);for(let{name:e,handler:r}of t.values())n.append(`[ ${i.length+1} of ${t.size} ] ${e}`),i.push(await r());n.succeed(`ready ✨`)}let a=[g.tsconfigPaths(e),g.nodePrefix(),g.virtualModules(l(e,r),{kind:`csr`,command:t})];for(let t of r)await t.factory(e).build?.(i);let o=r.find(e=>e.meta.slot===`frontend`),s=r.find(e=>e.meta.slot===`backend`);if(o&&await v(u(e.config,...r.map(({factory:n})=>n(e).config?.({kind:`client`,command:t})),{root:n.src(),cacheDir:W(e,t,`client`),plugins:a,build:{outDir:n.distDir(`client`),manifest:!0,emptyOutDir:!0}})),s){let r=n.distDir(`api`);await v(u(s.options,s.factory(e).config?.({kind:`backend`,command:t}),{base:`./`,root:n.src(),appType:`custom`,plugins:a,resolve:{conditions:[`node`]},build:{ssr:!0,target:`esnext`,sourcemap:!0,emptyOutDir:!0,rolldownOptions:{input:[n.api(`app.ts`),n.api(`server.ts`),n.lib(`@api/listener.ts`)],output:{dir:r,format:`esm`}}},cacheDir:W(e,t,`backend`)}))}for(let t of r)await t.factory(e).postBuild?.(i)},K=async e=>{let{resolvers:t,resolversFactory:n}=await m(e,A),{createPath:r}=f(e),i=[];for(let t of e.config.generators){let n=t.factory(e);i.push({name:t.meta.name,factory:n})}let a=new Map,o=async t=>{let n=Array.from(a.values());for(let{name:r,factory:a}of i)try{await a.watch?.(n,t)}catch(n){console.error(s(`red`,`${e.name}: ${r} generator failed`)),t&&console.error(t),console.error(n)}},c=async n=>{let i=t.get(n);if(i)try{let e=await i.handler(n);return a.set(e.entry.fileFullpath,e),e}catch(t){let i=n.replace(`${r.api()}/`,``);console.error(s(`red`,`${e.name}: ${i} route resolution failed`)),console.error(t);return}};{let n=h(`${e.name}: resolving routes`);for(let{name:e,handler:r}of t.values()){n.append(`[ ${a.size+1} of ${t.size} ] ${e}`);let i=await r();a.set(i.entry.fileFullpath,i)}n.succeed(`ready ✨`)}return await o(),{async add(e){let[r]=n([e]).values();r&&(t.set(e,r),await c(e)&&await o({kind:`create`,file:e}))},async change(e){if(a.has(e))await c(e);else{let t=a.values().flatMap(({kind:t,entry:n})=>t===`apiRoute`&&n.referencedFiles.includes(e)?[n]:[]);for(let e of t)await c(e.fileFullpath)}await o({kind:`update`,file:e})},async unlink(e){t.delete(e),a.delete(e),await o({kind:`delete`,file:e})}}},q=e=>e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`).replace(/\/+$/,``),J=({config:e})=>{let t=RegExp(`^${q(e.base)}(?=$|/)`),n=RegExp(`^${q(r(e.base,e.apiBase))}(?=$|/)`);return{base(e){return!n.test(e.url)&&t.test(e.url)},api(e){return n.test(e.url)}}},Y=async e=>{let t=0,n=0;for(let r of[3,2,1,``])if(t=Number(`${r}${e}`)+100,n=t+100,n<65e3)break;if(n>=65e3)throw Error(`the devPort in package.json should be less than 64000`);let r=n-t+1,i=Math.floor(Math.random()*r),a=await Array.from({length:r},(e,n)=>t+(i+n)%r).reduce(async(e,t)=>await e||(await X(t)?t:void 0),Promise.resolve(void 0));if(!a)throw Error(`No free ports found in range ${t}-${n}`);return a},X=e=>new Promise(t=>{let n=T.createServer();n.once(`error`,()=>t(!1)),n.once(`listening`,()=>{n.close(),t(!0)}),n.listen(e,`127.0.0.1`)});export{U as default};
 //# sourceMappingURL=chassis.js.map