@voltro/data-transfer 0.85.0 → 0.86.0

package/THIRD-PARTY-NOTICES.md

@@ -1,11 +1,11 @@
 # Third-Party Notices — @voltro/data-transfer
 
-This package depends on the open-source software listed below. Each is the
+This package uses the open-source software listed below. Each is the
 property of its respective copyright holders and is used under the terms of
 its license. This file is provided for attribution; it grants no rights in
 @voltro/data-transfer itself, which is proprietary (see LICENSE).
 
-Generated from the resolved runtime dependency closure (109 packages).
+Generated from the resolved runtime dependency closure (108 packages).
 
 ---
 
@@ -9624,34 +9624,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## layerr@3.0.0
-
-License: MIT
-
-```
-MIT License
-
-Copyright (c) 2020 Perry Mitchell
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-```
-
 ## lib0@0.2.117
 
 License: MIT
@@ -10459,14 +10431,14 @@ Apache License
    limitations under the License.
 ```
 
-## ulidx@2.4.1
+## ulid@3.0.2
 
 License: MIT
 
 ```
-MIT License
+The MIT License (MIT)
 
-Copyright (c) 2021 Perry Mitchell
+Copyright (c) 2017 Alizain Feerasta
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/assets.js

@@ -0,0 +1,47 @@
+import { BundleError as e, IntegrityError as t } from "./errors.js";
+import { Effect as n, Stream as r } from "effect";
+import { fromNodeReadable as i, getObjectStream as a, putObjectStream as o, toNodeReadable as s } from "@voltro/plugin-storage";
+//#region src/assets.ts
+var c = (e, t) => ({
+	list: t,
+	open: (t) => a(e, t)
+}), l = (e) => ({
+	write: (t, n, r) => o(e, t, n, r),
+	has: (t) => e.head(t).pipe(n.map((e) => e !== null))
+}), u = (t, r) => n.tryPromise({
+	try: async () => {
+		let { createWriteStream: e } = await import("node:fs"), n = await import("node:fs/promises"), { createHash: i, randomUUID: a } = await import("node:crypto"), { pipeline: o } = await import("node:stream/promises"), { Transform: c } = await import("node:stream"), l = await import("node:path"), u = l.join(r, `.tmp-${a()}`), d = i("sha256"), f = 0, p = new c({ transform(e, t, n) {
+			d.update(e), f += e.length, n(null, e);
+		} });
+		await o(await s(t.stream), p, e(u));
+		let m = d.digest("hex"), h = l.join(r, m);
+		try {
+			await n.access(h), await n.rm(u, { force: !0 });
+		} catch {
+			await n.rename(u, h);
+		}
+		return {
+			sha256: m,
+			size: f,
+			contentType: t.contentType
+		};
+	},
+	catch: (t) => new e({
+		reason: `asset write failed: ${String(t?.message ?? t)}`,
+		path: r
+	})
+}), d = (e, a, o) => n.gen(function* () {
+	let s = yield* n.promise(() => import("node:path")), { createReadStream: c } = yield* n.promise(() => import("node:fs")), { createHash: l } = yield* n.promise(() => import("node:crypto")), u = s.join(a, o.sha256), d = l("sha256"), f = i("bundle", () => c(u)).pipe(r.tap((e) => n.sync(() => d.update(e))));
+	yield* e.write(o.key, f, {
+		contentType: o.contentType,
+		totalSize: o.size
+	});
+	let p = d.digest("hex");
+	if (p !== o.sha256) return yield* n.fail(new t({
+		what: `asset ${o.key}`,
+		expected: o.sha256,
+		actual: p
+	}));
+});
+//#endregion
+export { d as restoreAssetFromCas, l as storageAssetSink, c as storageAssetSource, u as writeAssetToCas };

package/dist/blobStorage.js

@@ -0,0 +1,40 @@
+import { Effect as e, Stream as t } from "effect";
+import { streamTable as n } from "@voltro/database";
+import { STORAGE_REFS_TABLE as r, fromNodeReadable as i, getObjectStream as a, putObjectStream as o, toNodeReadable as s } from "@voltro/plugin-storage";
+import { Readable as c } from "node:stream";
+//#region src/blobStorage.ts
+var l = (n, r) => ({
+	list: () => {
+		let n = r();
+		return { async *[Symbol.asyncIterator]() {
+			let r = await e.runPromise(t.runCollect(n));
+			for (let e of r) yield {
+				key: e.key,
+				contentType: e.contentType,
+				size: e.size
+			};
+		} };
+	},
+	open: (t) => ({ async *[Symbol.asyncIterator]() {
+		let r = await e.runPromise(a(n, t)), i = await s(r.stream);
+		for await (let e of i) yield e instanceof Uint8Array ? e : new Uint8Array(e);
+	} })
+}), u = (e, i) => l(e, () => n(i, {
+	table: r,
+	chunkSize: 500
+}).pipe(t.map((e) => ({
+	key: String(e.key),
+	contentType: String(e.contentType ?? "application/octet-stream"),
+	size: Number(e.size ?? 0)
+})))), d = (t) => ({
+	has: (n) => e.runPromise(t.head(n).pipe(e.map((e) => e !== null))),
+	write: async (n, r, a) => {
+		let s = i("storage", () => c.from(r));
+		await e.runPromise(o(t, n, s, {
+			contentType: a.contentType,
+			totalSize: a.size
+		}));
+	}
+});
+//#endregion
+export { d as storageBlobSink, l as storageBlobSource, u as storageRefsBlobSource };

package/dist/bundleArchive.js

@@ -0,0 +1,165 @@
+import { createHash as e } from "node:crypto";
+import { createReadStream as t, createWriteStream as n } from "node:fs";
+import { PassThrough as r } from "node:stream";
+import { mkdir as i, readdir as a, stat as o } from "node:fs/promises";
+import { dirname as s, join as c, resolve as l, sep as u } from "node:path";
+//#region src/bundleArchive.ts
+var d = Buffer.from("VBUNDLE2"), f = 0, p = 1, m = 2, h = 32, g = async (e) => {
+	let t = [], n = async (r) => {
+		let i;
+		try {
+			i = await a(c(e, r), { withFileTypes: !0 });
+		} catch {
+			return;
+		}
+		for (let e of i) {
+			let i = r ? `${r}/${e.name}` : e.name;
+			e.isDirectory() ? await n(i) : e.isFile() && t.push(i);
+		}
+	};
+	return await n(""), t.sort();
+}, _ = (e, t) => {
+	let n = Buffer.from(e, "utf8"), r = Buffer.alloc(5 + n.length + 8);
+	return r.writeUInt8(p, 0), r.writeUInt32BE(n.length, 1), n.copy(r, 5), r.writeBigUInt64BE(BigInt(t), 5 + n.length), r;
+}, v = (e, t, n) => {
+	let r = Buffer.from(e, "utf8"), i = Buffer.from(t, "utf8"), a = Buffer.alloc(5 + r.length + 2 + i.length + 8), o = 0;
+	return a.writeUInt8(m, o), o += 1, a.writeUInt32BE(r.length, o), o += 4, r.copy(a, o), o += r.length, a.writeUInt16BE(i.length, o), o += 2, i.copy(a, o), o += i.length, a.writeBigUInt64BE(BigInt(n), o), a;
+};
+async function* y(n) {
+	yield new Uint8Array(d);
+	for (let e of await g(n.dir)) {
+		let r = c(n.dir, e), i = await o(r);
+		if (yield new Uint8Array(_(e, i.size)), i.size > 0) for await (let e of t(r)) yield new Uint8Array(e);
+	}
+	if (n.blobs) for await (let t of n.blobs.list()) {
+		yield new Uint8Array(v(t.key, t.contentType, t.size));
+		let r = e("sha256"), i = 0;
+		for await (let e of n.blobs.open(t.key)) {
+			let t = Buffer.from(e);
+			r.update(t), i += t.length, yield new Uint8Array(t);
+		}
+		if (i !== t.size) throw Error(`blob '${t.key}' size mismatch: header ${t.size}, streamed ${i}`);
+		yield new Uint8Array(r.digest());
+	}
+	yield new Uint8Array(Buffer.from([f]));
+}
+var b = (e, t) => new Promise((n, r) => e.write(t, (e) => e ? r(e) : n())), x = (e) => new Promise((t) => e.end(t)), S = async (t, a) => {
+	let o = l(a.dir);
+	await i(o, { recursive: !0 });
+	let c = Buffer.alloc(0), g = t[Symbol.asyncIterator](), _ = !1, v = async () => {
+		let { value: e, done: t } = await g.next();
+		return t ? (_ = !0, !1) : (c = c.length === 0 ? Buffer.from(e) : Buffer.concat([c, Buffer.from(e)]), !0);
+	}, y = async (e) => {
+		for (; c.length < e;) if (!await v()) throw Error("truncated bundle archive");
+	}, S = (e) => {
+		let t = c.subarray(0, e);
+		return c = c.subarray(e), t;
+	};
+	try {
+		if (await y(d.length), !S(d.length).equals(d)) throw Error("not a bundle archive (bad magic)");
+		for (;;) {
+			await y(1);
+			let t = S(1).readUInt8(0);
+			if (t === f) return;
+			if (t === p) {
+				await y(4);
+				let e = S(4).readUInt32BE(0);
+				await y(e);
+				let t = S(e).toString("utf8");
+				await y(8);
+				let r = S(8).readBigUInt64BE(0), a = l(o, t);
+				if (a !== o && !a.startsWith(o + u)) throw Error(`archive path '${t}' escapes the destination`);
+				await i(s(a), { recursive: !0 });
+				let d = n(a);
+				for (; r > 0n;) {
+					c.length === 0 && await y(1);
+					let e = r < BigInt(c.length) ? Number(r) : c.length;
+					await b(d, S(e)), r -= BigInt(e);
+				}
+				await x(d);
+			} else if (t === m) {
+				await y(4);
+				let t = S(4).readUInt32BE(0);
+				await y(t);
+				let n = S(t).toString("utf8");
+				await y(2);
+				let i = S(2).readUInt16BE(0);
+				await y(i);
+				let o = S(i).toString("utf8");
+				await y(8);
+				let s = S(8).readBigUInt64BE(0), l = await a.blobs.has(n), u = e("sha256"), d = new r(), f = l ? Promise.resolve() : a.blobs.write(n, d, {
+					contentType: o,
+					size: Number(s)
+				}), p = s;
+				for (; p > 0n;) {
+					c.length === 0 && await y(1);
+					let e = p < BigInt(c.length) ? Number(p) : c.length, t = S(e);
+					u.update(t), l || await b(d, t), p -= BigInt(e);
+				}
+				l ? d.destroy() : await x(d), await f, await y(h);
+				let m = S(h);
+				if (!u.digest().equals(m)) throw Error(`blob '${n}' failed integrity (sha mismatch)`);
+			} else throw Error(`unknown bundle entry kind ${t}`);
+		}
+	} finally {
+		_ || await Promise.resolve(g.return?.()).catch(() => void 0);
+	}
+}, C = async (e, t) => {
+	let n = new Set(t), r = /* @__PURE__ */ new Map(), i = Buffer.alloc(0), a = e[Symbol.asyncIterator](), o = async () => {
+		let { value: e, done: t } = await a.next();
+		return !t && (i = i.length === 0 ? Buffer.from(e) : Buffer.concat([i, Buffer.from(e)]), !0);
+	}, s = async (e) => {
+		for (; i.length < e;) if (!await o()) return !1;
+		return !0;
+	}, c = (e) => {
+		let t = i.subarray(0, e);
+		return i = i.subarray(e), t;
+	}, l = async (e) => {
+		let t = [], n = e;
+		for (; n > 0n;) {
+			if (i.length === 0 && !await s(1)) return null;
+			let e = n < BigInt(i.length) ? Number(n) : i.length;
+			t.push(c(e)), n -= BigInt(e);
+		}
+		return Buffer.concat(t);
+	};
+	if (!await s(d.length) || !c(d.length).equals(d)) throw Error("not a bundle archive (bad magic)");
+	for (; await s(1);) {
+		let e = c(1).readUInt8(0);
+		if (e === f || e === m) break;
+		if (e !== p) throw Error(`unknown bundle entry kind ${e}`);
+		if (!await s(4)) break;
+		let t = c(4).readUInt32BE(0);
+		if (!await s(t)) break;
+		let i = c(t).toString("utf8");
+		if (!await s(8)) break;
+		let a = await l(c(8).readBigUInt64BE(0));
+		if (a === null || n.has(i) && (r.set(i, a), n.delete(i), n.size === 0)) break;
+	}
+	return r;
+}, w = (e, t) => S(e, {
+	dir: t,
+	blobs: T(t)
+}), T = (t) => {
+	let r = /* @__PURE__ */ new Set();
+	return {
+		has: async (e) => r.has(e),
+		write: async (a, o, s) => {
+			let l = await import("node:fs/promises"), { pipeline: u } = await import("node:stream/promises"), { Transform: d } = await import("node:stream"), f = c(t, "assets");
+			await i(f, { recursive: !0 });
+			let p = e("sha256"), m = 0, h = new d({ transform(e, t, n) {
+				p.update(e), m += e.length, n(null, e);
+			} }), g = c(f, `.tmp-${Date.now()}-${r.size}`);
+			await u(o, h, n(g));
+			let _ = p.digest("hex");
+			await l.rename(g, c(f, _)), await l.appendFile(c(f, "index.ndjson"), `${JSON.stringify({
+				key: a,
+				sha256: _,
+				size: m,
+				contentType: s.contentType
+			})}\n`), r.add(a);
+		}
+	};
+};
+//#endregion
+export { T as dirBlobSink, y as packBundle, C as peekBundle, S as unpackBundle, w as unpackBundleToDir };

package/dist/bundleCrypto.js

@@ -0,0 +1,106 @@
+import { createCipheriv as e, createDecipheriv as t, randomBytes as n, scrypt as r } from "node:crypto";
+import { promisify as i } from "node:util";
+//#region src/bundleCrypto.ts
+var a = i(r), o = Buffer.from("VENC1\0\0\0"), s = 32, c = 16, l = 7, u = 16, d = 262144, f = {
+	N: 32768,
+	r: 8,
+	p: 1
+}, p = 134217728, m = 43, h = (e, t, n) => {
+	let r = Buffer.alloc(12);
+	return e.copy(r, 0, 0, l), r.writeUInt32BE(t >>> 0, l), r.writeUInt8(+!!n, 11), r;
+};
+async function* g(t, r) {
+	if (!r) throw Error("encryptStream: a non-empty passphrase is required");
+	let i = n(c), g = n(l), _ = await a(r, i, s, {
+		...f,
+		maxmem: p
+	}), v = Buffer.alloc(m);
+	o.copy(v, 0), v.writeUInt32BE(f.N, 8), v.writeUInt32BE(f.r, 12), v.writeUInt32BE(f.p, 16), i.copy(v, 20), g.copy(v, 36), yield new Uint8Array(v);
+	let y = 0, b = (t, n) => {
+		let r = e("aes-256-gcm", _, h(g, y, n));
+		y === 0 && r.setAAD(v);
+		let i = Buffer.concat([r.update(t), r.final()]), a = r.getAuthTag();
+		y++;
+		let o = Buffer.alloc(5 + i.length + u);
+		return o.writeUInt8(+!!n, 0), o.writeUInt32BE(i.length + u, 1), i.copy(o, 5), a.copy(o, 5 + i.length), new Uint8Array(o);
+	}, x = Buffer.alloc(0), S = 0;
+	for await (let e of t) {
+		let t = Buffer.from(e), n = 0;
+		for (; n < t.length;) {
+			if (S === d && (yield b(x, !1), S = 0), S === 0 && t.length - n >= d) {
+				let e = t.subarray(n, n + d);
+				n += d, n < t.length ? yield b(e, !1) : (x = e, S = d);
+				continue;
+			}
+			x.length !== d && (x = Buffer.alloc(d));
+			let e = Math.min(d - S, t.length - n);
+			t.copy(x, S, n, n + e), S += e, n += e;
+		}
+	}
+	yield b(x.subarray(0, S), !0);
+}
+async function* _(e, n) {
+	if (!n) throw Error("decryptStream: a non-empty passphrase is required");
+	let r = e[Symbol.asyncIterator](), i = Buffer.alloc(0), c = 0, l = !1, d = async (e) => {
+		let t, n = 0;
+		for (; n < e;) {
+			if (c === i.length) {
+				if (l) break;
+				let e = await r.next();
+				if (e.done) {
+					l = !0;
+					break;
+				}
+				if (i = Buffer.from(e.value), c = 0, i.length === 0) continue;
+			}
+			if (n === 0 && i.length - c >= e) {
+				let t = i.subarray(c, c + e);
+				return c += e, t;
+			}
+			t ??= Buffer.alloc(e);
+			let a = Math.min(e - n, i.length - c);
+			i.copy(t, n, c, c + a), c += a, n += a;
+		}
+		return t?.subarray(0, n) ?? Buffer.alloc(0);
+	}, f = !1;
+	try {
+		let e = await d(m);
+		if (e.length !== m) throw Error("encrypted bundle truncated (no header)");
+		if (!e.subarray(0, 8).equals(o)) throw Error("not an encrypted bundle (bad magic / wrong passphrase target)");
+		let r = e.readUInt32BE(8), i = e.readUInt32BE(12), c = e.readUInt32BE(16), l = Buffer.from(e.subarray(20, 36)), f = Buffer.from(e.subarray(36, m)), g = await a(n, l, s, {
+			N: r,
+			r: i,
+			p: c,
+			maxmem: p
+		}), _ = 0, v = !1;
+		for (;;) {
+			let n = await d(5);
+			if (n.length !== 5) {
+				if (n.length === 0 && v) return;
+				throw Error("encrypted bundle truncated (no authenticated final frame)");
+			}
+			if (v) throw Error("encrypted bundle has trailing data after the final frame");
+			let r = n.readUInt8(0);
+			if (r !== 0 && r !== 1) throw Error("encrypted bundle corrupt (invalid final flag)");
+			let i = r === 1, a = n.readUInt32BE(1);
+			if (a < u) throw Error("encrypted bundle corrupt (short frame)");
+			if (a > 262160) throw Error("encrypted bundle corrupt (oversized frame)");
+			let o = await d(a);
+			if (o.length !== a) throw Error("encrypted bundle truncated (frame body)");
+			let s = o.subarray(0, a - u), c = o.subarray(a - u), l = t("aes-256-gcm", g, h(f, _, i));
+			_ === 0 && l.setAAD(e), l.setAuthTag(c);
+			let p = Buffer.concat([l.update(s), l.final()]);
+			_++, i && (v = !0), p.length > 0 && (yield new Uint8Array(p));
+		}
+	} catch (e) {
+		throw f = !0, e;
+	} finally {
+		if (!l) try {
+			await r.return?.();
+		} catch (e) {
+			if (!f) throw e;
+		}
+	}
+}
+//#endregion
+export { _ as decryptStream, g as encryptStream };

package/dist/casAssetPhase.js

@@ -0,0 +1,43 @@
+import { BundleError as e } from "./errors.js";
+import { restoreAssetFromCas as t, writeAssetToCas as n } from "./assets.js";
+import { Effect as r, Stream as i } from "effect";
+import { createReadStream as a } from "node:fs";
+import { fromNodeReadable as o } from "@voltro/plugin-storage";
+//#region src/casAssetPhase.ts
+var s = {
+	done: () => !1,
+	mark: () => r.void
+}, c = (e) => typeof e == "object" && !!e && e.status === 404, l = (t) => r.gen(function* () {
+	let a = t.progress ?? s, o = 0, l = 0, u = 0, d = 0, f = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Set(), m = [];
+	return yield* i.runForEach(t.source.list(), (e) => (u++, a.done(e.key) || p.has(e.key) ? r.void : (p.add(e.key), t.source.open(e.key).pipe(r.map((e) => e), r.catchIf(c, () => r.sync(() => {
+		m.push(e.key);
+	})), r.flatMap((i) => i === void 0 ? r.void : n(i, t.assetsDir).pipe(r.flatMap((t) => {
+		let n = {
+			key: e.key,
+			sha256: t.sha256,
+			size: t.size,
+			contentType: t.contentType
+		};
+		return o++, l += t.size, f.has(t.sha256) || (f.add(t.sha256), d += t.size), a.mark(e.key, n);
+	}))))))).pipe(r.mapError((t) => t instanceof e ? t : new e({ reason: `asset export failed: ${String(t)}` }))), {
+		count: o,
+		totalBytes: l,
+		references: u,
+		objects: f.size,
+		objectBytes: d,
+		missing: m
+	};
+}), u = (t) => o("bundle", () => a(t)).pipe(i.decodeText(), i.splitLines, i.filter((e) => e.trim().length > 0), i.map((e) => JSON.parse(e)), i.mapError((n) => n instanceof e ? n : new e({
+	reason: `asset index unreadable: ${String(n)}`,
+	path: t
+}))), d = (e) => r.gen(function* () {
+	let n = e.progress ?? s, a = 0, o = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set();
+	return yield* i.runForEach(u(e.indexPath), (i) => n.done(i.key) || c.has(i.key) ? r.void : (c.add(i.key), t(e.sink, e.assetsDir, i)).pipe(r.andThen(r.sync(() => {
+		a++, o.add(i.sha256);
+	})), r.andThen(n.mark(i.key, i)))), {
+		count: a,
+		objects: o.size
+	};
+});
+//#endregion
+export { l as captureAssetsToCas, s as noAssetProgress, u as readAssetIndex, d as restoreAssetsFromCas };

package/dist/compress.js

@@ -0,0 +1,6 @@
+import * as e from "node:zlib";
+import { PassThrough as t } from "node:stream";
+//#region src/compress.ts
+var n = () => typeof e.createZstdCompress == "function", r = (e) => e === "none" ? "none" : e === "gzip" ? "gzip" : n() ? "zstd" : "gzip", i = (e) => e === "zstd" ? ".zst" : e === "gzip" ? ".gz" : "", a = (n) => n === "zstd" ? e.createZstdCompress() : n === "gzip" ? e.createGzip() : new t(), o = (n) => n === "zstd" ? e.createZstdDecompress() : n === "gzip" ? e.createGunzip() : new t();
+//#endregion
+export { i as compressionExt, n as hasZstd, a as makeCompressor, o as makeDecompressor, r as pickCompression };

package/dist/consistency.js

@@ -0,0 +1,14 @@
+//#region src/consistency.ts
+var e = (e) => {
+	switch (e) {
+		case "postgres": return ["SET TRANSACTION ISOLATION LEVEL REPEATABLE READ"];
+		case "mysql":
+		case "mariadb": return ["SET TRANSACTION ISOLATION LEVEL REPEATABLE READ"];
+		case "mssql": return ["SET TRANSACTION ISOLATION LEVEL SNAPSHOT"];
+		case "sqlite":
+		case "turso": return [];
+		default: return [];
+	}
+};
+//#endregion
+export { e as snapshotPrelude };

package/dist/crossDialect.js

@@ -0,0 +1,58 @@
+//#region src/crossDialect.ts
+var e = (e) => {
+	switch (e) {
+		case "id":
+		case "text":
+		case "enum": return e === "enum" ? "enum" : "string";
+		case "integer": return "integer";
+		case "real": return "float";
+		case "boolean": return "boolean";
+		case "timestamp": return "datetime";
+		case "date": return "date";
+		case "json": return "json";
+		case "bytes": return "binary";
+		case "reference": return "reference";
+		case "vector": return "vector";
+		case "array": return "array";
+		case "interval": return "interval";
+		case "raw": return "raw";
+		default: return "string";
+	}
+}, t = {
+	vector: /* @__PURE__ */ new Set(["postgres"]),
+	array: /* @__PURE__ */ new Set(["postgres"]),
+	interval: /* @__PURE__ */ new Set(["postgres"])
+}, n = (n, r, i, a) => {
+	let o = e(i);
+	if (o === "raw") return {
+		table: n,
+		column: r,
+		type: i,
+		severity: "block",
+		reason: `raw() is verbatim source-dialect SQL — it cannot be assumed valid on ${a}`
+	};
+	let s = t[o];
+	return !s || s.has(a) ? null : o === "array" || o === "interval" ? {
+		table: n,
+		column: r,
+		type: i,
+		severity: "warn",
+		reason: `${o} is native to postgres; ${a} will represent it as json/text — verify downstream reads`
+	} : {
+		table: n,
+		column: r,
+		type: i,
+		severity: "block",
+		reason: `${o} columns require a ${[...s].join("/")} target; ${a} has no compatible column type`
+	};
+}, r = (e, t, r) => {
+	if (t === r) return [];
+	let i = [];
+	for (let t of e) for (let [e, a] of Object.entries(t.columnTypes)) {
+		let o = n(t.name, e, a, r);
+		o && i.push(o);
+	}
+	return i;
+}, i = (e) => `[${e.severity}] ${e.table}.${e.column} (${e.type}): ${e.reason}`;
+//#endregion
+export { e as canonicalType, r as checkPortability, i as formatIssue };

package/dist/driftClassification.js

@@ -0,0 +1,58 @@
+//#region src/driftClassification.ts
+var e = (e, t) => {
+	let n = new Map(t.map((e) => [e.name, e])), r = [], i = {};
+	for (let t of e) {
+		let e = n.get(t.name);
+		if (e === void 0) {
+			r.push({
+				verdict: "refuse",
+				table: t.name,
+				detail: `the bundle carries '${t.name}' and the target schema has no such table — nowhere to put ${t.name}'s rows`
+			});
+			continue;
+		}
+		let a = new Map(e.columns.map((e) => [e.name, e])), o = new Map(t.columns.map((e) => [e.name, e])), s = [];
+		for (let e of t.columns) {
+			let n = a.get(e.name);
+			n === void 0 ? (s.push(e.name), r.push({
+				verdict: "value-dropped",
+				table: t.name,
+				column: e.name,
+				detail: `'${t.name}.${e.name}' is in the bundle and not in the schema — its values are DISCARDED`
+			})) : n.type !== e.type && r.push({
+				verdict: "refuse",
+				table: t.name,
+				column: e.name,
+				detail: `'${t.name}.${e.name}' changed type (${e.type} → ${n.type}) — the bundle's values would be written through a codec that no longer matches them`
+			});
+		}
+		for (let n of e.columns) o.has(n.name) || (n.nullable || n.hasDefault ? r.push({
+			verdict: "filled-by-default",
+			table: t.name,
+			column: n.name,
+			detail: `'${t.name}.${n.name}' is in the schema and not in the bundle — every imported row gets ${n.hasDefault ? "its default" : "NULL"}`
+		}) : r.push({
+			verdict: "refuse",
+			table: t.name,
+			column: n.name,
+			detail: `'${t.name}.${n.name}' is NOT NULL with no default and the bundle has no value for it`
+		}));
+		s.length > 0 && (i[t.name] = s);
+	}
+	return {
+		findings: r,
+		skipColumns: i,
+		refuse: r.some((e) => e.verdict === "refuse")
+	};
+}, t = (e) => {
+	if (e.findings.length === 0) return ["  schema matches the bundle"];
+	let t = {
+		safe: "✓",
+		"value-dropped": "⊖",
+		"filled-by-default": "⊕",
+		refuse: "✗"
+	}, n = e.findings.map((e) => `  ${t[e.verdict]} ${e.detail}`), r = (t) => e.findings.filter((e) => e.verdict === t).length;
+	return n.push(""), n.push(`  discarded: ${r("value-dropped")}   defaulted: ${r("filled-by-default")}   refused: ${r("refuse")}`), e.refuse && (n.push(""), n.push("  REFUSED — no row was written. These are the differences that would make"), n.push("  imported rows WRONG rather than merely incomplete.")), n;
+};
+//#endregion
+export { e as classifyImportDrift, t as formatImportDrift };