@voltro/plugin-storage 0.85.0 → 0.86.0

package/dist/storageNamespaces.js

@@ -0,0 +1,56 @@
+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";
+//#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 = [];
+	for (;;) try {
+		return d(o(t), ...n.reverse());
+	} catch (e) {
+		if (!(e instanceof Error && "code" in e && e.code === "ENOENT")) throw e;
+		let r = u(t);
+		if (r === t) throw e;
+		n.push(l(t)), t = r;
+	}
+}, g = (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;
+	try {
+		l = a(o, "utf8");
+	} catch (e) {
+		if (!(e instanceof Error && "code" in e && e.code === "ENOENT")) throw e;
+		let n = p(["filesystem-volume", t()]), i = `${o}-${t()}`;
+		try {
+			c(i, n, {
+				flag: "wx",
+				mode: 384
+			});
+			try {
+				r(i, o);
+			} catch (e) {
+				if (!(e instanceof Error && "code" in e && e.code === "EEXIST")) throw e;
+			}
+			l = a(o, "utf8");
+		} finally {
+			s(i, { 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([
+		"upload-ticket-destination",
+		e.storageInstance,
+		e.catalogueId,
+		e.objectNamespace
+	]);
+};
+//#endregion
+export { _ as FILESYSTEM_NAMESPACE_FILE, h as canonicalStorageRoot, v as filesystemObjectNamespace, m as requireStorageReferenceScope, g as storageEndpointIdentity, p as storageObjectNamespace, y as storageUploadTicketScope };

package/dist/storageNumbers.js

@@ -0,0 +1,13 @@
+import { StorageError as e } from "./types.js";
+//#region src/storageNumbers.ts
+var t = (t, n) => {
+	let r = typeof t == "number" ? t : typeof t == "bigint" || typeof t == "string" && /^\d+$/.test(t) ? Number(t) : NaN;
+	if (!Number.isSafeInteger(r) || r < 0) throw new e({
+		provider: "metadata",
+		message: `Storage ${n} must be a non-negative safe integer at most Number.MAX_SAFE_INTEGER`,
+		transient: !1
+	});
+	return r;
+}, n = (e, n, r) => t(e + n, r);
+//#endregion
+export { t as storageInteger, n as storageIntegerSum };

package/dist/storageObjectNamespaces.js

@@ -0,0 +1,194 @@
+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";
+//#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 = [
+	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([
+		"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({
+	table: t,
+	predicate: void 0,
+	lock: "update",
+	order: [],
+	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);
+	}
+	let T = [];
+	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;
+	};
+	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);
+	}
+	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),
+			...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);
+		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 (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,
+				objectNamespace: n.objectNamespace,
+				generation: t.generation,
+				key: t.key,
+				reservations: String(i(e ? r(e.reservations, "shared-object reservation count") : 0, 1, "shared-object reservation count"))
+			});
+		}
+		return {
+			previous: t,
+			row: {
+				...t,
+				...n,
+				id: l.id,
+				objectId: l.objectId
+			},
+			intent: a,
+			identity: s
+		};
+	});
+	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");
+	}
+	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");
+		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({
+			refId: e.row.refId,
+			storageInstance: e.identity.storageInstance,
+			objectNamespace: e.identity.objectNamespace
+		}));
+	}
+	let V = 0;
+	for (let [e, r, i] of [[
+		n,
+		E,
+		"id"
+	], [
+		t,
+		D,
+		"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++;
+		}
+	}
+	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, {
+		...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
+	};
+};
+//#endregion
+export { w as assignStorageObjectNamespacesInTransaction, C as requireStorageObjectNamespaces };

package/dist/storageReferenceInstances.js

@@ -0,0 +1,52 @@
+import { STORAGE_GRANTS_TABLE as e, STORAGE_REFS_TABLE as t } from "./table.js";
+import { authoredError as n, eq as r, isNull as i } from "@voltro/database";
+//#region src/storageReferenceInstances.ts
+var a = "@voltro/plugin-storage", o = [
+	t,
+	e,
+	"_voltro_storage_put_intents"
+], s = async (e) => {
+	for (let t of o) if ((await e.query({
+		table: t,
+		predicate: i("storageInstance"),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	})).length) throw n("Storage reference ownership migration required: assign existing references, grants and put intents to their configured storageInstance before starting the app");
+}, c = async (e, t, i) => {
+	if (t.length === 0 || t.some((e) => !e.trim()) || new Set(t).size !== t.length) throw n("Provide distinct configured storage instance names");
+	let a = new Set(t), s = /* @__PURE__ */ new Map();
+	for (let e of i) {
+		if (!e.refId.trim() || !a.has(e.storageInstance)) throw n("Storage reference assignment must name a reference and a configured instance");
+		let t = s.get(e.refId);
+		if (t !== void 0 && t !== e.storageInstance) throw n("Storage reference assignment is ambiguous");
+		s.set(e.refId, e.storageInstance);
+	}
+	let c = e, l = 0;
+	for (let [e, t] of s) {
+		let i = !1;
+		for (let a of o) {
+			let o = await c.query({
+				table: a,
+				predicate: r(a === "_voltro_storage_refs" ? "id" : "refId", e),
+				lock: "update",
+				order: [],
+				take: void 0,
+				skip: void 0,
+				projection: void 0
+			});
+			for (let e of o) {
+				if (i = !0, e.storageInstance !== null && e.storageInstance !== void 0 && e.storageInstance !== t) throw n("Storage reference already belongs to another instance; assignment does not move objects");
+				if (e.storageInstance !== t) {
+					if (await c.update(a, String(e.id), { storageInstance: t }) === null) throw n("Storage reference assignment lost its metadata row");
+					l++;
+				}
+			}
+		}
+		if (!i) throw n("Storage reference assignment target does not exist");
+	}
+	return { assigned: l };
+};
+//#endregion
+export { a as DEFAULT_STORAGE_INSTANCE, c as assignStorageReferenceInstancesInTransaction, s as requireStorageReferenceOwnership };

package/dist/streamBridge.js

@@ -0,0 +1,30 @@
+import { StorageError as e } from "./types.js";
+import { Effect as t, Stream as n } from "effect";
+//#region src/streamBridge.ts
+var r = 1 << 20, i = (t, n, r = !1) => new e({
+	provider: t,
+	message: n,
+	transient: r
+}), a = (e) => {
+	let t = 0;
+	for (let n of e) t += n.byteLength;
+	let n = new Uint8Array(t), r = 0;
+	for (let t of e) n.set(t, r), r += t.byteLength;
+	return n;
+}, o = (e, t = r) => {
+	let i = [];
+	for (let n = 0; n < e.byteLength; n += t) i.push(e.subarray(n, Math.min(n + t, e.byteLength)));
+	return n.fromIterable(i);
+}, 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) => ({
+	stream: o(e.bytes),
+	contentType: e.contentType,
+	size: e.bytes.byteLength
+}))), d = (e, n, r, i) => e.putStream ? e.putStream(n, r, i) : s(r).pipe(t.flatMap((t) => e.put(n, t, {
+	contentType: i.contentType,
+	...i.public === void 0 ? {} : { public: i.public }
+})));
+//#endregion
+export { o as bytesToStream, s as collectStream, a as concatBytes, c as fromNodeReadable, u as getObjectStream, d as putObjectStream, l as toNodeReadable };

package/dist/table.js

@@ -0,0 +1,53 @@
+import { bigint as e, bytes as t, id as n, integer as r, json as i, table as a, text as o, timestamp as s } from "@voltro/database";
+//#region src/table.ts
+var c = "_voltro_storage_refs", l = "_voltro_storage_grants", u = "_voltro_storage_blobs", d = "_voltro_storage_usage", f = a(c, {
+	id: n({ prefix: "file" }),
+	storageInstance: o().nullable(),
+	objectNamespace: o().maxLength(64).nullable(),
+	tenantId: o().nullable(),
+	ownerId: o().nullable(),
+	bucket: o(),
+	key: o(),
+	contentType: o(),
+	size: e(),
+	checksum: o(),
+	visibility: o(),
+	accessPolicy: i().nullable(),
+	passwordHash: o().nullable(),
+	width: r().nullable(),
+	height: r().nullable(),
+	duration: r().nullable(),
+	placeholder: o().nullable(),
+	folder: o().nullable(),
+	tags: i().nullable(),
+	alt: o().nullable(),
+	caption: o().nullable(),
+	derivedFrom: o().nullable(),
+	kind: o().nullable(),
+	createdAt: s()
+}).index(["storageInstance"]).index(["objectNamespace"]).index(["key"]).index(["tenantId"]).index(["ownerId"]).index(["folder"]).index(["derivedFrom"]), p = a(l, {
+	id: n({ prefix: "sgrant" }),
+	storageInstance: o().nullable(),
+	objectNamespace: o().maxLength(64).nullable(),
+	refId: o(),
+	principalType: o(),
+	principalId: o(),
+	permission: o(),
+	createdAt: s(),
+	expiresAt: s().nullable(),
+	createdBy: o().nullable()
+}).index(["storageInstance"]).index(["objectNamespace"]).index(["refId"]).index(["principalId"]), m = a(d, {
+	id: n({ prefix: "susage" }),
+	tenantId: o().maxLength(191),
+	bytes: e().default("0"),
+	count: e().default("0"),
+	updatedAt: s()
+}).unique("byStorageUsageTenant", ["tenantId"]), h = a(u, {
+	id: n({ prefix: "blob" }),
+	key: o(),
+	data: t(),
+	contentType: o(),
+	size: e()
+}).index(["key"]);
+//#endregion
+export { u as STORAGE_BLOBS_TABLE, l as STORAGE_GRANTS_TABLE, c as STORAGE_REFS_TABLE, d as STORAGE_USAGE_TABLE, h as _voltroStorageBlobsTable, p as _voltroStorageGrantsTable, f as _voltroStorageRefsTable, m as _voltroStorageUsageTable };

package/dist/transcodeVideo.js

@@ -0,0 +1,53 @@
+import { join as e } from "node:path";
+import { spawn as t } from "node:child_process";
+import { mkdtemp as n, readFile as r, rm as i, writeFile as a } from "node:fs/promises";
+import { tmpdir as o } from "node:os";
+//#region src/transcodeVideo.ts
+var s = (e, n, r) => new Promise((i, a) => {
+	let o = t(e, [...n], { stdio: [
+		"ignore",
+		"ignore",
+		"pipe"
+	] }), s = "", c = setTimeout(() => {
+		o.kill("SIGKILL"), a(/* @__PURE__ */ Error("ffmpeg timed out"));
+	}, r);
+	o.stderr?.on("data", (e) => {
+		s += String(e);
+	}), o.on("error", (e) => {
+		clearTimeout(c), a(e);
+	}), o.on("close", (e) => {
+		clearTimeout(c), e === 0 ? i() : a(/* @__PURE__ */ Error(`ffmpeg exited ${String(e)}: ${s.slice(-400)}`));
+	});
+}), c = (t) => async ({ bytes: c }) => {
+	let l = t.ffmpegPath ?? "ffmpeg", u = t.timeoutMs ?? 3e5, d = await n(e(o(), "voltro-tc-")), f = e(d, "in"), p = [];
+	try {
+		await a(f, c);
+		for (let n of t.renditions) {
+			let t = e(d, `out.${n.ext}`);
+			try {
+				await s(l, [
+					"-y",
+					"-i",
+					f,
+					...n.args,
+					t
+				], u);
+				let e = await r(t);
+				p.push({
+					bytes: new Uint8Array(e),
+					contentType: n.contentType,
+					kind: n.kind,
+					...n.label === void 0 ? {} : { label: n.label }
+				}), await i(t, { force: !0 });
+			} catch {}
+		}
+	} finally {
+		await i(d, {
+			recursive: !0,
+			force: !0
+		}).catch(() => void 0);
+	}
+	return p;
+};
+//#endregion
+export { c as ffmpegTranscoder };

package/dist/transform.js

@@ -0,0 +1,90 @@
+import { createTransformCache as e } from "./transformCache.js";
+//#region src/transform.ts
+var t = (e, t, n, r, i, a) => {
+	let o = n / r, s = Math.min(e, Math.round(t * o)), c = Math.min(t, Math.round(s / o)), l = (e, t) => Math.max(0, Math.min(t, e));
+	return {
+		left: l(Math.round(i * e - s / 2), e - s),
+		top: l(Math.round(a * t - c / 2), t - c),
+		width: s,
+		height: c
+	};
+}, n = {
+	webp: "image/webp",
+	avif: "image/avif",
+	jpeg: "image/jpeg",
+	jpg: "image/jpeg",
+	png: "image/png"
+}, r = (e) => {
+	if (!e) return null;
+	let t = new URLSearchParams(e), n = (e) => {
+		let n = t.get(e);
+		if (n == null) return;
+		let r = Number(n);
+		return Number.isFinite(r) && r > 0 ? Math.floor(r) : void 0;
+	}, r = n("w"), i = n("h"), a = n("q"), o = (t.get("format") ?? t.get("fm") ?? void 0)?.toLowerCase(), s = t.get("fit") ?? void 0, c = (t.get("fp") ?? "").split(",").map(Number), l = c.length === 2 && c.every((e) => Number.isFinite(e) && e >= 0 && e <= 1) ? {
+		x: c[0],
+		y: c[1]
+	} : void 0;
+	return r === void 0 && i === void 0 && !o && a === void 0 ? null : {
+		...r === void 0 ? {} : { w: r },
+		...i === void 0 ? {} : { h: i },
+		...o ? { format: o } : {},
+		...a === void 0 ? {} : { q: a },
+		...s ? { fit: s } : {},
+		...l ? { fp: l } : {}
+	};
+}, i = (e) => e.startsWith("image/") && !e.includes("svg"), a, o = async () => (a ??= import("sharp").then((e) => e.default ?? e, () => null), a), s = async (e, t) => t ? null : i(e) ? await o() === null ? "no-sharp" : "failed" : "not-an-image", c = async (e, r, a) => {
+	if (!i(r)) return null;
+	let s = await o();
+	if (!s) return null;
+	try {
+		let i = s(Buffer.from(e), { failOn: "none" }), o = a.fit ?? "cover";
+		if (a.fp !== void 0 && a.w !== void 0 && a.h !== void 0 && o === "cover") {
+			let e = await i.metadata();
+			e.width !== void 0 && e.height !== void 0 && (i = i.extract(t(e.width, e.height, a.w, a.h, a.fp.x, a.fp.y)));
+		}
+		(a.w !== void 0 || a.h !== void 0) && (i = i.resize({
+			...a.w === void 0 ? {} : { width: a.w },
+			...a.h === void 0 ? {} : { height: a.h },
+			fit: a.fit ?? "cover",
+			withoutEnlargement: !0
+		}));
+		let c = a.format && n[a.format] ? a.format : void 0, l = r;
+		if (c) {
+			let e = c === "jpg" ? "jpeg" : c;
+			i = i.toFormat(e, a.q === void 0 ? {} : { quality: a.q }), l = n[c];
+		} else a.q !== void 0 && (r === "image/jpeg" || r === "image/webp") && (i = i.toFormat(r === "image/webp" ? "webp" : "jpeg", { quality: a.q }));
+		let u = await i.toBuffer();
+		return {
+			bytes: new Uint8Array(u),
+			contentType: l
+		};
+	} catch {
+		return null;
+	}
+}, l = async (e, t, n) => {
+	if (!i(t) || n.rotate === void 0 && n.flip !== !0 && n.flop !== !0 && n.grayscale !== !0 && n.crop === void 0) return null;
+	let r = await o();
+	if (!r) return null;
+	try {
+		let i = r(Buffer.from(e), { failOn: "none" });
+		return n.crop !== void 0 && (i = i.extract(n.crop)), n.rotate !== void 0 && (i = i.rotate(n.rotate)), n.flip === !0 && (i = i.flip()), n.flop === !0 && (i = i.flop()), n.grayscale === !0 && (i = i.grayscale()), {
+			bytes: new Uint8Array(await i.toBuffer()),
+			contentType: t
+		};
+	} catch {
+		return null;
+	}
+}, u = e(), d = (e, t, n) => JSON.stringify([
+	e,
+	t,
+	n.w,
+	n.h,
+	n.format,
+	n.q,
+	n.fit,
+	n.fp?.x,
+	n.fp?.y
+]), f = async (e, t, n, r) => u.getOrCreate(d(e, n, r), () => c(t, n, r));
+//#endregion
+export { l as editImage, t as focalRegion, i as isTransformable, o as loadSharp, r as parseTransformParams, f as transformCached, s as transformFallbackReason, c as transformImage, d as transformKey };

package/dist/transformCache.js

@@ -0,0 +1,31 @@
+//#region src/transformCache.ts
+var e = (e = {
+	entries: 200,
+	bytes: 67108864,
+	pending: 32
+}) => {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = 0;
+	return { getOrCreate: (i, a) => {
+		let o = t.get(i);
+		if (o) return Promise.resolve(o);
+		let s = n.get(i);
+		if (s) return s;
+		if (n.size >= e.pending) return Promise.resolve(null);
+		let c = Promise.resolve().then(a).then((n) => {
+			if (n && e.entries > 0 && n.bytes.byteLength <= e.bytes) {
+				for (; t.size >= e.entries || r + n.bytes.byteLength > e.bytes;) {
+					let e = t.keys().next().value;
+					if (e === void 0) break;
+					r -= t.get(e).bytes.byteLength, t.delete(e);
+				}
+				t.set(i, n), r += n.bytes.byteLength;
+			}
+			return n;
+		}).finally(() => {
+			n.delete(i);
+		});
+		return n.set(i, c), c;
+	} };
+};
+//#endregion
+export { e as createTransformCache };

package/dist/types.d.ts

@@ -208,6 +208,8 @@ export declare type StorageGuard = (ctx: {
  * access policy.
  */
 export declare interface StorageProvider {
+    /** Stable physical object-key namespace; exclude credentials and plugin aliases. */
+    readonly objectNamespace: Effect.Effect<string, StorageError>;
     /**
      * Where a FILESYSTEM provider writes. Absent for every other provider.
      *
@@ -376,6 +378,8 @@ declare const StorageService_base: Context.ServiceClass<StorageService, "@voltro
 
 /** The service handlers consume: `const storage = yield* StorageService`. */
 export declare interface StorageServiceShape {
+    /** Opaque destination binding for manually signed upload-family credentials. */
+    readonly uploadTicketScope: () => Effect.Effect<string, StorageError>;
     /** Store bytes. The result is the ref plus this call's `outcome`. */
     readonly put: (input: PutInput) => Effect.Effect<StoredRef, StorageError | StorageRejected | StorageScanRejected>;
     /** Fetch an object's bytes by id. Enforces the tenant guard ONLY — it does

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-storage",
-  "version": "0.85.0",
+  "version": "0.86.0",
   "description": "File-storage plugin — one StorageProvider contract, switchable backends (S3 / MinIO / Azure / filesystem / memory / database). Public (CDN-direct) + private (access policy + per-object grants) objects, upload constraints, virus-scan hook, on-the-fly image transforms.",
   "keywords": [
     "voltro",
@@ -43,10 +43,10 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.85.0",
-    "@voltro/env": "0.85.0",
-    "@voltro/protocol": "0.85.0",
-    "@voltro/runtime": "0.85.0"
+    "@voltro/database": "0.86.0",
+    "@voltro/env": "0.86.0",
+    "@voltro/protocol": "0.86.0",
+    "@voltro/runtime": "0.86.0"
   },
   "optionalDependencies": {
     "@aws-sdk/client-s3": "^3.1134.0",