@voltro/data-transfer 0.85.0 → 0.87.0

package/dist/importer.js

@@ -0,0 +1,576 @@
+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 { 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 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";
+//#region src/importer.ts
+var Pe = 2e3, Fe = 2e3, O = 200, k = /* @__PURE__ */ new Set([
+	"BundleError",
+	"CodecError",
+	"IntegrityError",
+	"CrossDialectError",
+	"FieldKeysMissingError",
+	"ImportModeError",
+	"RowsRefusedError",
+	"SchemaDriftError",
+	"StorageError"
+]), A = (e) => {
+	let t = b.isCause(e) ? e : S.isExit(e) && S.isFailure(e) ? e.cause : void 0, n = t === void 0 ? [e] : t.reasons.flatMap((e) => b.isFailReason(e) ? [e.error] : b.isDieReason(e) ? [e.defect] : []);
+	for (let t of n) {
+		let n = t?._tag;
+		if (typeof n == "string" && k.has(n)) return t;
+		if (t !== e && (b.isCause(t) || S.isExit(t))) {
+			let e = A(t);
+			if (e) return e;
+		}
+	}
+}, 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, d), "utf8");
+		return f(r);
+	},
+	catch: (e) => new r({
+		reason: `manifest read/parse failed: ${String(e?.message ?? e)}`,
+		path: d
+	})
+}), j = (d) => {
+	let f;
+	return x.gen(function* () {
+		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 k = d.tables === void 0 ? void 0 : new Set(d.tables), j = k === void 0 ? C : {
+			...C,
+			tables: C.tables.filter((e) => k.has(e.name))
+		};
+		if (d.targetSnapshot) {
+			let e = { tables: j.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
+				}))
+			})) }, t = Se(j.source.schemaFingerprint, d.targetSnapshot, e);
+			if (t.drifted) {
+				if (!d.force) return yield* x.fail(new l({
+					bundleFingerprint: t.bundleFingerprint,
+					targetFingerprint: t.targetFingerprint,
+					diff: t.diff
+				}));
+				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 (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 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 (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 (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 (!i.has(e.from)) {
+					let t = yield* x.tryPromise({
+						try: () => d.store.query({
+							table: e.from,
+							predicate: void 0,
+							order: [],
+							take: void 0,
+							skip: void 0,
+							projection: []
+						}),
+						catch: () => new r({ reason: `unreadable: ${e.from}` })
+					}).pipe(x.map((e) => e.length), x.orElseSucceed(() => 0));
+					i.set(e.from, t);
+				}
+				let t = i.get(e.from) ?? 0;
+				t > 0 && n.push({
+					...e,
+					rowCount: t
+				});
+			}
+			if (n.length > 0) return yield* x.fail(new o({
+				mode: M,
+				reason: re(n)
+			}));
+		}
+		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: j,
+			tablesWritten: 0,
+			rowsWritten: 0,
+			tablesSkipped: 0,
+			rowsSkipped: 0,
+			fullyResumed: !1
+		};
+		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 && He.set(e.name, t);
+		}
+		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;
+		}, 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;
+		}, 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) => 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]))
+			};
+		}, 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];
+				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 c({
+				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)
+			});
+		}, 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* 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 = 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* 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;
+		})(), 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 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 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 r({ reason: `emptying the target for --mode replace failed (nothing was deleted): ${ce(e)}` })
+				}), i && (F.truncated = !0, yield* v(P, F));
+			}
+			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 && r.name in F.tables) {
+					c.push(r.name), J++, $e += F.tables[r.name].rowCount, h(d.onProgress, {
+						phase: "import",
+						table: r.name,
+						index: t,
+						tableCount: u,
+						event: "done",
+						rowsDone: F.tables[r.name].rowCount,
+						total: r.rowCount
+					});
+					continue;
+				}
+				let f = b.join(d.bundleDir, r.file);
+				h(d.onProgress, {
+					phase: "import",
+					table: r.name,
+					index: t,
+					tableCount: u,
+					event: "start",
+					rowsDone: 0,
+					total: r.rowCount
+				});
+				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 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 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 e.query({
+								table: r.name,
+								predicate: void 0,
+								order: [],
+								take: 1,
+								skip: void 0,
+								projection: void 0
+							})).length === 0;
+						} catch {
+							return !1;
+						}
+					}), 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 d.copyLoader.copyInto({
+								table: r.name,
+								columns: l,
+								columnTypes: r.columnTypes,
+								rows: e
+							});
+						} catch (t) {
+							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);
+						}
+					}, h = Math.max(1, d.savepointBatchSize ?? 200), te = typeof e.savepoint == "function", g = [], _ = async () => {
+						if (g.length === 0) return;
+						let t = g;
+						g = [];
+						try {
+							await e.savepoint(async () => {
+								for (let n of t) await L(e, r, n);
+							});
+						} catch {
+							for (let e of t) await s(e);
+						}
+					};
+					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: n.digest("hex")
+					};
+				}), { 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 (g !== r.rowCount) return yield* x.fail(new s({
+						what: `table ${r.name} rowCount`,
+						expected: String(r.rowCount),
+						actual: String(g)
+					}));
+				}
+				h(d.onProgress, {
+					phase: "import",
+					table: r.name,
+					index: t,
+					tableCount: u,
+					event: "done",
+					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 (a.length > 0 && (yield* Ye(e, a)), M === "replace" && (yield* x.promise(() => e.deleteMany(T, { where: {
+				column: "startedAt",
+				op: "lte",
+				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* v(P, F);
+			}
+			{
+				let e = t(l, "skipped");
+				e !== void 0 && d.onWarn?.(e);
+			}
+			if (c.length > 0) {
+				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.`);
+			}
+		}), 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
+		});
+		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: Z.dir
+			})
+		})), 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: d.bundleDir,
+			sourceFingerprint: j.source.schemaFingerprint ?? null,
+			tablesWritten: 0,
+			rowsWritten: 0,
+			staged: M === "replace" ? W : null
+		}).then(() => {
+			rt = !0;
+		}, (e) => {
+			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.`);
+		}))), 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 it = 0, at = !1;
+		Qe = () => {
+			if (!rt || at) return;
+			let e = Date.now();
+			e - it < Pe || (it = e, d.store.update(w, Q, {
+				tablesWritten: K,
+				rowsWritten: G
+			}).then(() => void 0, () => {
+				at = !0;
+			}));
+		};
+		let ot = (e) => rt ? d.store.update(w, Q, {
+			finishedAt: e === null ? /* @__PURE__ */ new Date() : null,
+			tablesWritten: K,
+			rowsWritten: G,
+			failure: e
+		}).then(() => void 0, () => void 0) : Promise.resolve();
+		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.`), 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(U.length),
+					capture: Z?.dir ?? null,
+					via: d.via ?? "direct",
+					staging: t.map(ve).join(","),
+					heartbeatAt: /* @__PURE__ */ new Date(),
+					resumable: !N
+				}).then(() => {
+					i = !0;
+				}, (e) => {
+					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();
+				q = () => {
+					if (!i) return;
+					let t = Date.now();
+					t - e < Fe || (e = t, d.store.update(T, n, { heartbeatAt: /* @__PURE__ */ new Date() }).then(() => void 0, () => void 0));
+				};
+			}
+			let a = () => i ? d.store.delete(T, n).then(() => void 0, () => void 0) : Promise.resolve(), o = he(t, {
+				getTable: (e) => D(e),
+				registerTable: (e) => {
+					Oe(e);
+				},
+				unregisterTable: je
+			}), s = !1;
+			try {
+				let n = N ? t : t.filter((e) => !_(F, e));
+				yield* x.tryPromise({
+					try: async () => {
+						await y(e, n.map((e) => pe(e, V))), await y(e, n.map((e) => ue(e, V)));
+					},
+					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 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 || 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 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 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 F.assets,
+					mark: (e) => (F.assets[e] = !0, v(P, F))
+				}
+			});
+		}
+		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.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, j as runImport };