@voltro/cli 0.33.0 → 0.35.0

package/dist/newCommand-COWOJ1_E.js

@@ -0,0 +1,156 @@
+import { i as e, n as t, r as n } from "./cliArgs-D4p8n7EE.js";
+import { dirname as r, join as i, resolve as a } from "node:path";
+import { existsSync as o, mkdirSync as s, writeFileSync as c } from "node:fs";
+//#region src/newCommand.ts
+var l = [
+	"query",
+	"mutation",
+	"action",
+	"workflow",
+	"page"
+], u = (e) => {
+	let t = e.split(/[^A-Za-z0-9]+/).filter((e) => e.length > 0);
+	if (t.length === 0) return "handler";
+	let n = t[0] + t.slice(1).map((e) => e[0].toUpperCase() + e.slice(1)).join("");
+	return /^[0-9]/.test(n) ? `p${n[0].toUpperCase()}${n.slice(1)}` : n;
+}, d = (e) => e.replace(/\//g, ".").replace(/[^A-Za-z0-9.]/g, "-"), f = (e) => {
+	let t = u(e), n = d(e);
+	return [{
+		rel: `${n}.query.ts`,
+		content: `import { defineQuery } from '@voltro/protocol'
+import { Schema } from 'effect'
+
+// DESCRIPTOR (browser-safe): imports only @voltro/protocol + effect. The web
+// client value-imports this, so it must reach NOTHING server-only.
+export const ${t} = defineQuery({
+  name: '${e}',
+  input: Schema.Struct({}),
+  output: Schema.Array(Schema.Struct({
+    id: Schema.String,
+  })),
+})
+`
+	}, {
+		rel: `${n}.query.server.ts`,
+		content: "import type { AppContext } from '@voltro/runtime'\n\n// EXECUTOR (server-only): paired to the descriptor by filename. Read through\n// `ctx.store` and return rows matching the descriptor's `output` schema.\nconst execute = async (_input: Record<string, never>, ctx: AppContext) => {\n  void ctx // TODO: query ctx.store\n  return [] as ReadonlyArray<{ id: string }>\n}\n\nexport default execute\n"
+	}];
+}, p = (e) => {
+	let t = u(e), n = d(e);
+	return [{
+		rel: `${n}.mutation.ts`,
+		content: `import { defineMutation } from '@voltro/protocol'
+import { Schema } from 'effect'
+
+// DESCRIPTOR (browser-safe): imports only @voltro/protocol + effect.
+export const ${t} = defineMutation({
+  name: '${e}',
+  input: Schema.Struct({
+    // TODO: the fields the caller sends.
+  }),
+  output: Schema.Struct({
+    id: Schema.String,
+  }),
+})
+`
+	}, {
+		rel: `${n}.mutation.server.ts`,
+		content: "import type { AppContext } from '@voltro/runtime'\n\n// EXECUTOR (server-only): perform the write via `ctx.store` and return the row.\nconst execute = async (input: Record<string, never>, ctx: AppContext) => {\n  void input\n  void ctx // TODO: ctx.store.insert(...) / update(...)\n  return { id: '' }\n}\n\nexport default execute\n"
+	}];
+}, m = (e) => {
+	let t = u(e), n = d(e);
+	return [{
+		rel: `${n}.action.ts`,
+		content: `import { defineAction } from '@voltro/protocol'
+import { Schema } from 'effect'
+
+// DESCRIPTOR (browser-safe): an action is a free-form server call (no declared
+// store target). Imports only @voltro/protocol + effect.
+export const ${t} = defineAction({
+  name: '${e}',
+  input: Schema.Struct({}),
+  output: Schema.Struct({
+    ok: Schema.Boolean,
+  }),
+})
+`
+	}, {
+		rel: `${n}.action.server.ts`,
+		content: "import type { AppContext } from '@voltro/runtime'\n\n// EXECUTOR (server-only): do the work and return a value matching `output`.\nconst execute = async (_input: Record<string, never>, ctx: AppContext) => {\n  void ctx // TODO\n  return { ok: true }\n}\n\nexport default execute\n"
+	}];
+}, h = (e) => {
+	let t = u(e), n = d(e), r = t[0].toUpperCase() + t.slice(1);
+	return [{
+		rel: `${n}.workflow.tsx`,
+		content: `import { workflow } from '@voltro/workflow/define'
+import { Schema } from 'effect'
+
+// DESCRIPTOR (browser-safe): imports the '@voltro/workflow/define' contract
+// surface ONLY — never the executor's server graph, which would drag
+// database/cluster into the client bundle.
+export const ${r} = workflow({
+  name: '${e}',
+  payload: {
+    id: Schema.String,
+  },
+  success: Schema.Struct({
+    id: Schema.String,
+  }),
+})
+`
+	}, {
+		rel: `${n}.workflow.server.tsx`,
+		content: "import { step } from '@voltro/workflow'\nimport { Effect, Schema } from 'effect'\nimport type { AppContext } from '@voltro/runtime'\n\n// EXECUTOR (server-only): a factory `(ctx) => execute`. The CLI calls\n// `workflow.toLayer(execute)` at boot so the run closes over the live AppContext.\n// Every `step` is durable — replayed from its journaled result on resume.\nconst buildExecute = (ctx: AppContext) =>\n  (payload: { id: string }, _executionId: string) =>\n    Effect.gen(function* () {\n      void ctx // TODO: real work via ctx.store / ctx.events\n      yield* step({\n        name: 'first-step',\n        input: { id: payload.id },\n        success: Schema.Struct({ id: Schema.String }),\n        execute: Effect.succeed({ id: payload.id }),\n      })\n      return { id: payload.id }\n    })\n\nexport default buildExecute\n"
+	}];
+}, g = (e) => {
+	let t = d(e).replace(/\./g, "/");
+	return [{
+		rel: e === "" || e === "index" ? "page.tsx" : `${t}/page.tsx`,
+		content: `import type { ReactNode } from 'react'
+import type { PageMeta } from '@voltro/web'
+
+// Mounted at the URL derived from this file's path under src/pages/.
+export const meta = (): PageMeta => ({
+  title: '${e || "Home"}',
+})
+
+export default function Page(): ReactNode {
+  return (
+    <main>
+      <h1>${e || "Home"}</h1>
+    </main>
+  )
+}
+`
+	}];
+}, _ = (e, t) => {
+	switch (e) {
+		case "query": return f(t);
+		case "mutation": return p(t);
+		case "action": return m(t);
+		case "workflow": return h(t);
+		case "page": return g(t);
+		default: return null;
+	}
+}, v = () => {
+	console.error("voltro new <kind> <name> [--dir <path>] [--force]"), console.error(`  kinds: ${l.join(", ")}`), console.error("  e.g.:  voltro new query notes.list"), console.error("         voltro new workflow orders.fulfill --dir workflows");
+}, y = ["--dir"], b = async (u) => {
+	let d = e(u, y), f = d[0], p = d[1] ?? "";
+	if (f === void 0) return v(), 1;
+	if (!l.includes(f)) return console.error(`voltro new: unknown kind '${f}'.`), v(), 1;
+	if (p === "" && f !== "page") return console.error(`voltro new ${f}: a name is required, e.g. \`voltro new ${f} notes.list\`.`), 1;
+	let m = _(f, p);
+	if (m === null) return v(), 1;
+	let h = a(t(u, "--dir") ?? "."), g = n(u, "--force"), b = m.map((e) => i(h, e.rel)).filter((e) => o(e));
+	if (b.length > 0 && !g) {
+		console.error("voltro new: refusing to overwrite existing file(s) (use --force):");
+		for (let e of b) console.error(`    ${e}`);
+		return 1;
+	}
+	for (let e of m) {
+		let t = i(h, e.rel);
+		s(r(t), { recursive: !0 }), c(t, e.content, "utf8"), console.log(`  created ${t}`);
+	}
+	return console.log(`\nvoltro new ${f}: ${m.length} file(s) written. Fill in the TODOs, then \`voltro dev\` picks them up.`), 0;
+};
+//#endregion
+export { b as runNewCommand };

package/dist/nodeEnvironment-cGFAj1J8.js

@@ -0,0 +1,28 @@
+//#region bin/nodeEnvironment.mjs
+var e = Object.freeze({
+	serve: "production",
+	start: "production",
+	db: "production",
+	migrate: "production",
+	dev: "development"
+}), t = (e) => typeof e == "string" && e.length > 0, n = (e) => {
+	for (let t of e ?? []) if (typeof t == "string" && !t.startsWith("-")) return t.toLowerCase();
+}, r = (r, i) => {
+	let a = i ?? process.env;
+	if (t(a.NODE_ENV)) return a.NODE_ENV.toLowerCase();
+	let o = n(r);
+	if (o !== void 0) return e[o];
+}, i = !1, a = () => i, o = (e, n) => {
+	let a = n ?? process.env;
+	if (t(a.NODE_ENV)) return a.NODE_ENV.toLowerCase();
+	let o = r(e, a);
+	if (o !== void 0) return a.NODE_ENV = o, i = !0, o;
+}, s = (e = process.env) => {
+	let t = (e.NODE_ENV ?? "").toLowerCase();
+	return t === "production" ? "prod" : t === "staging" ? "staging" : "dev";
+}, c = (e = process.env) => {
+	let t = (e.NODE_ENV ?? "").toLowerCase();
+	return t === "production" || t === "staging";
+}, l = () => a() ? "\n  NODE_ENV was not set, so this run resolved to PRODUCTION — the same way `voltro serve`\n  resolves it, which is what keeps the declared schema of a pre-deploy job identical to\n  the serving container's. Set NODE_ENV=development for a local database." : "", u = (e) => o([e]);
+//#endregion
+export { o as a, c as i, l as n, s as r, u as t };

package/dist/packageCommand-Cug_3Ogl.js

@@ -0,0 +1,271 @@
+import { i as e, n as t } from "./cliArgs-D4p8n7EE.js";
+import { dirname as n, isAbsolute as r, join as i, relative as a, resolve as o } from "node:path";
+import { existsSync as s, mkdirSync as c, promises as l, readFileSync as u } from "node:fs";
+import { createLogger as d } from "@voltro/logger";
+import { spawnSync as f } from "node:child_process";
+//#region src/packageCommand.ts
+var p = d({ scope: "voltro:package" }), m = (e) => {
+	let t = [], n = !1;
+	for (let r of e.split("\n")) {
+		let e = r.replace(/#.*$/, "");
+		if (/^packages:\s*$/.test(e)) {
+			n = !0;
+			continue;
+		}
+		if (n) {
+			let r = e.match(/^\s*-\s*['"]?([^'"]+?)['"]?\s*$/);
+			if (r) {
+				t.push(r[1]);
+				continue;
+			}
+			/^\S/.test(e) && (n = !1);
+		}
+	}
+	return t;
+}, h = (e) => {
+	if (typeof e != "string") return null;
+	let t = e.match(/^(@[^/]+)\//);
+	return t ? t[1] : null;
+}, g = (e) => {
+	let t = o(e);
+	for (let e = 0; e < 16; e++) {
+		let e = i(t, "pnpm-workspace.yaml"), r = i(t, "package.json"), a = null;
+		if (s(r)) try {
+			a = JSON.parse(u(r, "utf8"));
+		} catch {
+			a = null;
+		}
+		if (s(e)) {
+			let n = [];
+			try {
+				n = m(u(e, "utf8"));
+			} catch {
+				n = [];
+			}
+			return {
+				root: t,
+				kind: "pnpm",
+				globs: n,
+				scope: h(a?.name)
+			};
+		}
+		if (a && Array.isArray(a.workspaces)) return {
+			root: t,
+			kind: "npm",
+			globs: a.workspaces.filter((e) => typeof e == "string"),
+			scope: h(a.name)
+		};
+		if (a && typeof a.workspaces == "object" && a.workspaces !== null && Array.isArray(a.workspaces.packages)) return {
+			root: t,
+			kind: "npm",
+			globs: a.workspaces.packages.filter((e) => typeof e == "string"),
+			scope: h(a.name)
+		};
+		let o = n(t);
+		if (o === t) break;
+		t = o;
+	}
+	return null;
+}, _ = (e, t) => {
+	let r = n(t);
+	return e.some((e) => {
+		let n = e.replace(/\/+$/, "");
+		return n === t || n === `${r}/*` || n === `${r}/**` || n === "*" || n === "**";
+	});
+}, v = "0.1.0", y = "vite build", b = "@voltro/build", x = "SEE LICENSE IN LICENSE", S = (e, t) => t.publishable ? `{
+  "extends": "${e}/tsconfig.base.json",
+  "compilerOptions": { "rootDir": "src", "outDir": "dist" },
+  "include": ["src/**/*"]
+}
+` : `{
+  "extends": "${e}/tsconfig.base.json",
+  "compilerOptions": { "noEmit": true },
+  "include": ["src"]
+}
+`, C = (e) => {
+	let t = (e) => {
+		let t = e.match(/^\.\/src\/(.+)\.tsx?$/);
+		if (!t) return null;
+		let n = t[1];
+		return {
+			types: `./dist/${n}.d.ts`,
+			import: `./dist/${n}.js`,
+			default: `./dist/${n}.js`
+		};
+	};
+	if (typeof e == "string") return t(e) ?? e;
+	if (e && typeof e == "object") {
+		let n = {};
+		for (let [r, i] of Object.entries(e)) typeof i == "string" ? n[r] = t(i) ?? i : n[r] = i;
+		return n;
+	}
+	return e;
+}, w = (e, t = {}) => {
+	let n = { ...e };
+	delete n.private, !n.version || n.version === "0.0.0" ? n.version = t.version ?? v : t.version && (n.version = t.version), n.files = ["dist", "src"], n.sideEffects = !1, n.publishConfig = {
+		access: t.access ?? "public",
+		exports: C(n.exports),
+		main: "./dist/index.js",
+		module: "./dist/index.js",
+		types: "./dist/index.d.ts"
+	};
+	let r = { ...n.scripts ?? {} };
+	return r.build = y, r.prepack = y, n.scripts = r, n;
+}, T = (e) => {
+	let t = { ...e };
+	if (t.private = !0, delete t.files, delete t.publishConfig, delete t.sideEffects, t.scripts) {
+		let e = { ...t.scripts };
+		delete e.prepack, t.scripts = e;
+	}
+	return t;
+}, E = (e) => e.private !== !0 && !!e.publishConfig, D = (e, t = "workspace:*") => {
+	if (e.name === b) return e;
+	let n = { ...e.devDependencies ?? {} };
+	return n[b] || (n[b] = t), {
+		...e,
+		devDependencies: n
+	};
+}, O = async (e) => JSON.parse(await l.readFile(e, "utf8")), k = async (e, t) => {
+	await l.writeFile(e, JSON.stringify(t, null, 2) + "\n", "utf8");
+}, A = "import { voltroLib } from '@voltro/build'\n\n// Library build preset (Vite lib mode): bundles this package's own `.ts`\n// files, keeps every bare specifier (effect, @effect/*, @voltro/*, react,\n// drivers) external, emits `.d.ts`. Multi-export packages pass an entry map:\n// voltroLib({ entry: { index: 'src/index.ts', server: 'src/server.ts' } }).\nexport default voltroLib()\n", j = (e) => {
+	if (!e || typeof e != "object") return null;
+	let t = {};
+	for (let n of Object.values(e)) {
+		if (typeof n != "string") continue;
+		let e = n.match(/^\.\/src\/(.+)\.tsx?$/);
+		e && (t[e[1]] = n.replace(/^\.\//, ""));
+	}
+	let n = Object.keys(t);
+	return n.length === 0 || n.length === 1 && n[0] === "index" ? null : t;
+}, M = async (e, t) => {
+	let n = i(e, "vite.config.ts");
+	if (s(n)) return !1;
+	let r = j(t), a = r ? `import { voltroLib } from '@voltro/build'\n\nexport default voltroLib({ entry: ${JSON.stringify(r)} })\n` : A;
+	return await l.writeFile(n, a, "utf8"), !0;
+}, N = async (e, t) => {
+	let n = i(e, "LICENSE");
+	if (s(n)) return !0;
+	let r = i(t.root, "LICENSE");
+	return s(r) ? (await l.copyFile(r, n), !0) : !1;
+}, P = async (e, t) => {
+	let n = i(e, "tsconfig.json"), r = a(e, t.root) || ".";
+	if (!s(n)) {
+		await l.writeFile(n, S(r, { publishable: !0 }), "utf8");
+		return;
+	}
+	try {
+		let e = JSON.parse(await l.readFile(n, "utf8")), t = { ...e.compilerOptions ?? {} };
+		delete t.noEmit, t.rootDir = "src", t.outDir = "dist", e.compilerOptions = t, await l.writeFile(n, JSON.stringify(e, null, 2) + "\n", "utf8");
+	} catch {
+		p.warn(`could not patch ${a(t.root, e) || "."}/tsconfig.json — set compilerOptions.rootDir:"src" + outDir:"dist" (drop noEmit) so the publishable build emits to ./dist`);
+	}
+}, F = (e) => {
+	let t = i(e.root, "scripts", "gen-api-extractor.mjs");
+	if (!s(t)) return null;
+	let n = f(process.execPath, [t], {
+		cwd: e.root,
+		encoding: "utf8"
+	}), r = (e) => e.trim().split("\n").filter(Boolean).pop() ?? "";
+	return n.status === 0 ? r(n.stdout || "") || "wired" : `FAILED — run \`node scripts/gen-api-extractor.mjs\` manually (${r(n.stderr || n.stdout || "") || "unknown error"})`;
+}, I = (e, t) => {
+	let a = r(t) ? t : o(process.cwd(), t);
+	if (s(i(a, "package.json"))) return a;
+	let c = t.replace(/^@[^/]+\//, ""), l = /* @__PURE__ */ new Set(["packages"]);
+	for (let t of e.globs) {
+		let e = n(t.replace(/\/+$/, ""));
+		e && e !== "." && l.add(e);
+	}
+	for (let t of l) {
+		let n = i(e.root, t, c);
+		if (s(i(n, "package.json"))) return n;
+	}
+	return null;
+}, L = (e, n) => t(e, `--${n}`), R = [
+	"--dir",
+	"--scope",
+	"--description",
+	"--version",
+	"--access"
+], z = (e, t) => e.includes(`--${t}`), B = /^[a-z][a-z0-9-]*$/, V = async (t) => {
+	let n = e(t, R)[0];
+	if (!n) return p.error("usage: voltro package create <name> [--publishable] [--dir <reldir>] [--scope <@scope>]"), 2;
+	let r = n.replace(/^@[^/]+\//, "");
+	if (!B.test(r)) return p.error(`invalid package name: ${r}`, { rule: "lowercase kebab-case (npm forbids uppercase): ^[a-z][a-z0-9-]*$" }), 2;
+	let o = g(process.cwd());
+	if (!o) return p.error("no workspace root found (looked for pnpm-workspace.yaml or a package.json with \"workspaces\")", {
+		cwd: process.cwd(),
+		hint: "run inside a workspace, or create one first"
+	}), 2;
+	let u = L(t, "dir") ?? "packages", d = L(t, "scope") ?? n.match(/^(@[^/]+)\//)?.[1] ?? o.scope, f = d ? `${d}/${r}` : r, m = L(t, "description") ?? `${f} package`, h = z(t, "publishable"), v = i(u, r), y = i(o.root, v);
+	if (s(y)) return p.error(`target already exists: ${v}`, { abs: y }), 1;
+	c(i(y, "src"), { recursive: !0 });
+	let b = {
+		name: f,
+		version: "0.0.0",
+		private: !0,
+		type: "module",
+		description: m,
+		exports: { ".": "./src/index.ts" },
+		scripts: {
+			typecheck: "tsc --noEmit",
+			test: "vitest run"
+		},
+		devDependencies: {
+			typescript: "^5.7.0",
+			vitest: "^3.0.0"
+		}
+	}, C = h && s(i(o.root, "LICENSE"));
+	h && (b = D(w(b, {})), C && (b.license = x)), await k(i(y, "package.json"), b), await l.writeFile(i(y, "tsconfig.json"), S(a(y, o.root) || ".", { publishable: h }), "utf8");
+	let T = null, E = !1;
+	return h && (await M(y, b.exports), E = await N(y, o), T = F(o)), await l.writeFile(i(y, "src", "index.ts"), `// ${f}\n\nexport const ${W(r)} = (): string => '${f}'\n`, "utf8"), await l.writeFile(i(y, "README.md"), `# ${f}\n\n${m}\n`, "utf8"), console.log(), console.log(`Created package: ${f}`), console.log(`  path:        ${v}`), console.log(`  mode:        ${h ? "publishable (npm-ready)" : "private (in-workspace source)"}`), h ? (E && console.log("  license:     LICENSE copied from workspace root"), T && console.log(`  api-extract: ${T}`), console.log(`  publish via: pnpm --filter ${f} publish   (runs vite build via prepack)`)) : console.log(`  make publishable later:  voltro package publishable ${r}`), _(o.globs, v) || (console.log(), p.warn(`workspace globs may not cover ${v}`, {
+		globs: o.globs,
+		hint: o.kind === "pnpm" ? `add '- "${u}/*"' under packages: in pnpm-workspace.yaml` : `add "${u}/*" to "workspaces" in the root package.json`
+	})), 0;
+}, H = async (t, n) => {
+	let r = e(t, R)[0];
+	if (!r) return p.error(`usage: voltro package ${n} <name|path>`), 2;
+	let a = g(process.cwd());
+	if (!a) return p.error("no workspace root found", { cwd: process.cwd() }), 2;
+	let o = I(a, r);
+	if (!o) return p.error(`package not found: ${r}`, { hint: "pass a bare name (resolved under packages/) or a path to the package dir" }), 1;
+	let c = i(o, "package.json"), l = await O(c), u = E(l);
+	if (n === "publishable") {
+		let e = L(t, "version"), n = L(t, "access"), d = D(w(l, {
+			...e ? { version: e } : {},
+			...n ? { access: n } : {}
+		}));
+		s(i(a.root, "LICENSE")) && (d.license = x), await k(c, d);
+		let f = await M(o, l.exports);
+		await P(o, a);
+		let p = await N(o, a), m = F(a);
+		return console.log(), console.log(`${l.name ?? r} → publishable${u ? " (already was; refreshed)" : ""}`), console.log(`  version:       ${d.version}`), console.log("  build:         vite build (via @voltro/build preset)"), console.log("  publishConfig: exports/main/types → ./dist (dev exports unchanged)"), console.log("  tsconfig:      rootDir:\"src\" + outDir:\"dist\" (emits to ./dist)"), f && console.log("  wrote:         vite.config.ts"), p && console.log("  license:       LICENSE copied from workspace root"), m && console.log(`  api-extract:   ${m}`), console.log(`  publish via:   pnpm --filter ${d.name} publish`), 0;
+	} else return await k(c, T(l)), console.log(), console.log(`${l.name ?? r} → private (in-workspace source)${u ? "" : " (already was)"}`), console.log("  private: true; publishConfig/files/prepack removed; exports unchanged"), 0;
+}, U = async (t) => {
+	let n = g(process.cwd());
+	if (!n) return p.error("no workspace root found", { cwd: process.cwd() }), 2;
+	let r = e(t, R)[0] ?? process.cwd(), o = I(n, r);
+	if (!o) return p.error(`package not found: ${r}`), 1;
+	let c = await O(i(o, "package.json")), l = E(c) ? "publishable" : "private";
+	return console.log(`package:  ${c.name ?? "(unnamed)"}`), console.log(`path:     ${a(n.root, o) || "."}`), console.log(`version:  ${c.version ?? "(none)"}`), console.log(`mode:     ${l}`), console.log(`private:  ${c.private === !0}`), console.log(`build:    ${s(i(o, "vite.config.ts")) ? "vite.config.ts present" : "no vite.config.ts"}`), 0;
+}, W = (e) => e.replace(/-([a-z0-9])/g, (e, t) => t.toUpperCase()), G = () => {
+	console.log("voltro package <subcommand>"), console.log(), console.log("Subcommands:"), console.log("  create <name> [--publishable]   Scaffold a new workspace package."), console.log("    [--dir <reldir>]                Parent dir (default: packages)."), console.log("    [--scope <@scope>]              Package scope (default: root pkg scope)."), console.log("  publishable <name|path>         Convert a package → publishable (npm-ready)."), console.log("    [--version <semver>] [--access public|restricted]"), console.log("  private <name|path>             Convert a package → non-publishable (source)."), console.log("  status [<name|path>]            Show a package's current mode."), console.log("  help"), console.log(), console.log("The publishable<->private toggle is lossless & reversible: it only"), console.log("adds/removes publishConfig + files + private + build/prepack scripts."), console.log("The dev-facing `exports` (./src/index.ts) never changes, so the"), console.log("in-workspace dev loop is identical in both modes. Publish via pnpm"), console.log("(its publishConfig.exports override + workspace: rewriting are what"), console.log("make the ./dist tarball shape work).");
+}, K = async (e) => {
+	let t = e[0];
+	if (!t || t === "help" || t === "--help" || t === "-h") return G(), +!t;
+	let n = e.slice(1);
+	switch (t) {
+		case "create": return V(n);
+		case "publishable": return H(n, "publishable");
+		case "private": return H(n, "private");
+		case "status": return U(n);
+		default: return p.error(`unknown subcommand: ${t}`, { valid: [
+			"create",
+			"publishable",
+			"private",
+			"status",
+			"help"
+		] }), 2;
+	}
+}, q = async (e) => V(e);
+//#endregion
+export { q as runCreatePackage, K as runPackageCommand };

package/dist/pageConvention-cEiRxdab.js

@@ -0,0 +1,5 @@
+import { T as e } from "./fileConventions-Cof68_BL.js";
+//#region src/pageConvention.ts
+var t = (t) => e.test(t), n = (e) => e.replace(/page\.tsx$/, "page.test.tsx");
+//#endregion
+export { n, t };

package/dist/privacyCommand-C-Df56U_.js

@@ -0,0 +1,146 @@
+import { t as e } from "./cliError-BmdYnghb.js";
+import { i as t, n, t as r } from "./cliArgs-D4p8n7EE.js";
+import { b as i, y as a } from "./fileConventions-Cof68_BL.js";
+import { n as o } from "./cliOutput-D1tSBoRM.js";
+import { join as s, resolve as c } from "node:path";
+import { promises as l } from "node:fs";
+import { pathToFileURL as u } from "node:url";
+import { createLogger as d } from "@voltro/logger";
+import { clearRelationsRegistry as f, deriveSubjectGraph as p, ensureTableRegistered as m, formatSubjectGraph as h, registerDiscoveredRelations as g } from "@voltro/database";
+//#region src/privacyCommand.ts
+var _ = d({ scope: "voltro:privacy" }), v = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".turbo",
+	".vite",
+	".next",
+	".git",
+	".framework"
+]), y = [
+	"--depth",
+	"--exclude",
+	"--mode",
+	"--out",
+	"--root",
+	"--subject-table",
+	"--token",
+	"--url"
+], b = async (e, t) => {
+	let n = [], r = async (e) => {
+		let i = await l.readdir(e, { withFileTypes: !0 }).catch(() => []);
+		for (let a of i) {
+			if (v.has(a.name) || a.name.startsWith(".")) continue;
+			let i = s(e, a.name);
+			a.isDirectory() ? await r(i) : a.isFile() && t.test(a.name) && n.push(i);
+		}
+	};
+	return await r(e), n;
+}, x = (e) => typeof e == "object" && !!e && "tableName" in e && "fields" in e && typeof e.tableName == "string", S = async (e) => {
+	f();
+	let t = 0, n = 0, r = [...await b(e, i), ...await b(e, a)];
+	for (let e of r) {
+		let r;
+		try {
+			r = await import(u(e).href);
+		} catch (t) {
+			_.warn("privacy: failed to import a schema file — its tables are NOT in the graph below", {
+				file: e,
+				error: String(t)
+			});
+			continue;
+		}
+		for (let e of Object.values(r)) x(e) && (m(e), t += 1);
+		n += g(r);
+	}
+	return {
+		tables: t,
+		relations: n
+	};
+}, C = (t) => {
+	if (t === void 0) return;
+	let n = Number(t);
+	if (!Number.isInteger(n) || n < 1) throw new e(`voltro privacy: --depth must be a positive integer, got "${t}"`);
+	return n;
+}, w = (e) => e === void 0 ? void 0 : e.split(",").map((e) => e.trim()).filter((e) => e !== ""), T = async (e) => {
+	let t = c(r(e, y) ?? process.cwd()), i = n(e, "--subject-table") ?? "actors", a = C(n(e, "--depth")), s = w(n(e, "--exclude"));
+	if ((await S(t)).tables === 0) return _.error("voltro privacy scope: no schema files found", {
+		root: t,
+		hint: "looked for *.entity.ts / *.schema.ts / schema.ts"
+	}), 1;
+	let l = p({
+		subjectTable: i,
+		...a === void 0 ? {} : { maxDepth: a },
+		...s === void 0 ? {} : { exclude: s }
+	});
+	return e.includes("--json") ? o({
+		subjectTable: l.subjectTable,
+		paths: l.paths,
+		limitations: l.limitations,
+		summary: {
+			reachable: l.paths.length,
+			unreachable: l.limitations.filter((e) => e.kind === "unreachable").length,
+			depthTruncated: l.limitations.filter((e) => e.kind === "depth-truncated").length
+		}
+	}) : (console.log(""), console.log(h(l)), console.log("")), +(l.paths.length === 0);
+}, E = (t) => {
+	let r = n(t, "--url");
+	if (r === void 0 || r === "") throw new e("voltro privacy: --url <app base url> is required — this runs against the RUNNING app's admin-gated governance endpoint, so the erasure log and the configured anonymize fields apply.");
+	let i = n(t, "--token") ?? process.env.VOLTRO_INSPECT_TOKEN;
+	if (i === void 0 || i === "") throw new e("voltro privacy: no inspect credential — pass --token or set VOLTRO_INSPECT_TOKEN. The governance export/erase endpoints are fail-closed and will answer 401 without one.");
+	return {
+		base: `${r.replace(/\/+$/, "")}/_voltro/inspect/plugins/governance`,
+		headers: {
+			accept: "application/json",
+			"content-type": "application/json",
+			authorization: `Bearer ${i}`
+		}
+	};
+}, D = async (e, t, n) => {
+	let r = await fetch(`${e.base}${t}`, {
+		method: "POST",
+		headers: e.headers,
+		body: JSON.stringify(n)
+	}), i = await r.json().catch(() => ({}));
+	return {
+		ok: r.ok,
+		status: r.status,
+		data: i
+	};
+}, O = (n, r) => {
+	let i = t(n, y)[0];
+	if (i === void 0) throw new e(`voltro privacy ${r}: a <subjectId> is required.`);
+	return i;
+}, k = {
+	scope: T,
+	export: async (e) => {
+		let t = O(e, "export"), r = await D(E(e), "/export", { subjectId: t });
+		if (!r.ok) return _.error(`voltro privacy export: the app answered ${r.status}`, { error: String(r.data.error ?? "") }), 1;
+		let i = n(e, "--out"), a = r.data.bundle, s = JSON.stringify(a ?? {}, null, 2);
+		if (i !== void 0) {
+			await l.writeFile(c(i), `${s}\n`, "utf8");
+			let e = Object.keys(a ?? {});
+			_.info(`voltro privacy export: wrote ${e.length} table(s) to ${i}`, { tables: e });
+		} else o(a ?? {});
+		return 0;
+	},
+	erase: async (t) => {
+		let r = O(t, "erase"), i = n(t, "--mode") ?? "delete";
+		if (i !== "delete" && i !== "anonymize") throw new e(`voltro privacy erase: --mode must be delete|anonymize, got "${i}"`);
+		if (!t.includes("--confirm")) return _.error("voltro privacy erase: refusing without --confirm."), console.error(`  This performs an IRREVERSIBLE ${i} of subject '${r}' across every table in the`), console.error("  configured subject scope, on the app at --url. Run `voltro privacy scope` first to see"), console.error("  which tables that is — and which it cannot reach."), 2;
+		let a = await D(E(t), "/erase", {
+			subjectId: r,
+			mode: i
+		});
+		if (!a.ok) return _.error(`voltro privacy erase: the app answered ${a.status}`, { error: String(a.data.error ?? "") }), 1;
+		let s = a.data.entry;
+		return o(s ?? {}), s?.truncated !== void 0 && s.truncated.length > 0 ? (_.error(`voltro privacy erase: INCOMPLETE — the row cap was hit on ${s.truncated.join(", ")}. Re-run until 'truncated' is absent.`), 1) : 0;
+	}
+}, A = async (e) => {
+	let [t, ...n] = e;
+	if (t === void 0) return console.error("voltro privacy <subcommand> [args]"), console.error("  scope  [root] [--subject-table <t>] [--depth <n>] [--exclude a,b] [--json]"), console.error("         Derive the DSAR subject graph from the schema — and print what it CANNOT see."), console.error("  export <subjectId> --url <app> [--token <t>] [--out <file>]"), console.error("  erase  <subjectId> --url <app> [--token <t>] [--mode delete|anonymize] --confirm"), console.error("         Both run against the RUNNING app's admin-gated governance endpoint, so the"), console.error("         configured anonymize fields and the erasure log apply."), 1;
+	let r = k[t];
+	return r === void 0 ? (console.error(`voltro privacy: unknown subcommand '${t}'`), 2) : r(n);
+};
+//#endregion
+export { A as runPrivacyCommand };