@voltro/data-transfer 0.85.0 → 0.86.0

package/dist/environmentLocal.js

@@ -0,0 +1,122 @@
+//#region src/environmentLocal.ts
+var e = /* @__PURE__ */ new Map([
+	["_voltro_storage_reference_catalogue", "the identity of THIS deployment's storage reference catalogue — a foreign marker would claim that independent metadata stores are one catalogue"],
+	["_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"]
+]), t = /* @__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"]
+]), n = (t) => e.has(t), r = (t) => e.get(t), i = (e, t) => {
+	if (e.length === 0) return;
+	let n = e.map((e) => `    ${e} — ${r(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.`;
+};
+//#endregion
+export { e as ENVIRONMENT_LOCAL_TABLES, t as ENVIRONMENT_PORTABLE_TABLES, i as environmentLocalNotice, r as environmentLocalReason, n as isEnvironmentLocal };

package/dist/errors.js

@@ -0,0 +1,82 @@
+import { Data as e, Schema as t } from "effect";
+//#region src/errors.ts
+var n = class extends t.TaggedError()("BundleError", {
+	reason: t.String,
+	path: t.optional(t.String)
+}) {
+	get message() {
+		return this.path === void 0 ? this.reason : `${this.reason} (${this.path})`;
+	}
+}, r = class extends t.TaggedError()("CodecError", {
+	table: t.String,
+	reason: t.String
+}) {}, i = class extends t.TaggedError()("IntegrityError", {
+	what: t.String,
+	expected: t.String,
+	actual: t.String
+}) {
+	get message() {
+		return `${this.what}: expected ${this.expected}, got ${this.actual}`;
+	}
+}, a = class extends e.TaggedError("CompressionError") {}, o = class extends t.TaggedError()("ScopeError", { reason: t.String }) {
+	get message() {
+		return this.reason;
+	}
+}, s = class extends t.TaggedError()("RowsRefusedError", {
+	rows: t.Array(t.Struct({
+		table: t.String,
+		id: t.String,
+		reason: t.String,
+		derived: t.Boolean
+	})),
+	primaryCount: t.Number,
+	totalCount: t.Number,
+	byTable: t.Array(t.Struct({
+		table: t.String,
+		refused: t.Number,
+		primary: t.Number
+	}))
+}) {
+	get message() {
+		return `RowsRefusedError: ${JSON.stringify({
+			rows: this.rows,
+			primaryCount: this.primaryCount,
+			totalCount: this.totalCount,
+			byTable: this.byTable
+		})}`;
+	}
+}, c = class extends t.TaggedError()("SchemaDriftError", {
+	bundleFingerprint: t.String,
+	targetFingerprint: t.String,
+	diff: t.Array(t.String)
+}) {
+	get message() {
+		return `bundle schema ${this.bundleFingerprint} does not match target ${this.targetFingerprint}: ${this.diff.join("; ")}`;
+	}
+}, l = class extends e.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}` : ""}`;
+	}
+}, u = class extends t.TaggedError()("MaskingError", {
+	unclassified: t.Array(t.String),
+	invalidActions: t.optional(t.Array(t.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"}`;
+	}
+}, d = class extends t.TaggedError()("ImportModeError", {
+	mode: t.String,
+	reason: t.String
+}) {
+	get message() {
+		return `import mode '${this.mode}' refused: ${this.reason}`;
+	}
+}, f = class extends t.TaggedError()("CrossDialectError", {
+	sourceDialect: t.String,
+	targetDialect: t.String,
+	blocking: t.Array(t.String)
+}) {};
+//#endregion
+export { n as BundleError, r as CodecError, a as CompressionError, f as CrossDialectError, d as ImportModeError, i as IntegrityError, u as MaskingError, l as NativeToolError, s as RowsRefusedError, c as SchemaDriftError, o as ScopeError };

package/dist/exporter.js

@@ -0,0 +1,257 @@
+import { snapshotPrelude as e } from "./consistency.js";
+import { classificationFromSnapshot as t, maskRow as n, planMasking as r } from "./masking.js";
+import { BundleError as i, MaskingError as a, ScopeError as o } from "./errors.js";
+import { computeSubsetIds as s, subsetToScope as c } from "./subset.js";
+import { resolveScope as l } from "./scope.js";
+import { captureAssetsToCas as u } from "./casAssetPhase.js";
+import { compressionExt as d, makeCompressor as f, pickCompression as p } from "./compress.js";
+import { ASSETS_DIR as m, ASSET_INDEX_FILE as h, DATA_DIR as g, LEDGER_FILE as _, MANIFEST_FILE as v, README_FILE as y, encodeManifest as b } from "./manifest.js";
+import { buildReadme as x } from "./readme.js";
+import { reportProgress as S, withTableSpan as C } from "./progress.js";
+import { readLedger as w, tableDone as T, writeLedger as E } from "./ledger.js";
+import { rowsToNdjson as D } from "./ndjson.js";
+import { topoSortTables as O } from "./topo.js";
+import { Cause as k, Effect as A, Exit as j, Schedule as M, Stream as N } from "effect";
+import { streamTable as P } from "@voltro/database";
+import { fingerprintSchema as F } from "@voltro/database/sql";
+//#region src/exporter.ts
+var I = (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(I(t.cause)) : n.push(r), n.length === 0) {
+		let t = String(e ?? "").trim();
+		return t === "" || t === "[object Object]" ? L(e) : t;
+	}
+	return n.join(": ");
+}, L = (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)";
+	}
+}, R = (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;
+}, z = (e, t) => (e.tables.find((e) => e.name === t)?.columns ?? []).filter((e) => e.generatedAs !== void 0).map((e) => e.name), B = (e, t) => {
+	if (t.length === 0) return e;
+	let n = { ...e };
+	for (let e of t) delete n[e];
+	return n;
+}, V = (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.` };
+}, H = (e, t, n) => A.tryPromise({
+	try: async () => {
+		let { createWriteStream: r } = 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: c, Transform: l } = await import("node:stream"), u = a("sha256"), d = 0, p = new l({ transform(e, t, n) {
+			u.update(e);
+			let r = e;
+			for (let e = 0; e < r.length; e++) r[e] === 10 && d++;
+			n(null, e);
+		} }), m = c.fromWeb(N.toReadableStream(e)), h = `${t}.tmp-${o()}`;
+		try {
+			await s(m, p, f(n), r(h)), await i.rename(h, t);
+		} catch (e) {
+			throw await i.rm(h, { force: !0 }).catch(() => {}), e;
+		}
+		return {
+			rowCount: d,
+			checksum: u.digest("hex")
+		};
+	},
+	catch: (e) => new i({
+		reason: `write table failed: ${I(e)}`,
+		path: t
+	})
+}), U = (e, t) => A.tryPromise({
+	try: async () => {
+		await (await import("node:fs/promises")).appendFile(e, `${t}\n`);
+	},
+	catch: (t) => new i({
+		reason: `append failed: ${I(t)}`,
+		path: e
+	})
+}), W = (e, t) => A.gen(function* () {
+	let r = [], i = t.ordered.length;
+	for (let a = 0; a < t.ordered.length; a++) {
+		let s = t.ordered[a], c = R(t.snapshot, s), l = V(t.snapshot, s);
+		if ("refusal" in l) return yield* A.fail(new o({ reason: `export: ${l.refusal}` }));
+		let u = l.column, f = `${g}/${s}.ndjson${d(t.compression)}`;
+		if (T(t.ledger, s)) {
+			let e = t.ledger.tables[s];
+			S(t.onProgress, {
+				phase: "export",
+				table: s,
+				index: a,
+				tableCount: i,
+				event: "done",
+				rowsDone: e.rowCount,
+				total: e.rowCount
+			}), r.push({
+				name: s,
+				file: f,
+				rowCount: e.rowCount,
+				checksum: e.checksum,
+				columnTypes: c,
+				primaryKey: u
+			});
+			continue;
+		}
+		S(t.onProgress, {
+			phase: "export",
+			table: s,
+			index: a,
+			tableCount: i,
+			event: "start",
+			rowsDone: 0
+		});
+		let p = t.resolved.predicateFor(s), m = P(e, {
+			table: s,
+			pk: u,
+			chunkSize: t.chunkSize,
+			retry: t.retry,
+			...p === void 0 ? {} : { where: p }
+		}), h = z(t.snapshot, s), _ = h.length === 0 ? m : m.pipe(N.map((e) => B(e, h))), v = t.mask ? _.pipe(N.map((e) => n(e, s, t.mask.actions, t.mask.seed, c))) : _, { rowCount: y, checksum: b } = yield* C("export", s, a, i, (e) => e.rowCount, H(D(v, c), t.bundleFile(f), t.compression));
+		t.ledger.tables[s] = {
+			rowCount: y,
+			checksum: b
+		}, yield* E(t.ledgerPath, t.ledger), S(t.onProgress, {
+			phase: "export",
+			table: s,
+			index: a,
+			tableCount: i,
+			event: "done",
+			rowsDone: y,
+			total: y
+		}), r.push({
+			name: s,
+			file: f,
+			rowCount: y,
+			checksum: b,
+			columnTypes: c,
+			primaryKey: u
+		});
+	}
+	return r;
+}), G = (e) => ({
+	_tag: "RawSqlFragment",
+	strings: [e],
+	values: []
+}), K = (t, n, r) => A.tryPromise({
+	try: () => t.transactional(async (t) => {
+		if (t.raw) for (let r of e(n)) await t.raw(G(r));
+		let i = await A.runPromiseExit(r(t));
+		if (j.isFailure(i)) throw Error(k.pretty(i.cause));
+		return i.value;
+	}),
+	catch: (e) => e instanceof i ? e : new i({ reason: `snapshot export failed: ${I(e)}` })
+}), q = (e) => A.gen(function* () {
+	let n = e.scope ?? { kind: "all" }, o = p(e.compression), d = e.chunkSize ?? 1e3, f = e.retryTimes ?? 5, S = M.max([M.exponential("50 millis").pipe(M.jittered), M.recurs(f)]), C = yield* A.promise(() => import("node:path")), T = (t) => C.join(e.outDir, t);
+	yield* A.tryPromise({
+		try: async () => {
+			let t = await import("node:fs/promises");
+			await t.mkdir(T(g), { recursive: !0 }), e.assets && await t.mkdir(T(m), { recursive: !0 });
+		},
+		catch: (t) => new i({
+			reason: `mkdir failed: ${I(t)}`,
+			path: e.outDir
+		})
+	});
+	let D = T(_), k = yield* w(D), j = e.subset ? c(yield* s(e.store, e.snapshot, e.subset), e.snapshot) : yield* l(n, e.snapshot, {
+		store: e.store,
+		...e.tenantTables ? { tenantTables: e.tenantTables } : {}
+	}), N = O(j.tables, e.snapshot), P = e.consistency ?? "live", L, R;
+	if (e.masking) {
+		let n = e.classification ?? t(e.snapshot), i = N.map((t) => ({
+			name: t,
+			columns: (e.snapshot.tables.find((e) => e.name === t)?.columns ?? []).map((e) => ({
+				name: e.name,
+				type: e.type
+			}))
+		})), o = r(i, n, e.masking);
+		if (o.unclassified.length > 0 || o.invalid.length > 0) return yield* A.fail(new a({
+			unclassified: o.unclassified,
+			...o.invalid.length > 0 ? { invalidActions: o.invalid.map((e) => `${e.column}: ${JSON.stringify(e.action)}`) } : {}
+		}));
+		R = {
+			actions: o.actions,
+			seed: e.masking.seed
+		};
+		let s = Object.entries(o.actions).filter(([, e]) => e !== "keep").map(([e]) => e);
+		L = {
+			...e.masking.id ? { policyId: e.masking.id } : {},
+			transformed: s
+		};
+	}
+	let z = {
+		snapshot: e.snapshot,
+		ordered: N,
+		resolved: j,
+		compression: o,
+		chunkSize: d,
+		retry: S,
+		ledger: k,
+		ledgerPath: D,
+		bundleFile: T,
+		...R ? { mask: R } : {},
+		...e.onProgress ? { onProgress: e.onProgress } : {}
+	}, B = P === "snapshot" ? yield* K(e.store, e.dialect, (e) => W(e, z)) : yield* W(e.store, z), V = 0, H = 0;
+	if (e.assets) {
+		let t = T(h), n = yield* u({
+			source: e.assets,
+			assetsDir: T(m),
+			progress: {
+				done: (e) => e in k.assets,
+				mark: (e, n) => (k.assets[e] = !0, U(t, JSON.stringify(n)).pipe(A.andThen(E(D, k))))
+			}
+		});
+		V = n.count, H = n.totalBytes, n.missing.length > 0 && (yield* A.logWarning(`${n.missing.length} of ${n.missing.length + n.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. ${n.missing.slice(0, 3).map((e) => `'${e}'`).join(", ")}` + (n.missing.length > 3 ? `, and ${n.missing.length - 3} more` : "")));
+	}
+	let G = {
+		formatVersion: 1,
+		createdAt: e.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		source: {
+			dialect: e.dialect,
+			schemaFingerprint: F(e.snapshot)
+		},
+		scope: n,
+		consistency: P,
+		compression: o,
+		tables: B,
+		assets: V > 0 ? {
+			count: V,
+			totalBytes: H,
+			index: h
+		} : {
+			count: 0,
+			totalBytes: 0
+		},
+		...L ? { masking: L } : {}
+	};
+	return yield* A.tryPromise({
+		try: async () => {
+			await (await import("node:fs/promises")).writeFile(T(v), b(G));
+		},
+		catch: (e) => new i({
+			reason: `manifest write failed: ${I(e)}`,
+			path: v
+		})
+	}), yield* A.tryPromise({
+		try: async () => {
+			let e = await import("node:fs/promises"), t = await import("node:os");
+			await e.writeFile(T(y), x(G, { hostname: t.hostname() }));
+		},
+		catch: (e) => new i({
+			reason: `readme write failed: ${I(e)}`,
+			path: y
+		})
+	}), G;
+});
+//#endregion
+export { q as runExport };