@effect-kit/storage 0.0.0-stage → 0.1.0

package/dist/providers/azure/properties.js

@@ -0,0 +1,55 @@
+import { storageError } from "../../core/errors.js";
+import { decodeRequest } from "../../internal/request-validation.js";
+import { encryption, lease } from "./config.js";
+import { metadata, nativeHeaders, target } from "./mapping.js";
+import { request } from "./transport.js";
+import { AzureStorage } from "../../azure.js";
+import { MetadataReplace } from "../../lifecycle.js";
+import { replaceHeaders } from "../../lifecycle/metadata.js";
+import { Context, Effect, Layer } from "effect";
+
+// src/providers/azure/properties.ts
+const make = (storage) => ({ 
+/** Azure writes system headers separately from custom metadata. Each operation has its own CAS. */
+setHeaders: Effect.fnUntraced(function* (input) {
+	const value = yield* decodeRequest(MetadataReplace, input, "setHeaders", "azure", true);
+	if (value.ref.version || value.condition?._tag !== "IfMatch" || value.headers.customMetadata) return yield* storageError("setHeaders", "azure", {
+		_tag: "InvalidInput",
+		field: "current-if-match-system-headers"
+	}, "not-started");
+	const address = yield* target(storage, { ref: value.ref }, "setHeaders");
+	const conditions = {
+		ifMatch: value.condition.etag,
+		...lease(storage.config)
+	};
+	const before = yield* request(storage, "setHeaders.head", false, (signal) => address.client.getProperties({
+		abortSignal: signal,
+		conditions,
+		...encryption(storage.config)
+	}));
+	const previous = metadata(storage, value.ref.key, before);
+	const headers = replaceHeaders(previous, value.headers);
+	const output = yield* request(storage, "setHeaders", true, (signal) => address.client.setHTTPHeaders(nativeHeaders(headers), {
+		abortSignal: signal,
+		conditions
+	}));
+	if (!output.etag) return yield* storageError("setHeaders", "azure", {
+		_tag: "ProviderFailure",
+		code: "MissingHeadersReceipt"
+	}, "unknown");
+	return {
+		...metadata(storage, value.ref.key, {
+			...before,
+			versionId: void 0,
+			...output
+		}),
+		...value.headers
+	};
+}) });
+var AzureProperties = class AzureProperties extends Context.Service()("@effect-kit/storage/azure/AzureProperties") {
+	static make = make;
+	static layer = Layer.effect(AzureProperties, Effect.map(AzureStorage, make));
+};
+
+export { AzureProperties };
+//# sourceMappingURL=properties.js.map

package/dist/providers/azure/properties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.js","names":[],"sources":["../../../src/providers/azure/properties.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport { decodeRequest } from \"../../internal/request-validation.js\";\nimport { MetadataReplace } from \"../../lifecycle/index.js\";\nimport { replaceHeaders } from \"../../lifecycle/metadata.js\";\nimport { encryption, lease } from \"./config.js\";\nimport { AzureStorage } from \"./index.js\";\nimport type { AzureStorageService } from \"./index.js\";\nimport { metadata, nativeHeaders, target } from \"./mapping.js\";\nimport { request } from \"./transport.js\";\n\nconst make = (storage: AzureStorageService) => ({\n  /** Azure writes system headers separately from custom metadata. Each operation has its own CAS. */\n  setHeaders: Effect.fnUntraced(function* (input: typeof MetadataReplace.Type) {\n    const value = yield* decodeRequest(MetadataReplace, input, \"setHeaders\", \"azure\", true);\n    if (value.ref.version || value.condition?._tag !== \"IfMatch\" || value.headers.customMetadata)\n      return yield* storageError(\n        \"setHeaders\",\n        \"azure\",\n        { _tag: \"InvalidInput\", field: \"current-if-match-system-headers\" },\n        \"not-started\",\n      );\n    const address = yield* target(storage, { ref: value.ref }, \"setHeaders\");\n    const conditions = { ifMatch: value.condition.etag, ...lease(storage.config) };\n    const before = yield* request(storage, \"setHeaders.head\", false, (signal) =>\n      address.client.getProperties({\n        abortSignal: signal,\n        conditions,\n        ...encryption(storage.config),\n      }),\n    );\n    const previous = metadata(storage, value.ref.key, before);\n    const headers = replaceHeaders(previous, value.headers);\n    const output = yield* request(storage, \"setHeaders\", true, (signal) =>\n      address.client.setHTTPHeaders(nativeHeaders(headers), { abortSignal: signal, conditions }),\n    );\n    if (!output.etag)\n      return yield* storageError(\n        \"setHeaders\",\n        \"azure\",\n        { _tag: \"ProviderFailure\", code: \"MissingHeadersReceipt\" },\n        \"unknown\",\n      );\n    return {\n      ...metadata(storage, value.ref.key, { ...before, versionId: undefined, ...output }),\n      ...value.headers,\n    };\n  }),\n});\nexport class AzureProperties extends Context.Service<AzureProperties, ReturnType<typeof make>>()(\n  \"@effect-kit/storage/azure/AzureProperties\",\n) {\n  static readonly make = make;\n  static readonly layer = Layer.effect(AzureProperties, Effect.map(AzureStorage, make));\n}\n"],"mappings":";;;;;;;;;;;AAYA,MAAM,QAAQ,aAAkC;;AAE9C,YAAY,OAAO,WAAW,WAAW,OAAoC;CAC3E,MAAM,QAAQ,OAAO,cAAc,iBAAiB,OAAO,cAAc,SAAS,IAAI;CACtF,IAAI,MAAM,IAAI,WAAW,MAAM,WAAW,SAAS,aAAa,MAAM,QAAQ,gBAC5E,OAAO,OAAO,aACZ,cACA,SACA;EAAE,MAAM;EAAgB,OAAO;CAAkC,GACjE,aACF;CACF,MAAM,UAAU,OAAO,OAAO,SAAS,EAAE,KAAK,MAAM,IAAI,GAAG,YAAY;CACvE,MAAM,aAAa;EAAE,SAAS,MAAM,UAAU;EAAM,GAAG,MAAM,QAAQ,MAAM;CAAE;CAC7E,MAAM,SAAS,OAAO,QAAQ,SAAS,mBAAmB,QAAQ,WAChE,QAAQ,OAAO,cAAc;EAC3B,aAAa;EACb;EACA,GAAG,WAAW,QAAQ,MAAM;CAC9B,CAAC,CACH;CACA,MAAM,WAAW,SAAS,SAAS,MAAM,IAAI,KAAK,MAAM;CACxD,MAAM,UAAU,eAAe,UAAU,MAAM,OAAO;CACtD,MAAM,SAAS,OAAO,QAAQ,SAAS,cAAc,OAAO,WAC1D,QAAQ,OAAO,eAAe,cAAc,OAAO,GAAG;EAAE,aAAa;EAAQ;CAAW,CAAC,CAC3F;CACA,IAAI,CAAC,OAAO,MACV,OAAO,OAAO,aACZ,cACA,SACA;EAAE,MAAM;EAAmB,MAAM;CAAwB,GACzD,SACF;CACF,OAAO;EACL,GAAG,SAAS,SAAS,MAAM,IAAI,KAAK;GAAE,GAAG;GAAQ,WAAW;GAAW,GAAG;EAAO,CAAC;EAClF,GAAG,MAAM;CACX;AACF,CAAC,EACH;AACA,IAAa,kBAAb,MAAa,wBAAwB,QAAQ,QAAkD,CAAC,CAC9F,2CACF,CAAC,CAAC;CACA,OAAgB,OAAO;CACvB,OAAgB,QAAQ,MAAM,OAAO,iBAAiB,OAAO,IAAI,cAAc,IAAI,CAAC;AACtF"}

package/dist/providers/azure/transport.js

@@ -0,0 +1,14 @@
+import { providerError } from "../../internal/node/provider-errors.js";
+import { Effect } from "effect";
+
+// src/providers/azure/transport.ts
+const request = (connection, operation, mutation, call) => Effect.tryPromise({
+	try: call,
+	catch: (error) => providerError("azure", operation, mutation, error)
+}).pipe(Effect.timeoutOrElse({
+	duration: connection.config.requestTimeoutMillis,
+	orElse: () => Effect.fail(providerError("azure", operation, mutation, void 0))
+}));
+
+export { request };
+//# sourceMappingURL=transport.js.map

package/dist/providers/azure/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","names":[],"sources":["../../../src/providers/azure/transport.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { providerError } from \"../../internal/node/provider-errors.js\";\nimport type { AzureConnection } from \"./config.js\";\n\nexport const request = <A>(\n  connection: AzureConnection,\n  operation: string,\n  mutation: boolean,\n  call: (signal: AbortSignal) => Promise<A>,\n) =>\n  Effect.tryPromise({\n    try: call,\n    catch: (error) => providerError(\"azure\", operation, mutation, error),\n  }).pipe(\n    Effect.timeoutOrElse({\n      duration: connection.config.requestTimeoutMillis,\n      orElse: () => Effect.fail(providerError(\"azure\", operation, mutation, undefined)),\n    }),\n  );\n"],"mappings":";;;;AAKA,MAAa,WACX,YACA,WACA,UACA,SAEA,OAAO,WAAW;CAChB,KAAK;CACL,QAAQ,UAAU,cAAc,SAAS,WAAW,UAAU,KAAK;AACrE,CAAC,CAAC,CAAC,KACD,OAAO,cAAc;CACnB,UAAU,WAAW,OAAO;CAC5B,cAAc,OAAO,KAAK,cAAc,SAAS,WAAW,UAAU,MAAS,CAAC;AAClF,CAAC,CACH"}

package/dist/providers/azure/validation.js

@@ -0,0 +1,11 @@
+import { ObjectKey } from "../../core/object.js";
+import { decodeRequest } from "../../internal/request-validation.js";
+import { Schema } from "effect";
+
+// src/providers/azure/validation.ts
+/** The SDK normalizes dot segments, so accepting them would address a different blob. */
+const AzureKey = ObjectKey.check(Schema.makeFilter((key) => Array.from(key).length <= 1024 && !key.split("/").some((segment) => segment === "." || segment === ".."), { expected: "an Azure blob name within 1024 characters without dot segments" }));
+const validateKey = (key, operation, mutation = false) => decodeRequest(AzureKey, key, operation, "azure", mutation);
+
+export { AzureKey, validateKey };
+//# sourceMappingURL=validation.js.map

package/dist/providers/azure/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","names":[],"sources":["../../../src/providers/azure/validation.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { ObjectKey } from \"../../core/object.js\";\nimport { decodeRequest } from \"../../internal/request-validation.js\";\n\n/** The SDK normalizes dot segments, so accepting them would address a different blob. */\nexport const AzureKey = ObjectKey.check(\n  Schema.makeFilter(\n    (key) =>\n      Array.from(key).length <= 1024 &&\n      !key.split(\"/\").some((segment) => segment === \".\" || segment === \"..\"),\n    { expected: \"an Azure blob name within 1024 characters without dot segments\" },\n  ),\n);\nexport const validateKey = (key: string, operation: string, mutation = false) =>\n  decodeRequest(AzureKey, key, operation, \"azure\", mutation);\n"],"mappings":";;;;;;AAMA,MAAa,WAAW,UAAU,MAChC,OAAO,YACJ,QACC,MAAM,KAAK,GAAG,CAAC,CAAC,UAAU,QAC1B,CAAC,IAAI,MAAM,GAAG,CAAC,CAAC,MAAM,YAAY,YAAY,OAAO,YAAY,IAAI,GACvE,EAAE,UAAU,iEAAiE,CAC/E,CACF;AACA,MAAa,eAAe,KAAa,WAAmB,WAAW,UACrE,cAAc,UAAU,KAAK,WAAW,SAAS,QAAQ"}

package/dist/providers/filesystem/envelope.js

@@ -0,0 +1,56 @@
+import { ObjectMetadata } from "../../core/object.js";
+import { fileError, fileSize } from "./layout.js";
+import { Effect, Option, Schema } from "effect";
+
+// src/providers/filesystem/envelope.ts
+const headerBytes = 65536;
+const magic = new TextEncoder().encode("EFSTOR01");
+const Envelope = Schema.fromJsonString(Schema.Struct({
+	version: Schema.Literal(1),
+	metadata: ObjectMetadata
+}));
+const readExactly = Effect.fnUntraced(function* (file, length, position) {
+	const bytes = new Uint8Array(length);
+	let offset = 0;
+	while (offset < length) {
+		const count = yield* file.read(bytes.subarray(offset), { position: BigInt(position + offset) });
+		if (count === 0) return yield* fileError("get", "TruncatedEnvelope");
+		offset += count;
+	}
+	return bytes;
+});
+const encodeEnvelope = Effect.fnUntraced(function* (metadata) {
+	const encoded = yield* Schema.encodeEffect(Envelope)({
+		version: 1,
+		metadata
+	}).pipe(Effect.mapError(() => fileError("put", "InvalidMetadata", "not-started")));
+	const bytes = new TextEncoder().encode(encoded);
+	if (bytes.length > 65524) return yield* fileError("put", "MetadataTooLarge", "not-started");
+	const header = new Uint8Array(headerBytes);
+	header.set(magic);
+	new DataView(header.buffer).setUint32(8, bytes.length);
+	header.set(bytes, 12);
+	return header;
+});
+const readEnvelope = Effect.fnUntraced(function* (context, file, key) {
+	const prefix = yield* readExactly(file, 12, 0);
+	if (!magic.every((byte, index) => prefix[index] === byte)) return yield* fileError("get", "InvalidEnvelope");
+	const length = new DataView(prefix.buffer).getUint32(8);
+	if (length < 1 || length > 65524) return yield* fileError("get", "InvalidEnvelope");
+	const encoded = yield* readExactly(file, length, 12);
+	const text = yield* Effect.try({
+		try: () => new TextDecoder("utf-8", { fatal: true }).decode(encoded),
+		catch: () => fileError("get", "InvalidEnvelope")
+	});
+	const { metadata } = yield* Schema.decodeUnknownEffect(Envelope)(text).pipe(Effect.mapError(() => fileError("get", "InvalidEnvelope")));
+	if (metadata.ref.storeId !== context.storeId || metadata.ref.version || key !== void 0 && metadata.ref.key !== key || metadata.size === void 0 || !metadata.etag || metadata.checksums?.length !== 1 || metadata.checksums[0]?.algorithm !== "sha256" || metadata.checksums[0]?.scope !== "full-object" || fileSize(yield* file.stat) !== BigInt(65536) + BigInt(metadata.size)) return yield* fileError("get", "InvalidEnvelope");
+	return metadata;
+});
+const readChunk = Effect.fnUntraced(function* (file, position, length) {
+	const bytes = yield* file.readAlloc(length, { position: BigInt(position) });
+	if (Option.isNone(bytes)) return yield* fileError("get", "TruncatedBody");
+	return bytes.value;
+});
+
+export { encodeEnvelope, headerBytes, readChunk, readEnvelope, readExactly };
+//# sourceMappingURL=envelope.js.map

package/dist/providers/filesystem/envelope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.js","names":[],"sources":["../../../src/providers/filesystem/envelope.ts"],"sourcesContent":["import { Effect, Option, Schema } from \"effect\";\nimport type { FileSystem } from \"effect\";\n\nimport { ObjectMetadata } from \"../../core/object.js\";\nimport { fileError, fileSize } from \"./layout.js\";\nimport type { FilesystemContext } from \"./layout.js\";\n\n// One immutable file publishes bytes and metadata together, without sidecar races.\nexport const headerBytes = 65536;\nconst magic = new TextEncoder().encode(\"EFSTOR01\");\nconst Envelope = Schema.fromJsonString(\n  Schema.Struct({ version: Schema.Literal(1), metadata: ObjectMetadata }),\n);\n\nexport const readExactly = Effect.fnUntraced(function* (\n  file: FileSystem.File,\n  length: number,\n  position: number,\n) {\n  const bytes = new Uint8Array(length);\n  let offset = 0;\n  while (offset < length) {\n    const count = yield* file.read(bytes.subarray(offset), { position: BigInt(position + offset) });\n    if (count === 0) return yield* fileError(\"get\", \"TruncatedEnvelope\");\n    offset += count;\n  }\n  return bytes;\n});\n\nexport const encodeEnvelope = Effect.fnUntraced(function* (metadata: ObjectMetadata) {\n  const encoded = yield* Schema.encodeEffect(Envelope)({ version: 1, metadata }).pipe(\n    Effect.mapError(() => fileError(\"put\", \"InvalidMetadata\", \"not-started\")),\n  );\n  const bytes = new TextEncoder().encode(encoded);\n  if (bytes.length > headerBytes - 12)\n    return yield* fileError(\"put\", \"MetadataTooLarge\", \"not-started\");\n  const header = new Uint8Array(headerBytes);\n  header.set(magic);\n  new DataView(header.buffer).setUint32(8, bytes.length);\n  header.set(bytes, 12);\n  return header;\n});\n\nexport const readEnvelope = Effect.fnUntraced(function* (\n  context: FilesystemContext,\n  file: FileSystem.File,\n  key?: string,\n) {\n  const prefix = yield* readExactly(file, 12, 0);\n  if (!magic.every((byte, index) => prefix[index] === byte))\n    return yield* fileError(\"get\", \"InvalidEnvelope\");\n  const length = new DataView(prefix.buffer).getUint32(8);\n  if (length < 1 || length > headerBytes - 12) return yield* fileError(\"get\", \"InvalidEnvelope\");\n  const encoded = yield* readExactly(file, length, 12);\n  const text = yield* Effect.try({\n    try: () => new TextDecoder(\"utf-8\", { fatal: true }).decode(encoded),\n    catch: () => fileError(\"get\", \"InvalidEnvelope\"),\n  });\n  const { metadata } = yield* Schema.decodeUnknownEffect(Envelope)(text).pipe(\n    Effect.mapError(() => fileError(\"get\", \"InvalidEnvelope\")),\n  );\n  if (\n    metadata.ref.storeId !== context.storeId ||\n    metadata.ref.version ||\n    (key !== undefined && metadata.ref.key !== key) ||\n    metadata.size === undefined ||\n    !metadata.etag ||\n    metadata.checksums?.length !== 1 ||\n    metadata.checksums[0]?.algorithm !== \"sha256\" ||\n    metadata.checksums[0]?.scope !== \"full-object\" ||\n    fileSize(yield* file.stat) !== BigInt(headerBytes) + BigInt(metadata.size)\n  )\n    return yield* fileError(\"get\", \"InvalidEnvelope\");\n  return metadata;\n});\n\nexport const readChunk = Effect.fnUntraced(function* (\n  file: FileSystem.File,\n  position: number,\n  length: number,\n) {\n  const bytes = yield* file.readAlloc(length, { position: BigInt(position) });\n  if (Option.isNone(bytes)) return yield* fileError(\"get\", \"TruncatedBody\");\n  return bytes.value;\n});\n"],"mappings":";;;;;AAQA,MAAa,cAAc;AAC3B,MAAM,QAAQ,IAAI,YAAY,CAAC,CAAC,OAAO,UAAU;AACjD,MAAM,WAAW,OAAO,eACtB,OAAO,OAAO;CAAE,SAAS,OAAO,QAAQ,CAAC;CAAG,UAAU;AAAe,CAAC,CACxE;AAEA,MAAa,cAAc,OAAO,WAAW,WAC3C,MACA,QACA,UACA;CACA,MAAM,QAAQ,IAAI,WAAW,MAAM;CACnC,IAAI,SAAS;CACb,OAAO,SAAS,QAAQ;EACtB,MAAM,QAAQ,OAAO,KAAK,KAAK,MAAM,SAAS,MAAM,GAAG,EAAE,UAAU,OAAO,WAAW,MAAM,EAAE,CAAC;EAC9F,IAAI,UAAU,GAAG,OAAO,OAAO,UAAU,OAAO,mBAAmB;EACnE,UAAU;CACZ;CACA,OAAO;AACT,CAAC;AAED,MAAa,iBAAiB,OAAO,WAAW,WAAW,UAA0B;CACnF,MAAM,UAAU,OAAO,OAAO,aAAa,QAAQ,CAAC,CAAC;EAAE,SAAS;EAAG;CAAS,CAAC,CAAC,CAAC,KAC7E,OAAO,eAAe,UAAU,OAAO,mBAAmB,aAAa,CAAC,CAC1E;CACA,MAAM,QAAQ,IAAI,YAAY,CAAC,CAAC,OAAO,OAAO;CAC9C,IAAI,MAAM,SAAS,OACjB,OAAO,OAAO,UAAU,OAAO,oBAAoB,aAAa;CAClE,MAAM,SAAS,IAAI,WAAW,WAAW;CACzC,OAAO,IAAI,KAAK;CAChB,IAAI,SAAS,OAAO,MAAM,CAAC,CAAC,UAAU,GAAG,MAAM,MAAM;CACrD,OAAO,IAAI,OAAO,EAAE;CACpB,OAAO;AACT,CAAC;AAED,MAAa,eAAe,OAAO,WAAW,WAC5C,SACA,MACA,KACA;CACA,MAAM,SAAS,OAAO,YAAY,MAAM,IAAI,CAAC;CAC7C,IAAI,CAAC,MAAM,OAAO,MAAM,UAAU,OAAO,WAAW,IAAI,GACtD,OAAO,OAAO,UAAU,OAAO,iBAAiB;CAClD,MAAM,SAAS,IAAI,SAAS,OAAO,MAAM,CAAC,CAAC,UAAU,CAAC;CACtD,IAAI,SAAS,KAAK,SAAS,OAAkB,OAAO,OAAO,UAAU,OAAO,iBAAiB;CAC7F,MAAM,UAAU,OAAO,YAAY,MAAM,QAAQ,EAAE;CACnD,MAAM,OAAO,OAAO,OAAO,IAAI;EAC7B,WAAW,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC,OAAO,OAAO;EACnE,aAAa,UAAU,OAAO,iBAAiB;CACjD,CAAC;CACD,MAAM,EAAE,aAAa,OAAO,OAAO,oBAAoB,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,KACrE,OAAO,eAAe,UAAU,OAAO,iBAAiB,CAAC,CAC3D;CACA,IACE,SAAS,IAAI,YAAY,QAAQ,WACjC,SAAS,IAAI,WACZ,QAAQ,UAAa,SAAS,IAAI,QAAQ,OAC3C,SAAS,SAAS,UAClB,CAAC,SAAS,QACV,SAAS,WAAW,WAAW,KAC/B,SAAS,UAAU,EAAE,EAAE,cAAc,YACrC,SAAS,UAAU,EAAE,EAAE,UAAU,iBACjC,SAAS,OAAO,KAAK,IAAI,MAAM,YAAkB,IAAI,OAAO,SAAS,IAAI,GAEzE,OAAO,OAAO,UAAU,OAAO,iBAAiB;CAClD,OAAO;AACT,CAAC;AAED,MAAa,YAAY,OAAO,WAAW,WACzC,MACA,UACA,QACA;CACA,MAAM,QAAQ,OAAO,KAAK,UAAU,QAAQ,EAAE,UAAU,OAAO,QAAQ,EAAE,CAAC;CAC1E,IAAI,OAAO,OAAO,KAAK,GAAG,OAAO,OAAO,UAAU,OAAO,eAAe;CACxE,OAAO,MAAM;AACf,CAAC"}

package/dist/providers/filesystem/identity.js

@@ -0,0 +1,68 @@
+import { storageError } from "../../core/errors.js";
+import { syncDirectory } from "../../runtime/filesystem.js";
+import { ByteSize, Effect, Schema } from "effect";
+
+// src/providers/filesystem/identity.ts
+const Identity = Schema.fromJsonString(Schema.Struct({
+	version: Schema.Literal(1),
+	storeId: Schema.NonEmptyString,
+	id: Schema.NonEmptyString
+}));
+/** A root is bound to one format/store identity; reopening with another identity fails closed. */
+const invalid = () => storageError("make", "filesystem", {
+	_tag: "InvalidConfiguration",
+	field: "root.identity"
+});
+const initializeIdentity = Effect.fnUntraced(function* (fs, path, root, storeId, random) {
+	const filename = path.join(root, "format.json");
+	if (!(yield* fs.exists(filename))) {
+		if ((yield* fs.readDirectory(root)).some((name) => name !== "objects" && name !== "staging" && name !== "format.json") || (yield* fs.readDirectory(path.join(root, "objects"))).length) {
+			if (!(yield* fs.exists(filename))) return yield* invalid();
+		}
+		const temporary = path.join(root, "staging", `upload-${yield* random.uuidV4()}.pending`);
+		const encoded = Schema.encodeSync(Identity)({
+			version: 1,
+			storeId,
+			id: yield* random.uuidV4()
+		});
+		yield* Effect.acquireUseRelease(Effect.succeed(temporary), () => Effect.gen(function* () {
+			yield* Effect.scoped(Effect.gen(function* () {
+				const file = yield* fs.open(temporary, {
+					flag: "wx",
+					mode: 384,
+					noFollow: true
+				});
+				yield* file.writeAll(new TextEncoder().encode(encoded));
+				yield* file.sync;
+			}));
+			yield* fs.link(temporary, filename).pipe(Effect.catchReason("PlatformError", "AlreadyExists", () => Effect.void));
+			yield* syncDirectory(fs, root);
+		}), () => fs.remove(temporary, { force: true }).pipe(Effect.orDie)).pipe(Effect.uninterruptible);
+	}
+	const identity = yield* Effect.scoped(Effect.gen(function* () {
+		if ((yield* fs.lstat(filename)).type !== "File") return yield* invalid();
+		const file = yield* fs.open(filename, {
+			flag: "r",
+			noFollow: true
+		});
+		const length = Number(ByteSize.toBigInt((yield* file.stat).size));
+		if (length < 1 || length > 16384) return yield* invalid();
+		const bytes = new Uint8Array(length);
+		let offset = 0;
+		while (offset < length) {
+			const count = yield* file.read(bytes.subarray(offset));
+			if (count === 0) return yield* invalid();
+			offset += count;
+		}
+		const text = yield* Effect.try({
+			try: () => new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+			catch: invalid
+		});
+		return yield* Schema.decodeUnknownEffect(Identity)(text).pipe(Effect.mapError(invalid));
+	}));
+	if (identity.storeId !== storeId) return yield* invalid();
+	return identity.id;
+});
+
+export { initializeIdentity };
+//# sourceMappingURL=identity.js.map

package/dist/providers/filesystem/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","names":[],"sources":["../../../src/providers/filesystem/identity.ts"],"sourcesContent":["import { ByteSize, Effect, Schema } from \"effect\";\nimport type { FileSystem, Path } from \"effect\";\nimport type { SecureRandom } from \"effect/crypto\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport { syncDirectory } from \"../../runtime/filesystem.js\";\n\nconst Identity = Schema.fromJsonString(\n  Schema.Struct({\n    version: Schema.Literal(1),\n    storeId: Schema.NonEmptyString,\n    id: Schema.NonEmptyString,\n  }),\n);\n\n/** A root is bound to one format/store identity; reopening with another identity fails closed. */\nconst invalid = () =>\n  storageError(\"make\", \"filesystem\", { _tag: \"InvalidConfiguration\", field: \"root.identity\" });\n\nexport const initializeIdentity = Effect.fnUntraced(function* (\n  fs: FileSystem.FileSystem,\n  path: Path.Path,\n  root: string,\n  storeId: string,\n  random: SecureRandom.SecureRandom[\"Service\"],\n) {\n  const filename = path.join(root, \"format.json\");\n  if (!(yield* fs.exists(filename))) {\n    const names = yield* fs.readDirectory(root);\n    if (\n      names.some((name) => name !== \"objects\" && name !== \"staging\" && name !== \"format.json\") ||\n      (yield* fs.readDirectory(path.join(root, \"objects\"))).length\n    ) {\n      if (!(yield* fs.exists(filename))) return yield* invalid();\n    }\n    const temporary = path.join(root, \"staging\", `upload-${yield* random.uuidV4()}.pending`);\n    const encoded = Schema.encodeSync(Identity)({\n      version: 1,\n      storeId,\n      id: yield* random.uuidV4(),\n    });\n    yield* Effect.acquireUseRelease(\n      Effect.succeed(temporary),\n      () =>\n        Effect.gen(function* () {\n          yield* Effect.scoped(\n            Effect.gen(function* () {\n              const file = yield* fs.open(temporary, { flag: \"wx\", mode: 0o600, noFollow: true });\n              yield* file.writeAll(new TextEncoder().encode(encoded));\n              yield* file.sync;\n            }),\n          );\n          yield* fs\n            .link(temporary, filename)\n            .pipe(Effect.catchReason(\"PlatformError\", \"AlreadyExists\", () => Effect.void));\n          yield* syncDirectory(fs, root);\n        }),\n      () => fs.remove(temporary, { force: true }).pipe(Effect.orDie),\n    ).pipe(Effect.uninterruptible);\n  }\n  const identity = yield* Effect.scoped(\n    Effect.gen(function* () {\n      if ((yield* fs.lstat(filename)).type !== \"File\") return yield* invalid();\n      const file = yield* fs.open(filename, { flag: \"r\", noFollow: true });\n      const length = Number(ByteSize.toBigInt((yield* file.stat).size));\n      if (length < 1 || length > 16384) return yield* invalid();\n      const bytes = new Uint8Array(length);\n      let offset = 0;\n      while (offset < length) {\n        const count = yield* file.read(bytes.subarray(offset));\n        if (count === 0) return yield* invalid();\n        offset += count;\n      }\n      const text = yield* Effect.try({\n        try: () => new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes),\n        catch: invalid,\n      });\n      return yield* Schema.decodeUnknownEffect(Identity)(text).pipe(Effect.mapError(invalid));\n    }),\n  );\n  if (identity.storeId !== storeId) return yield* invalid();\n  return identity.id;\n});\n"],"mappings":";;;;;AAOA,MAAM,WAAW,OAAO,eACtB,OAAO,OAAO;CACZ,SAAS,OAAO,QAAQ,CAAC;CACzB,SAAS,OAAO;CAChB,IAAI,OAAO;AACb,CAAC,CACH;;AAGA,MAAM,gBACJ,aAAa,QAAQ,cAAc;CAAE,MAAM;CAAwB,OAAO;AAAgB,CAAC;AAE7F,MAAa,qBAAqB,OAAO,WAAW,WAClD,IACA,MACA,MACA,SACA,QACA;CACA,MAAM,WAAW,KAAK,KAAK,MAAM,aAAa;CAC9C,IAAI,EAAE,OAAO,GAAG,OAAO,QAAQ,IAAI;EAEjC,KACE,OAFmB,GAAG,cAAc,IAAI,EAEnC,CAAC,MAAM,SAAS,SAAS,aAAa,SAAS,aAAa,SAAS,aAAa,MACtF,OAAO,GAAG,cAAc,KAAK,KAAK,MAAM,SAAS,CAAC,EAAC,CAAE,QAEtD;OAAI,EAAE,OAAO,GAAG,OAAO,QAAQ,IAAI,OAAO,OAAO,QAAQ;EAAC;EAE5D,MAAM,YAAY,KAAK,KAAK,MAAM,WAAW,UAAU,OAAO,OAAO,OAAO,EAAE,SAAS;EACvF,MAAM,UAAU,OAAO,WAAW,QAAQ,CAAC,CAAC;GAC1C,SAAS;GACT;GACA,IAAI,OAAO,OAAO,OAAO;EAC3B,CAAC;EACD,OAAO,OAAO,kBACZ,OAAO,QAAQ,SAAS,SAEtB,OAAO,IAAI,aAAa;GACtB,OAAO,OAAO,OACZ,OAAO,IAAI,aAAa;IACtB,MAAM,OAAO,OAAO,GAAG,KAAK,WAAW;KAAE,MAAM;KAAM,MAAM;KAAO,UAAU;IAAK,CAAC;IAClF,OAAO,KAAK,SAAS,IAAI,YAAY,CAAC,CAAC,OAAO,OAAO,CAAC;IACtD,OAAO,KAAK;GACd,CAAC,CACH;GACA,OAAO,GACJ,KAAK,WAAW,QAAQ,CAAC,CACzB,KAAK,OAAO,YAAY,iBAAiB,uBAAuB,OAAO,IAAI,CAAC;GAC/E,OAAO,cAAc,IAAI,IAAI;EAC/B,CAAC,SACG,GAAG,OAAO,WAAW,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK,CAC/D,CAAC,CAAC,KAAK,OAAO,eAAe;CAC/B;CACA,MAAM,WAAW,OAAO,OAAO,OAC7B,OAAO,IAAI,aAAa;EACtB,KAAK,OAAO,GAAG,MAAM,QAAQ,EAAC,CAAE,SAAS,QAAQ,OAAO,OAAO,QAAQ;EACvE,MAAM,OAAO,OAAO,GAAG,KAAK,UAAU;GAAE,MAAM;GAAK,UAAU;EAAK,CAAC;EACnE,MAAM,SAAS,OAAO,SAAS,UAAU,OAAO,KAAK,KAAI,CAAE,IAAI,CAAC;EAChE,IAAI,SAAS,KAAK,SAAS,OAAO,OAAO,OAAO,QAAQ;EACxD,MAAM,QAAQ,IAAI,WAAW,MAAM;EACnC,IAAI,SAAS;EACb,OAAO,SAAS,QAAQ;GACtB,MAAM,QAAQ,OAAO,KAAK,KAAK,MAAM,SAAS,MAAM,CAAC;GACrD,IAAI,UAAU,GAAG,OAAO,OAAO,QAAQ;GACvC,UAAU;EACZ;EACA,MAAM,OAAO,OAAO,OAAO,IAAI;GAC7B,WAAW,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK;GACjE,OAAO;EACT,CAAC;EACD,OAAO,OAAO,OAAO,oBAAoB,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,OAAO,SAAS,OAAO,CAAC;CACxF,CAAC,CACH;CACA,IAAI,SAAS,YAAY,SAAS,OAAO,OAAO,QAAQ;CACxD,OAAO,SAAS;AAClB,CAAC"}

package/dist/providers/filesystem/layout.d.ts

@@ -0,0 +1,15 @@
+import "../../core/errors.js";
+import "../../index.js";
+import "../../transfers/models.js";
+import "../../transfers/dependencies.js";
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { Digest, SecureRandom } from "effect/crypto";
+import { PlatformError } from "effect/PlatformError";
+export declare const FilesystemOptions: Schema.Struct<{
+  readonly root: Schema.NonEmptyString;
+  readonly storeId: Schema.NonEmptyString;
+  readonly maxObjectBytes: Schema.optional<Schema.Natural>;
+  readonly maxListEntries: Schema.optional<Schema.Int>;
+}>;
+export type FilesystemOptions = typeof FilesystemOptions.Type;
+//# sourceMappingURL=layout.d.ts.map

package/dist/providers/filesystem/layout.js

@@ -0,0 +1,112 @@
+import { storageError } from "../../core/errors.js";
+import { TransferHash } from "../../transfers/dependencies.js";
+import { syncDirectory } from "../../runtime/filesystem.js";
+import { initializeIdentity } from "./identity.js";
+import { ByteSize, Effect, FileSystem, Path, Schema } from "effect";
+import { Digest, SecureRandom } from "effect/crypto";
+
+// src/providers/filesystem/layout.ts
+const FilesystemOptions = Schema.Struct({
+	root: Schema.NonEmptyString,
+	storeId: Schema.NonEmptyString,
+	maxObjectBytes: Schema.optional(Schema.Natural.check(Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER - 65536))),
+	maxListEntries: Schema.optional(Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 1e6
+	})))
+});
+const fileError = (operation, code, outcome = "not-applicable") => storageError(operation, "filesystem", {
+	_tag: "ProviderFailure",
+	code
+}, outcome);
+const mapIO = (operation, outcome = "not-applicable") => (error) => {
+	const reason = error.reason._tag;
+	return storageError(operation, "filesystem", reason === "NotFound" ? { _tag: "NotFound" } : reason === "PermissionDenied" ? { _tag: "AccessDenied" } : {
+		_tag: "ProviderFailure",
+		code: reason
+	}, outcome);
+};
+const makeLayout = Effect.fnUntraced(function* (options) {
+	const input = yield* Schema.decodeUnknownEffect(FilesystemOptions, { onExcessProperty: "error" })(options).pipe(Effect.mapError(() => storageError("make", "filesystem", {
+		_tag: "InvalidConfiguration",
+		field: "options"
+	})));
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const identities = yield* Digest.Digest;
+	const random = yield* SecureRandom.SecureRandom;
+	const hash = yield* TransferHash;
+	if (hash.algorithm !== "sha256") return yield* storageError("make", "filesystem", {
+		_tag: "InvalidConfiguration",
+		field: "TransferHash.algorithm"
+	});
+	const assertDirectory = Effect.fnUntraced(function* (directory) {
+		if ((yield* fs.lstat(directory)).type !== "Directory") return yield* fileError("filesystem.directory", "UnsafeDirectory");
+	});
+	const suppliedRoot = path.resolve(input.root);
+	if (yield* fs.exists(suppliedRoot)) yield* assertDirectory(suppliedRoot);
+	const missing = [];
+	let ancestor = suppliedRoot;
+	while (!(yield* fs.exists(ancestor))) {
+		missing.push(ancestor);
+		if (path.dirname(ancestor) === ancestor) break;
+		ancestor = path.dirname(ancestor);
+	}
+	yield* fs.makeDirectory(suppliedRoot, {
+		recursive: true,
+		mode: 448
+	}).pipe(Effect.mapError(mapIO("make")));
+	for (const created of missing) yield* syncDirectory(fs, created).pipe(Effect.mapError(mapIO("make")));
+	if (missing.length) yield* syncDirectory(fs, ancestor).pipe(Effect.mapError(mapIO("make")));
+	const root = yield* fs.realPath(suppliedRoot).pipe(Effect.mapError(mapIO("make")));
+	const objects = path.join(root, "objects");
+	const staging = path.join(root, "staging");
+	for (const directory of [objects, staging]) {
+		yield* fs.makeDirectory(directory, { mode: 448 }).pipe(Effect.catchReason("PlatformError", "AlreadyExists", () => Effect.void), Effect.mapError(mapIO("make")));
+		yield* assertDirectory(directory).pipe(Effect.mapError((error) => error._tag === "PlatformError" ? mapIO("make")(error) : error));
+	}
+	yield* syncDirectory(fs, root).pipe(Effect.mapError(mapIO("make")));
+	const rootId = yield* initializeIdentity(fs, path, root, input.storeId, random);
+	const checkDirectories = Effect.all([
+		assertDirectory(root),
+		assertDirectory(objects),
+		assertDirectory(staging)
+	], { discard: true }).pipe(Effect.mapError((error) => error._tag === "PlatformError" ? mapIO("filesystem.directory")(error) : error));
+	const objectFilename = (key) => identities.digestHex(Digest.sha256, new TextEncoder().encode(key)).pipe(Effect.map((digest) => path.join(objects, `${digest}.object`)));
+	const regularFile = Effect.fnUntraced(function* (filename) {
+		const info = yield* fs.lstat(filename);
+		if (info.type !== "File") return yield* fileError("filesystem.open", "UnsafeObject");
+		return info;
+	});
+	const open = Effect.fnUntraced(function* (filename) {
+		yield* checkDirectories;
+		yield* regularFile(filename);
+		const file = yield* fs.open(filename, {
+			flag: "r",
+			noFollow: true
+		});
+		if ((yield* file.stat).type !== "File") return yield* fileError("filesystem.open", "UnsafeObject");
+		return file;
+	});
+	return {
+		fs,
+		path,
+		root,
+		rootId,
+		objects,
+		staging,
+		storeId: input.storeId,
+		random,
+		hash,
+		filename: objectFilename,
+		open,
+		regularFile,
+		checkDirectories,
+		maxObjectBytes: input.maxObjectBytes ?? 1073741824,
+		maxListEntries: input.maxListEntries ?? 1e4
+	};
+});
+const fileSize = (info) => ByteSize.toBigInt(info.size);
+
+export { FilesystemOptions, fileError, fileSize, makeLayout, mapIO };
+//# sourceMappingURL=layout.js.map

package/dist/providers/filesystem/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","names":[],"sources":["../../../src/providers/filesystem/layout.ts"],"sourcesContent":["import { ByteSize, Effect, FileSystem, Path, Schema } from \"effect\";\nimport { Digest, SecureRandom } from \"effect/crypto\";\nimport type { PlatformError } from \"effect/PlatformError\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport type { MutationOutcome } from \"../../core/errors.js\";\nimport { syncDirectory } from \"../../runtime/filesystem.js\";\nimport { TransferHash } from \"../../transfers/dependencies.js\";\nimport { initializeIdentity } from \"./identity.js\";\n\nexport const FilesystemOptions = Schema.Struct({\n  root: Schema.NonEmptyString,\n  storeId: Schema.NonEmptyString,\n  maxObjectBytes: Schema.optional(\n    Schema.Natural.check(Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER - 65536)),\n  ),\n  maxListEntries: Schema.optional(\n    Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1000000 })),\n  ),\n});\nexport type FilesystemOptions = typeof FilesystemOptions.Type;\n\nexport const fileError = (\n  operation: string,\n  code: string,\n  outcome: MutationOutcome = \"not-applicable\",\n) => storageError(operation, \"filesystem\", { _tag: \"ProviderFailure\", code }, outcome);\n\nexport const mapIO =\n  (operation: string, outcome: MutationOutcome = \"not-applicable\") =>\n  (error: PlatformError) => {\n    const reason = error.reason._tag;\n    return storageError(\n      operation,\n      \"filesystem\",\n      reason === \"NotFound\"\n        ? { _tag: \"NotFound\" }\n        : reason === \"PermissionDenied\"\n          ? { _tag: \"AccessDenied\" }\n          : { _tag: \"ProviderFailure\", code: reason },\n      outcome,\n    );\n  };\n\nexport const makeLayout = Effect.fnUntraced(function* (options: FilesystemOptions) {\n  const input = yield* Schema.decodeUnknownEffect(FilesystemOptions, { onExcessProperty: \"error\" })(\n    options,\n  ).pipe(\n    Effect.mapError(() =>\n      storageError(\"make\", \"filesystem\", { _tag: \"InvalidConfiguration\", field: \"options\" }),\n    ),\n  );\n  const fs = yield* FileSystem.FileSystem;\n  const path = yield* Path.Path;\n  const identities = yield* Digest.Digest;\n  const random = yield* SecureRandom.SecureRandom;\n  const hash = yield* TransferHash;\n  if (hash.algorithm !== \"sha256\")\n    return yield* storageError(\"make\", \"filesystem\", {\n      _tag: \"InvalidConfiguration\",\n      field: \"TransferHash.algorithm\",\n    });\n\n  const assertDirectory = Effect.fnUntraced(function* (directory: string) {\n    const info = yield* fs.lstat(directory);\n    if (info.type !== \"Directory\")\n      return yield* fileError(\"filesystem.directory\", \"UnsafeDirectory\");\n  });\n  const suppliedRoot = path.resolve(input.root);\n  if (yield* fs.exists(suppliedRoot)) yield* assertDirectory(suppliedRoot);\n  const missing: string[] = [];\n  let ancestor = suppliedRoot;\n  while (!(yield* fs.exists(ancestor))) {\n    missing.push(ancestor);\n    if (path.dirname(ancestor) === ancestor) break;\n    ancestor = path.dirname(ancestor);\n  }\n  yield* fs\n    .makeDirectory(suppliedRoot, { recursive: true, mode: 0o700 })\n    .pipe(Effect.mapError(mapIO(\"make\")));\n  for (const created of missing)\n    yield* syncDirectory(fs, created).pipe(Effect.mapError(mapIO(\"make\")));\n  if (missing.length) yield* syncDirectory(fs, ancestor).pipe(Effect.mapError(mapIO(\"make\")));\n  const root = yield* fs.realPath(suppliedRoot).pipe(Effect.mapError(mapIO(\"make\")));\n  const objects = path.join(root, \"objects\");\n  const staging = path.join(root, \"staging\");\n  for (const directory of [objects, staging]) {\n    yield* fs.makeDirectory(directory, { mode: 0o700 }).pipe(\n      Effect.catchReason(\"PlatformError\", \"AlreadyExists\", () => Effect.void),\n      Effect.mapError(mapIO(\"make\")),\n    );\n    yield* assertDirectory(directory).pipe(\n      Effect.mapError((error) => (error._tag === \"PlatformError\" ? mapIO(\"make\")(error) : error)),\n    );\n  }\n  yield* syncDirectory(fs, root).pipe(Effect.mapError(mapIO(\"make\")));\n\n  const rootId = yield* initializeIdentity(fs, path, root, input.storeId, random);\n\n  const checkDirectories = Effect.all(\n    [assertDirectory(root), assertDirectory(objects), assertDirectory(staging)],\n    { discard: true },\n  ).pipe(\n    Effect.mapError((error) =>\n      error._tag === \"PlatformError\" ? mapIO(\"filesystem.directory\")(error) : error,\n    ),\n  );\n  const objectFilename = (key: string) =>\n    identities\n      .digestHex(Digest.sha256, new TextEncoder().encode(key))\n      .pipe(Effect.map((digest) => path.join(objects, `${digest}.object`)));\n  const regularFile = Effect.fnUntraced(function* (filename: string) {\n    const info = yield* fs.lstat(filename);\n    if (info.type !== \"File\") return yield* fileError(\"filesystem.open\", \"UnsafeObject\");\n    return info;\n  });\n  const open = Effect.fnUntraced(function* (filename: string) {\n    yield* checkDirectories;\n    yield* regularFile(filename);\n    const file = yield* fs.open(filename, { flag: \"r\", noFollow: true });\n    if ((yield* file.stat).type !== \"File\")\n      return yield* fileError(\"filesystem.open\", \"UnsafeObject\");\n    return file;\n  });\n\n  return {\n    fs,\n    path,\n    root,\n    rootId,\n    objects,\n    staging,\n    storeId: input.storeId,\n    random,\n    hash,\n    filename: objectFilename,\n    open,\n    regularFile,\n    checkDirectories,\n    maxObjectBytes: input.maxObjectBytes ?? 1024 * 1024 * 1024,\n    maxListEntries: input.maxListEntries ?? 10000,\n  };\n});\nexport type FilesystemContext = Effect.Success<ReturnType<typeof makeLayout>>;\nexport const fileSize = (info: FileSystem.File.Info) => ByteSize.toBigInt(info.size);\n"],"mappings":"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"}

package/dist/providers/filesystem/list.js

@@ -0,0 +1,82 @@
+import { storageError } from "../../core/errors.js";
+import { mapIO } from "./layout.js";
+import { readEnvelope } from "./envelope.js";
+import { Effect, Schema } from "effect";
+import { Base64Url } from "effect/encoding";
+
+// src/providers/filesystem/list.ts
+const Cursor = Schema.fromJsonString(Schema.Struct({
+	version: Schema.Literal(1),
+	root: Schema.String,
+	storeId: Schema.String,
+	prefix: Schema.String,
+	delimiter: Schema.NullOr(Schema.String),
+	limit: Schema.Natural,
+	after: Schema.String
+}));
+const invalid = () => storageError("listPage", "filesystem", {
+	_tag: "InvalidInput",
+	field: "cursor"
+});
+const list = Effect.fnUntraced(function* (context, request = {}) {
+	const { prefix = "", delimiter, limit = 100 } = request;
+	let after;
+	if (request.cursor) {
+		if (request.cursor.length > 32768) return yield* invalid();
+		const text = yield* Effect.fromResult(Base64Url.decodeString(request.cursor)).pipe(Effect.mapError(invalid));
+		const cursor = yield* Schema.decodeUnknownEffect(Cursor)(text).pipe(Effect.mapError(invalid));
+		if (cursor.root !== context.rootId || cursor.storeId !== context.storeId || cursor.prefix !== prefix || cursor.delimiter !== (delimiter ?? null) || cursor.limit !== limit) return yield* invalid();
+		after = cursor.after;
+	}
+	yield* context.checkDirectories;
+	const names = yield* context.fs.readDirectory(context.objects).pipe(Effect.mapError(mapIO("listPage")));
+	if (names.length > context.maxListEntries) return yield* storageError("listPage", "filesystem", {
+		_tag: "LimitExceeded",
+		limit: context.maxListEntries
+	});
+	const entries = /* @__PURE__ */ new Map();
+	for (const name of names) {
+		if (!/^[a-f0-9]{64}\.object$/u.test(name)) continue;
+		const filename = context.path.join(context.objects, name);
+		const metadata = yield* Effect.scoped(Effect.gen(function* () {
+			const file = yield* context.open(filename);
+			const saved = yield* readEnvelope(context, file);
+			if ((yield* context.filename(saved.ref.key)) !== filename) return yield* invalid();
+			return saved;
+		})).pipe(Effect.mapError((error) => error._tag === "PlatformError" ? mapIO("listPage")(error) : error), Effect.catchReason("StorageError", "NotFound", () => Effect.undefined));
+		if (!metadata || !metadata.ref.key.startsWith(prefix)) continue;
+		const key = metadata.ref.key;
+		const index = delimiter ? key.indexOf(delimiter, prefix.length) : -1;
+		if (delimiter && index >= 0) {
+			const common = key.slice(0, index + delimiter.length);
+			entries.set(common, {
+				_tag: "CommonPrefix",
+				prefix: common
+			});
+		} else entries.set(key, {
+			_tag: "Object",
+			metadata
+		});
+	}
+	const sorted = [...entries.keys()].toSorted().filter((key) => after === void 0 || key > after);
+	const keys = sorted.slice(0, limit);
+	const last = keys.at(-1);
+	return {
+		entries: keys.flatMap((key) => {
+			const entry = entries.get(key);
+			return entry ? [entry] : [];
+		}),
+		...last !== void 0 && sorted.length > limit ? { cursor: Base64Url.encode(Schema.encodeSync(Cursor)({
+			version: 1,
+			root: context.rootId,
+			storeId: context.storeId,
+			prefix,
+			delimiter: delimiter ?? null,
+			limit,
+			after: last
+		})) } : {}
+	};
+});
+
+export { list };
+//# sourceMappingURL=list.js.map

package/dist/providers/filesystem/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","names":[],"sources":["../../../src/providers/filesystem/list.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\nimport { Base64Url } from \"effect/encoding\";\n\nimport type { StorageError } from \"../../core/errors.js\";\nimport { storageError } from \"../../core/errors.js\";\nimport type { ListEntry, ListPage, ListRequest } from \"../../core/requests.js\";\nimport { readEnvelope } from \"./envelope.js\";\nimport { mapIO } from \"./layout.js\";\nimport type { FilesystemContext } from \"./layout.js\";\n\nconst Cursor = Schema.fromJsonString(\n  Schema.Struct({\n    version: Schema.Literal(1),\n    root: Schema.String,\n    storeId: Schema.String,\n    prefix: Schema.String,\n    delimiter: Schema.NullOr(Schema.String),\n    limit: Schema.Natural,\n    after: Schema.String,\n  }),\n);\n\nconst invalid = () =>\n  storageError(\"listPage\", \"filesystem\", { _tag: \"InvalidInput\", field: \"cursor\" });\n\nexport const list = Effect.fnUntraced(function* (\n  context: FilesystemContext,\n  request: ListRequest = {},\n): Effect.fn.Return<ListPage, StorageError> {\n  const { prefix = \"\", delimiter, limit = 100 } = request;\n  let after: string | undefined;\n  if (request.cursor) {\n    if (request.cursor.length > 32768) return yield* invalid();\n    const text = yield* Effect.fromResult(Base64Url.decodeString(request.cursor)).pipe(\n      Effect.mapError(invalid),\n    );\n    const cursor = yield* Schema.decodeUnknownEffect(Cursor)(text).pipe(Effect.mapError(invalid));\n    if (\n      cursor.root !== context.rootId ||\n      cursor.storeId !== context.storeId ||\n      cursor.prefix !== prefix ||\n      cursor.delimiter !== (delimiter ?? null) ||\n      cursor.limit !== limit\n    )\n      return yield* invalid();\n    after = cursor.after;\n  }\n  yield* context.checkDirectories;\n  // readDirectory allocates an array. This profile deliberately documents O(directory) scans.\n  const names = yield* context.fs\n    .readDirectory(context.objects)\n    .pipe(Effect.mapError(mapIO(\"listPage\")));\n  if (names.length > context.maxListEntries)\n    return yield* storageError(\"listPage\", \"filesystem\", {\n      _tag: \"LimitExceeded\",\n      limit: context.maxListEntries,\n    });\n  const entries = new Map<string, ListEntry>();\n  for (const name of names) {\n    if (!/^[a-f0-9]{64}\\.object$/u.test(name)) continue;\n    const filename = context.path.join(context.objects, name);\n    const metadata = yield* Effect.scoped(\n      Effect.gen(function* () {\n        const file = yield* context.open(filename);\n        const saved = yield* readEnvelope(context, file);\n        if ((yield* context.filename(saved.ref.key)) !== filename) return yield* invalid();\n        return saved;\n      }),\n    ).pipe(\n      Effect.mapError((error) =>\n        error._tag === \"PlatformError\" ? mapIO(\"listPage\")(error) : error,\n      ),\n      Effect.catchReason(\"StorageError\", \"NotFound\", () => Effect.undefined),\n    );\n    if (!metadata || !metadata.ref.key.startsWith(prefix)) continue;\n    const key = metadata.ref.key;\n    const index = delimiter ? key.indexOf(delimiter, prefix.length) : -1;\n    if (delimiter && index >= 0) {\n      const common = key.slice(0, index + delimiter.length);\n      entries.set(common, { _tag: \"CommonPrefix\", prefix: common });\n    } else entries.set(key, { _tag: \"Object\", metadata });\n  }\n  const sorted = [...entries.keys()].toSorted().filter((key) => after === undefined || key > after);\n  const keys = sorted.slice(0, limit);\n  const last = keys.at(-1);\n  return {\n    entries: keys.flatMap((key) => {\n      const entry = entries.get(key);\n      return entry ? [entry] : [];\n    }),\n    ...(last !== undefined && sorted.length > limit\n      ? {\n          cursor: Base64Url.encode(\n            Schema.encodeSync(Cursor)({\n              version: 1,\n              root: context.rootId,\n              storeId: context.storeId,\n              prefix,\n              delimiter: delimiter ?? null,\n              limit,\n              after: last,\n            }),\n          ),\n        }\n      : {}),\n  };\n});\n"],"mappings":"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"}

package/dist/providers/filesystem/operations.js

@@ -0,0 +1,134 @@
+import { storageError } from "../../core/errors.js";
+import { resolveRange } from "../../core/ranges.js";
+import { syncDirectory } from "../../runtime/filesystem.js";
+import { mapIO } from "./layout.js";
+import { encodeEnvelope, headerBytes, readChunk, readEnvelope } from "./envelope.js";
+import { Cause, DateTime, Effect, Predicate, Stream } from "effect";
+
+// src/providers/filesystem/operations.ts
+const head = Effect.fnUntraced(function* (context, request) {
+	const key = "ref" in request ? request.ref.key : request.key;
+	return yield* Effect.scoped(Effect.gen(function* () {
+		const file = yield* context.open(yield* context.filename(key));
+		return yield* readEnvelope(context, file, key);
+	})).pipe(Effect.mapError((error) => error._tag === "PlatformError" ? mapIO("head")(error) : error));
+});
+const get = Effect.fnUntraced(function* (context, request) {
+	const key = "ref" in request ? request.ref.key : request.key;
+	const file = yield* context.open(yield* context.filename(key)).pipe(Effect.mapError((error) => error._tag === "PlatformError" ? mapIO("get")(error) : error));
+	const metadata = yield* readEnvelope(context, file, key).pipe(Effect.mapError((error) => error._tag === "PlatformError" ? mapIO("get")(error) : error));
+	if (request.condition?._tag === "IfMatch" && request.condition.etag !== "*" && request.condition.etag !== metadata.etag) return yield* storageError("get", "filesystem", { _tag: "PreconditionFailed" });
+	if (request.condition?._tag === "IfNoneMatch" && (request.condition.etag === "*" || request.condition.etag === metadata.etag)) return {
+		_tag: "NotModified",
+		metadata
+	};
+	const size = metadata.size ?? 0;
+	const range = request.range ? yield* Effect.fromResult(resolveRange(request.range, size, "filesystem")) : void 0;
+	const start = range?.start ?? 0;
+	const length = range ? range.end - range.start + 1 : size;
+	let offset = 0;
+	return {
+		_tag: "Object",
+		metadata,
+		body: Stream.fromPull(Effect.succeed(Effect.gen(function* () {
+			if (offset >= length) return yield* Cause.done();
+			const bytes = yield* readChunk(file, headerBytes + start + offset, Math.min(65536, length - offset)).pipe(Effect.mapError((error) => error._tag === "PlatformError" ? mapIO("get")(error) : error));
+			offset += bytes.length;
+			return [bytes];
+		}))),
+		contentLength: length,
+		range
+	};
+});
+const put = Effect.fnUntraced(function* (context, request) {
+	const { fs, path } = context;
+	const headers = {
+		contentType: request.contentType,
+		contentEncoding: request.contentEncoding,
+		contentLanguage: request.contentLanguage,
+		contentDisposition: request.contentDisposition,
+		cacheControl: request.cacheControl,
+		customMetadata: request.customMetadata ? { ...request.customMetadata } : void 0
+	};
+	const limit = Math.min(context.maxObjectBytes, request.maxBytes ?? context.maxObjectBytes);
+	if (new TextEncoder().encode(request.key).length > 4096) return yield* storageError("put", "filesystem", {
+		_tag: "InvalidInput",
+		field: "key"
+	}, "not-started");
+	if (new TextEncoder().encode(JSON.stringify(headers)).length > 32768) return yield* storageError("put", "filesystem", {
+		_tag: "InvalidInput",
+		field: "metadata"
+	}, "not-started");
+	if (request.contentLength !== void 0 && request.contentLength > limit) return yield* storageError("put", "filesystem", {
+		_tag: "LimitExceeded",
+		limit
+	}, "not-started");
+	yield* context.checkDirectories;
+	const destination = yield* context.filename(request.key);
+	const temporary = path.join(context.staging, `upload-${yield* context.random.uuidV4()}.pending`);
+	let outcome = "not-started";
+	const map = (error) => mapIO("put", outcome)(error);
+	return yield* Effect.acquireUseRelease(Effect.succeed(temporary), () => Effect.gen(function* () {
+		const metadata = yield* Effect.scoped(Effect.gen(function* () {
+			const file = yield* fs.open(temporary, {
+				flag: "wx+",
+				mode: 384,
+				noFollow: true
+			}).pipe(Effect.mapError(map));
+			yield* file.seek(BigInt(headerBytes), "start").pipe(Effect.mapError(map));
+			const hash = context.hash.create();
+			let length = 0;
+			const source = Predicate.isUint8Array(request.body) ? Stream.succeed(request.body) : request.body;
+			yield* Stream.runForEach(source, (chunk) => Effect.gen(function* () {
+				if (!Predicate.isUint8Array(chunk)) return yield* storageError("put", "filesystem", {
+					_tag: "InvalidInput",
+					field: "body"
+				}, "not-started");
+				if (chunk.length > limit - length) return yield* storageError("put", "filesystem", {
+					_tag: "LimitExceeded",
+					limit
+				}, "not-started");
+				for (let offset = 0; offset < chunk.length; offset += 65536) {
+					const bytes = chunk.subarray(offset, offset + 65536);
+					hash.update(bytes);
+					yield* file.writeAll(bytes).pipe(Effect.uninterruptible, Effect.mapError(map));
+				}
+				length += chunk.length;
+			}));
+			if (request.contentLength !== void 0 && request.contentLength !== length) return yield* storageError("put", "filesystem", {
+				_tag: "LengthMismatch",
+				expected: request.contentLength,
+				actual: length
+			}, "not-started");
+			const saved = {
+				...headers,
+				ref: {
+					storeId: context.storeId,
+					key: request.key
+				},
+				size: length,
+				etag: `"${yield* context.random.uuidV4()}"`,
+				lastModified: yield* DateTime.now,
+				checksums: [hash.finish()]
+			};
+			const header = yield* encodeEnvelope(saved);
+			yield* file.seek(0n, "start").pipe(Effect.mapError(map));
+			yield* file.writeAll(header).pipe(Effect.uninterruptible, Effect.mapError(map));
+			yield* file.sync.pipe(Effect.uninterruptible, Effect.mapError(map));
+			return saved;
+		}));
+		yield* Effect.gen(function* () {
+			yield* context.checkDirectories;
+			yield* context.regularFile(destination).pipe(Effect.asVoid, Effect.catchReason("PlatformError", "NotFound", () => Effect.void), Effect.mapError((error) => error._tag === "PlatformError" ? map(error) : error));
+			outcome = "unknown";
+			if (request.condition?._tag === "CreateOnly") yield* fs.link(temporary, destination).pipe(Effect.catchReason("PlatformError", "AlreadyExists", () => storageError("put", "filesystem", { _tag: "PreconditionFailed" }, "rejected")), Effect.mapError((error) => error._tag === "PlatformError" ? map(error) : error));
+			else yield* fs.rename(temporary, destination).pipe(Effect.mapError(map));
+			yield* syncDirectory(fs, context.objects).pipe(Effect.mapError(map));
+			outcome = "succeeded";
+		}).pipe(Effect.uninterruptible);
+		return metadata;
+	}), () => fs.remove(temporary, { force: true }).pipe(Effect.andThen(syncDirectory(fs, context.staging)), Effect.mapError(map), Effect.orDie));
+});
+
+export { get, head, put };
+//# sourceMappingURL=operations.js.map