@voltro/cli 0.2.2 → 0.3.0

package/CHANGELOG.md

@@ -39,6 +39,26 @@ _Changes staged for the next release accumulate here (rolled up from
 
 ---
 
+## [0.3.0] — 2026-07-18
+
+### ⚠ BREAKING
+
+- **@voltro/cli** — `voltro build` precompiles the whole serve path (framework + effect + `@voltro` inlined, app modules as lazy chunks) into a single **serve bundle**, and `voltro serve` boots from it in-process — cutting `serve: ready` from ~1000 ms to ~180 ms (5–6×; the win is larger on a cold scale-to-zero container). The app's declared SQL driver is inlined (only the native leaf like `pg` stays external, resolved at runtime so it survives the deploy relocation). **Production now serves ONLY from the bundle and NEVER transpiles on demand:** the bundle build externalises unresolvable optional peers (e.g. `@react-email/render` behind `@voltro/plugin-mail`) so it always builds; a bundle-build failure is **fatal** (`voltro build` exits non-zero); and an unbuilt production `voltro serve` fails loud instead of falling back to tsx. The build toolchain (`tsx`, `esbuild`, `vite`, `@vitejs/plugin-react`, `@tailwindcss/vite` + their native tree: rolldown/lightningcss/postcss/jiti) moves to **`optionalDependencies`** of `@voltro/cli`, so `pnpm --prod --no-optional deploy` yields a serve image with none of it — a prod API image's `node_modules` drops ~305 MB → ~131 MB, structurally, with no fragile prune list. `voltro dev` and a non-production local `voltro serve` are unchanged (still tsx). **Migration:** in production (`NODE_ENV=production`) run `voltro build` before `voltro serve`. The generated Dockerfiles already do; a custom Dockerfile / start script adds a `voltro build .` step before `voltro serve .` (`voltro update` prints this — see the 0.3.0 codemod note).
+
+### Added
+
+- **@voltro/protocol, @voltro/runtime, @voltro/plugin-rbac** — Declarative authorization `guards:` on `defineMutation` / `defineQuery` / `defineAction`. The framework enforces the declared scope(s) in the dispatch spine BEFORE the executor (for a mutation, before the transaction opens), fails with a typed `ScopeError`, and auto-merges `ScopeError` into the wire error union so the client decodes the denial typed. Guards are browser-safe DATA (scope strings + a pure `resource: (input) => id` extractor). Checks run against the caller's EFFECTIVE scope set — raw subject scopes ∪ `@voltro/plugin-rbac` role-derived scopes — via a new canonical effective-scope seam in `@voltro/protocol` (`effectiveScopes` / `setEffectiveScopes` / `checkGuards`), which rbac now publishes to (so a role-granted scope satisfies a `guards:` entry and the in-handler `permission()` identically). Adds `ctx.access` (`has` / `hasAny` / `require` / `scopes`) — the cast-free typed authorization slice on every handler context. Enforcement is single-sourced in the shared serve pipeline, so `voltro dev` and `voltro serve` can't drift.
+- **@voltro/protocol, @voltro/client** — Nested / path-targeted auto-optimistic. A mutation `target` can now patch a nested array INSIDE a query's value — a JSON array column (`snapshot.projects`) or a computed/shaped result — at item granularity, via `path` (dot-path to the array), `by` (item key, default `id`), and `match` (a pure predicate that scopes the patch to the entries whose current value satisfies it, preventing a patch bleeding across sibling subscriptions that share a source table). Previously auto-optimistic only patched the flat top-level row array keyed by `id`; nested values needed a hand-written `.withOptimistic` reducer. `path`/`by`/`match` are browser-safe descriptor data (a dot-path string + pure predicate), same discipline as `identify`/`shape`. A path insert is applied even on a computed entry (it targets a known document, not a blind top-level add).
+- **@voltro/runtime** — `ctx.store.applyDefined(input, keys)` (and a standalone `applyDefined` export from `@voltro/runtime`) — builds a partial-update patch keeping only the listed keys whose value the caller actually provided (`!== undefined`; a defined falsy value like `0`/`''`/`false` is kept). Collapses the per-field `if (input.x !== undefined) patch.x = input.x` idiom every partial-update mutation hand-writes.
+- **@voltro/database** — `.uniqueActive([cols], opts?)` on the table builder — a portable partial-UNIQUE constraint that holds only among the rows matching a predicate (default `"deletedAt" IS NULL`, pairing with `.softDelete()`). Emits `CREATE UNIQUE INDEX … WHERE` on postgres / sqlite / mssql, so a soft-deleted row leaves the active set and a NEW row with the same key inserts cleanly — no hand-written `generatedAs("CASE WHEN …")` column and no resurrection footgun. On mysql / mariadb (no partial-index support) it FAILS LOUDLY at migrate time rather than silently emitting a full unique index that would forbid re-creating a soft-deleted key — the generated-STORED-column lowering for those dialects is a follow-up. Kept out of the declarative index snapshot (the incremental planner is predicate-blind and would misclassify a unique+partial index as a full constraint), so the fresh-schema DDL path is its sole emitter and there is no re-diff churn. Live-verified against postgres.
+- **@voltro/cli** — `voltro update` upgrades an app to the latest framework: it bumps every `@voltro/*` dependency, installs with the detected package manager, and runs the codemods shipped with the target version. Codemods are authored with `defineCodemod` + an import-scoped ts-morph helper toolkit (`renameImport`, `renameModuleSpecifier`, `renameJsxProp`, `renameObjectKey`, `add`/`removeImport`, structural `changeCallArgs`/`wrapCall`, `annotate`) and run against the app source; a `manual` kind surfaces written steps for changes that can't be automated. Breaking public-API changes now ship a codemod (or an explicit `codemod: none`), enforced by the changelog gate. Framework-owned `_voltro_*` table changes continue to ride the declarative differ on `voltro db apply` / `voltro dev` boot — `update` does not touch the database.
+
+### 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.
+
+---
+
 ## [0.2.2] — 2026-07-17
 
 ### Added

package/THIRD-PARTY-NOTICES.md

@@ -5,7 +5,7 @@ property of its respective copyright holders and is used under the terms of
 its license. This file is provided for attribution; it grants no rights in
 @voltro/cli itself, which is proprietary (see LICENSE).
 
-Generated from the resolved runtime dependency closure (191 packages).
+Generated from the resolved runtime dependency closure (198 packages).
 
 ---
 
@@ -10139,6 +10139,34 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
+## @ts-morph/common@0.29.0
+
+License: MIT
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2017 David Sherret
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
 ## @typespec/ts-http-runtime@0.3.5
 
 License: MIT
@@ -10490,6 +10518,36 @@ See the License for the specific language governing permissions and
 limitations under the License.
 ```
 
+## balanced-match@4.0.4
+
+License: MIT
+
+```
+(MIT)
+
+Original code Copyright Julian Gruber <julian@juliangruber.com>
+
+Port to TypeScript Copyright Isaac Z. Schlueter <i@izs.me>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
 ## base64-js@1.5.1
 
 License: MIT
@@ -10564,6 +10622,36 @@ programs and associated documentation files created by the
 Original Author, when distributed with the Software.
 ```
 
+## brace-expansion@5.0.6
+
+License: MIT
+
+```
+MIT License
+
+Copyright Julian Gruber <julian@juliangruber.com>
+
+TypeScript port Copyright Isaac Z. Schlueter <i@izs.me>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
 ## buffer@5.6.0
 
 License: MIT
@@ -10640,6 +10728,34 @@ See the License for the specific language governing permissions and
 limitations under the License.
 ```
 
+## code-block-writer@13.0.3
+
+License: MIT
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2015-2024 David Sherret
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
 ## debug@4.4.3
 
 License: MIT
@@ -12590,6 +12706,68 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ```
 
+## minimatch@10.2.3
+
+License: BlueOak-1.0.0
+
+```
+# Blue Oak Model License
+
+Version 1.0.0
+
+## Purpose
+
+This license gives everyone as much permission to work with
+this software as possible, while protecting contributors
+from liability.
+
+## Acceptance
+
+In order to receive this license, you must agree to its
+rules. The rules of this license are both obligations
+under that agreement and conditions to your license.
+You must not do anything with this software that triggers
+a rule that you cannot or will not follow.
+
+## Copyright
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe that contributor's
+copyright in it.
+
+## Notices
+
+You must ensure that everyone who gets a copy of
+any part of this software from you, with or without
+changes, also gets the text of this license or a link to
+<https://blueoakcouncil.org/license/1.0.0>.
+
+## Excuse
+
+If anyone notifies you in writing that you have not
+complied with [Notices](#notices), you can keep your
+license by taking all practical steps to comply within 30
+days after the notice. If you do not do so, your license
+ends immediately.
+
+## Patent
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe any patent claims
+they can license or become able to license.
+
+## Reliability
+
+No contributor can revoke this license.
+
+## No Liability
+
+**_As far as the law allows, this software comes as is,
+without any warranty or condition, and no contributor
+will be liable to anyone for any damages related to this
+software or this license, under any kind of legal claim._**
+```
+
 ## ms@2.1.3
 
 License: MIT
@@ -12823,6 +13001,33 @@ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 USE OR OTHER DEALINGS IN THE SOFTWARE.
 ```
 
+## path-browserify@1.0.1
+
+License: MIT
+
+```
+MIT License
+
+Copyright (c) 2013 James Halliday
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
 ## path-expression-matcher@1.5.0
 
 License: MIT
@@ -13982,6 +14187,34 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
+## ts-morph@28.0.0
+
+License: MIT
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2017 David Sherret
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
 ## tslib@2.8.1
 
 License: 0BSD

package/bin/voltro.mjs

@@ -1,4 +1,16 @@
 #!/usr/bin/env node
+// `framework` executable. `pnpm install` symlinks this into every
+// dependent package's `node_modules/.bin/framework`, so user apps invoke
+// it from their npm scripts as just `voltro dev` / `voltro serve`
+// — same UX as `next dev` or `vite`, without the user knowing the bin
+// lives in our monorepo's framework/ tree.
+//
+// Prefer the bundled, minified `dist/bin.js` (the published artifact);
+// fall back to the TypeScript `src/bin.ts` when running from the
+// monorepo before a build (dev). The tsx ESM loader stays registered in
+// BOTH modes because the CLI imports the USER's `app.config.ts` (and
+// other `.ts` app files) at runtime — Node cannot import those without
+// it. The public bin interface (`voltro <cmd>`) is unchanged.
 
 import { spawn } from 'node:child_process'
 import { existsSync } from 'node:fs'
@@ -6,6 +18,16 @@ import { createRequire } from 'node:module'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { dirname, join, resolve } from 'node:path'
 
+// FAST PATH — `voltro serve <app>` with a precompiled SERVE BUNDLE boots from that
+// ONE artefact IN THIS PROCESS: no child `node --import tsx`, no CLI command
+// graph. `voltro build` esbuilds the whole serve path (framework + effect +
+// @voltro inlined) into `.framework/dist-api/serveBundle/serveEntry.js` with the
+// app modules as lazy .js chunks — so tsx is UNNECESSARY (nothing loads `.ts` at
+// runtime) and the second node startup + the tsx loader hook are pure overhead on
+// a cold scale-to-zero boot. The bundle's exported `runServe` loads `.env` itself
+// (idempotent) so the boot is fully self-contained here. In PRODUCTION the bundle
+// is MANDATORY — a missing/unusable bundle fails loud (below), never on-demand
+// tsx. Only non-production falls through to the tsx spawn path (a dev convenience).
 const argv = process.argv.slice(2)
 if (argv[0] === 'serve') {
   const appArg = argv.slice(1).find((a) => !a.startsWith('-'))
@@ -13,6 +35,11 @@ if (argv[0] === 'serve') {
   const serveBundle = join(serveRoot, '.framework', 'dist-api', 'serveBundle', 'serveEntry.js')
   if (existsSync(serveBundle)) {
     try {
+      // chdir to the app root BEFORE importing the bundle: the bundle's generated
+      // entry registers its app-module keys from `process.cwd()` at import time, so
+      // cwd must already be the app root (the serve runtime resolves the same keys
+      // by walking the app tree). This is what makes the bundle relocation-safe —
+      // the Docker deploy moves the app from `apps/x/api` to the image root.
       if (serveRoot !== process.cwd()) process.chdir(serveRoot)
       const mod = await import(pathToFileURL(serveBundle).href)
       if (typeof mod.runServe === 'function') {
@@ -20,17 +47,42 @@ if (argv[0] === 'serve') {
         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)
+      // Unusable bundle — degrade to the standard tsx path, never crash the boot.
+      console.warn('[voltro] serve bundle failed to load:', error?.message ?? error)
     }
   }
+  // PRODUCTION MUST serve from the precompiled bundle — never transpile on demand.
+  // If we reach here in production the bundle is missing or unusable: FAIL LOUD
+  // instead of silently spawning the slow tsx path (which re-transpiles the app on
+  // every cold start, defeating the whole precompiled-boot optimisation). `voltro
+  // build` produces the bundle and treats a build failure as fatal, so a healthy
+  // deploy never hits this. Non-production (dev / an unbuilt local serve) falls
+  // through to the tsx path below — on-demand transpile is a DEV-only convenience.
+  if (process.env.NODE_ENV === 'production') {
+    console.error(
+      `[voltro] FATAL: production \`voltro serve\` requires a precompiled serve bundle at\n  ${serveBundle}\n` +
+        'but it is missing or failed to load. Run `voltro build` before serving — a bundle-build ' +
+        'failure is fatal by design; production never transpiles on demand.',
+    )
+    process.exit(1)
+  }
 }
 
 const here = dirname(fileURLToPath(import.meta.url))
 const built = resolve(here, '..', 'dist', 'bin.js')
 const entry = existsSync(built) ? built : resolve(here, '..', 'src', 'bin.ts')
 
+// Resolve the tsx ESM loader RELATIVE TO @voltro/cli (which depends on it) —
+// NOT the user app's CWD. As a bare `--import tsx`, Node resolves the specifier
+// from the current working directory; strict pnpm nests tsx inside @voltro/cli,
+// so from a consuming app's dir it isn't reachable and a standalone (non-
+// monorepo) install fails at `voltro dev` / `voltro build` with "Cannot find
+// package 'tsx'". Resolving to an absolute URL here sidesteps CWD resolution
+// entirely (the monorepo happened to hoist tsx, which hid this).
 let tsxImport = 'tsx'
 try {
+  // import.meta.resolve applies tsx's export map (the ESM auto-register entry);
+  // synchronous since Node 20.6.
   tsxImport = import.meta.resolve('tsx')
 } catch {
   try {
@@ -46,6 +98,11 @@ const child = spawn(
   { stdio: 'inherit' },
 )
 
+// Forward signals the parent receives to the child. Without this the
+// shim catches SIGTERM (e.g. from `kill $PID` in test-all.sh) and exits,
+// leaving the spawned Node child as an orphan still bound to its port.
+// Subsequent harness stages then fail to start their own server because
+// the port is held by the orphan.
 const forward = (signal) => () => {
   if (!child.killed) child.kill(signal)
 }
@@ -61,12 +118,25 @@ child.on('exit', (code, signal) => {
   process.exit(code ?? 0)
 })
 
+// Parent-death guard. When invoked from a smoke (or any wrapper) that
+// dies ungracefully — `process.exit(1)` skipping `finally`, kill -9,
+// IDE termination — we'd otherwise be reparented to init and keep our
+// tsx child alive holding the port. We watch our parent pid; when it
+// flips to 1 we forward SIGTERM to the child and exit. The 2s interval
+// gives the harness fast-enough orphan cleanup without burning a watch
+// loop per shim. The TSX child has its own ppid watch on US (the shim),
+// so this layer covers the case where the shim itself outlives its
+// parent; the inner layer covers the unusual case of the shim dying
+// while the tsx child somehow survives.
 const initialPpid = process.ppid
 if (initialPpid > 1) {
   const ppidWatch = setInterval(() => {
     if (process.ppid !== initialPpid || process.ppid === 1) {
       clearInterval(ppidWatch)
       if (!child.killed) child.kill('SIGTERM')
+      // Give the child a brief window to clean up + exit; if it doesn't,
+      // we exit anyway. The child's `on('exit')` above will route us out
+      // cleanly if it does.
       setTimeout(() => process.exit(0), 1500).unref()
     }
   }, 2000)

package/dist/apiBuild-DdgYydVJ.js

@@ -0,0 +1,193 @@
+import { Yt as e, d as t, et as n } from "./dev-x_VqbV_8.js";
+import { isAbsolute as r, join as i, relative as a, resolve as o } from "node:path";
+import { createLogger as s } from "@voltro/logger";
+import { existsSync as c, promises as l } from "node:fs";
+import { createRequire as u } from "node:module";
+//#region src/apiBuild.ts
+var d = s({ scope: "voltro:build" }), f = async (e) => {
+	let t = i(e, "package.json");
+	if (!c(t)) return [];
+	let r = {};
+	try {
+		let e = JSON.parse(await l.readFile(t, "utf8"));
+		r = {
+			...e.dependencies,
+			...e.devDependencies,
+			...e.optionalDependencies
+		};
+	} catch {
+		return [];
+	}
+	let a = u(t);
+	return n.filter((e) => {
+		if (r[e] === void 0) return !1;
+		try {
+			return a.resolve(e), !0;
+		} catch {
+			return !1;
+		}
+	});
+}, p = /(?:\.(?: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)$/, m = (e) => /\.(ts|tsx)$/.test(e) && !/\.(test|spec)\.[tj]sx?$/.test(e), h = async (e) => (await t(e)).filter((t) => p.test(t) && m(t) && !t.includes(`${e}/.framework/`)), g = {
+	name: "externalize-bare",
+	setup(e) {
+		e.onResolve({ filter: /.*/ }, (e) => {
+			let t = e.path;
+			if (!(t.startsWith(".") || r(t))) return {
+				path: t,
+				external: !0
+			};
+		});
+	}
+}, _ = async (t) => {
+	let n = await e("esbuild", () => import("esbuild")), r = i(t, ".framework"), s = i(r, "dist-api");
+	await l.mkdir(r, { recursive: !0 });
+	let u = [...await h(t)], f = i(t, "app.config.ts");
+	if (c(f) && u.push(f), u.length === 0) return d.warn("api build: no handlers or app.config found — nothing to precompile", { root: t }), null;
+	let p = i(t, "tsconfig.json"), _ = {
+		bundle: !0,
+		format: "esm",
+		platform: "node",
+		target: "node22",
+		logLevel: "silent",
+		jsx: "automatic",
+		jsxImportSource: "react",
+		absWorkingDir: t,
+		...c(p) ? { tsconfig: p } : {},
+		plugins: [g]
+	}, v = await n.build({
+		..._,
+		entryPoints: u,
+		write: !1,
+		metafile: !0,
+		outdir: s
+	}), y = Object.keys(v.metafile.inputs).map((e) => o(t, e)).filter((e) => e.startsWith(`${t}/`) && !e.includes("/node_modules/") && !e.includes("/.framework/") && m(e)), b = [
+		"// 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.",
+		""
+	], x = [];
+	y.forEach((e, n) => {
+		b.push(`import * as m${n} from ${JSON.stringify(e)}`), x.push(`  ${JSON.stringify(a(t, e))}: m${n},`);
+	}), b.push("", "export const modules: Record<string, unknown> = {", ...x, "}", "");
+	let S = i(r, "apiEntry.ts");
+	return await l.writeFile(S, b.join("\n"), "utf8"), await n.build({
+		..._,
+		entryPoints: [S],
+		outfile: i(s, "apiEntry.js"),
+		metafile: !1,
+		write: !0
+	}), d.info("api build: precompiled bundle written", {
+		modules: y.length,
+		out: i(".framework", "dist-api", "apiEntry.js")
+	}), i(s, "apiEntry.js");
+}, v = (e) => i(e, ".framework", "dist-api", "apiEntry.js"), y = [
+	"better-sqlite3",
+	"mysql2",
+	"tedious",
+	"pg",
+	"pg-native",
+	"@tursodatabase/*",
+	"@libsql/*",
+	"ioredis",
+	"@vlasky/zongji",
+	"nodemailer"
+], b = [
+	"tsx",
+	"esbuild",
+	"vite",
+	"@vitejs/*",
+	"@tailwindcss/*",
+	"rolldown",
+	"lightningcss"
+], x = (e, t) => t.some((t) => t.endsWith("/*") ? e === t.slice(0, -2) || e.startsWith(t.slice(0, -1)) : e === t || e.startsWith(`${t}/`)), S = (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`, C = (e, t, n) => ({
+	name: "native-leaf-runtime-resolver",
+	setup(a) {
+		a.onResolve({ filter: /.*/ }, (e) => {
+			let a = e.path;
+			if (!(a.startsWith(".") || r(a) || a.startsWith("node:"))) {
+				if (x(a, y)) return {
+					path: a,
+					namespace: "native-leaf"
+				};
+				if (x(a, b)) return {
+					path: a,
+					external: !0
+				};
+				for (let n of [e.resolveDir, t]) if (n) try {
+					u(i(n, "_.js")).resolve(a);
+					return;
+				} catch {}
+				return n.add(a), {
+					path: a,
+					external: !0
+				};
+			}
+		}), a.onLoad({
+			filter: /.*/,
+			namespace: "native-leaf"
+		}, (t) => ({
+			contents: S(t.path, e),
+			loader: "js"
+		}));
+	}
+}), w = (e) => i(e, ".framework", "dist-api", "serveBundle", "serveEntry.js"), T = async (t) => {
+	let n = await e("esbuild", () => import("esbuild")), r = i(t, ".framework"), s = i(r, "dist-api", "serveBundle");
+	await l.mkdir(r, { recursive: !0 });
+	let u = [...await h(t)], p = i(t, "app.config.ts");
+	if (c(p) && u.push(p), u.length === 0) return null;
+	let _ = i(t, "tsconfig.json"), v = await n.build({
+		entryPoints: u,
+		bundle: !0,
+		write: !1,
+		metafile: !0,
+		format: "esm",
+		platform: "node",
+		absWorkingDir: t,
+		jsx: "automatic",
+		jsxImportSource: "react",
+		logLevel: "silent",
+		plugins: [g],
+		outdir: i(s, ".probe"),
+		...c(_) ? { tsconfig: _ } : {}
+	}), y = Object.keys(v.metafile.inputs).map((e) => o(t, e)).filter((e) => e.startsWith(`${t}/`) && !e.includes("/node_modules/") && !e.includes("/.framework/") && m(e)), b = await f(t), x = /* @__PURE__ */ new Set(), S = [
+		"// 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'",
+		...b.map((e, t) => `import * as __drv${t} from ${JSON.stringify(e)}`),
+		"const __root = process.cwd()",
+		"registerAppModules({",
+		...y.map((e) => `  [__join(__root, ${JSON.stringify(a(t, e))})]: () => import(${JSON.stringify(e)}),`),
+		"})",
+		...b.map((e, t) => `registerDriver(${JSON.stringify(e)}, __drv${t})`),
+		"export const runServe = (args = []) => { loadDotEnv([]); return __runServe(args) }",
+		""
+	], w = i(r, "serveEntry.ts");
+	return await l.writeFile(w, S.join("\n"), "utf8"), await n.build({
+		entryPoints: [w],
+		bundle: !0,
+		format: "esm",
+		platform: "node",
+		target: "node22",
+		outdir: s,
+		splitting: !0,
+		write: !0,
+		plugins: [C(b, t, x)],
+		banner: { js: "import { createRequire as __voltroRequire } from 'node:module'; const require = __voltroRequire(import.meta.url);" },
+		jsx: "automatic",
+		jsxImportSource: "react",
+		logLevel: "silent",
+		absWorkingDir: t,
+		...c(_) ? { tsconfig: _ } : {}
+	}), d.info("api build: serve bundle written", {
+		appModules: y.length,
+		drivers: b.length > 0 ? b.join(", ") : "none (memory)",
+		...x.size > 0 ? { externalizedOptionalPeers: [...x].join(", ") } : {},
+		out: i(".framework", "dist-api", "serveBundle", "serveEntry.js")
+	}), i(s, "serveEntry.js");
+};
+//#endregion
+export { w as a, T as i, h as n, _ as r, v as t };

package/dist/apiBuild-cadmH8ca.js

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

package/dist/bin.js

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