@voltro/plugin-storage 0.85.0 → 0.87.0

package/dist/providers.js

@@ -0,0 +1,638 @@
+import { canonicalStorageRoot as e, filesystemObjectNamespace as t, storageEndpointIdentity as n, storageObjectNamespace as r } from "./storageNamespaces.js";
+import { storageReferenceCatalogueId as i } from "./referenceCatalogue.js";
+import { STORAGE_BLOBS_TABLE as a } from "./table.js";
+import { StorageError as o } from "./types.js";
+import { storageInteger as s } from "./storageNumbers.js";
+import { concatBytes as c, fromNodeReadable as l, toNodeReadable as u } from "./streamBridge.js";
+import { storageEnv as d } from "./env.js";
+import { storageMetadataError as f } from "./metadataError.js";
+import { storageRequest as p } from "./storageRequest.js";
+import { Effect as m } from "effect";
+import { randomUUID as h } from "node:crypto";
+import { authoredError as g, generateId as _ } from "@voltro/database";
+//#region src/providers.ts
+var v = (e, t, n, r) => new o({
+	provider: e,
+	message: t,
+	transient: n,
+	...r === void 0 ? {} : { status: r }
+}), y = (e) => e === void 0 || e === 408 || e === 429 || e >= 500, b = h(), x = /* @__PURE__ */ new WeakMap(), S = /* @__PURE__ */ new Map(), C = (e, t) => S.get(e)?.get(t)?.bytes, w = (e) => {
+	S.get(e)?.clear();
+}, T = (e = "default") => {
+	let t = S.get(e) ?? /* @__PURE__ */ new Map();
+	return S.set(e, t), E(t);
+}, E = (e) => {
+	let t = x.get(e);
+	return t === void 0 && (t = r([
+		"memory",
+		b,
+		h()
+	]), x.set(e, t)), {
+		objectLocation: (t) => m.succeed({
+			namespace: e,
+			key: t
+		}),
+		name: "memory",
+		objectNamespace: m.succeed(t),
+		presigns: !1,
+		put: (t, n, r) => m.sync(() => (e.set(t, {
+			bytes: n,
+			contentType: r.contentType
+		}), { size: n.byteLength })),
+		get: (t) => m.suspend(() => {
+			let n = e.get(t);
+			return n ? m.succeed({
+				bytes: n.bytes,
+				contentType: n.contentType
+			}) : m.fail(v("memory", `no object at key '${t}'`, !1, 404));
+		}),
+		delete: (t) => m.sync(() => {
+			e.delete(t);
+		}),
+		publicUrl: () => null,
+		getUrl: () => m.succeed(""),
+		head: (t) => m.sync(() => {
+			let n = e.get(t);
+			return n ? {
+				size: n.bytes.byteLength,
+				contentType: n.contentType
+			} : null;
+		})
+	};
+}, D = (n) => {
+	let r = e(n.root), i = async (e) => {
+		if (e.split("/")[0]?.startsWith(".voltro-object-namespace")) throw Error("Storage namespace metadata is not an object key");
+		let { join: t, resolve: n, sep: i } = await import("node:path"), a = n(r), o = n(a, e);
+		if (o.startsWith(n(a, ".voltro-object-namespace"))) throw Error("Storage namespace metadata is not an object key");
+		if (o !== a && !o.startsWith(a + i)) throw Error(`key '${e}' escapes the storage root`);
+		return t(o);
+	}, a = (e, t, n = !1) => m.tryPromise({
+		try: e,
+		catch: (e) => e?.code === "ENOENT" ? v("filesystem", `no object at key '${t}'`, !1, 404) : v("filesystem", String(e?.message ?? e), n)
+	});
+	return {
+		root: r,
+		objectLocation: (e) => a(async () => {
+			let t = await import("node:fs/promises"), { dirname: n, basename: r, join: a } = await import("node:path"), o = await i(e), s = [];
+			for (;;) try {
+				return {
+					namespace: "filesystem",
+					key: a(await t.realpath(o), ...s)
+				};
+			} catch (e) {
+				if (e.code !== "ENOENT") throw e;
+				let t = n(o);
+				if (t === o) throw e;
+				s.unshift(r(o)), o = t;
+			}
+		}, e),
+		name: "filesystem",
+		objectNamespace: m.try({
+			try: () => t(r),
+			catch: (e) => v("filesystem", String(e instanceof Error ? e.message : e), !1)
+		}),
+		presigns: !1,
+		put: (e, t, n) => a(async () => {
+			let n = await import("node:fs/promises"), { dirname: r } = await import("node:path"), { randomUUID: a } = await import("node:crypto"), o = await i(e), s = r(o);
+			await n.mkdir(s, { recursive: !0 });
+			let c = `${o}.tmp-${a()}`;
+			try {
+				await n.writeFile(c, t), await n.rename(c, o);
+			} catch (e) {
+				throw await n.rm(c, { force: !0 }).catch(() => {}), e;
+			}
+			return { size: t.byteLength };
+		}, e, !0),
+		get: (e) => a(async () => {
+			let t = await (await import("node:fs/promises")).readFile(await i(e));
+			return {
+				bytes: new Uint8Array(t),
+				contentType: "application/octet-stream"
+			};
+		}, e),
+		delete: (e) => a(async () => {
+			await (await import("node:fs/promises")).rm(await i(e), { force: !0 });
+		}, e),
+		publicUrl: () => null,
+		getUrl: () => m.succeed(""),
+		head: (e) => m.tryPromise({
+			try: async () => {
+				let t = await import("node:fs/promises");
+				try {
+					return { size: (await t.stat(await i(e))).size };
+				} catch (e) {
+					if (e?.code === "ENOENT") return null;
+					throw e;
+				}
+			},
+			catch: (e) => v("filesystem", String(e?.message ?? e), !1)
+		}),
+		getStream: (e) => a(async () => {
+			let t = await import("node:fs/promises"), { createReadStream: n } = await import("node:fs"), r = await i(e), a = await t.stat(r);
+			return {
+				stream: l("filesystem", () => n(r)),
+				contentType: "application/octet-stream",
+				size: a.size
+			};
+		}, e),
+		putStream: (e, t, n) => a(async (n) => {
+			let r = await import("node:fs/promises"), { dirname: a } = await import("node:path"), { randomUUID: o } = await import("node:crypto"), { createWriteStream: s } = await import("node:fs"), { pipeline: c } = await import("node:stream/promises"), l = await i(e);
+			n.throwIfAborted(), await r.mkdir(a(l), { recursive: !0 });
+			let d = `${l}.tmp-${o()}`;
+			try {
+				await c(await u(t), s(d), { signal: n });
+				let e = await r.stat(d);
+				return n.throwIfAborted(), await r.rename(d, l), { size: e.size };
+			} catch (e) {
+				throw await r.rm(d, { force: !0 }).catch(() => {}), e;
+			}
+		}, e, !0),
+		getRange: (e, t, n) => a(async () => {
+			let { createReadStream: r } = await import("node:fs"), a = await i(e), o = [];
+			return await new Promise((e, i) => {
+				let s = r(a, {
+					start: t,
+					end: n
+				});
+				s.on("data", (e) => o.push(e)), s.on("end", () => e()), s.on("error", i);
+			}), c(o);
+		}, e)
+	};
+}, O = (e) => k(e).provider, k = (e) => {
+	let t = e.name ?? "s3", i = e.publicAcl ?? !0, a = null, s = () => a || (a = (async () => {
+		let t, n;
+		try {
+			t = await import("@aws-sdk/client-s3"), n = await import("@aws-sdk/s3-request-presigner");
+		} catch (e) {
+			throw Error("the 's3'/'minio' storage provider requires the '@aws-sdk/client-s3' + '@aws-sdk/s3-request-presigner' optional dependencies. Install them to enable it.", { cause: e });
+		}
+		return {
+			client: new t.S3Client({
+				maxAttempts: 1,
+				...e.region ? { region: e.region } : { region: "us-east-1" },
+				...e.endpoint ? { endpoint: e.endpoint } : {},
+				...e.forcePathStyle ? { forcePathStyle: !0 } : {},
+				...e.accessKeyId && e.secretAccessKey ? { credentials: {
+					accessKeyId: e.accessKeyId,
+					secretAccessKey: e.secretAccessKey
+				} } : {}
+			}),
+			cmds: t,
+			presign: n.getSignedUrl
+		};
+	})(), a), c = (e, n) => p(e, (e) => {
+		if (e instanceof o) return e;
+		let n = e?.$metadata?.httpStatusCode;
+		return v(t, String(e?.message ?? e), y(n), n);
+	}, n), d = async (e, t) => {
+		let n = e, r = () => {
+			n.destroy?.();
+		};
+		t.addEventListener("abort", r, { once: !0 });
+		try {
+			if (t.aborted) throw r(), Error("Storage read interrupted");
+			if (typeof n.transformToByteArray == "function") return await n.transformToByteArray();
+			let e = [];
+			for await (let t of n) e.push(t);
+			let i = e.reduce((e, t) => e + t.byteLength, 0), a = new Uint8Array(i), o = 0;
+			for (let t of e) a.set(t, o), o += t.byteLength;
+			return a;
+		} finally {
+			t.removeEventListener("abort", r);
+		}
+	};
+	return {
+		provider: {
+			name: t,
+			objectLocation: (n) => m.try({
+				try: () => ({
+					namespace: JSON.stringify([
+						"s3",
+						e.endpoint === void 0 ? "aws" : new URL(e.endpoint).href.replace(/\/+$/, ""),
+						e.bucket
+					]),
+					key: n
+				}),
+				catch: () => v(t, "Storage endpoint cannot identify its physical namespace", !1)
+			}),
+			objectNamespace: m.succeed(r([
+				"s3",
+				e.endpoint ? n(e.endpoint) : "aws-s3",
+				e.bucket
+			])),
+			presigns: !0,
+			put: (t, n, r) => c(async (a) => {
+				let { client: o, cmds: c } = await s();
+				return await o.send(new c.PutObjectCommand({
+					Bucket: e.bucket,
+					Key: t,
+					Body: n,
+					ContentType: r.contentType,
+					...r.public && i ? { ACL: "public-read" } : {}
+				}), { abortSignal: a }), { size: n.byteLength };
+			}),
+			get: (t) => c(async (n) => {
+				let { client: r, cmds: i } = await s(), a = await r.send(new i.GetObjectCommand({
+					Bucket: e.bucket,
+					Key: t
+				}), { abortSignal: n });
+				return {
+					bytes: await d(a.Body, n),
+					contentType: a.ContentType ?? "application/octet-stream"
+				};
+			}),
+			delete: (t) => c(async (n) => {
+				let { client: r, cmds: i } = await s();
+				await r.send(new i.DeleteObjectCommand({
+					Bucket: e.bucket,
+					Key: t
+				}), { abortSignal: n });
+			}),
+			publicUrl: (t) => e.cdnBaseUrl ? `${e.cdnBaseUrl.replace(/\/$/, "")}/${t}` : null,
+			...i ? { setObjectPublic: (t, n) => c(async (r) => {
+				let { client: i, cmds: a } = await s();
+				await i.send(new a.PutObjectAclCommand({
+					Bucket: e.bucket,
+					Key: t,
+					ACL: n ? "public-read" : "private"
+				}), { abortSignal: r });
+			}) } : {},
+			getUrl: (t, n) => c(async (r) => {
+				let { client: i, cmds: a, presign: o } = await s();
+				return o(i, new a.GetObjectCommand({
+					Bucket: e.bucket,
+					Key: t
+				}), { expiresIn: n });
+			}),
+			getUploadUrl: (t, n, r) => c(async (i) => {
+				let { client: a, cmds: o, presign: c } = await s();
+				return c(a, new o.PutObjectCommand({
+					Bucket: e.bucket,
+					Key: t,
+					ContentType: r
+				}), { expiresIn: n });
+			}),
+			createMultipartUpload: (t, n, r) => c(async (a) => {
+				let { client: o, cmds: c } = await s(), l = await o.send(new c.CreateMultipartUploadCommand({
+					Bucket: e.bucket,
+					Key: t,
+					ContentType: n,
+					...r?.public && i ? { ACL: "public-read" } : {}
+				}), { abortSignal: a });
+				if (!l.UploadId) throw Error("s3 createMultipartUpload returned no UploadId");
+				return { uploadId: l.UploadId };
+			}),
+			presignUploadPart: (t, n, r, i) => c(async (a) => {
+				let { client: o, cmds: c, presign: l } = await s();
+				return l(o, new c.UploadPartCommand({
+					Bucket: e.bucket,
+					Key: t,
+					UploadId: n,
+					PartNumber: r
+				}), { expiresIn: i });
+			}),
+			completeMultipartUpload: (t, n, r) => c(async (i) => {
+				let { client: a, cmds: o } = await s(), c = await a.send(new o.CompleteMultipartUploadCommand({
+					Bucket: e.bucket,
+					Key: t,
+					UploadId: n,
+					MultipartUpload: { Parts: r.map((e) => ({
+						PartNumber: e.partNumber,
+						ETag: e.etag
+					})) }
+				}), { abortSignal: i });
+				return c.ETag === void 0 ? {} : { etag: c.ETag };
+			}),
+			abortMultipartUpload: (t, n) => c(async (r) => {
+				let { client: i, cmds: a } = await s();
+				await i.send(new a.AbortMultipartUploadCommand({
+					Bucket: e.bucket,
+					Key: t,
+					UploadId: n
+				}), { abortSignal: r });
+			}),
+			head: (t) => c(async (n) => {
+				let { client: r, cmds: i } = await s();
+				try {
+					let a = await r.send(new i.HeadObjectCommand({
+						Bucket: e.bucket,
+						Key: t
+					}), { abortSignal: n });
+					return {
+						size: a.ContentLength ?? 0,
+						contentType: a.ContentType ?? "application/octet-stream",
+						...a.ETag === void 0 ? {} : { etag: a.ETag }
+					};
+				} catch (e) {
+					if (e?.$metadata?.httpStatusCode === 404) return null;
+					throw e;
+				}
+			}),
+			getStream: (n) => c(async (r) => {
+				let { client: i, cmds: a } = await s(), o = await i.send(new a.GetObjectCommand({
+					Bucket: e.bucket,
+					Key: n
+				}), { abortSignal: r }), c = o.Body;
+				return {
+					stream: l(t, () => c),
+					close: m.sync(() => {
+						c.destroy();
+					}),
+					contentType: o.ContentType ?? "application/octet-stream",
+					...o.ContentLength === void 0 ? {} : { size: o.ContentLength }
+				};
+			}, (e) => e.close ?? m.void),
+			putStream: (n, r, a) => c(async (c) => {
+				let { client: l, cmds: d } = await s(), f;
+				try {
+					f = await import("@aws-sdk/lib-storage");
+				} catch (e) {
+					throw Error("s3/minio `putStream` requires the '@aws-sdk/lib-storage' optional dependency (multipart upload). Install it to enable streamed uploads.", { cause: e });
+				}
+				c.throwIfAborted();
+				let p = await u(r), m = new AbortController(), h = AbortSignal.any([c, m.signal]), g = () => {
+					p.destroy(/* @__PURE__ */ Error("Storage upload interrupted"));
+				}, _ = (e) => {
+					m.abort(e);
+				}, v = new Proxy(l, { get(e, t, n) {
+					return t === "send" ? (e) => l.send(e, { abortSignal: h }).then((t) => {
+						if (e instanceof d.UploadPartCommand && (!("ETag" in t) || !t.ETag)) throw Error("Storage upload part acknowledgement omitted its ETag");
+						return t;
+					}).catch((e) => {
+						throw m.abort(e), e;
+					}) : Reflect.get(e, t, n);
+				} }), y = new f.Upload({
+					client: v,
+					leavePartsOnError: !0,
+					params: {
+						Bucket: e.bucket,
+						Key: n,
+						Body: p,
+						ContentType: a.contentType,
+						...a.public && i ? { ACL: "public-read" } : {}
+					}
+				});
+				p.once("error", _), h.addEventListener("abort", g, { once: !0 });
+				try {
+					h.aborted && g(), await y.done();
+				} catch (r) {
+					if (y.uploadId !== void 0) try {
+						await l.send(new d.AbortMultipartUploadCommand({
+							Bucket: e.bucket,
+							Key: n,
+							UploadId: y.uploadId
+						}), { abortSignal: AbortSignal.timeout(5e3) });
+					} catch {
+						throw new o({
+							provider: t,
+							message: "Multipart cleanup was not confirmed; object outcome is unknown",
+							transient: !1,
+							outcome: "unknown"
+						});
+					}
+					throw r;
+				} finally {
+					h.removeEventListener("abort", g), p.removeListener("error", _), p.destroy();
+				}
+				return { size: a.totalSize ?? (await l.send(new d.HeadObjectCommand({
+					Bucket: e.bucket,
+					Key: n
+				}), { abortSignal: c })).ContentLength ?? 0 };
+			}),
+			getRange: (t, n, r) => c(async (i) => {
+				let { client: a, cmds: o } = await s(), c = await a.send(new o.GetObjectCommand({
+					Bucket: e.bucket,
+					Key: t,
+					Range: `bytes=${n}-${r}`
+				}), { abortSignal: i });
+				return d(c.Body, i);
+			})
+		},
+		probe: c(async (t) => {
+			let { client: n, cmds: r } = await s();
+			await n.send(new r.HeadBucketCommand({ Bucket: e.bucket }), { abortSignal: t });
+		}),
+		close: m.promise(async () => {
+			a !== null && (await a.catch(() => null))?.client.destroy();
+		})
+	};
+}, A = (e) => e instanceof Uint8Array ? e : typeof e == "string" ? new Uint8Array(Buffer.from(e, "base64")) : new Uint8Array(e), j = () => {
+	let e = null, t = () => {
+		if (!e) throw g("the 'database' storage provider isn't bound to a DataStore yet");
+		return e;
+	}, n = (e) => m.tryPromise({
+		try: e,
+		catch: (e) => f(e, "database", !0)
+	}), o = async (e, n) => (await t().query({
+		table: a,
+		predicate: {
+			column: "key",
+			op: "eq",
+			value: e
+		},
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: n
+	}))[0];
+	return {
+		name: "database",
+		objectLocation: (e) => n(async () => ({
+			namespace: r([
+				"database",
+				await i(t()),
+				a
+			]),
+			key: e
+		})),
+		objectNamespace: n(async () => r([
+			"database",
+			await i(t()),
+			a
+		])),
+		presigns: !1,
+		bindDataStore: (t) => {
+			e = t;
+		},
+		put: (e, r, i) => n(async () => {
+			let n = await o(e);
+			return n ? await t().update(a, String(n.id), {
+				data: r,
+				contentType: i.contentType,
+				size: String(r.byteLength)
+			}) : await t().insert(a, {
+				id: _({
+					kind: "typeid",
+					prefix: "blob"
+				}, a),
+				key: e,
+				data: r,
+				contentType: i.contentType,
+				size: String(r.byteLength)
+			}), { size: r.byteLength };
+		}),
+		get: (e) => m.suspend(() => n(() => o(e)).pipe(m.flatMap((t) => t ? m.succeed({
+			bytes: A(t.data),
+			contentType: String(t.contentType)
+		}) : m.fail(v("database", `no object at key '${e}'`, !1, 404))))),
+		delete: (e) => n(async () => {
+			let n = await o(e, ["id"]);
+			n && await t().delete(a, String(n.id));
+		}),
+		publicUrl: () => null,
+		getUrl: () => m.succeed(""),
+		head: (e) => n(async () => {
+			let t = await o(e, ["size", "contentType"]);
+			return t ? {
+				size: s(t.size, "blob size"),
+				contentType: String(t.contentType)
+			} : null;
+		})
+	};
+}, M = (e) => {
+	let t = d.read("AZURE_STORAGE_ACCOUNT", e.accountName), n = d.read("AZURE_STORAGE_KEY", e.accountKey), r = d.read("AZURE_STORAGE_CONNECTION_STRING", e.connectionString);
+	return N({
+		...e,
+		...t === void 0 ? {} : { accountName: t },
+		...n === void 0 ? {} : { accountKey: n },
+		...r === void 0 ? {} : { connectionString: r }
+	}).provider;
+}, N = (e) => {
+	let t = new AbortController(), i = null, a = () => i || (i = (async () => {
+		let t;
+		try {
+			t = await import("@azure/storage-blob");
+		} catch (e) {
+			throw Error("the 'azure' storage provider requires the '@azure/storage-blob' optional dependency. Install it to enable it.", { cause: e });
+		}
+		let n = e.accountName, r = e.accountKey, i = n && r ? new t.StorageSharedKeyCredential(n, r) : null, a = e.connectionString;
+		return {
+			container: (a ? t.BlobServiceClient.fromConnectionString(a, { retryOptions: { maxTries: 1 } }) : new t.BlobServiceClient(e.endpoint ?? `https://${n}.blob.core.windows.net`, i ?? void 0, { retryOptions: { maxTries: 1 } })).getContainerClient(e.container),
+			sdk: t,
+			cred: i
+		};
+	})(), i), o = (e, n) => p((n) => e(AbortSignal.any([n, t.signal])), (e) => {
+		let t = e?.statusCode;
+		return v("azure", String(e?.message ?? e), y(t), t);
+	}, n), s = async (e, t) => {
+		if (!e) return /* @__PURE__ */ new Uint8Array();
+		let n = () => {
+			e.destroy();
+		};
+		t.addEventListener("abort", n, { once: !0 });
+		try {
+			if (t.aborted) throw n(), Error("Storage read interrupted");
+			let r = [];
+			for await (let t of e) r.push(typeof t == "string" ? new TextEncoder().encode(t) : new Uint8Array(t));
+			let i = r.reduce((e, t) => e + t.byteLength, 0), a = new Uint8Array(i), o = 0;
+			for (let e of r) a.set(e, o), o += e.byteLength;
+			return a;
+		} finally {
+			t.removeEventListener("abort", n);
+		}
+	}, c = async (t, n, r) => {
+		let { container: i, sdk: o, cred: s } = await a();
+		if (!s) throw Error("azure SAS requires accountName + accountKey (set them or AZURE_STORAGE_ACCOUNT/AZURE_STORAGE_KEY)");
+		let c = i.getBlockBlobClient(t), l = o.generateBlobSASQueryParameters({
+			containerName: e.container,
+			blobName: t,
+			permissions: o.BlobSASPermissions.parse(n),
+			startsOn: /* @__PURE__ */ new Date(Date.now() - 6e4),
+			expiresOn: new Date(Date.now() + r * 1e3)
+		}, s).toString();
+		return `${c.url}?${l}`;
+	};
+	return {
+		provider: {
+			name: "azure",
+			objectLocation: (e) => o(async () => {
+				let t = (await a()).container, n = new URL(t.url);
+				return n.search = "", n.hash = "", {
+					namespace: JSON.stringify(["azure", n.href.replace(/\/+$/, "")]),
+					key: e
+				};
+			}),
+			objectNamespace: o(async () => {
+				let { container: e } = await a();
+				return r(["azure", n(e.url)]);
+			}),
+			presigns: !0,
+			put: (e, t, n) => o(async (r) => {
+				let { container: i } = await a();
+				return await i.getBlockBlobClient(e).uploadData(Buffer.from(t), {
+					blobHTTPHeaders: { blobContentType: n.contentType },
+					abortSignal: r
+				}), { size: t.byteLength };
+			}),
+			get: (e) => o(async (t) => {
+				let { container: n } = await a(), r = await n.getBlockBlobClient(e).download(0, void 0, { abortSignal: t });
+				return {
+					bytes: await s(r.readableStreamBody, t),
+					contentType: r.contentType ?? "application/octet-stream"
+				};
+			}),
+			delete: (e) => o(async (t) => {
+				let { container: n } = await a();
+				await n.getBlockBlobClient(e).deleteIfExists({ abortSignal: t });
+			}),
+			publicUrl: (t) => e.cdnBaseUrl ? `${e.cdnBaseUrl.replace(/\/$/, "")}/${t}` : null,
+			getUrl: (e, t) => o(() => c(e, "r", t)),
+			getUploadUrl: (e, t, n) => o(() => c(e, "cw", t)),
+			head: (e) => o(async (t) => {
+				let { container: n } = await a();
+				try {
+					let r = await n.getBlockBlobClient(e).getProperties({ abortSignal: t });
+					return {
+						size: r.contentLength ?? 0,
+						contentType: r.contentType ?? "application/octet-stream",
+						...r.etag === void 0 ? {} : { etag: r.etag }
+					};
+				} catch (e) {
+					if (e?.statusCode === 404) return null;
+					throw e;
+				}
+			}),
+			getStream: (e) => o(async (t) => {
+				let { container: n } = await a(), r = await n.getBlockBlobClient(e).download(0, void 0, { abortSignal: t });
+				return {
+					stream: l("azure", () => r.readableStreamBody),
+					close: m.sync(() => {
+						r.readableStreamBody?.destroy();
+					}),
+					contentType: r.contentType ?? "application/octet-stream",
+					...r.contentLength === void 0 ? {} : { size: r.contentLength }
+				};
+			}, (e) => e.close ?? m.void),
+			putStream: (e, n, r) => o(async (i) => {
+				let { container: o } = await a();
+				i.throwIfAborted();
+				let s = await u(n), c = () => {
+					s.destroy();
+				};
+				i.addEventListener("abort", c, { once: !0 });
+				try {
+					if (i.aborted) throw c(), Error("Storage upload interrupted");
+					await o.getBlockBlobClient(e).uploadStream(s, 4194304, 5, {
+						blobHTTPHeaders: { blobContentType: r.contentType },
+						abortSignal: i
+					});
+				} finally {
+					i.removeEventListener("abort", c), s.destroy();
+				}
+				return { size: r.totalSize ?? (await o.getBlockBlobClient(e).getProperties({ abortSignal: AbortSignal.any([i, t.signal]) })).contentLength ?? 0 };
+			}),
+			getRange: (e, t, n) => o(async (r) => {
+				let { container: i } = await a(), o = await i.getBlockBlobClient(e).download(t, n - t + 1, { abortSignal: r });
+				return s(o.readableStreamBody, r);
+			})
+		},
+		probe: o(async (e) => {
+			await (await a()).container.getProperties({ abortSignal: e });
+		}),
+		close: m.sync(() => {
+			t.abort();
+		})
+	};
+};
+//#endregion
+export { N as azureConnectionTransport, M as azureProvider, w as clearStorageBuffer, j as databaseProvider, D as filesystemProvider, T as memoryProvider, E as memoryProviderWithState, C as readStorageBuffer, k as s3ConnectionTransport, O as s3Provider };

package/dist/referenceCatalogue.js

@@ -0,0 +1,31 @@
+import { storageObjectNamespace as e } from "./storageNamespaces.js";
+import { randomUUID as t } from "node:crypto";
+import { authoredError as n, eq as r, table as i, text as a } from "@voltro/database";
+//#region src/referenceCatalogue.ts
+var o = "_voltro_storage_reference_catalogue", s = i(o, {
+	id: a().maxLength(64),
+	namespace: a().maxLength(64)
+}).primaryKey(["id"]).nonReactive(), c = async (n) => {
+	await n.insertIgnoreWithOutcome(o, {
+		id: "catalogue",
+		namespace: e(["reference-catalogue", t()])
+	}, { conflictColumns: ["id"] }), await l(n);
+}, l = async (t, i) => {
+	let a = await t.query({
+		table: o,
+		predicate: r("id", "catalogue"),
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0
+	}), s = a[0]?.namespace;
+	if (a.length !== 1 || typeof s != "string" || !/^[a-f0-9]{64}$/.test(s)) throw n("Storage reference catalogue identity is missing or invalid; initialize it after normal schema reconciliation before serving inspection");
+	return i ? e([
+		"reference-view",
+		s,
+		i.storageInstance,
+		i.objectNamespace
+	]) : s;
+};
+//#endregion
+export { o as STORAGE_REFERENCE_CATALOGUE_TABLE, c as ensureStorageReferenceCatalogue, l as storageReferenceCatalogueId, s as storageReferenceCatalogueTable };