@kosmojs/dev 0.4.3 → 0.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@kosmojs/dev",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "cacheVersion": "001",
   "author": "Slee Woo",
   "license": "MIT",
@@ -25,16 +25,17 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@kosmojs/core": "^0.4.3",
-    "@kosmojs/lib": "^0.4.3",
+    "@kosmojs/core": "^0.5.0",
+    "@kosmojs/lib": "^0.5.0",
     "@mdx-js/rollup": "^3.1.1",
     "@sveltejs/vite-plugin-svelte": "^7.3.0",
-    "@vitejs/plugin-react": "^6.1.0",
+    "@vitejs/plugin-react": "^6.1.1",
     "@vitejs/plugin-vue": "^6.0.8",
+    "chokidar": "^5.0.0",
     "crc": "^4.3.2",
     "path-to-regexp": "^8.4.2",
     "semver": "^7.8.5",
-    "typebox": "^1.3.18",
+    "typebox": "^1.3.30",
     "vite": "^8.2.2",
     "vite-plugin-solid": "^2.11.14",
     "yaml": "^2.9.0"

package/pkg/chassis.js

@@ -1,2 +1,624 @@
-import{t as e}from"./assets/pkg-dTglxmYm.js";import{createRequire as t}from"node:module";import{dirname as n,join as r,resolve as i}from"node:path";import{styleText as a}from"node:util";import{defaults as o}from"@kosmojs/core";import{mergeConfigs as s,pathExists as c,pathResolver as l,routesFactory as u,spinnerFactory as d,vitePlugins as f}from"@kosmojs/lib";import p from"crc/crc32";import{build as m,createServer as h}from"vite";import{mkdir as g,readFile as _,writeFile as v}from"node:fs/promises";import y from"node:http";import b from"node:net";import{readFileSync as x}from"node:fs";var S=JSON.parse(x(t(import.meta.url).resolve(`@kosmojs/dev/package.json`),`utf-8`)),C=(e,t,r)=>{let a=l(t).createPath.libApi(n(e.file),`cache.json`),o=async n=>{if(!n?.hash||!n.typeDeclarations||!n.referencedFiles)return;let a=await w(e.fileFullpath,{...r});if(T(n.hash,a)){for(let[e,r]of Object.entries(n.referencedFiles))if(!T(r,await w(i(t.root,e))))return;return n}};return{async get(e){if(await c(a))try{let t=JSON.parse(await _(a,`utf8`));return e?.validate?o(t):t}catch{}},async set(i){let o=await w(e.fileFullpath,{...r}),s={};for(let e of i.referencedFiles)s[e.replace(`${t.root}/`,``)]=await w(e);let c={...i,hash:o,referencedFiles:s};return await g(n(a),{recursive:!0}),await v(a,JSON.stringify(c,null,2),`utf8`),c}}},w=async(e,t)=>{let n;try{n=await _(e,`utf8`)}catch{return 0}return n?p(JSON.stringify({...t,[S.cacheVersion]:n})):0},T=(e,t)=>e===t,E=async e=>{let{devPort:t,command:n}=e;for(let t of e.sourceFolders)for(let e of O(t)){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(a(`red`,`${t.name}: ${e.meta.name} generator failed to initialize`)),n}}if(n===`build`){for(let t of e.sourceFolders){let{createPath:e}=l(t),r=[];{let{resolvers:e}=await u(t,C),n=d(`${t.name}: resolving routes`);for(let{name:t,handler:i}of e.values())n.append(`[ ${r.length+1} of ${e.size} ] ${t}`),r.push(await i());n.succeed(`ready ✨`)}let i=[f.tsconfigPaths(t),f.nodePrefix()],a=O(t);for(let e of a)await e.factory(t).build?.(r);let o=a.find(e=>e.meta.slot===`frontend`),c=a.find(e=>e.meta.slot===`backend`);if(o&&await m(s(t.config,...a.map(({factory:e})=>e(t).config?.({kind:`client`,command:n})),{root:e.src(),cacheDir:D(t,n,`client`),plugins:i,build:{outDir:e.distDir(`client`),manifest:!0,emptyOutDir:!0}})),c){let r=e.distDir(`api`);await m(s(c.options,c.factory(t).config?.({kind:`backend`,command:n}),{base:`./`,root:e.src(),appType:`custom`,plugins:i,resolve:{conditions:[`node`]},build:{ssr:!0,target:`esnext`,sourcemap:!0,emptyOutDir:!0,rolldownOptions:{input:[e.api(`app.ts`),e.api(`server.ts`)],output:{dir:r,format:`esm`}}},cacheDir:D(t,n,`backend`)}))}for(let e of a)await e.factory(t).postBuild?.(r)}return async()=>{}}let i=[],c=[],p={};for(let t of e.sourceFolders)p[t.name]=await k(t);let g=await M(t);for(let t of e.sourceFolders){let{createPath:e}=l(t),u=j(t),d=O(t),m=[f.tsconfigPaths(t),f.nodePrefix()],_=d.find(e=>e.meta.slot===`frontend`),v=d.find(e=>e.meta.slot===`backend`);if(_){let r=await h(s(t.config,...d.map(({factory:e})=>e(t).config?.({kind:`client`,command:n})),{root:e.src(),cacheDir:D(t,n,`client`),plugins:m,server:{port:g++,middlewareMode:!0,hmr:{port:g++}}}));for(let[e,n]of Object.entries(p[t.name]))r.watcher.on(e,n);i.push([[t.config.base],()=>u.base,()=>r.middlewares]),c.push(r.close)}if(v){let l=await h(s(v.options,v.factory(t).config?.({kind:`backend`,command:n}),{root:e.src(),appType:`custom`,cacheDir:D(t,n,`backend`),plugins:m,server:{port:g++,middlewareMode:!0,hmr:{port:g++}},resolve:{conditions:[`node`]},environments:{api:{resolve:{conditions:[`node`]}}}})),d=l.environments.api,f=async()=>(d.runner.clearCache(),d.runner.import(r(o.apiDir,`dev.ts`)).then(e=>e.default)),_=await f();for(let[e,n]of Object.entries(p[t.name]))l.watcher.on(e,async e=>{if(d.moduleGraph.getModulesByFile(e)?.size)try{await n(e),await _?.teardownHandler?.(),_=await f()}catch(e){console.error(a(`red`,`${t.name}: api reload failed - keeping previous api program`)),console.error(e)}});i.push([[t.config.base,t.config.apiBase],()=>_.requestMatcher||u.api,()=>_.requestHandler()]),c.push(l.close)}}let _=([e])=>{let[t,n]=e,r=t.split(`/`).filter(Boolean).length;return n?r+5:r},v=i.sort((e,t)=>_(t)-_(e)),b=y.createServer((e,t)=>{for(let[,n,r]of v){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 b.on(`error`,e=>{console.error(a(`red`,`Failed to start dev server on port ${t}`)),console.error(e.message),process.exit(1)}),b.listen(t),c.push(async()=>{b.close()}),async()=>{for(let e of c)await e();await new Promise(e=>setTimeout(e,100))}},D=({root:e,name:t},n,r)=>i(e,`var/.vite/${t}/${n}/${r}`),O=t=>{let n=[],r={};for(let e of t.config.generators||[])e.meta.slot?r[e.meta.slot]=e:n.push(e);return[e(),...r.backend?[r.backend]:[],...r.fetch&&r.backend?[r.fetch]:[],...r.frontend?[r.frontend]:[],...n,...r.ssr?[r.ssr]:[],...r.ssg?[r.ssg]:[]]},k=async e=>{let{resolvers:t,resolversFactory:n}=await u(e,C),{createPath:r}=l(e),i=[];for(let t of O(e)){let n=t.factory(e);i.push({name:t.meta.name,factory:n})}let o=new Map,s=async t=>{let n=Array.from(o.values());for(let{name:r,factory:o}of i)try{await o.watch?.(n,t)}catch(n){console.error(a(`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 o.set(e.entry.fileFullpath,e),e}catch(t){let i=n.replace(`${r.api()}/`,``);console.error(a(`red`,`${e.name}: ${i} route resolution failed`)),console.error(t);return}};{let n=d(`${e.name}: resolving routes`);for(let{name:e,handler:r}of t.values()){n.append(`[ ${o.size+1} of ${t.size} ] ${e}`);let i=await r();o.set(i.entry.fileFullpath,i)}n.succeed(`ready ✨`)}return await s(),{async add(e){let[r]=n([e]).values();r&&(t.set(e,r),await c(e)&&await s({kind:`create`,file:e}))},async change(e){if(o.has(e))await c(e);else{let t=o.values().flatMap(({kind:t,entry:n})=>t===`apiRoute`&&n.referencedFiles.includes(e)?[n]:[]);for(let e of t)await c(e.fileFullpath)}await s({kind:`update`,file:e})},async unlink(e){t.delete(e),o.delete(e),await s({kind:`delete`,file:e})}}},A=e=>e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`).replace(/\/+$/,``),j=({config:e})=>{let t=RegExp(`^${A(e.base)}(?=$|/)`),n=RegExp(`^${A(r(e.base,e.apiBase))}(?=$|/)`);return{base(e){return!n.test(e.url)&&t.test(e.url)},api(e){return n.test(e.url)}}},M=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 N(t)?t:void 0),Promise.resolve(void 0));if(!a)throw Error(`No free ports found in range ${t}-${n}`);return a},N=e=>new Promise(t=>{let n=b.createServer();n.once(`error`,()=>t(!1)),n.once(`listening`,()=>{n.close(),t(!0)}),n.listen(e,`127.0.0.1`)});export{E as default};
+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
+/**
+* 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;
+		}
+	};
+};
+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;
+};
+var identicalHashSum = (a, b) => {
+	return a === b;
+};
+//#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 * only node builtins are used here: `node:http` runs unchanged on Node, Bun and Deno.\n * */\n\nimport { chmod, readdir, readFile, unlink } 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 { pathToFileURL } from \"node:url\";\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\n    const { default: manifest } = await import(join(dir, \"kosmo.json\"), {\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, ssr } of folders) {\n    const aliasPatterns =\n      backend?.aliasPatterns.map((alias) => {\n        return pathToRegexp(posix.join(\"/\", alias)).regexp;\n      }) || [];\n\n    if (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      if (backend) {\n        handlers.push({\n          name,\n          base: backend.base,\n          aliasPatterns: aliasPatterns,\n          listener,\n        });\n      }\n\n      if (frontend) {\n        handlers.push({\n          name,\n          base: frontend?.base as string,\n          aliasPatterns: [],\n          listener,\n        });\n      }\n\n      continue;\n    }\n\n    if (backend) {\n      const { default: listener } = (await import(\n        pathToFileURL(join(dir, \"api\", \"listener.js\")).href\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 (pathToFileURL(process.argv[1] || \"\").href === 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 } } : {},
+		...backend?.base ? { backend: {
+			base: backend.base,
+			aliasPatterns: createAliasPatterns(backend?.alias)
+		} } : {},
+		ssr: frontend?.ssr ? true : false
+	};
+};
+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");
+};
+var runnerPath = ({ root, distDir }) => {
+	return resolve(root, distDir, "run.js");
+};
+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;
+};
+/**
+* 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;
+};
+//#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.map((sourceFolder) => {
+		const { createPath } = pathResolver(sourceFolder);
+		return {
+			dir: createPath.src(),
+			sourceFolder
+		};
+	});
+	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.config.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).start?.();
+		} catch (error) {
+			console.error(styleText("red", `${sourceFolder.name}: ${generator.meta.name} generator failed to initialize`));
+			throw error;
+		}
+	}
+	if (command === "build" || command === "preview") {
+		for (const sourceFolder of projectSettings.sourceFolders) {
+			await buildSourceFolder(sourceFolder);
+			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) eventMap[sourceFolder.name] = await eventFactory(sourceFolder);
+	let port = await findFreePort(devPort);
+	for (const sourceFolder of projectSettings.sourceFolders) {
+		const { createPath } = pathResolver(sourceFolder);
+		const { generators, frontend, backend } = sourceFolder.config;
+		const requestMatchers = matchersFactory(sourceFolder);
+		const plugins = [
+			vitePlugins.tsconfigPaths(sourceFolder),
+			vitePlugins.nodePrefix(),
+			vitePlugins.virtualModules(sourceFolder, {
+				kind: "csr",
+				command
+			})
+		];
+		if (frontend) {
+			const viteServer = await createServer(mergeConfigs(frontend?.viteConfig, ...generators.map(({ factory }) => {
+				return factory(sourceFolder).viteConfig?.({
+					kind: "client",
+					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 = 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: { api: { resolve: { conditions: ["node"] } } }
+			}));
+			const env = viteServer.environments.api;
+			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) {
+					/**
+					* A transiently-invalid module (half-saved file, atomic rewrite mid-flight, syntax error)
+					* must not take the dev server down: an uncaught rejection here is fatal to the whole process.
+					* Keep serving the previous api program; the next successful change reloads it.
+					* */
+					console.error(styleText("red", `${sourceFolder.name}: api reload failed - keeping previous api program`));
+					console.error(error);
+				}
+			});
+			requestHandlers.push([
+				backend.base,
+				() => devSetup.requestMatcher || requestMatchers.backend,
+				() => devSetup.requestHandler()
+			]);
+			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}`);
+};
+/**
+* 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 { generators, frontend, backend } = sourceFolder.config;
+	const resolvedRoutes = [];
+	{
+		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 generators) await generator.factory(sourceFolder).build?.(resolvedRoutes);
+	if (frontend) await build(mergeConfigs(frontend.viteConfig, ...generators.map(({ factory }) => {
+		return factory(sourceFolder).viteConfig?.({
+			kind: "client",
+			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 = 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")
+		}));
+	}
+	for (const generator of generators) await generator.factory(sourceFolder).postBuild?.(resolvedRoutes);
+};
+var eventFactory = async (sourceFolder) => {
+	const { resolvers, resolversFactory } = await routesFactory(sourceFolder, cacheFactory);
+	const { createPath } = pathResolver(sourceFolder);
+	const generators = [];
+	for (const generator of sourceFolder.config.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
+			});
+		}
+	};
+};
+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);
+		}
+	};
+};
+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 };
+
 //# sourceMappingURL=chassis.js.map