@voltro/data-transfer 0.86.0 → 0.88.0

package/dist/importer.js

@@ -1,27 +1,29 @@
-import { environmentLocalNotice as e, isEnvironmentLocal as t } from "./environmentLocal.js";
-import { BundleError as n, CrossDialectError as r, ImportModeError as i, IntegrityError as a, RowsRefusedError as o, SchemaDriftError as s } from "./errors.js";
-import { restoreAssetsFromCas as c } from "./casAssetPhase.js";
+import { nullUnreadableSealed as e } from "./sealedKeys.js";
+import { environmentLocalNotice as t, isEnvironmentLocal as n } from "./environmentLocal.js";
+import { BundleError as r, CrossDialectError as i, FieldKeysMissingError as a, ImportModeError as o, IntegrityError as s, RowsRefusedError as c, SchemaDriftError as l } from "./errors.js";
+import { ASSETS_DIR as u, MANIFEST_FILE as d, decodeManifest as f } from "./manifest.js";
+import { prepareAssetsFromCas as p, restoreAssetsFromCas as m } from "./casAssetPhase.js";
 import { makeDecompressor as ee } from "./compress.js";
-import { ASSETS_DIR as l, MANIFEST_FILE as u, decodeManifest as d } from "./manifest.js";
-import { reportProgress as f, withTableSpan as p } from "./progress.js";
-import { readLedger as te, tableDone as m, writeLedger as h } from "./ledger.js";
+import { reportProgress as h, withTableSpan as te } from "./progress.js";
+import { readLedger as g, tableDone as _, writeLedger as v } from "./ledger.js";
 import { ndjsonToRows as ne } from "./ndjson.js";
-import { outsideReferenceRefusal as g, outsideReferencesInto as _ } from "./replacePreflight.js";
-import { checkPortability as v, formatIssue as re } from "./crossDialect.js";
-import { rowFailureDiagnosis as ie, tableFailureReason as ae } from "./rowFailureReason.js";
-import { canStage as oe, createStagingSql as se, danglingReport as ce, decideStaging as le, dropStagingSql as ue, execStatements as y, findDangling as de, registerStagingClones as fe, runSwap as pe, stagedReferences as me, stagingNameFor as he, stagingUnavailable as ge } from "./stagedSwap.js";
-import { captureRollback as _e, rollbackNotice as ve } from "./rollbackCapture.js";
-import { checkSchemaDrift as ye } from "./schemaDrift.js";
-import { Cause as b, Effect as x, Exit as S, Option as C, Stream as be } from "effect";
-import { DATA_TRANSFERS_TABLE as w, REPLACE_IN_PROGRESS_TABLE as T, _voltroDataTransfersTable as xe, derivedRowId as E, ensureTableRegistered as Se, getTable as D, isNotNull as Ce, recordsTable as we, registerTable as Te, suspendWriteRecorders as Ee, suspendWriteRecordersEffect as De, unregisterTable as Oe } from "@voltro/database";
-import { createReadStream as ke } from "node:fs";
-import { fromNodeReadable as Ae } from "@voltro/plugin-storage";
-//#region src/importer.ts
-var je = 2e3, Me = 2e3, O = 200, k = /* @__PURE__ */ new Set([
+import { outsideReferenceRefusal as re, outsideReferencesInto as ie } from "./replacePreflight.js";
+import { checkPortability as ae, formatIssue as oe } from "./crossDialect.js";
+import { rowFailureDiagnosis as se, tableFailureReason as ce } from "./rowFailureReason.js";
+import { canStage as le, createStagingSql as ue, danglingReport as de, decideStaging as fe, dropStagingSql as pe, execStatements as y, findDangling as me, registerStagingClones as he, runSwap as ge, stagedReferences as _e, stagingNameFor as ve, stagingUnavailable as ye } from "./stagedSwap.js";
+import { captureRollback as be, rollbackNotice as xe } from "./rollbackCapture.js";
+import { checkSchemaDrift as Se } from "./schemaDrift.js";
+import { Cause as b, Effect as x, Exit as S, Option as C, Stream as Ce } from "effect";
+import { DATA_TRANSFERS_TABLE as w, REPLACE_IN_PROGRESS_TABLE as T, _voltroDataTransfersTable as we, derivedRowId as E, ensureTableRegistered as Te, getTable as D, isNotNull as Ee, recordsTable as De, registerTable as Oe, suspendWriteRecorders as ke, suspendWriteRecordersEffect as Ae, unregisterTable as je } from "@voltro/database";
+import { createReadStream as Me } from "node:fs";
+import { fromNodeReadable as Ne } from "@voltro/plugin-storage";
+// src/importer.ts
+var Pe = 2e3, Fe = 2e3, O = 200, k = /* @__PURE__ */ new Set([
 	"BundleError",
 	"CodecError",
 	"IntegrityError",
 	"CrossDialectError",
+	"FieldKeysMissingError",
 	"ImportModeError",
 	"RowsRefusedError",
 	"SchemaDriftError",
@@ -36,30 +38,35 @@ var je = 2e3, Me = 2e3, O = 200, k = /* @__PURE__ */ new Set([
 			if (e) return e;
 		}
 	}
-}, Ne = (e) => C.getOrUndefined(b.findErrorOption(e)) ?? Error(b.pretty(e)), Pe = (e) => x.tryPromise({
+}, Ie = (e) => C.getOrUndefined(b.findErrorOption(e)) ?? Error(b.pretty(e)), Le = (e) => x.tryPromise({
 	try: async () => {
-		let t = await import("node:fs/promises"), n = await import("node:path"), r = await t.readFile(n.join(e, u), "utf8");
-		return d(r);
+		let t = await import("node:fs/promises"), n = await import("node:path"), r = await t.readFile(n.join(e, d), "utf8");
+		return f(r);
 	},
-	catch: (e) => new n({
+	catch: (e) => new r({
 		reason: `manifest read/parse failed: ${String(e?.message ?? e)}`,
-		path: u
+		path: d
 	})
-}), Fe = (u) => {
-	let d;
+}), j = (d) => {
+	let f;
 	return x.gen(function* () {
-		let b = yield* x.promise(() => import("node:path")), C = yield* Pe(u.bundleDir);
-		if (C.formatVersion !== 1) return yield* x.fail(new n({ reason: `unsupported bundle formatVersion ${C.formatVersion} (expected 1)` }));
-		if (u.tables !== void 0) {
-			let e = new Set(C.tables.map((e) => e.name)), t = u.tables.filter((t) => !e.has(t));
-			if (t.length > 0) return yield* x.fail(new n({ reason: `--tables names ${t.length} table(s) this bundle does not carry: ${t.join(", ")}. The bundle carries: ${[...e].sort().join(", ")}.` }));
+		let b = yield* x.promise(() => import("node:path")), C = yield* Le(d.bundleDir);
+		if (C.formatVersion !== 2) return yield* x.fail(new r({ reason: `unsupported bundle formatVersion ${C.formatVersion} (expected 2)` }));
+		let O = d.assets && C.assets.index ? yield* p({
+			sink: d.assets,
+			assetsDir: b.join(d.bundleDir, u),
+			indexPath: b.join(d.bundleDir, C.assets.index)
+		}) : void 0;
+		if (d.tables !== void 0) {
+			let e = new Set(C.tables.map((e) => e.name)), t = d.tables.filter((t) => !e.has(t));
+			if (t.length > 0) return yield* x.fail(new r({ reason: `--tables names ${t.length} table(s) this bundle does not carry: ${t.join(", ")}. The bundle carries: ${[...e].sort().join(", ")}.` }));
 		}
-		let O = u.tables === void 0 ? void 0 : new Set(u.tables), k = O === void 0 ? C : {
+		let k = d.tables === void 0 ? void 0 : new Set(d.tables), j = k === void 0 ? C : {
 			...C,
-			tables: C.tables.filter((e) => O.has(e.name))
+			tables: C.tables.filter((e) => k.has(e.name))
 		};
-		if (u.targetSnapshot) {
-			let e = { tables: k.tables.map((e) => ({
+		if (d.targetSnapshot) {
+			let e = { tables: j.tables.map((e) => ({
 				name: e.name,
 				indexes: [],
 				columns: Object.entries(e.columnTypes).map(([e, t]) => ({
@@ -69,43 +76,43 @@ var je = 2e3, Me = 2e3, O = 200, k = /* @__PURE__ */ new Set([
 					unique: !1,
 					hasDefault: !1
 				}))
-			})) }, t = ye(k.source.schemaFingerprint, u.targetSnapshot, e);
+			})) }, t = Se(j.source.schemaFingerprint, d.targetSnapshot, e);
 			if (t.drifted) {
-				if (!u.force) return yield* x.fail(new s({
+				if (!d.force) return yield* x.fail(new l({
 					bundleFingerprint: t.bundleFingerprint,
 					targetFingerprint: t.targetFingerprint,
 					diff: t.diff
 				}));
-				u.onWarn?.(`schema drift: the target schema (fingerprint ${t.targetFingerprint.slice(0, 16)}) differs from the bundle's source (${t.bundleFingerprint.slice(0, 16)}); importing anyway (--force). ${t.diff.join("; ")}`);
+				d.onWarn?.(`schema drift: the target schema (fingerprint ${t.targetFingerprint.slice(0, 16)}) differs from the bundle's source (${t.bundleFingerprint.slice(0, 16)}); importing anyway (--force). ${t.diff.join("; ")}`);
 			}
 		}
-		if (u.targetDialect && u.targetDialect !== k.source.dialect) {
-			let e = v(k.tables, k.source.dialect, u.targetDialect).filter((e) => e.severity === "block");
-			if (e.length > 0 && !u.allowIncompatible) return yield* x.fail(new r({
-				sourceDialect: k.source.dialect,
-				targetDialect: u.targetDialect,
-				blocking: e.map(re)
+		if (d.targetDialect && d.targetDialect !== j.source.dialect) {
+			let e = ae(j.tables, j.source.dialect, d.targetDialect).filter((e) => e.severity === "block");
+			if (e.length > 0 && !d.allowIncompatible) return yield* x.fail(new i({
+				sourceDialect: j.source.dialect,
+				targetDialect: d.targetDialect,
+				blocking: e.map(oe)
 			}));
 		}
-		let Fe = u.verify ?? !0, j = u.mode ?? "upsert", M = u.atomic ?? j === "replace", Ie = u.onConflict ?? "skip", N = u.ledgerPath ?? b.join(u.bundleDir, ".import..ledger.json"), P = yield* te(N);
-		if (j === "replace" && k.scope.kind !== "all") return yield* x.fail(new i({
-			mode: j,
-			reason: `replace refuses a partial bundle (scope='${k.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.`
+		let Re = d.verify ?? !0, M = d.mode ?? "upsert", N = d.atomic ?? M === "replace", ze = d.onConflict ?? "skip", P = d.ledgerPath ?? b.join(d.bundleDir, ".import..ledger.json"), F = yield* g(P);
+		if (M === "replace" && j.scope.kind !== "all") return yield* x.fail(new o({
+			mode: M,
+			reason: `replace refuses a partial bundle (scope='${j.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 (j === "replace" && (k.scope.exclude?.length ?? 0) > 0) {
-			let e = k.scope.exclude;
-			u.onWarn?.(`this bundle was exported with ${e.length} table(s) excluded: ${e.join(", ")}.\n  A replace empties and refills the tables the bundle CARRIES, so those keep whatever rows the
+		if (M === "replace" && (j.scope.exclude?.length ?? 0) > 0) {
+			let e = j.scope.exclude;
+			d.onWarn?.(`this bundle was exported with ${e.length} table(s) excluded: ${e.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 (j === "replace") {
-			let e = k.tables.map((e) => e.name), t = u.store.incomingForeignKeys ? yield* x.tryPromise({
-				try: () => u.store.incomingForeignKeys(e),
-				catch: (e) => new n({ reason: `foreign-key pre-flight failed: ${ae(e)}` })
-			}) : u.targetSnapshot === void 0 ? [] : _(u.targetSnapshot, e), r = [], a = /* @__PURE__ */ new Map();
+		if (M === "replace") {
+			let e = j.tables.map((e) => e.name), t = d.store.incomingForeignKeys ? yield* x.tryPromise({
+				try: () => d.store.incomingForeignKeys(e),
+				catch: (e) => new r({ reason: `foreign-key pre-flight failed: ${ce(e)}` })
+			}) : d.targetSnapshot === void 0 ? [] : ie(d.targetSnapshot, e), n = [], i = /* @__PURE__ */ new Map();
 			for (let e of t) {
-				if (!a.has(e.from)) {
+				if (!i.has(e.from)) {
 					let t = yield* x.tryPromise({
-						try: () => u.store.query({
+						try: () => d.store.query({
 							table: e.from,
 							predicate: void 0,
 							order: [],
@@ -113,68 +120,98 @@ var je = 2e3, Me = 2e3, O = 200, k = /* @__PURE__ */ new Set([
 							skip: void 0,
 							projection: []
 						}),
-						catch: () => new n({ reason: `unreadable: ${e.from}` })
+						catch: () => new r({ reason: `unreadable: ${e.from}` })
 					}).pipe(x.map((e) => e.length), x.orElseSucceed(() => 0));
-					a.set(e.from, t);
+					i.set(e.from, t);
 				}
-				let t = a.get(e.from) ?? 0;
-				t > 0 && r.push({
+				let t = i.get(e.from) ?? 0;
+				t > 0 && n.push({
 					...e,
 					rowCount: t
 				});
 			}
-			if (r.length > 0) return yield* x.fail(new i({
-				mode: j,
-				reason: g(r)
+			if (n.length > 0) return yield* x.fail(new o({
+				mode: M,
+				reason: re(n)
 			}));
 		}
-		if (u.dryRun === !0) return u.traceId !== void 0 && (yield* x.promise(() => u.store.update(w, u.traceId, {
+		let I = {
+			nulled: /* @__PURE__ */ new Map(),
+			unreadable: /* @__PURE__ */ new Map()
+		};
+		if (d.fieldKeys !== void 0 && j.fieldKeys !== void 0) {
+			let e = new Set(d.fieldKeys.held), t = j.fieldKeys.keyIds.filter((t) => !e.has(t));
+			if (t.length > 0 && d.fieldKeys.nullSealed !== !0) return yield* x.fail(new a({
+				missing: t,
+				held: [...e]
+			}));
+			t.length > 0 && d.onWarn?.(`field encryption: values under ${t.join(", ")} are written as NULL where they are a whole value — this environment does not hold those keys`);
+		}
+		let Be = (t, n) => {
+			if (d.fieldKeys?.nullSealed !== !0) return n;
+			let r = {
+				nulled: I.nulled.get(t) ?? I.nulled.set(t, /* @__PURE__ */ new Map()).get(t),
+				unreadable: I.unreadable.get(t) ?? I.unreadable.set(t, /* @__PURE__ */ new Map()).get(t)
+			};
+			return e(t, n, d.fieldKeys, r);
+		}, Ve = () => {
+			let e = (e) => [...e].flatMap(([e, t]) => [...t].filter(([, e]) => e > 0).map(([t, n]) => ({
+				table: e,
+				column: t,
+				count: n
+			})));
+			return {
+				nulled: e(I.nulled),
+				unreadable: e(I.unreadable)
+			};
+		};
+		if (d.dryRun === !0) return d.traceId !== void 0 && (yield* x.promise(() => d.store.update(w, d.traceId, {
 			finishedAt: /* @__PURE__ */ new Date(),
 			tablesWritten: 0,
 			rowsWritten: 0,
 			failure: null
 		}).then(() => void 0, () => void 0))), {
-			manifest: k,
+			manifest: j,
 			tablesWritten: 0,
 			rowsWritten: 0,
 			tablesSkipped: 0,
 			rowsSkipped: 0,
 			fullyResumed: !1
 		};
-		let Le = /* @__PURE__ */ new Map();
-		for (let e of u.targetSnapshot?.tables ?? []) {
+		let He = /* @__PURE__ */ new Map();
+		for (let e of d.targetSnapshot?.tables ?? []) {
 			let t = e.columns.filter((e) => e.generatedAs !== void 0).map((e) => e.name);
-			t.length > 0 && Le.set(e.name, t);
+			t.length > 0 && He.set(e.name, t);
 		}
-		let Re = (e, t) => {
-			let n = Le.get(e);
+		let Ue = (e, t) => {
+			let n = He.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;
-		}, F = (e, t, n, r = !1) => {
-			let i = H ? he(t.name) : t.name, a = t.primaryKey, o = Be(t.name, Re(t.name, n), t.columnTypes);
-			return j === "append" ? Ie === "fail" ? e.insert(i, o) : e.insertIgnore(i, o, { conflictColumns: [a] }) : j === "replace" ? r ? e.upsert(i, o, { conflictColumns: [a] }) : e.insert(i, o) : e.upsert(i, o, { conflictColumns: [a] });
-		}, ze = u.targetDialect !== void 0 && u.targetDialect !== "memory", Be = (e, t, n) => {
-			if (!ze || n === void 0 || D(e) !== void 0) return t;
+		}, L = (e, t, n, r = !1) => {
+			let i = W ? ve(t.name) : t.name, a = t.primaryKey, o = Ge(t.name, Ue(t.name, n), t.columnTypes);
+			return M === "append" ? ze === "fail" ? e.insert(i, o) : e.insertIgnore(i, o, { conflictColumns: [a] }) : M === "replace" ? r ? e.upsert(i, o, { conflictColumns: [a] }) : e.insert(i, o) : e.upsert(i, o, { conflictColumns: [a] });
+		}, We = d.targetDialect !== void 0 && d.targetDialect !== "memory", Ge = (e, t, n) => {
+			if (!We || n === void 0 || D(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;
-		}, I = (e, t) => e.savepoint ? e.savepoint(t) : t(), L = 0, Ve = (e, t, n) => {
-			n.unclassified && (L++, !(L > 3) && u.onWarn?.(`row refused with no driver detail — table '${e.name}', row '${String(t.id ?? "?")}'. The full rendering follows so the LAYER that refused is on the record; it is logged, never returned. ${n.raw}` + (L === 3 ? " (further unclassified refusals are counted, not logged)" : "")));
-		}, R = (e, t, n = !0) => x.tryPromise({
+		}, R = (e, t) => e.savepoint ? e.savepoint(t) : t(), z = 0, Ke = (e, t, n) => {
+			n.unclassified && (z++, !(z > 3) && d.onWarn?.(`row refused with no driver detail — table '${e.name}', row '${String(t.id ?? "?")}'. The full rendering follows so the LAYER that refused is on the record; it is logged, never returned. ${n.raw}` + (z === 3 ? " (further unclassified refusals are counted, not logged)" : "")));
+		}, B = (e, t, n = !0) => x.tryPromise({
 			try: e,
-			catch: (e) => ie(e)
-		}).pipe(x.map(() => !0), x.catch((e) => x.sync(() => (n && (t.reason = e.reason, Ve(t.entry, t.row, e)), !1)))), He = (e) => {
+			catch: (e) => se(e)
+		}).pipe(x.map(() => !0), x.catch((e) => x.sync(() => (n && (t.reason = e.reason, Ke(t.entry, t.row, e)), !1)))), qe = (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]))
 			};
-		}, Ue = (e) => {
+		}, Je = (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];
@@ -192,7 +229,7 @@ var je = 2e3, Me = 2e3, O = 200, k = /* @__PURE__ */ new Set([
 				};
 				t.refused++, e.derived || t.primary++, a.set(e.table, t);
 			}
-			return new o({
+			return new c({
 				rows: i.slice(0, 20),
 				primaryCount: r.filter((e) => !e.derived).length,
 				totalCount: e.length,
@@ -202,104 +239,104 @@ var je = 2e3, Me = 2e3, O = 200, k = /* @__PURE__ */ new Set([
 					primary: t.primary
 				})).sort((e, t) => t.refused - e.refused || e.table.localeCompare(t.table)).slice(0, 100)
 			});
-		}, We = (e, t) => x.gen(function* () {
+		}, Ye = (e, t) => x.gen(function* () {
 			let n = t, r = [], i = !0;
 			for (; n.length > 0 && i;) {
 				i = !1;
 				let t = [];
-				for (let r of n) (yield* R(() => I(e, () => F(e, r.entry, r.row, !0)), r)) ? i = !0 : t.push(r);
+				for (let r of n) (yield* B(() => R(e, () => L(e, r.entry, r.row, !0)), r)) ? i = !0 : t.push(r);
 				if (!i && t.length > 0) for (let n = t.length - 1; n >= 0; n--) {
-					let a = t[n], o = He(a);
-					o !== void 0 && (yield* R(() => I(e, () => F(e, a.entry, o, !0)), a, !1)) && (r.push(a), t.splice(n, 1), i = !0);
+					let a = t[n], o = qe(a);
+					o !== void 0 && (yield* B(() => R(e, () => L(e, a.entry, o, !0)), a, !1)) && (r.push(a), t.splice(n, 1), i = !0);
 				}
 				n = t;
 			}
-			for (let t of r) (yield* R(() => I(e, () => e.upsert(t.entry.name, Be(t.entry.name, t.row, t.entry.columnTypes), { conflictColumns: [t.entry.primaryKey] })), t)) || (n = [...n, t]);
-			if (n.length > 0) return yield* x.fail(Ue(n));
-		}), z = (() => {
-			let e = u.targetDialect;
+			for (let t of r) (yield* B(() => R(e, () => e.upsert(t.entry.name, Ge(t.entry.name, t.row, t.entry.columnTypes), { conflictColumns: [t.entry.primaryKey] })), t)) || (n = [...n, t]);
+			if (n.length > 0) return yield* x.fail(Je(n));
+		}), V = (() => {
+			let e = d.targetDialect;
 			return e === "postgres" || e === "mysql" || e === "mariadb" || e === "sqlite" || e === "mssql" ? e : void 0;
-		})(), B = le({
-			mode: j,
-			...u.targetDialect === void 0 ? {} : { targetDialect: u.targetDialect },
-			...u.targetSnapshot === void 0 ? {} : { targetSnapshot: u.targetSnapshot },
-			bundleTables: k.tables.map((e) => e.name),
-			isSkipped: t,
-			canRunSql: oe(u.store)
-		}), V = B.tables, Ge = k.tables.filter((e) => !t(e.name) && we(e.name)).map((e) => e.name), H = B.active, Ke = !1, U = 0, W = 0, qe, G, Je = 0, K = 0, q = (r, i) => x.gen(function* () {
-			if (j === "replace" && !H && !(i && P.truncated)) {
-				u.recordInterruption === !0 && (yield* x.tryPromise({
-					try: () => r.insert(T, {
-						id: E("repl", Ye),
-						startedAt: J,
-						tables: String(k.tables.length),
-						capture: Y?.dir ?? null,
-						via: u.via ?? "direct"
+		})(), H = fe({
+			mode: M,
+			...d.targetDialect === void 0 ? {} : { targetDialect: d.targetDialect },
+			...d.targetSnapshot === void 0 ? {} : { targetSnapshot: d.targetSnapshot },
+			bundleTables: j.tables.map((e) => e.name),
+			isSkipped: n,
+			canRunSql: le(d.store)
+		}), U = H.tables, Xe = j.tables.filter((e) => !n(e.name) && De(e.name)).map((e) => e.name), W = H.active, Ze = !1, G = 0, K = 0, Qe, q, $e = 0, J = 0, Y = (e, i) => x.gen(function* () {
+			if (M === "replace" && !W && !(i && F.truncated)) {
+				d.recordInterruption === !0 && (yield* x.tryPromise({
+					try: () => e.insert(T, {
+						id: E("repl", et),
+						startedAt: X,
+						tables: String(j.tables.length),
+						capture: Z?.dir ?? null,
+						via: d.via ?? "direct"
 					}),
-					catch: (e) => new n({ 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
+					catch: (e) => new r({ 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 e = [...k.tables].reverse().map((e) => e.name).filter((e) => !t(e)), a = !i, o = r.emptyTables ? () => r.emptyTables(e) : a ? async () => {
-					for (let e of [...k.tables].reverse()) await r.deleteMany(e.name, { where: Ce(e.primaryKey) });
-				} : () => r.transactional(async (e) => {
-					for (let t of [...k.tables].reverse()) await e.deleteMany(t.name, { where: Ce(t.primaryKey) });
+				let t = [...j.tables].reverse().map((e) => e.name).filter((e) => !n(e)), a = !i, o = e.emptyTables ? () => e.emptyTables(t) : a ? async () => {
+					for (let t of [...j.tables].reverse()) await e.deleteMany(t.name, { where: Ee(t.primaryKey) });
+				} : () => e.transactional(async (e) => {
+					for (let t of [...j.tables].reverse()) await e.deleteMany(t.name, { where: Ee(t.primaryKey) });
 				});
 				yield* x.tryPromise({
 					try: o,
-					catch: (e) => new n({ reason: `emptying the target for --mode replace failed (nothing was deleted): ${ae(e)}` })
-				}), i && (P.truncated = !0, yield* h(N, P));
+					catch: (e) => new r({ reason: `emptying the target for --mode replace failed (nothing was deleted): ${ce(e)}` })
+				}), i && (F.truncated = !0, yield* v(P, F));
 			}
-			let o = [], s = [], c = [], l = [], d = k.tables.length;
-			for (let e = 0; e < k.tables.length; e++) {
-				let n = k.tables[e];
-				if (t(n.name)) {
-					l.push(n.name);
+			let a = [], o = [], c = [], l = [], u = j.tables.length;
+			for (let t = 0; t < j.tables.length; t++) {
+				let r = j.tables[t];
+				if (n(r.name)) {
+					l.push(r.name);
 					continue;
 				}
-				if (i && n.name in P.tables) {
-					c.push(n.name), K++, Je += P.tables[n.name].rowCount, f(u.onProgress, {
+				if (i && r.name in F.tables) {
+					c.push(r.name), J++, $e += F.tables[r.name].rowCount, h(d.onProgress, {
 						phase: "import",
-						table: n.name,
-						index: e,
-						tableCount: d,
+						table: r.name,
+						index: t,
+						tableCount: u,
 						event: "done",
-						rowsDone: P.tables[n.name].rowCount,
-						total: n.rowCount
+						rowsDone: F.tables[r.name].rowCount,
+						total: r.rowCount
 					});
 					continue;
 				}
-				let te = b.join(u.bundleDir, n.file);
-				f(u.onProgress, {
+				let f = b.join(d.bundleDir, r.file);
+				h(d.onProgress, {
 					phase: "import",
-					table: n.name,
-					index: e,
-					tableCount: d,
+					table: r.name,
+					index: t,
+					tableCount: u,
 					event: "start",
 					rowsDone: 0,
-					total: n.rowCount
+					total: r.rowCount
 				});
-				let m = o.length, g = x.gen(function* () {
-					let { createHash: e } = yield* x.promise(() => import("node:crypto")), t = e("sha256"), i = 0, a = Ae("bundle", () => ke(te).pipe(ee(k.compression))).pipe(be.tap((e) => x.sync(() => t.update(e)))), s = async (e) => {
-						let t = {
-							entry: n,
-							row: e,
+				let p = a.length, m = x.gen(function* () {
+					let { createHash: t } = yield* x.promise(() => import("node:crypto")), n = t("sha256"), i = 0, o = Ne("bundle", () => Me(f).pipe(ee(j.compression))).pipe(Ce.tap((e) => x.sync(() => n.update(e)))), s = async (t) => {
+						let n = {
+							entry: r,
+							row: t,
 							reason: ""
 						};
 						try {
-							await I(r, () => F(r, n, e));
-						} catch (r) {
-							let i = ie(r);
-							t.reason = i.reason, Ve(n, e, i), o.push(t);
+							await R(e, () => L(e, r, t));
+						} catch (e) {
+							let i = se(e);
+							n.reason = i.reason, Ke(r, t, i), a.push(n);
 						}
 					}, c = yield* x.promise(async () => {
-						let e = u.copyLoader;
-						if (!e || e.dialect !== "postgres") return !1;
-						if (M) return Ke || (Ke = !0, u.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 (j === "replace") return !0;
-						if (j !== "upsert") return !1;
+						let t = d.copyLoader;
+						if (!t || t.dialect !== "postgres") return !1;
+						if (N) return Ze || (Ze = !0, d.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 (M === "replace") return !0;
+						if (M !== "upsert") return !1;
 						try {
-							return (await r.query({
-								table: n.name,
+							return (await e.query({
+								table: r.name,
 								predicate: void 0,
 								order: [],
 								take: 1,
@@ -309,228 +346,230 @@ var je = 2e3, Me = 2e3, O = 200, k = /* @__PURE__ */ new Set([
 						} catch {
 							return !1;
 						}
-					}), l = Object.keys(n.columnTypes), d = Math.max(1, u.copyBatchSize ?? 5e3), f = [], p = async () => {
-						if (f.length === 0) return;
-						let e = f;
-						f = [];
+					}), l = Object.keys(r.columnTypes), u = Math.max(1, d.copyBatchSize ?? 5e3), p = [], m = async () => {
+						if (p.length === 0) return;
+						let e = p;
+						p = [];
 						try {
-							await u.copyLoader.copyInto({
-								table: n.name,
+							await d.copyLoader.copyInto({
+								table: r.name,
 								columns: l,
-								columnTypes: n.columnTypes,
+								columnTypes: r.columnTypes,
 								rows: e
 							});
 						} catch (t) {
-							c = !1, u.onWarn?.(`bulk COPY into ${n.name} failed (${String(t?.message ?? t)}); falling back to per-row writes for this table`);
+							c = !1, d.onWarn?.(`bulk COPY into ${r.name} failed (${String(t?.message ?? t)}); falling back to per-row writes for this table`);
 							for (let t of e) await s(t);
 						}
-					}, m = Math.max(1, u.savepointBatchSize ?? 200), h = typeof r.savepoint == "function", g = [], _ = async () => {
+					}, h = Math.max(1, d.savepointBatchSize ?? 200), te = typeof e.savepoint == "function", g = [], _ = async () => {
 						if (g.length === 0) return;
-						let e = g;
+						let t = g;
 						g = [];
 						try {
-							await r.savepoint(async () => {
-								for (let t of e) await F(r, n, t);
+							await e.savepoint(async () => {
+								for (let n of t) await L(e, r, n);
 							});
 						} catch {
-							for (let t of e) await s(t);
+							for (let e of t) await s(e);
 						}
 					};
-					return yield* be.runForEach(ne(a, n.name, n.columnTypes), (e) => x.promise(async () => {
-						i++, G?.(), c ? (f.push(e), f.length >= d && await p()) : h ? (g.push(e), g.length >= m && await _()) : await s(e);
-					})), yield* x.promise(_), yield* x.promise(p), {
+					return yield* Ce.runForEach(ne(o, r.name, r.columnTypes), (e) => x.promise(async () => {
+						let t = Be(r.name, e);
+						i++, q?.(), c ? (p.push(t), p.length >= u && await m()) : te ? (g.push(t), g.length >= h && await _()) : await s(t);
+					})), yield* x.promise(_), yield* x.promise(m), {
 						rowCount: i,
-						checksum: t.digest("hex")
+						checksum: n.digest("hex")
 					};
-				}), { rowCount: _, checksum: v } = yield* p("import", n.name, e, d, (e) => e.rowCount, g);
-				if (Fe) {
-					if (v !== n.checksum) return yield* x.fail(new a({
-						what: `table ${n.name} checksum`,
-						expected: n.checksum,
-						actual: v
+				}), { rowCount: g, checksum: _ } = yield* te("import", r.name, t, u, (e) => e.rowCount, m);
+				if (Re) {
+					if (_ !== r.checksum) return yield* x.fail(new s({
+						what: `table ${r.name} checksum`,
+						expected: r.checksum,
+						actual: _
 					}));
-					if (_ !== n.rowCount) return yield* x.fail(new a({
-						what: `table ${n.name} rowCount`,
-						expected: String(n.rowCount),
-						actual: String(_)
+					if (g !== r.rowCount) return yield* x.fail(new s({
+						what: `table ${r.name} rowCount`,
+						expected: String(r.rowCount),
+						actual: String(g)
 					}));
 				}
-				f(u.onProgress, {
+				h(d.onProgress, {
 					phase: "import",
-					table: n.name,
-					index: e,
-					tableCount: d,
+					table: r.name,
+					index: t,
+					tableCount: u,
 					event: "done",
-					rowsDone: _,
-					total: n.rowCount
-				}), W++, U += _, qe?.(), G?.(), i && (o.length > m ? s.push({
-					name: n.name,
-					rowCount: _
-				}) : (P.tables[n.name] = {
-					rowCount: _,
-					checksum: n.checksum
-				}, yield* h(N, P)));
+					rowsDone: g,
+					total: r.rowCount
+				}), K++, G += g, Qe?.(), q?.(), i && (a.length > p ? o.push({
+					name: r.name,
+					rowCount: g
+				}) : (F.tables[r.name] = {
+					rowCount: g,
+					checksum: r.checksum
+				}, yield* v(P, F)));
 			}
-			if (o.length > 0 && (yield* We(r, o)), j === "replace" && (yield* x.promise(() => r.deleteMany(T, { where: {
+			if (a.length > 0 && (yield* Ye(e, a)), M === "replace" && (yield* x.promise(() => e.deleteMany(T, { where: {
 				column: "startedAt",
 				op: "lte",
-				value: J
-			} }).then(() => void 0, () => void 0))), i && s.length > 0) {
-				for (let e of s) {
-					let t = k.tables.find((t) => t.name === e.name);
-					P.tables[e.name] = {
+				value: X
+			} }).then(() => void 0, () => void 0))), i && o.length > 0) {
+				for (let e of o) {
+					let t = j.tables.find((t) => t.name === e.name);
+					F.tables[e.name] = {
 						rowCount: e.rowCount,
 						checksum: t.checksum
 					};
 				}
-				yield* h(N, P);
+				yield* v(P, F);
 			}
 			{
-				let t = e(l, "skipped");
-				t !== void 0 && u.onWarn?.(t);
+				let e = t(l, "skipped");
+				e !== void 0 && d.onWarn?.(e);
 			}
 			if (c.length > 0) {
-				let e = c.length === k.tables.length;
-				u.onWarn?.(`resume: ${c.length} of ${k.tables.length} table(s) were already applied by an earlier run of THIS bundle directory, so this run wrote NO rows for them${e ? " — that is every table in the bundle, so nothing was written at all" : ""}. Tables: ${c.join(", ")}. Delete ${N} to force a full re-import.`);
+				let e = c.length === j.tables.length;
+				d.onWarn?.(`resume: ${c.length} of ${j.tables.length} table(s) were already applied by an earlier run of THIS bundle directory, so this run wrote NO rows for them${e ? " — that is every table in the bundle, so nothing was written at all" : ""}. Tables: ${c.join(", ")}. Delete ${P} to force a full re-import.`);
 			}
-		}), Ye = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`, J = /* @__PURE__ */ new Date(), Y = yield* _e({
-			store: u.store,
-			mode: j,
-			dir: u.rollbackDir,
-			snapshot: u.targetSnapshot,
-			dialect: u.targetDialect,
-			tables: k.tables.map((e) => e.name).filter((e) => !t(e)),
-			onWarn: u.onWarn
+		}), et = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`, X = /* @__PURE__ */ new Date(), Z = yield* be({
+			store: d.store,
+			mode: M,
+			dir: d.rollbackDir,
+			snapshot: d.targetSnapshot,
+			dialect: d.targetDialect,
+			tables: j.tables.map((e) => e.name).filter((e) => !n(e)),
+			onWarn: d.onWarn
 		});
-		Y !== void 0 && (u.onRollbackCaptured !== void 0 && (yield* x.tryPromise({
-			try: () => u.onRollbackCaptured(Y),
-			catch: (e) => new n({
+		Z !== void 0 && (d.onRollbackCaptured !== void 0 && (yield* x.tryPromise({
+			try: () => d.onRollbackCaptured(Z),
+			catch: (e) => new r({
 				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: Y.dir
+				path: Z.dir
 			})
-		})), u.onWarn?.(ve(Y)));
-		let Xe = (e) => j === "replace" ? Ee(e) : e(), X = (e) => j === "replace" ? De(e) : e, Z = u.traceId ?? E("dimp", `${Date.now()}-${k.source.schemaFingerprint ?? ""}`), Q = u.traceId !== void 0, $ = (u.targetSnapshot?.tables.some((e) => e.name === w) ?? !1) || D(w) !== void 0;
-		$ && Se(xe), $ && u.traceId === void 0 && (yield* x.promise(() => u.store.insert(w, {
-			id: Z,
-			mode: j,
-			via: u.via ?? "direct",
+		})), d.onWarn?.(xe(Z)));
+		let tt = (e) => M === "replace" ? ke(e) : e(), nt = (e) => M === "replace" ? Ae(e) : e, Q = d.traceId ?? E("dimp", `${Date.now()}-${j.source.schemaFingerprint ?? ""}`), rt = d.traceId !== void 0, $ = (d.targetSnapshot?.tables.some((e) => e.name === w) ?? !1) || D(w) !== void 0;
+		$ && Te(we), $ && d.traceId === void 0 && (yield* x.promise(() => d.store.insert(w, {
+			id: Q,
+			mode: M,
+			via: d.via ?? "direct",
 			direction: "import",
-			bundle: u.bundleDir,
-			sourceFingerprint: k.source.schemaFingerprint ?? null,
+			bundle: d.bundleDir,
+			sourceFingerprint: j.source.schemaFingerprint ?? null,
 			tablesWritten: 0,
 			rowsWritten: 0,
-			staged: j === "replace" ? H : null
+			staged: M === "replace" ? W : null
 		}).then(() => {
-			Q = !0;
+			rt = !0;
 		}, (e) => {
-			u.onWarn?.(`the import trace could not be written (${String(e?.message ?? e)}).\n  The import continues — this is a record of what happened, not a safety check. Run
+			d.onWarn?.(`the import trace could not be written (${String(e?.message ?? e)}).\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.`);
-		}))), u.traceId !== void 0 && $ && (yield* x.promise(() => u.store.update(w, Z, {
-			staged: j === "replace" ? H : null,
-			sourceFingerprint: k.source.schemaFingerprint ?? null
+		}))), d.traceId !== void 0 && $ && (yield* x.promise(() => d.store.update(w, Q, {
+			staged: M === "replace" ? W : null,
+			sourceFingerprint: j.source.schemaFingerprint ?? null
 		}).then(() => void 0, () => void 0)));
-		let Ze = 0, Qe = !1;
-		qe = () => {
-			if (!Q || Qe) return;
+		let it = 0, at = !1;
+		Qe = () => {
+			if (!rt || at) return;
 			let e = Date.now();
-			e - Ze < je || (Ze = e, u.store.update(w, Z, {
-				tablesWritten: W,
-				rowsWritten: U
+			e - it < Pe || (it = e, d.store.update(w, Q, {
+				tablesWritten: K,
+				rowsWritten: G
 			}).then(() => void 0, () => {
-				Qe = !0;
+				at = !0;
 			}));
 		};
-		let $e = (e) => Q ? u.store.update(w, Z, {
+		let ot = (e) => rt ? d.store.update(w, Q, {
 			finishedAt: e === null ? /* @__PURE__ */ new Date() : null,
-			tablesWritten: W,
-			rowsWritten: U,
+			tablesWritten: K,
+			rowsWritten: G,
 			failure: e
 		}).then(() => void 0, () => void 0) : Promise.resolve();
-		if (d = (e) => $e(e), j === "replace" && !H && B.blocker !== void 0 && u.onWarn?.(ge(B.blocker)), j === "replace" && Ge.length > 0 && u.onWarn?.(`write recorders are SUSPENDED for this replace (${Ge.length} table(s) have one).\n  A replace sets a state rather than changing rows, so a per-row history entry would describe
+		if (f = (e) => ot(e), M === "replace" && !W && H.blocker !== void 0 && d.onWarn?.(ye(H.blocker)), M === "replace" && Xe.length > 0 && d.onWarn?.(`write recorders are SUSPENDED for this replace (${Xe.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.`), H) {
-			u.onWarn?.(`staging ${V.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 e = u.store, t = V.map((e) => e.name), r = E("repl", `staging-${Ye}`), i = !1;
-			if (u.recordInterruption === !0) {
-				yield* x.promise(() => u.store.insert(T, {
-					id: r,
-					startedAt: J,
+  tenant scoping or \`audit()\` stamping, for the same reason.`), W) {
+			d.onWarn?.(`staging ${U.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 e = d.store, t = U.map((e) => e.name), n = E("repl", `staging-${et}`), i = !1;
+			if (d.recordInterruption === !0) {
+				yield* x.promise(() => d.store.insert(T, {
+					id: n,
+					startedAt: X,
 					kind: "staging",
-					tables: String(V.length),
-					capture: Y?.dir ?? null,
-					via: u.via ?? "direct",
-					staging: t.map(he).join(","),
+					tables: String(U.length),
+					capture: Z?.dir ?? null,
+					via: d.via ?? "direct",
+					staging: t.map(ve).join(","),
 					heartbeatAt: /* @__PURE__ */ new Date(),
-					resumable: !M
+					resumable: !N
 				}).then(() => {
 					i = !0;
 				}, (e) => {
-					u.onWarn?.(`the staging tables could not be recorded (${String(e?.message ?? e)}).\n  The import continues and the target is unaffected — but if this run dies before the swap,
+					d.onWarn?.(`the staging tables could not be recorded (${String(e?.message ?? e)}).\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 e = Date.now();
-				G = () => {
+				q = () => {
 					if (!i) return;
 					let t = Date.now();
-					t - e < Me || (e = t, u.store.update(T, r, { heartbeatAt: /* @__PURE__ */ new Date() }).then(() => void 0, () => void 0));
+					t - e < Fe || (e = t, d.store.update(T, n, { heartbeatAt: /* @__PURE__ */ new Date() }).then(() => void 0, () => void 0));
 				};
 			}
-			let a = () => i ? u.store.delete(T, r).then(() => void 0, () => void 0) : Promise.resolve(), o = fe(t, {
+			let a = () => i ? d.store.delete(T, n).then(() => void 0, () => void 0) : Promise.resolve(), o = he(t, {
 				getTable: (e) => D(e),
 				registerTable: (e) => {
-					Te(e);
+					Oe(e);
 				},
-				unregisterTable: Oe
+				unregisterTable: je
 			}), s = !1;
 			try {
-				let r = M ? t : t.filter((e) => !m(P, e));
+				let n = N ? t : t.filter((e) => !_(F, e));
 				yield* x.tryPromise({
 					try: async () => {
-						await y(e, r.map((e) => ue(e, z))), await y(e, r.map((e) => se(e, z)));
+						await y(e, n.map((e) => pe(e, V))), await y(e, n.map((e) => ue(e, V)));
 					},
-					catch: (e) => new n({ reason: `could not prepare the staging tables, so the import did not start and the target is untouched: ${String(e?.message ?? e)}` })
-				}), yield* X(q(u.store, !M)), !M && P.truncated === !0 ? s = !0 : yield* x.tryPromise({
-					try: () => pe(e, V, z).then(() => {
+					catch: (e) => new r({ reason: `could not prepare the staging tables, so the import did not start and the target is untouched: ${String(e?.message ?? e)}` })
+				}), yield* nt(Y(d.store, !N)), !N && F.truncated === !0 ? s = !0 : yield* x.tryPromise({
+					try: () => ge(e, U, V).then(() => {
 						s = !0;
 					}),
-					catch: (e) => new n({ reason: String(e?.message ?? e) })
-				}).pipe(x.catch((r) => x.gen(function* () {
-					let i = yield* x.promise(() => de(e, me(u.targetSnapshot, t), z).then((e) => e, () => [])), a = ce(i);
-					return yield* x.fail(new n({ reason: a ?? `the swap failed and the target is UNCHANGED: ${r.reason}` }));
-				}))), !M && s && P.truncated !== !0 && (P.truncated = !0, yield* h(N, P));
+					catch: (e) => new r({ reason: String(e?.message ?? e) })
+				}).pipe(x.catch((n) => x.gen(function* () {
+					let i = yield* x.promise(() => me(e, _e(d.targetSnapshot, t), V).then((e) => e, () => [])), a = de(i);
+					return yield* x.fail(new r({ reason: a ?? `the swap failed and the target is UNCHANGED: ${n.reason}` }));
+				}))), !N && s && F.truncated !== !0 && (F.truncated = !0, yield* v(P, F));
 			} finally {
-				o.undo(), s || M ? (G = void 0, yield* x.promise(() => y(e, t.map((e) => ue(e, z))).then(() => void 0, () => void 0)), yield* x.promise(a)) : u.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");
+				o.undo(), s || N ? (q = void 0, yield* x.promise(() => y(e, t.map((e) => pe(e, V))).then(() => void 0, () => void 0)), yield* x.promise(a)) : d.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 M ? yield* x.tryPromise({
-			try: () => u.store.transactional(async (e) => {
-				let t = await Xe(() => x.runPromiseExit(q(e, !1)));
-				if (S.isFailure(t)) throw Ne(t.cause);
+		} else N ? yield* x.tryPromise({
+			try: () => d.store.transactional(async (e) => {
+				let t = await tt(() => x.runPromiseExit(Y(e, !1)));
+				if (S.isFailure(t)) throw Ie(t.cause);
 			}),
-			catch: (e) => A(e) ?? new n({ reason: `atomic import failed (rolled back): ${String(e?.message ?? e)}` })
-		}) : yield* X(q(u.store, !0));
-		if (u.assets && k.assets.index && !u.assetsAlreadyRestored) {
-			let e = u.assets, t = b.join(u.bundleDir, l), n = b.join(u.bundleDir, k.assets.index ?? "assets/index.ndjson");
-			yield* c({
+			catch: (e) => A(e) ?? new r({ reason: `atomic import failed (rolled back): ${String(e?.message ?? e)}` })
+		}) : yield* nt(Y(d.store, !0));
+		if (d.assets && j.assets.index) {
+			let e = d.assets, t = b.join(d.bundleDir, u), n = b.join(d.bundleDir, j.assets.index ?? "assets/index.ndjson");
+			yield* m({
 				sink: e,
 				assetsDir: t,
 				indexPath: n,
+				...O === void 0 ? {} : { prepared: O },
 				progress: {
-					done: (e) => e in P.assets,
-					mark: (e) => (P.assets[e] = !0, h(N, P))
+					done: (e) => e in F.assets,
+					mark: (e) => (F.assets[e] = !0, v(P, F))
 				}
 			});
 		}
-		return yield* x.promise(() => $e(null)), {
-			manifest: k,
-			tablesWritten: W,
-			rowsWritten: U,
-			tablesSkipped: K,
-			rowsSkipped: Je,
-			fullyResumed: W === 0 && K > 0,
-			...Y === void 0 ? {} : { rollback: Y }
+		return yield* x.promise(() => ot(null)), {
+			manifest: j,
+			tablesWritten: K,
+			rowsWritten: G,
+			tablesSkipped: J,
+			rowsSkipped: $e,
+			fullyResumed: K === 0 && J > 0,
+			...Z === void 0 ? {} : { rollback: Z },
+			...d.fieldKeys?.nullSealed === !0 ? { sealed: Ve() } : {}
 		};
-	}).pipe(x.tapError((e) => x.promise(() => d?.(e._tag === "RowsRefusedError" ? e.message : e?.reason ?? e?._tag ?? "the import did not finish") ?? Promise.resolve())));
+	}).pipe(x.scoped, x.tapError((e) => x.promise(() => f?.(e._tag === "RowsRefusedError" ? e.message : e?.reason ?? e?._tag ?? "the import did not finish") ?? Promise.resolve())));
 };
-//#endregion
-export { O as SAVEPOINT_BATCH_SIZE, A as asImportError, Fe as runImport };
+export { O as SAVEPOINT_BATCH_SIZE, A as asImportError, j as runImport };