@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/testing/conformance/core-cases.js

@@ -0,0 +1,107 @@
+import { bytesEqual, check, expectReason, read } from "./assertions.js";
+import { Effect, Result, Stream } from "effect";
+
+// src/testing/conformance/core-cases.ts
+const coreCases = [
+	{
+		name: "binary-empty-and-metadata",
+		run: (storage) => Effect.gen(function* () {
+			const expected = new Uint8Array([
+				0,
+				255,
+				13,
+				10
+			]);
+			const saved = yield* storage.put({
+				key: "binary",
+				body: expected,
+				contentType: "application/octet-stream",
+				customMetadata: { suite: "portable" }
+			});
+			const head = yield* storage.head({ key: "binary" });
+			yield* check(head.ref.storeId === storage.storeId && head.ref.key === "binary", "Incorrect namespace identity");
+			yield* check(head.contentType === "application/octet-stream" && head.customMetadata?.suite === "portable", "Metadata did not round-trip");
+			yield* check(saved.etag === void 0 || saved.etag === head.etag, "Write/head identity differs without a mutation");
+			yield* check(bytesEqual(yield* read(storage, "binary"), expected), "Binary bytes changed");
+			yield* storage.put({
+				key: "empty",
+				body: /* @__PURE__ */ new Uint8Array()
+			});
+			yield* check((yield* read(storage, "empty")).length === 0, "Empty object did not round-trip");
+		})
+	},
+	{
+		name: "stream-and-overwrite",
+		run: (storage) => Effect.gen(function* () {
+			yield* storage.put({
+				key: "stream",
+				body: Stream.make(new Uint8Array([1]), new Uint8Array([2]))
+			});
+			yield* check(bytesEqual(yield* read(storage, "stream"), new Uint8Array([1, 2])), "Stream bytes changed");
+			yield* storage.put({
+				key: "stream",
+				body: new Uint8Array([3])
+			});
+			yield* check(bytesEqual(yield* read(storage, "stream"), new Uint8Array([3])), "Overwrite did not replace");
+		})
+	},
+	{
+		name: "missing-and-idempotent-delete",
+		run: (storage) => Effect.gen(function* () {
+			yield* expectReason(storage.head({ key: "missing" }), "NotFound");
+			yield* expectReason(storage.get({ key: "missing" }), "NotFound");
+			yield* storage.delete({ key: "missing" });
+			yield* storage.put({
+				key: "remove",
+				body: new Uint8Array([1])
+			});
+			yield* storage.delete({ key: "remove" });
+			yield* storage.delete({ key: "remove" });
+			yield* expectReason(storage.head({ key: "remove" }), "NotFound");
+		})
+	},
+	{
+		name: "atomic-create-only",
+		requires: (profile) => profile.putConditions.includes("create-only"),
+		run: (storage) => Effect.gen(function* () {
+			const results = yield* Effect.all([1, 2].map((byte) => Effect.result(storage.put({
+				key: "race",
+				body: new Uint8Array([byte]),
+				condition: { _tag: "CreateOnly" }
+			}))), { concurrency: 2 });
+			yield* check(results.filter(Result.isSuccess).length === 1, "Create-only did not have one winner");
+			const failed = results.find(Result.isFailure);
+			yield* check(failed?.failure.reason._tag === "PreconditionFailed", "Losing writer was not conditionally rejected");
+		})
+	},
+	{
+		name: "stale-write-condition",
+		requires: (profile) => profile.putConditions.includes("if-match"),
+		run: (storage) => Effect.gen(function* () {
+			const first = yield* storage.put({
+				key: "match",
+				body: new Uint8Array([1])
+			});
+			yield* check(first.etag !== void 0, "Conditional adapter omitted its validator");
+			yield* expectReason(storage.put({
+				key: "match",
+				body: new Uint8Array([2]),
+				condition: {
+					_tag: "IfMatch",
+					etag: "\"deliberately-stale\""
+				}
+			}), "PreconditionFailed");
+			yield* check(bytesEqual(yield* read(storage, "match"), new Uint8Array([1])), "Rejected write changed bytes");
+		})
+	},
+	{
+		name: "foreign-reference",
+		run: (storage) => expectReason(storage.head({ ref: {
+			storeId: `foreign:${storage.storeId}`,
+			key: "anything"
+		} }), "InvalidInput")
+	}
+];
+
+export { coreCases };
+//# sourceMappingURL=core-cases.js.map

package/dist/testing/conformance/core-cases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-cases.js","names":[],"sources":["../../../src/testing/conformance/core-cases.ts"],"sourcesContent":["import { Effect, Result, Stream } from \"effect\";\n\nimport type { StorageConformanceCase } from \"../conformance.js\";\nimport { bytesEqual, check, expectReason, read } from \"./assertions.js\";\n\nexport const coreCases: ReadonlyArray<StorageConformanceCase> = [\n  {\n    name: \"binary-empty-and-metadata\",\n    run: (storage) =>\n      Effect.gen(function* () {\n        const expected = new Uint8Array([0, 255, 13, 10]);\n        const saved = yield* storage.put({\n          key: \"binary\",\n          body: expected,\n          contentType: \"application/octet-stream\",\n          customMetadata: { suite: \"portable\" },\n        });\n        const head = yield* storage.head({ key: \"binary\" });\n        yield* check(\n          head.ref.storeId === storage.storeId && head.ref.key === \"binary\",\n          \"Incorrect namespace identity\",\n        );\n        yield* check(\n          head.contentType === \"application/octet-stream\" &&\n            head.customMetadata?.suite === \"portable\",\n          \"Metadata did not round-trip\",\n        );\n        yield* check(\n          saved.etag === undefined || saved.etag === head.etag,\n          \"Write/head identity differs without a mutation\",\n        );\n        yield* check(bytesEqual(yield* read(storage, \"binary\"), expected), \"Binary bytes changed\");\n        yield* storage.put({ key: \"empty\", body: new Uint8Array() });\n        yield* check(\n          (yield* read(storage, \"empty\")).length === 0,\n          \"Empty object did not round-trip\",\n        );\n      }),\n  },\n  {\n    name: \"stream-and-overwrite\",\n    run: (storage) =>\n      Effect.gen(function* () {\n        yield* storage.put({\n          key: \"stream\",\n          body: Stream.make(new Uint8Array([1]), new Uint8Array([2])),\n        });\n        yield* check(\n          bytesEqual(yield* read(storage, \"stream\"), new Uint8Array([1, 2])),\n          \"Stream bytes changed\",\n        );\n        yield* storage.put({ key: \"stream\", body: new Uint8Array([3]) });\n        yield* check(\n          bytesEqual(yield* read(storage, \"stream\"), new Uint8Array([3])),\n          \"Overwrite did not replace\",\n        );\n      }),\n  },\n  {\n    name: \"missing-and-idempotent-delete\",\n    run: (storage) =>\n      Effect.gen(function* () {\n        yield* expectReason(storage.head({ key: \"missing\" }), \"NotFound\");\n        yield* expectReason(storage.get({ key: \"missing\" }), \"NotFound\");\n        yield* storage.delete({ key: \"missing\" });\n        yield* storage.put({ key: \"remove\", body: new Uint8Array([1]) });\n        yield* storage.delete({ key: \"remove\" });\n        yield* storage.delete({ key: \"remove\" });\n        yield* expectReason(storage.head({ key: \"remove\" }), \"NotFound\");\n      }),\n  },\n  {\n    name: \"atomic-create-only\",\n    requires: (profile) => profile.putConditions.includes(\"create-only\"),\n    run: (storage) =>\n      Effect.gen(function* () {\n        const results = yield* Effect.all(\n          [1, 2].map((byte) =>\n            Effect.result(\n              storage.put({\n                key: \"race\",\n                body: new Uint8Array([byte]),\n                condition: { _tag: \"CreateOnly\" },\n              }),\n            ),\n          ),\n          { concurrency: 2 },\n        );\n        yield* check(\n          results.filter(Result.isSuccess).length === 1,\n          \"Create-only did not have one winner\",\n        );\n        const failed = results.find(Result.isFailure);\n        yield* check(\n          failed?.failure.reason._tag === \"PreconditionFailed\",\n          \"Losing writer was not conditionally rejected\",\n        );\n      }),\n  },\n  {\n    name: \"stale-write-condition\",\n    requires: (profile) => profile.putConditions.includes(\"if-match\"),\n    run: (storage) =>\n      Effect.gen(function* () {\n        const first = yield* storage.put({ key: \"match\", body: new Uint8Array([1]) });\n        yield* check(first.etag !== undefined, \"Conditional adapter omitted its validator\");\n        yield* expectReason(\n          storage.put({\n            key: \"match\",\n            body: new Uint8Array([2]),\n            condition: { _tag: \"IfMatch\", etag: '\"deliberately-stale\"' },\n          }),\n          \"PreconditionFailed\",\n        );\n        yield* check(\n          bytesEqual(yield* read(storage, \"match\"), new Uint8Array([1])),\n          \"Rejected write changed bytes\",\n        );\n      }),\n  },\n  {\n    name: \"foreign-reference\",\n    run: (storage) =>\n      expectReason(\n        storage.head({\n          ref: { storeId: `foreign:${storage.storeId}`, key: \"anything\" },\n        }),\n        \"InvalidInput\",\n      ),\n  },\n];\n"],"mappings":"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"}

package/dist/testing/conformance/list-cases.js

@@ -0,0 +1,72 @@
+import { Storage } from "../../core/storage.js";
+import { check, expectReason } from "./assertions.js";
+import { Effect, Stream } from "effect";
+
+// src/testing/conformance/list-cases.ts
+const listCases = [
+	{
+		name: "paged-prefix-traversal",
+		run: (storage) => Effect.gen(function* () {
+			for (const key of [
+				"p/a",
+				"p/b",
+				"p/c",
+				"unrelated"
+			]) yield* storage.put({
+				key,
+				body: /* @__PURE__ */ new Uint8Array()
+			});
+			const keys = (yield* Stream.runCollect(Storage.list({
+				prefix: "p/",
+				limit: 1
+			}).pipe(Stream.provideService(Storage, storage)))).filter((entry) => entry._tag === "Object").map((entry) => entry.metadata.ref.key).toSorted();
+			yield* check(JSON.stringify(keys) === JSON.stringify([
+				"p/a",
+				"p/b",
+				"p/c"
+			]), "Listing lost/duplicated keys");
+		})
+	},
+	{
+		name: "common-prefixes",
+		requires: (profile) => profile.list.delimiter,
+		run: (storage) => Effect.gen(function* () {
+			for (const key of [
+				"p/a/x",
+				"p/a/y",
+				"p/b"
+			]) yield* storage.put({
+				key,
+				body: /* @__PURE__ */ new Uint8Array()
+			});
+			const page = yield* storage.listPage({
+				prefix: "p/",
+				delimiter: "/"
+			});
+			yield* check(page.entries.some((entry) => entry._tag === "CommonPrefix" && entry.prefix === "p/a/"), "Missing aggregated common prefix");
+			yield* check(page.entries.filter((entry) => entry._tag === "CommonPrefix").length === 1, "Repeated common prefix");
+		})
+	},
+	{
+		name: "cursor-query-binding",
+		run: (storage) => Effect.gen(function* () {
+			for (const key of ["q/a", "q/b"]) yield* storage.put({
+				key,
+				body: /* @__PURE__ */ new Uint8Array()
+			});
+			const page = yield* storage.listPage({
+				prefix: "q/",
+				limit: 1
+			});
+			if (!page.cursor) return yield* check(false, "Page omitted required continuation");
+			yield* expectReason(storage.listPage({
+				prefix: "other/",
+				limit: 1,
+				cursor: page.cursor
+			}), "InvalidInput");
+		})
+	}
+];
+
+export { listCases };
+//# sourceMappingURL=list-cases.js.map

package/dist/testing/conformance/list-cases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-cases.js","names":[],"sources":["../../../src/testing/conformance/list-cases.ts"],"sourcesContent":["import { Effect, Stream } from \"effect\";\n\nimport { Storage } from \"../../core/storage.js\";\nimport type { StorageConformanceCase } from \"../conformance.js\";\nimport { check, expectReason } from \"./assertions.js\";\n\nexport const listCases: ReadonlyArray<StorageConformanceCase> = [\n  {\n    name: \"paged-prefix-traversal\",\n    run: (storage) =>\n      Effect.gen(function* () {\n        for (const key of [\"p/a\", \"p/b\", \"p/c\", \"unrelated\"]) {\n          yield* storage.put({ key, body: new Uint8Array() });\n        }\n        const entries = yield* Stream.runCollect(\n          Storage.list({ prefix: \"p/\", limit: 1 }).pipe(Stream.provideService(Storage, storage)),\n        );\n        const keys = entries\n          .filter((entry) => entry._tag === \"Object\")\n          .map((entry) => entry.metadata.ref.key)\n          .toSorted();\n        yield* check(\n          JSON.stringify(keys) === JSON.stringify([\"p/a\", \"p/b\", \"p/c\"]),\n          \"Listing lost/duplicated keys\",\n        );\n      }),\n  },\n  {\n    name: \"common-prefixes\",\n    requires: (profile) => profile.list.delimiter,\n    run: (storage) =>\n      Effect.gen(function* () {\n        for (const key of [\"p/a/x\", \"p/a/y\", \"p/b\"])\n          yield* storage.put({ key, body: new Uint8Array() });\n        const page = yield* storage.listPage({ prefix: \"p/\", delimiter: \"/\" });\n        yield* check(\n          page.entries.some((entry) => entry._tag === \"CommonPrefix\" && entry.prefix === \"p/a/\"),\n          \"Missing aggregated common prefix\",\n        );\n        yield* check(\n          page.entries.filter((entry) => entry._tag === \"CommonPrefix\").length === 1,\n          \"Repeated common prefix\",\n        );\n      }),\n  },\n  {\n    name: \"cursor-query-binding\",\n    run: (storage) =>\n      Effect.gen(function* () {\n        for (const key of [\"q/a\", \"q/b\"]) yield* storage.put({ key, body: new Uint8Array() });\n        const page = yield* storage.listPage({ prefix: \"q/\", limit: 1 });\n        if (!page.cursor) return yield* check(false, \"Page omitted required continuation\");\n        yield* expectReason(\n          storage.listPage({ prefix: \"other/\", limit: 1, cursor: page.cursor }),\n          \"InvalidInput\",\n        );\n      }),\n  },\n];\n"],"mappings":";;;;;AAMA,MAAa,YAAmD;CAC9D;EACE,MAAM;EACN,MAAM,YACJ,OAAO,IAAI,aAAa;GACtB,KAAK,MAAM,OAAO;IAAC;IAAO;IAAO;IAAO;GAAW,GACjD,OAAO,QAAQ,IAAI;IAAE;IAAK,sBAAM,IAAI,WAAW;GAAE,CAAC;GAKpD,MAAM,QAAO,OAHU,OAAO,WAC5B,QAAQ,KAAK;IAAE,QAAQ;IAAM,OAAO;GAAE,CAAC,CAAC,CAAC,KAAK,OAAO,eAAe,SAAS,OAAO,CAAC,CACvF,EACoB,CACjB,QAAQ,UAAU,MAAM,SAAS,QAAQ,CAAC,CAC1C,KAAK,UAAU,MAAM,SAAS,IAAI,GAAG,CAAC,CACtC,SAAS;GACZ,OAAO,MACL,KAAK,UAAU,IAAI,MAAM,KAAK,UAAU;IAAC;IAAO;IAAO;GAAK,CAAC,GAC7D,8BACF;EACF,CAAC;CACL;CACA;EACE,MAAM;EACN,WAAW,YAAY,QAAQ,KAAK;EACpC,MAAM,YACJ,OAAO,IAAI,aAAa;GACtB,KAAK,MAAM,OAAO;IAAC;IAAS;IAAS;GAAK,GACxC,OAAO,QAAQ,IAAI;IAAE;IAAK,sBAAM,IAAI,WAAW;GAAE,CAAC;GACpD,MAAM,OAAO,OAAO,QAAQ,SAAS;IAAE,QAAQ;IAAM,WAAW;GAAI,CAAC;GACrE,OAAO,MACL,KAAK,QAAQ,MAAM,UAAU,MAAM,SAAS,kBAAkB,MAAM,WAAW,MAAM,GACrF,kCACF;GACA,OAAO,MACL,KAAK,QAAQ,QAAQ,UAAU,MAAM,SAAS,cAAc,CAAC,CAAC,WAAW,GACzE,wBACF;EACF,CAAC;CACL;CACA;EACE,MAAM;EACN,MAAM,YACJ,OAAO,IAAI,aAAa;GACtB,KAAK,MAAM,OAAO,CAAC,OAAO,KAAK,GAAG,OAAO,QAAQ,IAAI;IAAE;IAAK,sBAAM,IAAI,WAAW;GAAE,CAAC;GACpF,MAAM,OAAO,OAAO,QAAQ,SAAS;IAAE,QAAQ;IAAM,OAAO;GAAE,CAAC;GAC/D,IAAI,CAAC,KAAK,QAAQ,OAAO,OAAO,MAAM,OAAO,oCAAoC;GACjF,OAAO,aACL,QAAQ,SAAS;IAAE,QAAQ;IAAU,OAAO;IAAG,QAAQ,KAAK;GAAO,CAAC,GACpE,cACF;EACF,CAAC;CACL;AACF"}

package/dist/testing/conformance/read-cases.js

@@ -0,0 +1,105 @@
+import { Storage } from "../../core/storage.js";
+import { bytesEqual, check, expectReason } from "./assertions.js";
+import { Effect, Stream } from "effect";
+
+// src/testing/conformance/read-cases.ts
+const readCases = [
+	{
+		name: "single-open-and-suffix-ranges",
+		requires: (profile) => [
+			"bounded",
+			"from",
+			"suffix"
+		].every((kind) => profile.ranges.some((range) => range === kind)),
+		run: (storage) => Effect.gen(function* () {
+			yield* storage.put({
+				key: "range",
+				body: new Uint8Array([
+					0,
+					1,
+					2,
+					3
+				])
+			});
+			for (const [range, expected] of [
+				[{
+					_tag: "Bounded",
+					start: 1,
+					end: 2
+				}, [1, 2]],
+				[{
+					_tag: "From",
+					start: 2
+				}, [2, 3]],
+				[{
+					_tag: "Suffix",
+					length: 2
+				}, [2, 3]]
+			]) {
+				const actual = yield* Storage.getBytes({
+					key: "range",
+					range,
+					maxBytes: 4
+				}).pipe(Effect.provideService(Storage, storage));
+				yield* check(bytesEqual(actual, new Uint8Array(expected)), "Wrong range bytes");
+			}
+			yield* expectReason(storage.get({
+				key: "range",
+				range: {
+					_tag: "From",
+					start: 4
+				}
+			}), "RangeNotSatisfiable");
+		})
+	},
+	{
+		name: "not-modified-is-not-an-empty-body",
+		requires: (profile) => profile.getConditions.includes("if-none-match"),
+		run: (storage) => Effect.gen(function* () {
+			yield* storage.put({
+				key: "cached",
+				body: new Uint8Array([1])
+			});
+			const response = yield* storage.get({
+				key: "cached",
+				condition: {
+					_tag: "IfNoneMatch",
+					etag: "*"
+				}
+			});
+			yield* check(response._tag === "NotModified" && !("body" in response), "Conditional read fabricated a body");
+		})
+	},
+	{
+		name: "body-cannot-outlive-acquisition",
+		run: (storage) => Effect.gen(function* () {
+			yield* storage.put({
+				key: "scoped",
+				body: new Uint8Array([1])
+			});
+			const response = yield* Effect.scoped(storage.get({ key: "scoped" }));
+			if (response._tag !== "Object") return yield* check(false, "Unconditional get did not return an object");
+			yield* expectReason(Stream.runDrain(response.body), "ScopeClosed");
+		})
+	},
+	{
+		name: "explicit-collection-limit",
+		run: (storage) => Effect.gen(function* () {
+			yield* storage.put({
+				key: "large",
+				body: new Uint8Array([
+					1,
+					2,
+					3
+				])
+			});
+			yield* expectReason(Storage.getBytes({
+				key: "large",
+				maxBytes: 2
+			}).pipe(Effect.provideService(Storage, storage)), "LimitExceeded");
+		})
+	}
+];
+
+export { readCases };
+//# sourceMappingURL=read-cases.js.map

package/dist/testing/conformance/read-cases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-cases.js","names":[],"sources":["../../../src/testing/conformance/read-cases.ts"],"sourcesContent":["import { Effect, Stream } from \"effect\";\n\nimport { Storage } from \"../../core/storage.js\";\nimport type { StorageConformanceCase } from \"../conformance.js\";\nimport { bytesEqual, check, expectReason } from \"./assertions.js\";\n\nexport const readCases: ReadonlyArray<StorageConformanceCase> = [\n  {\n    name: \"single-open-and-suffix-ranges\",\n    requires: (profile) =>\n      [\"bounded\", \"from\", \"suffix\"].every((kind) => profile.ranges.some((range) => range === kind)),\n    run: (storage) =>\n      Effect.gen(function* () {\n        yield* storage.put({ key: \"range\", body: new Uint8Array([0, 1, 2, 3]) });\n        for (const [range, expected] of [\n          [{ _tag: \"Bounded\", start: 1, end: 2 }, [1, 2]],\n          [{ _tag: \"From\", start: 2 }, [2, 3]],\n          [{ _tag: \"Suffix\", length: 2 }, [2, 3]],\n        ] as const) {\n          const actual = yield* Storage.getBytes({ key: \"range\", range, maxBytes: 4 }).pipe(\n            Effect.provideService(Storage, storage),\n          );\n          yield* check(bytesEqual(actual, new Uint8Array(expected)), \"Wrong range bytes\");\n        }\n        yield* expectReason(\n          storage.get({ key: \"range\", range: { _tag: \"From\", start: 4 } }),\n          \"RangeNotSatisfiable\",\n        );\n      }),\n  },\n  {\n    name: \"not-modified-is-not-an-empty-body\",\n    requires: (profile) => profile.getConditions.includes(\"if-none-match\"),\n    run: (storage) =>\n      Effect.gen(function* () {\n        yield* storage.put({ key: \"cached\", body: new Uint8Array([1]) });\n        const response = yield* storage.get({\n          key: \"cached\",\n          condition: { _tag: \"IfNoneMatch\", etag: \"*\" },\n        });\n        yield* check(\n          response._tag === \"NotModified\" && !(\"body\" in response),\n          \"Conditional read fabricated a body\",\n        );\n      }),\n  },\n  {\n    name: \"body-cannot-outlive-acquisition\",\n    run: (storage) =>\n      Effect.gen(function* () {\n        yield* storage.put({ key: \"scoped\", body: new Uint8Array([1]) });\n        const response = yield* Effect.scoped(storage.get({ key: \"scoped\" }));\n        if (response._tag !== \"Object\")\n          return yield* check(false, \"Unconditional get did not return an object\");\n        yield* expectReason(Stream.runDrain(response.body), \"ScopeClosed\");\n      }),\n  },\n  {\n    name: \"explicit-collection-limit\",\n    run: (storage) =>\n      Effect.gen(function* () {\n        yield* storage.put({ key: \"large\", body: new Uint8Array([1, 2, 3]) });\n        yield* expectReason(\n          Storage.getBytes({ key: \"large\", maxBytes: 2 }).pipe(\n            Effect.provideService(Storage, storage),\n          ),\n          \"LimitExceeded\",\n        );\n      }),\n  },\n];\n"],"mappings":";;;;;AAMA,MAAa,YAAmD;CAC9D;EACE,MAAM;EACN,WAAW,YACT;GAAC;GAAW;GAAQ;EAAQ,CAAC,CAAC,OAAO,SAAS,QAAQ,OAAO,MAAM,UAAU,UAAU,IAAI,CAAC;EAC9F,MAAM,YACJ,OAAO,IAAI,aAAa;GACtB,OAAO,QAAQ,IAAI;IAAE,KAAK;IAAS,MAAM,IAAI,WAAW;KAAC;KAAG;KAAG;KAAG;IAAC,CAAC;GAAE,CAAC;GACvE,KAAK,MAAM,CAAC,OAAO,aAAa;IAC9B,CAAC;KAAE,MAAM;KAAW,OAAO;KAAG,KAAK;IAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9C,CAAC;KAAE,MAAM;KAAQ,OAAO;IAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;KAAE,MAAM;KAAU,QAAQ;IAAE,GAAG,CAAC,GAAG,CAAC,CAAC;GACxC,GAAY;IACV,MAAM,SAAS,OAAO,QAAQ,SAAS;KAAE,KAAK;KAAS;KAAO,UAAU;IAAE,CAAC,CAAC,CAAC,KAC3E,OAAO,eAAe,SAAS,OAAO,CACxC;IACA,OAAO,MAAM,WAAW,QAAQ,IAAI,WAAW,QAAQ,CAAC,GAAG,mBAAmB;GAChF;GACA,OAAO,aACL,QAAQ,IAAI;IAAE,KAAK;IAAS,OAAO;KAAE,MAAM;KAAQ,OAAO;IAAE;GAAE,CAAC,GAC/D,qBACF;EACF,CAAC;CACL;CACA;EACE,MAAM;EACN,WAAW,YAAY,QAAQ,cAAc,SAAS,eAAe;EACrE,MAAM,YACJ,OAAO,IAAI,aAAa;GACtB,OAAO,QAAQ,IAAI;IAAE,KAAK;IAAU,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC;GAAE,CAAC;GAC/D,MAAM,WAAW,OAAO,QAAQ,IAAI;IAClC,KAAK;IACL,WAAW;KAAE,MAAM;KAAe,MAAM;IAAI;GAC9C,CAAC;GACD,OAAO,MACL,SAAS,SAAS,iBAAiB,EAAE,UAAU,WAC/C,oCACF;EACF,CAAC;CACL;CACA;EACE,MAAM;EACN,MAAM,YACJ,OAAO,IAAI,aAAa;GACtB,OAAO,QAAQ,IAAI;IAAE,KAAK;IAAU,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC;GAAE,CAAC;GAC/D,MAAM,WAAW,OAAO,OAAO,OAAO,QAAQ,IAAI,EAAE,KAAK,SAAS,CAAC,CAAC;GACpE,IAAI,SAAS,SAAS,UACpB,OAAO,OAAO,MAAM,OAAO,4CAA4C;GACzE,OAAO,aAAa,OAAO,SAAS,SAAS,IAAI,GAAG,aAAa;EACnE,CAAC;CACL;CACA;EACE,MAAM;EACN,MAAM,YACJ,OAAO,IAAI,aAAa;GACtB,OAAO,QAAQ,IAAI;IAAE,KAAK;IAAS,MAAM,IAAI,WAAW;KAAC;KAAG;KAAG;IAAC,CAAC;GAAE,CAAC;GACpE,OAAO,aACL,QAAQ,SAAS;IAAE,KAAK;IAAS,UAAU;GAAE,CAAC,CAAC,CAAC,KAC9C,OAAO,eAAe,SAAS,OAAO,CACxC,GACA,eACF;EACF,CAAC;CACL;AACF"}

package/dist/testing/conformance.d.ts

@@ -0,0 +1,23 @@
+import { StorageError } from "../core/errors.js";
+import { StorageCapabilities } from "../core/capabilities.js";
+import { StorageService } from "../core/storage.js";
+import { ConformanceFailure } from "./conformance/assertions.js";
+import { Effect, Scope } from "effect";
+export interface StorageConformanceCase {
+  readonly name: string;
+  readonly requires?: ((profile: StorageCapabilities) => boolean) | undefined;
+  readonly run: (storage: StorageService) => Effect.Effect<void, StorageError | ConformanceFailure, Scope.Scope>;
+}
+export declare const storageConformanceCases: ReadonlyArray<StorageConformanceCase>;
+export type ConformanceResult = {
+  readonly name: string;
+  readonly status: "passed";
+} | {
+  readonly name: string;
+  readonly status: "skipped";
+  readonly reason: string;
+};
+/** Each case owns a fresh scoped fixture; callers own provider resource cleanup. */
+export declare function runStorageConformance<E, R>(makeFixture: () => Effect.Effect<StorageService, E, R>): Effect.Effect<ReadonlyArray<ConformanceResult>, E | ConformanceFailure, Exclude<R, Scope.Scope>>;
+export { ConformanceFailure };
+//# sourceMappingURL=conformance.d.ts.map

package/dist/testing/conformance.js

@@ -0,0 +1,37 @@
+import { ConformanceFailure } from "./conformance/assertions.js";
+import { coreCases } from "./conformance/core-cases.js";
+import { listCases } from "./conformance/list-cases.js";
+import { readCases } from "./conformance/read-cases.js";
+import { Effect } from "effect";
+
+// src/testing/conformance.ts
+const storageConformanceCases = [
+	...coreCases,
+	...readCases,
+	...listCases
+];
+/** Each case owns a fresh scoped fixture; callers own provider resource cleanup. */
+function runStorageConformance(makeFixture) {
+	return Effect.forEach(storageConformanceCases, (test) => Effect.scoped(Effect.gen(function* () {
+		const storage = yield* makeFixture();
+		if (test.requires && !test.requires(storage.capabilities)) return {
+			name: test.name,
+			status: "skipped",
+			reason: "Capability is not advertised by this profile"
+		};
+		yield* test.run(storage).pipe(Effect.catchTag("StorageError", (error) => Effect.fail(new ConformanceFailure({
+			testName: test.name,
+			detail: error.reason._tag
+		}))), Effect.catchTag("ConformanceFailure", (error) => Effect.fail(new ConformanceFailure({
+			testName: test.name,
+			detail: error.detail
+		}))));
+		return {
+			name: test.name,
+			status: "passed"
+		};
+	})));
+}
+
+export { ConformanceFailure, runStorageConformance, storageConformanceCases };
+//# sourceMappingURL=conformance.js.map

package/dist/testing/conformance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conformance.js","names":[],"sources":["../../src/testing/conformance.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport type { Scope } from \"effect\";\n\nimport type { StorageCapabilities } from \"../core/capabilities.js\";\nimport type { StorageError } from \"../core/errors.js\";\nimport type { StorageService } from \"../core/storage.js\";\nimport { ConformanceFailure } from \"./conformance/assertions.js\";\nimport { coreCases } from \"./conformance/core-cases.js\";\nimport { listCases } from \"./conformance/list-cases.js\";\nimport { readCases } from \"./conformance/read-cases.js\";\n\nexport { ConformanceFailure } from \"./conformance/assertions.js\";\n\nexport interface StorageConformanceCase {\n  readonly name: string;\n  readonly requires?: ((profile: StorageCapabilities) => boolean) | undefined;\n  readonly run: (\n    storage: StorageService,\n  ) => Effect.Effect<void, StorageError | ConformanceFailure, Scope.Scope>;\n}\n\nexport const storageConformanceCases: ReadonlyArray<StorageConformanceCase> = [\n  ...coreCases,\n  ...readCases,\n  ...listCases,\n];\n\nexport type ConformanceResult =\n  | { readonly name: string; readonly status: \"passed\" }\n  | { readonly name: string; readonly status: \"skipped\"; readonly reason: string };\n\n/** Each case owns a fresh scoped fixture; callers own provider resource cleanup. */\nexport function runStorageConformance<E, R>(\n  makeFixture: () => Effect.Effect<StorageService, E, R>,\n): Effect.Effect<\n  ReadonlyArray<ConformanceResult>,\n  E | ConformanceFailure,\n  Exclude<R, Scope.Scope>\n> {\n  return Effect.forEach(storageConformanceCases, (test) =>\n    Effect.scoped(\n      Effect.gen(function* () {\n        const storage = yield* makeFixture();\n        if (test.requires && !test.requires(storage.capabilities)) {\n          return {\n            name: test.name,\n            status: \"skipped\",\n            reason: \"Capability is not advertised by this profile\",\n          } as const;\n        }\n        yield* test.run(storage).pipe(\n          Effect.catchTag(\"StorageError\", (error) =>\n            Effect.fail(new ConformanceFailure({ testName: test.name, detail: error.reason._tag })),\n          ),\n          Effect.catchTag(\"ConformanceFailure\", (error) =>\n            Effect.fail(new ConformanceFailure({ testName: test.name, detail: error.detail })),\n          ),\n        );\n        return { name: test.name, status: \"passed\" } as const;\n      }),\n    ),\n  );\n}\n"],"mappings":";;;;;;;AAqBA,MAAa,0BAAiE;CAC5E,GAAG;CACH,GAAG;CACH,GAAG;AACL;;AAOA,SAAgB,sBACd,aAKA;CACA,OAAO,OAAO,QAAQ,0BAA0B,SAC9C,OAAO,OACL,OAAO,IAAI,aAAa;EACtB,MAAM,UAAU,OAAO,YAAY;EACnC,IAAI,KAAK,YAAY,CAAC,KAAK,SAAS,QAAQ,YAAY,GACtD,OAAO;GACL,MAAM,KAAK;GACX,QAAQ;GACR,QAAQ;EACV;EAEF,OAAO,KAAK,IAAI,OAAO,CAAC,CAAC,KACvB,OAAO,SAAS,iBAAiB,UAC/B,OAAO,KAAK,IAAI,mBAAmB;GAAE,UAAU,KAAK;GAAM,QAAQ,MAAM,OAAO;EAAK,CAAC,CAAC,CACxF,GACA,OAAO,SAAS,uBAAuB,UACrC,OAAO,KAAK,IAAI,mBAAmB;GAAE,UAAU,KAAK;GAAM,QAAQ,MAAM;EAAO,CAAC,CAAC,CACnF,CACF;EACA,OAAO;GAAE,MAAM,KAAK;GAAM,QAAQ;EAAS;CAC7C,CAAC,CACH,CACF;AACF"}

package/dist/testing/faults.d.ts

@@ -0,0 +1,258 @@
+import { StorageError } from "../core/errors.js";
+import { StorageService } from "../core/storage.js";
+import { Effect, Schema } from "effect";
+declare namespace faults_d_exports {
+  export { FaultAttempt, FaultController, FaultDiagnostic, FaultStep, make };
+}
+declare const Operation: Schema.Literals<readonly ["put", "get", "head", "delete", "listPage"]>;
+declare const FaultStep: Schema.Struct<{
+  readonly operation: Schema.Literals<readonly ["put", "get", "head", "delete", "listPage"]>;
+  readonly delayMillis: Schema.optional<Schema.Natural>;
+  readonly beforeFailure: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"InvalidInput", {
+    readonly field: Schema.String;
+  }>, Schema.TaggedStruct<"InvalidConfiguration", {
+    readonly field: Schema.String;
+  }>, Schema.TaggedStruct<"Unsupported", {
+    readonly capability: Schema.String;
+  }>, Schema.TaggedStruct<"NotFound", {}>, Schema.TaggedStruct<"AccessDenied", {}>, Schema.TaggedStruct<"PreconditionFailed", {}>, Schema.TaggedStruct<"NotModified", {}>, Schema.TaggedStruct<"RangeNotSatisfiable", {}>, Schema.TaggedStruct<"Expired", {}>, Schema.TaggedStruct<"Throttled", {
+    readonly retryAfterMillis: Schema.optional<Schema.Natural>;
+  }>, Schema.TaggedStruct<"TransportFailure", {
+    readonly code: Schema.optional<Schema.String>;
+  }>, Schema.TaggedStruct<"ProviderFailure", {
+    readonly code: Schema.optional<Schema.String>;
+  }>, Schema.TaggedStruct<"IntegrityMismatch", {}>, Schema.TaggedStruct<"LengthMismatch", {
+    readonly expected: Schema.Natural;
+    readonly actual: Schema.Natural;
+  }>, Schema.TaggedStruct<"LimitExceeded", {
+    readonly limit: Schema.Natural;
+  }>, Schema.TaggedStruct<"InvalidSession", {}>, Schema.TaggedStruct<"QuotaExceeded", {
+    readonly limit: Schema.Natural;
+  }>, Schema.TaggedStruct<"ScopeClosed", {}>, Schema.TaggedStruct<"BodyConsumed", {}>, Schema.TaggedStruct<"PartialFailure", {}>]>>;
+  readonly afterFailure: Schema.optional<Schema.Union<readonly [Schema.TaggedStruct<"InvalidInput", {
+    readonly field: Schema.String;
+  }>, Schema.TaggedStruct<"InvalidConfiguration", {
+    readonly field: Schema.String;
+  }>, Schema.TaggedStruct<"Unsupported", {
+    readonly capability: Schema.String;
+  }>, Schema.TaggedStruct<"NotFound", {}>, Schema.TaggedStruct<"AccessDenied", {}>, Schema.TaggedStruct<"PreconditionFailed", {}>, Schema.TaggedStruct<"NotModified", {}>, Schema.TaggedStruct<"RangeNotSatisfiable", {}>, Schema.TaggedStruct<"Expired", {}>, Schema.TaggedStruct<"Throttled", {
+    readonly retryAfterMillis: Schema.optional<Schema.Natural>;
+  }>, Schema.TaggedStruct<"TransportFailure", {
+    readonly code: Schema.optional<Schema.String>;
+  }>, Schema.TaggedStruct<"ProviderFailure", {
+    readonly code: Schema.optional<Schema.String>;
+  }>, Schema.TaggedStruct<"IntegrityMismatch", {}>, Schema.TaggedStruct<"LengthMismatch", {
+    readonly expected: Schema.Natural;
+    readonly actual: Schema.Natural;
+  }>, Schema.TaggedStruct<"LimitExceeded", {
+    readonly limit: Schema.Natural;
+  }>, Schema.TaggedStruct<"InvalidSession", {}>, Schema.TaggedStruct<"QuotaExceeded", {
+    readonly limit: Schema.Natural;
+  }>, Schema.TaggedStruct<"ScopeClosed", {}>, Schema.TaggedStruct<"BodyConsumed", {}>, Schema.TaggedStruct<"PartialFailure", {}>]>>;
+  readonly bodyFailure: Schema.optional<Schema.Struct<{
+    readonly afterBytes: Schema.Natural;
+    readonly reason: Schema.Union<readonly [Schema.TaggedStruct<"InvalidInput", {
+      readonly field: Schema.String;
+    }>, Schema.TaggedStruct<"InvalidConfiguration", {
+      readonly field: Schema.String;
+    }>, Schema.TaggedStruct<"Unsupported", {
+      readonly capability: Schema.String;
+    }>, Schema.TaggedStruct<"NotFound", {}>, Schema.TaggedStruct<"AccessDenied", {}>, Schema.TaggedStruct<"PreconditionFailed", {}>, Schema.TaggedStruct<"NotModified", {}>, Schema.TaggedStruct<"RangeNotSatisfiable", {}>, Schema.TaggedStruct<"Expired", {}>, Schema.TaggedStruct<"Throttled", {
+      readonly retryAfterMillis: Schema.optional<Schema.Natural>;
+    }>, Schema.TaggedStruct<"TransportFailure", {
+      readonly code: Schema.optional<Schema.String>;
+    }>, Schema.TaggedStruct<"ProviderFailure", {
+      readonly code: Schema.optional<Schema.String>;
+    }>, Schema.TaggedStruct<"IntegrityMismatch", {}>, Schema.TaggedStruct<"LengthMismatch", {
+      readonly expected: Schema.Natural;
+      readonly actual: Schema.Natural;
+    }>, Schema.TaggedStruct<"LimitExceeded", {
+      readonly limit: Schema.Natural;
+    }>, Schema.TaggedStruct<"InvalidSession", {}>, Schema.TaggedStruct<"QuotaExceeded", {
+      readonly limit: Schema.Natural;
+    }>, Schema.TaggedStruct<"ScopeClosed", {}>, Schema.TaggedStruct<"BodyConsumed", {}>, Schema.TaggedStruct<"PartialFailure", {}>]>;
+  }>>;
+  readonly cleanupFailure: Schema.optional<Schema.NonEmptyString>;
+  readonly observerFailure: Schema.optional<Schema.NonEmptyString>;
+}>;
+type FaultStep = typeof FaultStep.Type;
+export interface FaultAttempt {
+  readonly index: number;
+  readonly operation: typeof Operation.Type;
+  readonly status: "started" | "acquired" | "closed" | "succeeded" | "failed" | "interrupted" | "defect";
+}
+export interface FaultDiagnostic {
+  readonly index: number;
+  readonly operation: typeof Operation.Type;
+  readonly kind: "cleanup" | "observer";
+  readonly code: string;
+}
+export interface FaultController {
+  readonly storage: StorageService;
+  readonly attempts: Effect.Effect<ReadonlyArray<FaultAttempt>>;
+  readonly diagnostics: Effect.Effect<ReadonlyArray<FaultDiagnostic>>;
+  readonly assertDone: Effect.Effect<void>;
+}
+export declare const make: (base: StorageService, script: readonly {
+  readonly operation: "delete" | "get" | "head" | "listPage" | "put";
+  readonly delayMillis?: number | undefined;
+  readonly beforeFailure?: {
+    readonly _tag: "InvalidInput";
+    readonly field: string;
+  } | {
+    readonly _tag: "InvalidConfiguration";
+    readonly field: string;
+  } | {
+    readonly _tag: "Unsupported";
+    readonly capability: string;
+  } | {
+    readonly _tag: "NotFound";
+  } | {
+    readonly _tag: "AccessDenied";
+  } | {
+    readonly _tag: "PreconditionFailed";
+  } | {
+    readonly _tag: "NotModified";
+  } | {
+    readonly _tag: "RangeNotSatisfiable";
+  } | {
+    readonly _tag: "Expired";
+  } | {
+    readonly _tag: "Throttled";
+    readonly retryAfterMillis?: number | undefined;
+  } | {
+    readonly _tag: "TransportFailure";
+    readonly code?: string | undefined;
+  } | {
+    readonly _tag: "ProviderFailure";
+    readonly code?: string | undefined;
+  } | {
+    readonly _tag: "IntegrityMismatch";
+  } | {
+    readonly _tag: "LengthMismatch";
+    readonly expected: number;
+    readonly actual: number;
+  } | {
+    readonly _tag: "LimitExceeded";
+    readonly limit: number;
+  } | {
+    readonly _tag: "InvalidSession";
+  } | {
+    readonly _tag: "QuotaExceeded";
+    readonly limit: number;
+  } | {
+    readonly _tag: "ScopeClosed";
+  } | {
+    readonly _tag: "BodyConsumed";
+  } | {
+    readonly _tag: "PartialFailure";
+  } | undefined;
+  readonly afterFailure?: {
+    readonly _tag: "InvalidInput";
+    readonly field: string;
+  } | {
+    readonly _tag: "InvalidConfiguration";
+    readonly field: string;
+  } | {
+    readonly _tag: "Unsupported";
+    readonly capability: string;
+  } | {
+    readonly _tag: "NotFound";
+  } | {
+    readonly _tag: "AccessDenied";
+  } | {
+    readonly _tag: "PreconditionFailed";
+  } | {
+    readonly _tag: "NotModified";
+  } | {
+    readonly _tag: "RangeNotSatisfiable";
+  } | {
+    readonly _tag: "Expired";
+  } | {
+    readonly _tag: "Throttled";
+    readonly retryAfterMillis?: number | undefined;
+  } | {
+    readonly _tag: "TransportFailure";
+    readonly code?: string | undefined;
+  } | {
+    readonly _tag: "ProviderFailure";
+    readonly code?: string | undefined;
+  } | {
+    readonly _tag: "IntegrityMismatch";
+  } | {
+    readonly _tag: "LengthMismatch";
+    readonly expected: number;
+    readonly actual: number;
+  } | {
+    readonly _tag: "LimitExceeded";
+    readonly limit: number;
+  } | {
+    readonly _tag: "InvalidSession";
+  } | {
+    readonly _tag: "QuotaExceeded";
+    readonly limit: number;
+  } | {
+    readonly _tag: "ScopeClosed";
+  } | {
+    readonly _tag: "BodyConsumed";
+  } | {
+    readonly _tag: "PartialFailure";
+  } | undefined;
+  readonly bodyFailure?: {
+    readonly afterBytes: number;
+    readonly reason: {
+      readonly _tag: "InvalidInput";
+      readonly field: string;
+    } | {
+      readonly _tag: "InvalidConfiguration";
+      readonly field: string;
+    } | {
+      readonly _tag: "Unsupported";
+      readonly capability: string;
+    } | {
+      readonly _tag: "NotFound";
+    } | {
+      readonly _tag: "AccessDenied";
+    } | {
+      readonly _tag: "PreconditionFailed";
+    } | {
+      readonly _tag: "NotModified";
+    } | {
+      readonly _tag: "RangeNotSatisfiable";
+    } | {
+      readonly _tag: "Expired";
+    } | {
+      readonly _tag: "Throttled";
+      readonly retryAfterMillis?: number | undefined;
+    } | {
+      readonly _tag: "TransportFailure";
+      readonly code?: string | undefined;
+    } | {
+      readonly _tag: "ProviderFailure";
+      readonly code?: string | undefined;
+    } | {
+      readonly _tag: "IntegrityMismatch";
+    } | {
+      readonly _tag: "LengthMismatch";
+      readonly expected: number;
+      readonly actual: number;
+    } | {
+      readonly _tag: "LimitExceeded";
+      readonly limit: number;
+    } | {
+      readonly _tag: "InvalidSession";
+    } | {
+      readonly _tag: "QuotaExceeded";
+      readonly limit: number;
+    } | {
+      readonly _tag: "ScopeClosed";
+    } | {
+      readonly _tag: "BodyConsumed";
+    } | {
+      readonly _tag: "PartialFailure";
+    };
+  } | undefined;
+  readonly cleanupFailure?: string | undefined;
+  readonly observerFailure?: string | undefined;
+}[]) => Effect.Effect<FaultController, StorageError, never>;
+export { FaultStep, faults_d_exports };
+//# sourceMappingURL=faults.d.ts.map