@voltro/plugin-storage 0.86.0 → 0.87.0

package/dist/sourceIdentity.js

@@ -0,0 +1,14 @@
+import { createHash as e } from "node:crypto";
+import { canonicalJson as t } from "@voltro/protocol";
+//#region src/sourceIdentity.ts
+var n = (n) => e("sha256").update(t({
+	id: n.id,
+	tenantId: n.tenantId,
+	bucket: n.bucket,
+	key: n.key,
+	contentType: n.contentType,
+	size: n.size,
+	checksum: n.checksum
+})).digest("hex");
+//#endregion
+export { n as retainedSourceDigest };

package/dist/sourcePin.js

@@ -0,0 +1,35 @@
+import { StorageError as e } from "./types.js";
+import { retainedSourceDigest as t } from "./sourceIdentity.js";
+import { ownRenditionRef as n } from "./renditionProof.js";
+import { createHash as r } from "node:crypto";
+import { canonicalJson as i } from "@voltro/protocol";
+//#region src/sourcePin.ts
+var a = (e) => r("sha256").update(i(e)).digest("hex"), o = (e, t) => typeof e == "string" && e.length > 0 && e.length <= t, s = (e, t) => e == null || typeof e == "string" && e.length <= t, c = (r, i) => {
+	let c = n(r);
+	if (!o(i, 256) || !o(c.id, 64) || !o(c.bucket, 128) || c.tenantId !== null && !o(c.tenantId, 64) || !o(c.checksum, 512) || !o(c.contentType, 512) || !Number.isSafeInteger(c.size) || c.size < 0 || !s(c.derivedFrom, 64) || !s(c.kind, 512)) throw new e({
+		provider: "custody",
+		message: "Invalid custody source metadata",
+		status: 409,
+		transient: !1
+	});
+	let l = {
+		version: 1,
+		instance: i,
+		tenantId: c.tenantId,
+		bucket: c.bucket,
+		id: c.id,
+		sourceDigest: t(c),
+		checksum: c.checksum,
+		size: c.size,
+		contentType: c.contentType,
+		derivedFrom: c.derivedFrom ?? null,
+		kind: c.kind ?? null,
+		renditionProof: c.renditionProof ?? null
+	};
+	return {
+		...l,
+		digest: a(l)
+	};
+};
+//#endregion
+export { c as pinStorageSource };

package/dist/storageNamespaces.js

@@ -1,51 +1,75 @@
-import { createHash as e, randomUUID as t } from "node:crypto";
-import { authoredError as n } from "@voltro/database";
-import { linkSync as r, mkdirSync as i, readFileSync as a, realpathSync as o, rmSync as s, writeFileSync as c } from "node:fs";
-import { basename as l, dirname as u, join as d, resolve as f } from "node:path";
+import { StorageError as e } from "@voltro/kv/storage";
+import { Effect as t } from "effect";
+import { createHash as n, randomUUID as r } from "node:crypto";
+import { authoredError as i } from "@voltro/database";
+import { linkSync as a, mkdirSync as o, readFileSync as s, realpathSync as c, rmSync as l, writeFileSync as u } from "node:fs";
+import { basename as d, dirname as f, join as p, resolve as m } from "node:path";
 //#region src/storageNamespaces.ts
-var p = (t) => e("sha256").update(JSON.stringify(t)).digest("hex"), m = (e) => {
-	if (!e?.storageInstance?.trim() || !/^[a-f0-9]{64}$/.test(e.objectNamespace)) throw n("Storage requires a configured instance and a stable physical objectNamespace SHA-256 identity");
-}, h = (e) => {
-	let t = f(e), n = [];
+var h = (e) => n("sha256").update(JSON.stringify(e)).digest("hex"), g = (n, r) => ("resolveNamespace" in n ? n.resolveNamespace(r) : t.succeed(n.objectNamespace)).pipe(t.flatMap((r) => t.try({
+	try: () => {
+		let e = {
+			storageInstance: n.storageInstance,
+			objectNamespace: r
+		};
+		return _(e), e;
+	},
+	catch: () => new e({
+		provider: "metadata",
+		message: "Storage reference scope is invalid",
+		transient: !1
+	})
+}))), _ = (e) => {
+	if (!e?.storageInstance?.trim() || !/^[a-f0-9]{64}$/.test(e.objectNamespace)) throw i("Storage requires a configured instance and a stable physical objectNamespace SHA-256 identity");
+}, v = (e) => {
+	let t = m(e), n = [];
 	for (;;) try {
-		return d(o(t), ...n.reverse());
+		return p(c(t), ...n.reverse());
 	} catch (e) {
 		if (!(e instanceof Error && "code" in e && e.code === "ENOENT")) throw e;
-		let r = u(t);
+		let r = f(t);
 		if (r === t) throw e;
-		n.push(l(t)), t = r;
+		n.push(d(t)), t = r;
 	}
-}, g = (e) => {
+}, y = (e) => {
 	let t = new URL(e);
 	return t.username = "", t.password = "", t.search = "", t.hash = "", t.href.replace(/\/+$/, "");
-}, _ = ".voltro-object-namespace", v = (e) => {
-	i(e, { recursive: !0 });
-	let o = d(e, _), l;
+}, b = ".voltro-object-namespace", x = (e) => {
+	o(e, { recursive: !0 });
+	let t = p(e, b), n;
 	try {
-		l = a(o, "utf8");
+		n = s(t, "utf8");
 	} catch (e) {
 		if (!(e instanceof Error && "code" in e && e.code === "ENOENT")) throw e;
-		let n = p(["filesystem-volume", t()]), i = `${o}-${t()}`;
+		let i = h(["filesystem-volume", r()]), o = `${t}-${r()}`;
 		try {
-			c(i, n, {
+			u(o, i, {
 				flag: "wx",
 				mode: 384
 			});
 			try {
-				r(i, o);
+				a(o, t);
 			} catch (e) {
 				if (!(e instanceof Error && "code" in e && e.code === "EEXIST")) throw e;
 			}
-			l = a(o, "utf8");
+			n = s(t, "utf8");
 		} finally {
-			s(i, { force: !0 });
+			l(o, { force: !0 });
 		}
 	}
-	if (!/^[a-f0-9]{64}$/.test(l)) throw n("Filesystem storage object namespace marker is invalid; restore the volume marker before serving storage");
-	return l;
-}, y = (e) => {
-	if (m(e), typeof e.catalogueId != "string" || !e.catalogueId.trim()) throw n("Storage upload tickets require an actual reference catalogue identity");
-	return p([
+	if (!/^[a-f0-9]{64}$/.test(n)) throw i("Filesystem storage object namespace marker is invalid; restore the volume marker before serving storage");
+	return n;
+}, S = (e) => {
+	let t;
+	try {
+		t = s(p(e, b), "utf8");
+	} catch (t) {
+		throw t instanceof Error && "code" in t && t.code === "ENOENT" ? i(`Filesystem storage volume at ${e} carries no ${b} marker; mount the volume the serving replicas use before assigning namespaces`) : t;
+	}
+	if (!/^[a-f0-9]{64}$/.test(t)) throw i("Filesystem storage object namespace marker is invalid; restore the volume marker before serving storage");
+	return t;
+}, C = (e) => {
+	if (_(e), typeof e.catalogueId != "string" || !e.catalogueId.trim()) throw i("Storage upload tickets require an actual reference catalogue identity");
+	return h([
 		"upload-ticket-destination",
 		e.storageInstance,
 		e.catalogueId,
@@ -53,4 +77,4 @@ var p = (t) => e("sha256").update(JSON.stringify(t)).digest("hex"), m = (e) => {
 	]);
 };
 //#endregion
-export { _ as FILESYSTEM_NAMESPACE_FILE, h as canonicalStorageRoot, v as filesystemObjectNamespace, m as requireStorageReferenceScope, g as storageEndpointIdentity, p as storageObjectNamespace, y as storageUploadTicketScope };
+export { b as FILESYSTEM_NAMESPACE_FILE, v as canonicalStorageRoot, S as existingFilesystemObjectNamespace, x as filesystemObjectNamespace, _ as requireStorageReferenceScope, y as storageEndpointIdentity, h as storageObjectNamespace, g as storageReferenceScopeFor, C as storageUploadTicketScope };

package/dist/storageObjectNamespaces.js

@@ -2,37 +2,37 @@ import { requireStorageReferenceScope as e } from "./storageNamespaces.js";
 import { STORAGE_GRANTS_TABLE as t, STORAGE_REFS_TABLE as n } from "./table.js";
 import { storageInteger as r, storageIntegerSum as i } from "./storageNumbers.js";
 import { storageObjectClaimId as a, storageObjectIdentifiers as o } from "./objectLifecycle.js";
-import { createHash as s } from "node:crypto";
-import { authoredError as c, isNull as l, or as u } from "@voltro/database";
-import { Schema as d } from "effect";
+import { Schema as s } from "effect";
+import { createHash as c } from "node:crypto";
+import { authoredError as l, inSet as u, isNull as d, or as f } from "@voltro/database";
 //#region src/storageObjectNamespaces.ts
-var f = "_voltro_storage_put_intents", p = "_voltro_storage_operations", m = "_voltro_storage_object_heads", h = "_voltro_storage_object_claims", g = [
+var p = "_voltro_storage_put_intents", m = "_voltro_storage_operations", h = "_voltro_storage_object_heads", g = "_voltro_storage_object_claims", _ = [
 	n,
 	t,
-	f,
-	p
-], _ = d.Struct({
-	tenantId: d.NullOr(d.String),
-	bucket: d.String,
-	operationId: d.String,
-	fingerprint: d.String,
-	checksum: d.String,
-	logicalKey: d.String
-}), v = d.Struct({
-	id: d.String,
-	objectId: d.String,
-	fingerprint: d.String,
-	generation: d.String,
-	key: d.String,
-	refId: d.String,
-	state: d.Literals([
+	p,
+	m
+], v = s.Struct({
+	tenantId: s.NullOr(s.String),
+	bucket: s.String,
+	operationId: s.String,
+	fingerprint: s.String,
+	checksum: s.String,
+	logicalKey: s.String
+}), y = s.Struct({
+	id: s.String,
+	objectId: s.String,
+	fingerprint: s.String,
+	generation: s.String,
+	key: s.String,
+	refId: s.String,
+	state: s.Literals([
 		"reserved",
 		"ready",
 		"deleting",
 		"deleted"
 	]),
-	deleteKey: d.NullOr(d.String)
-}), y = (e) => s("sha256").update(JSON.stringify(e)).digest("hex"), b = (e) => JSON.stringify([e.storageInstance, e.objectNamespace]), x = (e, t) => JSON.stringify([e.objectNamespace, t]), S = (e, t) => e.query({
+	deleteKey: s.NullOr(s.String)
+}), b = (e) => c("sha256").update(JSON.stringify(e)).digest("hex"), x = (e) => JSON.stringify([e.storageInstance, e.objectNamespace]), S = (e, t) => JSON.stringify([e.objectNamespace, t]), C = (e, t) => e.query({
 	table: t,
 	predicate: void 0,
 	lock: "update",
@@ -40,78 +40,108 @@ var f = "_voltro_storage_put_intents", p = "_voltro_storage_operations", m = "_v
 	take: void 0,
 	skip: void 0,
 	projection: void 0
-}), C = async (e) => {
-	for (let t of [...g, m]) if ((await e.query({
-		table: t,
-		predicate: t === m ? l("objectNamespace") : u(l("storageInstance"), l("objectNamespace")),
-		order: [],
-		take: 1,
-		skip: void 0,
-		projection: ["id"]
-	})).length) throw c("Storage physical namespace migration required: assign references and retained operations to their configured storageInstance and provider objectNamespace before starting the app");
-}, w = async (s, l, u) => {
-	for (let t of l) e(t);
-	if (!l.length || new Set(l.map(b)).size !== l.length) throw c("Provide distinct configured storage instance and physical namespace pairs");
-	let g = new Set(l.map(b)), w = /* @__PURE__ */ new Map();
-	for (let { refId: t, ...n } of u) {
-		if (e(n), !t.trim() || !g.has(b(n))) throw c("Storage namespace assignment must name a reference and a configured physical scope");
-		let r = w.get(t);
-		if (r && b(r) !== b(n)) throw c("Storage physical namespace assignment is ambiguous");
-		w.set(t, n);
+}), w = 500, T = (e) => {
+	let t = [];
+	for (let n = 0; n < e.length; n += w) t.push(e.slice(n, n + w));
+	return t;
+}, E = async (e) => {
+	let t = [];
+	for (let n of [..._, h]) {
+		let r = n === h ? d("objectNamespace") : f(d("storageInstance"), d("objectNamespace")), [i] = await e.query({
+			table: n,
+			predicate: r,
+			order: [],
+			take: void 0,
+			skip: void 0,
+			projection: void 0,
+			aggregations: [{
+				op: "count",
+				alias: "unassigned"
+			}]
+		}), a = Number(i?.unassigned ?? 0);
+		a > 0 && t.push(`${n}: ${a}`);
 	}
-	let T = [];
+	if (t.length > 0) throw l(`Storage physical namespace migration required: assign references and retained operations to their configured storageInstance and provider objectNamespace before starting the app (unassigned rows — ${t.join(", ")}). Rows written after an assignment already ran — by a replica of the previous version — need the assignment again: a recorded file migration does not re-run, so repeat the idempotent assignment over every reference in a new migration.`);
+}, D = async (e, t, n) => k(e, t, n), O = async (t, n, r) => {
+	let i = /* @__PURE__ */ new Map();
+	for (let t of r) {
+		if (e(t.from), t.from.storageInstance !== t.storageInstance) throw l("Storage snapshot relocation must preserve the configured plugin instance");
+		let n = i.get(t.refId);
+		if (n && x(n) !== x(t.from)) throw l("Storage snapshot source scope is ambiguous");
+		i.set(t.refId, t.from);
+	}
+	return k(t, n, r.map(({ from: e, ...t }) => t), i);
+}, k = async (c, d, f, _) => {
+	for (let t of d) e(t);
+	if (!d.length || new Set(d.map(x)).size !== d.length) throw l("Provide distinct configured storage instance and physical namespace pairs");
+	let w = new Set(d.map(x)), D = /* @__PURE__ */ new Map();
+	for (let { refId: t, ...n } of f) {
+		if (e(n), !t.trim() || !w.has(x(n))) throw l("Storage namespace assignment must name a reference and a configured physical scope");
+		let r = D.get(t);
+		if (r && x(r) !== x(n)) throw l("Storage physical namespace assignment is ambiguous");
+		D.set(t, n);
+	}
+	let O = [];
 	for (let e of [
 		n,
 		t,
-		f,
 		p,
 		m,
-		h
-	]) T.push(await S(s, e));
-	let [E, D, O, k, A, j] = T, M = /* @__PURE__ */ new Set(), N = (e, t) => {
-		let n = w.get(e);
-		if (!n) throw c("Storage physical namespace assignment is incomplete");
-		for (let e of ["storageInstance", "objectNamespace"]) if (t[e] != null && t[e] !== n[e]) throw c("Storage metadata already belongs to another physical scope; assignment does not move objects");
-		return M.add(e), n;
+		h,
+		g
+	]) O.push(await C(c, e));
+	let [k, A, j, M, N, P] = O, F = /* @__PURE__ */ new Set(), I = (e, t) => {
+		let n = D.get(e);
+		if (!n) throw l("Storage physical namespace assignment is incomplete");
+		if (_ !== void 0) {
+			let r = _.get(e);
+			if (r === void 0 || ![r, n].some((e) => t.storageInstance === e.storageInstance && t.objectNamespace === e.objectNamespace)) throw l("Storage snapshot metadata does not match its declared source or restored target scope");
+		} else for (let e of ["storageInstance", "objectNamespace"]) if (t[e] != null && t[e] !== n[e]) throw l("Storage metadata already belongs to another physical scope; assignment does not move objects");
+		return F.add(e), n;
 	};
-	for (let e of E) N(String(e.id), e);
-	for (let e of D) if (N(String(e.refId), e), !E.some((t) => t.id === e.refId)) throw c("Storage grant has no readable reference");
-	let P = /* @__PURE__ */ new Map();
-	for (let e of O) {
-		if (N(String(e.refId), e), P.has(String(e.id))) throw c("Storage put intent ownership is ambiguous");
-		P.set(String(e.id), e);
+	for (let e of k) I(String(e.id), e);
+	let L = new Map(k.map((e) => [e.id, e]));
+	for (let e of A) if (I(String(e.refId), e), !L.has(e.refId)) throw l("Storage grant has no readable reference");
+	let R = /* @__PURE__ */ new Map();
+	for (let e of j) {
+		if (I(String(e.refId), e), R.has(String(e.id))) throw l("Storage put intent ownership is ambiguous");
+		R.set(String(e.id), e);
 	}
-	let F = /* @__PURE__ */ new Map(), I = k.map((e) => {
-		let t = d.decodeUnknownSync(v)(e), n = N(t.refId, e), a = P.get(t.id);
-		if (!a || a.refId !== t.refId) throw c("Storage operation lost its retained put intent");
-		let s = {
-			...d.decodeUnknownSync(_)(a.identity),
+	let z = /* @__PURE__ */ new Map(), B = M.map((e) => {
+		let t = s.decodeUnknownSync(y)(e), n = I(t.refId, e), a = R.get(t.id);
+		if (!a || a.refId !== t.refId) throw l("Storage operation lost its retained put intent");
+		let c = {
+			...s.decodeUnknownSync(v)(a.identity),
 			...n
 		};
-		typeof a.identity == "object" && a.identity !== null && N(t.refId, a.identity);
-		let l = o(s), u = y([
-			s.bucket,
-			s.tenantId,
-			s.operationId
-		]), f = y([
-			s.bucket,
-			s.tenantId,
-			s.logicalKey,
-			s.checksum
-		]);
-		if (![u, l.id].includes(t.id) || ![f, l.objectId].includes(t.objectId) || t.fingerprint !== s.fingerprint) throw c("Storage operation identity does not match its retained intent");
-		if (typeof a.ref != "object" || a.ref === null || Array.isArray(a.ref)) throw c("Storage put intent reference is unreadable");
-		let p = a.ref;
-		if (p.id !== t.refId || p.key !== t.key || p.checksum !== s.checksum || p.tenantId !== s.tenantId || p.bucket !== s.bucket) throw c("Storage operation reference does not match its retained intent");
-		let m = E.find((e) => e.id === t.refId);
+		typeof a.identity == "object" && a.identity !== null && I(t.refId, a.identity);
+		let u = o(c), d = b([
+			c.bucket,
+			c.tenantId,
+			c.operationId
+		]), f = b([
+			c.bucket,
+			c.tenantId,
+			c.logicalKey,
+			c.checksum
+		]), p = _ === void 0 ? void 0 : o({
+			...c,
+			storageInstance: String(e.storageInstance),
+			objectNamespace: String(e.objectNamespace)
+		});
+		if (!(p === void 0 ? [d, u.id].includes(t.id) && [f, u.objectId].includes(t.objectId) : t.id === p.id && t.objectId === p.objectId) || t.fingerprint !== c.fingerprint) throw l("Storage operation identity does not match its retained intent");
+		if (typeof a.ref != "object" || a.ref === null || Array.isArray(a.ref)) throw l("Storage put intent reference is unreadable");
+		let m = a.ref;
+		if (m.id !== t.refId || m.key !== t.key || m.checksum !== c.checksum || m.tenantId !== c.tenantId || m.bucket !== c.bucket) throw l("Storage operation reference does not match its retained intent");
+		let h = L.get(t.refId);
 		if (t.state === "ready") {
-			if (!m || m.key !== t.key || m.checksum !== s.checksum) throw c("Ready storage operation lost its readable reference");
-		} else if (m) throw c("Unreadable storage operation still owns a readable reference");
+			if (!h || h.key !== t.key || h.checksum !== c.checksum) throw l("Ready storage operation lost its readable reference");
+		} else if (h) throw l("Unreadable storage operation still owns a readable reference");
 		if (t.state === "ready" || t.state === "reserved") {
-			let e = F.get(l.objectId);
-			if (e && (e.generation !== t.generation || e.key !== t.key)) throw c("Storage physical namespace has conflicting active generations");
-			F.set(l.objectId, {
-				id: l.objectId,
+			let e = z.get(u.objectId);
+			if (e && (e.generation !== t.generation || e.key !== t.key)) throw l("Storage physical namespace has conflicting active generations");
+			z.set(u.objectId, {
+				id: u.objectId,
 				objectNamespace: n.objectNamespace,
 				generation: t.generation,
 				key: t.key,
@@ -120,75 +150,94 @@ var f = "_voltro_storage_put_intents", p = "_voltro_storage_operations", m = "_v
 		}
 		return {
 			previous: t,
+			previousNamespace: e.objectNamespace,
 			row: {
 				...t,
 				...n,
-				id: l.id,
-				objectId: l.objectId
+				id: u.id,
+				objectId: u.objectId
 			},
 			intent: a,
-			identity: s
+			identity: c
 		};
 	});
-	if (I.length !== O.length || new Set(I.map((e) => e.row.id)).size !== I.length) throw c("Storage operation namespace migration has unmatched or conflicting identities");
-	for (let e of A) {
-		let t = I.filter(({ previous: t }) => t.objectId === e.id && (t.state === "ready" || t.state === "reserved"));
-		if (!t.length || t.length !== r(e.reservations, "shared-object reservation count") || t.some(({ previous: t, identity: n }) => t.generation !== e.generation || t.key !== e.key || e.objectNamespace != null && e.objectNamespace !== n.objectNamespace)) throw c("Storage object head does not match its active reservations");
+	if (B.length !== j.length || new Set(B.map((e) => e.row.id)).size !== B.length) throw l("Storage operation namespace migration has unmatched or conflicting identities");
+	let V = /* @__PURE__ */ new Map();
+	for (let e of B) (e.previous.state === "ready" || e.previous.state === "reserved") && V.set(e.previous.objectId, [...V.get(e.previous.objectId) ?? [], e]);
+	for (let e of N) {
+		let t = V.get(String(e.id)) ?? [];
+		if (!t.length || t.length !== r(e.reservations, "shared-object reservation count") || t.some(({ previous: t, previousNamespace: n, identity: r }) => t.generation !== e.generation || t.key !== e.key || e.objectNamespace != null && e.objectNamespace !== (_ === void 0 ? r.objectNamespace : n))) throw l("Storage object head does not match its active reservations");
 	}
-	for (let { previous: e } of I) if ((e.state === "ready" || e.state === "reserved") && !A.some((t) => t.id === e.objectId)) throw c("Storage operation lost its active object head");
-	if ([...w.keys()].some((e) => !M.has(e))) throw c("Storage namespace assignment target does not exist");
-	let L = new Map(I.map((e) => [e.previous.id, e])), R = j.map((e) => {
-		let t = L.get(String(e.operationId));
-		if (!t || typeof e.claim != "string" || !e.claim || e.id !== a(String(e.operationId), e.claim)) throw c("Storage operation claim does not match its retained operation");
+	let H = new Set(N.map((e) => e.id));
+	for (let { previous: e } of B) if ((e.state === "ready" || e.state === "reserved") && !H.has(e.objectId)) throw l("Storage operation lost its active object head");
+	if ([...D.keys()].some((e) => !F.has(e))) throw l("Storage namespace assignment target does not exist");
+	let U = new Map(B.map((e) => [e.previous.id, e])), W = P.map((e) => {
+		let t = U.get(String(e.operationId));
+		if (!t || typeof e.claim != "string" || !e.claim || e.id !== a(String(e.operationId), e.claim)) throw l("Storage operation claim does not match its retained operation");
 		return {
 			...e,
 			id: a(t.row.id, e.claim),
 			operationId: t.row.id
 		};
-	}), z = /* @__PURE__ */ new Set([...E.map((e) => x(w.get(String(e.id)), String(e.key))), ...[...F.values()].map((e) => JSON.stringify([e.objectNamespace, e.key]))]), B = [];
-	for (let e of I) {
-		let t = z.has(x(e.identity, e.row.key));
-		(e.row.state === "deleting" || e.row.state === "deleted") && (t ? e.row.deleteKey = null : e.row.state === "deleted" && e.row.deleteKey === null && (e.row.state = "deleting", e.row.deleteKey = e.row.key), e.row.state === "deleting" && e.row.deleteKey !== null && B.push({
+	}), G = /* @__PURE__ */ new Set([...k.map((e) => S(D.get(String(e.id)), String(e.key))), ...[...z.values()].map((e) => JSON.stringify([e.objectNamespace, e.key]))]), K = [];
+	for (let e of B) {
+		let t = G.has(S(e.identity, e.row.key));
+		(e.row.state === "deleting" || e.row.state === "deleted") && (t ? e.row.deleteKey = null : e.row.state === "deleted" && e.row.deleteKey === null && (e.row.state = "deleting", e.row.deleteKey = e.row.key), e.row.state === "deleting" && e.row.deleteKey !== null && K.push({
 			refId: e.row.refId,
 			storageInstance: e.identity.storageInstance,
 			objectNamespace: e.identity.objectNamespace
 		}));
 	}
-	let V = 0;
+	let q = 0;
 	for (let [e, r, i] of [[
 		n,
-		E,
+		k,
 		"id"
 	], [
 		t,
-		D,
+		A,
 		"refId"
-	]]) for (let t of r) {
-		let n = w.get(String(t[i]));
-		if (t.storageInstance !== n.storageInstance || t.objectNamespace !== n.objectNamespace) {
-			if (await s.update(e, String(t.id), { ...n }) === null) throw c("Storage physical namespace assignment lost its metadata row");
-			V++;
+	]]) {
+		let t = /* @__PURE__ */ new Map();
+		for (let e of r) {
+			let n = D.get(String(e[i]));
+			if (e.storageInstance === n.storageInstance && e.objectNamespace === n.objectNamespace) continue;
+			let r = t.get(x(n)) ?? {
+				scope: n,
+				ids: []
+			};
+			r.ids.push(String(e.id)), t.set(x(n), r);
+		}
+		for (let { scope: n, ids: r } of t.values()) for (let t of T(r)) {
+			let r = await c.updateMany(e, {
+				storageInstance: n.storageInstance,
+				objectNamespace: n.objectNamespace
+			}, { where: u("id", t) });
+			if (r !== t.length) throw l("Storage physical namespace assignment lost its metadata row");
+			q += r;
 		}
 	}
 	for (let [e, t] of [
-		[h, j],
-		[f, O],
-		[p, k],
-		[m, A]
-	]) for (let n of t) await s.delete(e, String(n.id));
-	for (let e of F.values()) await s.insert(m, e);
-	for (let e of I) await s.insert(p, e.row), await s.insert(f, {
+		[g, P],
+		[p, j],
+		[m, M],
+		[h, N]
+	]) for (let n of T(t.map((e) => String(e.id)))) if (await c.deleteMany(e, { where: u("id", n) }) !== n.length) throw l("Storage physical namespace assignment lost a retained row");
+	let J = async (e, t) => {
+		for (let n of T(t)) await c.insertMany(e, n, { returning: "none" });
+	};
+	await J(h, [...z.values()]), await J(m, B.map((e) => e.row)), await J(p, B.map((e) => ({
 		...e.intent,
 		id: e.row.id,
 		storageInstance: e.identity.storageInstance,
 		objectNamespace: e.identity.objectNamespace,
 		identity: e.identity
-	}), (e.previous.id !== e.row.id || e.intent.objectNamespace !== e.identity.objectNamespace || e.previous.state !== e.row.state || e.previous.deleteKey !== e.row.deleteKey) && V++;
-	for (let e of R) await s.insert(h, e);
-	return await C(s), {
-		assigned: V,
-		pendingDeletes: B
+	})));
+	for (let e of B) (e.previous.id !== e.row.id || e.intent.objectNamespace !== e.identity.objectNamespace || e.previous.state !== e.row.state || e.previous.deleteKey !== e.row.deleteKey) && q++;
+	return await J(g, W), await E(c), {
+		assigned: q,
+		pendingDeletes: K
 	};
 };
 //#endregion
-export { w as assignStorageObjectNamespacesInTransaction, C as requireStorageObjectNamespaces };
+export { D as assignStorageObjectNamespacesInTransaction, O as relocateRestoredStorageObjectNamespacesInTransaction, E as requireStorageObjectNamespaces };

package/dist/storageRequest.js

@@ -0,0 +1,10 @@
+import { Effect as e } from "effect";
+//#region src/storageRequest.ts
+var t = (t, n, r) => e.callback((i) => {
+	let a = new AbortController(), o = Promise.resolve().then(() => t(a.signal));
+	return o.then((t) => i(e.succeed(t)), (t) => i(e.fail(n(t)))), e.sync(() => {
+		a.abort();
+	}).pipe(e.andThen(e.promise(() => o.then((e) => ({ value: e }), () => void 0))), e.flatMap((t) => t !== void 0 && r !== void 0 ? r(t.value) : e.void));
+});
+//#endregion
+export { t as storageRequest };

package/dist/storageRouting.js

@@ -0,0 +1,46 @@
+import { StorageAddress as e, StorageError as t } from "@voltro/kv/storage";
+import { Effect as n, Schema as r } from "effect";
+//#region src/storageRouting.ts
+var i = () => new t({
+	provider: "storage",
+	message: "Storage destination is unknown, ambiguous or unavailable for this tenant",
+	transient: !1
+}), a = (e, t, r) => n.suspend(() => {
+	if (e === void 0 || !t.startsWith("storage:")) return n.fail(i());
+	let a = t;
+	return e.validate(a).pipe(n.mapError(() => i()), n.flatMap((t) => t.tenantScoped && r === null ? n.fail(i()) : e.storage(a, r === null ? void 0 : { tenantId: r }).pipe(n.mapError(() => i()))));
+}), o = (t) => {
+	let o = (e, r) => e.startsWith("storage:") ? a(t.registry(), e, r) : e === t.directDestination ? n.try({
+		try: t.directProvider,
+		catch: () => i()
+	}) : n.fail(i());
+	return {
+		select: (a) => n.suspend(() => {
+			let s = t.selected();
+			return r.decodeUnknownEffect(e)({
+				destination: s,
+				tenantId: a,
+				key: "selection"
+			}).pipe(n.mapError(() => i()), n.flatMap((e) => o(e.destination, e.tenantId)), n.map((e) => ({
+				destination: s,
+				provider: e
+			})));
+		}),
+		resolve: (t) => r.decodeUnknownEffect(e)(t).pipe(n.mapError(() => i()), n.flatMap((e) => o(e.destination, e.tenantId)))
+	};
+}, s = (t) => {
+	let o = t.flatMap((e) => e.capabilities?.storageDestinations === void 0 ? [] : [e.capabilities.storageDestinations]);
+	return {
+		select: (e) => o.length === 1 ? o[0].router.select(e) : n.fail(i()),
+		resolve: (t) => r.decodeUnknownEffect(e)(t).pipe(n.mapError(() => i()), n.flatMap((e) => {
+			if (e.destination.startsWith("storage:")) {
+				let t = new Set(o.map((e) => e.registry()).filter((e) => e !== void 0));
+				return t.size === 1 ? a([...t][0], e.destination, e.tenantId) : n.fail(i());
+			}
+			let t = o.filter((t) => t.directDestination === e.destination);
+			return t.length === 1 ? t[0].router.resolve(e) : n.fail(i());
+		}))
+	};
+};
+//#endregion
+export { s as appStorageRouter, o as makeStorageDestinationRouter };

package/dist/streamBridge.js

@@ -18,7 +18,10 @@ var r = 1 << 20, i = (t, n, r = !1) => new e({
 }, s = (e) => e.pipe(n.runCollect, t.map((e) => a(e))), c = (e, t) => n.suspend(() => n.fromAsyncIterable(t(), (t) => i(e, `read stream failed: ${String(t?.message ?? t)}`, !0))).pipe(n.map((e) => e instanceof Uint8Array ? e : new Uint8Array(e))), l = async (e) => {
 	let { Readable: t } = await import("node:stream");
 	return t.fromWeb(n.toReadableStream(e));
-}, u = (e, n) => e.getStream ? e.getStream(n) : e.get(n).pipe(t.map((e) => ({
+}, u = (e, r) => e.getStream ? e.getStream(r).pipe(t.map((e) => e.close === void 0 ? e : {
+	...e,
+	stream: e.stream.pipe(n.ensuring(e.close))
+})) : e.get(r).pipe(t.map((e) => ({
 	stream: o(e.bytes),
 	contentType: e.contentType,
 	size: e.bytes.byteLength

package/dist/table.js

@@ -24,6 +24,7 @@ var c = "_voltro_storage_refs", l = "_voltro_storage_grants", u = "_voltro_stora
 	caption: o().nullable(),
 	derivedFrom: o().nullable(),
 	kind: o().nullable(),
+	renditionProof: i().nullable(),
 	createdAt: s()
 }).index(["storageInstance"]).index(["objectNamespace"]).index(["key"]).index(["tenantId"]).index(["ownerId"]).index(["folder"]).index(["derivedFrom"]), p = a(l, {
 	id: n({ prefix: "sgrant" }),