@voltro/data-transfer 0.85.0 → 0.86.0

package/dist/index.js

@@ -1,2673 +1,28 @@
-import { Cause as e, Data as t, Effect as n, Exit as r, Metric as i, Option as a, Schedule as o, Schema as s, Stream as c } from "effect";
-import { DATA_TRANSFERS_TABLE as l, REPLACE_IN_PROGRESS_TABLE as u, STAGING_TABLE_PREFIX as d, _voltroDataTransfersTable as f, classifyConstraintViolation as p, derivedRowId as m, ensureTableRegistered as h, eq as g, extractDbCause as _, getTable as v, inSet as y, isNotNull as b, or as x, recordsTable as S, registerTable as ee, streamTable as C, suspendWriteRecorders as te, suspendWriteRecordersEffect as ne, unregisterTable as re } from "@voltro/database";
-import { fingerprintSchema as ie } from "@voltro/database/sql";
-import { createCipheriv as ae, createDecipheriv as oe, createHash as w, createHmac as T, randomBytes as E, randomUUID as se, scrypt as ce } from "node:crypto";
-import { copyFile as le, createReadStream as ue, createWriteStream as de, existsSync as fe, rename as D, statSync as O, unlinkSync as k } from "node:fs";
-import { STORAGE_REFS_TABLE as pe, fromNodeReadable as me, getObjectStream as A, putObjectStream as he, toNodeReadable as j } from "@voltro/plugin-storage";
-import * as M from "node:zlib";
-import { PassThrough as ge, Readable as _e } from "node:stream";
-import { SqlClient as ve } from "effect/sql";
-import { mkdir as N, readdir as ye, stat as be } from "node:fs/promises";
-import { basename as P, delimiter as F, dirname as xe, join as I, resolve as L, sep as Se } from "node:path";
-import { promisify as Ce } from "node:util";
-import { spawn as we } from "node:child_process";
-//#region src/consistency.ts
-var Te = (e) => {
-	switch (e) {
-		case "postgres": return ["SET TRANSACTION ISOLATION LEVEL REPEATABLE READ"];
-		case "mysql":
-		case "mariadb": return ["SET TRANSACTION ISOLATION LEVEL REPEATABLE READ"];
-		case "mssql": return ["SET TRANSACTION ISOLATION LEVEL SNAPSHOT"];
-		case "sqlite":
-		case "turso": return [];
-		default: return [];
-	}
-}, Ee = {
-	email: { fake: "email" },
-	fullName: { fake: "fullName" },
-	firstName: { fake: "firstName" },
-	lastName: { fake: "lastName" },
-	username: { fake: "username" },
-	phone: { fake: "phone" },
-	address: { fake: "address" },
-	company: { fake: "company" },
-	url: { fake: "url" },
-	ip: { fake: "ip" },
-	creditCard: { fake: "creditCard" },
-	date: "dateShift",
-	secret: "null",
-	freeText: "redact"
-}, De = (e) => {
-	let t = {};
-	for (let n of e.tables) {
-		let e = {};
-		for (let t of n.columns) e[t.name] = {
-			...t.sensitive ? { sensitive: t.sensitive } : {},
-			...t.safe ? { safe: !0 } : {},
-			columnType: t.type
-		};
-		t[n.name] = e;
-	}
-	return t;
-}, Oe = (e, t, n, r) => {
-	let i = r.columns?.[`${e}.${t}`];
-	if (i) return i;
-	if (n?.sensitive) {
-		let e = n.sensitive.class;
-		return r.classes?.[e] ?? Ee[e] ?? "redact";
-	}
-	return n?.safe ? r.onSafe ?? "keep" : n?.columnType === "id" || n?.columnType === "reference" ? "keep" : r.onUnclassified ?? "error";
-}, ke = (e, t) => T("sha256", e).update(t == null ? "∅" : String(t)).digest(), R = (e, t) => e.readUInt32BE(t * 4 % (e.length - 4)), Ae = [
-	"Ada",
-	"Alan",
-	"Grace",
-	"Linus",
-	"Ida",
-	"Ken",
-	"Barbara",
-	"Dennis",
-	"Radia",
-	"Guido",
-	"Margaret",
-	"Bjarne"
-], je = [
-	"Lovelace",
-	"Turing",
-	"Hopper",
-	"Torvalds",
-	"Rhodes",
-	"Thompson",
-	"Liskov",
-	"Ritchie",
-	"Perlman",
-	"Rossum",
-	"Hamilton",
-	"Stroustrup"
-], Me = [
-	"Maple",
-	"Oak",
-	"Cedar",
-	"Pine",
-	"Elm",
-	"Birch",
-	"Willow",
-	"Ash"
-], Ne = [
-	"Initech",
-	"Hooli",
-	"Umbrella",
-	"Acme",
-	"Globex",
-	"Soylent",
-	"Stark",
-	"Wayne"
-], z = (e, t, n) => e[R(t, n) % e.length], Pe = (e, t, n) => {
-	let r = ke(n, `${e}:${String(t)}`), i = R(r, 1) % 1e4;
-	switch (e) {
-		case "email": return `${z(Ae, r, 0).toLowerCase()}.${z(je, r, 2).toLowerCase()}${i}@example.com`;
-		case "fullName": return `${z(Ae, r, 0)} ${z(je, r, 1)}`;
-		case "firstName": return z(Ae, r, 0);
-		case "lastName": return z(je, r, 1);
-		case "username": return `${z(Ae, r, 0).toLowerCase()}${i}`;
-		case "phone": return `+1${String(R(r, 0) % 1e10).padStart(10, "0")}`;
-		case "address": return `${R(r, 0) % 9899 + 100} ${z(Me, r, 1)} St`;
-		case "company": return z(Ne, r, 0);
-		case "url": return `https://example.com/${r.toString("hex").slice(0, 12)}`;
-		case "ip": return `${R(r, 0) % 256}.${R(r, 1) % 256}.${R(r, 2) % 256}.${R(r, 3) % 254 + 1}`;
-		case "creditCard": return Fe(`4${r.toString("hex").replace(/\D/g, "").padEnd(14, "0").slice(0, 14)}`);
-		default: return `${e}_${r.toString("hex").slice(0, 8)}`;
-	}
-}, Fe = (e) => {
-	let t = e.slice(0, 15).split("").map(Number), n = 0;
-	t.forEach((e, t) => {
-		let r = e;
-		(15 - t) % 2 == 1 && (r *= 2, r > 9 && (r -= 9)), n += r;
-	});
-	let r = (10 - n % 10) % 10;
-	return e.slice(0, 15) + String(r);
-}, Ie = 864e5, Le = (e, t) => {
-	let n = e instanceof Date ? e.getTime() : Date.parse(String(e));
-	if (Number.isNaN(n)) return e;
-	let r = R(ke(t, "date-shift-offset"), 0) % 730 - 365, i = new Date(n + r * Ie);
-	return e instanceof Date ? i : i.toISOString();
-}, B = (e, t) => {
-	if (t.value === null || t.value === void 0) return null;
-	if (e === "error") throw Error(`masking: unresolved 'error' action for ${t.table}.${t.column}`);
-	if (e === "keep") return t.value;
-	if (e === "null") return null;
-	if (e === "redact") return t.columnType === "text" || typeof t.value == "string" ? "[redacted]" : null;
-	if (e === "hash") return ke(t.seed, t.value).toString("hex").slice(0, 16);
-	if (e === "dateShift") return Le(t.value, t.seed);
-	if (typeof e == "object" && "fake" in e) return Pe(e.fake, t.value, t.seed);
-	if (typeof e == "object" && "custom" in e) return e.custom(t);
-	if (typeof e == "object" && "json" in e) return Re(e, t);
-	throw Error(`masking: '${t.table}.${t.column}' resolved to an action this build does not understand (${JSON.stringify(e)}). Refusing to copy the value through. Valid actions: 'keep' | 'null' | 'redact' | 'hash' | 'dateShift' | { fake: '<class>' } | { custom: fn } | { json: { fields, rest? } }.`);
-}, Re = (e, t) => {
-	let { fields: n, rest: r = "redact" } = e.json, i = typeof t.value == "string" ? ze(t.value) : {
-		ok: !0,
-		value: t.value
-	};
-	if (!i.ok) return B(r, {
-		...t,
-		columnType: "text"
-	});
-	let a = (e, i) => {
-		if (e == null) return null;
-		if (Array.isArray(e)) return e.map((e, t) => a(e, `${i}[${t}]`));
-		if (typeof e == "object") {
-			let a = {};
-			for (let [o, s] of Object.entries(e)) {
-				let e = n[o] ?? r, c = `${i}.${o}`;
-				a[o] = typeof e == "object" && "json" in e ? Re(e, {
-					...t,
-					value: s,
-					column: c,
-					columnType: "json"
-				}) : B(e, {
-					...t,
-					value: s,
-					column: c,
-					columnType: typeof s == "string" ? "text" : "json"
-				});
-			}
-			return a;
-		}
-		return B(r, {
-			...t,
-			value: e,
-			column: i,
-			columnType: typeof e == "string" ? "text" : "json"
-		});
-	}, o = a(i.value, t.column);
-	return typeof t.value == "string" ? JSON.stringify(o) : o;
-}, ze = (e) => {
-	try {
-		return {
-			ok: !0,
-			value: JSON.parse(e)
-		};
-	} catch {
-		return { ok: !1 };
-	}
-}, Be = (e) => {
-	if (typeof e == "string") return e === "keep" || e === "null" || e === "redact" || e === "hash" || e === "dateShift" || e === "error";
-	if (typeof e != "object" || !e) return !1;
-	if ("fake" in e) return typeof e.fake == "string";
-	if ("custom" in e) return typeof e.custom == "function";
-	if ("json" in e) {
-		let t = e.json;
-		if (typeof t != "object" || !t) return !1;
-		let { fields: n, rest: r } = t;
-		return typeof n != "object" || !n ? !1 : Object.values(n).every(Be) && (r === void 0 || Be(r));
-	}
-	return !1;
-}, Ve = (e, t, n) => {
-	let r = {}, i = [], a = [];
-	for (let o of e) for (let e of o.columns) {
-		let s = `${o.name}.${e.name}`, c = Oe(o.name, e.name, t[o.name]?.[e.name], n);
-		if (c === "error") {
-			i.push(s);
-			continue;
-		}
-		if (!Be(c)) {
-			a.push({
-				column: s,
-				action: c
-			});
-			continue;
-		}
-		r[s] = c;
-	}
-	return {
-		actions: r,
-		unclassified: i,
-		invalid: a
-	};
-}, He = [
-	{
-		name: "email",
-		re: /[\w.+-]+@[\w-]+\.[\w.-]+/
-	},
-	{
-		name: "phone",
-		re: /(?:\+?\d[\d\s().-]{8,}\d)/
-	},
-	{
-		name: "ipv4",
-		re: /\b(?:\d{1,3}\.){3}\d{1,3}\b/
-	},
-	{
-		name: "creditCard",
-		re: /\b(?:\d[ -]?){13,16}\b/
-	}
-], Ue = (e, t, n) => {
-	let r = [], i = /* @__PURE__ */ new Set();
-	for (let [a, o] of Object.entries(n)) {
-		if (!a.startsWith(`${t}.`) || o !== "keep") continue;
-		let n = a.slice(t.length + 1);
-		for (let a of e) {
-			let e = a[n];
-			if (typeof e != "string" || e.length === 0) continue;
-			let o = He.find((t) => t.re.test(e));
-			if (o && !i.has(n)) {
-				i.add(n), r.push({
-					table: t,
-					column: n,
-					pattern: o.name,
-					sample: e.slice(0, 40)
-				});
-				break;
-			}
-		}
-	}
-	return r;
-}, We = (e, t, n, r, i) => {
-	let a = {};
-	for (let [o, s] of Object.entries(e)) a[o] = B(n[`${t}.${o}`] ?? "keep", {
-		value: s,
-		table: t,
-		column: o,
-		seed: r,
-		...i?.[o] ? { columnType: i[o] } : {}
-	});
-	return a;
-}, Ge = /* @__PURE__ */ new Map([
-	["_voltro_inspect_create_receipts", "inspect creation commands accepted by THIS deployment — a foreign receipt would replay or suppress a creation the target never accepted"],
-	["_voltro_isr_cache", "pages rendered by THIS deployment’s web processes — a foreign row would serve another environment’s HTML here"],
-	["_voltro_web_replicas", "heartbeats of the web processes running HERE — a foreign row advertises replicas that do not exist in the target"],
-	["_voltro_aggregate_meta", "materialized refresh generations computed HERE — a foreign row would claim that the target refreshed its own source data"],
-	["_voltro_aggregate_rows", "materialized rows tied to this deployment’s refresh generation — the target recomputes them from its own data"],
-	["_voltro_timeline", "captured source mutations from this deployment — foreign rows invent local timeline history"],
-	["_voltro_timeline_meta", "capture epoch and source cursor of this database — foreign metadata claims continuity with another database"],
-	["_voltro_timeline_leases", "active capture readers of this database — foreign leases claim readers that do not exist here"],
-	["_voltro_timeline_slots", "bounded capture slots belonging to this source epoch — foreign slots invent local mutation history"],
-	["_voltro_plugin_migrations", "plugin migration steps applied to this database — a foreign ledger would skip steps that the target has not run"],
-	["_voltro_migration_plans", "the schema fingerprint THIS deployment applied — a foreign row makes the next boot refuse"],
-	["_voltro_migrations", "which file-based migrations ran HERE — a foreign row marks unrun migrations as done"],
-	["_voltro_plugin_migrations", "which plugin migration steps ran HERE — a foreign row marks a plugin's unrun steps as done"],
-	["_voltro_schema_owner", "which app owns THIS database — a foreign row hands the target's schema to the source app, so the target's own app refuses to boot on it"],
-	["_voltro_deploys", "the deploy THIS database is in the middle of, with the baseline to undo it from — a foreign row makes the next apply undo a deploy the target never started"],
-	["_voltro_devices", "devices paired with THIS deployment — token hashes; a foreign row makes a device paired elsewhere authenticate here"],
-	["_voltro_seeds", "which seeds ran HERE — a foreign row suppresses seeding the target still needs"],
-	["_voltro_cdc_offsets", "binlog/WAL positions of the SOURCE server — meaningless and unsafe against another one"],
-	["_voltro_notification_push_subscriptions", "browser push endpoints bound to THIS deployment's VAPID key — the browser's applicationServerKey is derived from `VOLTRO_VAPID_PRIVATE_KEY`, so a push service refuses a delivery signed by another one. A foreign row makes the target attempt a delivery that must fail, and the auto-prune then deletes a subscription that was valid where it came from"],
-	["_voltro_schedule_claims", "live leases held by THIS deployment's replicas — a foreign row hands out a lease nobody holds"],
-	["_voltro_change_claims", "the record that ONE of THIS deployment's replicas already handled a given change — a foreign row asserts that an effect fired here when it fired somewhere else, so the subscriber or reaction it gates stands down for a notification nobody sent"],
-	["_voltro_replica_observations", "what THIS deployment's replicas last published about themselves — a foreign row invents a replica that does not exist here, and a fleet answer would then report it as present or, once it ages, as a replica that has stopped answering"],
-	["_voltro_data_transfers", "which bundles moved through HERE, in or out — a foreign row claims a transfer this deployment never ran"],
-	["_voltro_replace_in_progress", "the marker a destructive import HERE left behind — a foreign row refuses a boot over a healthy database"],
-	["_voltro_wakeups", "pending wakeups addressed to THIS deployment's runners"],
-	["_voltro_workflow_watermarks", "how far a consumer has read THIS deployment's event journal — a foreign position skips events"],
-	["_voltro_workflow_pending", "starts waiting to be drained HERE — a foreign row makes the target RUN a workflow somebody queued elsewhere"],
-	["_voltro_workflow_admissions", "the in-flight accounting a concurrency gate decides on — a foreign row makes the target refuse or admit wrongly"],
-	["_voltro_workflow_pauses", "which workflows an operator paused HERE — a foreign row silently pauses them in the target"],
-	["_voltro_workflow_event_deliveries", "which (event, trigger) pairs were already delivered HERE — a foreign row SUPPRESSES a delivery the target owes"],
-	["_voltro_traces", "spans recorded HERE — a foreign span claims a request this deployment never served"],
-	["_voltro_undo_log", "the before-images of mutations made HERE — a foreign row offers to undo a write into rows the target does not have"],
-	["_voltro_outbox", "messages waiting to be SENT by this deployment — a foreign row makes the target deliver something queued elsewhere"],
-	["_voltro_outbox_attempts", "the delivery attempts this deployment made — they belong to its outbox rows and to no other"],
-	["_voltro_ai_inferences", "offloaded inference work queued for THIS deployment's runners — a foreign row makes the target run somebody else's"],
-	["_voltro_ai_budget", "the live spend RESERVATION counter a budget refuses against — a foreign row makes the target refuse calls it should allow"],
-	["_voltro_ai_usage", "what this deployment spent on model calls — a foreign row overstates a bill nobody here ran up"],
-	["_voltro_budget_holds", "in-flight holds against a running deployment's budget — the same accounting `_voltro_workflow_admissions` keeps"],
-	["_voltro_ai_budget_reservations", "reservations held against THIS deployment's live spend counter — a foreign row makes the target refuse calls it should allow, exactly as `_voltro_ai_budget` does"],
-	["_voltro_storage_grants", "short-lived upload/download grants issued HERE — a foreign grant authorises nothing in the target"],
-	["_voltro_storage_usage", "how much storage this deployment accounts for — a foreign row makes a quota decision on somebody else's bytes"],
-	["_voltro_storage_operations", "the puts and deletes in flight against THIS provider, by physical key — a foreign row makes the target finish or undo an operation on a key it does not have"],
-	["_voltro_storage_object_heads", "which physical generation of each content-addressed object is live HERE — a foreign row points the target at a key it does not own"],
-	["_voltro_storage_object_claims", "which callers HERE still hold a shared object — a foreign row keeps the target retaining a key for a claimant it never had, or releases one it does"],
-	["_voltro_storage_put_intents", "the ref a reservation HERE will become — a foreign row makes the target confirm a write it never received"],
-	["_voltro_storage_operation_locks", "the per-tenant serialisation rows the operation transactions lock — a foreign row is a lock nobody here holds"],
-	["_voltro_idempotency", "the request keys this deployment has already answered — a foreign key SUPPRESSES a request the target never served"],
-	["_voltro_webhook_deliveries", "the delivery attempts this deployment made to a subscriber — a foreign row claims a call the target never placed"],
-	["_voltro_schedule_runs", "every schedule firing that happened HERE, replica ids included — a foreign row is history the target did not live"],
-	["_voltro_schedule_backfill_requests", "backfills queued for THIS deployment's runners — a foreign row makes the target re-run a range somebody asked another deployment for"],
-	["_voltro_tenant_namespaces", "which physical namespace each tenant lives in HERE — a foreign row points a tenant at a namespace the target does not have"],
-	["_voltro_workflow_execution_placements", "which physical store holds each execution HERE — a foreign row sends the target looking in a database it does not own"],
-	["_voltro_workflow_pool_permits", "concurrency permits held against a running deployment's budget — the same accounting `_voltro_workflow_admissions` keeps"],
-	["_voltro_workflow_admission_locks", "the locks an admission decision is being made under RIGHT NOW — a foreign row blocks or releases a decision the target is not making"],
-	["_voltro_workflow_submissions", "starts submitted HERE and not yet admitted — a foreign row makes the target admit a start somebody handed to another deployment"],
-	["_voltro_workflow_start_receipts", "the caller-facing identity of a start placed HERE, resolved through this deployment's placements — a foreign receipt names a run the target never accepted"],
-	["_voltro_workflow_control_requests", "cancel/resume traffic issued against executions HERE — a foreign row claims an operation nobody asked the target to perform"],
-	["_voltro_workflow_queued_cancellations", "cancellations waiting on a run that is queued HERE — a foreign row cancels something the target has not queued"],
-	["_voltro_workflow_restart_withdrawals", "withdrawal fences for restart requests issued HERE — a foreign row would block a target restart that its operator never withdrew"],
-	["_voltro_workflow_restart_requests", "restarts pending against this deployment's generations — a foreign row restarts a generation the target never entered"],
-	["_voltro_workflow_retry_requests", "retry intents an operator raised against runs HERE, keyed by their own request id — a foreign row binds the target to an intent nobody raised against it, and lets a later observation read somebody else's execution"],
-	["_voltro_workflow_parent_closures", "which parents are still waiting on children in flight HERE — a foreign row holds a parent open against a child the target is not running"],
-	["_voltro_workflow_failure_reports", "failures being handed off to a runner HERE — a foreign row makes the target take delivery of somebody else's failure"],
-	["_voltro_cdc_log", "the change rows this deployment captured from its own database — a foreign row replays a change that never happened here"],
-	["_voltro_notification_deliveries", "the notification attempts this deployment made — a foreign row claims a send the target never performed"],
-	["_voltro_notification_held", "notifications waiting to be SENT from here — a foreign row makes the target deliver something queued elsewhere"],
-	["_voltro_webhook_event_stats", "per-deployment delivery counters a backoff decision reads — foreign counts steer the target's retries"],
-	["_voltro_webhook_rate_windows", "the live rate-limit windows this deployment is inside — a foreign window throttles or releases wrongly"],
-	["cluster_runners", "the workflow runners of THIS deployment and their addresses — a foreign row routes shards to a runner that does not exist here"],
-	["cluster_locks", "the shard leases THIS deployment's runners hold — a foreign row holds a shard for nobody, and its work stalls"],
-	["cluster_messages", "workflow messages in flight HERE — a foreign row makes the target run work that was started, and may be running, elsewhere"],
-	["cluster_replies", "replies to those messages — a foreign row answers a request the target never sent"],
-	["cluster_migrations", "which engine migrations ran HERE — a foreign row marks the target's engine tables migrated when they are not"]
-]), Ke = /* @__PURE__ */ new Map([
-	["_voltro_comment_thread_events", "the status history of the app's comment threads — belongs with those threads"],
-	["_voltro_agent_threads", "conversations the app's users had — app data"],
-	["_voltro_agent_messages", "the messages in those conversations — app data"],
-	["_voltro_prompts", "prompt definitions the app authored — app data"],
-	["_voltro_api_keys", "keys the app issued (hashed) — app data, and a restore without them locks callers out"],
-	["_voltro_tenant_selections", "the tenant each user chose to act in — app data, verified against memberships on every request"],
-	["_voltro_kv", "the app's own key/value rows — app data by construction"],
-	["_voltro_approvals", "human decisions on workflow runs — they belong with the runs"],
-	["_voltro_connections", "third-party connections the app's users authorised. Portable as ROWS; note the secrets are encrypted with the project's key, so a target without that key holds ciphertext it cannot read"],
-	["_voltro_connection_grants", "who may use which connection — belongs with the connections"],
-	["_voltro_storage_blobs", "the stored objects' metadata — the assets travel with the bundle"],
-	["_voltro_storage_refs", "which rows reference which blob — belongs with the blobs"],
-	["_voltro_webhook_targets", "the endpoints subscribers registered through the app — app data"],
-	["_voltro_workflow_runs", "what the app's workflows did — history the app owns"],
-	["_voltro_workflow_run_steps", "the steps of those runs — belongs with the runs"],
-	["_voltro_workflow_run_events", "the events those runs emitted — belongs with the runs"],
-	["_voltro_workflow_events", "the app's event journal — app data (the target keeps its OWN watermarks, which are local)"],
-	["_voltro_workflow_start_contexts", "the context a start was made with — belongs with the runs"],
-	["_voltro_events", "the app's domain events — app data"],
-	["_voltro_ai_flows", "the flow definitions the app authored — app data"],
-	["_voltro_ai_flow_runs", "what those flows did — history the app owns, like a workflow run"],
-	["_voltro_notification_inbox", "what the app's users received — app data, and a restore without it loses their inbox"],
-	["_voltro_notification_preferences", "the per-user delivery settings the app's users chose — app data"],
-	["_voltro_notification_quiet_hours", "the per-user quiet hours the app's users chose — app data"],
-	["_voltro_notification_topic_subscriptions", "which topics the app's users subscribed to — app data"],
-	["_voltro_rebac_tuples", "the relationship tuples the app's authorisation decisions are made from — app data"],
-	["_voltro_scim_users", "identities an external directory provisioned into the app — app data"],
-	["_voltro_scim_groups", "groups an external directory provisioned into the app — app data"],
-	["_voltro_row_history", "the app's own row-version history — the point of keeping versions is that they survive a move"],
-	["_voltro_crdt_versions", "the version history of the app's collaborative documents (named snapshots, archived lineages) — it restores the document rows that travel with it"],
-	["_voltro_audit_log", "the app's audit trail — compliance data the app owns, not deployment bookkeeping"],
-	["_voltro_feature_flags", "the flags the app defined — app configuration"],
-	["_voltro_feature_flag_audit", "who changed which flag — belongs with the flags"],
-	["_voltro_comments", "the comments the app's users wrote — app data"],
-	["_voltro_comment_threads", "the threads those comments hang on — app data"],
-	["_voltro_comment_reactions", "the reactions the app's users left — app data"],
-	["_voltro_comment_reads", "which comments each user has read — app data, and losing it re-marks everything unread"],
-	["_voltro_comment_thread_events", "the status changes the app's users made on a thread — app data"]
-]), V = (e) => Ge.has(e), qe = (e) => Ge.get(e), Je = (e, t) => {
-	if (e.length === 0) return;
-	let n = e.map((e) => `    ${e} — ${qe(e) ?? "describes this deployment"}`);
-	return `${t} ${e.length} table(s) that describe a deployment rather than its data:\n${n.join("\n")}\n  A row from another environment is not stale there, it is a false statement about this one.`;
-}, H = class extends s.TaggedError()("BundleError", {
-	reason: s.String,
-	path: s.optional(s.String)
-}) {
-	get message() {
-		return this.path === void 0 ? this.reason : `${this.reason} (${this.path})`;
-	}
-}, Ye = class extends s.TaggedError()("CodecError", {
-	table: s.String,
-	reason: s.String
-}) {}, Xe = class extends s.TaggedError()("IntegrityError", {
-	what: s.String,
-	expected: s.String,
-	actual: s.String
-}) {
-	get message() {
-		return `${this.what}: expected ${this.expected}, got ${this.actual}`;
-	}
-}, Ze = class extends t.TaggedError("CompressionError") {}, Qe = class extends s.TaggedError()("ScopeError", { reason: s.String }) {
-	get message() {
-		return this.reason;
-	}
-}, $e = class extends s.TaggedError()("RowsRefusedError", {
-	rows: s.Array(s.Struct({
-		table: s.String,
-		id: s.String,
-		reason: s.String,
-		derived: s.Boolean
-	})),
-	primaryCount: s.Number,
-	totalCount: s.Number,
-	byTable: s.Array(s.Struct({
-		table: s.String,
-		refused: s.Number,
-		primary: s.Number
-	}))
-}) {}, et = class extends s.TaggedError()("SchemaDriftError", {
-	bundleFingerprint: s.String,
-	targetFingerprint: s.String,
-	diff: s.Array(s.String)
-}) {
-	get message() {
-		return `bundle schema ${this.bundleFingerprint} does not match target ${this.targetFingerprint}: ${this.diff.join("; ")}`;
-	}
-}, U = class extends t.TaggedError("NativeToolError") {
-	get message() {
-		let e = this.stderr?.trim(), t = this.hint?.trim();
-		return `${this.tool}: ${this.reason}${e ? `\n${e}` : ""}${t ? `\n\nhint: ${t}` : ""}`;
-	}
-}, tt = class extends s.TaggedError()("MaskingError", {
-	unclassified: s.Array(s.String),
-	invalidActions: s.optional(s.Array(s.String))
-}) {
-	get message() {
-		let e = [];
-		return this.unclassified.length > 0 && e.push(`unclassified columns: ${this.unclassified.join(", ")}`), this.invalidActions !== void 0 && this.invalidActions.length > 0 && e.push(`invalidActions: ${this.invalidActions.join(", ")}`), `masking refused — ${e.join("; ") || "no column may be exported"}`;
-	}
-}, nt = class extends s.TaggedError()("ImportModeError", {
-	mode: s.String,
-	reason: s.String
-}) {
-	get message() {
-		return `import mode '${this.mode}' refused: ${this.reason}`;
-	}
-}, rt = class extends s.TaggedError()("CrossDialectError", {
-	sourceDialect: s.String,
-	targetDialect: s.String,
-	blocking: s.Array(s.String)
-}) {}, it = (e, t) => e.tables.find((e) => e.name === t)?.columns.find((e) => e.type === "id")?.name ?? "id", at = (e, t, r) => n.gen(function* () {
-	let i = r.maxDepth ?? 12, a = new Set(r.pinned ?? []), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map();
-	for (let e of t.tables) u.has(e.name) || u.set(e.name, e);
-	let d = /* @__PURE__ */ new Map();
-	for (let [e, t] of u) d.set(e, {
-		pk: t.columns.find((e) => e.type === "id")?.name ?? "id",
-		fks: t.columns.filter((e) => e.references !== void 0).map((e) => ({
-			col: e.name,
-			refTable: e.references.table
-		}))
-	});
-	let f = (e) => d.get(e)?.pk ?? "id", p = (e) => {
-		let t = s.get(e) ?? /* @__PURE__ */ new Set();
-		return s.set(e, t), t;
-	}, m = (e, t) => {
-		if (t == null || a.has(e) || s.get(e)?.has(t)) return;
-		let n = l.get(e) ?? /* @__PURE__ */ new Set();
-		n.add(t), l.set(e, n);
-	}, h = (e, t, n) => {
-		let r = p(e), i = a.has(e) ? void 0 : o.get(e) ?? (() => {
-			let t = /* @__PURE__ */ new Set();
-			return o.set(e, t), t;
-		})();
-		return (e) => {
-			r.add(e[t]), i?.add(e[t]);
-			for (let t of n) m(t.refTable, e[t.col]);
-		};
-	}, g = (t, r) => {
-		let i = h(t, f(t), d.get(t)?.fks ?? []);
-		return c.runForEach(C(e, {
-			table: t,
-			pk: f(t),
-			...r === void 0 ? {} : { where: r }
-		}), (e) => n.sync(() => i(e)));
-	}, _ = n.gen(function* () {
-		for (let e = 0; e < i && l.size > 0; e++) {
-			let e = [...l.entries()];
-			l.clear();
-			for (let [t, n] of e) {
-				let e = [...n].filter((e) => !s.get(t)?.has(e));
-				if (e.length !== 0) for (let n = 0; n < e.length; n += 500) yield* g(t, y(f(t), e.slice(n, n + 500)));
-			}
-		}
-	});
-	for (let [e, t] of Object.entries(r.seeds)) yield* g(e, t);
-	if (yield* _, r.children) {
-		let e = new Set(r.children === !0 ? [...s.keys()] : r.children.roots.filter((e) => s.has(e))), a = /* @__PURE__ */ new Map();
-		for (let r = 0; r < i; r++) {
-			let r = !1, i = [];
-			for (let o of t.tables) {
-				let t = o.name, c = o.columns.map((e) => ({
-					col: e.name,
-					refTable: e.references?.table
-				})).filter((t) => !!t.refTable && e.has(t.refTable) && (s.get(t.refTable)?.size ?? 0) > 0);
-				if (c.length === 0) continue;
-				let l = s.get(t)?.size ?? 0, u = a.get(t);
-				u === void 0 && (u = /* @__PURE__ */ new Map(), a.set(t, u));
-				let d = [], f = 0, p = () => {
-					let e = d;
-					return d = [], f = 0, e.length === 0 ? n.void : g(t, e.length === 1 ? e[0] : x(...e));
-				};
-				for (let e of c) {
-					let t = u.get(e.col);
-					t === void 0 && (t = /* @__PURE__ */ new Set(), u.set(e.col, t));
-					let n = [...s.get(e.refTable)].filter((e) => !t.has(e));
-					for (let t = 0; t < n.length; t += 500) {
-						let r = n.slice(t, t + 500);
-						f + r.length > 500 && (yield* p()), d.push(y(e.col, r)), f += r.length;
-					}
-					for (let e of n) t.add(e);
-				}
-				yield* p(), (s.get(t)?.size ?? 0) > l && !e.has(t) && i.push(t), (s.get(t)?.size ?? 0) > l && (r = !0);
-			}
-			for (let t of i) e.add(t);
-			if (yield* _, !r) break;
-		}
-	}
-	return o;
-}), ot = (e, t) => ({
-	tables: [...e.keys()],
-	predicateFor: (n) => {
-		let r = e.get(n);
-		return r ? y(it(t, n), [...r]) : void 0;
-	}
-}), st = "tenantId", ct = (e, t, r) => n.gen(function* () {
-	let i = t.tables.map((e) => e.name), a = new Map(t.tables.map((e) => [e.name, e]));
-	if (e.kind === "all") {
-		let t = new Set(e.exclude ?? []);
-		return {
-			tables: i.filter((e) => !V(e) && !t.has(e)),
-			predicateFor: () => void 0
-		};
-	}
-	if (e.kind === "tables") {
-		let t = e.tables ?? [], r = new Set(i), a = t.filter((e) => !r.has(e));
-		if (a.length > 0) return yield* n.fail(new Qe({ reason: `scope { kind: 'tables' } names ${a.length} table(s) that are not in the schema: ${a.join(", ")}. Refusing to write a bundle that silently omits them. Known tables: ${i.length}.` }));
-		let o = new Set(t);
-		return {
-			tables: i.filter((e) => o.has(e)),
-			predicateFor: () => void 0
-		};
-	}
-	let o = e.tenantId;
-	if (o === void 0 || o === "") return yield* n.fail(new Qe({ reason: "scope { kind: 'tenant' } requires a tenantId — pass --tenant <id> (CLI) or scope.tenantId (API). Refusing to fall back to an unfiltered export." }));
-	let s = r.tenantTables ? r.tenantTables.filter((e) => a.has(e)) : i.filter((e) => a.get(e)?.columns.some((e) => e.name === st) ?? !1);
-	if (s.length === 0) return yield* n.fail(new Qe({ reason: r.tenantTables ? "tenant scope: none of the provided tenantTables exist in the schema — nothing to filter." : `tenant scope: no table carries a '${st}' column — nothing to filter. A tenant export of a schema without tenant-scoped tables would be the full database; refusing.` }));
-	let c = yield* at(r.store, t, {
-		seeds: Object.fromEntries(s.map((e) => [e, g(st, o)])),
-		pinned: s,
-		children: { roots: s }
-	}), l = [...c.entries()].filter(([, e]) => e.size > 0).map(([e]) => e), u = new Set(s);
-	return {
-		tables: [...s, ...l],
-		predicateFor: (e) => u.has(e) ? g(st, o) : c.has(e) ? y(it(t, e), [...c.get(e)]) : void 0
-	};
-}), lt = (e, t) => ({
-	list: t,
-	open: (t) => A(e, t)
-}), ut = (e) => ({
-	write: (t, n, r) => he(e, t, n, r),
-	has: (t) => e.head(t).pipe(n.map((e) => e !== null))
-}), dt = (e, t) => n.tryPromise({
-	try: async () => {
-		let { createWriteStream: n } = await import("node:fs"), r = await import("node:fs/promises"), { createHash: i, randomUUID: a } = await import("node:crypto"), { pipeline: o } = await import("node:stream/promises"), { Transform: s } = await import("node:stream"), c = await import("node:path"), l = c.join(t, `.tmp-${a()}`), u = i("sha256"), d = 0, f = new s({ transform(e, t, n) {
-			u.update(e), d += e.length, n(null, e);
-		} });
-		await o(await j(e.stream), f, n(l));
-		let p = u.digest("hex"), m = c.join(t, p);
-		try {
-			await r.access(m), await r.rm(l, { force: !0 });
-		} catch {
-			await r.rename(l, m);
-		}
-		return {
-			sha256: p,
-			size: d,
-			contentType: e.contentType
-		};
-	},
-	catch: (e) => new H({
-		reason: `asset write failed: ${String(e?.message ?? e)}`,
-		path: t
-	})
-}), ft = (e, t, r) => n.gen(function* () {
-	let i = yield* n.promise(() => import("node:path")), { createReadStream: a } = yield* n.promise(() => import("node:fs")), { createHash: o } = yield* n.promise(() => import("node:crypto")), s = i.join(t, r.sha256), l = o("sha256"), u = me("bundle", () => a(s)).pipe(c.tap((e) => n.sync(() => l.update(e))));
-	yield* e.write(r.key, u, {
-		contentType: r.contentType,
-		totalSize: r.size
-	});
-	let d = l.digest("hex");
-	if (d !== r.sha256) return yield* n.fail(new Xe({
-		what: `asset ${r.key}`,
-		expected: r.sha256,
-		actual: d
-	}));
-}), pt = {
-	done: () => !1,
-	mark: () => n.void
-}, mt = (e) => typeof e == "object" && !!e && e.status === 404, ht = (e) => n.gen(function* () {
-	let t = e.progress ?? pt, r = 0, i = 0, a = 0, o = 0, s = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), u = [];
-	return yield* c.runForEach(e.source.list(), (c) => (a++, t.done(c.key) || l.has(c.key) ? n.void : (l.add(c.key), e.source.open(c.key).pipe(n.map((e) => e), n.catchIf(mt, () => n.sync(() => {
-		u.push(c.key);
-	})), n.flatMap((a) => a === void 0 ? n.void : dt(a, e.assetsDir).pipe(n.flatMap((e) => {
-		let n = {
-			key: c.key,
-			sha256: e.sha256,
-			size: e.size,
-			contentType: e.contentType
-		};
-		return r++, i += e.size, s.has(e.sha256) || (s.add(e.sha256), o += e.size), t.mark(c.key, n);
-	}))))))).pipe(n.mapError((e) => e instanceof H ? e : new H({ reason: `asset export failed: ${String(e)}` }))), {
-		count: r,
-		totalBytes: i,
-		references: a,
-		objects: s.size,
-		objectBytes: o,
-		missing: u
-	};
-}), gt = (e) => me("bundle", () => ue(e)).pipe(c.decodeText(), c.splitLines, c.filter((e) => e.trim().length > 0), c.map((e) => JSON.parse(e)), c.mapError((t) => t instanceof H ? t : new H({
-	reason: `asset index unreadable: ${String(t)}`,
-	path: e
-}))), _t = (e) => n.gen(function* () {
-	let t = e.progress ?? pt, r = 0, i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
-	return yield* c.runForEach(gt(e.indexPath), (o) => t.done(o.key) || a.has(o.key) ? n.void : (a.add(o.key), ft(e.sink, e.assetsDir, o)).pipe(n.andThen(n.sync(() => {
-		r++, i.add(o.sha256);
-	})), n.andThen(t.mark(o.key, o)))), {
-		count: r,
-		objects: i.size
-	};
-}), vt = () => typeof M.createZstdCompress == "function", yt = (e) => e === "none" ? "none" : e === "gzip" ? "gzip" : vt() ? "zstd" : "gzip", bt = (e) => e === "zstd" ? ".zst" : e === "gzip" ? ".gz" : "", xt = (e) => e === "zstd" ? M.createZstdCompress() : e === "gzip" ? M.createGzip() : new ge(), St = (e) => e === "zstd" ? M.createZstdDecompress() : e === "gzip" ? M.createGunzip() : new ge(), Ct = 1, wt = s.Struct({
-	name: s.String,
-	file: s.String,
-	rowCount: s.Number,
-	checksum: s.String,
-	columnTypes: s.Record(s.String, s.String),
-	primaryKey: s.String
-}), Tt = s.Struct({
-	kind: s.Literals([
-		"all",
-		"tenant",
-		"tables"
-	]),
-	tenantId: s.optional(s.String),
-	tables: s.optional(s.Array(s.String)),
-	exclude: s.optional(s.Array(s.String))
-}), Et = s.Struct({
-	count: s.Number,
-	totalBytes: s.Number,
-	index: s.optional(s.String)
-});
-s.Struct({
-	key: s.String,
-	sha256: s.String,
-	size: s.Number,
-	contentType: s.String
-});
-var Dt = s.Struct({
-	formatVersion: s.Number,
-	createdAt: s.String,
-	source: s.Struct({
-		dialect: s.String,
-		schemaFingerprint: s.String
-	}),
-	scope: Tt,
-	consistency: s.Literals(["live", "snapshot"]),
-	compression: s.Literals([
-		"zstd",
-		"gzip",
-		"none"
-	]),
-	tables: s.Array(wt),
-	assets: Et,
-	masking: s.optional(s.Struct({
-		policyId: s.optional(s.String),
-		transformed: s.Array(s.String)
-	}))
-}), Ot = s.encodeSync(s.fromJsonString(Dt)), kt = s.decodeUnknownSync(s.fromJsonString(Dt)), At = "manifest.json", jt = "README.md", Mt = "data", Nt = "assets", Pt = "assets/index.ndjson", Ft = ".ledger.json", It = (e) => e.kind === "tenant" ? `tenant \`${e.tenantId}\`` : e.kind === "tables" ? `tables \`${(e.tables ?? []).join(", ")}\`` : "all tables", Lt = (e, t) => {
-	let n = e.tables.reduce((e, t) => e + t.rowCount, 0), r = e.masking ? `✅ **Masked at the source** — ${e.masking.transformed.length} column(s) transformed${e.masking.policyId ? ` (policy \`${e.masking.policyId}\`)` : ""}. Personal data was replaced with realistic, referentially-consistent fakes before any byte was written.` : "⚠️ **NOT masked — this bundle contains REAL data (PII included).** Treat it as production data: do not copy it into a lower environment or share it without review. To produce a safe copy, re-export under a masking profile (`--profile`).", i = e.masking && e.masking.transformed.length > 0 ? `\n\nMasked columns: ${e.masking.transformed.map((e) => `\`${e}\``).join(", ")}.` : "", a = e.assets.count > 0 ? `${e.assets.count} object(s), ${e.assets.totalBytes} bytes` : "none", o = e.tables.map((e) => `| \`${e.name}\` | ${e.rowCount} |`).join("\n");
-	return `# Voltro data export
-
-The machine-readable manifest is \`manifest.json\`; this file is a human summary.
-
-| | |
-|---|---|
-| **Generated** | ${e.createdAt} |
-| **Exported from** | \`${t.hostname}\` |
-| **Source dialect** | \`${e.source.dialect}\` |
-| **Format version** | ${e.formatVersion} |
-| **Consistency** | ${e.consistency} |
-| **Compression** | ${e.compression} |
-| **Scope** | ${It(e.scope)} |
-| **Tables** | ${e.tables.length} |
-| **Rows (total)** | ${n} |
-| **Assets** | ${a} |
-
-## Data sensitivity
-
-${r}${i}
-
-## Tables
-
-| Table | Rows |
-|---|---|
-${o}
-
-## Restore
-
-\`\`\`bash
-# into a stopped/replica DB directly:
-voltro data import <this-directory>
-
-# or into a running instance (needs the data-transfer secret):
-voltro data import <this-directory> --target api --api-url <url> --token <secret>
-\`\`\`
-`;
-}, Rt = i.counter("voltro_data_transfer_rows", { description: "Rows exported/imported by @voltro/data-transfer, tagged by phase + table." }), zt = Array.from({ length: 16 }, (e, t) => .01 * 2 ** t), Bt = i.histogram("voltro_data_transfer_table_seconds", {
-	boundaries: zt,
-	description: "Per-table export/import duration in seconds, tagged by phase."
-}), W = (e, t) => {
-	if (e) try {
-		e(t);
-	} catch {}
-}, Vt = (e, t, r, a, o, s) => n.Do.pipe(n.bind("start", () => n.clockWith((e) => e.currentTimeMillis)), n.bind("result", () => s), n.tap(({ start: r, result: a }) => n.clockWith((e) => e.currentTimeMillis).pipe(n.flatMap((s) => n.andThen(Bt.pipe(i.withAttributes({ phase: e }), i.update((s - r) / 1e3)), Rt.pipe(i.withAttributes({ phase: e }), i.withAttributes({ table: t }), i.update(o(a))))))), n.map(({ result: e }) => e), n.withSpan(`data-transfer.${e}.table`, { attributes: {
-	table: t,
-	index: r,
-	tableCount: a,
-	phase: e
-} })), Ht = () => ({
-	tables: {},
-	assets: {}
-}), Ut = (e) => n.tryPromise(async () => {
-	let t = await (await import("node:fs/promises")).readFile(e, "utf8");
-	return JSON.parse(t);
-}).pipe(n.orElseSucceed(Ht)), G = (e, t) => n.tryPromise({
-	try: async () => {
-		let n = await import("node:fs/promises"), { randomUUID: r } = await import("node:crypto"), i = `${e}.tmp-${r()}`;
-		await n.writeFile(i, JSON.stringify(t)), await n.rename(i, e);
-	},
-	catch: (t) => new H({
-		reason: `ledger write failed: ${String(t?.message ?? t)}`,
-		path: e
-	})
-}), Wt = (e, t) => t in e.tables, Gt = (e, t) => t in e.assets, Kt = /* @__PURE__ */ new Set([
-	"json",
-	"array",
-	"vector"
-]), qt = (e) => typeof e == "object" && !!e && !Array.isArray(e) && typeof e.$v == "string", Jt = (e) => Buffer.from(e).toString("base64"), Yt = (e) => new Uint8Array(Buffer.from(e, "base64")), Xt = (e) => e instanceof Date ? e.toISOString() : typeof e == "number" ? new Date(e).toISOString() : String(e), Zt = (e, t) => e == null ? null : t !== void 0 && Kt.has(t) ? e : t === "bytes" ? Jt(e) : t === "timestamp" || t === "date" ? Xt(e) : typeof e == "bigint" ? {
-	$v: "bigint",
-	d: e.toString()
-} : typeof e == "number" && !Number.isFinite(e) ? {
-	$v: "number",
-	d: String(e)
-} : e instanceof Date ? {
-	$v: "date",
-	d: e.toISOString()
-} : e instanceof Uint8Array ? {
-	$v: "bytes",
-	d: Jt(e)
-} : e, Qt = (e) => {
-	switch (e.$v) {
-		case "bigint": return BigInt(e.d);
-		case "number": return Number(e.d);
-		case "date": return new Date(e.d);
-		case "bytes": return Yt(e.d);
-		default: return e;
-	}
-}, $t = (e, t) => e == null ? null : t !== void 0 && Kt.has(t) ? e : qt(e) ? Qt(e) : t === "bytes" ? Yt(e) : t === "timestamp" || t === "date" ? new Date(e) : e, en = (e, t) => {
-	let n = {};
-	for (let [r, i] of Object.entries(e)) n[r] = Zt(i, t[r]);
-	return n;
-}, tn = (e, t) => {
-	let n = {};
-	for (let [r, i] of Object.entries(e)) n[r] = $t(i, t[r]);
-	return n;
-}, nn = new TextEncoder(), rn = (e, t) => e.pipe(c.map((e) => nn.encode(`${JSON.stringify(en(e, t))}\n`))), an = (e, t, r) => e.pipe(c.decodeText(), c.splitLines, c.filter((e) => e.trim().length > 0), c.mapEffect((e) => n.try({
-	try: () => tn(JSON.parse(e), r),
-	catch: (e) => new Ye({
-		table: t,
-		reason: String(e?.message ?? e)
-	})
-}))), on = (e, t) => {
-	let n = new Set(e), r = /* @__PURE__ */ new Map();
-	for (let e of t.tables) {
-		if (!n.has(e.name)) continue;
-		let t = /* @__PURE__ */ new Set();
-		for (let r of e.columns) {
-			let i = r.references?.table;
-			i && i !== e.name && n.has(i) && t.add(i);
-		}
-		r.set(e.name, t);
-	}
-	let i = [], a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), s = (e) => {
-		if (!(a.has(e) || o.has(e))) {
-			o.add(e);
-			for (let t of r.get(e) ?? []) s(t);
-			o.delete(e), a.add(e), i.push(e);
-		}
-	};
-	for (let t of e) n.has(t) && s(t);
-	return i;
-}, K = (e) => {
-	let t = e, n = [];
-	typeof t?._tag == "string" && t._tag !== "" && n.push(t._tag);
-	let r = typeof t?.message == "string" ? t.message.trim() : "";
-	if (r === "" ? t?.cause !== void 0 && t.cause !== null && n.push(K(t.cause)) : n.push(r), n.length === 0) {
-		let t = String(e ?? "").trim();
-		return t === "" || t === "[object Object]" ? sn(e) : t;
-	}
-	return n.join(": ");
-}, sn = (e) => {
-	try {
-		let t = JSON.stringify(e);
-		return t === void 0 || t === "{}" ? "unknown error (no message, cause or tag)" : t;
-	} catch {
-		return "unknown error (not serialisable)";
-	}
-}, cn = (e, t) => {
-	let n = e.tables.find((e) => e.name === t), r = {};
-	for (let e of n?.columns ?? []) e.generatedAs === void 0 && (r[e.name] = e.type);
-	return r;
-}, ln = (e, t) => (e.tables.find((e) => e.name === t)?.columns ?? []).filter((e) => e.generatedAs !== void 0).map((e) => e.name), un = (e, t) => {
-	if (t.length === 0) return e;
-	let n = { ...e };
-	for (let e of t) delete n[e];
-	return n;
-}, dn = (e, t) => {
-	let n = e.tables.find((e) => e.name === t);
-	if (n === void 0) return { refusal: `${t}: not in the schema snapshot, so its primary key is unknown.` };
-	let r = n.columns.find((e) => e.type === "id");
-	if (r !== void 0) return { column: r.name };
-	let i = n.indexes.find((e) => e.name === `${t}_pkey`)?.columns ?? n.primaryKey ?? [];
-	return i.length === 1 ? { column: i[0] } : i.length > 1 ? { refusal: `${t}: composite primary key (${i.join(", ")}). Keyset export orders by ONE column; ordering by the first alone would split equal values across pages and drop or duplicate rows. Exclude this table from the scope, or give it a single-column key.` } : { refusal: `${t}: no primary key, so there is no stable order to paginate by. A keyset export would return rows in an order the database may change between pages. Exclude this table from the scope.` };
-}, fn = (e, t, r) => n.tryPromise({
-	try: async () => {
-		let { createWriteStream: n } = await import("node:fs"), i = await import("node:fs/promises"), { createHash: a, randomUUID: o } = await import("node:crypto"), { pipeline: s } = await import("node:stream/promises"), { Readable: l, Transform: u } = await import("node:stream"), d = a("sha256"), f = 0, p = new u({ transform(e, t, n) {
-			d.update(e);
-			let r = e;
-			for (let e = 0; e < r.length; e++) r[e] === 10 && f++;
-			n(null, e);
-		} }), m = l.fromWeb(c.toReadableStream(e)), h = `${t}.tmp-${o()}`;
-		try {
-			await s(m, p, xt(r), n(h)), await i.rename(h, t);
-		} catch (e) {
-			throw await i.rm(h, { force: !0 }).catch(() => {}), e;
-		}
-		return {
-			rowCount: f,
-			checksum: d.digest("hex")
-		};
-	},
-	catch: (e) => new H({
-		reason: `write table failed: ${K(e)}`,
-		path: t
-	})
-}), pn = (e, t) => n.tryPromise({
-	try: async () => {
-		await (await import("node:fs/promises")).appendFile(e, `${t}\n`);
-	},
-	catch: (t) => new H({
-		reason: `append failed: ${K(t)}`,
-		path: e
-	})
-}), mn = (e, t) => n.gen(function* () {
-	let r = [], i = t.ordered.length;
-	for (let a = 0; a < t.ordered.length; a++) {
-		let o = t.ordered[a], s = cn(t.snapshot, o), l = dn(t.snapshot, o);
-		if ("refusal" in l) return yield* n.fail(new Qe({ reason: `export: ${l.refusal}` }));
-		let u = l.column, d = `${Mt}/${o}.ndjson${bt(t.compression)}`;
-		if (Wt(t.ledger, o)) {
-			let e = t.ledger.tables[o];
-			W(t.onProgress, {
-				phase: "export",
-				table: o,
-				index: a,
-				tableCount: i,
-				event: "done",
-				rowsDone: e.rowCount,
-				total: e.rowCount
-			}), r.push({
-				name: o,
-				file: d,
-				rowCount: e.rowCount,
-				checksum: e.checksum,
-				columnTypes: s,
-				primaryKey: u
-			});
-			continue;
-		}
-		W(t.onProgress, {
-			phase: "export",
-			table: o,
-			index: a,
-			tableCount: i,
-			event: "start",
-			rowsDone: 0
-		});
-		let f = t.resolved.predicateFor(o), p = C(e, {
-			table: o,
-			pk: u,
-			chunkSize: t.chunkSize,
-			retry: t.retry,
-			...f === void 0 ? {} : { where: f }
-		}), m = ln(t.snapshot, o), h = m.length === 0 ? p : p.pipe(c.map((e) => un(e, m))), g = t.mask ? h.pipe(c.map((e) => We(e, o, t.mask.actions, t.mask.seed, s))) : h, { rowCount: _, checksum: v } = yield* Vt("export", o, a, i, (e) => e.rowCount, fn(rn(g, s), t.bundleFile(d), t.compression));
-		t.ledger.tables[o] = {
-			rowCount: _,
-			checksum: v
-		}, yield* G(t.ledgerPath, t.ledger), W(t.onProgress, {
-			phase: "export",
-			table: o,
-			index: a,
-			tableCount: i,
-			event: "done",
-			rowsDone: _,
-			total: _
-		}), r.push({
-			name: o,
-			file: d,
-			rowCount: _,
-			checksum: v,
-			columnTypes: s,
-			primaryKey: u
-		});
-	}
-	return r;
-}), hn = (e) => ({
-	_tag: "RawSqlFragment",
-	strings: [e],
-	values: []
-}), gn = (t, i, a) => n.tryPromise({
-	try: () => t.transactional(async (t) => {
-		if (t.raw) for (let e of Te(i)) await t.raw(hn(e));
-		let o = await n.runPromiseExit(a(t));
-		if (r.isFailure(o)) throw Error(e.pretty(o.cause));
-		return o.value;
-	}),
-	catch: (e) => e instanceof H ? e : new H({ reason: `snapshot export failed: ${K(e)}` })
-}), _n = (e) => n.gen(function* () {
-	let t = e.scope ?? { kind: "all" }, r = yt(e.compression), i = e.chunkSize ?? 1e3, a = e.retryTimes ?? 5, s = o.max([o.exponential("50 millis").pipe(o.jittered), o.recurs(a)]), c = yield* n.promise(() => import("node:path")), l = (t) => c.join(e.outDir, t);
-	yield* n.tryPromise({
-		try: async () => {
-			let t = await import("node:fs/promises");
-			await t.mkdir(l(Mt), { recursive: !0 }), e.assets && await t.mkdir(l(Nt), { recursive: !0 });
-		},
-		catch: (t) => new H({
-			reason: `mkdir failed: ${K(t)}`,
-			path: e.outDir
-		})
-	});
-	let u = l(Ft), d = yield* Ut(u), f = e.subset ? ot(yield* at(e.store, e.snapshot, e.subset), e.snapshot) : yield* ct(t, e.snapshot, {
-		store: e.store,
-		...e.tenantTables ? { tenantTables: e.tenantTables } : {}
-	}), p = on(f.tables, e.snapshot), m = e.consistency ?? "live", h, g;
-	if (e.masking) {
-		let t = e.classification ?? De(e.snapshot), r = Ve(p.map((t) => ({
-			name: t,
-			columns: (e.snapshot.tables.find((e) => e.name === t)?.columns ?? []).map((e) => ({
-				name: e.name,
-				type: e.type
-			}))
-		})), t, e.masking);
-		if (r.unclassified.length > 0 || r.invalid.length > 0) return yield* n.fail(new tt({
-			unclassified: r.unclassified,
-			...r.invalid.length > 0 ? { invalidActions: r.invalid.map((e) => `${e.column}: ${JSON.stringify(e.action)}`) } : {}
-		}));
-		g = {
-			actions: r.actions,
-			seed: e.masking.seed
-		};
-		let i = Object.entries(r.actions).filter(([, e]) => e !== "keep").map(([e]) => e);
-		h = {
-			...e.masking.id ? { policyId: e.masking.id } : {},
-			transformed: i
-		};
-	}
-	let _ = {
-		snapshot: e.snapshot,
-		ordered: p,
-		resolved: f,
-		compression: r,
-		chunkSize: i,
-		retry: s,
-		ledger: d,
-		ledgerPath: u,
-		bundleFile: l,
-		...g ? { mask: g } : {},
-		...e.onProgress ? { onProgress: e.onProgress } : {}
-	}, v = m === "snapshot" ? yield* gn(e.store, e.dialect, (e) => mn(e, _)) : yield* mn(e.store, _), y = 0, b = 0;
-	if (e.assets) {
-		let t = l(Pt), r = yield* ht({
-			source: e.assets,
-			assetsDir: l(Nt),
-			progress: {
-				done: (e) => e in d.assets,
-				mark: (e, r) => (d.assets[e] = !0, pn(t, JSON.stringify(r)).pipe(n.andThen(G(u, d))))
-			}
-		});
-		y = r.count, b = r.totalBytes, r.missing.length > 0 && (yield* n.logWarning(`${r.missing.length} of ${r.missing.length + r.count} blob reference(s) point at objects the storage provider does not have; they are NOT in this bundle and no import can bring them back. e.g. ${r.missing.slice(0, 3).map((e) => `'${e}'`).join(", ")}` + (r.missing.length > 3 ? `, and ${r.missing.length - 3} more` : "")));
-	}
-	let x = {
-		formatVersion: 1,
-		createdAt: e.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-		source: {
-			dialect: e.dialect,
-			schemaFingerprint: ie(e.snapshot)
-		},
-		scope: t,
-		consistency: m,
-		compression: r,
-		tables: v,
-		assets: y > 0 ? {
-			count: y,
-			totalBytes: b,
-			index: Pt
-		} : {
-			count: 0,
-			totalBytes: 0
-		},
-		...h ? { masking: h } : {}
-	};
-	return yield* n.tryPromise({
-		try: async () => {
-			await (await import("node:fs/promises")).writeFile(l(At), Ot(x));
-		},
-		catch: (e) => new H({
-			reason: `manifest write failed: ${K(e)}`,
-			path: At
-		})
-	}), yield* n.tryPromise({
-		try: async () => {
-			let e = await import("node:fs/promises"), t = await import("node:os");
-			await e.writeFile(l(jt), Lt(x, { hostname: t.hostname() }));
-		},
-		catch: (e) => new H({
-			reason: `readme write failed: ${K(e)}`,
-			path: jt
-		})
-	}), x;
-}), vn = (e, t) => {
-	let n = new Set(t), r = [];
-	for (let t of e.tables) if (!n.has(t.name)) for (let e of t.columns) {
-		let i = e.references?.table;
-		i !== void 0 && n.has(i) && r.push({
-			from: t.name,
-			column: e.name,
-			to: i
-		});
-	}
-	return r;
-}, yn = (e) => {
-	let t = /* @__PURE__ */ new Map();
-	for (let n of e) t.set(n.from, [...t.get(n.from) ?? [], n]);
-	let n = [...t.entries()].map(([e, t]) => {
-		let n = t[0].rowCount, r = t.map((e) => `${e.column} → ${e.to}`).join(", ");
-		return `  ${e} (${n} row${n === 1 ? "" : "s"}): ${r}`;
-	});
-	return `replace cannot empty this target: ${t.size} table(s) OUTSIDE the bundle hold rows that reference tables INSIDE it. Emptying the bundle's tables would leave those rows pointing at nothing, and the bundle cannot restore them.\n${n.join("\n")}\nNothing has been deleted. Either re-export with a scope that includes those tables, or use --mode upsert if those rows are meant to survive.`;
-}, bn = (e) => {
-	switch (e) {
-		case "id":
-		case "text":
-		case "enum": return e === "enum" ? "enum" : "string";
-		case "integer": return "integer";
-		case "real": return "float";
-		case "boolean": return "boolean";
-		case "timestamp": return "datetime";
-		case "date": return "date";
-		case "json": return "json";
-		case "bytes": return "binary";
-		case "reference": return "reference";
-		case "vector": return "vector";
-		case "array": return "array";
-		case "interval": return "interval";
-		case "raw": return "raw";
-		default: return "string";
-	}
-}, xn = {
-	vector: /* @__PURE__ */ new Set(["postgres"]),
-	array: /* @__PURE__ */ new Set(["postgres"]),
-	interval: /* @__PURE__ */ new Set(["postgres"])
-}, Sn = (e, t, n, r) => {
-	let i = bn(n);
-	if (i === "raw") return {
-		table: e,
-		column: t,
-		type: n,
-		severity: "block",
-		reason: `raw() is verbatim source-dialect SQL — it cannot be assumed valid on ${r}`
-	};
-	let a = xn[i];
-	return !a || a.has(r) ? null : i === "array" || i === "interval" ? {
-		table: e,
-		column: t,
-		type: n,
-		severity: "warn",
-		reason: `${i} is native to postgres; ${r} will represent it as json/text — verify downstream reads`
-	} : {
-		table: e,
-		column: t,
-		type: n,
-		severity: "block",
-		reason: `${i} columns require a ${[...a].join("/")} target; ${r} has no compatible column type`
-	};
-}, Cn = (e, t, n) => {
-	if (t === n) return [];
-	let r = [];
-	for (let t of e) for (let [e, i] of Object.entries(t.columnTypes)) {
-		let a = Sn(t.name, e, i, n);
-		a && r.push(a);
-	}
-	return r;
-}, wn = (e) => `[${e.severity}] ${e.table}.${e.column} (${e.type}): ${e.reason}`, Tn = (e) => {
-	let t = e.constraint ?? e.column, n = t === void 0 ? "" : ` ${t}`;
-	switch (e.kind) {
-		case "foreignKey": return `foreign key${n}: the referenced row does not exist (import it first, or check the bundle's table order)`;
-		case "foreignKeyInUse": return `foreign key${n}: the row is still referenced by other rows`;
-		case "unique": return `unique constraint${n}: a row with this value already exists`;
-		case "notNull": return `not-null constraint${n}: the column requires a value`;
-		case "check": return `check constraint${n}: the row does not satisfy it`;
-	}
-}, En = (e) => {
-	let t = [e.dbCode, e.dbErrno ?? e.dbNumber].filter((e) => e !== void 0).map(String);
-	return t.length > 0 ? t.join("/") : void 0;
-}, Dn = "Failed to execute statement", On = (e) => {
-	let t = (e.split("\n", 1)[0] ?? "").trim();
-	return t === `SqlError: ${Dn}` ? Dn : t;
-}, kn = (e) => {
-	let t = String(e?.stack ?? e), n = t.length <= 1200 ? t : `${t.slice(0, 1200)}…`, r = (e, t) => ({
-		reason: e.length <= 300 ? e : `${e.slice(0, 300)}…`,
-		unclassified: t,
-		raw: n
-	}), i = _(e), a = p(i), o = En(i), s = o === void 0 ? "" : ` [${o}]`;
-	if (a !== void 0) return r(`${Tn(a)}${s}`, !1);
-	let c = typeof i.dbMessage == "string" ? i.dbMessage : void 0, l = e?.message, u = On(typeof l == "string" && l.length > 0 ? l : String(e)), d = c !== void 0 && c !== u && !c.startsWith("SqlError:") ? c : u, f = typeof i.dbCauseChain == "string" ? i.dbCauseChain : void 0, m = f !== void 0 && /[←‖]/.test(f) ? ` (via ${f})` : "";
-	return r(d === Dn || d.length === 0 ? `the database refused the write and the driver gave no detail${s}${m}` : `${d}${s}`, d === Dn || d.length === 0);
-}, An = (e) => kn(e).reason, jn = (e) => {
-	let t = _(e), n = p(t);
-	if (n?.kind === "foreignKeyInUse") {
-		let e = n.constraint ?? n.column, r = e === void 0 ? "" : ` ${e}`, i = En(t);
-		return `foreign key${r}: rows elsewhere still reference this table${i === void 0 ? "" : ` [${i}]`}`;
-	}
-	return An(e);
-}, Mn = d, q = (e) => `${Mn}${e}`, Nn = (e) => typeof e.run == "function", Pn = (e) => `staging is not available for this run — loading directly into the target instead: ${e}\n  The load therefore holds the destructive transaction open for its whole duration, so a
-  process that dies mid-load depends on the database rolling it back. The rollback capture
-  written before the first delete is what covers that case.`, Fn = /^[a-zA-Z_][a-zA-Z0-9_]*$/, J = (e, t) => {
-	if (!Fn.test(e)) throw Error(`refusing to build SQL for the table name ${JSON.stringify(e)}: it is outside the identifier class the framework allows. A name from a bundle manifest reaches this concatenation, so it is checked here rather than assumed to still be what the declaration validated.`);
-	return t === "mysql" || t === "mariadb" ? `\`${e}\`` : t === "mssql" ? `[${e}]` : `"${e}"`;
-}, In = (e, t) => {
-	let n = J(e, t), r = J(q(e), t);
-	switch (t) {
-		case "postgres": return `CREATE TABLE ${r} (LIKE ${n})`;
-		case "mysql":
-		case "mariadb": return `CREATE TABLE ${r} LIKE ${n}`;
-		case "sqlite": return `CREATE TABLE ${r} AS SELECT * FROM ${n} WHERE 0`;
-		case "mssql": return `SELECT * INTO ${r} FROM ${n} WHERE 1 = 0`;
-	}
-}, Ln = (e, t) => {
-	let n = J(q(e), t);
-	return t === "mssql" ? `IF OBJECT_ID('${q(e)}', 'U') IS NOT NULL DROP TABLE ${n}` : `DROP TABLE IF EXISTS ${n}`;
-}, Rn = (e, t) => {
-	let n = t === "mysql" || t === "mariadb", r = [];
-	n && r.push("SET FOREIGN_KEY_CHECKS = 0");
-	for (let n of [...e].reverse()) r.push(`DELETE FROM ${J(n.name, t)}`);
-	for (let n of e) {
-		if (n.columns.length === 0) throw Error(`refusing to build a swap for '${n.name}' with no columns: an empty list would have to mean \`SELECT *\`, which is the shape that fails on a generated column.`);
-		let e = n.columns.map((e) => J(e, t)).join(", ");
-		r.push(`INSERT INTO ${J(n.name, t)} (${e}) SELECT ${e} FROM ${J(q(n.name), t)}`);
-	}
-	return n && r.push("SET FOREIGN_KEY_CHECKS = 1"), r;
-}, zn = (e, t) => {
-	let n = [], r = () => {
-		for (let e of n) t.unregisterTable(e);
-	};
-	try {
-		for (let r of e) {
-			let e = t.getTable(r);
-			if (e === void 0) continue;
-			let i = q(r);
-			t.registerTable({
-				...e,
-				tableName: i,
-				isReactive: !1
-			}), n.push(i);
-		}
-	} catch (e) {
-		throw r(), e;
-	}
-	return {
-		staged: n,
-		undo: r
-	};
-}, Bn = (e, t) => {
-	let n = new Set(t), r = [];
-	for (let t of e.tables) {
-		if (!n.has(t.name)) continue;
-		let e = t.primaryKey?.[0] ?? "id";
-		for (let i of t.columns) {
-			let a = i.references;
-			a !== void 0 && n.has(a.table) && r.push({
-				from: t.name,
-				column: i.name,
-				to: a.table,
-				toColumn: a.column,
-				primaryKey: e
-			});
-		}
-	}
-	return r;
-}, Vn = (e, t) => {
-	let n = J(q(e.from), t), r = J(q(e.to), t), i = J(e.column, t), a = J(e.toColumn, t);
-	return `SELECT ${J(e.primaryKey, t)} AS pk, ${i} AS value FROM ${n} c WHERE ${i} IS NOT NULL AND NOT EXISTS (SELECT 1 FROM ${r} p WHERE p.${a} = c.${i})`;
-}, Hn = (e) => {
-	if (e.length === 0) return;
-	let t = e.slice(0, 20), n = t.map((e) => `    ${e.table}.${e.primaryKey}: ${e.column} = ${JSON.stringify(e.value)} — no such row in ${e.references}`);
-	return `the swap could not run: ${e.length} row(s) in the bundle reference a row the bundle does not carry.\n${n.join("\n")}\n` + (e.length > t.length ? `    … and ${e.length - t.length} more\n` : "") + "  The target is UNCHANGED — the swap runs in one transaction and none of it committed.\n  Every offending row is listed above rather than only the first, so this can be fixed in one pass.";
-}, Un = async (e, t) => {
-	t.length !== 0 && await e.run(ve.SqlClient.pipe(n.flatMap((e) => n.forEach(t, (t) => e.unsafe(t), { discard: !0 }))));
-}, Wn = async (e, t, r) => {
-	let i = Rn(t, r);
-	i.length !== 0 && await e.run(ve.SqlClient.pipe(n.flatMap((e) => e.withTransaction(n.forEach(i, (t) => e.unsafe(t), { discard: !0 })))));
-}, Gn = async (e, t, r) => {
-	let i = [];
-	for (let a of t) {
-		let t = await e.run(ve.SqlClient.pipe(n.flatMap((e) => e.unsafe(Vn(a, r)))));
-		for (let e of t) i.push({
-			table: a.from,
-			primaryKey: String(e.pk ?? ""),
-			column: a.column,
-			value: e.value,
-			references: a.to
-		});
-	}
-	return i;
-}, Kn = (e, t) => {
-	let n = new Map(t.map((e, t) => [e, t]));
-	return e.filter((e) => {
-		if (e.from === e.to) return !1;
-		let t = n.get(e.from), r = n.get(e.to);
-		return t === void 0 || r === void 0 ? !1 : r > t;
-	});
-}, qn = (e) => e === "mysql" || e === "mariadb", Jn = (e) => {
-	if (e.mode !== "replace") return {
-		active: !1,
-		tables: [],
-		blocker: `staging applies to \`replace\` only (this run is \`${e.mode}\`).`
-	};
-	let t = (() => {
-		let t = e.targetDialect;
-		return t === "postgres" || t === "mysql" || t === "mariadb" || t === "sqlite" || t === "mssql" ? t : void 0;
-	})();
-	if (t === void 0) return {
-		active: !1,
-		tables: [],
-		blocker: `the target dialect (${e.targetDialect ?? "unknown"}) is not one this build can stage on.`
-	};
-	if (!e.canRunSql) return {
-		active: !1,
-		tables: [],
-		blocker: "this store cannot send DDL (no raw-SQL channel), which a staged swap needs."
-	};
-	let n = e.targetSnapshot;
-	if (n === void 0) return {
-		active: !1,
-		tables: [],
-		blocker: "this caller did not supply a snapshot of the target schema, so the staging tables cannot be given the target's column shape."
-	};
-	let r = new Map(n.tables.map((e) => [e.name, e])), i = e.bundleTables.filter((t) => !e.isSkipped(t)), a = i.filter((e) => !r.has(e));
-	if (a.length > 0) return {
-		active: !1,
-		tables: [],
-		blocker: `the bundle carries ${a.length} table(s) the target does not have (${a.join(", ")}). Staging copies the TARGET's column shape, and there is none for those.`
-	};
-	let o = [];
-	for (let e of i) {
-		let t = r.get(e).columns.filter((e) => e.generatedAs === void 0).map((e) => e.name);
-		if (t.length === 0) return {
-			active: !1,
-			tables: [],
-			blocker: `\`${e}\` has no ordinary columns in the target (every column is generated), so a staged copy would have nothing to write.`
-		};
-		o.push({
-			name: e,
-			columns: t
-		});
-	}
-	if (o.length === 0) return {
-		active: !1,
-		tables: [],
-		blocker: "every table in the bundle is one that describes a deployment, so there is nothing for a staged swap to move."
-	};
-	let s = o.map((e) => e.name), c = qn(t) ? [] : Kn(Bn(n, s), s);
-	return c.length > 0 ? {
-		active: !1,
-		tables: [],
-		blocker: `the bundle's tables reference each other in a cycle (${c.map((e) => `${e.from}.${e.column} → ${e.to}`).join(", ")}), and a bulk copy cannot satisfy both directions on this dialect.`
-	} : {
-		active: !0,
-		tables: o
-	};
-}, Yn = (e) => n.gen(function* () {
-	if (e.mode !== "replace" || e.dir === void 0 || e.tables.length === 0) return;
-	if (e.snapshot === void 0) return yield* n.fail(new H({
-		reason: "rollback capture needs the TARGET's schema, and this run has none.\n  `--mode replace` empties the target first, so a run without a capture can leave it\n  emptied and unfilled if the process does not survive to roll back. Pass the target\n  snapshot, or `--no-rollback` to accept that risk deliberately.",
-		path: e.dir
-	}));
-	let t = {
-		...e.snapshot,
-		tables: e.snapshot.tables.filter((t) => e.tables.includes(t.name))
-	};
-	if (t.tables.length === 0) return;
-	e.onWarn?.(`capturing the target's current rows before emptying it → ${e.dir}\n  This is what a failed replace is restored FROM. It is written before the first delete,
-  so it survives a run whose process does not.`);
-	let r = yield* _n({
-		store: e.store,
-		snapshot: t,
-		dialect: e.dialect ?? "unknown",
-		outDir: e.dir,
-		scope: { kind: "all" },
-		compression: "none"
-	}).pipe(n.mapError((t) => new H({
-		reason: `rollback capture failed, so the import did not start and the target is untouched: ${t.reason ?? String(t)}\n  Fix the capture, or re-run with \`--no-rollback\` to proceed without one.`,
-		path: e.dir
-	})));
-	return {
-		dir: e.dir,
-		rows: r.tables.reduce((e, t) => e + t.rowCount, 0),
-		tables: r.tables.length
-	};
-}), Xn = (e) => `rollback capture: ${e.rows} row(s) across ${e.tables} table(s) → ${e.dir}\n  If this run does not finish, restore with:  voltro data import ${e.dir} --mode replace`, Zn = /__dropped_\d+$/, Qn = (e, t) => {
-	let n = [], r = /* @__PURE__ */ new Map();
-	for (let e of t.tables) {
-		let t = e.name;
-		r.has(t) || r.set(t, e);
-	}
-	for (let t of [...e.tables].sort((e, t) => e.name.localeCompare(t.name))) {
-		let e = r.get(t.name);
-		if (e === void 0) {
-			n.push(`table '${t.name}' is in the bundle but MISSING from the target — its rows have nowhere to go`);
-			continue;
-		}
-		let i = new Map(e.columns.map((e) => [e.name, e])), a = new Map(t.columns.map((e) => [e.name, e]));
-		for (let [e, r] of a) {
-			let a = i.get(e);
-			if (a === void 0) {
-				n.push(Zn.test(e) ? `${t.name}.${e}: a soft-dropped column, present only in the SOURCE — reclaim it there (voltro db gc-snapshots --before <date>) or re-export without it; the target is not missing anything` : `${t.name}.${e}: in the bundle, MISSING from the target — the value has nowhere to go`);
-				continue;
-			}
-			a.type !== r.type && n.push(`${t.name}.${e}: type '${r.type}' (bundle) vs '${a.type}' (target)`);
-		}
-		for (let [e, r] of i) a.has(e) || !r.nullable && !r.hasDefault && n.push(`${t.name}.${e}: the target requires it (NOT NULL, no default) and the bundle carries no value — every row of this table would fail`);
-	}
-	return n.length > 30 ? [...n.slice(0, 30), `… and ${n.length - 30} more difference(s)`] : n;
-}, $n = (e, t, n) => {
-	let r = ie(t);
-	if (r === e || n === void 0) return {
-		drifted: !1,
-		bundleFingerprint: e,
-		targetFingerprint: r,
-		diff: []
-	};
-	let i = Qn(n, t);
-	return {
-		drifted: i.length > 0,
-		bundleFingerprint: e,
-		targetFingerprint: r,
-		diff: i
-	};
-}, er = 2e3, tr = 2e3, nr = 200, rr = /* @__PURE__ */ new Set([
-	"BundleError",
-	"CodecError",
-	"IntegrityError",
-	"CrossDialectError",
-	"ImportModeError",
-	"RowsRefusedError",
-	"SchemaDriftError",
-	"StorageError"
-]), ir = (t) => {
-	let n = e.isCause(t) ? t : r.isExit(t) && r.isFailure(t) ? t.cause : void 0, i = n === void 0 ? [t] : n.reasons.flatMap((t) => e.isFailReason(t) ? [t.error] : e.isDieReason(t) ? [t.defect] : []);
-	for (let n of i) {
-		let i = n?._tag;
-		if (typeof i == "string" && rr.has(i)) return n;
-		if (n !== t && (e.isCause(n) || r.isExit(n))) {
-			let e = ir(n);
-			if (e) return e;
-		}
-	}
-}, ar = (t) => a.getOrUndefined(e.findErrorOption(t)) ?? Error(e.pretty(t)), or = (e) => n.tryPromise({
-	try: async () => {
-		let t = await import("node:fs/promises"), n = await import("node:path");
-		return kt(await t.readFile(n.join(e, At), "utf8"));
-	},
-	catch: (e) => new H({
-		reason: `manifest read/parse failed: ${String(e?.message ?? e)}`,
-		path: At
-	})
-}), sr = (e) => {
-	let t;
-	return n.gen(function* () {
-		let i = yield* n.promise(() => import("node:path")), a = yield* or(e.bundleDir);
-		if (a.formatVersion !== 1) return yield* n.fail(new H({ reason: `unsupported bundle formatVersion ${a.formatVersion} (expected 1)` }));
-		if (e.tables !== void 0) {
-			let t = new Set(a.tables.map((e) => e.name)), r = e.tables.filter((e) => !t.has(e));
-			if (r.length > 0) return yield* n.fail(new H({ reason: `--tables names ${r.length} table(s) this bundle does not carry: ${r.join(", ")}. The bundle carries: ${[...t].sort().join(", ")}.` }));
-		}
-		let o = e.tables === void 0 ? void 0 : new Set(e.tables), s = o === void 0 ? a : {
-			...a,
-			tables: a.tables.filter((e) => o.has(e.name))
-		};
-		if (e.targetSnapshot) {
-			let t = { tables: s.tables.map((e) => ({
-				name: e.name,
-				indexes: [],
-				columns: Object.entries(e.columnTypes).map(([e, t]) => ({
-					name: e,
-					type: t,
-					nullable: !0,
-					unique: !1,
-					hasDefault: !1
-				}))
-			})) }, r = $n(s.source.schemaFingerprint, e.targetSnapshot, t);
-			if (r.drifted) {
-				if (!e.force) return yield* n.fail(new et({
-					bundleFingerprint: r.bundleFingerprint,
-					targetFingerprint: r.targetFingerprint,
-					diff: r.diff
-				}));
-				e.onWarn?.(`schema drift: the target schema (fingerprint ${r.targetFingerprint.slice(0, 16)}) differs from the bundle's source (${r.bundleFingerprint.slice(0, 16)}); importing anyway (--force). ${r.diff.join("; ")}`);
-			}
-		}
-		if (e.targetDialect && e.targetDialect !== s.source.dialect) {
-			let t = Cn(s.tables, s.source.dialect, e.targetDialect).filter((e) => e.severity === "block");
-			if (t.length > 0 && !e.allowIncompatible) return yield* n.fail(new rt({
-				sourceDialect: s.source.dialect,
-				targetDialect: e.targetDialect,
-				blocking: t.map(wn)
-			}));
-		}
-		let d = e.verify ?? !0, p = e.mode ?? "upsert", g = e.atomic ?? p === "replace", _ = e.onConflict ?? "skip", y = e.ledgerPath ?? i.join(e.bundleDir, ".import..ledger.json"), x = yield* Ut(y);
-		if (p === "replace" && s.scope.kind !== "all") return yield* n.fail(new nt({
-			mode: p,
-			reason: `replace refuses a partial bundle (scope='${s.scope.kind}') — truncating would delete rows not in the bundle. Use --mode upsert, or re-export with full scope. To leave specific tables out of a FULL export, use \`--exclude a,b\`: it keeps the scope \`all\` and records what it left out.`
-		}));
-		if (p === "replace" && (s.scope.exclude?.length ?? 0) > 0) {
-			let t = s.scope.exclude;
-			e.onWarn?.(`this bundle was exported with ${t.length} table(s) excluded: ${t.join(", ")}.\n  A replace empties and refills the tables the bundle CARRIES, so those keep whatever rows the
-  target already holds. That is not "everything the bundle says" — check it is what you meant.`);
-		}
-		if (p === "replace") {
-			let t = s.tables.map((e) => e.name), r = e.store.incomingForeignKeys ? yield* n.tryPromise({
-				try: () => e.store.incomingForeignKeys(t),
-				catch: (e) => new H({ reason: `foreign-key pre-flight failed: ${jn(e)}` })
-			}) : e.targetSnapshot === void 0 ? [] : vn(e.targetSnapshot, t), i = [], a = /* @__PURE__ */ new Map();
-			for (let t of r) {
-				if (!a.has(t.from)) {
-					let r = yield* n.tryPromise({
-						try: () => e.store.query({
-							table: t.from,
-							predicate: void 0,
-							order: [],
-							take: void 0,
-							skip: void 0,
-							projection: []
-						}),
-						catch: () => new H({ reason: `unreadable: ${t.from}` })
-					}).pipe(n.map((e) => e.length), n.orElseSucceed(() => 0));
-					a.set(t.from, r);
-				}
-				let r = a.get(t.from) ?? 0;
-				r > 0 && i.push({
-					...t,
-					rowCount: r
-				});
-			}
-			if (i.length > 0) return yield* n.fail(new nt({
-				mode: p,
-				reason: yn(i)
-			}));
-		}
-		if (e.dryRun === !0) return e.traceId !== void 0 && (yield* n.promise(() => e.store.update(l, e.traceId, {
-			finishedAt: /* @__PURE__ */ new Date(),
-			tablesWritten: 0,
-			rowsWritten: 0,
-			failure: null
-		}).then(() => void 0, () => void 0))), {
-			manifest: s,
-			tablesWritten: 0,
-			rowsWritten: 0,
-			tablesSkipped: 0,
-			rowsSkipped: 0,
-			fullyResumed: !1
-		};
-		let C = /* @__PURE__ */ new Map();
-		for (let t of e.targetSnapshot?.tables ?? []) {
-			let e = t.columns.filter((e) => e.generatedAs !== void 0).map((e) => e.name);
-			e.length > 0 && C.set(t.name, e);
-		}
-		let ie = (e, t) => {
-			let n = C.get(e);
-			if (n === void 0) return t;
-			let r;
-			for (let e of n) e in t && (r ??= { ...t }, delete r[e]);
-			return r ?? t;
-		}, ae = (e, t, n, r = !1) => {
-			let i = A ? q(t.name) : t.name, a = t.primaryKey, o = w(t.name, ie(t.name, n), t.columnTypes);
-			return p === "append" ? _ === "fail" ? e.insert(i, o) : e.insertIgnore(i, o, { conflictColumns: [a] }) : p === "replace" ? r ? e.upsert(i, o, { conflictColumns: [a] }) : e.insert(i, o) : e.upsert(i, o, { conflictColumns: [a] });
-		}, oe = e.targetDialect !== void 0 && e.targetDialect !== "memory", w = (e, t, n) => {
-			if (!oe || n === void 0 || v(e) !== void 0) return t;
-			let r = null;
-			for (let [e, i] of Object.entries(n)) {
-				let n = t[e];
-				i === "json" && n != null && (r === null && (r = { ...t }), r[e] = JSON.stringify(n));
-			}
-			return r ?? t;
-		}, T = (e, t) => e.savepoint ? e.savepoint(t) : t(), E = 0, se = (t, n, r) => {
-			r.unclassified && (E++, !(E > 3) && e.onWarn?.(`row refused with no driver detail — table '${t.name}', row '${String(n.id ?? "?")}'. The full rendering follows so the LAYER that refused is on the record; it is logged, never returned. ${r.raw}` + (E === 3 ? " (further unclassified refusals are counted, not logged)" : "")));
-		}, ce = (e, t, r = !0) => n.tryPromise({
-			try: e,
-			catch: (e) => kn(e)
-		}).pipe(n.map(() => !0), n.catch((e) => n.sync(() => (r && (t.reason = e.reason, se(t.entry, t.row, e)), !1)))), le = (e) => {
-			let t = Object.entries(e.entry.columnTypes).filter(([t, n]) => n === "reference" && e.row[t] !== null && e.row[t] !== void 0).map(([e]) => e);
-			if (t.length !== 0) return {
-				...e.row,
-				...Object.fromEntries(t.map((e) => [e, null]))
-			};
-		}, de = (e) => {
-			let t = new Set(e.map((e) => String(e.row[e.entry.primaryKey]))), n = (e) => Object.entries(e.entry.columnTypes).some(([n, r]) => {
-				if (r !== "reference") return !1;
-				let i = e.row[n];
-				return i != null && t.has(String(i));
-			}), r = e.map((e) => ({
-				table: e.entry.name,
-				id: String(e.row[e.entry.primaryKey]),
-				reason: e.reason,
-				derived: n(e)
-			})), i = [...r.filter((e) => !e.derived), ...r.filter((e) => e.derived)], a = /* @__PURE__ */ new Map();
-			for (let e of r) {
-				let t = a.get(e.table) ?? {
-					refused: 0,
-					primary: 0
-				};
-				t.refused++, e.derived || t.primary++, a.set(e.table, t);
-			}
-			return new $e({
-				rows: i.slice(0, 20),
-				primaryCount: r.filter((e) => !e.derived).length,
-				totalCount: e.length,
-				byTable: [...a.entries()].map(([e, t]) => ({
-					table: e,
-					refused: t.refused,
-					primary: t.primary
-				})).sort((e, t) => t.refused - e.refused || e.table.localeCompare(t.table)).slice(0, 100)
-			});
-		}, fe = (e, t) => n.gen(function* () {
-			let r = t, i = [], a = !0;
-			for (; r.length > 0 && a;) {
-				a = !1;
-				let t = [];
-				for (let n of r) (yield* ce(() => T(e, () => ae(e, n.entry, n.row, !0)), n)) ? a = !0 : t.push(n);
-				if (!a && t.length > 0) for (let n = t.length - 1; n >= 0; n--) {
-					let r = t[n], o = le(r);
-					o !== void 0 && (yield* ce(() => T(e, () => ae(e, r.entry, o, !0)), r, !1)) && (i.push(r), t.splice(n, 1), a = !0);
-				}
-				r = t;
-			}
-			for (let t of i) (yield* ce(() => T(e, () => e.upsert(t.entry.name, w(t.entry.name, t.row, t.entry.columnTypes), { conflictColumns: [t.entry.primaryKey] })), t)) || (r = [...r, t]);
-			if (r.length > 0) return yield* n.fail(de(r));
-		}), D = (() => {
-			let t = e.targetDialect;
-			return t === "postgres" || t === "mysql" || t === "mariadb" || t === "sqlite" || t === "mssql" ? t : void 0;
-		})(), O = Jn({
-			mode: p,
-			...e.targetDialect === void 0 ? {} : { targetDialect: e.targetDialect },
-			...e.targetSnapshot === void 0 ? {} : { targetSnapshot: e.targetSnapshot },
-			bundleTables: s.tables.map((e) => e.name),
-			isSkipped: V,
-			canRunSql: Nn(e.store)
-		}), k = O.tables, pe = s.tables.filter((e) => !V(e.name) && S(e.name)).map((e) => e.name), A = O.active, he = !1, j = 0, M = 0, ge, _e, ve = 0, N = 0, ye = (t, r) => n.gen(function* () {
-			if (p === "replace" && !A && !(r && x.truncated)) {
-				e.recordInterruption === !0 && (yield* n.tryPromise({
-					try: () => t.insert(u, {
-						id: m("repl", be),
-						startedAt: P,
-						tables: String(s.tables.length),
-						capture: F?.dir ?? null,
-						via: e.via ?? "direct"
-					}),
-					catch: (e) => new H({ reason: `could not record that this replace started: ${String(e?.message ?? e)}\n  The marker is what makes an interrupted run visible instead of silent, so the run does
-  not proceed without it.` })
-				}));
-				let i = [...s.tables].reverse().map((e) => e.name).filter((e) => !V(e)), a = !r, o = t.emptyTables ? () => t.emptyTables(i) : a ? async () => {
-					for (let e of [...s.tables].reverse()) await t.deleteMany(e.name, { where: b(e.primaryKey) });
-				} : () => t.transactional(async (e) => {
-					for (let t of [...s.tables].reverse()) await e.deleteMany(t.name, { where: b(t.primaryKey) });
-				});
-				yield* n.tryPromise({
-					try: o,
-					catch: (e) => new H({ reason: `emptying the target for --mode replace failed (nothing was deleted): ${jn(e)}` })
-				}), r && (x.truncated = !0, yield* G(y, x));
-			}
-			let a = [], o = [], l = [], f = [], h = s.tables.length;
-			for (let u = 0; u < s.tables.length; u++) {
-				let m = s.tables[u];
-				if (V(m.name)) {
-					f.push(m.name);
-					continue;
-				}
-				if (r && m.name in x.tables) {
-					l.push(m.name), N++, ve += x.tables[m.name].rowCount, W(e.onProgress, {
-						phase: "import",
-						table: m.name,
-						index: u,
-						tableCount: h,
-						event: "done",
-						rowsDone: x.tables[m.name].rowCount,
-						total: m.rowCount
-					});
-					continue;
-				}
-				let _ = i.join(e.bundleDir, m.file);
-				W(e.onProgress, {
-					phase: "import",
-					table: m.name,
-					index: u,
-					tableCount: h,
-					event: "start",
-					rowsDone: 0,
-					total: m.rowCount
-				});
-				let v = a.length, b = n.gen(function* () {
-					let { createHash: r } = yield* n.promise(() => import("node:crypto")), i = r("sha256"), o = 0, l = me("bundle", () => ue(_).pipe(St(s.compression))).pipe(c.tap((e) => n.sync(() => i.update(e)))), u = async (e) => {
-						let n = {
-							entry: m,
-							row: e,
-							reason: ""
-						};
-						try {
-							await T(t, () => ae(t, m, e));
-						} catch (t) {
-							let r = kn(t);
-							n.reason = r.reason, se(m, e, r), a.push(n);
-						}
-					}, d = yield* n.promise(async () => {
-						let n = e.copyLoader;
-						if (!n || n.dialect !== "postgres") return !1;
-						if (g) return he || (he = !0, e.onWarn?.("bulk COPY is off for this run: it needs its own connection and this import runs in ONE transaction (the default for --mode replace, so a failure mid-load cannot leave the target emptied and unfilled). Pass --no-atomic to trade that guarantee back for COPY.")), !1;
-						if (p === "replace") return !0;
-						if (p !== "upsert") return !1;
-						try {
-							return (await t.query({
-								table: m.name,
-								predicate: void 0,
-								order: [],
-								take: 1,
-								skip: void 0,
-								projection: void 0
-							})).length === 0;
-						} catch {
-							return !1;
-						}
-					}), f = Object.keys(m.columnTypes), h = Math.max(1, e.copyBatchSize ?? 5e3), v = [], y = async () => {
-						if (v.length === 0) return;
-						let t = v;
-						v = [];
-						try {
-							await e.copyLoader.copyInto({
-								table: m.name,
-								columns: f,
-								columnTypes: m.columnTypes,
-								rows: t
-							});
-						} catch (n) {
-							d = !1, e.onWarn?.(`bulk COPY into ${m.name} failed (${String(n?.message ?? n)}); falling back to per-row writes for this table`);
-							for (let e of t) await u(e);
-						}
-					}, b = Math.max(1, e.savepointBatchSize ?? 200), x = typeof t.savepoint == "function", S = [], ee = async () => {
-						if (S.length === 0) return;
-						let e = S;
-						S = [];
-						try {
-							await t.savepoint(async () => {
-								for (let n of e) await ae(t, m, n);
-							});
-						} catch {
-							for (let t of e) await u(t);
-						}
-					};
-					return yield* c.runForEach(an(l, m.name, m.columnTypes), (e) => n.promise(async () => {
-						if (o++, _e?.(), d) {
-							v.push(e), v.length >= h && await y();
-							return;
-						}
-						if (x) {
-							S.push(e), S.length >= b && await ee();
-							return;
-						}
-						await u(e);
-					})), yield* n.promise(ee), yield* n.promise(y), {
-						rowCount: o,
-						checksum: i.digest("hex")
-					};
-				}), { rowCount: S, checksum: ee } = yield* Vt("import", m.name, u, h, (e) => e.rowCount, b);
-				if (d) {
-					if (ee !== m.checksum) return yield* n.fail(new Xe({
-						what: `table ${m.name} checksum`,
-						expected: m.checksum,
-						actual: ee
-					}));
-					if (S !== m.rowCount) return yield* n.fail(new Xe({
-						what: `table ${m.name} rowCount`,
-						expected: String(m.rowCount),
-						actual: String(S)
-					}));
-				}
-				W(e.onProgress, {
-					phase: "import",
-					table: m.name,
-					index: u,
-					tableCount: h,
-					event: "done",
-					rowsDone: S,
-					total: m.rowCount
-				}), M++, j += S, ge?.(), _e?.(), r && (a.length > v ? o.push({
-					name: m.name,
-					rowCount: S
-				}) : (x.tables[m.name] = {
-					rowCount: S,
-					checksum: m.checksum
-				}, yield* G(y, x)));
-			}
-			if (a.length > 0 && (yield* fe(t, a)), p === "replace" && (yield* n.promise(() => t.deleteMany(u, { where: {
-				column: "startedAt",
-				op: "lte",
-				value: P
-			} }).then(() => void 0, () => void 0))), r && o.length > 0) {
-				for (let e of o) {
-					let t = s.tables.find((t) => t.name === e.name);
-					x.tables[e.name] = {
-						rowCount: e.rowCount,
-						checksum: t.checksum
-					};
-				}
-				yield* G(y, x);
-			}
-			{
-				let t = Je(f, "skipped");
-				t !== void 0 && e.onWarn?.(t);
-			}
-			if (l.length > 0) {
-				let t = l.length === s.tables.length;
-				e.onWarn?.(`resume: ${l.length} of ${s.tables.length} table(s) were already applied by an earlier run of THIS bundle directory, so this run wrote NO rows for them${t ? " — that is every table in the bundle, so nothing was written at all" : ""}. Tables: ${l.join(", ")}. Delete ${y} to force a full re-import.`);
-			}
-		}), be = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`, P = /* @__PURE__ */ new Date(), F = yield* Yn({
-			store: e.store,
-			mode: p,
-			dir: e.rollbackDir,
-			snapshot: e.targetSnapshot,
-			dialect: e.targetDialect,
-			tables: s.tables.map((e) => e.name).filter((e) => !V(e)),
-			onWarn: e.onWarn
-		});
-		F !== void 0 && (e.onRollbackCaptured !== void 0 && (yield* n.tryPromise({
-			try: () => e.onRollbackCaptured(F),
-			catch: (e) => new H({
-				reason: `the rollback capture could not be stored durably, so the import did not start and the target is untouched: ${String(e?.message ?? e)}\n  The capture only helps if it outlives this process — that is the failure it exists for.`,
-				path: F.dir
-			})
-		})), e.onWarn?.(Xn(F)));
-		let xe = (e) => p === "replace" ? te(e) : e(), I = (e) => p === "replace" ? ne(e) : e, L = e.traceId ?? m("dimp", `${Date.now()}-${s.source.schemaFingerprint ?? ""}`), Se = e.traceId !== void 0, Ce = (e.targetSnapshot?.tables.some((e) => e.name === l) ?? !1) || v(l) !== void 0;
-		Ce && h(f), Ce && e.traceId === void 0 && (yield* n.promise(() => e.store.insert(l, {
-			id: L,
-			mode: p,
-			via: e.via ?? "direct",
-			direction: "import",
-			bundle: e.bundleDir,
-			sourceFingerprint: s.source.schemaFingerprint ?? null,
-			tablesWritten: 0,
-			rowsWritten: 0,
-			staged: p === "replace" ? A : null
-		}).then(() => {
-			Se = !0;
-		}, (t) => {
-			e.onWarn?.(`the import trace could not be written (${String(t?.message ?? t)}).\n  The import continues — this is a record of what happened, not a safety check. Run
-  \`voltro db apply\` so the next one is recorded.`);
-		}))), e.traceId !== void 0 && Ce && (yield* n.promise(() => e.store.update(l, L, {
-			staged: p === "replace" ? A : null,
-			sourceFingerprint: s.source.schemaFingerprint ?? null
-		}).then(() => void 0, () => void 0)));
-		let we = 0, Te = !1;
-		ge = () => {
-			if (!Se || Te) return;
-			let t = Date.now();
-			t - we < er || (we = t, e.store.update(l, L, {
-				tablesWritten: M,
-				rowsWritten: j
-			}).then(() => void 0, () => {
-				Te = !0;
-			}));
-		};
-		let Ee = (t) => Se ? e.store.update(l, L, {
-			finishedAt: t === null ? /* @__PURE__ */ new Date() : null,
-			tablesWritten: M,
-			rowsWritten: j,
-			failure: t
-		}).then(() => void 0, () => void 0) : Promise.resolve();
-		if (t = (e) => Ee(e), p === "replace" && !A && O.blocker !== void 0 && e.onWarn?.(Pn(O.blocker)), p === "replace" && pe.length > 0 && e.onWarn?.(`write recorders are SUSPENDED for this replace (${pe.length} table(s) have one).\n  A replace sets a state rather than changing rows, so a per-row history entry would describe
-  something that did not happen — and this path already writes through the raw store, without
-  tenant scoping or \`audit()\` stamping, for the same reason.`), A) {
-			e.onWarn?.(`staging ${k.length} table(s) before the swap — the target keeps its rows until the load stands.\n  The destructive step is one server-side transaction at the end, not the whole load.`);
-			let t = e.store, r = k.map((e) => e.name), i = m("repl", `staging-${be}`), a = !1;
-			if (e.recordInterruption === !0) {
-				yield* n.promise(() => e.store.insert(u, {
-					id: i,
-					startedAt: P,
-					kind: "staging",
-					tables: String(k.length),
-					capture: F?.dir ?? null,
-					via: e.via ?? "direct",
-					staging: r.map(q).join(","),
-					heartbeatAt: /* @__PURE__ */ new Date(),
-					resumable: !g
-				}).then(() => {
-					a = !0;
-				}, (t) => {
-					e.onWarn?.(`the staging tables could not be recorded (${String(t?.message ?? t)}).\n  The import continues and the target is unaffected — but if this run dies before the swap,
-  nothing at boot will mention the scratch tables it leaves. \`voltro data clear-staging\` finds
-  them by introspection.`);
-				}));
-				let t = Date.now();
-				_e = () => {
-					if (!a) return;
-					let n = Date.now();
-					n - t < tr || (t = n, e.store.update(u, i, { heartbeatAt: /* @__PURE__ */ new Date() }).then(() => void 0, () => void 0));
-				};
-			}
-			let o = () => a ? e.store.delete(u, i).then(() => void 0, () => void 0) : Promise.resolve(), s = zn(r, {
-				getTable: (e) => v(e),
-				registerTable: (e) => {
-					ee(e);
-				},
-				unregisterTable: re
-			}), c = !1;
-			try {
-				let i = g ? r : r.filter((e) => !Wt(x, e));
-				yield* n.tryPromise({
-					try: async () => {
-						await Un(t, i.map((e) => Ln(e, D))), await Un(t, i.map((e) => In(e, D)));
-					},
-					catch: (e) => new H({ reason: `could not prepare the staging tables, so the import did not start and the target is untouched: ${String(e?.message ?? e)}` })
-				}), yield* I(ye(e.store, !g)), !g && x.truncated === !0 ? c = !0 : yield* n.tryPromise({
-					try: () => Wn(t, k, D).then(() => {
-						c = !0;
-					}),
-					catch: (e) => new H({ reason: String(e?.message ?? e) })
-				}).pipe(n.catch((i) => n.gen(function* () {
-					let a = Hn(yield* n.promise(() => Gn(t, Bn(e.targetSnapshot, r), D).then((e) => e, () => [])));
-					return yield* n.fail(new H({ reason: a ?? `the swap failed and the target is UNCHANGED: ${i.reason}` }));
-				}))), !g && c && x.truncated !== !0 && (x.truncated = !0, yield* G(y, x));
-			} finally {
-				s.undo(), c || g ? (_e = void 0, yield* n.promise(() => Un(t, r.map((e) => Ln(e, D))).then(() => void 0, () => void 0)), yield* n.promise(o)) : e.onWarn?.("the staged rows are KEPT so a re-run can continue from them rather than reload.\n  If you are not going to re-run this bundle, drop them: voltro data clear-staging --yes");
-			}
-		} else g ? yield* n.tryPromise({
-			try: () => e.store.transactional(async (e) => {
-				let t = await xe(() => n.runPromiseExit(ye(e, !1)));
-				if (r.isFailure(t)) throw ar(t.cause);
-			}),
-			catch: (e) => ir(e) ?? new H({ reason: `atomic import failed (rolled back): ${String(e?.message ?? e)}` })
-		}) : yield* I(ye(e.store, !0));
-		if (e.assets && s.assets.index && !e.assetsAlreadyRestored) {
-			let t = e.assets;
-			yield* _t({
-				sink: t,
-				assetsDir: i.join(e.bundleDir, Nt),
-				indexPath: i.join(e.bundleDir, s.assets.index ?? "assets/index.ndjson"),
-				progress: {
-					done: (e) => e in x.assets,
-					mark: (e) => (x.assets[e] = !0, G(y, x))
-				}
-			});
-		}
-		return yield* n.promise(() => Ee(null)), {
-			manifest: s,
-			tablesWritten: M,
-			rowsWritten: j,
-			tablesSkipped: N,
-			rowsSkipped: ve,
-			fullyResumed: M === 0 && N > 0,
-			...F === void 0 ? {} : { rollback: F }
-		};
-	}).pipe(n.tapError((e) => n.promise(() => t?.(e?.reason ?? e?._tag ?? "the import did not finish") ?? Promise.resolve())));
-}, cr = (e) => e, lr = (e) => {
-	if (e.allowLive || e.liveInstance === null || e.sameTarget === "different") return { refuse: !1 };
-	let t = e.targetLabel === void 0 ? "" : ` Target: ${e.targetLabel}.`, n = e.sameTarget === "same" ? " That instance is connected to the SAME database." : " We could not confirm which database that instance is connected to, so this is refused on the conservative reading — an older instance, or one whose connection could not be parsed, reports nothing to compare.";
-	return {
-		refuse: !0,
-		message: `refusing to write into a target with a LIVE instance (${e.liveInstance}).${t}${n} A direct import is an uncoordinated concurrent writer — readers see partial state, the reactive layer either storms or goes stale, and rows race with live writes. Re-run with --allow-live to override, or use a live-safe strategy (shadow-swap for replace, or the api target).`
-	};
-}, Y = Buffer.from("VBUNDLE2"), ur = 0, dr = 1, fr = 2, pr = 32, mr = async (e) => {
-	let t = [], n = async (r) => {
-		let i;
-		try {
-			i = await ye(I(e, r), { withFileTypes: !0 });
-		} catch {
-			return;
-		}
-		for (let e of i) {
-			let i = r ? `${r}/${e.name}` : e.name;
-			e.isDirectory() ? await n(i) : e.isFile() && t.push(i);
-		}
-	};
-	return await n(""), t.sort();
-}, hr = (e, t) => {
-	let n = Buffer.from(e, "utf8"), r = Buffer.alloc(5 + n.length + 8);
-	return r.writeUInt8(dr, 0), r.writeUInt32BE(n.length, 1), n.copy(r, 5), r.writeBigUInt64BE(BigInt(t), 5 + n.length), r;
-}, gr = (e, t, n) => {
-	let r = Buffer.from(e, "utf8"), i = Buffer.from(t, "utf8"), a = Buffer.alloc(5 + r.length + 2 + i.length + 8), o = 0;
-	return a.writeUInt8(fr, o), o += 1, a.writeUInt32BE(r.length, o), o += 4, r.copy(a, o), o += r.length, a.writeUInt16BE(i.length, o), o += 2, i.copy(a, o), o += i.length, a.writeBigUInt64BE(BigInt(n), o), a;
-};
-async function* _r(e) {
-	yield new Uint8Array(Y);
-	for (let t of await mr(e.dir)) {
-		let n = I(e.dir, t), r = await be(n);
-		if (yield new Uint8Array(hr(t, r.size)), r.size > 0) for await (let e of ue(n)) yield new Uint8Array(e);
-	}
-	if (e.blobs) for await (let t of e.blobs.list()) {
-		yield new Uint8Array(gr(t.key, t.contentType, t.size));
-		let n = w("sha256"), r = 0;
-		for await (let i of e.blobs.open(t.key)) {
-			let e = Buffer.from(i);
-			n.update(e), r += e.length, yield new Uint8Array(e);
-		}
-		if (r !== t.size) throw Error(`blob '${t.key}' size mismatch: header ${t.size}, streamed ${r}`);
-		yield new Uint8Array(n.digest());
-	}
-	yield new Uint8Array(Buffer.from([ur]));
-}
-var vr = (e, t) => new Promise((n, r) => e.write(t, (e) => e ? r(e) : n())), yr = (e) => new Promise((t) => e.end(t)), br = async (e, t) => {
-	let n = L(t.dir);
-	await N(n, { recursive: !0 });
-	let r = Buffer.alloc(0), i = e[Symbol.asyncIterator](), a = !1, o = async () => {
-		let { value: e, done: t } = await i.next();
-		return t ? (a = !0, !1) : (r = r.length === 0 ? Buffer.from(e) : Buffer.concat([r, Buffer.from(e)]), !0);
-	}, s = async (e) => {
-		for (; r.length < e;) if (!await o()) throw Error("truncated bundle archive");
-	}, c = (e) => {
-		let t = r.subarray(0, e);
-		return r = r.subarray(e), t;
-	};
-	try {
-		if (await s(Y.length), !c(Y.length).equals(Y)) throw Error("not a bundle archive (bad magic)");
-		for (;;) {
-			await s(1);
-			let e = c(1).readUInt8(0);
-			if (e === ur) return;
-			if (e === dr) {
-				await s(4);
-				let e = c(4).readUInt32BE(0);
-				await s(e);
-				let t = c(e).toString("utf8");
-				await s(8);
-				let i = c(8).readBigUInt64BE(0), a = L(n, t);
-				if (a !== n && !a.startsWith(n + Se)) throw Error(`archive path '${t}' escapes the destination`);
-				await N(xe(a), { recursive: !0 });
-				let o = de(a);
-				for (; i > 0n;) {
-					r.length === 0 && await s(1);
-					let e = i < BigInt(r.length) ? Number(i) : r.length;
-					await vr(o, c(e)), i -= BigInt(e);
-				}
-				await yr(o);
-			} else if (e === fr) {
-				await s(4);
-				let e = c(4).readUInt32BE(0);
-				await s(e);
-				let n = c(e).toString("utf8");
-				await s(2);
-				let i = c(2).readUInt16BE(0);
-				await s(i);
-				let a = c(i).toString("utf8");
-				await s(8);
-				let o = c(8).readBigUInt64BE(0), l = await t.blobs.has(n), u = w("sha256"), d = new ge(), f = l ? Promise.resolve() : t.blobs.write(n, d, {
-					contentType: a,
-					size: Number(o)
-				}), p = o;
-				for (; p > 0n;) {
-					r.length === 0 && await s(1);
-					let e = p < BigInt(r.length) ? Number(p) : r.length, t = c(e);
-					u.update(t), l || await vr(d, t), p -= BigInt(e);
-				}
-				l ? d.destroy() : await yr(d), await f, await s(pr);
-				let m = c(pr);
-				if (!u.digest().equals(m)) throw Error(`blob '${n}' failed integrity (sha mismatch)`);
-			} else throw Error(`unknown bundle entry kind ${e}`);
-		}
-	} finally {
-		a || await Promise.resolve(i.return?.()).catch(() => void 0);
-	}
-}, xr = async (e, t) => {
-	let n = new Set(t), r = /* @__PURE__ */ new Map(), i = Buffer.alloc(0), a = e[Symbol.asyncIterator](), o = async () => {
-		let { value: e, done: t } = await a.next();
-		return !t && (i = i.length === 0 ? Buffer.from(e) : Buffer.concat([i, Buffer.from(e)]), !0);
-	}, s = async (e) => {
-		for (; i.length < e;) if (!await o()) return !1;
-		return !0;
-	}, c = (e) => {
-		let t = i.subarray(0, e);
-		return i = i.subarray(e), t;
-	}, l = async (e) => {
-		let t = [], n = e;
-		for (; n > 0n;) {
-			if (i.length === 0 && !await s(1)) return null;
-			let e = n < BigInt(i.length) ? Number(n) : i.length;
-			t.push(c(e)), n -= BigInt(e);
-		}
-		return Buffer.concat(t);
-	};
-	if (!await s(Y.length) || !c(Y.length).equals(Y)) throw Error("not a bundle archive (bad magic)");
-	for (; await s(1);) {
-		let e = c(1).readUInt8(0);
-		if (e === ur || e === fr) break;
-		if (e !== dr) throw Error(`unknown bundle entry kind ${e}`);
-		if (!await s(4)) break;
-		let t = c(4).readUInt32BE(0);
-		if (!await s(t)) break;
-		let i = c(t).toString("utf8");
-		if (!await s(8)) break;
-		let a = await l(c(8).readBigUInt64BE(0));
-		if (a === null || n.has(i) && (r.set(i, a), n.delete(i), n.size === 0)) break;
-	}
-	return r;
-}, Sr = (e, t) => br(e, {
-	dir: t,
-	blobs: Cr(t)
-}), Cr = (e) => {
-	let t = /* @__PURE__ */ new Set();
-	return {
-		has: async (e) => t.has(e),
-		write: async (n, r, i) => {
-			let a = await import("node:fs/promises"), { pipeline: o } = await import("node:stream/promises"), { Transform: s } = await import("node:stream"), c = I(e, "assets");
-			await N(c, { recursive: !0 });
-			let l = w("sha256"), u = 0, d = new s({ transform(e, t, n) {
-				l.update(e), u += e.length, n(null, e);
-			} }), f = I(c, `.tmp-${Date.now()}-${t.size}`);
-			await o(r, d, de(f));
-			let p = l.digest("hex");
-			await a.rename(f, I(c, p)), await a.appendFile(I(c, "index.ndjson"), `${JSON.stringify({
-				key: n,
-				sha256: p,
-				size: u,
-				contentType: i.contentType
-			})}\n`), t.add(n);
-		}
-	};
-}, wr = Ce(ce), Tr = Buffer.from("VENC1\0\0\0"), Er = 32, Dr = 16, Or = 7, kr = 16, X = 262144, Ar = {
-	N: 32768,
-	r: 8,
-	p: 1
-}, jr = 134217728, Mr = 43, Nr = (e, t, n) => {
-	let r = Buffer.alloc(12);
-	return e.copy(r, 0, 0, Or), r.writeUInt32BE(t >>> 0, Or), r.writeUInt8(+!!n, 11), r;
-};
-async function* Pr(e, t) {
-	if (!t) throw Error("encryptStream: a non-empty passphrase is required");
-	let n = E(Dr), r = E(Or), i = await wr(t, n, Er, {
-		...Ar,
-		maxmem: jr
-	}), a = Buffer.alloc(Mr);
-	Tr.copy(a, 0), a.writeUInt32BE(Ar.N, 8), a.writeUInt32BE(Ar.r, 12), a.writeUInt32BE(Ar.p, 16), n.copy(a, 20), r.copy(a, 36), yield new Uint8Array(a);
-	let o = 0, s = (e, t) => {
-		let n = ae("aes-256-gcm", i, Nr(r, o, t));
-		o === 0 && n.setAAD(a);
-		let s = Buffer.concat([n.update(e), n.final()]), c = n.getAuthTag();
-		o++;
-		let l = Buffer.alloc(5 + s.length + kr);
-		return l.writeUInt8(+!!t, 0), l.writeUInt32BE(s.length + kr, 1), s.copy(l, 5), c.copy(l, 5 + s.length), new Uint8Array(l);
-	}, c = Buffer.alloc(0), l = 0;
-	for await (let t of e) {
-		let e = Buffer.from(t), n = 0;
-		for (; n < e.length;) {
-			if (l === X && (yield s(c, !1), l = 0), l === 0 && e.length - n >= X) {
-				let t = e.subarray(n, n + X);
-				n += X, n < e.length ? yield s(t, !1) : (c = t, l = X);
-				continue;
-			}
-			c.length !== X && (c = Buffer.alloc(X));
-			let t = Math.min(X - l, e.length - n);
-			e.copy(c, l, n, n + t), l += t, n += t;
-		}
-	}
-	yield s(c.subarray(0, l), !0);
-}
-async function* Fr(e, t) {
-	if (!t) throw Error("decryptStream: a non-empty passphrase is required");
-	let n = e[Symbol.asyncIterator](), r = Buffer.alloc(0), i = 0, a = !1, o = async (e) => {
-		let t, o = 0;
-		for (; o < e;) {
-			if (i === r.length) {
-				if (a) break;
-				let e = await n.next();
-				if (e.done) {
-					a = !0;
-					break;
-				}
-				if (r = Buffer.from(e.value), i = 0, r.length === 0) continue;
-			}
-			if (o === 0 && r.length - i >= e) {
-				let t = r.subarray(i, i + e);
-				return i += e, t;
-			}
-			t ??= Buffer.alloc(e);
-			let s = Math.min(e - o, r.length - i);
-			r.copy(t, o, i, i + s), i += s, o += s;
-		}
-		return t?.subarray(0, o) ?? Buffer.alloc(0);
-	}, s = !1;
-	try {
-		let e = await o(Mr);
-		if (e.length !== Mr) throw Error("encrypted bundle truncated (no header)");
-		if (!e.subarray(0, 8).equals(Tr)) throw Error("not an encrypted bundle (bad magic / wrong passphrase target)");
-		let n = e.readUInt32BE(8), r = e.readUInt32BE(12), i = e.readUInt32BE(16), a = Buffer.from(e.subarray(20, 36)), s = Buffer.from(e.subarray(36, Mr)), c = await wr(t, a, Er, {
-			N: n,
-			r,
-			p: i,
-			maxmem: jr
-		}), l = 0, u = !1;
-		for (;;) {
-			let t = await o(5);
-			if (t.length !== 5) {
-				if (t.length === 0 && u) return;
-				throw Error("encrypted bundle truncated (no authenticated final frame)");
-			}
-			if (u) throw Error("encrypted bundle has trailing data after the final frame");
-			let n = t.readUInt8(0);
-			if (n !== 0 && n !== 1) throw Error("encrypted bundle corrupt (invalid final flag)");
-			let r = n === 1, i = t.readUInt32BE(1);
-			if (i < kr) throw Error("encrypted bundle corrupt (short frame)");
-			if (i > 262160) throw Error("encrypted bundle corrupt (oversized frame)");
-			let a = await o(i);
-			if (a.length !== i) throw Error("encrypted bundle truncated (frame body)");
-			let d = a.subarray(0, i - kr), f = a.subarray(i - kr), p = oe("aes-256-gcm", c, Nr(s, l, r));
-			l === 0 && p.setAAD(e), p.setAuthTag(f);
-			let m = Buffer.concat([p.update(d), p.final()]);
-			l++, r && (u = !0), m.length > 0 && (yield new Uint8Array(m));
-		}
-	} catch (e) {
-		throw s = !0, e;
-	} finally {
-		if (!a) try {
-			await n.return?.();
-		} catch (e) {
-			if (!s) throw e;
-		}
-	}
-}
-//#endregion
-//#region src/blobStorage.ts
-var Ir = (e, t) => ({
-	list: () => {
-		let e = t();
-		return { async *[Symbol.asyncIterator]() {
-			let t = await n.runPromise(c.runCollect(e));
-			for (let e of t) yield {
-				key: e.key,
-				contentType: e.contentType,
-				size: e.size
-			};
-		} };
-	},
-	open: (t) => ({ async *[Symbol.asyncIterator]() {
-		let r = await n.runPromise(A(e, t)), i = await j(r.stream);
-		for await (let e of i) yield e instanceof Uint8Array ? e : new Uint8Array(e);
-	} })
-}), Lr = (e, t) => Ir(e, () => C(t, {
-	table: pe,
-	chunkSize: 500
-}).pipe(c.map((e) => ({
-	key: String(e.key),
-	contentType: String(e.contentType ?? "application/octet-stream"),
-	size: Number(e.size ?? 0)
-})))), Rr = (e) => ({
-	has: (t) => n.runPromise(e.head(t).pipe(n.map((e) => e !== null))),
-	write: async (t, r, i) => {
-		let a = me("storage", () => _e.from(r));
-		await n.runPromise(he(e, t, a, {
-			contentType: i.contentType,
-			totalSize: i.size
-		}));
-	}
-}), zr = (e, t) => {
-	let n = t === "dump" ? "mariadb-dump" : "mariadb", r = t === "dump" ? "mysqldump" : "mysql";
-	return e === "mariadb" ? Br(n) ? { tool: n } : {
-		tool: r,
-		hint: `'${n}' is not on PATH, so this ran '${r}' instead. If that binary came from Oracle's MySQL client it queries information_schema.COLUMN_STATISTICS, which MariaDB does not have, and the run dies with error 1109 after the first table. Install the MariaDB client package (which ships '${n}') and re-run. Do NOT reach for --column-statistics=0: that flag does not exist on '${n}', so it fixes the wrong client and breaks the right one. Note: a MariaDB 12.x client requires TLS by default, so running '${n}' BY HAND against a server without it fails with "TLS/SSL error: SSL is required" (2026) and needs --skip-ssl. This command is not affected.`
-	} : { tool: r };
-}, Br = (e) => (process.env.PATH ?? "").split(F).filter((e) => e !== "").some((t) => fe(I(t, e))), Vr = (e) => {
-	switch (e) {
-		case "postgres": return "db.dump";
-		case "mysql":
-		case "mariadb": return "db.sql";
-		case "sqlite":
-		case "turso": return "db.sqlite";
-		case "mssql": return "db.bacpac";
-		default: return "db.dump";
-	}
-}, Hr = (e) => e.filename ?? e.database ?? ((e.url ?? "").replace(/^file:/, "") || "app.sqlite"), Z = (e, t = 3306) => {
-	if (e.host || e.database) return {
-		host: e.host ?? "localhost",
-		port: e.port ?? t,
-		username: e.username ?? "root",
-		password: e.password ?? "",
-		database: e.database ?? ""
-	};
-	let n = new URL(e.url ?? "");
-	return {
-		host: n.hostname || "localhost",
-		port: e.port ?? (n.port ? Number(n.port) : t),
-		username: decodeURIComponent(n.username) || "root",
-		password: decodeURIComponent(n.password) || "",
-		database: n.pathname.replace(/^\//, "") || ""
-	};
-}, Ur = (e) => `Server=${e.host},${e.port};Database=${e.database};User ID=${e.username};Password=${e.password};TrustServerCertificate=True`, Wr = (e, t, n) => {
-	switch (e) {
-		case "postgres": {
-			if (t.url) return {
-				kind: "spawn",
-				tool: "pg_dump",
-				args: [
-					"--format=custom",
-					"--no-owner",
-					"--no-privileges",
-					...Kr,
-					"--dbname",
-					t.url,
-					"--file",
-					n
-				],
-				env: {}
-			};
-			let e = Z(t, 5432);
-			return {
-				kind: "spawn",
-				tool: "pg_dump",
-				args: [
-					"--format=custom",
-					"--no-owner",
-					"--no-privileges",
-					...Kr,
-					"-h",
-					e.host,
-					"-p",
-					String(e.port),
-					"-U",
-					e.username,
-					"-d",
-					e.database,
-					"--file",
-					n
-				],
-				env: { PGPASSWORD: e.password }
-			};
-		}
-		case "mysql":
-		case "mariadb": {
-			let r = Z(t);
-			return {
-				kind: "spawn",
-				...zr(e, "dump"),
-				args: [
-					"--single-transaction",
-					"--routines",
-					"--triggers",
-					"--no-tablespaces",
-					"--protocol=TCP",
-					...Gr.map((e) => `--ignore-table=${r.database}.${e}`),
-					"-h",
-					r.host,
-					"-P",
-					String(r.port),
-					"-u",
-					r.username,
-					r.database
-				],
-				env: { MYSQL_PWD: r.password },
-				stdoutFile: n
-			};
-		}
-		case "sqlite":
-		case "turso": return {
-			kind: "copy",
-			from: Hr(t),
-			to: n
-		};
-		case "mssql": return {
-			kind: "spawn",
-			tool: "sqlpackage",
-			args: [
-				"/Action:Export",
-				`/SourceConnectionString:${Ur(Z(t, 1433))}`,
-				`/TargetFile:${n}`
-			],
-			env: {}
-		};
-		default: throw new U({
-			tool: "backup",
-			reason: `no native backup for dialect '${e}'`
-		});
-	}
-}, Gr = [u, l], Kr = Gr.flatMap((e) => ["--exclude-table", e]), qr = (e) => e === "postgres" || e === "mysql" || e === "mariadb" ? Gr : [], Jr = (e, t, n) => {
-	switch (e) {
-		case "postgres": {
-			if (t.url) return {
-				kind: "spawn",
-				tool: "pg_restore",
-				args: [
-					"--clean",
-					"--if-exists",
-					"--no-owner",
-					"--dbname",
-					t.url,
-					n
-				],
-				env: {}
-			};
-			let e = Z(t, 5432);
-			return {
-				kind: "spawn",
-				tool: "pg_restore",
-				args: [
-					"--clean",
-					"--if-exists",
-					"--no-owner",
-					"-h",
-					e.host,
-					"-p",
-					String(e.port),
-					"-U",
-					e.username,
-					"-d",
-					e.database,
-					n
-				],
-				env: { PGPASSWORD: e.password }
-			};
-		}
-		case "mysql":
-		case "mariadb": {
-			let r = Z(t);
-			return {
-				kind: "spawn",
-				...zr(e, "client"),
-				args: [
-					"--protocol=TCP",
-					"-h",
-					r.host,
-					"-P",
-					String(r.port),
-					"-u",
-					r.username,
-					r.database
-				],
-				env: { MYSQL_PWD: r.password },
-				stdinFile: n
-			};
-		}
-		case "sqlite":
-		case "turso": return {
-			kind: "copy",
-			from: n,
-			to: Hr(t)
-		};
-		case "mssql": {
-			let e = Z(t, 1433), r = Xr(e.database);
-			return {
-				kind: "mssql-replace",
-				load: {
-					kind: "spawn",
-					tool: "sqlpackage",
-					args: [
-						"/Action:Import",
-						`/TargetConnectionString:${Ur({
-							...e,
-							database: r
-						})}`,
-						`/SourceFile:${n}`
-					],
-					env: {}
-				},
-				server: {
-					host: e.host,
-					port: e.port,
-					username: e.username,
-					password: e.password,
-					database: "master"
-				},
-				live: e.database,
-				scratch: r,
-				carry: Gr
-			};
-		}
-		default: throw new U({
-			tool: "restore",
-			reason: `no native restore for dialect '${e}'`
-		});
-	}
-}, Q = (e) => `[${e.replaceAll("]", "]]")}]`, $ = (e) => `N'${e.replaceAll("'", "''")}'`, Yr = "__voltro_restore_", Xr = (e, t = se().slice(0, 8)) => `${e}${Yr}${t}`, Zr = (e) => e.replace(Yr, "__voltro_replaced_"), Qr = (e) => `IF DB_ID(${$(e)}) IS NOT NULL BEGIN ALTER DATABASE ${Q(e)} SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE ${Q(e)} END`, $r = (e) => `DECLARE @leftover sysname, @drop nvarchar(max);
-DECLARE leftovers CURSOR LOCAL FAST_FORWARD FOR SELECT name FROM sys.databases WHERE name LIKE ${$(`${`${e}${Yr}`.replace(/[\\%_[]/g, (e) => `\\${e}`)}%`)} ESCAPE N'\\';
-OPEN leftovers; FETCH NEXT FROM leftovers INTO @leftover;
-WHILE @@FETCH_STATUS = 0 BEGIN
-  SET @drop = N'ALTER DATABASE ' + QUOTENAME(@leftover) + N' SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE ' + QUOTENAME(@leftover);
-  EXEC(@drop);
-  FETCH NEXT FROM leftovers INTO @leftover;
-END`, ei = (e) => {
-	let t = Q(e.live), n = Q(e.scratch), r = Zr(e.scratch);
-	return {
-		prepare: [$r(e.live)],
-		carry: e.carry.map((e) => {
-			let r = $(`${n}.dbo.${Q(e)}`), i = $(`${t}.dbo.${Q(e)}`);
-			return `IF OBJECT_ID(${r}) IS NOT NULL BEGIN
-  DELETE FROM ${n}.dbo.${Q(e)};
-  IF OBJECT_ID(${i}) IS NOT NULL BEGIN
-    DECLARE @columns nvarchar(max) = (SELECT STRING_AGG(QUOTENAME(s.name), ',') FROM ${n}.sys.columns s
-      JOIN ${t}.sys.columns l ON l.name = s.name AND l.object_id = OBJECT_ID(${i})
-      WHERE s.object_id = OBJECT_ID(${r}) AND s.is_computed = 0);
-    EXEC(N'INSERT INTO ${n.replaceAll("'", "''")}.dbo.${Q(e).replaceAll("'", "''")} (' + @columns + N') SELECT ' + @columns + N' FROM ${t.replaceAll("'", "''")}.dbo.${Q(e).replaceAll("'", "''")}');
-  END
-END`;
-		}),
-		swap: [
-			`ALTER DATABASE ${t} SET SINGLE_USER WITH ROLLBACK IMMEDIATE`,
-			`ALTER DATABASE ${t} MODIFY NAME = ${Q(r)}`,
-			`ALTER DATABASE ${n} MODIFY NAME = ${t}`,
-			Qr(r)
-		],
-		undoSwap: [`IF DB_ID(${$(e.live)}) IS NULL AND DB_ID(${$(r)}) IS NOT NULL ALTER DATABASE ${Q(r)} MODIFY NAME = ${t}`, `IF DB_ID(${$(e.live)}) IS NOT NULL ALTER DATABASE ${t} SET MULTI_USER`],
-		cleanup: [Qr(e.scratch)]
-	};
-}, ti = (e) => {
-	let t = [];
-	for (let n = e, r = 0; n != null && r < 4; r++) {
-		let e = n instanceof Error ? n.message : typeof n == "object" && "message" in n ? String(n.message) : String(n);
-		e && !t.includes(e) && t.push(e), n = typeof n == "object" && "cause" in n ? n.cause : void 0;
-	}
-	return t.join(": ");
-}, ni = (e, t) => {
-	if (t === void 0) return n.fail(new U({
-		tool: "sqlpackage",
-		reason: "an mssql restore swaps databases and needs a SQL connection to the server; none was provided"
-	}));
-	let r = ei(e), i = (r, i) => t(e.server, i).pipe(n.mapError((e) => new U({
-		tool: "sqlpackage",
-		reason: `${r}: ${ti(e)}`
-	}))), a = i("dropping the scratch database", r.cleanup).pipe(n.ignore);
-	return n.gen(function* () {
-		yield* i(`preparing ${e.scratch}`, r.prepare), yield* ri(e.load).pipe(n.tapError(() => a)), yield* i(`carrying ${e.carry.join(", ")} into the imported copy`, r.carry).pipe(n.tapError(() => a)), yield* i(`swapping ${e.scratch} in as ${e.live}`, r.swap).pipe(n.tapError(() => i("putting the original database back", r.undoSwap).pipe(n.ignore)));
-	});
-}, ri = (e, t) => e.kind === "mssql-replace" ? ni(e, t) : e.kind === "copy" ? n.callback((t) => {
-	let r = `${e.to}.restoring-${se()}`, i = (e) => {
-		try {
-			k(r);
-		} catch {}
-		t(n.fail(new U({
-			tool: "copy",
-			reason: e
-		})));
-	};
-	le(e.from, r, (a) => {
-		if (a) {
-			i(`copy ${e.from} → ${e.to}: ${a.message}`);
-			return;
-		}
-		for (let t of [
-			`${e.to}-wal`,
-			`${e.to}-shm`,
-			`${e.to}-journal`
-		]) try {
-			k(t);
-		} catch {}
-		D(r, e.to, (r) => {
-			if (r) {
-				i(`copy ${e.from} → ${e.to}: ${r.message}`);
-				return;
-			}
-			t(n.void);
-		});
-	});
-}) : n.callback((t) => {
-	let r = we(e.tool, [...e.args], {
-		env: {
-			...process.env,
-			...e.env
-		},
-		stdio: [
-			"pipe",
-			e.stdoutFile ? "pipe" : "inherit",
-			"pipe"
-		]
-	}), i = "";
-	r.stderr?.on("data", (e) => {
-		i += String(e);
-	});
-	let a = !1, o = (e) => {
-		a || (a = !0, t(e));
-	}, s, c = (e) => {
-		s ??= e;
-	};
-	if (e.stdoutFile && r.stdout) {
-		let t = de(e.stdoutFile);
-		t.on("error", (t) => c(`writing ${P(e.stdoutFile)}: ${t.message}`)), r.stdout.on("error", (e) => c(`reading the tool's output: ${e.message}`)), r.stdout.pipe(t);
-	}
-	let l = 0;
-	if (e.stdinFile && r.stdin) {
-		let t = ue(e.stdinFile);
-		t.on("data", (e) => {
-			l += e.length;
-		}), t.on("error", (t) => {
-			c(`reading ${P(e.stdinFile)}: ${t.message}`), r.stdin?.end();
-		}), r.stdin.on("error", (t) => {
-			t.code !== "EPIPE" && c(`feeding ${P(e.stdinFile)} to ${e.tool}: ${t.message}`);
-		}), t.pipe(r.stdin);
-	}
-	let u = () => {
-		if (e.stdoutFile !== void 0) try {
-			k(e.stdoutFile);
-		} catch {}
-	};
-	r.on("error", (t) => {
-		u(), o(n.fail(new U({
-			tool: e.tool,
-			reason: `failed to launch (is '${e.tool}' installed + on PATH?): ${t.message}`,
-			...e.hint === void 0 ? {} : { hint: e.hint }
-		})));
-	}), r.on("close", (t) => {
-		if (t === 0 && s === void 0) {
-			o(n.void);
-			return;
-		}
-		u();
-		let r = e.stdinFile === void 0 ? "" : ` — ${l} of ${ii(e.stdinFile)} byte(s) of ${P(e.stdinFile)} had been fed to it`;
-		o(n.fail(new U({
-			tool: e.tool,
-			reason: (t === 0 ? `exited cleanly, but ${s}` : `exited with code ${t}${s === void 0 ? "" : ` (${s})`}`) + r + (e.stdoutFile === void 0 ? "" : ` — the partial ${P(e.stdoutFile)} was removed, so it cannot be mistaken for a backup`),
-			stderr: i.trim() === "" ? `(${e.tool} printed nothing to stderr)` : i.slice(-2e3),
-			...e.hint === void 0 ? {} : { hint: e.hint }
-		})));
-	});
-}), ii = (e) => {
-	try {
-		return String(O(e).size);
-	} catch {
-		return "?";
-	}
-}, ai = (e) => typeof e == "object" && e ? "fake" in e ? `fake:${e.fake}` : "custom" : String(e), oi = (e) => n.gen(function* () {
-	let t = yield* ct(e.scope ?? { kind: "all" }, e.snapshot, {
-		store: e.store,
-		...e.tenantTables ? { tenantTables: e.tenantTables } : {}
-	}), r = on(t.tables, e.snapshot), i = e.classification ?? De(e.snapshot), a = e.sampleSize ?? 20, o = Ve(r.map((t) => ({
-		name: t,
-		columns: (e.snapshot.tables.find((e) => e.name === t)?.columns ?? []).map((e) => ({
-			name: e.name,
-			type: e.type
-		}))
-	})), i, e.masking), s = [], l = [];
-	for (let i of r) {
-		let r = t.predicateFor(i), u = yield* C(e.store, {
-			table: i,
-			chunkSize: a,
-			...r === void 0 ? {} : { where: r }
-		}).pipe(c.take(a), c.runCollect, n.map((e) => [...e])), d = u.map((t) => We(t, i, o.actions, e.masking.seed));
-		l.push(...Ue(d, i, o.actions));
-		let f = u[0], p = d[0], m = [];
-		if (f && p) for (let [e, t] of Object.entries(o.actions)) {
-			if (!e.startsWith(`${i}.`) || t === "keep") continue;
-			let n = e.slice(i.length + 1);
-			m.push({
-				column: n,
-				action: ai(t),
-				before: f[n],
-				after: p[n]
-			});
-		}
-		s.push({
-			table: i,
-			samples: m
-		});
-	}
-	return {
-		tables: s,
-		leaks: l,
-		unclassified: o.unclassified
-	};
-}), si = (e, t) => {
-	let n = new Map(t.map((e) => [e.name, e])), r = [], i = {};
-	for (let t of e) {
-		let e = n.get(t.name);
-		if (e === void 0) {
-			r.push({
-				verdict: "refuse",
-				table: t.name,
-				detail: `the bundle carries '${t.name}' and the target schema has no such table — nowhere to put ${t.name}'s rows`
-			});
-			continue;
-		}
-		let a = new Map(e.columns.map((e) => [e.name, e])), o = new Map(t.columns.map((e) => [e.name, e])), s = [];
-		for (let e of t.columns) {
-			let n = a.get(e.name);
-			if (n === void 0) {
-				s.push(e.name), r.push({
-					verdict: "value-dropped",
-					table: t.name,
-					column: e.name,
-					detail: `'${t.name}.${e.name}' is in the bundle and not in the schema — its values are DISCARDED`
-				});
-				continue;
-			}
-			n.type !== e.type && r.push({
-				verdict: "refuse",
-				table: t.name,
-				column: e.name,
-				detail: `'${t.name}.${e.name}' changed type (${e.type} → ${n.type}) — the bundle's values would be written through a codec that no longer matches them`
-			});
-		}
-		for (let n of e.columns) if (!o.has(n.name)) {
-			if (n.nullable || n.hasDefault) {
-				r.push({
-					verdict: "filled-by-default",
-					table: t.name,
-					column: n.name,
-					detail: `'${t.name}.${n.name}' is in the schema and not in the bundle — every imported row gets ${n.hasDefault ? "its default" : "NULL"}`
-				});
-				continue;
-			}
-			r.push({
-				verdict: "refuse",
-				table: t.name,
-				column: n.name,
-				detail: `'${t.name}.${n.name}' is NOT NULL with no default and the bundle has no value for it`
-			});
-		}
-		s.length > 0 && (i[t.name] = s);
-	}
-	return {
-		findings: r,
-		skipColumns: i,
-		refuse: r.some((e) => e.verdict === "refuse")
-	};
-}, ci = (e) => {
-	if (e.findings.length === 0) return ["  schema matches the bundle"];
-	let t = {
-		safe: "✓",
-		"value-dropped": "⊖",
-		"filled-by-default": "⊕",
-		refuse: "✗"
-	}, n = e.findings.map((e) => `  ${t[e.verdict]} ${e.detail}`), r = (t) => e.findings.filter((e) => e.verdict === t).length;
-	return n.push(""), n.push(`  discarded: ${r("value-dropped")}   defaulted: ${r("filled-by-default")}   refused: ${r("refuse")}`), e.refuse && (n.push(""), n.push("  REFUSED — no row was written. These are the differences that would make"), n.push("  imported rows WRONG rather than merely incomplete.")), n;
-};
-//#endregion
-export { Nt as ASSETS_DIR, Pt as ASSET_INDEX_FILE, H as BundleError, Ye as CodecError, Ze as CompressionError, rt as CrossDialectError, Mt as DATA_DIR, Ee as DEFAULT_CLASS_ACTIONS, Ge as ENVIRONMENT_LOCAL_TABLES, Ke as ENVIRONMENT_PORTABLE_TABLES, Gr as EXCLUDED_FROM_DUMP, Ct as FORMAT_VERSION, nt as ImportModeError, Xe as IntegrityError, Ft as LEDGER_FILE, At as MANIFEST_FILE, tt as MaskingError, U as NativeToolError, $e as RowsRefusedError, nr as SAVEPOINT_BATCH_SIZE, Mn as STAGING_PREFIX, et as SchemaDriftError, Qe as ScopeError, B as applyAction, ir as asImportError, lr as assessLiveImport, Gt as assetDone, Vr as backupArtifactName, Wr as backupCommand, Nn as canStage, bn as canonicalType, ht as captureAssetsToCas, Cn as checkPortability, $n as checkSchemaDrift, De as classificationFromSnapshot, si as classifyImportDrift, bt as compressionExt, at as computeSubsetIds, Jn as decideStaging, kt as decodeManifest, tn as decodeRow, $t as decodeValue, Fr as decryptStream, cr as defineDataProfile, Qn as diffSnapshots, Cr as dirBlobSink, Ln as dropStagingSql, qr as dumpExcludedTables, Ht as emptyLedger, Ot as encodeManifest, en as encodeRow, Zt as encodeValue, Pr as encryptStream, Je as environmentLocalNotice, qe as environmentLocalReason, Un as execStatements, ci as formatImportDrift, wn as formatIssue, vt as hasZstd, V as isEnvironmentLocal, xt as makeCompressor, St as makeDecompressor, We as maskRow, ei as mssqlReplaceStatements, Xr as mssqlScratchName, an as ndjsonToRows, pt as noAssetProgress, yn as outsideReferenceRefusal, vn as outsideReferencesInto, _r as packBundle, xr as peekBundle, yt as pickCompression, Ve as planMasking, oi as previewMasking, gt as readAssetIndex, Ut as readLedger, Oe as resolveAction, ct as resolveScope, ft as restoreAssetFromCas, _t as restoreAssetsFromCas, Jr as restoreCommand, rn as rowsToNdjson, _n as runExport, sr as runImport, ri as runNativeStep, Ue as scanForLeaks, q as stagingNameFor, ut as storageAssetSink, lt as storageAssetSource, Rr as storageBlobSink, Ir as storageBlobSource, Lr as storageRefsBlobSource, ot as subsetToScope, Wt as tableDone, on as topoSortTables, br as unpackBundle, Sr as unpackBundleToDir, dt as writeAssetToCas, G as writeLedger };
+import { DEFAULT_CLASS_ACTIONS as e, applyAction as t, classificationFromSnapshot as n, maskRow as r, planMasking as i, resolveAction as a, scanForLeaks as o } from "./masking.js";
+import { ENVIRONMENT_LOCAL_TABLES as s, ENVIRONMENT_PORTABLE_TABLES as c, environmentLocalNotice as l, environmentLocalReason as u, isEnvironmentLocal as d } from "./environmentLocal.js";
+import { BundleError as f, CodecError as p, CompressionError as m, CrossDialectError as h, ImportModeError as g, IntegrityError as _, MaskingError as v, NativeToolError as y, RowsRefusedError as b, SchemaDriftError as x, ScopeError as S } from "./errors.js";
+import { computeSubsetIds as C, subsetToScope as w } from "./subset.js";
+import { resolveScope as T } from "./scope.js";
+import { restoreAssetFromCas as E, storageAssetSink as D, storageAssetSource as O, writeAssetToCas as k } from "./assets.js";
+import { captureAssetsToCas as A, noAssetProgress as j, readAssetIndex as M, restoreAssetsFromCas as N } from "./casAssetPhase.js";
+import { compressionExt as P, hasZstd as F, makeCompressor as I, makeDecompressor as L, pickCompression as R } from "./compress.js";
+import { ASSETS_DIR as z, ASSET_INDEX_FILE as B, DATA_DIR as V, FORMAT_VERSION as H, LEDGER_FILE as U, MANIFEST_FILE as W, decodeManifest as G, encodeManifest as K } from "./manifest.js";
+import { assetDone as q, emptyLedger as J, readLedger as Y, tableDone as X, writeLedger as Z } from "./ledger.js";
+import { decodeRow as Q, decodeValue as $, encodeRow as ee, encodeValue as te } from "./typedCodec.js";
+import { ndjsonToRows as ne, rowsToNdjson as re } from "./ndjson.js";
+import { topoSortTables as ie } from "./topo.js";
+import { runExport as ae } from "./exporter.js";
+import { outsideReferenceRefusal as oe, outsideReferencesInto as se } from "./replacePreflight.js";
+import { canonicalType as ce, checkPortability as le, formatIssue as ue } from "./crossDialect.js";
+import { STAGING_PREFIX as de, canStage as fe, decideStaging as pe, dropStagingSql as me, execStatements as he, stagingNameFor as ge } from "./stagedSwap.js";
+import { checkSchemaDrift as _e, diffSnapshots as ve } from "./schemaDrift.js";
+import { SAVEPOINT_BATCH_SIZE as ye, asImportError as be, runImport as xe } from "./importer.js";
+import { defineDataProfile as Se } from "./profile.js";
+import { assessLiveImport as Ce } from "./liveGuard.js";
+import { dirBlobSink as we, packBundle as Te, peekBundle as Ee, unpackBundle as De, unpackBundleToDir as Oe } from "./bundleArchive.js";
+import { decryptStream as ke, encryptStream as Ae } from "./bundleCrypto.js";
+import { storageBlobSink as je, storageBlobSource as Me, storageRefsBlobSource as Ne } from "./blobStorage.js";
+import { EXCLUDED_FROM_DUMP as Pe, backupArtifactName as Fe, backupCommand as Ie, dumpExcludedTables as Le, mssqlReplaceStatements as Re, mssqlScratchName as ze, restoreCommand as Be, runNativeStep as Ve } from "./nativeDump.js";
+import { previewMasking as He } from "./maskingPreview.js";
+import { classifyImportDrift as Ue, formatImportDrift as We } from "./driftClassification.js";
+export { z as ASSETS_DIR, B as ASSET_INDEX_FILE, f as BundleError, p as CodecError, m as CompressionError, h as CrossDialectError, V as DATA_DIR, e as DEFAULT_CLASS_ACTIONS, s as ENVIRONMENT_LOCAL_TABLES, c as ENVIRONMENT_PORTABLE_TABLES, Pe as EXCLUDED_FROM_DUMP, H as FORMAT_VERSION, g as ImportModeError, _ as IntegrityError, U as LEDGER_FILE, W as MANIFEST_FILE, v as MaskingError, y as NativeToolError, b as RowsRefusedError, ye as SAVEPOINT_BATCH_SIZE, de as STAGING_PREFIX, x as SchemaDriftError, S as ScopeError, t as applyAction, be as asImportError, Ce as assessLiveImport, q as assetDone, Fe as backupArtifactName, Ie as backupCommand, fe as canStage, ce as canonicalType, A as captureAssetsToCas, le as checkPortability, _e as checkSchemaDrift, n as classificationFromSnapshot, Ue as classifyImportDrift, P as compressionExt, C as computeSubsetIds, pe as decideStaging, G as decodeManifest, Q as decodeRow, $ as decodeValue, ke as decryptStream, Se as defineDataProfile, ve as diffSnapshots, we as dirBlobSink, me as dropStagingSql, Le as dumpExcludedTables, J as emptyLedger, K as encodeManifest, ee as encodeRow, te as encodeValue, Ae as encryptStream, l as environmentLocalNotice, u as environmentLocalReason, he as execStatements, We as formatImportDrift, ue as formatIssue, F as hasZstd, d as isEnvironmentLocal, I as makeCompressor, L as makeDecompressor, r as maskRow, Re as mssqlReplaceStatements, ze as mssqlScratchName, ne as ndjsonToRows, j as noAssetProgress, oe as outsideReferenceRefusal, se as outsideReferencesInto, Te as packBundle, Ee as peekBundle, R as pickCompression, i as planMasking, He as previewMasking, M as readAssetIndex, Y as readLedger, a as resolveAction, T as resolveScope, E as restoreAssetFromCas, N as restoreAssetsFromCas, Be as restoreCommand, re as rowsToNdjson, ae as runExport, xe as runImport, Ve as runNativeStep, o as scanForLeaks, ge as stagingNameFor, D as storageAssetSink, O as storageAssetSource, je as storageBlobSink, Me as storageBlobSource, Ne as storageRefsBlobSource, w as subsetToScope, X as tableDone, ie as topoSortTables, De as unpackBundle, Oe as unpackBundleToDir, k as writeAssetToCas, Z as writeLedger };