@voltro/cli 0.47.0 → 0.49.0

package/dist/dataCommand-CJv_OMoS.js

@@ -0,0 +1,1156 @@
+import { i as e, t } from "./subcommandNames-DpYs3DXr.js";
+import { t as n } from "./cliError-BmdYnghb.js";
+import { c as r, i, o as a, z as o } from "./dev-C31Nvlbv.js";
+import { n as s, t as c } from "./cliArgs-D4p8n7EE.js";
+import { r as l } from "./dialectDriver-czCHYpeH.js";
+import { i as u, n as d, r as f, t as p } from "./dataProfile-Du3ztYxv.js";
+import { o as m, t as h } from "./inspectFetch-EMuhTG_9.js";
+import { r as g } from "./dbCommand-Bf7Cy0mn.js";
+import { resolve as _ } from "node:path";
+import { createLogger as v } from "@voltro/logger";
+import { DATA_TRANSFERS_TABLE as y, connectionIdentity as b, normaliseTarget as x, sameDatabase as S, streamTable as C } from "@voltro/database";
+import { Effect as w, Stream as ee } from "effect";
+import { SqlClient as te } from "@effect/sql";
+import { declaredSnapshot as ne, fingerprintSchema as re, introspectSchema as ie } from "@voltro/database/sql";
+import { STORAGE_REFS_TABLE as ae, resolveStorageProvider as T } from "@voltro/plugin-storage";
+import { createHash as oe } from "node:crypto";
+import { asImportError as se, assessLiveImport as ce, backupArtifactName as E, backupCommand as le, classificationFromSnapshot as ue, decryptStream as D, encryptStream as de, packBundle as fe, peekBundle as O, previewMasking as pe, restoreCommand as k, runExport as me, runImport as he, runNativeStep as A, storageAssetSink as ge, storageAssetSource as _e, storageBlobSink as ve, storageBlobSource as ye, unpackBundle as be, unpackBundleToDir as xe } from "@voltro/data-transfer";
+import { request as Se } from "node:http";
+import { request as Ce } from "node:https";
+//#region src/longRequest.ts
+var we = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ETIMEDOUT",
+	"EHOSTUNREACH",
+	"ENETUNREACH",
+	"ENOTFOUND",
+	"ECONNRESET",
+	"EAI_AGAIN"
+]), j = class extends Error {
+	url;
+	cause;
+	constructor(e, t) {
+		let n = (() => {
+			try {
+				return new URL(e).host;
+			} catch {
+				return e;
+			}
+		})();
+		super(`the instance at ${n} is not answering (${t.code ?? "connect failed"}).`), this.url = e, this.cause = t, this.name = "InstanceUnreachable";
+	}
+}, M = class extends Error {
+	elapsedMs;
+	url;
+	constructor(e, t) {
+		super(`no response after ${Math.round(e / 1e3)}s`), this.elapsedMs = e, this.url = t, this.name = "LongRequestTimeout";
+	}
+}, N = async (e, t, n, r) => {
+	let i = new URL(e), a = i.protocol === "https:" ? Ce : Se, o = Date.now();
+	return await new Promise((s, c) => {
+		let l = a({
+			protocol: i.protocol,
+			hostname: i.hostname,
+			port: i.port === "" ? void 0 : Number(i.port),
+			path: `${i.pathname}${i.search}`,
+			method: "POST",
+			headers: n
+		}, (e) => {
+			let t = [];
+			e.on("data", (e) => t.push(e)), e.on("end", () => s({
+				status: e.statusCode ?? 0,
+				headers: Object.fromEntries(Object.entries(e.headers).map(([e, t]) => [e, Array.isArray(t) ? t.join(", ") : String(t ?? "")])),
+				body: Buffer.concat(t)
+			})), e.on("error", c);
+		});
+		if (r?.timeoutMs !== void 0 && r.timeoutMs > 0 && l.setTimeout(r.timeoutMs, () => {
+			l.destroy(new M(Date.now() - o, e));
+		}), l.on("error", (t) => c(we.has(t.code ?? "") ? new j(e, t) : t)), typeof t == "string" || Buffer.isBuffer(t)) {
+			l.end(t);
+			return;
+		}
+		(async () => {
+			try {
+				for await (let e of t) l.write(Buffer.from(e)) || await new Promise((e) => l.once("drain", () => e()));
+				l.end();
+			} catch (e) {
+				l.destroy(e);
+			}
+		})();
+	});
+}, P = (e) => `${e.message}\n  That address came from --api-url (or VOLTRO_API_URL) — it is the running instance, not the database.\n  Nothing was sent, so nothing was imported. Check the instance is up and reachable from here\n  (a VPN, an ingress or a stopped deployment are the usual three), e.g. curl -sS ${e.url}/_voltro/inspect/app`, Te = (e, t) => `the instance did not answer within ${Math.round(e.elapsedMs / 1e3)}s. This is a client-side deadline, not a failure on the server: the upload itself finished long before, and the response arrives only when the import does. The instance is very probably STILL IMPORTING and will finish.\n` + (t === "replace" ? "  Do NOT simply re-run: --mode replace empties the target first, so a second run started while the first is mid-flight would empty it under the first one. Check the instance's log for the import's completion, and check the target's row counts, before deciding." : `  Re-running the same bundle is safe once the first run has finished (--mode ${t} is idempotent), but check the instance's log first — the work may already be done.`) + "\n  To keep a deadline anyway, pass --timeout <seconds>; the default is to wait.", Ee = 16777216, De = async function* (e, t) {
+	let n = [], r = 0, i = 0, a = function* (e) {
+		let t = Buffer.concat(n);
+		n = [], r = 0;
+		let a = {
+			bytes: t,
+			offset: i,
+			final: e
+		};
+		i += t.byteLength, yield a;
+	};
+	for await (let a of e) for (n.push(Buffer.from(a)), r += a.byteLength; r >= t;) {
+		let e = Buffer.concat(n), a = e.subarray(0, t), o = e.subarray(t);
+		n = o.byteLength > 0 ? [Buffer.from(o)] : [], r = o.byteLength;
+		let s = {
+			bytes: Buffer.from(a),
+			offset: i,
+			final: !1
+		};
+		i += a.byteLength, yield s;
+	}
+	yield* a(!0);
+}, Oe = (e) => oe("sha256").update(Buffer.from(e)).digest("hex"), ke = async (e) => {
+	let t = 0, n = 0, r = {
+		status: 0,
+		body: {}
+	};
+	for await (let i of De(e.stream, e.chunkBytes)) {
+		if (i.offset + i.bytes.byteLength <= e.alreadyHeld && !i.final) {
+			n++;
+			continue;
+		}
+		let a = Math.max(0, e.alreadyHeld - i.offset), o = a > 0 ? i.bytes.subarray(a) : i.bytes, s = i.offset + a;
+		if (o.byteLength === 0 && !i.final) {
+			n++;
+			continue;
+		}
+		if (i.final && e.onFinalChunk?.(), r = await e.target.send(Buffer.from(o), {
+			...e.baseHeaders,
+			"content-type": "application/octet-stream",
+			"x-import-upload-id": e.uploadId,
+			"x-import-upload-key": e.key,
+			"x-import-chunk-offset": String(s),
+			...i.final ? { "x-import-chunk-final": "1" } : {}
+		}), n++, t += o.byteLength, e.onProgress?.(t), r.status >= 400) break;
+	}
+	return {
+		status: r.status,
+		body: r.body,
+		chunks: n,
+		bytes: t,
+		resumedFrom: e.alreadyHeld
+	};
+}, F = "voltro-backup-stamp.json", Ae = (e) => ({
+	stampVersion: 1,
+	dialect: e.dialect,
+	schemaFingerprint: e.schemaFingerprint,
+	voltroVersion: e.voltroVersion,
+	createdAt: e.createdAt
+}), je = (e) => {
+	let t;
+	try {
+		t = JSON.parse(e);
+	} catch {
+		return null;
+	}
+	if (typeof t != "object" || !t) return null;
+	let n = t;
+	if (n.stampVersion !== 1 || typeof n.dialect != "string" || typeof n.voltroVersion != "string" || typeof n.createdAt != "string") return null;
+	let r = n.schemaFingerprint;
+	return r !== null && typeof r != "string" ? null : {
+		stampVersion: 1,
+		dialect: n.dialect,
+		schemaFingerprint: r,
+		voltroVersion: n.voltroVersion,
+		createdAt: n.createdAt
+	};
+}, Me = (e) => {
+	let { stamp: t, currentDialect: n, currentFingerprint: r } = e;
+	if (t === null) return {
+		warn: `no ${F} beside the dump — an older/handmade backup. Cannot verify dialect or schema version; make sure this dump is a ${n} dump.`,
+		info: []
+	};
+	let i = [`backup produced by @voltro/cli ${t.voltroVersion} at ${t.createdAt}`, `schema fingerprint: ${t.schemaFingerprint ?? "<none recorded>"}`];
+	return t.dialect === n ? t.schemaFingerprint !== null && r !== null && t.schemaFingerprint !== r ? {
+		warn: `schema skew — the backup's schema (${t.schemaFingerprint.slice(0, 12)}) differs from what this code declares (${r.slice(0, 12)}). Run \`voltro db apply\` after the restore, or the app may boot against a schema it doesn't understand.`,
+		info: i
+	} : { info: i } : {
+		refuse: `dialect mismatch — backup is a ${t.dialect} dump, but DB_DIALECT is ${n}. A cross-dialect restore is never valid.`,
+		info: i
+	};
+}, I = (e) => {
+	try {
+		let t = new URL(e), n = t.pathname.replace(/^\//, "");
+		return `${t.hostname.toLowerCase()}:${t.port || "(default)"}/${n}`;
+	} catch {
+		return e.trim();
+	}
+}, Ne = (e) => {
+	let t = e.flagUrl ?? e.envUrl;
+	if (t === void 0 || t.trim() === "") return {
+		ok: !1,
+		error: "no drill target — pass `--drill-url <url>` or set `DRILL_DB_URL`. The drill restores into a THROWAWAY database (never the live one), so it needs its own connection."
+	};
+	let n = I(t);
+	return e.liveKeys.some((e) => e === n) ? {
+		ok: !1,
+		error: `drill target (${n}) is the LIVE database — a restore drill must target a throwaway DB, never production. It would --clean and overwrite it.`
+	} : {
+		ok: !0,
+		url: t
+	};
+}, Pe = (e) => {
+	let { stampFingerprint: t, restoredFingerprint: n, restoredTableCount: r } = e;
+	return r === 0 ? {
+		pass: !1,
+		lines: ["FAIL — the restore produced ZERO tables. The dump is empty or unreadable; this backup would NOT recover your app."]
+	} : t !== null && n !== null && t !== n ? {
+		pass: !1,
+		lines: [`FAIL — restored ${r} table(s), but the schema fingerprint (${n.slice(0, 12)}) does NOT match the backup's stamp (${t.slice(0, 12)}).`, "The restore did not reproduce the schema that was backed up — the artifact is inconsistent."]
+	} : t === null || n === null ? {
+		pass: !0,
+		lines: [`PASS (partial) — restored ${r} table(s) into the throwaway DB.`, "No stamped fingerprint to cross-check the schema shape (older/hand-made backup) — the bytes restore, but the shape was not verified."]
+	} : {
+		pass: !0,
+		lines: [`PASS — restored ${r} table(s); schema fingerprint matches the backup stamp (${n.slice(0, 12)}).`]
+	};
+}, L = v({ scope: "voltro:data" }), Fe = async () => {
+	try {
+		let { createRequire: e } = await import("node:module"), { join: t } = await import("node:path"), { readFileSync: n } = await import("node:fs"), r = e(t(process.cwd(), "package.json")).resolve("@voltro/cli/package.json");
+		return JSON.parse(n(r, "utf8")).version ?? "unknown";
+	} catch {
+		return "unknown";
+	}
+}, R = async (e) => {
+	try {
+		return re(await Be(e));
+	} catch {
+		return null;
+	}
+}, z = (e) => {
+	if (e.event !== "done") return;
+	let t = e.total === void 0 ? "" : ` / ${e.total}`;
+	L.info(`${e.phase} [${e.index + 1}/${e.tableCount}] ${e.table}`, { rows: `${e.rowsDone}${t}` });
+}, Ie = async (e) => {
+	let t = (e) => e?.meta?.databaseId;
+	if (e) {
+		let n = await h({
+			name: "target",
+			url: e
+		}, "/_voltro/inspect/app");
+		if (n.kind === "ok") return {
+			label: e,
+			databaseId: t(n.data)
+		};
+	}
+	for (let e of await m()) {
+		let n = await h(e, "/_voltro/inspect/app");
+		if (n.kind === "ok") return {
+			label: `${e.name} (${e.url})`,
+			databaseId: t(n.data)
+		};
+	}
+	return null;
+}, Le = async (e) => {
+	let t = e.includes("--allow-live"), n = t ? null : await Ie(B(e, "--api-url")), r = b({
+		dialect: H(),
+		...a()
+	}), i = x({
+		dialect: H(),
+		...a()
+	}), { refuse: o, message: s } = ce({
+		liveInstance: n?.label ?? null,
+		allowLive: t,
+		sameTarget: S(r, n?.databaseId),
+		...i === void 0 ? {} : { targetLabel: `${i.host}:${i.port}/${i.database}` }
+	});
+	return !o || (L.error(s ?? "refusing: live instance detected"), !1);
+}, B = s, Re = [
+	"--api-url",
+	"--bundle-key",
+	"--compression",
+	"--consistency",
+	"--drill-url",
+	"--chunk-size",
+	"--exclude",
+	"--limit",
+	"--max-request-seconds",
+	"--mode",
+	"--no-atomic",
+	"--on-conflict",
+	"--passphrase",
+	"--profile",
+	"--tables",
+	"--target",
+	"--timeout",
+	"--tenant",
+	"--token"
+], V = (e) => c(e, Re), H = () => {
+	let e = (process.env.DB_DIALECT ?? "postgres").toLowerCase();
+	if (e === "memory") throw new n("voltro data: requires a real dialect, not DB_DIALECT=memory.");
+	return e;
+}, ze = async (e, t) => {
+	let n = (await l(e)).makeSqlLayer(t);
+	return w.runPromise(te.SqlClient.pipe(w.flatMap(ie), w.provide(n)));
+}, Be = (e) => ze(e, a()), Ve = () => {
+	let e = a(), t = [];
+	return e.url && t.push(I(e.url)), (e.host || e.database) && t.push(`${(e.host ?? "localhost").toLowerCase()}:${e.port ?? "(default)"}/${e.database ?? ""}`), t;
+}, U = async () => {
+	let e = process.cwd(), t = await r(e);
+	if (!t) throw new n("voltro data: no app.config.ts found in the current directory.");
+	let a = await i(t, void 0), o = H();
+	return {
+		store: a,
+		snapshot: await Be(o),
+		dialect: o
+	};
+}, W = (e) => C(e, {
+	table: ae,
+	chunkSize: 500
+}).pipe(ee.map((e) => ({
+	key: String(e.key),
+	contentType: String(e.contentType ?? "application/octet-stream"),
+	size: Number(e.size ?? 0)
+}))), G = (e) => !!e && e.endsWith(".vbundle"), K = (e) => B(e, "--passphrase") ?? process.env.VOLTRO_BUNDLE_KEY, He = (e) => e.includes("--encrypt") || B(e, "--passphrase") !== void 0 || process.env.VOLTRO_BUNDLE_KEY !== void 0, Ue = async (e, t) => {
+	let { createWriteStream: n } = await import("node:fs"), { pipeline: r } = await import("node:stream/promises"), { Readable: i } = await import("node:stream");
+	await r(i.from(e), n(t));
+}, q = (e) => ({ async *[Symbol.asyncIterator]() {
+	let { createReadStream: t } = await import("node:fs");
+	for await (let n of t(e)) yield n instanceof Uint8Array ? n : new Uint8Array(n);
+} }), We = async (e, t) => {
+	if (t !== void 0 || e === void 0) return null;
+	try {
+		let { resolve: t, join: n } = await import("node:path"), r = await import("node:fs/promises"), i = t(process.cwd(), e), a = G(e) ? (await O(q(i), ["manifest.json"])).get("manifest.json") : await r.readFile(n(i, "manifest.json"));
+		if (a === void 0) return null;
+		let o = (JSON.parse(Buffer.from(a).toString("utf8")).tables ?? []).map((e) => e.name).filter((e) => typeof e == "string");
+		return o.length > 0 ? o : null;
+	} catch {
+		return null;
+	}
+}, Ge = (e) => {
+	let t = B(e, "--max-request-seconds") ?? process.env.VOLTRO_MAX_REQUEST_SECONDS;
+	if (t === void 0) return { pollMs: 2e3 };
+	let r = Number(t);
+	if (!Number.isFinite(r) || r <= 0) throw new n(`--max-request-seconds expects a positive number of seconds, got '${t}'`);
+	let i = Math.round(r * 1e3);
+	return {
+		perRequest: { timeoutMs: i },
+		pollMs: Math.max(500, Math.min(2e3, Math.floor(i / 2)))
+	};
+}, Ke = async (e, t, n) => {
+	let r = await fetch(`${e.replace(/\/+$/, "")}/_voltro/admin/imports?limit=50`, { headers: { authorization: `Bearer ${t}` } }).catch(() => null);
+	if (r === null || r.status !== 200) return null;
+	let i = ((await r.json().catch(() => null))?.runs ?? []).find((e) => e.id === n);
+	return i === void 0 ? null : {
+		...i,
+		startedAt: new Date(String(i.startedAt)),
+		finishedAt: i.finishedAt === null || i.finishedAt === void 0 ? null : new Date(String(i.finishedAt))
+	};
+}, qe = async (e) => {
+	let t = e.apiUrl.replace(/\/+$/, ""), n = [], r = 0, i;
+	for (;;) {
+		let a = `${t}/_voltro/admin/export/download?runId=${encodeURIComponent(e.runId)}&offset=${r}`, o = new AbortController(), s = e.perRequest === void 0 ? void 0 : setTimeout(() => {
+			o.abort();
+		}, e.perRequest.timeoutMs), c;
+		try {
+			c = await fetch(a, {
+				headers: { authorization: `Bearer ${e.secret}` },
+				signal: o.signal
+			});
+		} catch (t) {
+			return e.log.error(`api export: fetching bytes at offset ${r} failed — ${t?.message ?? String(t)}. The bundle is still on the instance; re-run to resume from here.`), null;
+		} finally {
+			s !== void 0 && clearTimeout(s);
+		}
+		if (c.status !== 200) return e.log.error(`api export: the instance answered HTTP ${c.status} for the bytes at offset ${r} — ${await c.text()}`), null;
+		let l = Buffer.from(await c.arrayBuffer());
+		if (i ??= Number(c.headers.get("x-export-total-bytes") ?? "0"), n.push(l), r += l.byteLength, l.byteLength === 0 || i !== void 0 && r >= i) break;
+		e.log.info(`  downloading — ${r}/${i ?? "?"} bytes`);
+	}
+	return new Uint8Array(Buffer.concat(n));
+}, J = "transfers", Je = (e) => (e ?? "").split(",").map((e) => e.trim()).filter(Boolean), Ye = (e, t) => {
+	let r = B(e, "--tenant"), i = B(e, "--tables"), a = B(e, "--exclude");
+	if (a !== void 0) {
+		if (i !== void 0) throw new n("voltro data export: --exclude and --tables are two ways to say the same thing; use one.");
+		if (r !== void 0) throw new n("voltro data export: --exclude does not apply to --tenant, whose table set is derived from the tenant closure.");
+		let e = Je(a), o = new Set(t), s = e.filter((e) => !o.has(e));
+		if (s.length > 0) throw new n(`voltro data export: --exclude names ${s.length} table(s) that do not exist: ${s.join(", ")}. An exclusion that excludes nothing would leave the run looking like it worked.`);
+		return {
+			kind: "all",
+			exclude: e
+		};
+	}
+	return r ? {
+		kind: "tenant",
+		tenantId: r
+	} : i ? {
+		kind: "tables",
+		tables: Je(i)
+	} : { kind: "all" };
+}, Xe = async () => {
+	let e = await g(process.cwd());
+	return ue(ne(e));
+}, Ze = "voltro/tenant", Qe = async () => {
+	let e = (await g(process.cwd())).filter((e) => (e.appliedMixins ?? []).some((e) => e.id === Ze)).map((e) => e.tableName);
+	return e.length > 0 ? e : void 0;
+}, $e = (e) => {
+	for (let t of e.tables) if (t.samples.length !== 0) {
+		console.log(`\n  ${t.table}`);
+		for (let e of t.samples) console.log(`    ${e.column}  [${e.action}]  ${JSON.stringify(e.before)} → ${JSON.stringify(e.after)}`);
+	}
+	if (e.leaks.length > 0) {
+		console.log("\n  ⚠ possible leaks in KEPT columns:");
+		for (let t of e.leaks) console.log(`    ${t.table}.${t.column} looks like ${t.pattern}: ${JSON.stringify(t.sample)}`);
+	}
+	if (e.unclassified.length > 0) {
+		console.log("\n  ✗ unclassified (would BLOCK a real export — add .sensitive()/.safe() or a policy override):");
+		for (let t of e.unclassified) console.log(`    ${t}`);
+	} else console.log("\n  ✓ every exported column is classified — safe to run.");
+}, et = async (e) => {
+	let { resolve: t, join: r } = await import("node:path"), i = await import("node:fs/promises"), a = B(e.args, "--chunk-size"), o = a === void 0 ? Ee : Math.round(Number(a) * 1024 * 1024);
+	if (!Number.isFinite(o) || o <= 0) throw new n(`--chunk-size expects a positive number of megabytes, got '${String(a)}'`);
+	let s = e.stream[Symbol.asyncIterator](), c = [], l = 0, u = !1;
+	for (; l <= o;) {
+		let e = await s.next();
+		if (e.done === !0) {
+			u = !0;
+			break;
+		}
+		c.push(Buffer.from(e.value)), l += e.value.byteLength;
+	}
+	if (u && l <= o) return {
+		kind: "small",
+		body: Buffer.concat(c)
+	};
+	let d = t(process.cwd(), e.bundleDir), f = Oe(G(e.bundleDir) ? await i.readFile(d) : await i.readFile(r(d, "manifest.json"))), p = `up-${f.slice(0, 32)}`, m = await N(e.url, Buffer.alloc(0), {
+		...e.headers,
+		"x-import-upload-id": p,
+		"x-import-probe": "1"
+	}, X(e.args)), h = m.status === 200 ? Number(JSON.parse(m.body.toString("utf8")).bytes ?? 0) : 0;
+	h > 0 && e.log.info("api import: resuming a chunked upload the instance already holds", { bytes: h });
+	let g = (async function* () {
+		for (let e of c) yield e;
+		for (;;) {
+			let e = await s.next();
+			if (e.done === !0) return;
+			yield e.value;
+		}
+	})(), _ = 0, v = await ke({
+		stream: g,
+		chunkBytes: o,
+		uploadId: p,
+		key: f,
+		alreadyHeld: h,
+		baseHeaders: e.headers,
+		onProgress: (t) => {
+			_++, e.log.info(`api import: uploading — chunk ${_}, ${Math.round(t / 1024)} KiB sent`);
+		},
+		onFinalChunk: () => {
+			e.log.info("api import: upload done — the instance is importing now. This request stays open until it finishes, which on a full bundle is minutes, and nothing more is printed until then. It is not a hang; the instance logs the import itself.");
+		},
+		target: { send: async (t, n) => {
+			let r = await N(e.url, t, n, X(e.args)), i = {};
+			try {
+				i = JSON.parse(r.body.toString("utf8") || "{}");
+			} catch {}
+			return {
+				status: r.status,
+				body: i
+			};
+		} }
+	});
+	return e.log.info("api import: uploaded in chunks", {
+		chunks: v.chunks,
+		bytes: v.bytes,
+		...v.resumedFrom > 0 ? { resumedFrom: v.resumedFrom } : {}
+	}), {
+		kind: "sent",
+		res: {
+			status: v.status,
+			headers: {},
+			body: Buffer.from(JSON.stringify(v.body))
+		}
+	};
+}, tt = (e) => `--mode replace with --no-atomic against a ${e ? "RUNNING instance" : "live database"}: the target is empty between the delete and the load, and anything the application writes in that window can collide with a row from the bundle — or survive the import as a row the bundle never carried. Drop --no-atomic to run the whole load in one transaction (concurrent writers then wait instead of racing), or stop the traffic for the duration.`, Y = (e, t) => e.includes("--no-atomic") ? !1 : e.includes("--atomic") || t === "replace", nt = (e, t, n) => {
+	if (t !== "replace" || e.includes("--no-rollback")) return;
+	let r = B(e, "--rollback-dir");
+	return r === void 0 ? o(n) : _(r);
+}, rt = (e, t, n) => {
+	let r = nt(e, t, n);
+	return {
+		...r === void 0 ? {} : { rollbackDir: r },
+		recordInterruption: !0,
+		via: "direct"
+	};
+}, X = (e) => {
+	let t = B(e, "--timeout");
+	if (t === void 0) return {};
+	let r = Number(t);
+	if (!Number.isFinite(r) || r <= 0) throw new n(`--timeout expects a positive number of seconds, got '${t}'`);
+	return { timeoutMs: Math.round(r * 1e3) };
+}, it = async (e) => {
+	let t = B(e, "--target") === "api", n = B(e, "--bundle-key"), r = V(e);
+	if (!r && !(t && n)) return L.error("usage: voltro data export <outDir> [--target direct|api] [--api-url <url>] [--token <secret>] [--timeout <seconds>] [--profile <name>] [--tenant <id>] [--tables a,b] [--exclude a,b] [--bundle-key <storage-key>] [--assets] [--compression zstd|gzip|none] [--consistency live|snapshot] [--dry-run]"), 1;
+	if (t) {
+		let t = B(e, "--api-url");
+		if (!t) return L.error("--target api requires --api-url <url> (the running instance)"), 1;
+		let i = B(e, "--token") ?? process.env.VOLTRO_DATA_TRANSFER_SECRET;
+		if (!i) return L.error("--target api requires --token <secret> (or VOLTRO_DATA_TRANSFER_SECRET) matching the instance secret"), 1;
+		let a = B(e, "--tables"), o = B(e, "--exclude");
+		if (o !== void 0 && a !== void 0) return L.error("voltro data export: --exclude and --tables are two ways to say the same thing; use one."), 1;
+		let s = {
+			...B(e, "--profile") ? { profile: B(e, "--profile") } : {},
+			...B(e, "--tenant") ? { tenant: B(e, "--tenant") } : {},
+			...a ? { tables: a.split(",").map((e) => e.trim()).filter(Boolean) } : {},
+			...o ? { exclude: o.split(",").map((e) => e.trim()).filter(Boolean) } : {},
+			...B(e, "--consistency") === "snapshot" ? { consistency: "snapshot" } : {},
+			...B(e, "--compression") ? { compression: B(e, "--compression") } : {},
+			...e.includes("--assets") ? { assets: !0 } : {},
+			...n ? { bundleKey: n } : {}
+		}, c = Ge(e), l;
+		try {
+			let n = await N(`${t.replace(/\/+$/, "")}/_voltro/admin/export`, JSON.stringify(s), {
+				"content-type": "application/json",
+				authorization: `Bearer ${i}`
+			}, c.perRequest ?? X(e));
+			if (n.status < 200 || n.status >= 300) return L.error(`api export failed: HTTP ${n.status} — ${n.body.toString("utf8")}`), 1;
+			l = JSON.parse(n.body.toString("utf8"));
+		} catch (e) {
+			if (e instanceof M) return L.error(`api export: the instance did not answer within ${Math.round(e.elapsedMs / 1e3)}s. That is a client-side deadline. Nothing was written locally; re-run, or raise --timeout.`), 1;
+			if (e instanceof j) return L.error(`api export: ${P(e)}`), 1;
+			throw e;
+		}
+		if (e.includes("--detach")) return L.info(`api export: started as ${l.runId}. NOT waiting for it.\n  The outcome is not known yet — read it with:  voltro data ${J} --target api --api-url ${t}`), 0;
+		if (l.recorded === !1) return L.warn(`api export: started as ${l.runId}, but this instance could not record the run — so its outcome\n  cannot be read back. Run \`voltro db apply\` against it so the next one is watchable.`), 0;
+		let p = await d({
+			read: () => Ke(t, i, l.runId),
+			onTick: (e) => {
+				L.info(f(e));
+			},
+			intervalMs: c.pollMs,
+			...c.total === void 0 ? {} : { timeoutMs: c.total }
+		}), m = u(p);
+		if (m !== 0) return L.error(m === 1 ? `api export FAILED (${l.runId}): ${String(p?.failure ?? "no reason recorded")}` : `api export: no outcome visible for ${l.runId}. The run is not cancelled; it is simply not readable from here.`), m;
+		if (n) return L.info("api export complete (pushed to storage)", {
+			via: t,
+			runId: l.runId,
+			bundleKey: n,
+			tables: p?.tablesWritten ?? 0,
+			rows: p?.rowsWritten ?? 0
+		}), 0;
+		let { resolve: h } = await import("node:path"), g = await qe({
+			apiUrl: t,
+			secret: i,
+			runId: l.runId,
+			log: L,
+			...c.perRequest ? { perRequest: c.perRequest } : {}
+		});
+		return g === null ? 1 : (await xe((async function* () {
+			yield g;
+		})(), h(process.cwd(), r)), L.info("api export complete (downloaded from the running instance)", {
+			outDir: r,
+			runId: l.runId,
+			tables: p?.tablesWritten ?? 0,
+			rows: p?.rowsWritten ?? 0,
+			bytes: g.byteLength
+		}), 0);
+	}
+	if (!r) return L.error("a <outDir> is required for a direct export"), 1;
+	let i = B(e, "--profile"), a = i ? await p(i, { allowPath: !0 }) : {}, { store: o, snapshot: s, dialect: c } = await U(), l = e.includes("--assets") || a.assets === !0, m = l ? T({}) : void 0, h = B(e, "--compression") ?? a.compression, g = B(e, "--consistency") === "snapshot" ? "snapshot" : a.consistency ?? "live", _ = a.masking, v = a.subset, y = a.scope ?? Ye(e, s.tables.map((e) => e.name)), b = _ ? await Xe() : void 0, x = y.kind === "tenant" ? await Qe() : void 0, S = x ? { tenantTables: x } : {};
+	if (e.includes("--dry-run")) {
+		let e = y.kind === "tables" && y.tables ? [...y.tables] : s.tables.map((e) => e.name);
+		if (L.info("export DRY RUN — nothing was written", {
+			outDir: r,
+			tables: e.length,
+			scope: y.kind,
+			consistency: g,
+			compression: h ?? "zstd",
+			assets: l,
+			masking: _ ? "profile policy applies" : "none"
+		}), L.info(`would export: ${e.join(", ")}`), !_) return 0;
+		let t = await w.runPromise(pe({
+			store: o,
+			snapshot: s,
+			masking: _,
+			...b ? { classification: b } : {},
+			...v ? {} : {
+				scope: y,
+				...S
+			}
+		}));
+		return $e(t), +(t.unclassified.length > 0);
+	}
+	if (G(r)) {
+		let t = await import("node:os"), n = await import("node:fs/promises"), { resolve: i, join: a } = await import("node:path"), u = await n.mkdtemp(a(t.tmpdir(), "voltro-export-"));
+		try {
+			let t = await w.runPromise(me({
+				store: o,
+				snapshot: s,
+				dialect: c,
+				outDir: u,
+				...v ? { subset: v } : {
+					scope: y,
+					...S
+				},
+				consistency: g,
+				...h ? { compression: h } : {},
+				..._ ? { masking: _ } : {},
+				...b ? { classification: b } : {},
+				onProgress: z
+			})), n = fe({
+				dir: u,
+				...m ? { blobs: ye(m, () => W(o)) } : {}
+			}), a = He(e);
+			if (a) {
+				let t = K(e);
+				if (!t) return L.error("--encrypt requires --passphrase <p> or VOLTRO_BUNDLE_KEY (a dedicated key, NOT the transfer secret)"), 1;
+				n = de(n, t);
+			}
+			return await Ue(n, i(process.cwd(), r)), L.info("export complete (single file)", {
+				file: r,
+				encrypted: a,
+				assets: l,
+				tables: t.tables.length,
+				rows: t.tables.reduce((e, t) => e + t.rowCount, 0)
+			}), 0;
+		} finally {
+			await n.rm(u, {
+				recursive: !0,
+				force: !0
+			});
+		}
+	}
+	let C = await w.runPromise(me({
+		store: o,
+		snapshot: s,
+		dialect: c,
+		outDir: r,
+		...v ? { subset: v } : {
+			scope: y,
+			...S
+		},
+		consistency: g,
+		...h ? { compression: h } : {},
+		..._ ? { masking: _ } : {},
+		...b ? { classification: b } : {},
+		...m ? { assets: _e(m, () => W(o)) } : {},
+		onProgress: z
+	}));
+	return L.info("export complete", {
+		outDir: r,
+		tables: C.tables.length,
+		rows: C.tables.reduce((e, t) => e + t.rowCount, 0),
+		assets: C.assets.count,
+		compression: C.compression,
+		...C.masking ? { maskedColumns: C.masking.transformed.length } : {}
+	}), 0;
+}, Z = () => "dry run checked: schema fit, cross-dialect portability, mode legality, the table selection. It did NOT read per-table checksums (those stream during the load) and cannot see conflicts that depend on the target's current rows.", at = (e) => {
+	let t = B(e, "--tables");
+	return {
+		...t ? { tables: t.split(",").map((e) => e.trim()).filter(Boolean) } : {},
+		...e.includes("--dry-run") ? { dryRun: !0 } : {}
+	};
+}, ot = (e) => ({
+	tables: e.tablesWritten,
+	rows: e.rowsWritten,
+	carried: e.manifest.tables.reduce((e, t) => e + t.rowCount, 0),
+	...e.tablesSkipped > 0 ? {
+		skippedTables: e.tablesSkipped,
+		skippedRows: e.rowsSkipped
+	} : {}
+}), st = (e, t) => {
+	if (e.includes("--dry-run")) {
+		L.info("import DRY RUN — nothing was written", t), L.info(Z());
+		return;
+	}
+	if (t.rows === 0 && typeof t.skippedRows == "number" && t.skippedRows !== 0) {
+		L.info("import complete — 0 rows written, every table was already applied by an earlier run of this bundle directory", t);
+		return;
+	}
+	L.info("import complete", t);
+}, ct = Symbol("refused"), Q = (e) => {
+	let t = se(e) ?? e;
+	if (t?._tag !== "RowsRefusedError" || !Array.isArray(t.rows)) return !1;
+	let n = t.rows, r = n.filter((e) => !e.derived), i = Number(t.totalCount ?? n.length), a = Number(t.primaryCount ?? r.length);
+	L.error(`import refused ${i} row(s), of which ${a} are the actual failures — the rest could not land because a row they reference did not.`);
+	let o = Array.isArray(t.byTable) ? t.byTable : [];
+	o.length > 1 && L.error(`  by table: ${o.map((e) => `${e.table} ${e.refused}`).join(", ")}`);
+	for (let e of r) L.error(`  ${e.table} ${e.id}  ${e.reason}`);
+	n.length < i && L.error(`  (the list above is capped at ${n.length} of ${i} — the counts by table are complete)`);
+	let s = i - a;
+	return s > 0 && L.error(`  … and ${s} row(s) behind them. Fix the ${a} above and re-run; they resolve with their parents.`), !0;
+}, lt = (e) => {
+	let t = typeof e == "string" ? e : e.toString("utf8"), n = t;
+	try {
+		let e = JSON.parse(t), r = e.error ?? e.message;
+		typeof r == "string" && (n = r);
+	} catch {}
+	let r = n.indexOf("RowsRefusedError");
+	if (r < 0) return;
+	let i = n.indexOf("{", r);
+	if (i < 0) return;
+	let a = 0, o = !1, s = !1;
+	for (let e = i; e < n.length; e++) {
+		let t = n[e];
+		if (o) {
+			if (s) {
+				s = !1;
+				continue;
+			}
+			if (t === "\\") {
+				s = !0;
+				continue;
+			}
+			t === "\"" && (o = !1);
+			continue;
+		}
+		if (t === "\"") {
+			o = !0;
+			continue;
+		}
+		if (t === "{") a++;
+		else if (t === "}" && --a === 0) try {
+			let t = JSON.parse(n.slice(i, e + 1));
+			return Array.isArray(t.rows) ? {
+				_tag: "RowsRefusedError",
+				...t
+			} : void 0;
+		} catch {
+			return;
+		}
+	}
+}, ut = async (e) => {
+	let t = B(e, "--target") === "api", n = B(e, "--bundle-key"), r = V(e);
+	if (!r && !(t && n)) return L.error("usage: voltro data import <bundleDir> [--target direct|api] [--api-url <url>] [--token <secret>] [--timeout <seconds>] [--bundle-key <storage-key>] [--tables a,b] [--mode upsert|append|replace] [--on-conflict skip|fail] [--atomic] [--assets] [--no-verify] [--force] [--allow-live] [--dry-run]  (--force: import despite schema drift AND cross-dialect warnings; --dry-run: report what would move, write nothing)"), 1;
+	let i = B(e, "--mode") ?? "upsert", o = B(e, "--on-conflict") ?? "skip";
+	if (t) {
+		let t = B(e, "--api-url");
+		if (!t) return L.error("--target api requires --api-url <url> (the running instance)"), 1;
+		let a = B(e, "--token") ?? process.env.VOLTRO_DATA_TRANSFER_SECRET;
+		if (!a) return L.error("--target api requires --token <secret> (or VOLTRO_DATA_TRANSFER_SECRET) matching the instance secret"), 1;
+		let s = B(e, "--tables"), c = B(e, "--rollback-key");
+		i === "replace" && c === void 0 && L.warn("api replace: no rollback capture — this run empties the target first and nothing was asked to be kept.\n  Pass --rollback-key <storage-key> and the INSTANCE stores the target's current rows in its own\n  object storage before deleting them, which is the one place that survives the pod going away.");
+		let l = {
+			authorization: `Bearer ${a}`,
+			"x-import-mode": i,
+			"x-import-on-conflict": o,
+			...Y(e, i) ? { "x-import-atomic": "1" } : {},
+			...e.includes("--no-atomic") ? { "x-import-atomic": "0" } : {},
+			...c === void 0 ? {} : { "x-import-rollback-key": c },
+			...e.includes("--force") ? { "x-import-force": "1" } : {},
+			...e.includes("--dry-run") ? { "x-import-dry-run": "1" } : {},
+			...s ? { "x-import-tables": s } : {}
+		}, { resolve: p } = await import("node:path"), m;
+		if (n) l["content-type"] = "application/json", m = JSON.stringify({ bundleKey: n });
+		else if (G(r)) {
+			let t = q(p(process.cwd(), r)), n = K(e);
+			n && (t = D(t, n)), l["content-type"] = "application/octet-stream", m = t;
+		} else await (await import("node:fs/promises")).access(p(process.cwd(), r, "assets", "index.ndjson")).then(() => !0, () => !1) && L.warn("this directory bundle has assets; --target api uploads DATA ONLY. Pack a single-file `.vbundle` (voltro data export <name>.vbundle --assets) to transfer assets over the API."), l["content-type"] = "application/octet-stream", m = fe({ dir: p(process.cwd(), r) });
+		if (i === "replace") {
+			let i = await We(r, n);
+			{
+				let r = i === null ? { bundleKey: n } : { tables: i }, a = await N(`${t.replace(/\/+$/, "")}/_voltro/admin/import`, JSON.stringify(r), {
+					...l,
+					"content-type": "application/json",
+					"x-import-preflight": "1"
+				}, X(e)).catch(() => null), o = a !== null && a.status === 200 ? JSON.parse(a.body.toString("utf8")) : null;
+				o === null ? L.warn("api replace: the instance did not answer the preflight (an older build does not have it). The run still works; the decision will only be visible in the pod log.") : o.staged === !0 ? L.info(`api replace: the instance WILL stage — ${o.stagedTables ?? 0} table(s) load into copies and the\n  target keeps its rows until one short swap at the end. Interrupting the load leaves the target intact.`) : L.warn(`api replace: the instance will NOT stage — it empties the target first and refills it, so an
+  interrupted run leaves the target empty.\n  Reason: ${o.reason ?? "not stated"}`);
+			}
+		}
+		i === "replace" && !Y(e, i) && L.warn(tt(!0));
+		let h = `${t.replace(/\/+$/, "")}/_voltro/admin/import`, g = Ge(e), _;
+		try {
+			let t = typeof m == "string" ? null : await et({
+				stream: m,
+				url: h,
+				headers: l,
+				bundleDir: r,
+				args: e,
+				log: L
+			}), n = t === null ? await N(h, m, l, g.perRequest ?? X(e)) : t.kind === "sent" ? t.res : await N(h, t.body, l, g.perRequest ?? X(e));
+			if (n.status < 200 || n.status >= 300) return Q(lt(n.body)) || L.error(`api import failed: HTTP ${n.status} — ${n.body.toString("utf8")}`), 1;
+			_ = JSON.parse(n.body.toString("utf8"));
+		} catch (e) {
+			if (e instanceof M) return L.error(`api import: ${Te(e, i)}`), 1;
+			if (e instanceof j) return L.error(`api import: ${P(e)}`), 1;
+			throw e;
+		}
+		let v = await N(`${t.replace(/\/+$/, "")}/_voltro/admin/import/start`, JSON.stringify(_.bundleKey === void 0 ? { uploadId: _.uploadId } : { bundleKey: _.bundleKey }), {
+			...l,
+			"content-type": "application/json"
+		}, g.perRequest ?? X(e)).catch((e) => {
+			if (e instanceof j) return L.error(`api import: ${P(e)}`), null;
+			throw e;
+		});
+		if (v === null) return 1;
+		if (v.status < 200 || v.status >= 300) return Q(lt(v.body)) || L.error(`api import refused: HTTP ${v.status} — ${v.body.toString("utf8")}`), 1;
+		let y = JSON.parse(v.body.toString("utf8"));
+		if (y.alreadyStarted === !0 && L.info(`api import: this bundle is already being imported as ${y.runId} — watching that run instead of starting a second one`), e.includes("--detach")) return L.info(`api import: started as ${y.runId}. NOT waiting for it.\n  The outcome is not known yet — read it with:  voltro data ${J} --target api --api-url ${t}`), 0;
+		if (y.recorded === !1) return L.warn(`api import: started as ${y.runId}, but this instance could not record the run — so its outcome\n  cannot be read back. Run \`voltro db apply\` against it so the next import is watchable.`), 0;
+		let b = await d({
+			read: () => Ke(t, a, y.runId),
+			onTick: (e) => {
+				L.info(f(e));
+			},
+			intervalMs: g.pollMs,
+			...g.total === void 0 ? {} : { timeoutMs: g.total }
+		}), x = u(b);
+		return x === 2 ? (L.warn(b === null ? `api import: started as ${y.runId}, but its record could not be READ back from this instance.\n  That is a channel problem, not a slow import — an older instance without the history route, a
+  proxy dropping the GET, or a target with no history table. The run itself is unaffected and
+  is NOT cancelled; its outcome is simply not visible from here.` : `api import: still running after the time allowed. The run is NOT cancelled — it is decoupled from\n  this client by design. Watch it with:  voltro data ${J} --target api --api-url ${t}`), 2) : x === 1 ? (L.error(`api import FAILED (${y.runId}): ${String(b?.failure ?? "no reason recorded")}`), 1) : e.includes("--dry-run") ? (L.info("api import DRY RUN — nothing was written", {
+			via: t,
+			runId: y.runId
+		}), L.info(Z()), 0) : (L.info("api import complete (imported by the running instance)", {
+			via: t,
+			runId: y.runId,
+			tables: b?.tablesWritten ?? 0,
+			rows: b?.rowsWritten ?? 0,
+			...b?.staged !== null && b?.staged !== void 0 ? { staged: b.staged } : {}
+		}), 0);
+	}
+	if (!r) return L.error("a <bundleDir> is required for a direct import"), 1;
+	if (!await Le(e)) return 1;
+	i === "replace" && e.includes("--allow-live") && !Y(e, i) && L.warn(tt(!1));
+	let { store: s, snapshot: c } = await U();
+	c.tables.some((e) => e.name === y) || L.warn(`this target has no \`${y}\` table, so this import will not be recorded.\n  The import itself is unaffected. \`voltro db apply\` creates it.`);
+	let l = e.includes("--force"), p = (e) => L.warn(e), m = e.includes("--assets") ? T({}) : void 0, h = H() === "postgres" ? (await import("@voltro/sql-postgres")).makePgCopySession(a()) : void 0;
+	if (G(r)) {
+		let t = await import("node:os"), n = await import("node:fs/promises"), { resolve: a, join: u } = await import("node:path"), d = await n.mkdtemp(u(t.tmpdir(), "voltro-import-"));
+		try {
+			let t = q(a(process.cwd(), r)), n = K(e);
+			return n && (t = D(t, n)), await be(t, {
+				dir: d,
+				blobs: ve(m ?? T({}))
+			}), st(e, {
+				file: r,
+				...ot(await w.runPromise(he({
+					store: s,
+					bundleDir: d,
+					mode: i,
+					onConflict: o,
+					atomic: Y(e, i),
+					...rt(e, i, r),
+					verify: !e.includes("--no-verify"),
+					targetDialect: H(),
+					allowIncompatible: l,
+					targetSnapshot: c,
+					force: l,
+					onWarn: p,
+					onProgress: z,
+					assetsAlreadyRestored: !0,
+					...at(e),
+					...h ? { copyLoader: h } : {}
+				})))
+			}), 0;
+		} finally {
+			await h?.close(), await n.rm(d, {
+				recursive: !0,
+				force: !0
+			});
+		}
+	}
+	let g = await w.runPromise(he({
+		...rt(e, i, r),
+		store: s,
+		bundleDir: r,
+		mode: i,
+		onConflict: o,
+		atomic: Y(e, i),
+		verify: !e.includes("--no-verify"),
+		targetDialect: H(),
+		allowIncompatible: l,
+		targetSnapshot: c,
+		force: l,
+		onWarn: p,
+		onProgress: z,
+		...at(e),
+		...m ? { assets: ge(m) } : {},
+		...h ? { copyLoader: h } : {}
+	})).catch((e) => {
+		if (Q(e)) return ct;
+		throw e;
+	}).finally(() => h?.close());
+	return typeof g == "symbol" ? 1 : (st(e, {
+		bundleDir: r,
+		...ot(g),
+		assets: g.manifest.assets.count
+	}), 0);
+}, dt = () => {
+	let e = a();
+	return {
+		...e.url ? { url: e.url } : {},
+		...e.host ? { host: e.host } : {},
+		...e.port ? { port: e.port } : {},
+		...e.username ? { username: e.username } : {},
+		...e.password ? { password: e.password } : {},
+		...e.database ? { database: e.database } : {}
+	};
+}, ft = async (e) => {
+	let t = V(e);
+	if (!t) return L.error("usage: voltro data backup <outDir>  (native pg_dump/mysqldump/… + consistent artifact)"), 1;
+	let n = H(), { mkdir: r, writeFile: i } = await import("node:fs/promises"), { join: a } = await import("node:path");
+	await r(t, { recursive: !0 });
+	let o = a(t, E(n));
+	await w.runPromise(A(le(n, dt(), o)));
+	let s = Ae({
+		dialect: n,
+		schemaFingerprint: await R(n),
+		voltroVersion: await Fe(),
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	return await i(a(t, F), `${JSON.stringify(s, null, 2)}\n`, "utf8"), L.info("native backup complete", {
+		dialect: n,
+		artifact: o,
+		stamp: F,
+		schemaFingerprint: s.schemaFingerprint ?? "<none>",
+		assets: "NOT included — use `voltro data export --assets` for rows + blobs"
+	}), 0;
+}, pt = async (e, t) => {
+	let n = H(), { join: r } = await import("node:path"), { readFile: i } = await import("node:fs/promises"), a = r(e, E(n)), o = Ne({
+		flagUrl: B(t, "--drill-url"),
+		envUrl: process.env.DRILL_DB_URL,
+		liveKeys: Ve()
+	});
+	if (!o.ok) return L.error(`restore --drill: ${o.error}`), 1;
+	let s = await i(r(e, F), "utf8").then(je, () => null);
+	if (s && s.dialect !== n) return L.error(`restore --drill: backup is a ${s.dialect} dump but DB_DIALECT is ${n} — cross-dialect restore is never valid.`), 1;
+	L.info("restore drill: restoring into throwaway DB", {
+		dialect: n,
+		target: I(o.url)
+	}), await w.runPromise(A(k(n, { url: o.url }, a)));
+	let c = null, l = 0;
+	try {
+		let e = await ze(n, { url: o.url });
+		c = re(e), l = e.tables.length;
+	} catch (e) {
+		return L.error(`restore --drill: could not introspect the restored DB — ${String(e)}`), 1;
+	}
+	let u = Pe({
+		stampFingerprint: s?.schemaFingerprint ?? null,
+		restoredFingerprint: c,
+		restoredTableCount: l
+	});
+	for (let e of u.lines) u.pass ? L.info(`restore drill: ${e}`) : L.error(`restore drill: ${e}`);
+	return +!u.pass;
+}, mt = async (e) => {
+	let t = V(e);
+	if (!t) return L.error("usage: voltro data restore <backupDir> [--allow-live] [--api-url <url>] [--force] [--drill [--drill-url <url>]]  (native pg_restore/mysql/…)"), 1;
+	if (e.includes("--drill")) return pt(t, e);
+	if (!await Le(e)) return 1;
+	let n = H(), { join: r } = await import("node:path"), { readFile: i } = await import("node:fs/promises"), a = r(t, E(n)), o = Me({
+		stamp: await i(r(t, F), "utf8").then(je, () => null),
+		currentDialect: n,
+		currentFingerprint: await R(n)
+	});
+	for (let e of o.info) L.info(`backup stamp: ${e}`);
+	if (o.warn && L.warn(o.warn), o.refuse) {
+		if (!e.includes("--force")) return L.error(`restore refused: ${o.refuse} (pass --force to override)`), 1;
+		L.warn(`restore proceeding despite: ${o.refuse} (--force)`);
+	}
+	return await w.runPromise(A(k(n, dt(), a))), L.info("native restore complete", {
+		dialect: n,
+		artifact: a
+	}), 0;
+}, ht = async (e) => {
+	let t = V(e);
+	if (!t) return L.error("usage: voltro data inspect <file.vbundle|dir> [--json] [--passphrase <p>]"), 1;
+	let { resolve: n, join: r } = await import("node:path"), i = await import("node:fs/promises"), a = n(process.cwd(), t);
+	if ((await i.stat(a).catch(() => void 0))?.isDirectory()) {
+		let n = r(a, "manifest.json"), o = r(a, "README.md");
+		if (!e.includes("--json")) {
+			let e = await i.readFile(o, "utf8").catch(() => void 0);
+			if (e !== void 0) return console.log(e), 0;
+		}
+		let s = await i.readFile(n, "utf8").catch(() => void 0);
+		return s === void 0 ? (L.error(`'${t}' is a directory but holds no manifest.json — is it an unpacked bundle? (a bundle exported with --target api is always unpacked into a directory, even when the path ends in .vbundle)`), 1) : (console.log(s), 0);
+	}
+	let o = K(e), s = () => {
+		let e = q(a);
+		return o ? D(e, o) : e;
+	};
+	if (e.includes("--json")) {
+		let e = (await O(s(), ["manifest.json"])).get("manifest.json");
+		return e ? (console.log(e.toString("utf8")), 0) : (L.error("no manifest.json found in the bundle"), 1);
+	}
+	let c = (await O(s(), ["README.md"])).get("README.md");
+	if (c) return console.log(c.toString("utf8")), 0;
+	let l = (await O(s(), ["manifest.json"])).get("manifest.json");
+	return l ? (console.log(l.toString("utf8")), 0) : (L.error("bundle has no README.md or manifest.json"), 1);
+}, gt = async (e) => {
+	let { REPLACE_IN_PROGRESS_TABLE: t } = await import("@voltro/database"), { interruptedReplaceAtBoot: n } = await import("./interruptedReplace-DNJ7MKph.js"), { store: r } = await U(), i = await n(r);
+	if (i === void 0) return L.info("no interrupted replace is recorded — nothing to clear"), 0;
+	if (!e.includes("--yes")) return L.error(`${i}\n\n  Re-run with --yes to clear it.`), 1;
+	let a = await r.query({
+		table: t,
+		predicate: void 0,
+		order: [],
+		take: void 0,
+		skip: void 0,
+		projection: void 0
+	});
+	for (let e of a) await r.delete(t, String(e.id));
+	return L.info(`cleared ${a.length} interrupted-replace marker(s) — the next boot will start`), 0;
+}, _t = async (e) => {
+	let { STAGING_PREFIX: t, dropStagingSql: n, execStatements: r } = await import("@voltro/data-transfer"), { store: i } = await U(), a = H();
+	if (a !== "postgres" && a !== "mysql" && a !== "mariadb" && a !== "sqlite" && a !== "mssql") return L.error(`this store has no staging tables to clear (dialect: ${a})`), 1;
+	let { introspectSchema: o } = await import("@voltro/database/sql"), s = (await i.run((await import("@effect/sql")).SqlClient.SqlClient.pipe((await import("effect")).Effect.flatMap(o)))).tables.map((e) => e.name).filter((e) => e.startsWith(t));
+	return s.length === 0 ? (L.info("no staging tables are present — nothing to clear"), 0) : e.includes("--yes") ? (await r(i, s.map((e) => n(e.slice(t.length), a))), L.info(`dropped ${s.length} staging table(s)`), 0) : (L.error(`${s.length} staging table(s) from an earlier \`--mode replace\`:\n` + s.map((e) => `    ${e}`).join("\n") + "\n\n  Each holds a copy of what a run was loading. Nothing else removes them.\n  Make sure no import is running right now — this cannot tell a leftover from one in flight.\n  Re-run with --yes to drop them."), 1);
+}, vt = async (e) => {
+	let { describeTransferRun: t, DATA_TRANSFERS_TABLE: n } = await import("@voltro/database"), r = Number(B(e, "--limit") ?? "20"), i = Number.isFinite(r) ? Math.max(1, Math.min(200, Math.trunc(r))) : 20;
+	if (B(e, "--target") === "api") {
+		let t = B(e, "--api-url");
+		if (!t) return L.error("--target api requires --api-url <url> (the running instance)"), 1;
+		let n = B(e, "--token") ?? process.env.VOLTRO_DATA_TRANSFER_SECRET;
+		if (!n) return L.error("--target api requires --token <secret> (or VOLTRO_DATA_TRANSFER_SECRET)"), 1;
+		let r = await fetch(`${t.replace(/\/+$/, "")}/_voltro/admin/imports?limit=${i}`, { headers: { authorization: `Bearer ${n}` } }), a = await r.text();
+		if (r.status !== 200) return L.error(`api imports: ${r.status} ${a}`), 1;
+		let o = JSON.parse(a);
+		if (e.includes("--json")) return console.log(a), 0;
+		let s = o.runs ?? [];
+		if (s.length === 0) return L.info("no imports recorded on this instance"), 0;
+		(o.running ?? 0) > 0 && L.info(`${o.running} import(s) IN FLIGHT — re-run this to watch the counters move`);
+		for (let e of s) L.info(`  ${e.line ?? ""}`);
+		return 0;
+	}
+	let { store: a } = await U(), o;
+	try {
+		o = await a.query({
+			table: n,
+			order: [{
+				column: "startedAt",
+				direction: "desc"
+			}],
+			predicate: void 0,
+			projection: void 0,
+			skip: 0,
+			take: i
+		});
+	} catch {
+		return L.error(`this target has no \`${n}\` table, so no import has been recorded here.\n  Run \`voltro db apply\`; imports themselves are unaffected by its absence.`), 1;
+	}
+	if (o.length === 0) return L.info("no imports recorded against this target"), 0;
+	for (let e of o) {
+		let n = e;
+		L.info(`  ${t({
+			...e,
+			startedAt: new Date(n.startedAt),
+			finishedAt: n.finishedAt === null ? null : new Date(n.finishedAt)
+		})}`);
+	}
+	return 0;
+}, yt = async (e) => {
+	let t = V(e), n = V(e.filter((e) => e !== t));
+	if (!t || !n) return L.error("usage: voltro data unpack <file.vbundle> <dir> [--passphrase <p>]"), 1;
+	let { resolve: r } = await import("node:path"), i = q(r(process.cwd(), t)), a = K(e);
+	return a && (i = D(i, a)), await xe(i, r(process.cwd(), n)), L.info("unpack complete", {
+		file: t,
+		dir: n
+	}), 0;
+}, $ = {
+	export: {
+		common: [
+			"--target",
+			"--tables",
+			"--exclude",
+			"--profile",
+			"--tenant",
+			"--assets",
+			"--compression",
+			"--consistency",
+			"--json"
+		],
+		directOnly: [
+			"--passphrase",
+			"--dry-run",
+			"--encrypt"
+		],
+		apiOnly: [
+			"--api-url",
+			"--token",
+			"--bundle-key",
+			"--timeout",
+			"--detach",
+			"--max-request-seconds"
+		]
+	},
+	"clear-staging": { common: ["--yes"] },
+	transfers: {
+		common: [
+			"--target",
+			"--limit",
+			"--json"
+		],
+		apiOnly: ["--api-url", "--token"]
+	},
+	"clear-replace-marker": { common: ["--yes"] },
+	import: {
+		common: [
+			"--target",
+			"--tables",
+			"--mode",
+			"--on-conflict",
+			"--atomic",
+			"--no-atomic",
+			"--assets",
+			"--force",
+			"--dry-run",
+			"--json"
+		],
+		directOnly: [
+			"--no-verify",
+			"--allow-live",
+			"--passphrase",
+			"--rollback-dir",
+			"--no-rollback"
+		],
+		apiOnly: [
+			"--api-url",
+			"--token",
+			"--bundle-key",
+			"--timeout",
+			"--chunk-size",
+			"--rollback-key",
+			"--detach",
+			"--max-request-seconds"
+		]
+	},
+	unpack: { common: ["--passphrase", "--json"] },
+	inspect: { common: ["--json", "--passphrase"] },
+	backup: { common: ["--json", "--assets"] },
+	restore: { common: [
+		"--json",
+		"--allow-live",
+		"--force",
+		"--drill",
+		"--drill-url",
+		"--api-url"
+	] }
+}, bt = (e) => e.split("=")[0], xt = (e, t) => {
+	let n = $[e];
+	if (!n) return;
+	let r = B(t, "--target") === "api" ? "api" : "direct", i = /* @__PURE__ */ new Set([...n.common, ...r === "api" ? n.apiOnly ?? [] : n.directOnly ?? []]), a = new Set(r === "api" ? n.directOnly ?? [] : n.apiOnly ?? []);
+	for (let n of t) {
+		if (!n.startsWith("--")) continue;
+		let t = bt(n);
+		if (i.has(t)) continue;
+		if (a.has(t)) return `voltro data ${e}: ${t} is not read with --target ${r} (it is a --target ${r === "api" ? "direct" : "api"} flag). Remove it, or change --target.`;
+		let o = Object.entries($).filter(([n, r]) => n !== e && [
+			...r.common,
+			...r.directOnly ?? [],
+			...r.apiOnly ?? []
+		].includes(t)).map(([e]) => e);
+		return o.length > 0 ? `voltro data ${e}: ${t} is not a \`${e}\` flag (it belongs to \`voltro data ${o.join("` / `")}\`). Remove it.` : `voltro data ${e}: unknown flag ${t}. Run \`voltro data --help\` for the flags this command reads.`;
+	}
+}, St = {
+	export: it,
+	import: ut,
+	transfers: vt,
+	inspect: ht,
+	unpack: yt,
+	backup: ft,
+	restore: mt,
+	"clear-replace-marker": gt,
+	"clear-staging": _t
+}, Ct = async (n) => {
+	let [r, ...i] = n;
+	if (r !== void 0 && $[r] !== void 0) {
+		let e = xt(r, i);
+		if (e) return L.error(e), 2;
+	}
+	let a = r === void 0 ? void 0 : St[r];
+	return a === void 0 ? (L.error(`usage: voltro data ${e(t)} … (logical: export/import; native: backup/restore; \`imports\` reads the history, incl. a run in flight)`), r ? 2 : 1) : a(i);
+};
+//#endregion
+export { Ct as runDataCommand };