@voltro/plugin-storage 0.85.0 → 0.87.0

package/dist/ingest.js

@@ -0,0 +1,87 @@
+import { StorageError as e, StorageRejected as t } from "./types.js";
+import { Effect as n } from "effect";
+//#region src/ingest.ts
+var r = 67108864, i = (e) => new t({
+	reason: "too-large",
+	detail: `remote body exceeds the ${e}-byte ingest limit`
+}), a = (e, n) => new t({
+	reason: "blocked-source",
+	detail: `will not fetch ${e}: ${n}`
+}), o = (o, s, c = {}) => n.suspend(() => {
+	let l = s ?? r;
+	return !Number.isSafeInteger(l) || l < 0 ? n.fail(new e({
+		provider: "ingest",
+		message: "limits.maxBytes must be a non-negative safe integer",
+		transient: !1
+	})) : typeof c != "object" || !c || Array.isArray(c) || c.requireHttps !== void 0 && typeof c.requireHttps != "boolean" ? n.fail(new e({
+		provider: "ingest",
+		message: "Ingest policy must be an object with an optional boolean requireHttps",
+		transient: !1,
+		status: 400
+	})) : n.tryPromise({
+		try: async (t) => {
+			let { ssrfReason: n } = await import("./ingestPolicy.js");
+			t.throwIfAborted();
+			let r = o, s;
+			for (let e = 0;; e++) {
+				let i = n(r, { ...c.allowHosts === void 0 ? {} : { allowHosts: c.allowHosts } });
+				if (i !== null) throw a(r, i);
+				if (c.requireHttps === !0 && new URL(r).protocol !== "https:") throw a(r, "HTTPS is required for this source and its redirects");
+				s = await fetch(r, {
+					signal: t,
+					redirect: "manual"
+				});
+				let o = s.headers.get("location");
+				if (s.status < 300 || s.status >= 400 || o === null) break;
+				if (await s.body?.cancel().catch(() => {}), e >= (c.maxRedirects ?? 5)) throw a(r, "too many redirects");
+				r = new URL(o, r).toString();
+			}
+			let u;
+			try {
+				if (!s.ok) throw new e({
+					provider: "ingest",
+					message: `remote server returned HTTP ${s.status}`,
+					transient: s.status === 429 || s.status >= 500,
+					status: s.status
+				});
+				let t = s.headers.get("content-length"), n = s.headers.get("content-encoding")?.trim().toLowerCase();
+				if ((!n || n === "identity") && t !== null && /^\d+$/.test(t) && BigInt(t) > BigInt(l)) throw i(l);
+				let r = /* @__PURE__ */ new Uint8Array(), a = 0;
+				if (s.body !== null) for (u = s.body.getReader();;) {
+					let e = await u.read();
+					if (e.done) break;
+					if (e.value.byteLength > l - a) throw i(l);
+					if (e.value.byteLength !== 0) {
+						let t = a + e.value.byteLength;
+						if (t > r.byteLength) {
+							let e = Math.min(l, Math.max(65536, r.byteLength * 2, t)), n = new Uint8Array(e);
+							n.set(r), r = n;
+						}
+						r.set(e.value, a), a = t;
+					}
+				}
+				return {
+					bytes: a === r.byteLength ? r : r.slice(0, a),
+					contentType: s.headers.get("content-type")?.split(";")[0]?.trim() || "application/octet-stream"
+				};
+			} finally {
+				u === void 0 ? await s.body?.cancel().catch(() => {}) : (await u.cancel().catch(() => {}), u.releaseLock());
+			}
+		},
+		catch: (n) => n instanceof t || n instanceof e ? n : new e({
+			provider: "ingest",
+			message: "remote fetch or body read failed",
+			transient: !0
+		})
+	});
+}), s = (e, t) => n.suspend(() => {
+	if (t === void 0) return e;
+	if (t.aborted) return n.interrupt;
+	let r = n.callback((e) => {
+		let r = () => e(n.interrupt);
+		return t.addEventListener("abort", r, { once: !0 }), t.aborted && r(), n.sync(() => t.removeEventListener("abort", r));
+	});
+	return n.raceFirst(e, r);
+});
+//#endregion
+export { o as fetchIngestBody, s as withIngestAbort };

package/dist/ingestPolicy.js

@@ -0,0 +1 @@
+export { ssrfReason } from "@voltro/protocol";

package/dist/metadataError.js

@@ -0,0 +1,19 @@
+import { StorageError as e, StorageRejected as t } from "./types.js";
+import { Schema as n } from "effect";
+import { causeBranches as r, extractDbCause as i, isTransientContention as a, wireSafeCause as o } from "@voltro/database";
+//#region src/metadataError.ts
+var s = (t, s, c = !1) => {
+	let l = r(t).find(n.is(e));
+	if (l !== void 0) return l;
+	let u = i(t), d = u.dbCode === "22003" || u.dbSqlState === "22003" || u.dbCode === "ER_WARN_DATA_OUT_OF_RANGE" || u.dbErrno === 1264 || u.dbNumber === 8115 || u.dbNumber === 248, f = new e({
+		provider: s,
+		message: `${d ? "Storage metadata numeric value out of range: " : ""}${o(t)}`,
+		transient: d ? !1 : a(t) || c
+	});
+	return Object.defineProperty(f, "cause", {
+		value: t,
+		configurable: !0
+	}), f;
+}, c = (e) => r(e).find(n.is(t));
+//#endregion
+export { s as storageMetadataError, c as storageRejectedCause };

package/dist/objectAbandon.js

@@ -0,0 +1,16 @@
+import { storageMetadataError as e } from "./metadataError.js";
+import { beginStorageObjectAbandon as t, makeStorageObjectMetadata as n } from "./objectMetadata.js";
+import { Effect as r } from "effect";
+//#region src/objectAbandon.ts
+var i = (t) => r.tryPromise({
+	try: t,
+	catch: (t) => e(t, "metadata")
+}), a = (e, a, o) => r.gen(function* () {
+	let r = yield* i(() => t(e, o));
+	return r.state === "retired" ? (r.operation.deleteKey !== null && (yield* a.delete(r.operation.deleteKey)), yield* i(() => n(e, o).confirmDelete(r.identity)), {
+		state: "abandoned",
+		refId: r.operation.refId
+	}) : r;
+});
+//#endregion
+export { a as abandonStorageObject };

package/dist/objectLifecycle.js

@@ -0,0 +1,243 @@
+import { requireStorageReferenceScope as e } from "./storageNamespaces.js";
+import { StorageRejected as t } from "./types.js";
+import { storageInteger as n, storageIntegerSum as r } from "./storageNumbers.js";
+import { Schema as i } from "effect";
+import { createHash as a, randomUUID as o } from "node:crypto";
+import { and as s, bigint as c, eq as l, neq as u, table as d, text as f } from "@voltro/database";
+//#region src/objectLifecycle.ts
+var p = "_voltro_storage_operation_locks", m = "_voltro_storage_object_heads", h = "_voltro_storage_operations", g = "_voltro_storage_object_claims", _ = [
+	d(p, {
+		id: f().maxLength(64),
+		nonce: f()
+	}).primaryKey(["id"]).nonReactive(),
+	d(m, {
+		id: f().maxLength(64),
+		objectNamespace: f().maxLength(64).nullable(),
+		generation: f(),
+		key: f(),
+		reservations: c()
+	}).primaryKey(["id"]).nonReactive(),
+	d(h, {
+		id: f().maxLength(64),
+		storageInstance: f().nullable(),
+		objectNamespace: f().maxLength(64).nullable(),
+		objectId: f().maxLength(64),
+		fingerprint: f().maxLength(64),
+		generation: f(),
+		key: f(),
+		refId: f(),
+		state: f(),
+		deleteKey: f().nullable()
+	}).primaryKey(["id"]).nonReactive(),
+	d(g, {
+		id: f().maxLength(64),
+		operationId: f().maxLength(64),
+		claim: f()
+	}).primaryKey(["id"]).nonReactive()
+], v = i.Struct({
+	id: i.String,
+	storageInstance: i.String,
+	objectNamespace: i.String,
+	objectId: i.String,
+	fingerprint: i.String,
+	generation: i.String,
+	key: i.String,
+	refId: i.String,
+	state: i.Literals([
+		"reserved",
+		"ready",
+		"deleting",
+		"deleted"
+	]),
+	deleteKey: i.NullOr(i.String)
+}), y = i.Struct({
+	id: i.String,
+	objectNamespace: i.String,
+	generation: i.String,
+	key: i.String,
+	reservations: i.Int.pipe(i.check(i.isGreaterThanOrEqualTo(0)))
+}), b = (e) => i.decodeUnknownSync(y)({
+	...e,
+	reservations: n(e.reservations, "shared-object reservation count")
+}), x = (e) => a("sha256").update(JSON.stringify(e)).digest("hex"), S = (e, t) => x([e, t]), C = (n) => {
+	if (n.tenantId !== null && (typeof n.tenantId != "string" || !n.tenantId.trim() || n.tenantId.length > 191) || typeof n.bucket != "string" || !n.bucket.trim() || n.bucket.length > 200 || typeof n.operationId != "string" || !n.operationId.trim() || n.operationId.length > 200) throw new t({
+		reason: "operation-identity-reused",
+		detail: "Storage operation lookup requires explicit valid tenant, destination and operation identity"
+	});
+	return e(n), x([
+		n.storageInstance,
+		n.objectNamespace,
+		n.bucket,
+		n.tenantId,
+		n.operationId
+	]);
+}, w = (e) => C(e), T = async (e, t) => {
+	let n = await e.query({
+		table: h,
+		predicate: l("id", C(t)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n[0] ? i.decodeUnknownSync(v)(n[0]) : void 0;
+}, E = async (e, t, n) => {
+	if (typeof n != "string" || !n.trim() || n.length > 200) throw Error("Storage operation lookup requires a bounded claim");
+	return (await e.query({
+		table: g,
+		predicate: s(l("id", S(t, n)), l("operationId", t), l("claim", n)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	})).length === 1;
+}, D = (t) => {
+	if (e(t), !t.bucket || !t.operationId || !t.logicalKey || !/^[a-f0-9]{64}$/.test(t.fingerprint) || !/^[a-f0-9]{64}$/.test(t.checksum) || t.retainedSource !== void 0 && (!t.retainedSource.refId || !/^[a-f0-9]{64}$/.test(t.retainedSource.digest))) throw Error("Storage operation requires a bucket, operation identity, key and SHA-256 fingerprint");
+	return {
+		id: C(t),
+		objectId: x([
+			t.objectNamespace,
+			t.bucket,
+			t.tenantId,
+			t.logicalKey,
+			t.checksum
+		]),
+		lockId: x([t.tenantId])
+	};
+}, O = async (e, t, n) => {
+	let { lockId: r } = D(t);
+	return await e.insertIgnoreWithOutcome(p, {
+		id: r,
+		nonce: o()
+	}, { conflictColumns: ["id"] }), e.transactional(async (e) => {
+		if ((await e.query({
+			table: p,
+			predicate: l("id", r),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		})).length !== 1 || await e.update(p, r, { nonce: o() }) === null) throw Error("Storage operation lock is unavailable");
+		return n(e);
+	});
+}, k = async (e, n) => {
+	let r = D(n), a = await e.query({
+		table: h,
+		predicate: l("id", r.id),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (!a[0]) return;
+	let o = i.decodeUnknownSync(v)(a[0]);
+	if (o.storageInstance !== n.storageInstance || o.objectNamespace !== n.objectNamespace || o.fingerprint !== n.fingerprint || o.objectId !== r.objectId) throw new t({
+		reason: "operation-identity-reused",
+		detail: `storage operation '${n.operationId}' was already used with different inputs`
+	});
+	return o;
+}, A = async (e, t) => {
+	let n = await k(e, t);
+	if (n) return n;
+	let { id: i, objectId: a } = D(t), s = await e.query({
+		table: m,
+		predicate: l("id", a),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), c = s[0] ? b(s[0]) : void 0, u = c?.generation ?? o(), d = c?.key ?? `${t.logicalKey}/g-${u}`;
+	c ? await e.update(m, a, { reservations: String(r(c.reservations, 1, "shared-object reservation count")) }) : await e.insert(m, {
+		id: a,
+		objectNamespace: t.objectNamespace,
+		generation: u,
+		key: d,
+		reservations: "1"
+	});
+	let f = {
+		id: i,
+		storageInstance: t.storageInstance,
+		objectNamespace: t.objectNamespace,
+		objectId: a,
+		fingerprint: t.fingerprint,
+		generation: u,
+		key: d,
+		refId: `file_${o()}`,
+		state: "reserved",
+		deleteKey: null
+	};
+	return await e.insert(h, f), f;
+}, j = async (e, t) => {
+	let n = await k(e, t);
+	if (!n) throw Error("Storage operation is missing");
+	if (n.state === "deleting" || n.state === "deleted") throw Error("Deleted storage operation cannot be confirmed by a late put");
+	return await e.update(h, n.id, { state: "ready" }), {
+		...n,
+		state: "ready"
+	};
+}, M = async (e, t, n) => {
+	let r = await k(e, t);
+	if (!r) throw Error("Storage operation is missing");
+	if (r.state === "deleting" || r.state === "deleted") return r;
+	if (r.state !== n) throw Error(n === "ready" ? "An unconfirmed put cannot be deleted" : "A confirmed put cannot be abandoned");
+	if (n === "reserved" && (await e.query({
+		table: g,
+		predicate: l("operationId", r.id),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	})).length !== 0) throw Error("An unconfirmed operation unexpectedly holds claims");
+	let i = await e.query({
+		table: m,
+		predicate: l("id", r.objectId),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), a = i[0] ? b(i[0]) : void 0;
+	if (!a || a.generation !== r.generation || a.reservations < 1) throw Error("Storage object generation does not own its reservation");
+	let o = a.reservations === 1 ? a.key : null;
+	return o === null ? await e.update(m, a.id, { reservations: String(a.reservations - 1) }) : await e.delete(m, a.id), o !== null && (await e.query({
+		table: m,
+		predicate: s(l("objectNamespace", t.objectNamespace), l("key", o)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	})).length && (o = null), await e.update(h, r.id, {
+		state: "deleting",
+		deleteKey: o
+	}), {
+		...r,
+		state: "deleting",
+		deleteKey: o
+	};
+}, N = (e, t) => M(e, t, "ready"), P = (e, t) => M(e, t, "reserved"), F = async (e, t) => {
+	let n = await k(e, t);
+	if (!n || n.state !== "deleting" && n.state !== "deleted") throw Error("Storage deletion has not been accepted");
+	return n.state !== "deleted" && (await e.update(h, n.id, { state: "deleted" }), !0);
+}, I = async (e, t, n) => {
+	if (!n) throw Error("Storage object claim must be a non-empty string");
+	await e.insertIgnoreWithOutcome(g, {
+		id: S(t, n),
+		operationId: t,
+		claim: n
+	}, { conflictColumns: ["id"] });
+}, L = async (e, t, n) => {
+	let r = S(t, n);
+	return {
+		held: await e.delete(g, r),
+		others: (await e.query({
+			table: g,
+			predicate: s(l("operationId", t), u("claim", n)),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		})).length > 0
+	};
+}, R = (e, t) => e.deleteMany(g, { where: l("operationId", t) });
+//#endregion
+export { P as beginStorageObjectAbandonInTransaction, N as beginStorageObjectDeleteInTransaction, I as claimStorageObjectInTransaction, R as clearStorageObjectClaimsInTransaction, F as confirmStorageObjectDeleteInTransaction, j as confirmStorageObjectInTransaction, E as hasStorageObjectClaimInTransaction, T as lookupStorageObjectOperationInTransaction, k as readStorageObjectOperationInTransaction, L as releaseStorageObjectClaimInTransaction, A as reserveStorageObjectInTransaction, S as storageObjectClaimId, D as storageObjectIdentifiers, _ as storageObjectLifecycleTables, w as storageObjectOperationId, O as withStorageOperationTransaction };

package/dist/objectMetadata.js

@@ -0,0 +1,308 @@
+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";
+//#region 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: O,
+		predicate: C(w("storageInstance", n.storageInstance), w("objectNamespace", n.objectNamespace), w("refId", t)),
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r.length === 0) return;
+	if (r.length !== 1) throw Error("Storage reference has ambiguous operation ownership");
+	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 = 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
+	};
+}, 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,
+		...b
+	});
+	return {
+		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 j(t, c.refId, b);
+				if (!e) throw Error("Storage operation lost its put intent");
+				let n = c.state === "ready";
+				return n && s !== void 0 && await o(t, c.id, s), {
+					ref: e.ref,
+					ready: n,
+					outcome: n ? "joined" : "resumed"
+				};
+			}
+			let l = await m(t, S(e)), u = v(t, b);
+			if (!(await x.runPromise(u.consumeUsage(e.tenantId, {
+				bytes: r.size,
+				count: 1
+			}, a))).allowed) throw new n({
+				reason: "quota-exceeded",
+				detail: "Storage operation exceeds tenant quota"
+			});
+			let d = y({
+				...r,
+				id: l.refId,
+				key: l.key
+			});
+			return await t.insert(O, {
+				id: l.id,
+				refId: d.id,
+				...b,
+				identity: S(e),
+				ref: d
+			}), {
+				ref: d,
+				ready: !1,
+				outcome: "created"
+			};
+		}),
+		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 (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 l(t, S(e)), await x.runPromise(v(t, b).insert(a.ref)), a.ref;
+		}),
+		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 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: r.identity
+					};
+					if (!a.held) throw new n({
+						reason: "claim-not-held",
+						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 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 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: u,
+					identity: r.identity
+				};
+			});
+		},
+		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)
+	};
+}, I = (e, t, n) => F(e, t, n);
+//#endregion
+export { N as beginStorageObjectAbandon, I as makeAdmittedStorageObjectMetadata, F as makeStorageObjectMetadata, k as storagePutIntentsTable };