@voltro/data-transfer 0.85.0 → 0.86.0

package/dist/importer.js

@@ -0,0 +1,536 @@
+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 { 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 { 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([
+	"BundleError",
+	"CodecError",
+	"IntegrityError",
+	"CrossDialectError",
+	"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;
+		}
+	}
+}, Ne = (e) => C.getOrUndefined(b.findErrorOption(e)) ?? Error(b.pretty(e)), Pe = (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);
+	},
+	catch: (e) => new n({
+		reason: `manifest read/parse failed: ${String(e?.message ?? e)}`,
+		path: u
+	})
+}), Fe = (u) => {
+	let d;
+	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 O = u.tables === void 0 ? void 0 : new Set(u.tables), k = O === void 0 ? C : {
+			...C,
+			tables: C.tables.filter((e) => O.has(e.name))
+		};
+		if (u.targetSnapshot) {
+			let e = { tables: k.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 = ye(k.source.schemaFingerprint, u.targetSnapshot, e);
+			if (t.drifted) {
+				if (!u.force) return yield* x.fail(new s({
+					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("; ")}`);
+			}
+		}
+		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)
+			}));
+		}
+		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.`
+		}));
+		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
+  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();
+			for (let e of t) {
+				if (!a.has(e.from)) {
+					let t = yield* x.tryPromise({
+						try: () => u.store.query({
+							table: e.from,
+							predicate: void 0,
+							order: [],
+							take: void 0,
+							skip: void 0,
+							projection: []
+						}),
+						catch: () => new n({ reason: `unreadable: ${e.from}` })
+					}).pipe(x.map((e) => e.length), x.orElseSucceed(() => 0));
+					a.set(e.from, t);
+				}
+				let t = a.get(e.from) ?? 0;
+				t > 0 && r.push({
+					...e,
+					rowCount: t
+				});
+			}
+			if (r.length > 0) return yield* x.fail(new i({
+				mode: j,
+				reason: g(r)
+			}));
+		}
+		if (u.dryRun === !0) return u.traceId !== void 0 && (yield* x.promise(() => u.store.update(w, u.traceId, {
+			finishedAt: /* @__PURE__ */ new Date(),
+			tablesWritten: 0,
+			rowsWritten: 0,
+			failure: null
+		}).then(() => void 0, () => void 0))), {
+			manifest: k,
+			tablesWritten: 0,
+			rowsWritten: 0,
+			tablesSkipped: 0,
+			rowsSkipped: 0,
+			fullyResumed: !1
+		};
+		let Le = /* @__PURE__ */ new Map();
+		for (let e of u.targetSnapshot?.tables ?? []) {
+			let t = e.columns.filter((e) => e.generatedAs !== void 0).map((e) => e.name);
+			t.length > 0 && Le.set(e.name, t);
+		}
+		let Re = (e, t) => {
+			let n = Le.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;
+			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({
+			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) => {
+			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) => {
+			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 o({
+				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)
+			});
+		}, We = (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);
+				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);
+				}
+				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;
+			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"
+					}),
+					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
+  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) });
+				});
+				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));
+			}
+			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);
+					continue;
+				}
+				if (i && n.name in P.tables) {
+					c.push(n.name), K++, Je += P.tables[n.name].rowCount, f(u.onProgress, {
+						phase: "import",
+						table: n.name,
+						index: e,
+						tableCount: d,
+						event: "done",
+						rowsDone: P.tables[n.name].rowCount,
+						total: n.rowCount
+					});
+					continue;
+				}
+				let te = b.join(u.bundleDir, n.file);
+				f(u.onProgress, {
+					phase: "import",
+					table: n.name,
+					index: e,
+					tableCount: d,
+					event: "start",
+					rowsDone: 0,
+					total: n.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,
+							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);
+						}
+					}, 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;
+						try {
+							return (await r.query({
+								table: n.name,
+								predicate: void 0,
+								order: [],
+								take: 1,
+								skip: void 0,
+								projection: void 0
+							})).length === 0;
+						} 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 = [];
+						try {
+							await u.copyLoader.copyInto({
+								table: n.name,
+								columns: l,
+								columnTypes: n.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`);
+							for (let t of e) await s(t);
+						}
+					}, m = Math.max(1, u.savepointBatchSize ?? 200), h = typeof r.savepoint == "function", g = [], _ = async () => {
+						if (g.length === 0) return;
+						let e = g;
+						g = [];
+						try {
+							await r.savepoint(async () => {
+								for (let t of e) await F(r, n, t);
+							});
+						} catch {
+							for (let t of e) await s(t);
+						}
+					};
+					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), {
+						rowCount: i,
+						checksum: t.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
+					}));
+					if (_ !== n.rowCount) return yield* x.fail(new a({
+						what: `table ${n.name} rowCount`,
+						expected: String(n.rowCount),
+						actual: String(_)
+					}));
+				}
+				f(u.onProgress, {
+					phase: "import",
+					table: n.name,
+					index: e,
+					tableCount: d,
+					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)));
+			}
+			if (o.length > 0 && (yield* We(r, o)), j === "replace" && (yield* x.promise(() => r.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] = {
+						rowCount: e.rowCount,
+						checksum: t.checksum
+					};
+				}
+				yield* h(N, P);
+			}
+			{
+				let t = e(l, "skipped");
+				t !== void 0 && u.onWarn?.(t);
+			}
+			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.`);
+			}
+		}), 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
+		});
+		Y !== void 0 && (u.onRollbackCaptured !== void 0 && (yield* x.tryPromise({
+			try: () => u.onRollbackCaptured(Y),
+			catch: (e) => new n({
+				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
+			})
+		})), 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",
+			direction: "import",
+			bundle: u.bundleDir,
+			sourceFingerprint: k.source.schemaFingerprint ?? null,
+			tablesWritten: 0,
+			rowsWritten: 0,
+			staged: j === "replace" ? H : null
+		}).then(() => {
+			Q = !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
+  \`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
+		}).then(() => void 0, () => void 0)));
+		let Ze = 0, Qe = !1;
+		qe = () => {
+			if (!Q || Qe) return;
+			let e = Date.now();
+			e - Ze < je || (Ze = e, u.store.update(w, Z, {
+				tablesWritten: W,
+				rowsWritten: U
+			}).then(() => void 0, () => {
+				Qe = !0;
+			}));
+		};
+		let $e = (e) => Q ? u.store.update(w, Z, {
+			finishedAt: e === null ? /* @__PURE__ */ new Date() : null,
+			tablesWritten: W,
+			rowsWritten: U,
+			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
+  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,
+					kind: "staging",
+					tables: String(V.length),
+					capture: Y?.dir ?? null,
+					via: u.via ?? "direct",
+					staging: t.map(he).join(","),
+					heartbeatAt: /* @__PURE__ */ new Date(),
+					resumable: !M
+				}).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,
+  nothing at boot will mention the scratch tables it leaves. \`voltro data clear-staging\` finds
+  them by introspection.`);
+				}));
+				let e = Date.now();
+				G = () => {
+					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));
+				};
+			}
+			let a = () => i ? u.store.delete(T, r).then(() => void 0, () => void 0) : Promise.resolve(), o = fe(t, {
+				getTable: (e) => D(e),
+				registerTable: (e) => {
+					Te(e);
+				},
+				unregisterTable: Oe
+			}), s = !1;
+			try {
+				let r = M ? t : t.filter((e) => !m(P, e));
+				yield* x.tryPromise({
+					try: async () => {
+						await y(e, r.map((e) => ue(e, z))), await y(e, r.map((e) => se(e, z)));
+					},
+					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(() => {
+						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));
+			} 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");
+			}
+		} 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);
+			}),
+			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({
+				sink: e,
+				assetsDir: t,
+				indexPath: n,
+				progress: {
+					done: (e) => e in P.assets,
+					mark: (e) => (P.assets[e] = !0, h(N, P))
+				}
+			});
+		}
+		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 }
+		};
+	}).pipe(x.tapError((e) => x.promise(() => d?.(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 };

package/dist/index.d.ts

@@ -1563,6 +1563,8 @@ declare interface RollbackCapture {
  * list sorted by nothing sees hundreds of lines of which one matters.
  */
 export declare class RowsRefusedError extends RowsRefusedError_base {
+    /** Preserve the bounded refusal report when an error is stored as text. */
+    get message(): string;
 }
 
 declare const RowsRefusedError_base: Schema.Class<RowsRefusedError, Schema.TaggedStruct<"RowsRefusedError", {