@voltro/plugin-storage 0.86.0 → 0.88.0

package/dist/objectMetadata.js

@@ -1,30 +1,35 @@
-import { requireStorageReferenceScope as e } from "./storageNamespaces.js";
-import { StorageRejected as t } from "./types.js";
-import { beginStorageObjectDeleteInTransaction as n, claimStorageObjectInTransaction as r, clearStorageObjectClaimsInTransaction as i, confirmStorageObjectDeleteInTransaction as a, confirmStorageObjectInTransaction as o, readStorageObjectOperationInTransaction as s, releaseStorageObjectClaimInTransaction as c, reserveStorageObjectInTransaction as l, withStorageOperationTransaction as u } from "./objectLifecycle.js";
-import { dataStoreGrantStore as d, dataStoreRefStore as f, toRef as p } from "./service.js";
-import { and as m, eq as h, json as g, table as _, text as v } from "@voltro/database";
-import { Effect as y, Schema as b } from "effect";
-//#region src/objectMetadata.ts
-var x = "_voltro_storage_put_intents", S = _(x, {
-	id: v().maxLength(64),
-	refId: v().maxLength(64),
-	storageInstance: v().nullable(),
-	objectNamespace: v().maxLength(64).nullable(),
-	identity: g(),
-	ref: g()
-}).primaryKey(["id"]).unique("storagePutRef", ["refId"]).nonReactive(), C = b.Struct({
-	storageInstance: b.String,
-	objectNamespace: b.String,
-	tenantId: b.NullOr(b.String),
-	bucket: b.String,
-	operationId: b.String,
-	fingerprint: b.String,
-	checksum: b.String,
-	logicalKey: b.String
-}), w = async (e, t, n) => {
+import { requireStorageReferenceScope as e, storageReferenceScopeFor as t } from "./storageNamespaces.js";
+import { StorageRejected as n, storageRefAddress as r } from "./types.js";
+import { beginStorageObjectAbandonInTransaction as i, beginStorageObjectDeleteInTransaction as a, claimStorageObjectInTransaction as o, clearStorageObjectClaimsInTransaction as s, confirmStorageObjectDeleteInTransaction as c, confirmStorageObjectInTransaction as l, hasStorageObjectClaimInTransaction as u, lookupStorageObjectOperationInTransaction as d, readStorageObjectOperationInTransaction as f, releaseStorageObjectClaimInTransaction as p, reserveStorageObjectInTransaction as m, storageObjectOperationId as h, withStorageOperationTransaction as g } from "./objectLifecycle.js";
+import { dataStoreGrantStore as _, dataStoreRefStore as v, toRef as y } from "./service.js";
+import { StorageAddress as b } from "@voltro/kv/storage";
+import { Effect as x, Schema as S } from "effect";
+import { and as C, eq as w, json as T, table as E, text as D } from "@voltro/database";
+// src/objectMetadata.ts
+var O = "_voltro_storage_put_intents", k = E(O, {
+	id: D().maxLength(64),
+	refId: D().maxLength(64),
+	storageInstance: D().nullable(),
+	objectNamespace: D().maxLength(64).nullable(),
+	identity: T(),
+	ref: T()
+}).primaryKey(["id"]).unique("storagePutRef", ["refId"]).nonReactive(), A = S.Struct({
+	storageInstance: S.String,
+	objectNamespace: S.String,
+	tenantId: S.NullOr(S.String),
+	bucket: S.String,
+	operationId: S.String,
+	fingerprint: S.String,
+	checksum: S.String,
+	logicalKey: S.String,
+	retainedSource: S.optionalKey(S.Struct({
+		refId: S.String,
+		digest: S.String
+	}))
+}), j = async (e, t, n) => {
 	let r = await e.query({
-		table: x,
-		predicate: m(h("storageInstance", n.storageInstance), h("objectNamespace", n.objectNamespace), h("refId", t)),
+		table: O,
+		predicate: C(w("storageInstance", n.storageInstance), w("objectNamespace", n.objectNamespace), w("refId", t)),
 		order: [],
 		take: 2,
 		skip: void 0,
@@ -32,119 +37,271 @@ var x = "_voltro_storage_put_intents", S = _(x, {
 	});
 	if (r.length === 0) return;
 	if (r.length !== 1) throw Error("Storage reference has ambiguous operation ownership");
-	let i = r[0], a = b.decodeUnknownSync(C)(i.identity);
+	let i = r[0], a = S.decodeUnknownSync(A)(i.identity);
 	if (a.storageInstance !== n.storageInstance || a.objectNamespace !== n.objectNamespace) throw Error("Storage put intent does not match its bound storage scope");
 	if (typeof i.ref != "object" || i.ref === null || Array.isArray(i.ref)) throw Error("Storage operation reference is unreadable");
-	let o = p(i.ref);
+	let o = y(i.ref);
 	if (o.id !== t || o.bucket !== a.bucket || o.tenantId !== a.tenantId || o.checksum !== a.checksum || !Number.isSafeInteger(o.size) || o.size < 0 || !Number.isFinite(o.createdAt.getTime())) throw Error("Storage operation reference does not match its identity");
 	return {
 		identity: a,
 		ref: o
 	};
-}, T = (m, h) => {
-	let g = Object.freeze({ ...h });
-	e(g);
-	let _ = (e) => ({
+}, M = async (e, t) => {
+	let n = h(t), r = await e.query({
+		table: O,
+		predicate: w("id", n),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r.length === 0) return;
+	if (typeof r[0].refId != "string") throw Error("Storage operation has no reference identity");
+	let i = await j(e, r[0].refId, t);
+	if (i === void 0 || h(i.identity) !== n) throw Error("Storage operation intent does not match its requested scope");
+	let a = await f(e, i.identity);
+	if (a === void 0 || a.refId !== i.ref.id) throw Error("Storage operation intent lost its operation");
+	return {
+		...i,
+		state: a.state
+	};
+}, N = async (e, t) => {
+	let n = await M(e, t);
+	return n === void 0 ? { state: "missing" } : g(e, n.identity, async (e) => {
+		let n = await M(e, t);
+		if (n === void 0) throw Error("Storage operation disappeared before abandonment");
+		if (n.state === "ready") return {
+			state: "ready",
+			refId: n.ref.id
+		};
+		let r = v(e, t);
+		if (n.state === "reserved" && await x.runPromise(r.getById(n.ref.id)) !== null) throw Error("An unconfirmed operation unexpectedly has a readable reference");
+		let a = await i(e, n.identity);
+		return n.state === "reserved" && await x.runPromise(r.releaseUsage(n.identity.tenantId, {
+			bytes: n.ref.size,
+			count: 1
+		})), {
+			state: "retired",
+			identity: n.identity,
+			operation: a
+		};
+	});
+}, P = (t, r, i) => {
+	let b = Object.freeze({ ...r });
+	e(b);
+	let S = (e) => ({
 		...e,
-		...g
+		...b
 	});
 	return {
-		scope: g,
-		intent: (e) => w(m, e, g),
-		reserve: (e, n, i, a) => u(m, _(e), async (o) => {
-			if (n.tenantId !== e.tenantId || n.bucket !== e.bucket || n.checksum !== e.checksum || !Number.isSafeInteger(n.size) || n.size < 0) throw Error("Storage put metadata does not match its identity");
-			let c = await s(o, _(e));
+		scope: b,
+		operationStatus: (e) => t.transactional(async (t) => {
+			let n = {
+				...e,
+				...b
+			}, r = await d(t, n);
+			if (!r) return { state: "absent" };
+			let i = await j(t, r.refId, b);
+			if (!i || i.identity.bucket !== e.bucket || i.identity.tenantId !== e.tenantId || i.identity.operationId !== e.operationId || h(i.identity) !== r.id || i.ref.key !== r.key) throw Error("Storage operation lost its matching put intent");
+			let a = await f(t, i.identity);
+			if (!a || a.refId !== r.refId || a.key !== r.key) throw Error("Storage operation identity changed during observation");
+			if (a.state !== "ready") return { state: a.state };
+			let o = await x.runPromise(v(t, b).getById(a.refId));
+			if (!o || o.id !== i.ref.id || o.bucket !== e.bucket || o.tenantId !== e.tenantId || o.key !== a.key || o.checksum !== i.identity.checksum || o.size !== i.ref.size) throw Error("Ready storage operation has no matching readable reference");
+			let s = await f(t, i.identity);
+			if (!s || s.state !== "ready" || s.key !== o.key || s.refId !== o.id) throw Error("Storage operation changed during observation");
+			return {
+				state: "ready",
+				ref: o
+			};
+		}),
+		intent: (e) => j(t, e, b),
+		lookup: async (e, n) => {
+			if (typeof n != "string" || !n.trim() || n.length > 200) throw Error("Storage operation lookup requires an explicit bounded claim");
+			let r = Object.freeze({
+				...b,
+				tenantId: e.tenantId,
+				bucket: e.bucket,
+				operationId: e.operationId
+			}), i = await d(t, r);
+			if (!i) return;
+			let a = await j(t, i.refId, b);
+			if (!a || a.identity.tenantId !== r.tenantId || a.identity.bucket !== r.bucket || a.identity.operationId !== r.operationId) throw Error("Storage operation lookup has unrelated durable intent");
+			return g(t, a.identity, async (e) => {
+				let t = await f(e, a.identity);
+				if (!t) throw Error("Storage operation lookup lost its durable identity");
+				let r = await j(e, t.refId, b);
+				if (!r) throw Error("Storage operation lookup lost its put intent");
+				return {
+					state: t.state,
+					ref: r.ref,
+					held: await u(e, t.id, n)
+				};
+			});
+		},
+		operation: (e) => M(t, {
+			...e,
+			...b
+		}),
+		reserve: (e, r, a, s) => g(t, S(e), async (t) => {
+			if (await i?.(t, e, "reserve"), r.tenantId !== e.tenantId || r.bucket !== e.bucket || r.checksum !== e.checksum || !Number.isSafeInteger(r.size) || r.size < 0) throw Error("Storage put metadata does not match its identity");
+			let c = await f(t, S(e));
 			if (c) {
 				if (c.state === "deleting" || c.state === "deleted") throw Error("Storage put identity has already been deleted");
-				let e = await w(o, c.refId, g);
+				let e = await j(t, c.refId, b);
 				if (!e) throw Error("Storage operation lost its put intent");
-				let t = c.state === "ready";
-				return t && a !== void 0 && await r(o, c.id, a), {
+				let n = c.state === "ready";
+				return n && s !== void 0 && await o(t, c.id, s), {
 					ref: e.ref,
-					ready: t,
-					outcome: t ? "joined" : "resumed"
+					ready: n,
+					outcome: n ? "joined" : "resumed"
 				};
 			}
-			let u = await l(o, _(e)), d = f(o, g);
-			if (!(await y.runPromise(d.consumeUsage(e.tenantId, {
-				bytes: n.size,
+			let l = await m(t, S(e)), u = v(t, b);
+			if (!(await x.runPromise(u.consumeUsage(e.tenantId, {
+				bytes: r.size,
 				count: 1
-			}, i))).allowed) throw new t({
+			}, a))).allowed) throw new n({
 				reason: "quota-exceeded",
 				detail: "Storage operation exceeds tenant quota"
 			});
-			let m = p({
-				...n,
-				id: u.refId,
-				key: u.key
+			let d = y({
+				...r,
+				id: l.refId,
+				key: l.key
 			});
-			return await o.insert(x, {
-				id: u.id,
-				refId: m.id,
-				...g,
-				identity: _(e),
-				ref: m
+			return await t.insert(O, {
+				id: l.id,
+				refId: d.id,
+				...b,
+				identity: S(e),
+				ref: d
 			}), {
-				ref: m,
+				ref: d,
 				ready: !1,
 				outcome: "created"
 			};
 		}),
-		confirm: (e, t) => u(m, _(e), async (n) => {
-			let i = await s(n, _(e));
-			if (!i) throw Error("Storage put operation is missing");
-			let a = await w(n, i.refId, g);
+		confirm: (e, n) => g(t, S(e), async (t) => {
+			await i?.(t, e, "confirm");
+			let r = await f(t, S(e));
+			if (!r) throw Error("Storage put operation is missing");
+			let a = await j(t, r.refId, b);
 			if (!a) throw Error("Storage put intent is missing");
-			if (t !== void 0 && await r(n, i.id, t), i.state === "ready") {
-				let t = await y.runPromise(f(n, g).getById(i.refId));
-				if (!t || t.key !== i.key || t.checksum !== e.checksum) throw Error("Confirmed storage operation lost its reference");
-				return t;
+			if (n !== void 0 && await o(t, r.id, n), r.state === "ready") {
+				let n = await x.runPromise(v(t, b).getById(r.refId));
+				if (!n || n.key !== r.key || n.checksum !== e.checksum) throw Error("Confirmed storage operation lost its reference");
+				return n;
 			}
-			return await o(n, _(e)), await y.runPromise(f(n, g).insert(a.ref)), a.ref;
+			return await l(t, S(e)), await x.runPromise(v(t, b).insert(a.ref)), a.ref;
 		}),
-		beginDelete: async (e, r, a) => {
-			let o = await w(m, e, g);
+		beginDelete: async (e, r, i) => {
+			let o = await j(t, e, b);
 			if (!o) throw Error("Storage delete operation is missing");
 			if (r !== void 0 && o.identity.tenantId !== r) throw Error("Storage delete tenant mismatch");
-			return u(m, o.identity, async (r) => {
-				let o = await w(r, e, g);
-				if (!o) throw Error("Storage delete intent disappeared");
-				let l = await s(r, o.identity);
-				if (!l) throw Error("Storage delete lost its operation");
-				let u = l.state === "ready", p = l.state !== "deleting" && l.state !== "deleted";
-				if (a === void 0) p && await i(r, l.id);
-				else if (p) {
-					let n = await c(r, l.id, a);
-					if (n.others) return {
+			return g(t, o.identity, async (t) => {
+				let r = await j(t, e, b);
+				if (!r) throw Error("Storage delete intent disappeared");
+				let o = await f(t, r.identity);
+				if (!o) throw Error("Storage delete lost its operation");
+				let c = o.state === "ready", l = o.state !== "deleting" && o.state !== "deleted";
+				if (i === void 0) l && await s(t, o.id);
+				else if (l) {
+					let a = await p(t, o.id, i);
+					if (a.others) return {
 						released: !0,
-						identity: o.identity
+						identity: r.identity
 					};
-					if (!n.held) throw new t({
+					if (!a.held) throw new n({
 						reason: "claim-not-held",
-						detail: `claim '${a}' is not held on storage reference '${e}'; a reference put without a claim is deleted as a whole by a delete that names none`
+						detail: `claim '${i}' is not held on storage reference '${e}'; a reference put without a claim is deleted as a whole by a delete that names none`
 					});
 				}
-				let m = await n(r, o.identity);
-				if (u) {
-					let t = f(r, g);
-					if (await y.runPromise(d(r, g).deleteByRef(e)), !await y.runPromise(t.delete(e))) throw Error("Storage deletion lost its confirmed reference");
-					await y.runPromise(t.releaseUsage(o.identity.tenantId, {
-						bytes: o.ref.size,
+				let u = await a(t, r.identity);
+				if (c) {
+					let n = v(t, b);
+					if (await x.runPromise(_(t, b).deleteByRef(e)), !await x.runPromise(n.delete(e))) throw Error("Storage deletion lost its confirmed reference");
+					await x.runPromise(n.releaseUsage(r.identity.tenantId, {
+						bytes: r.ref.size,
 						count: 1
 					}));
 				}
-				return m.deleteKey !== null && await y.runPromise(f(r, g).countByKey(o.ref.bucket, m.deleteKey)) > 0 && (await r.update("_voltro_storage_operations", m.id, { deleteKey: null }), m = {
-					...m,
+				return u.deleteKey !== null && (await t.query({
+					table: "_voltro_storage_refs",
+					predicate: C(w("objectNamespace", b.objectNamespace), w("key", u.deleteKey)),
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: ["id"]
+				})).length > 0 && (await t.update("_voltro_storage_operations", u.id, { deleteKey: null }), u = {
+					...u,
 					deleteKey: null
 				}), {
 					released: !0,
-					operation: m,
-					identity: o.identity
+					operation: u,
+					identity: r.identity
 				};
 			});
 		},
-		confirmDelete: (e) => u(m, _(e), (t) => a(t, _(e)))
+		confirmDelete: (e) => g(t, S(e), (t) => c(t, S(e)))
+	};
+}, F = (n, i, a) => {
+	let o = Object.freeze({ ...i });
+	if (!o.storageInstance.trim()) throw Error("Storage operation metadata requires an explicit instance");
+	"resolveNamespace" in o || e(o);
+	let s = async (e) => {
+		if (!("resolveNamespace" in o)) return o;
+		if ("refId" in e) {
+			let t = await l(e.refId);
+			if (!t) throw Error("Storage delete operation is missing");
+			return {
+				storageInstance: t.identity.storageInstance,
+				objectNamespace: t.identity.objectNamespace
+			};
+		}
+		return x.runPromise(t(o, {
+			destination: e.bucket,
+			tenantId: e.tenantId,
+			key: "_namespace"
+		}));
+	}, c = async (e) => P(n, await s(e), a), l = async (e) => {
+		if (!("resolveNamespace" in o)) return P(n, o, a).intent(e);
+		let i = await n.query({
+			table: O,
+			predicate: C(w("storageInstance", o.storageInstance), w("refId", e)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0
+		});
+		if (i.length === 0) return;
+		if (i.length !== 1) throw Error("Storage reference has ambiguous operation ownership");
+		let s = S.decodeUnknownSync(A)(i[0].identity), c = y(i[0].ref);
+		S.decodeUnknownSync(b)(r(c));
+		let l = await x.runPromise(t(o, r(c)));
+		if (s.storageInstance !== l.storageInstance || s.objectNamespace !== l.objectNamespace) throw Error("Storage put intent belongs to a different physical object namespace");
+		return P(n, l, a).intent(e);
+	};
+	return {
+		scopeFor: s,
+		intent: l,
+		operationStatus: async (e) => {
+			let t = await s(e);
+			return {
+				observation: await P(n, t, a).operationStatus(e),
+				scope: t
+			};
+		},
+		lookup: async (e, t) => (await c(e)).lookup(e, t),
+		operation: async (e) => (await c(e)).operation(e),
+		reserve: async (e, t, n, r) => (await c(e)).reserve(e, t, n, r),
+		confirm: async (e, t) => (await c(e)).confirm(e, t),
+		beginDelete: async (e, t, r) => {
+			let i = await l(e);
+			if (!i) throw Error("Storage delete operation is missing");
+			return P(n, i.identity, a).beginDelete(e, t, r);
+		},
+		confirmDelete: async (e) => (await c(e)).confirmDelete(e)
 	};
-};
-//#endregion
-export { T as makeStorageObjectMetadata, S as storagePutIntentsTable };
+}, I = (e, t, n) => F(e, t, n);
+export { N as beginStorageObjectAbandon, I as makeAdmittedStorageObjectMetadata, F as makeStorageObjectMetadata, k as storagePutIntentsTable };

package/dist/objectWriter.js

@@ -1,58 +1,86 @@
 import { StorageError as e, StorageRejected as t } from "./types.js";
-import { storageMetadataError as n, storageRejectedCause as r } from "./metadataError.js";
-import { createHash as i } from "node:crypto";
-import { Effect as a } from "effect";
-//#region src/objectWriter.ts
-var o = (o) => {
-	let s = a.gen(function* () {
-		(yield* o.provider.objectNamespace) !== o.metadata.scope.objectNamespace && (yield* a.fail(new e({
+import { putObjectStream as n } from "./streamBridge.js";
+import { storageMetadataError as r, storageRejectedCause as i } from "./metadataError.js";
+import { Effect as a, Stream as o } from "effect";
+import { createHash as s } from "node:crypto";
+// src/objectWriter.ts
+var c = (c) => {
+	let l = (t) => a.gen(function* () {
+		(yield* c.provider.objectNamespace) !== (yield* a.tryPromise({
+			try: () => c.metadata.scopeFor(t),
+			catch: (e) => r(e, "metadata")
+		})).objectNamespace && (yield* a.fail(new e({
 			provider: "metadata",
 			message: "Storage metadata is bound to another physical object namespace",
 			transient: !1,
 			status: 409
 		})));
-	}), c = (t, i) => a.tryPromise({
-		try: i,
-		catch: (i) => {
-			let a = r(i);
+	}), u = (t, n) => a.tryPromise({
+		try: n,
+		catch: (n) => {
+			let a = i(n);
 			if (a !== void 0) return a;
-			let o = n(i, "metadata"), s = new e({
+			let o = r(n, "metadata"), s = new e({
 				provider: "metadata",
 				message: `Storage ${t} was not confirmed: ${o.message}; retain the operation identity for recovery`,
 				transient: o.transient,
 				...o.status === void 0 ? {} : { status: o.status }
 			});
 			return Object.defineProperty(s, "cause", {
-				value: i,
+				value: n,
 				configurable: !0
 			}), s;
 		}
 	});
 	return {
 		put: (e) => a.gen(function* () {
-			if (e.bytes.byteLength !== e.ref.size || i("sha256").update(e.bytes).digest("hex") !== e.identity.checksum) return yield* a.fail(new t({
+			if (e.bytes.byteLength !== e.ref.size || s("sha256").update(e.bytes).digest("hex") !== e.identity.checksum) return yield* a.fail(new t({
 				reason: "operation-content-mismatch",
 				detail: "Storage operation bytes do not match their reserved identity"
 			}));
-			yield* s;
-			let n = yield* c("put reservation", () => o.metadata.reserve(e.identity, e.ref, e.quota, e.claim)), r = n.outcome;
+			yield* l(e.identity);
+			let n = yield* u("put reservation", () => c.metadata.reserve(e.identity, e.ref, e.quota, e.claim)), r = n.outcome;
 			return n.ready ? {
 				ref: n.ref,
 				outcome: r
-			} : (yield* o.provider.put(n.ref.key, e.bytes, {
+			} : (yield* c.provider.put(n.ref.key, e.bytes, {
 				contentType: n.ref.contentType,
 				public: n.ref.visibility === "public"
 			}), {
-				ref: yield* c("put confirmation", () => o.metadata.confirm(e.identity, e.claim)),
+				ref: yield* u("put confirmation", () => c.metadata.confirm(e.identity, e.claim)),
 				outcome: r
 			});
 		}),
+		putStream: (t) => a.gen(function* () {
+			let r = yield* u("put reservation", () => c.metadata.reserve(t.identity, t.ref, t.quota, t.claim)), i = r.outcome;
+			if (r.ready) return {
+				ref: r.ref,
+				outcome: i
+			};
+			let l = () => new e({
+				provider: "integrity",
+				message: "Storage operation stream does not match its reserved checksum and size",
+				transient: !1,
+				status: 409
+			}), d = s("sha256"), f = 0, p = !1, m = t.stream.pipe(o.mapEffect((e) => a.suspend(() => {
+				if (e.byteLength > r.ref.size - f) return a.fail(l());
+				let t = Uint8Array.from(e);
+				return f += t.byteLength, d.update(t), a.succeed(t);
+			})), o.concat(o.fromEffect(a.suspend(() => f !== r.ref.size || d.digest("hex") !== t.identity.checksum ? a.fail(l()) : (p = !0, a.succeed(/* @__PURE__ */ new Uint8Array())))))), h = yield* n(c.provider, r.ref.key, m, {
+				contentType: r.ref.contentType,
+				public: r.ref.visibility === "public",
+				totalSize: r.ref.size
+			});
+			return !p || h.size !== r.ref.size ? yield* a.fail(l()) : {
+				ref: yield* u("put confirmation", () => c.metadata.confirm(t.identity, t.claim)),
+				outcome: i
+			};
+		}),
 		delete: (e, t, n) => a.gen(function* () {
-			yield* s;
-			let r = yield* c("delete acceptance", () => o.metadata.beginDelete(e, t, n));
-			"operation" in r && (r.operation.deleteKey !== null && (yield* o.provider.delete(r.operation.deleteKey)), yield* c("delete confirmation", () => o.metadata.confirmDelete(r.identity)));
+			yield* l({ refId: e });
+			let r = yield* u("delete acceptance", () => c.metadata.beginDelete(e, t, n));
+			"operation" in r && (r.operation.deleteKey !== null && (yield* c.provider.delete(r.operation.deleteKey)), yield* u("delete confirmation", () => c.metadata.confirmDelete(r.identity)));
 		})
 	};
 };
-//#endregion
-export { o as makeStorageObjectWriter };
+export { c as makeStorageObjectWriter };

package/dist/pathDurability.js

@@ -1,5 +1,5 @@
 import { statSync as e } from "node:fs";
-//#region src/pathDurability.ts
+// src/pathDurability.ts
 var t = (t) => {
 	try {
 		let n = e(t), r = e("/");
@@ -12,5 +12,4 @@ var t = (t) => {
   dies with it — which is the exact failure it exists for. On a development machine this is normal
   and can be ignored.`;
 };
-//#endregion
 export { n as durabilityNotice, t as pathDurability };

package/dist/physicalReferences.js

@@ -0,0 +1,53 @@
+import { StorageError as e } from "@voltro/kv/storage";
+import { Effect as t } from "effect";
+// src/physicalReferences.ts
+var n = (n, r, i, a) => {
+	let o = (o, s) => t.gen(function* () {
+		let c = (yield* r.listObjectReferences()).filter((e) => !s || e.visibility === "public"), l = yield* n.objectNamespace;
+		if (!s && r.hasObjectReservation !== void 0 && (yield* r.hasObjectReservation(l, o))) return !0;
+		if (c.length === 0) return !1;
+		let u, d = !1, f = !1;
+		for (let e of c) {
+			if (e.objectNamespace === l && e.key === o) return !0;
+			let t = yield* a === void 0 ? i({
+				destination: e.bucket,
+				tenantId: e.tenantId,
+				key: e.key
+			}) : a(e);
+			if (e.objectNamespace !== void 0 && (yield* t.objectNamespace) !== e.objectNamespace) {
+				f = !0;
+				continue;
+			}
+			if (n === t) {
+				if (o === e.key) return !0;
+				continue;
+			}
+			d ||= (u = n.objectLocation === void 0 ? void 0 : yield* n.objectLocation(o), !0);
+			let r = t.objectLocation === void 0 ? void 0 : yield* t.objectLocation(e.key);
+			if (u === void 0 || r === void 0) f = !0;
+			else if (u.namespace === r.namespace && u.key === r.key) return !0;
+		}
+		return f ? yield* t.fail(new e({
+			provider: "storage",
+			message: "Physical object ownership cannot be established for every storage destination",
+			transient: !1
+		})) : !1;
+	}), s = (e, n) => n === !0 ? t.succeed(!0) : o(e, !0);
+	return {
+		...n,
+		delete: (e) => o(e, !1).pipe(t.flatMap((r) => r ? n.setObjectPublic === void 0 ? t.void : o(e, !0).pipe(t.flatMap((t) => n.setObjectPublic(e, t))) : n.delete(e))),
+		...n.setObjectPublic === void 0 ? {} : {
+			setObjectPublic: (e, r) => s(e, r).pipe(t.flatMap((t) => n.setObjectPublic(e, t))),
+			put: (e, r, i) => s(e, i.public).pipe(t.flatMap((t) => n.put(e, r, {
+				...i,
+				public: t
+			}))),
+			...n.putStream === void 0 ? {} : { putStream: (e, r, i) => s(e, i.public).pipe(t.flatMap((t) => n.putStream(e, r, {
+				...i,
+				public: t
+			}))) },
+			...n.createMultipartUpload === void 0 ? {} : { createMultipartUpload: (e, r, i) => s(e, i?.public).pipe(t.flatMap((t) => n.createMultipartUpload(e, r, { public: t }))) }
+		}
+	};
+};
+export { n as protectStorageReferences };