@voltro/data-transfer 0.85.0 → 0.87.0

package/dist/assetAdmission.js

@@ -0,0 +1,92 @@
+import { BundleError as e, IntegrityError as t } from "./errors.js";
+import { admitFilesystemPath as n } from "./filesystemAdmission.js";
+import { AssetEntry as r } from "./manifest.js";
+import { physicalRequest as i } from "./physicalRequest.js";
+import { Effect as a, Schema as o } from "effect";
+import { createHash as s } from "node:crypto";
+import { constants as c, createWriteStream as l } from "node:fs";
+import { lstat as u, mkdtemp as d, open as f, rm as p } from "node:fs/promises";
+import { join as m } from "node:path";
+import { tmpdir as h } from "node:os";
+import { Transform as g } from "node:stream";
+import { pipeline as _ } from "node:stream/promises";
+import { storageAddressIdentity as v } from "@voltro/plugin-storage/errors";
+//#region src/assetAdmission.ts
+var y = Symbol("admitted-assets"), b = /* @__PURE__ */ new WeakMap(), x = (t) => o.decodeUnknownEffect(r)(t).pipe(a.mapError(() => new e({ reason: "asset index contains invalid key, digest, size or content type" }))), S = o.Struct({
+	...r.fields,
+	sha256: o.optionalKey(r.fields.sha256)
+}), C = (t) => o.decodeUnknownEffect(S)(t).pipe(a.mapError(() => new e({ reason: "asset source metadata contains invalid destination, tenant, key, digest, size or content type" }))), w = (t, n) => b.get(t) === n ? a.void : a.fail(new e({ reason: "asset admission is absent, belongs to another sink or its scope has closed" })), T = (e) => w(e.prepared, e.previousSink).pipe(a.flatMap(() => E({
+	entries: e.prepared.entries,
+	assetsDir: e.prepared.assetsDir,
+	sink: e.sink
+}))), E = (r) => a.gen(function* () {
+	yield* a.tryPromise({
+		try: () => n(r.assetsDir, "directory"),
+		catch: () => new e({ reason: "asset source directory could not be admitted" })
+	});
+	let o = [], S = /* @__PURE__ */ new Map();
+	for (let t of r.entries) {
+		let n = yield* x(t), r = v(n), i = S.get(r);
+		if (i !== void 0) {
+			if (i.sha256 !== n.sha256 || i.size !== n.size || i.contentType !== n.contentType) return yield* a.fail(new e({ reason: "asset index contains conflicting entries for one key" }));
+		} else S.set(r, n), o.push(n);
+	}
+	let C = yield* a.acquireRelease(a.tryPromise({
+		try: () => d(m(h(), "voltro-admitted-assets-")),
+		catch: () => new e({ reason: "cannot create asset admission directory" })
+	}), (e) => a.promise(() => p(e, {
+		recursive: !0,
+		force: !0
+	}))), w = /* @__PURE__ */ new Set();
+	for (let d of o) if (yield* r.sink.has(d), w.has(d.sha256)) {
+		let n = yield* a.tryPromise({
+			try: () => u(m(C, d.sha256)).then((e) => e.size),
+			catch: () => new e({ reason: "admitted asset body is unavailable" })
+		});
+		if (n !== d.size) return yield* a.fail(new t({
+			what: `asset ${d.key} size`,
+			expected: String(d.size),
+			actual: String(n)
+		}));
+	} else {
+		let o = yield* i(async (e) => {
+			let t = m(r.assetsDir, d.sha256);
+			await n(t, "file");
+			let i = await f(t, c.O_RDONLY | c.O_NOFOLLOW | c.O_NONBLOCK);
+			try {
+				if (!(await i.stat()).isFile()) throw Error("asset body must be a regular file");
+				let t = s("sha256"), n = 0, r = new g({ transform(e, r, i) {
+					t.update(e), n += e.length, i(null, e);
+				} });
+				return await _(i.createReadStream({ autoClose: !1 }), r, l(m(C, d.sha256), {
+					flags: "wx",
+					mode: 384
+				}), { signal: e }), {
+					sha256: t.digest("hex"),
+					size: n
+				};
+			} finally {
+				await i.close();
+			}
+		}, () => new e({
+			reason: "asset body could not be admitted",
+			path: d.sha256
+		}));
+		if (o.sha256 !== d.sha256 || o.size !== d.size) return yield* a.fail(new t({
+			what: `asset ${d.key}`,
+			expected: `${d.sha256}/${d.size}`,
+			actual: `${o.sha256}/${o.size}`
+		}));
+		w.add(d.sha256);
+	}
+	let T = Object.freeze({
+		[y]: !0,
+		assetsDir: C,
+		entries: Object.freeze(o.map((e) => Object.freeze(e)))
+	});
+	return b.set(T, r.sink), yield* a.addFinalizer(() => a.sync(() => {
+		b.delete(T);
+	})), T;
+});
+//#endregion
+export { S as AssetSourceInfo, w as assertPreparedAssets, x as decodeAssetEntry, C as decodeAssetSourceInfo, E as prepareAssetEntries, T as readmitPreparedAssets };

package/dist/assets.js

@@ -0,0 +1,68 @@
+import { BundleError as e } from "./errors.js";
+import { admitFilesystemPath as t } from "./filesystemAdmission.js";
+import { physicalRequest as n } from "./physicalRequest.js";
+import { assertPreparedAssets as r, prepareAssetEntries as i } from "./assetAdmission.js";
+import { Effect as a, Stream as o } from "effect";
+import { createHash as s } from "node:crypto";
+import { fromNodeReadable as c, getObjectStream as l, putObjectStream as u, toNodeReadable as d } from "@voltro/plugin-storage";
+import { storageAddressIdentity as f } from "@voltro/plugin-storage/errors";
+//#region src/assets.ts
+var p = (e, t) => ({
+	list: t,
+	open: (t) => e.resolve(t).pipe(a.flatMap((e) => l(e, t.key)))
+}), m = (e) => ({
+	write: (t, n, r) => e.resolve(t).pipe(a.flatMap((e) => u(e, t.key, n, r))),
+	has: (t) => e.resolve(t).pipe(a.flatMap((e) => e.head(t.key)), a.map((e) => e !== null)),
+	matches: (t) => a.gen(function* () {
+		let n = yield* e.resolve(t), r = yield* n.head(t.key);
+		if (r === null || r.size !== t.size || r.contentType !== void 0 && r.contentType !== t.contentType) return !1;
+		let i = yield* l(n, t.key);
+		if (i.contentType !== t.contentType) return !1;
+		let a = s("sha256");
+		return (yield* o.runFold(i.stream, () => 0, (e, t) => (a.update(t), e + t.byteLength))) === t.size && a.digest("hex") === t.sha256;
+	})
+}), h = (r, i) => n(async (e) => {
+	let { createWriteStream: n } = await import("node:fs"), a = await import("node:fs/promises"), { pipeline: o, finished: c } = await import("node:stream/promises"), { Transform: l } = await import("node:stream"), u = await import("node:path");
+	await t(i, "directory");
+	let f = await a.mkdtemp(u.join(i, ".voltro-capture-")), p;
+	try {
+		let c = u.join(f, "body"), m = s("sha256"), h = 0, g = new l({ transform(e, t, n) {
+			m.update(e), h += e.length, n(null, e);
+		} });
+		p = await d(r.stream), await o(p, g, n(c, {
+			flags: "wx",
+			mode: 384
+		}), { signal: e });
+		let _ = m.digest("hex"), v = u.join(i, _);
+		return await t(v, "file"), await a.rename(c, v), {
+			sha256: _,
+			size: h,
+			contentType: r.contentType
+		};
+	} finally {
+		p !== void 0 && (p.destroy(), await c(p, { cleanup: !0 }).catch(() => void 0)), await a.rm(f, {
+			recursive: !0,
+			force: !0
+		});
+	}
+}, () => new e({
+	reason: "asset capture failed",
+	path: i
+})), g = (e, t, n) => a.scoped(a.gen(function* () {
+	yield* _(e, yield* i({
+		sink: e,
+		assetsDir: t,
+		entries: [n]
+	}), n);
+})), _ = (t, n, i) => a.gen(function* () {
+	yield* r(n, t);
+	let o = yield* a.promise(() => import("node:path")), { createReadStream: s } = yield* a.promise(() => import("node:fs"));
+	if (!n.entries.some((e) => f(e) === f(i) && e.sha256 === i.sha256 && e.size === i.size && e.contentType === i.contentType)) return yield* a.fail(new e({ reason: "asset is outside the admitted index" }));
+	let l = o.join(n.assetsDir, i.sha256), u = c("bundle", () => s(l));
+	yield* t.write(i, u, {
+		contentType: i.contentType,
+		totalSize: i.size
+	});
+});
+//#endregion
+export { _ as applyAdmittedAsset, g as restoreAssetFromCas, m as storageAssetSink, p as storageAssetSource, h as writeAssetToCas };

package/dist/blobStorage.js

@@ -0,0 +1,64 @@
+import { physicalRequest as e } from "./physicalRequest.js";
+import { storageAssetSink as t } from "./assets.js";
+import { assetBundleContext as n, bundleAssetInfoStream as r, storageAssetInfo as i } from "./storageAssetMetadata.js";
+import { Effect as a, Stream as o } from "effect";
+import { streamTable as s } from "@voltro/database";
+import { STORAGE_REFS_TABLE as c, StorageError as l, fromNodeReadable as u, getObjectStream as d, putObjectStream as f, toNodeReadable as p } from "@voltro/plugin-storage";
+import { Readable as m } from "node:stream";
+import { finished as h } from "node:stream/promises";
+//#region src/blobStorage.ts
+var g = (e, t) => ({
+	list: (e) => {
+		let n = t(e);
+		return { async *[Symbol.asyncIterator]() {
+			let e = await a.runPromise(o.runCollect(n));
+			for (let t of e) yield t;
+		} };
+	},
+	open: (t) => ({ async *[Symbol.asyncIterator]() {
+		let n = await a.runPromise(e.resolve(t)), r = await a.runPromise(n.head(t.key));
+		if (r !== null && (r.contentType !== void 0 && r.contentType !== t.contentType || r.size !== t.size)) throw Error("archive blob contradicts source metadata");
+		let i = await a.runPromise(d(n, t.key));
+		if (r?.contentType !== void 0 && i.contentType !== t.contentType || i.size !== void 0 && i.size !== t.size) throw i.close !== void 0 && await a.runPromise(i.close), Error("archive blob contradicts source metadata");
+		let o = await p(i.stream);
+		for await (let e of o) yield e instanceof Uint8Array ? e : new Uint8Array(e);
+	} })
+}), _ = (e, t) => g(e, (e) => e === void 0 ? s(t, {
+	table: c,
+	chunkSize: 500
+}).pipe(o.map(i)) : o.unwrap(n(e).pipe(a.map(r)))), v = (e) => ({
+	has: (n, r) => a.runPromise(t(e).has(n), r),
+	matches: (n, r) => a.runPromise(t(e).matches(n), r),
+	write: async (t, n, r, i) => {
+		let o = u("storage", () => m.from(n));
+		await a.runPromise(e.resolve(t).pipe(a.flatMap((e) => f(e, t.key, o, {
+			contentType: r.contentType,
+			totalSize: r.size
+		}))), i);
+	}
+}), y = (t, n) => e(t, () => new l({
+	provider: "archive",
+	message: n,
+	transient: !1
+})), b = (e) => ({
+	has: (t) => y((n) => e.has(t, { signal: n }), "asset destination admission failed"),
+	matches: (t) => y((n) => e.matches(t, { signal: n }), "asset destination content verification failed"),
+	write: (t, n, r) => y(async (i) => {
+		if (r.totalSize === void 0) throw Error("admitted asset size is required");
+		let a = await p(n), o = () => {
+			a.destroy();
+		};
+		i.addEventListener("abort", o, { once: !0 });
+		try {
+			if (i.aborted) throw o(), Error("asset write interrupted");
+			await e.write(t, a, {
+				contentType: r.contentType,
+				size: r.totalSize
+			}, { signal: i });
+		} finally {
+			i.removeEventListener("abort", o), a.destroy(), await h(a, { cleanup: !0 }).catch(() => void 0);
+		}
+	}, "admitted asset write failed")
+});
+//#endregion
+export { b as blobAssetSink, v as storageBlobSink, g as storageBlobSource, _ as storageRefsBlobSource };

package/dist/bundleArchive.js

@@ -0,0 +1,310 @@
+import { admitFilesystemPath as e, publishBundleFile as t } from "./filesystemAdmission.js";
+import { isSafeBundlePath as n } from "./bundlePaths.js";
+import { AssetAddress as r, MANIFEST_FILE as i, decodeManifest as a, encodeManifest as o } from "./manifest.js";
+import { decodeAssetSourceInfo as s, prepareAssetEntries as c } from "./assetAdmission.js";
+import { readAssetIndex as l } from "./casAssetPhase.js";
+import { Effect as u, Schema as d, Stream as f } from "effect";
+import { createHash as p } from "node:crypto";
+import { createReadStream as m, createWriteStream as h } from "node:fs";
+import { lstat as g, mkdir as _, mkdtemp as v, readdir as y, rm as b, stat as x } from "node:fs/promises";
+import { dirname as S, join as C, resolve as w, sep as T } from "node:path";
+import { tmpdir as E } from "node:os";
+import { PassThrough as D } from "node:stream";
+import { storageAddressIdentity as O } from "@voltro/plugin-storage/errors";
+//#region src/bundleArchive.ts
+var k = Buffer.from("VBUNDLE3"), A = 0, j = 1, M = 2, N = 32, P = async (e) => {
+	let t = [], n = async (r) => {
+		let i;
+		try {
+			i = await y(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();
+}, F = (e, t) => {
+	let n = Buffer.from(e, "utf8"), r = Buffer.alloc(5 + n.length + 8);
+	return r.writeUInt8(j, 0), r.writeUInt32BE(n.length, 1), n.copy(r, 5), r.writeBigUInt64BE(BigInt(t), 5 + n.length), r;
+}, I = (e, t, n) => {
+	let i = Buffer.from(JSON.stringify(d.decodeUnknownSync(r)(e)), "utf8"), a = Buffer.from(t, "utf8"), o = Buffer.alloc(5 + i.length + 2 + a.length + 8), s = 0;
+	return o.writeUInt8(M, s), s += 1, o.writeUInt32BE(i.length, s), s += 4, i.copy(o, s), s += i.length, o.writeUInt16BE(a.length, s), s += 2, a.copy(o, s), s += a.length, o.writeBigUInt64BE(BigInt(n), s), o;
+};
+async function* L(e) {
+	yield new Uint8Array(k);
+	for (let t of await P(e.dir)) {
+		let n = C(e.dir, t), r = await x(n);
+		if (yield new Uint8Array(F(t, r.size)), r.size > 0) for await (let e of m(n)) yield new Uint8Array(e);
+	}
+	if (e.blobs) for await (let t of e.blobs.list(e.dir)) {
+		let n = await u.runPromise(s(t));
+		yield new Uint8Array(I(n, n.contentType, n.size));
+		let r = p("sha256"), i = 0;
+		for await (let t of e.blobs.open(n)) {
+			let e = Buffer.from(t);
+			r.update(e), i += e.length, yield new Uint8Array(e);
+		}
+		if (i !== n.size) throw Error(`blob '${n.key}' size mismatch: header ${n.size}, streamed ${i}`);
+		let a = r.digest();
+		if (n.sha256 !== void 0 && a.toString("hex") !== n.sha256) throw Error("archive blob contradicts SQL checksum");
+		yield new Uint8Array(a);
+	}
+	yield new Uint8Array(Buffer.from([A]));
+}
+var R = (e, t) => new Promise((n, r) => e.write(t, (e) => e ? r(e) : n())), z = (e) => new Promise((t) => e.end(t)), B = async (n, r) => {
+	let i = await v(C(E(), "voltro-admitted-archive-")), a = C(i, "files"), o = C(i, "objects");
+	try {
+		await V(n, {
+			dir: a,
+			blobs: {
+				...W(o),
+				has: async () => !1
+			}
+		});
+		let i = C(o, "assets", "index.ndjson"), s = await x(i).then(() => !0, () => !1) ? Array.from(await u.runPromise(f.runCollect(l(i)))) : [], c = await P(a);
+		await e(r.dir, "directory");
+		for (let t of c) await e(C(w(r.dir), t), "file");
+		let d = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Set();
+		for (let e of s) {
+			let t = O(e), n = d.get(t);
+			if (n !== void 0 && (n.sha256 !== e.sha256 || n.size !== e.size || n.contentType !== e.contentType)) throw Error("archive contains conflicting blob entries");
+			d.set(t, e), await r.blobs.has(e), await r.blobs.matches(e) && p.add(t);
+		}
+		for (let e of c) {
+			let n = C(w(r.dir), e);
+			await t(C(a, e), n);
+		}
+		for (let [e, t] of d) {
+			if (p.has(e)) continue;
+			let n = m(C(o, "assets", t.sha256));
+			try {
+				await r.blobs.write(t, n, {
+					contentType: t.contentType,
+					size: t.size
+				});
+			} finally {
+				n.destroy();
+			}
+		}
+	} finally {
+		await b(i, {
+			recursive: !0,
+			force: !0
+		});
+	}
+}, V = async (e, t) => {
+	let i = w(t.dir);
+	await _(i, { recursive: !0 });
+	let a = Buffer.alloc(0), o = e[Symbol.asyncIterator](), s = !1, c = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Map(), u = async () => {
+		let { value: e, done: t } = await o.next();
+		return t ? (s = !0, !1) : (a = a.length === 0 ? Buffer.from(e) : Buffer.concat([a, Buffer.from(e)]), !0);
+	}, f = async (e) => {
+		for (; a.length < e;) if (!await u()) throw Error("truncated bundle archive");
+	}, m = (e) => {
+		let t = a.subarray(0, e);
+		return a = a.subarray(e), t;
+	};
+	try {
+		if (await f(k.length), !m(k.length).equals(k)) throw Error("not a bundle archive (bad magic)");
+		for (;;) {
+			await f(1);
+			let e = m(1).readUInt8(0);
+			if (e === A) {
+				if (a.length > 0) throw Error("trailing bytes after bundle end marker");
+				for (; await u();) if (a.length > 0) throw Error("trailing bytes after bundle end marker");
+				return;
+			}
+			if (e === j) {
+				await f(4);
+				let e = m(4).readUInt32BE(0);
+				if (e === 0 || e > 65536) throw Error("invalid archive path length");
+				await f(e);
+				let t = m(e).toString("utf8");
+				await f(8);
+				let r = m(8).readBigUInt64BE(0), o = w(i, t);
+				if (o === i || !o.startsWith(i + T) || !n(t)) throw Error(`archive path '${t}' escapes the destination`);
+				if (c.has(o)) throw Error("duplicate plain archive path");
+				c.add(o), await _(S(o), { recursive: !0 });
+				let s = h(o);
+				try {
+					for (; r > 0n;) {
+						a.length === 0 && await f(1);
+						let e = r < BigInt(a.length) ? Number(r) : a.length;
+						await R(s, m(e)), r -= BigInt(e);
+					}
+					await z(s);
+				} finally {
+					s.destroy();
+				}
+			} else if (e === M) {
+				await f(4);
+				let e = m(4).readUInt32BE(0);
+				if (e === 0 || e > 65536) throw Error("invalid archive key length");
+				await f(e);
+				let n = d.decodeUnknownSync(r)(JSON.parse(m(e).toString("utf8"))), i = O(n);
+				await f(2);
+				let o = m(2).readUInt16BE(0);
+				await f(o);
+				let s = m(o).toString("utf8");
+				await f(8);
+				let c = m(8).readBigUInt64BE(0);
+				if (c > BigInt(2 ** 53 - 1)) throw Error("archive blob size exceeds exact integer range");
+				let u = p("sha256"), h = new D(), g = t.blobs.write(n, h, {
+					contentType: s,
+					size: Number(c)
+				});
+				g.catch((e) => {
+					h.destroy(e instanceof Error ? e : /* @__PURE__ */ Error("archive staging failed"));
+				});
+				let _ = c;
+				try {
+					for (; _ > 0n;) {
+						a.length === 0 && await f(1);
+						let e = _ < BigInt(a.length) ? Number(_) : a.length, t = m(e);
+						u.update(t), await R(h, t), _ -= BigInt(e);
+					}
+					await z(h), await g, await f(N);
+					let e = m(N), t = u.digest();
+					if (!t.equals(e)) throw Error(`blob '${i}' failed integrity (sha mismatch)`);
+					let r = {
+						...n,
+						sha256: t.toString("hex"),
+						size: Number(c),
+						contentType: s
+					}, o = l.get(i);
+					if (o !== void 0 && (o.sha256 !== r.sha256 || o.size !== r.size || o.contentType !== r.contentType)) throw Error("archive contains conflicting blob addresses");
+					l.set(i, r);
+				} finally {
+					h.destroy(), await g.catch(() => void 0);
+				}
+			} else throw Error(`unknown bundle entry kind ${e}`);
+		}
+	} finally {
+		s || await Promise.resolve(o.return?.()).catch(() => void 0);
+	}
+}, H = 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(k.length) || !c(k.length).equals(k)) throw Error("not a bundle archive (bad magic)");
+	for (; await s(1);) {
+		let e = c(1).readUInt8(0);
+		if (e === A || e === M) break;
+		if (e !== j) 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;
+}, U = (e, t) => B(e, {
+	dir: t,
+	blobs: W(t)
+}).then(async () => {
+	let e = await import("node:fs/promises"), n = C(t, "assets", "index.ndjson");
+	if (!await x(n).then(() => !0, () => !1)) return;
+	let r = await e.readFile(C(t, i), "utf8").catch(() => void 0);
+	if (r === void 0) return;
+	let s;
+	try {
+		s = a(r);
+	} catch {
+		return;
+	}
+	let c = Array.from(await u.runPromise(f.runCollect(l(n)))), d = new Map(c.map((e) => [O(e), e]));
+	await e.writeFile(C(t, i), o({
+		...s,
+		assets: {
+			count: d.size,
+			totalBytes: [...d.values()].reduce((e, t) => e + t.size, 0),
+			index: "assets/index.ndjson"
+		}
+	}));
+}), W = (t) => {
+	let n = /* @__PURE__ */ new Set();
+	return {
+		has: async (r) => (await e(C(t, "assets"), "directory"), await e(C(t, "assets", "index.ndjson"), "file"), n.has(O(r))),
+		matches: async (n) => {
+			let r = C(t, "assets", "index.ndjson");
+			if (await e(r, "file"), !await x(r).then(() => !0, () => !1)) return !1;
+			let i = Array.from(await u.runPromise(f.runCollect(l(r)))).filter((e) => O(e) === O(n));
+			if (i.length === 0 || i.some((e) => e.sha256 !== n.sha256 || e.size !== n.size || e.contentType !== n.contentType)) return !1;
+			let a = C(t, "assets", n.sha256);
+			await e(a, "file");
+			try {
+				await g(a);
+			} catch (e) {
+				if (typeof e == "object" && e && "code" in e && e.code === "ENOENT") return !1;
+				throw e;
+			}
+			return u.runPromise(u.scoped(c({
+				entries: [n],
+				assetsDir: C(t, "assets"),
+				sink: {
+					has: () => u.succeed(!1),
+					matches: () => u.succeed(!1),
+					write: () => u.void
+				}
+			}).pipe(u.as(!0), u.catchTag("IntegrityError", () => u.succeed(!1)))));
+		},
+		write: async (r, i, a) => {
+			let o = await import("node:fs/promises"), { pipeline: s } = await import("node:stream/promises"), { Transform: c } = await import("node:stream"), d = C(t, "assets");
+			await e(d, "directory"), await _(d, { recursive: !0 });
+			let m = p("sha256"), g = 0, y = new c({ transform(e, t, n) {
+				m.update(e), g += e.length, n(null, e);
+			} });
+			await e(d, "directory"), await e(C(d, "index.ndjson"), "file");
+			let S = await v(C(d, ".voltro-blob-"));
+			try {
+				let t = C(S, "body");
+				if (await s(i, y, h(t, {
+					flags: "wx",
+					mode: 384
+				})), g !== a.size) throw Error("blob body size does not match its metadata");
+				let n = m.digest("hex"), c = C(d, n);
+				await e(c, "file"), await e(C(d, "index.ndjson"), "file"), await o.rename(t, c);
+				let p = C(d, "index.ndjson"), _ = (await x(p).then(() => !0, () => !1) ? Array.from(await u.runPromise(f.runCollect(l(p)))) : []).filter((e) => O(e) !== O(r));
+				_.push({
+					...r,
+					sha256: n,
+					size: g,
+					contentType: a.contentType
+				});
+				let v = C(S, "index");
+				await o.writeFile(v, _.map((e) => JSON.stringify(e)).join("\n") + "\n", {
+					flag: "wx",
+					mode: 384
+				}), await e(p, "file"), await o.rename(v, p);
+			} finally {
+				await b(S, {
+					recursive: !0,
+					force: !0
+				});
+			}
+			n.add(O(r));
+		}
+	};
+};
+//#endregion
+export { W as dirBlobSink, L as packBundle, H as peekBundle, B as unpackBundle, U 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/bundlePaths.js

@@ -0,0 +1,4 @@
+//#region src/bundlePaths.ts
+var e = (e) => e.length > 0 && !e.includes("\0") && !e.includes("\\") && !e.startsWith("/") && !/^[a-z]:/i.test(e) && !e.split("/").some((e) => e === "" || e === "." || e === "..");
+//#endregion
+export { e as isSafeBundlePath };