@effect-kit/storage 0.0.0-stage → 0.1.0

package/dist/core/storage.js

@@ -0,0 +1,173 @@
+import { ObjectSize } from "./object.js";
+import { storageError } from "./errors.js";
+import { decodeRequest, validateTarget } from "../internal/request-validation.js";
+import { DeleteRequest, GetRequest, HeadRequest, ListRequest, PutRequest } from "./requests.js";
+import { Context, Effect, Option, Predicate, Schema, Stream } from "effect";
+
+// src/core/storage.ts
+var Storage = class Storage extends Context.Service()("@effect-kit/storage/Storage") {
+	/** Guards request boundaries and ties returned bodies to their acquisition scope. */
+	static make(service) {
+		const { provider, storeId } = service;
+		const capabilities = Object.freeze({
+			putConditions: Object.freeze([...service.capabilities.putConditions]),
+			getConditions: Object.freeze([...service.capabilities.getConditions]),
+			deleteConditions: Object.freeze([...service.capabilities.deleteConditions]),
+			ranges: Object.freeze([...service.capabilities.ranges]),
+			versionedReads: service.capabilities.versionedReads,
+			list: Object.freeze({ ...service.capabilities.list })
+		});
+		return Storage.of({
+			...service,
+			capabilities,
+			put: Effect.fnUntraced(function* (request) {
+				const input = yield* decodeRequest(PutRequest, request, "put", provider);
+				if (!Predicate.isUint8Array(input.body) && !Stream.isStream(input.body)) return yield* storageError("put", provider, {
+					_tag: "InvalidInput",
+					field: "body"
+				}, "not-started");
+				const condition = input.condition?._tag === "CreateOnly" ? "create-only" : "if-match";
+				if (input.condition && !capabilities.putConditions.includes(condition)) return yield* storageError("put", provider, {
+					_tag: "Unsupported",
+					capability: condition
+				}, "not-started");
+				return yield* service.put({
+					...input,
+					body: request.body
+				});
+			}),
+			get: Effect.fnUntraced(function* (request) {
+				const input = yield* decodeRequest(GetRequest, request, "get", provider);
+				yield* validateTarget(input, storeId, provider, "get", capabilities);
+				const condition = input.condition?._tag === "IfMatch" ? "if-match" : "if-none-match";
+				if (input.condition && !capabilities.getConditions.includes(condition)) return yield* storageError("get", provider, {
+					_tag: "Unsupported",
+					capability: condition
+				});
+				const range = input.range?._tag.toLowerCase();
+				if (range && !capabilities.ranges.includes(range)) return yield* storageError("get", provider, {
+					_tag: "Unsupported",
+					capability: range
+				});
+				const lifetime = yield* Effect.acquireRelease(Effect.sync(() => ({
+					open: true,
+					consumed: false
+				})), (state) => Effect.sync(() => {
+					state.open = false;
+				}));
+				const result = yield* service.get(input);
+				if (result._tag === "NotModified") return result;
+				const checkOpen = Effect.suspend(() => lifetime.open ? Effect.void : Effect.fail(storageError("get", provider, { _tag: "ScopeClosed" })));
+				return {
+					...result,
+					body: Stream.unwrap(Effect.gen(function* () {
+						yield* checkOpen;
+						if (lifetime.consumed) return yield* storageError("get", provider, { _tag: "BodyConsumed" });
+						lifetime.consumed = true;
+						return Stream.mapEffect(result.body, (chunk) => checkOpen.pipe(Effect.as(chunk)));
+					}))
+				};
+			}),
+			head: Effect.fnUntraced(function* (request) {
+				const input = yield* decodeRequest(HeadRequest, request, "head", provider);
+				yield* validateTarget(input, storeId, provider, "head", capabilities);
+				return yield* service.head(input);
+			}),
+			delete: Effect.fnUntraced(function* (request) {
+				const input = yield* decodeRequest(DeleteRequest, request, "delete", provider);
+				yield* validateTarget(input, storeId, provider, "delete", capabilities);
+				if (input.condition && !capabilities.deleteConditions.includes("if-match")) return yield* storageError("delete", provider, {
+					_tag: "Unsupported",
+					capability: "if-match"
+				}, "not-started");
+				return yield* service.delete(input);
+			}),
+			listPage: Effect.fnUntraced(function* (request = {}) {
+				const input = yield* decodeRequest(ListRequest, request, "listPage", provider);
+				if (input.delimiter && !capabilities.list.delimiter) return yield* storageError("listPage", provider, {
+					_tag: "Unsupported",
+					capability: "delimiter"
+				});
+				if (input.limit && input.limit > capabilities.list.maxPageSize) return yield* storageError("listPage", provider, {
+					_tag: "InvalidInput",
+					field: "limit"
+				});
+				return yield* service.listPage(input);
+			})
+		});
+	}
+	static exists = Effect.fnUntraced(function* (request) {
+		return yield* (yield* Storage).head(request).pipe(Effect.as(true), Effect.catchReason("StorageError", "NotFound", () => Effect.succeed(false)));
+	});
+	static getBytes = Effect.fnUntraced(function* (request) {
+		const storage = yield* Storage;
+		const { maxBytes, ...target } = request;
+		yield* decodeRequest(ObjectSize, maxBytes, "getBytes", storage.provider);
+		return yield* Effect.scoped(Effect.gen(function* () {
+			const response = yield* storage.get(target);
+			if (response._tag === "NotModified") return yield* storageError("getBytes", storage.provider, { _tag: "NotModified" });
+			if (response.contentLength !== void 0 && response.contentLength > maxBytes) return yield* storageError("getBytes", storage.provider, {
+				_tag: "LimitExceeded",
+				limit: maxBytes
+			});
+			const chunks = [];
+			let total = 0;
+			yield* Stream.runForEach(response.body, (chunk) => Effect.gen(function* () {
+				if (chunk.byteLength > maxBytes - total) return yield* storageError("getBytes", storage.provider, {
+					_tag: "LimitExceeded",
+					limit: maxBytes
+				});
+				chunks.push(Uint8Array.from(chunk));
+				total += chunk.byteLength;
+			}));
+			if (response.contentLength !== void 0 && total !== response.contentLength) return yield* storageError("getBytes", storage.provider, {
+				_tag: "LengthMismatch",
+				expected: response.contentLength,
+				actual: total
+			});
+			const bytes = new Uint8Array(total);
+			let offset = 0;
+			for (const chunk of chunks) {
+				bytes.set(chunk, offset);
+				offset += chunk.byteLength;
+			}
+			return bytes;
+		}));
+	});
+	static getText = Effect.fnUntraced(function* (request) {
+		const bytes = yield* Storage.getBytes(request);
+		const storage = yield* Storage;
+		return yield* Effect.try({
+			try: () => new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+			catch: () => storageError("getText", storage.provider, {
+				_tag: "InvalidInput",
+				field: "utf8"
+			})
+		});
+	});
+	static list(request = {}) {
+		return Stream.unwrap(Effect.map(Storage, (storage) => Stream.paginate(request, (current) => Effect.gen(function* () {
+			const page = yield* storage.listPage(current);
+			if (page.cursor !== void 0 && page.cursor === current.cursor) return yield* storageError("listPage", storage.provider, {
+				_tag: "ProviderFailure",
+				code: "RepeatedCursor"
+			});
+			return [page.entries, page.cursor === void 0 ? Option.none() : Option.some({
+				...request,
+				cursor: page.cursor
+			})];
+		}))));
+	}
+	static deleteMany = Effect.fnUntraced(function* (requests, options = {}) {
+		const storage = yield* Storage;
+		const concurrency = options.concurrency ?? 4;
+		yield* decodeRequest(Schema.Int.check(Schema.isGreaterThan(0)), concurrency, "deleteMany", storage.provider);
+		return yield* Effect.forEach(requests, (request) => Effect.map(Effect.result(storage.delete(request)), (result) => ({
+			request,
+			result
+		})), { concurrency });
+	});
+};
+
+export { Storage };
+//# sourceMappingURL=storage.js.map

package/dist/core/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","names":[],"sources":["../../src/core/storage.ts"],"sourcesContent":["import { Context, Effect, Option, Predicate, Schema, Stream } from \"effect\";\nimport type { Scope } from \"effect\";\n\nimport { decodeRequest, validateTarget } from \"../internal/request-validation.js\";\nimport type { StorageCapabilities } from \"./capabilities.js\";\nimport type { StorageError } from \"./errors.js\";\nimport { storageError } from \"./errors.js\";\nimport { ObjectSize } from \"./object.js\";\nimport type { ObjectMetadata } from \"./object.js\";\nimport { DeleteRequest, GetRequest, HeadRequest, ListRequest, PutRequest } from \"./requests.js\";\nimport type { GetResult, ListEntry, ListPage } from \"./requests.js\";\n\nexport interface StorageService {\n  readonly provider: string;\n  readonly storeId: string;\n  readonly capabilities: StorageCapabilities;\n  readonly put: <E = never, R = never>(\n    request: PutRequest<E, R>,\n  ) => Effect.Effect<ObjectMetadata, StorageError | E, R>;\n  readonly get: (request: GetRequest) => Effect.Effect<GetResult, StorageError, Scope.Scope>;\n  readonly head: (request: HeadRequest) => Effect.Effect<ObjectMetadata, StorageError>;\n  readonly delete: (request: DeleteRequest) => Effect.Effect<void, StorageError>;\n  readonly listPage: (request?: ListRequest) => Effect.Effect<ListPage, StorageError>;\n}\n\nexport class Storage extends Context.Service<Storage, StorageService>()(\n  \"@effect-kit/storage/Storage\",\n) {\n  /** Guards request boundaries and ties returned bodies to their acquisition scope. */\n  static make(service: StorageService): StorageService {\n    const { provider, storeId } = service;\n    const capabilities: StorageCapabilities = Object.freeze({\n      putConditions: Object.freeze([...service.capabilities.putConditions]),\n      getConditions: Object.freeze([...service.capabilities.getConditions]),\n      deleteConditions: Object.freeze([...service.capabilities.deleteConditions]),\n      ranges: Object.freeze([...service.capabilities.ranges]),\n      versionedReads: service.capabilities.versionedReads,\n      list: Object.freeze({ ...service.capabilities.list }),\n    });\n\n    return Storage.of({\n      ...service,\n      capabilities,\n      put: Effect.fnUntraced(function* <E = never, R = never>(\n        request: PutRequest<E, R>,\n      ): Effect.fn.Return<ObjectMetadata, StorageError | E, R> {\n        const input = yield* decodeRequest(PutRequest, request, \"put\", provider);\n        if (!Predicate.isUint8Array(input.body) && !Stream.isStream(input.body)) {\n          return yield* storageError(\n            \"put\",\n            provider,\n            { _tag: \"InvalidInput\", field: \"body\" },\n            \"not-started\",\n          );\n        }\n\n        const condition = input.condition?._tag === \"CreateOnly\" ? \"create-only\" : \"if-match\";\n        if (input.condition && !capabilities.putConditions.includes(condition)) {\n          return yield* storageError(\n            \"put\",\n            provider,\n            { _tag: \"Unsupported\", capability: condition },\n            \"not-started\",\n          );\n        }\n\n        return yield* service.put({ ...input, body: request.body });\n      }),\n      get: Effect.fnUntraced(function* (request: GetRequest) {\n        const input = yield* decodeRequest(GetRequest, request, \"get\", provider);\n        yield* validateTarget(input, storeId, provider, \"get\", capabilities);\n\n        const condition = input.condition?._tag === \"IfMatch\" ? \"if-match\" : \"if-none-match\";\n        if (input.condition && !capabilities.getConditions.includes(condition)) {\n          return yield* storageError(\"get\", provider, {\n            _tag: \"Unsupported\",\n            capability: condition,\n          });\n        }\n\n        const range = input.range?._tag.toLowerCase() as \"bounded\" | \"from\" | \"suffix\" | undefined;\n        if (range && !capabilities.ranges.includes(range)) {\n          return yield* storageError(\"get\", provider, { _tag: \"Unsupported\", capability: range });\n        }\n\n        const lifetime = yield* Effect.acquireRelease(\n          Effect.sync(() => ({ open: true, consumed: false })),\n          (state) =>\n            Effect.sync(() => {\n              state.open = false;\n            }),\n        );\n        const result = yield* service.get(input);\n        if (result._tag === \"NotModified\") return result;\n\n        const checkOpen = Effect.suspend(() =>\n          lifetime.open\n            ? Effect.void\n            : Effect.fail(storageError(\"get\", provider, { _tag: \"ScopeClosed\" })),\n        );\n        return {\n          ...result,\n          body: Stream.unwrap(\n            Effect.gen(function* () {\n              yield* checkOpen;\n              if (lifetime.consumed) {\n                return yield* storageError(\"get\", provider, { _tag: \"BodyConsumed\" });\n              }\n\n              lifetime.consumed = true;\n              return Stream.mapEffect(result.body, (chunk) => checkOpen.pipe(Effect.as(chunk)));\n            }),\n          ),\n        };\n      }),\n      head: Effect.fnUntraced(function* (request: HeadRequest) {\n        const input = yield* decodeRequest(HeadRequest, request, \"head\", provider);\n        yield* validateTarget(input, storeId, provider, \"head\", capabilities);\n        return yield* service.head(input);\n      }),\n      delete: Effect.fnUntraced(function* (request: DeleteRequest) {\n        const input = yield* decodeRequest(DeleteRequest, request, \"delete\", provider);\n        yield* validateTarget(input, storeId, provider, \"delete\", capabilities);\n        if (input.condition && !capabilities.deleteConditions.includes(\"if-match\")) {\n          return yield* storageError(\n            \"delete\",\n            provider,\n            { _tag: \"Unsupported\", capability: \"if-match\" },\n            \"not-started\",\n          );\n        }\n\n        return yield* service.delete(input);\n      }),\n      listPage: Effect.fnUntraced(function* (request: ListRequest = {}) {\n        const input = yield* decodeRequest(ListRequest, request, \"listPage\", provider);\n        if (input.delimiter && !capabilities.list.delimiter) {\n          return yield* storageError(\"listPage\", provider, {\n            _tag: \"Unsupported\",\n            capability: \"delimiter\",\n          });\n        }\n        if (input.limit && input.limit > capabilities.list.maxPageSize) {\n          return yield* storageError(\"listPage\", provider, {\n            _tag: \"InvalidInput\",\n            field: \"limit\",\n          });\n        }\n\n        return yield* service.listPage(input);\n      }),\n    });\n  }\n\n  static readonly exists = Effect.fnUntraced(function* (request: HeadRequest) {\n    const storage = yield* Storage;\n    return yield* storage.head(request).pipe(\n      Effect.as(true),\n      Effect.catchReason(\"StorageError\", \"NotFound\", () => Effect.succeed(false)),\n    );\n  });\n\n  static readonly getBytes = Effect.fnUntraced(function* (\n    request: GetRequest & { readonly maxBytes: number },\n  ) {\n    const storage = yield* Storage;\n    const { maxBytes, ...target } = request;\n    yield* decodeRequest(ObjectSize, maxBytes, \"getBytes\", storage.provider);\n\n    return yield* Effect.scoped(\n      Effect.gen(function* () {\n        const response = yield* storage.get(target);\n        if (response._tag === \"NotModified\") {\n          return yield* storageError(\"getBytes\", storage.provider, { _tag: \"NotModified\" });\n        }\n        if (response.contentLength !== undefined && response.contentLength > maxBytes) {\n          return yield* storageError(\"getBytes\", storage.provider, {\n            _tag: \"LimitExceeded\",\n            limit: maxBytes,\n          });\n        }\n\n        const chunks: Uint8Array[] = [];\n        let total = 0;\n        yield* Stream.runForEach(response.body, (chunk) =>\n          Effect.gen(function* () {\n            if (chunk.byteLength > maxBytes - total) {\n              return yield* storageError(\"getBytes\", storage.provider, {\n                _tag: \"LimitExceeded\",\n                limit: maxBytes,\n              });\n            }\n            chunks.push(Uint8Array.from(chunk));\n            total += chunk.byteLength;\n          }),\n        );\n\n        if (response.contentLength !== undefined && total !== response.contentLength) {\n          return yield* storageError(\"getBytes\", storage.provider, {\n            _tag: \"LengthMismatch\",\n            expected: response.contentLength,\n            actual: total,\n          });\n        }\n\n        const bytes = new Uint8Array(total);\n        let offset = 0;\n        for (const chunk of chunks) {\n          bytes.set(chunk, offset);\n          offset += chunk.byteLength;\n        }\n\n        return bytes;\n      }),\n    );\n  });\n\n  static readonly getText = Effect.fnUntraced(function* (\n    request: GetRequest & { readonly maxBytes: number },\n  ) {\n    const bytes = yield* Storage.getBytes(request);\n    const storage = yield* Storage;\n    return yield* Effect.try({\n      try: () => new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes),\n      catch: () =>\n        storageError(\"getText\", storage.provider, { _tag: \"InvalidInput\", field: \"utf8\" }),\n    });\n  });\n\n  static list(request: ListRequest = {}): Stream.Stream<ListEntry, StorageError, Storage> {\n    return Stream.unwrap(\n      Effect.map(Storage, (storage) =>\n        Stream.paginate(request, (current) =>\n          Effect.gen(function* () {\n            const page = yield* storage.listPage(current);\n            if (page.cursor !== undefined && page.cursor === current.cursor) {\n              return yield* storageError(\"listPage\", storage.provider, {\n                _tag: \"ProviderFailure\",\n                code: \"RepeatedCursor\",\n              });\n            }\n            return [\n              page.entries,\n              page.cursor === undefined\n                ? Option.none()\n                : Option.some({ ...request, cursor: page.cursor }),\n            ] as const;\n          }),\n        ),\n      ),\n    );\n  }\n\n  static readonly deleteMany = Effect.fnUntraced(function* (\n    requests: ReadonlyArray<DeleteRequest>,\n    options: { readonly concurrency?: number } = {},\n  ) {\n    const storage = yield* Storage;\n    const concurrency = options.concurrency ?? 4;\n    yield* decodeRequest(\n      Schema.Int.check(Schema.isGreaterThan(0)),\n      concurrency,\n      \"deleteMany\",\n      storage.provider,\n    );\n    return yield* Effect.forEach(\n      requests,\n      (request) =>\n        Effect.map(Effect.result(storage.delete(request)), (result) => ({ request, result })),\n      { concurrency },\n    );\n  });\n}\n"],"mappings":"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"}

package/dist/deno.d.ts

@@ -0,0 +1,14 @@
+import { StorageError } from "./core/errors.js";
+import "./index.js";
+import { TransferHash } from "./transfers/dependencies.js";
+import { UploadSessionStore } from "./sessions/store.js";
+import { sha256 } from "./runtime/portable-hash.js";
+import { aes256Gcm } from "./runtime/web-protection.js";
+import { FileSessionStoreOptions } from "./runtime/session-store.js";
+import { atomicFileStore } from "./runtime/filesystem.js";
+import { fileDownloadTarget } from "./runtime/file-target.js";
+import { Layer } from "effect";
+export declare const layer: Layer.Layer<import("effect/crypto/Aead").Aead | import("effect/crypto/Digest").Digest | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/crypto/SecureRandom").SecureRandom | TransferHash, never, never>;
+export declare const sessionStore: (options: FileSessionStoreOptions) => Layer.Layer<UploadSessionStore, import("effect/persistence/KeyValueStore").KeyValueStoreError | StorageError, import("effect/crypto/Aead").Aead | import("effect/crypto/Digest").Digest | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/crypto/SecureRandom").SecureRandom>;
+export { type FileSessionStoreOptions, aes256Gcm, atomicFileStore, fileDownloadTarget, sha256 };
+//# sourceMappingURL=deno.d.ts.map

package/dist/deno.js

@@ -0,0 +1,17 @@
+import { sha256 } from "./runtime/portable-hash.js";
+import { TransferHash } from "./transfers/dependencies.js";
+import { atomicFileStore } from "./runtime/filesystem.js";
+import { fileSessionStore } from "./runtime/session-store.js";
+import { fileDownloadTarget } from "./runtime/file-target.js";
+import { aes256Gcm } from "./runtime/web-protection.js";
+import { Layer } from "effect";
+import * as DenoCrypto from "@effect/platform-deno/DenoCrypto";
+import * as DenoFileSystem from "@effect/platform-deno/DenoFileSystem";
+import * as DenoPath from "@effect/platform-deno/DenoPath";
+
+// src/runtime/deno.ts
+const layer = Layer.mergeAll(DenoFileSystem.layer, DenoPath.layer, DenoCrypto.layerSecureRandom, DenoCrypto.layerDigest, DenoCrypto.layerAead, Layer.succeed(TransferHash, sha256));
+const sessionStore = (options) => fileSessionStore(options, aes256Gcm(options.key));
+
+export { aes256Gcm, atomicFileStore, fileDownloadTarget, layer, sessionStore, sha256 };
+//# sourceMappingURL=deno.js.map

package/dist/deno.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno.js","names":[],"sources":["../src/runtime/deno.ts"],"sourcesContent":["import * as DenoCrypto from \"@effect/platform-deno/DenoCrypto\";\nimport * as DenoFileSystem from \"@effect/platform-deno/DenoFileSystem\";\nimport * as DenoPath from \"@effect/platform-deno/DenoPath\";\nimport { Layer } from \"effect\";\n\nimport { TransferHash } from \"../transfers/dependencies.js\";\nimport { sha256 } from \"./portable-hash.js\";\nimport { fileSessionStore } from \"./session-store.js\";\nimport type { FileSessionStoreOptions } from \"./session-store.js\";\nimport { aes256Gcm } from \"./web-protection.js\";\n\nexport { sha256, aes256Gcm };\nexport { atomicFileStore } from \"./filesystem.js\";\nexport { fileDownloadTarget } from \"./file-target.js\";\nexport type { FileSessionStoreOptions } from \"./session-store.js\";\n\nexport const layer = Layer.mergeAll(\n  DenoFileSystem.layer,\n  DenoPath.layer,\n  DenoCrypto.layerSecureRandom,\n  DenoCrypto.layerDigest,\n  DenoCrypto.layerAead,\n  Layer.succeed(TransferHash, sha256),\n);\nexport const sessionStore = (options: FileSessionStoreOptions) =>\n  fileSessionStore(options, aes256Gcm(options.key));\n"],"mappings":";;;;;;;;;;;;AAgBA,MAAa,QAAQ,MAAM,SACzB,eAAe,OACf,SAAS,OACT,WAAW,mBACX,WAAW,aACX,WAAW,WACX,MAAM,QAAQ,cAAc,MAAM,CACpC;AACA,MAAa,gBAAgB,YAC3B,iBAAiB,SAAS,UAAU,QAAQ,GAAG,CAAC"}

package/dist/encryption/age.d.ts

@@ -0,0 +1,14 @@
+import { StorageError } from "../core/errors.js";
+import { RepresentationCodec } from "../representation.js";
+import { StorageEncryptionCodec } from "../encryption.js";
+import { Effect, Layer, Redacted, Scope } from "effect";
+export interface AgeEncryptionOptions<R = never> {
+  readonly recipients: ReadonlyArray<string>;
+  /** Resolve current and retained rotation identities at operation time. */
+  readonly identities: Effect.Effect<ReadonlyArray<Redacted.Redacted<string>>, StorageError, R>;
+}
+export declare const AgeEncryption: {
+  make: <R>(options: AgeEncryptionOptions<R>) => Effect.Effect<RepresentationCodec, StorageError, R>;
+  layer: <R>(options: AgeEncryptionOptions<R>) => Layer.Layer<StorageEncryptionCodec, StorageError, Exclude<R, Scope.Scope>>;
+};
+//# sourceMappingURL=age.d.ts.map

package/dist/encryption/age.js

@@ -0,0 +1,46 @@
+import { storageError } from "../core/errors.js";
+import { StorageEncryptionCodec } from "../encryption.js";
+import { Effect, Layer, Redacted, Stream } from "effect";
+import { Decrypter, Encrypter } from "age-encryption";
+
+// src/composition/encryption/age.ts
+const fail = () => storageError("age", "encryption", { _tag: "IntegrityMismatch" });
+const AgeEncryption = {
+	make: Effect.fnUntraced(function* (options) {
+		if (!options.recipients.length) return yield* storageError("age", "encryption", {
+			_tag: "InvalidConfiguration",
+			field: "recipients"
+		});
+		const context = yield* Effect.context();
+		const transform = (encode) => (body) => Stream.unwrap(Effect.gen(function* () {
+			const readable = yield* Stream.toReadableStreamEffect(body);
+			const identities = encode ? [] : yield* Effect.provide(options.identities, context);
+			const output = yield* Effect.tryPromise({
+				try: async () => {
+					if (encode) {
+						const encrypter = new Encrypter();
+						for (const recipient of options.recipients) encrypter.addRecipient(recipient);
+						return encrypter.encrypt(readable);
+					}
+					const decrypter = new Decrypter();
+					for (const identity of identities) decrypter.addIdentity(Redacted.value(identity));
+					return decrypter.decrypt(readable);
+				},
+				catch: fail
+			});
+			return Stream.fromReadableStream({
+				evaluate: () => output,
+				onError: fail
+			});
+		}));
+		return {
+			format: "effect-storage-age-v1",
+			encode: transform(true),
+			decode: transform(false)
+		};
+	}),
+	layer: (options) => Layer.effect(StorageEncryptionCodec, AgeEncryption.make(options))
+};
+
+export { AgeEncryption };
+//# sourceMappingURL=age.js.map

package/dist/encryption/age.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"age.js","names":[],"sources":["../../src/composition/encryption/age.ts"],"sourcesContent":["import { Effect, Layer, Redacted, Stream } from \"effect\";\nimport type { Scope } from \"effect\";\n\nimport { Decrypter, Encrypter } from \"age-encryption\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport type { StorageError } from \"../../core/errors.js\";\nimport type { RepresentationCodec } from \"../representation/index.js\";\nimport { StorageEncryptionCodec } from \"./index.js\";\n\nexport interface AgeEncryptionOptions<R = never> {\n  readonly recipients: ReadonlyArray<string>;\n  /** Resolve current and retained rotation identities at operation time. */\n  readonly identities: Effect.Effect<ReadonlyArray<Redacted.Redacted<string>>, StorageError, R>;\n}\nconst fail = () => storageError(\"age\", \"encryption\", { _tag: \"IntegrityMismatch\" });\n\nexport const AgeEncryption = {\n  make: Effect.fnUntraced(function* <R>(\n    options: AgeEncryptionOptions<R>,\n  ): Effect.fn.Return<RepresentationCodec, StorageError, R> {\n    if (!options.recipients.length)\n      return yield* storageError(\"age\", \"encryption\", {\n        _tag: \"InvalidConfiguration\",\n        field: \"recipients\",\n      });\n    const context = yield* Effect.context<R>();\n    const transform =\n      (encode: boolean) => (body: Stream.Stream<Uint8Array, StorageError, Scope.Scope>) =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            const readable = yield* Stream.toReadableStreamEffect(body);\n            const identities = encode ? [] : yield* Effect.provide(options.identities, context);\n            const output = yield* Effect.tryPromise({\n              try: async () => {\n                if (encode) {\n                  const encrypter = new Encrypter();\n                  for (const recipient of options.recipients) encrypter.addRecipient(recipient);\n                  return encrypter.encrypt(readable);\n                }\n                const decrypter = new Decrypter();\n                for (const identity of identities) decrypter.addIdentity(Redacted.value(identity));\n                return decrypter.decrypt(readable);\n              },\n              catch: fail,\n            });\n            return Stream.fromReadableStream({ evaluate: () => output, onError: fail });\n          }),\n        );\n    return { format: \"effect-storage-age-v1\", encode: transform(true), decode: transform(false) };\n  }),\n  layer: <R>(options: AgeEncryptionOptions<R>) =>\n    Layer.effect(StorageEncryptionCodec, AgeEncryption.make(options)),\n};\n"],"mappings":";;;;;;AAeA,MAAM,aAAa,aAAa,OAAO,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAElF,MAAa,gBAAgB;CAC3B,MAAM,OAAO,WAAW,WACtB,SACwD;EACxD,IAAI,CAAC,QAAQ,WAAW,QACtB,OAAO,OAAO,aAAa,OAAO,cAAc;GAC9C,MAAM;GACN,OAAO;EACT,CAAC;EACH,MAAM,UAAU,OAAO,OAAO,QAAW;EACzC,MAAM,aACH,YAAqB,SACpB,OAAO,OACL,OAAO,IAAI,aAAa;GACtB,MAAM,WAAW,OAAO,OAAO,uBAAuB,IAAI;GAC1D,MAAM,aAAa,SAAS,CAAC,IAAI,OAAO,OAAO,QAAQ,QAAQ,YAAY,OAAO;GAClF,MAAM,SAAS,OAAO,OAAO,WAAW;IACtC,KAAK,YAAY;KACf,IAAI,QAAQ;MACV,MAAM,YAAY,IAAI,UAAU;MAChC,KAAK,MAAM,aAAa,QAAQ,YAAY,UAAU,aAAa,SAAS;MAC5E,OAAO,UAAU,QAAQ,QAAQ;KACnC;KACA,MAAM,YAAY,IAAI,UAAU;KAChC,KAAK,MAAM,YAAY,YAAY,UAAU,YAAY,SAAS,MAAM,QAAQ,CAAC;KACjF,OAAO,UAAU,QAAQ,QAAQ;IACnC;IACA,OAAO;GACT,CAAC;GACD,OAAO,OAAO,mBAAmB;IAAE,gBAAgB;IAAQ,SAAS;GAAK,CAAC;EAC5E,CAAC,CACH;EACJ,OAAO;GAAE,QAAQ;GAAyB,QAAQ,UAAU,IAAI;GAAG,QAAQ,UAAU,KAAK;EAAE;CAC9F,CAAC;CACD,QAAW,YACT,MAAM,OAAO,wBAAwB,cAAc,KAAK,OAAO,CAAC;AACpE"}

package/dist/encryption.d.ts

@@ -0,0 +1,16 @@
+import { StorageError } from "./core/errors.js";
+import { Storage, StorageService } from "./core/storage.js";
+import "./index.js";
+import { TransferDriver } from "./transfers/dependencies.js";
+import { RepresentationCodec, RepresentationOptions, StorageRepresentation } from "./representation.js";
+import "./encryption.js";
+import { Context, Effect, Layer } from "effect";
+declare const StorageEncryptionCodec_base: Context.ServiceClass<StorageEncryptionCodec, "@effect-kit/storage/StorageEncryptionCodec", RepresentationCodec>;
+/** Supply a qualified authenticated format; the facade does not implement cryptography. */
+export declare class StorageEncryptionCodec extends StorageEncryptionCodec_base {}
+export declare const StorageEncryption: {
+  make: (options: RepresentationOptions) => Effect.Effect<StorageService, StorageError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | Storage | StorageEncryptionCodec>;
+  layer: (options: RepresentationOptions) => Layer.Layer<Storage | StorageRepresentation | TransferDriver, StorageError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | Storage | StorageEncryptionCodec | TransferDriver>;
+};
+export { StorageRepresentation };
+//# sourceMappingURL=encryption.d.ts.map

package/dist/encryption.js

@@ -0,0 +1,16 @@
+import { StorageRepresentation } from "./representation.js";
+import { makeRepresentation, representationLayer } from "./composition/representation/storage.js";
+import { Context, Effect, Layer } from "effect";
+
+// src/composition/encryption/index.ts
+/** Supply a qualified authenticated format; the facade does not implement cryptography. */
+var StorageEncryptionCodec = class extends Context.Service()("@effect-kit/storage/StorageEncryptionCodec") {};
+const StorageEncryption = {
+	make: Effect.fnUntraced(function* (options) {
+		return yield* makeRepresentation(yield* StorageEncryptionCodec, options).pipe(Effect.map((value) => value.storage));
+	}),
+	layer: (options) => Layer.unwrap(Effect.map(StorageEncryptionCodec, (codec) => representationLayer(codec, options)))
+};
+
+export { StorageEncryption, StorageEncryptionCodec, StorageRepresentation };
+//# sourceMappingURL=encryption.js.map

package/dist/encryption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.js","names":[],"sources":["../src/composition/encryption/index.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\n\nimport type { RepresentationCodec, RepresentationOptions } from \"../representation/index.js\";\nimport { makeRepresentation, representationLayer } from \"../representation/storage.js\";\n\n/** Supply a qualified authenticated format; the facade does not implement cryptography. */\nexport class StorageEncryptionCodec extends Context.Service<\n  StorageEncryptionCodec,\n  RepresentationCodec\n>()(\"@effect-kit/storage/StorageEncryptionCodec\") {}\nexport const StorageEncryption = {\n  make: Effect.fnUntraced(function* (options: RepresentationOptions) {\n    return yield* makeRepresentation(yield* StorageEncryptionCodec, options).pipe(\n      Effect.map((value) => value.storage),\n    );\n  }),\n  layer: (options: RepresentationOptions) =>\n    Layer.unwrap(\n      Effect.map(StorageEncryptionCodec, (codec) => representationLayer(codec, options)),\n    ),\n};\nexport { StorageRepresentation } from \"../representation/index.js\";\n"],"mappings":";;;;;;AAMA,IAAa,yBAAb,cAA4C,QAAQ,QAGlD,CAAC,CAAC,4CAA4C,CAAC,CAAC,CAAC;AACnD,MAAa,oBAAoB;CAC/B,MAAM,OAAO,WAAW,WAAW,SAAgC;EACjE,OAAO,OAAO,mBAAmB,OAAO,wBAAwB,OAAO,CAAC,CAAC,KACvE,OAAO,KAAK,UAAU,MAAM,OAAO,CACrC;CACF,CAAC;CACD,QAAQ,YACN,MAAM,OACJ,OAAO,IAAI,yBAAyB,UAAU,oBAAoB,OAAO,OAAO,CAAC,CACnF;AACJ"}

package/dist/events.d.ts

@@ -0,0 +1,57 @@
+import { StorageError } from "./core/errors.js";
+import { Context, Effect, Layer, Schema } from "effect";
+import { KeyValueStore } from "effect/persistence";
+export declare const StorageEvent: Schema.Struct<{
+  readonly provider: Schema.NonEmptyString;
+  readonly kind: Schema.Literals<readonly ["object-created", "object-deleted", "delete-marker-created", "version-archived", "metadata-updated", "restore-completed", "other"]>;
+  readonly ref: Schema.Struct<{
+    readonly storeId: Schema.NonEmptyString;
+    readonly key: Schema.NonEmptyString;
+    readonly version: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"S3Version", {
+      readonly id: Schema.NonEmptyString;
+    }>, Schema.TaggedStruct<"GcsGeneration", {
+      readonly id: Schema.NonEmptyString;
+      readonly metageneration: Schema.optional<Schema.NonEmptyString>;
+    }>, Schema.TaggedStruct<"AzureVersion", {
+      readonly id: Schema.NonEmptyString;
+    }>, Schema.TaggedStruct<"AzureSnapshot", {
+      readonly id: Schema.NonEmptyString;
+    }>, Schema.TaggedStruct<"OpaqueVersion", {
+      readonly provider: Schema.NonEmptyString;
+      readonly id: Schema.NonEmptyString;
+    }>]>>;
+  }>;
+  readonly occurredAt: Schema.DateTimeUtc;
+  readonly id: Schema.optional<Schema.NonEmptyString>;
+  readonly sequencer: Schema.optional<Schema.String>;
+  readonly nativeType: Schema.NonEmptyString;
+  readonly native: Schema.optional<Schema.Redacted<Schema.Unknown>>;
+}>;
+export type StorageEvent = typeof StorageEvent.Type;
+export interface EventInbox {
+  readonly process: <E, R>(event: StorageEvent, deliver: (input: {
+    readonly event: StorageEvent;
+    readonly idempotencyKey: string;
+  }) => Effect.Effect<void, E, R>) => Effect.Effect<"delivered" | "duplicate" | "out-of-order", E | StorageError, R>;
+}
+declare const StorageEventInbox_base: Context.ServiceClass<StorageEventInbox, "@effect-kit/storage/StorageEventInbox", EventInbox>;
+export declare class StorageEventInbox extends StorageEventInbox_base {
+  static readonly make: (input: {
+    readonly namespace: string;
+    readonly ownership: "exclusive";
+  }) => Effect.Effect<EventInbox, StorageError, KeyValueStore.KeyValueStore>;
+  static layer(options: {
+    readonly namespace: string;
+    readonly ownership: "exclusive";
+  }): Layer.Layer<StorageEventInbox, StorageError, KeyValueStore.KeyValueStore>;
+}
+/** Authentication belongs to the delivery transport. A decoded JSON payload grants no authority. */
+export declare const makeEventProcessor: <Input, AuthError, AuthR, DeliverError, DeliverR>(options: {
+  readonly authenticate: (input: Input) => Effect.Effect<ReadonlyArray<StorageEvent>, AuthError, AuthR>;
+  readonly deliver: (input: {
+    readonly event: StorageEvent;
+    readonly idempotencyKey: string;
+  }) => Effect.Effect<void, DeliverError, DeliverR>;
+}) => Effect.Effect<(input: Input) => Effect.Effect<("delivered" | "duplicate" | "out-of-order")[], AuthError | DeliverError | StorageError, AuthR | DeliverR>, never, StorageEventInbox>;
+export {};
+//# sourceMappingURL=events.d.ts.map

package/dist/events.js

@@ -0,0 +1,106 @@
+import { ObjectRef } from "./core/object.js";
+import { storageError } from "./core/errors.js";
+import { Context, Effect, Layer, Schema, Semaphore } from "effect";
+import { KeyValueStore } from "effect/persistence";
+
+// src/lifecycle/events.ts
+const StorageEvent = Schema.Struct({
+	provider: Schema.NonEmptyString,
+	kind: Schema.Literals([
+		"object-created",
+		"object-deleted",
+		"delete-marker-created",
+		"version-archived",
+		"metadata-updated",
+		"restore-completed",
+		"other"
+	]),
+	ref: ObjectRef,
+	occurredAt: Schema.DateTimeUtc,
+	id: Schema.optional(Schema.NonEmptyString),
+	sequencer: Schema.optional(Schema.String.check(Schema.isPattern(/^[a-fA-F0-9]{1,128}$/u))),
+	nativeType: Schema.NonEmptyString,
+	native: Schema.optional(Schema.Redacted(Schema.Unknown))
+});
+const Record$1 = Schema.Struct({
+	id: Schema.String,
+	sequencer: StorageEvent.fields.sequencer
+});
+const locks = /* @__PURE__ */ new WeakMap();
+var StorageEventInbox = class StorageEventInbox extends Context.Service()("@effect-kit/storage/StorageEventInbox") {
+	static make = Effect.fnUntraced(function* (input) {
+		const policy = yield* Schema.decodeUnknownEffect(Schema.Struct({
+			namespace: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{1,128}$/u)),
+			ownership: Schema.Literal("exclusive")
+		}))(input).pipe(Effect.mapError(() => storageError("events", "inbox", {
+			_tag: "InvalidConfiguration",
+			field: "ownership"
+		})));
+		const kvs = yield* KeyValueStore.KeyValueStore;
+		const store = KeyValueStore.toSchemaStore(kvs, Record$1);
+		let lock = locks.get(kvs);
+		if (!lock) {
+			lock = Semaphore.makeUnsafe(1);
+			locks.set(kvs, lock);
+		}
+		const mutex = lock;
+		return StorageEventInbox.of({ process: (raw, deliver) => mutex.withPermit(Effect.gen(function* () {
+			const event = yield* Schema.decodeUnknownEffect(StorageEvent)(raw).pipe(Effect.mapError(() => storageError("events", "inbox", {
+				_tag: "InvalidInput",
+				field: "event"
+			})));
+			if (!event.id || event.id.length > 8192) return yield* storageError("events", "inbox", {
+				_tag: "InvalidInput",
+				field: "stable-event-id-required"
+			});
+			const key = `${policy.namespace}:events:` + encodeURIComponent(JSON.stringify([
+				event.provider,
+				event.ref.storeId,
+				event.ref.key,
+				event.sequencer ? "ordered" : event.id
+			]));
+			const previous = yield* store.get(key).pipe(Effect.mapError(() => storageError("events", "inbox", {
+				_tag: "ProviderFailure",
+				code: "InboxRead"
+			})));
+			if (previous._tag === "Some") {
+				if (previous.value.id === event.id) return "duplicate";
+				if (event.sequencer && previous.value.sequencer) {
+					const current = event.sequencer.toUpperCase().padStart(128, "0");
+					const last = previous.value.sequencer.toUpperCase().padStart(128, "0");
+					if (current === last) return "duplicate";
+					if (current < last) return "out-of-order";
+				}
+			}
+			yield* deliver({
+				event,
+				idempotencyKey: JSON.stringify([
+					policy.namespace,
+					event.provider,
+					event.ref.storeId,
+					event.ref.key,
+					event.id
+				])
+			});
+			yield* store.set(key, {
+				id: event.id,
+				sequencer: event.sequencer
+			}).pipe(Effect.mapError(() => storageError("events", "inbox", {
+				_tag: "ProviderFailure",
+				code: "InboxAcknowledge"
+			})));
+			return "delivered";
+		})) });
+	});
+	static layer(options) {
+		return Layer.effect(StorageEventInbox, StorageEventInbox.make(options));
+	}
+};
+/** Authentication belongs to the delivery transport. A decoded JSON payload grants no authority. */
+const makeEventProcessor = Effect.fnUntraced(function* (options) {
+	const inbox = yield* StorageEventInbox;
+	return (input) => options.authenticate(input).pipe(Effect.flatMap((events) => Effect.forEach(events, (event) => inbox.process(event, options.deliver))));
+});
+
+export { StorageEvent, StorageEventInbox, makeEventProcessor };
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":["Record"],"sources":["../src/lifecycle/events.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema, Semaphore } from \"effect\";\nimport { KeyValueStore } from \"effect/persistence\";\n\nimport { storageError } from \"../core/errors.js\";\nimport type { StorageError } from \"../core/errors.js\";\nimport { ObjectRef } from \"../core/object.js\";\n\nexport const StorageEvent = Schema.Struct({\n  provider: Schema.NonEmptyString,\n  kind: Schema.Literals([\n    \"object-created\",\n    \"object-deleted\",\n    \"delete-marker-created\",\n    \"version-archived\",\n    \"metadata-updated\",\n    \"restore-completed\",\n    \"other\",\n  ]),\n  ref: ObjectRef,\n  occurredAt: Schema.DateTimeUtc,\n  id: Schema.optional(Schema.NonEmptyString),\n  sequencer: Schema.optional(Schema.String.check(Schema.isPattern(/^[a-fA-F0-9]{1,128}$/u))),\n  nativeType: Schema.NonEmptyString,\n  native: Schema.optional(Schema.Redacted(Schema.Unknown)),\n});\nexport type StorageEvent = typeof StorageEvent.Type;\nconst Record = Schema.Struct({ id: Schema.String, sequencer: StorageEvent.fields.sequencer });\nconst locks = new WeakMap<KeyValueStore.KeyValueStore, Semaphore.Semaphore>();\nexport interface EventInbox {\n  readonly process: <E, R>(\n    event: StorageEvent,\n    deliver: (input: {\n      readonly event: StorageEvent;\n      readonly idempotencyKey: string;\n    }) => Effect.Effect<void, E, R>,\n  ) => Effect.Effect<\"delivered\" | \"duplicate\" | \"out-of-order\", E | StorageError, R>;\n}\nexport class StorageEventInbox extends Context.Service<StorageEventInbox, EventInbox>()(\n  \"@effect-kit/storage/StorageEventInbox\",\n) {\n  static readonly make = Effect.fnUntraced(function* (input: {\n    readonly namespace: string;\n    readonly ownership: \"exclusive\";\n  }) {\n    const policy = yield* Schema.decodeUnknownEffect(\n      Schema.Struct({\n        namespace: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{1,128}$/u)),\n        ownership: Schema.Literal(\"exclusive\"),\n      }),\n    )(input).pipe(\n      Effect.mapError(() =>\n        storageError(\"events\", \"inbox\", { _tag: \"InvalidConfiguration\", field: \"ownership\" }),\n      ),\n    );\n    const kvs = yield* KeyValueStore.KeyValueStore;\n    const store = KeyValueStore.toSchemaStore(kvs, Record);\n    let lock = locks.get(kvs);\n    if (!lock) {\n      lock = Semaphore.makeUnsafe(1);\n      locks.set(kvs, lock);\n    }\n    const mutex = lock;\n    return StorageEventInbox.of({\n      process: <E, R>(\n        raw: StorageEvent,\n        deliver: (input: {\n          readonly event: StorageEvent;\n          readonly idempotencyKey: string;\n        }) => Effect.Effect<void, E, R>,\n      ) =>\n        mutex.withPermit(\n          Effect.gen(function* () {\n            const event = yield* Schema.decodeUnknownEffect(StorageEvent)(raw).pipe(\n              Effect.mapError(() =>\n                storageError(\"events\", \"inbox\", { _tag: \"InvalidInput\", field: \"event\" }),\n              ),\n            );\n            if (!event.id || event.id.length > 8192)\n              return yield* storageError(\"events\", \"inbox\", {\n                _tag: \"InvalidInput\",\n                field: \"stable-event-id-required\",\n              });\n            const namespace = `${policy.namespace}:events:`;\n            const key =\n              namespace +\n              encodeURIComponent(\n                JSON.stringify([\n                  event.provider,\n                  event.ref.storeId,\n                  event.ref.key,\n                  event.sequencer ? \"ordered\" : event.id,\n                ]),\n              );\n            const previous = yield* store\n              .get(key)\n              .pipe(\n                Effect.mapError(() =>\n                  storageError(\"events\", \"inbox\", { _tag: \"ProviderFailure\", code: \"InboxRead\" }),\n                ),\n              );\n            if (previous._tag === \"Some\") {\n              if (previous.value.id === event.id) return \"duplicate\" as const;\n              if (event.sequencer && previous.value.sequencer) {\n                const current = event.sequencer.toUpperCase().padStart(128, \"0\");\n                const last = previous.value.sequencer.toUpperCase().padStart(128, \"0\");\n                if (current === last) return \"duplicate\" as const;\n                if (current < last) return \"out-of-order\" as const;\n              }\n            }\n            yield* deliver({\n              event,\n              idempotencyKey: JSON.stringify([\n                policy.namespace,\n                event.provider,\n                event.ref.storeId,\n                event.ref.key,\n                event.id,\n              ]),\n            });\n            // A crash after delivery and before this acknowledgement can redeliver.\n            yield* store.set(key, { id: event.id, sequencer: event.sequencer }).pipe(\n              Effect.mapError(() =>\n                storageError(\"events\", \"inbox\", {\n                  _tag: \"ProviderFailure\",\n                  code: \"InboxAcknowledge\",\n                }),\n              ),\n            );\n            return \"delivered\" as const;\n          }),\n        ),\n    });\n  });\n  static layer(options: { readonly namespace: string; readonly ownership: \"exclusive\" }) {\n    return Layer.effect(StorageEventInbox, StorageEventInbox.make(options));\n  }\n}\n\n/** Authentication belongs to the delivery transport. A decoded JSON payload grants no authority. */\nexport const makeEventProcessor = Effect.fnUntraced(function* <\n  Input,\n  AuthError,\n  AuthR,\n  DeliverError,\n  DeliverR,\n>(options: {\n  readonly authenticate: (\n    input: Input,\n  ) => Effect.Effect<ReadonlyArray<StorageEvent>, AuthError, AuthR>;\n  readonly deliver: (input: {\n    readonly event: StorageEvent;\n    readonly idempotencyKey: string;\n  }) => Effect.Effect<void, DeliverError, DeliverR>;\n}) {\n  const inbox = yield* StorageEventInbox;\n  return (input: Input) =>\n    options\n      .authenticate(input)\n      .pipe(\n        Effect.flatMap((events) =>\n          Effect.forEach(events, (event) => inbox.process(event, options.deliver)),\n        ),\n      );\n});\n"],"mappings":"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"}

package/dist/filesystem.d.ts

@@ -0,0 +1,23 @@
+import { StorageError } from "./core/errors.js";
+import { Storage, StorageService } from "./core/storage.js";
+import { TransferDriver, TransferHash } from "./transfers/dependencies.js";
+import { FilesystemOptions } from "./providers/filesystem/layout.js";
+import { Context, Effect, Layer } from "effect";
+export interface FilesystemStorageService extends StorageService {
+  /** Only call after excluding every writer across processes. No age heuristic proves ownership. */
+  readonly reclaimStaging: (options: {
+    readonly ownership: "exclusive";
+  }) => Effect.Effect<number, StorageError>;
+}
+declare const FilesystemStorage_base: Context.ServiceClass<FilesystemStorage, "@effect-kit/storage/FilesystemStorage", FilesystemStorageService>;
+export declare class FilesystemStorage extends FilesystemStorage_base {
+  static readonly make: (options: {
+    readonly root: string;
+    readonly storeId: string;
+    readonly maxObjectBytes?: number | undefined;
+    readonly maxListEntries?: number | undefined;
+  }) => Effect.Effect<FilesystemStorageService, StorageError, import("effect/crypto/Digest").Digest | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/crypto/SecureRandom").SecureRandom | TransferHash>;
+  static layer(options: FilesystemOptions): Layer.Layer<FilesystemStorage | Storage | TransferDriver, StorageError, import("effect/crypto/Digest").Digest | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/crypto/SecureRandom").SecureRandom | TransferHash>;
+}
+export type { FilesystemOptions };
+//# sourceMappingURL=filesystem.d.ts.map