@voltro/data-transfer 0.86.0 → 0.87.0

package/dist/bundleArchive.js

@@ -1,14 +1,22 @@
-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";
+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 d = Buffer.from("VBUNDLE2"), f = 0, p = 1, m = 2, h = 32, g = async (e) => {
+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 a(c(e, r), { withFileTypes: !0 });
+			i = await y(C(e, r), { withFileTypes: !0 });
 		} catch {
 			return;
 		}
@@ -18,93 +26,166 @@ var d = Buffer.from("VBUNDLE2"), f = 0, p = 1, m = 2, h = 32, g = async (e) => {
 		}
 	};
 	return await n(""), t.sort();
-}, _ = (e, t) => {
+}, F = (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;
+	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* 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);
+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 (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 (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 !== t.size) throw Error(`blob '${t.key}' size mismatch: header ${t.size}, streamed ${i}`);
-		yield new Uint8Array(r.digest());
+		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([f]));
+	yield new Uint8Array(Buffer.from([A]));
 }
-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;
+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 y(d.length), !S(d.length).equals(d)) throw Error("not a bundle archive (bad magic)");
+		if (await f(k.length), !m(k.length).equals(k)) 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 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();
 				}
-				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);
+			} 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);
 				}
-				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}`);
+			} else throw Error(`unknown bundle entry kind ${e}`);
 		}
 	} finally {
-		_ || await Promise.resolve(g.return?.()).catch(() => void 0);
+		s || await Promise.resolve(o.return?.()).catch(() => void 0);
 	}
-}, C = async (e, t) => {
+}, 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);
@@ -123,11 +204,11 @@ var b = (e, t) => new Promise((n, r) => e.write(t, (e) => e ? r(e) : n())), x =
 		}
 		return Buffer.concat(t);
 	};
-	if (!await s(d.length) || !c(d.length).equals(d)) throw Error("not a bundle archive (bad magic)");
+	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 === f || e === m) break;
-		if (e !== p) throw Error(`unknown bundle entry kind ${e}`);
+		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;
@@ -137,29 +218,93 @@ var b = (e, t) => new Promise((n, r) => e.write(t, (e) => e ? r(e) : n())), x =
 		if (a === null || n.has(i) && (r.set(i, a), n.delete(i), n.size === 0)) break;
 	}
 	return r;
-}, w = (e, t) => S(e, {
+}, U = (e, t) => B(e, {
 	dir: t,
-	blobs: T(t)
-}), T = (t) => {
-	let r = /* @__PURE__ */ new Set();
+	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 (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);
+		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 { T as dirBlobSink, y as packBundle, C as peekBundle, S as unpackBundle, w as unpackBundleToDir };
+export { W as dirBlobSink, L as packBundle, H as peekBundle, B as unpackBundle, U as unpackBundleToDir };

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 };

package/dist/casAssetPhase.js

@@ -1,43 +1,87 @@
 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";
+import { admitFilesystemPath as t } from "./filesystemAdmission.js";
+import { assertPreparedAssets as n, decodeAssetEntry as r, decodeAssetSourceInfo as i, prepareAssetEntries as a } from "./assetAdmission.js";
+import { applyAdmittedAsset as o, writeAssetToCas as s } from "./assets.js";
+import { Effect as c, Stream as l } from "effect";
+import { constants as u } from "node:fs";
+import { open as d } from "node:fs/promises";
+import { fromNodeReadable as f } from "@voltro/plugin-storage";
+import { storageAddressIdentity as p } from "@voltro/plugin-storage/errors";
 //#region src/casAssetPhase.ts
-var s = {
+var m = {
 	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,
+	mark: () => c.void
+}, h = (e) => typeof e == "object" && !!e && e.status === 404, g = (t) => c.gen(function* () {
+	let n = t.progress ?? m, r = 0, a = 0, o = 0, u = 0, d = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Map(), g = [], _ = (t) => {
+		o++;
+		let r = p(t), i = f.get(r);
+		return i === void 0 ? (f.set(r, t), n.done(r) ? c.logDebug("Revalidating previously recorded source asset").pipe(c.andThen(v(t, r))) : v(t, r)) : i.size !== t.size || i.contentType !== t.contentType || i.sha256 !== void 0 && t.sha256 !== void 0 && i.sha256 !== t.sha256 ? c.fail(new e({ reason: "duplicate asset address has contradictory source metadata" })) : i.sha256 === void 0 && t.sha256 !== void 0 ? v(t, r) : c.void;
+	}, v = (i, o) => t.source.open(i).pipe(c.map((e) => e), c.catchIf(h, () => c.sync(() => {
+		g.push(o);
+	})), c.flatMap((l) => l === void 0 ? c.void : s(l, t.assetsDir).pipe(c.flatMap((t) => {
+		let s = {
+			destination: i.destination,
+			tenantId: i.tenantId,
+			key: i.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
+		return t.size !== i.size || t.contentType !== i.contentType || i.sha256 !== void 0 && t.sha256 !== i.sha256 ? c.fail(new e({ reason: "asset bytes contradict their source metadata" })) : (f.set(o, {
+			...i,
+			sha256: t.sha256
+		}), r++, a += t.size, d.has(t.sha256) || (d.add(t.sha256), u += t.size), n.mark(o, s));
+	}))));
+	return yield* l.runForEach(t.source.list().pipe(l.mapEffect(i)), _).pipe(c.mapError((t) => t instanceof e ? t : new e({ reason: `asset export failed: ${String(t)}` }))), {
+		count: r,
+		totalBytes: a,
+		references: o,
+		objects: d.size,
+		objectBytes: u,
+		missing: g
 	};
-}), 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
+}), _ = (n) => l.unwrap(c.gen(function* () {
+	let r = yield* c.acquireRelease(c.tryPromise({
+		try: async () => {
+			await t(n, "file");
+			let e = await d(n, u.O_RDONLY | u.O_NOFOLLOW | u.O_NONBLOCK);
+			try {
+				if (!(await e.stat()).isFile()) throw Error("asset index must be a regular file");
+				return e;
+			} catch (t) {
+				throw await e.close(), t;
+			}
+		},
+		catch: () => new e({
+			reason: "asset index could not be admitted",
+			path: n
+		})
+	}), (e) => c.promise(() => e.close()));
+	return f("bundle", () => r.createReadStream({ autoClose: !1 }));
+})).pipe(l.decodeText(), l.splitLines, l.filter((e) => e.trim().length > 0), l.mapEffect((t) => c.try({
+	try: () => JSON.parse(t),
+	catch: () => new e({
+		reason: "asset index contains invalid JSON",
+		path: n
+	})
+}).pipe(c.flatMap(r))), l.mapError((t) => t instanceof e ? t : new e({
+	reason: `asset index unreadable: ${String(t)}`,
+	path: n
+}))), v = (e) => c.scoped(c.gen(function* () {
+	let t = e.prepared ?? (yield* y(e));
+	yield* n(t, e.sink);
+	let r = e.progress ?? m, i = 0, a = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+	for (let n of t.entries) {
+		let l = p(n);
+		s.has(l) || (s.add(l), r.done(l) && (yield* c.logDebug("Revalidating previously recorded destination asset")), (yield* e.sink.matches(n)) || (yield* o(e.sink, t, n), i++, a.add(n.sha256)), yield* r.mark(l, n));
+	}
+	return {
+		count: i,
+		objects: a.size
 	};
-});
+})), y = (e) => l.runCollect(_(e.indexPath)).pipe(c.flatMap((t) => a({
+	...e,
+	entries: Array.from(t)
+})));
 //#endregion
-export { l as captureAssetsToCas, s as noAssetProgress, u as readAssetIndex, d as restoreAssetsFromCas };
+export { g as captureAssetsToCas, m as noAssetProgress, y as prepareAssetsFromCas, _ as readAssetIndex, v as restoreAssetsFromCas };

package/dist/compress.js

@@ -1,6 +1,6 @@
-import * as e from "node:zlib";
-import { PassThrough as t } from "node:stream";
+import { PassThrough as e } from "node:stream";
+import * as t from "node:zlib";
 //#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();
+var n = () => typeof t.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" ? t.createZstdCompress() : n === "gzip" ? t.createGzip() : new e(), o = (n) => n === "zstd" ? t.createZstdDecompress() : n === "gzip" ? t.createGunzip() : new e();
 //#endregion
 export { i as compressionExt, n as hasZstd, a as makeCompressor, o as makeDecompressor, r as pickCompression };