@voltro/cli 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -39,6 +39,22 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.2.2] — 2026-07-17
+
+### Added
+
+- **@voltro/cli** — `voltro build` now precompiles the whole serve path (framework + effect + `@voltro` inlined, app modules as lazy chunks) into a single **serve bundle** (`.framework/dist-api/serveBundle/serveEntry.js`), and `voltro serve` boots from it in-process — no child `node --import tsx`, no CLI command graph, no per-module resolution of the ~2700-module framework graph. This cuts `serve: ready` from ~1000 ms to ~180 ms (~5–6×) on both driverless (memory) and driver-backed (postgres) apps; the win is larger on a cold scale-to-zero container where module resolution dominates. The app's declared SQL driver is inlined into the bundle so it shares the framework's single effect instance (only the native leaf like `pg` stays external, resolved at runtime so it survives the deploy relocation). Fully fallback-safe: a missing, stale, or corrupt bundle degrades to the standard tsx serve path, so it can never stop `voltro serve` from booting. Nothing to configure — building an API app produces the bundle and serving prefers it automatically.
+
+### Fixed
+
+- **@voltro/database** — The core-table registry (`registerCoreTables` / `requireActors` / `requireTenants`) now stores its state on a process-global `Symbol.for` singleton, the same mechanism the main table registry already uses — instead of module-local `let` bindings. Module-local state splits when the `@voltro/database` module is duplicated in a process (e.g. resolved through both the `.` and `./sql` entry points, or a bundled framework copy alongside an externally-resolved one): one instance's `registerCoreTables` becomes invisible to the instance that reads it, surfacing as a spurious `core 'actors' table not registered` at store construction. Pinning it to `globalThis` makes every copy share one store, matching the table registry's already-global behaviour.
+
+### Internal (no consumer-facing effect)
+
+- **@voltro/cli** — `appModuleLoader` now accepts lazy `() => import()` loaders alongside eager module namespaces (the eager path — today's `apiEntry.js` bundle — is unchanged). Groundwork for the serve bundle: app modules registered as lazy loaders evaluate on first `importAppModule` (during `runServe`, after `registerCoreTables`) rather than eagerly at bundle-import time. No consumer-facing effect on its own.
+
+---
+
 ## [0.2.1] — 2026-07-17
 
 ### Fixed

package/bin/voltro.mjs

@@ -4,7 +4,26 @@ import { spawn } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import { dirname, resolve } from 'node:path'
+import { dirname, join, resolve } from 'node:path'
+
+const argv = process.argv.slice(2)
+if (argv[0] === 'serve') {
+  const appArg = argv.slice(1).find((a) => !a.startsWith('-'))
+  const serveRoot = appArg ? resolve(process.cwd(), appArg) : process.cwd()
+  const serveBundle = join(serveRoot, '.framework', 'dist-api', 'serveBundle', 'serveEntry.js')
+  if (existsSync(serveBundle)) {
+    try {
+      if (serveRoot !== process.cwd()) process.chdir(serveRoot)
+      const mod = await import(pathToFileURL(serveBundle).href)
+      if (typeof mod.runServe === 'function') {
+        const code = await mod.runServe(argv.slice(1))
+        process.exit(typeof code === 'number' ? code : 0)
+      }
+    } catch (error) {
+      console.warn('[voltro] serve bundle failed to load — using the standard serve path:', error?.message ?? error)
+    }
+  }
+}
 
 const here = dirname(fileURLToPath(import.meta.url))
 const built = resolve(here, '..', 'dist', 'bin.js')

package/dist/apiBuild-OpZROja5.js

@@ -0,0 +1,2 @@
+import { i as e, r as t } from "./apiBuild-o70rjpVJ.js";
+export { t as runApiBuild, e as runServeBundleBuild };

package/dist/apiBuild-o70rjpVJ.js

@@ -0,0 +1,184 @@
+import { d as e, et as t } from "./dev--jHe1vcu.js";
+import { isAbsolute as n, join as r, relative as i, resolve as a } from "node:path";
+import { createLogger as o } from "@voltro/logger";
+import { existsSync as s, promises as c } from "node:fs";
+import { createRequire as l } from "node:module";
+//#region src/apiBuild.ts
+var u = o({ scope: "voltro:build" }), d = async (e) => {
+	let n = r(e, "package.json");
+	if (!s(n)) return [];
+	let i = {};
+	try {
+		let e = JSON.parse(await c.readFile(n, "utf8"));
+		i = {
+			...e.dependencies,
+			...e.devDependencies,
+			...e.optionalDependencies
+		};
+	} catch {
+		return [];
+	}
+	let a = l(n);
+	return t.filter((e) => {
+		if (i[e] === void 0) return !1;
+		try {
+			return a.resolve(e), !0;
+		} catch {
+			return !1;
+		}
+	});
+}, f = /(?:\.(?:query|mutation|action|stream)(?:\.server)?\.ts|\.workflow(?:\.server)?\.tsx|\.(?:subscribe|reaction|aggregate|agent|tool|webhook|cron|trigger)(?:\.server)?\.tsx?|\.(?:startup|seed)\.tsx?|\.(?:entity|schema|relations)\.ts|(?:^|\/)schema\.ts)$/, p = (e) => /\.(ts|tsx)$/.test(e) && !/\.(test|spec)\.[tj]sx?$/.test(e), m = async (t) => (await e(t)).filter((e) => f.test(e) && p(e) && !e.includes(`${t}/.framework/`)), h = {
+	name: "externalize-bare",
+	setup(e) {
+		e.onResolve({ filter: /.*/ }, (e) => {
+			let t = e.path;
+			if (!(t.startsWith(".") || n(t))) return {
+				path: t,
+				external: !0
+			};
+		});
+	}
+}, g = async (e) => {
+	let t = await import("esbuild"), n = r(e, ".framework"), o = r(n, "dist-api");
+	await c.mkdir(n, { recursive: !0 });
+	let l = [...await m(e)], d = r(e, "app.config.ts");
+	if (s(d) && l.push(d), l.length === 0) return u.warn("api build: no handlers or app.config found — nothing to precompile", { root: e }), null;
+	let f = r(e, "tsconfig.json"), g = {
+		bundle: !0,
+		format: "esm",
+		platform: "node",
+		target: "node22",
+		logLevel: "silent",
+		jsx: "automatic",
+		jsxImportSource: "react",
+		absWorkingDir: e,
+		...s(f) ? { tsconfig: f } : {},
+		plugins: [h]
+	}, _ = await t.build({
+		...g,
+		entryPoints: l,
+		write: !1,
+		metafile: !0,
+		outdir: o
+	}), v = Object.keys(_.metafile.inputs).map((t) => a(e, t)).filter((t) => t.startsWith(`${e}/`) && !t.includes("/node_modules/") && !t.includes("/.framework/") && p(t)), y = [
+		"// GENERATED BY `voltro build` — do not edit; overwritten on next build.",
+		"// Precompiled api entry: the single bundle the serve runtime loads instead",
+		"// of importing every handler/schema source at boot. See apiBuild.ts /",
+		"// appModuleLoader.ts.",
+		""
+	], b = [];
+	v.forEach((t, n) => {
+		y.push(`import * as m${n} from ${JSON.stringify(t)}`), b.push(`  ${JSON.stringify(i(e, t))}: m${n},`);
+	}), y.push("", "export const modules: Record<string, unknown> = {", ...b, "}", "");
+	let x = r(n, "apiEntry.ts");
+	return await c.writeFile(x, y.join("\n"), "utf8"), await t.build({
+		...g,
+		entryPoints: [x],
+		outfile: r(o, "apiEntry.js"),
+		metafile: !1,
+		write: !0
+	}), u.info("api build: precompiled bundle written", {
+		modules: v.length,
+		out: r(".framework", "dist-api", "apiEntry.js")
+	}), r(o, "apiEntry.js");
+}, _ = (e) => r(e, ".framework", "dist-api", "apiEntry.js"), v = [
+	"better-sqlite3",
+	"mysql2",
+	"tedious",
+	"pg",
+	"pg-native",
+	"@tursodatabase/*",
+	"@libsql/*",
+	"ioredis",
+	"@vlasky/zongji",
+	"nodemailer"
+], y = [
+	"tsx",
+	"esbuild",
+	"vite",
+	"@vitejs/*",
+	"@tailwindcss/*",
+	"rolldown",
+	"lightningcss"
+], b = (e, t) => t.some((t) => t.endsWith("/*") ? e === t.slice(0, -2) || e.startsWith(t.slice(0, -1)) : e === t || e.startsWith(`${t}/`)), x = (e, t) => `const { createRequire } = require('node:module')
+const { join } = require('node:path')
+const reqApp = createRequire(join(process.cwd(), 'package.json'))
+const drivers = ${JSON.stringify(t)}\nlet mod\nfor (const d of drivers) {\n  try { mod = createRequire(reqApp.resolve(d + '/package.json'))(${JSON.stringify(e)}); break } catch (e) {}\n}\nif (!mod) { try { mod = reqApp(${JSON.stringify(e)}) } catch (e) {} }\nif (!mod) mod = require(${JSON.stringify(e)})\nmodule.exports = mod\n`, S = (e) => ({
+	name: "native-leaf-runtime-resolver",
+	setup(t) {
+		t.onResolve({ filter: /.*/ }, (e) => {
+			let t = e.path;
+			if (!(t.startsWith(".") || n(t) || t.startsWith("node:"))) {
+				if (b(t, v)) return {
+					path: t,
+					namespace: "native-leaf"
+				};
+				if (b(t, y)) return {
+					path: t,
+					external: !0
+				};
+			}
+		}), t.onLoad({
+			filter: /.*/,
+			namespace: "native-leaf"
+		}, (t) => ({
+			contents: x(t.path, e),
+			loader: "js"
+		}));
+	}
+}), C = (e) => r(e, ".framework", "dist-api", "serveBundle", "serveEntry.js"), w = async (e) => {
+	let t = await import("esbuild"), n = r(e, ".framework"), o = r(n, "dist-api", "serveBundle");
+	await c.mkdir(n, { recursive: !0 });
+	let l = [...await m(e)], f = r(e, "app.config.ts");
+	if (s(f) && l.push(f), l.length === 0) return null;
+	let g = r(e, "tsconfig.json"), _ = await t.build({
+		entryPoints: l,
+		bundle: !0,
+		write: !1,
+		metafile: !0,
+		format: "esm",
+		platform: "node",
+		absWorkingDir: e,
+		jsx: "automatic",
+		jsxImportSource: "react",
+		logLevel: "silent",
+		plugins: [h],
+		outdir: r(o, ".probe"),
+		...s(g) ? { tsconfig: g } : {}
+	}), v = Object.keys(_.metafile.inputs).map((t) => a(e, t)).filter((t) => t.startsWith(`${e}/`) && !t.includes("/node_modules/") && !t.includes("/.framework/") && p(t)), y = await d(e), b = [
+		"// GENERATED BY `voltro build` — do not edit; overwritten on next build.",
+		"import { join as __join } from 'node:path'",
+		"import { runServe as __runServe, registerAppModules, registerDriver, loadDotEnv } from '@voltro/cli/serveEntry'",
+		...y.map((e, t) => `import * as __drv${t} from ${JSON.stringify(e)}`),
+		"const __root = process.cwd()",
+		"registerAppModules({",
+		...v.map((t) => `  [__join(__root, ${JSON.stringify(i(e, t))})]: () => import(${JSON.stringify(t)}),`),
+		"})",
+		...y.map((e, t) => `registerDriver(${JSON.stringify(e)}, __drv${t})`),
+		"export const runServe = (args = []) => { loadDotEnv([]); return __runServe(args) }",
+		""
+	], x = r(n, "serveEntry.ts");
+	return await c.writeFile(x, b.join("\n"), "utf8"), await t.build({
+		entryPoints: [x],
+		bundle: !0,
+		format: "esm",
+		platform: "node",
+		target: "node22",
+		outdir: o,
+		splitting: !0,
+		write: !0,
+		plugins: [S(y)],
+		banner: { js: "import { createRequire as __voltroRequire } from 'node:module'; const require = __voltroRequire(import.meta.url);" },
+		jsx: "automatic",
+		jsxImportSource: "react",
+		logLevel: "silent",
+		absWorkingDir: e,
+		...s(g) ? { tsconfig: g } : {}
+	}), u.info("api build: serve bundle written", {
+		appModules: v.length,
+		drivers: y.length > 0 ? y.join(", ") : "none (memory)",
+		out: r(".framework", "dist-api", "serveBundle", "serveEntry.js")
+	}), r(o, "serveEntry.js");
+};
+//#endregion
+export { C as a, w as i, m as n, g as r, _ as t };

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { Ot as e } from "./dev-BGYmeKEx.js";
-import { n as t } from "./commands-BgOfGwLc.js";
+import { At as e } from "./dev--jHe1vcu.js";
+import { n as t } from "./commands-DQy4812j.js";
 import { createLogger as n } from "@voltro/logger";
 //#region src/bin.ts
 var r = n({ scope: "voltro:cli" }), i = process.argv.slice(2);