@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/content.js

@@ -0,0 +1,168 @@
+import { digestText } from "./runtime/portable-hash.js";
+import { Storage } from "./core/storage.js";
+import { replayable } from "./transfers/sources.js";
+import { Transfers } from "./transfers.js";
+import { makeRecordStore, workflowError } from "./workflows/store.js";
+import { deletePinned, hashObject, headOptional, pin } from "./workflows/objects.js";
+import { makeStaging } from "./composition/representation/staging.js";
+import { CollectionPlan, ContentId, ContentRecord } from "./workflows/content/schema.js";
+import { contentKey, makeReferences } from "./workflows/content/references.js";
+import { makeCollection } from "./workflows/content/collection.js";
+import { Clock, Context, Effect, Layer, Schema } from "effect";
+import { SecureRandom } from "effect/crypto";
+
+// src/workflows/content/index.ts
+var ContentReferenceStore = class ContentReferenceStore extends Context.Service()("@effect-kit/storage/ContentReferenceStore") {
+	static make(options) {
+		return makeRecordStore(options, "content");
+	}
+	static layer(options) {
+		return Layer.effect(ContentReferenceStore, ContentReferenceStore.make(options));
+	}
+};
+const marker = "effect-storage-content";
+const make = Effect.fnUntraced(function* (options) {
+	const store = yield* ContentReferenceStore;
+	const storage = yield* Storage;
+	const random = yield* SecureRandom.SecureRandom;
+	const stage = yield* makeStaging;
+	const minimumRetention = options.minimumRetentionMillis ?? 864e5;
+	if (!options.configurationId || !/^[A-Za-z0-9_-]{1,100}$/u.test(options.namespace) || options.algorithm !== void 0 && options.algorithm !== "sha256" || !Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1 || !Number.isSafeInteger(minimumRetention) || minimumRetention < 1 || !storage.capabilities.putConditions.includes("create-only")) return yield* workflowError("InvalidContentConfiguration");
+	const transfers = yield* Transfers.make({
+		...options.transfer,
+		maxBytes: options.maxBytes
+	});
+	const binding = digestText(JSON.stringify([
+		options.configurationId,
+		storage.storeId,
+		options.namespace,
+		"sha256"
+	]));
+	yield* store.exclusive(Effect.gen(function* () {
+		const existing = yield* store.read("configuration", Schema.String);
+		if (existing && existing !== binding) return yield* workflowError("ReferenceStoreConfigurationConflict");
+		if (!existing) yield* store.write("configuration", Schema.String, binding);
+	}));
+	const references = makeReferences(store, binding, storage, random);
+	const collection = makeCollection(store, binding, storage, references, random, minimumRetention);
+	const physicalKey = (record) => `${options.namespace}/sha256/${record.id}/${record.generation}`;
+	const verify = Effect.fnUntraced(function* (record, metadata) {
+		if (metadata.ref.storeId !== storage.storeId || metadata.ref.key !== physicalKey(record) || metadata.customMetadata?.[marker] !== binding) return yield* workflowError("ForeignContentObject");
+		const actual = yield* hashObject(storage, metadata);
+		if (actual.sha256 !== record.id || actual.size !== record.size) return yield* workflowError("ContentVerificationFailed");
+		return metadata;
+	});
+	const reconcile = Effect.fnUntraced(function* (id) {
+		const record = yield* references.load(id);
+		if (record.state === "ready" || record.state === "deleted") return record;
+		if (record.state === "deleting") {
+			if (!record.object || (yield* references.reachable(record))) return record;
+			yield* deletePinned(storage, record.object);
+			const deleted = {
+				...record,
+				state: "deleted"
+			};
+			yield* store.write(contentKey(id), ContentRecord, deleted);
+			return deleted;
+		}
+		const observed = yield* headOptional(storage, physicalKey(record));
+		if (!observed) return record;
+		const object = yield* verify(record, observed);
+		const ready = {
+			...record,
+			state: "ready",
+			object
+		};
+		yield* store.write(contentKey(id), ContentRecord, ready);
+		return ready;
+	});
+	const put = (request) => store.exclusive(Effect.scoped(Effect.gen(function* () {
+		const staged = yield* stage(request.source.open(), options.maxBytes);
+		if (request.source.length !== void 0 && request.source.length !== staged.size) return yield* workflowError("SourceLengthMismatch");
+		const id = staged.checksum.value;
+		let record = yield* store.read(contentKey(id), ContentRecord);
+		if (record && record.binding !== binding) return yield* workflowError("ContentConfigurationConflict");
+		if (record?.state === "deleting") return yield* workflowError("ContentDeletionPending");
+		if (record?.state === "ready" && record.object) yield* verify(record, yield* storage.head({ ref: record.object.ref }));
+		else {
+			if (!record || record.state === "deleted") {
+				const generation = (record?.generation ?? 0) + 1;
+				const next = {
+					id,
+					binding,
+					generation,
+					state: "writing",
+					size: staged.size,
+					createdAt: yield* Clock.currentTimeMillis,
+					retainUntil: (yield* Clock.currentTimeMillis) + minimumRetention,
+					edgeCount: record?.edgeCount ?? 0
+				};
+				if (yield* headOptional(storage, physicalKey(next))) return yield* workflowError("UnreservedDigestKey");
+				const sequence = (yield* store.read("content-sequence", Schema.Natural)) ?? 0;
+				yield* store.write("content-sequence", Schema.Natural, sequence + 1);
+				yield* store.write(`content-index:${sequence + 1}`, Schema.String, id);
+				yield* store.write(contentKey(id), ContentRecord, next);
+				record = next;
+			}
+			record = yield* reconcile(id);
+			if (record.state !== "ready") {
+				yield* transfers.upload({
+					key: physicalKey(record),
+					source: replayable(() => staged.stream(), staged.size),
+					expectedChecksum: staged.checksum,
+					condition: { _tag: "CreateOnly" },
+					headers: {
+						contentType: "application/octet-stream",
+						customMetadata: { [marker]: binding }
+					}
+				});
+				record = yield* reconcile(id);
+			}
+		}
+		const object = record.object;
+		if (!object || record.state !== "ready") return yield* workflowError("ContentOutcomeUnknown");
+		record = {
+			...record,
+			retainUntil: (yield* Clock.currentTimeMillis) + minimumRetention
+		};
+		yield* store.write(contentKey(id), ContentRecord, record);
+		if (request.reference !== void 0) yield* references.update(request.reference, id);
+		return {
+			id,
+			metadata: object,
+			size: record.size,
+			checksum: staged.checksum
+		};
+	})));
+	return {
+		put,
+		head: (id) => store.exclusive(Effect.gen(function* () {
+			const record = yield* references.load(id);
+			if (record.state !== "ready" || !record.object) return yield* workflowError("ContentNotReady");
+			return yield* storage.head({ ref: record.object.ref });
+		})),
+		get: (id) => store.exclusive(Effect.gen(function* () {
+			const record = yield* references.load(id);
+			if (record.state !== "ready" || !record.object) return yield* workflowError("ContentNotReady");
+			return yield* storage.get(yield* pin(record.object));
+		})),
+		status: (id) => store.exclusive(references.load(id)),
+		reconcile: (id) => store.exclusive(reconcile(id)),
+		attach: (request) => store.exclusive(references.update(request.reference, request.contentId, request.replace)),
+		detach: (request) => store.exclusive(references.update(request.reference)),
+		references: (id, page) => store.exclusive(references.inspect(id, page)),
+		reconcileReference: (reference) => store.exclusive(references.reconcile(reference)),
+		planGarbageCollection: (request) => store.exclusive(collection.plan(request)),
+		inspectGarbageCollection: (id, page) => store.exclusive(collection.inspect(id, page)),
+		applyGarbageCollection: (id, batch) => store.exclusive(collection.apply(id, batch))
+	};
+});
+var ContentStore = class ContentStore extends Context.Service()("@effect-kit/storage/ContentStore") {
+	static make = make;
+	static layer(options) {
+		return Layer.effect(ContentStore, make(options));
+	}
+};
+
+export { CollectionPlan, ContentId, ContentRecord, ContentReferenceStore, ContentStore };
+//# sourceMappingURL=content.js.map

package/dist/content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.js","names":["UploadSource.replayable"],"sources":["../src/workflows/content/index.ts"],"sourcesContent":["import { Clock, Context, Effect, Layer, Schema } from \"effect\";\nimport { SecureRandom } from \"effect/crypto\";\n\nimport { makeStaging } from \"../../composition/representation/staging.js\";\nimport type { ObjectMetadata } from \"../../core/object.js\";\nimport { Storage } from \"../../core/storage.js\";\nimport { digestText } from \"../../runtime/portable-hash.js\";\nimport { Transfers, UploadSource } from \"../../transfers/index.js\";\nimport type { UploadSourceType, TransferPolicy } from \"../../transfers/index.js\";\nimport { deletePinned, hashObject, headOptional, pin } from \"../objects.js\";\nimport { makeRecordStore, workflowError } from \"../store.js\";\nimport type { RecordStore, WorkflowStoreOptions } from \"../store.js\";\nimport { makeCollection } from \"./collection.js\";\nimport { contentKey, makeReferences } from \"./references.js\";\nimport { ContentRecord } from \"./schema.js\";\n\nexport { ContentId, ContentRecord, CollectionPlan } from \"./schema.js\";\nexport type { WorkflowStoreOptions as ContentReferenceStoreOptions } from \"../store.js\";\nexport class ContentReferenceStore extends Context.Service<ContentReferenceStore, RecordStore>()(\n  \"@effect-kit/storage/ContentReferenceStore\",\n) {\n  static make(options: WorkflowStoreOptions) {\n    return makeRecordStore(options, \"content\");\n  }\n  static layer(options: WorkflowStoreOptions) {\n    return Layer.effect(ContentReferenceStore, ContentReferenceStore.make(options));\n  }\n}\nexport interface ContentStoreOptions {\n  readonly configurationId: string;\n  readonly namespace: string;\n  readonly algorithm?: \"sha256\";\n  readonly maxBytes: number;\n  readonly minimumRetentionMillis?: number;\n  readonly transfer?: TransferPolicy;\n}\nconst marker = \"effect-storage-content\";\nconst make = Effect.fnUntraced(function* (options: ContentStoreOptions) {\n  const store = yield* ContentReferenceStore;\n  const storage = yield* Storage;\n  const random = yield* SecureRandom.SecureRandom;\n  const stage = yield* makeStaging;\n  const minimumRetention = options.minimumRetentionMillis ?? 86400000;\n  if (\n    !options.configurationId ||\n    !/^[A-Za-z0-9_-]{1,100}$/u.test(options.namespace) ||\n    (options.algorithm !== undefined && options.algorithm !== \"sha256\") ||\n    !Number.isSafeInteger(options.maxBytes) ||\n    options.maxBytes < 1 ||\n    !Number.isSafeInteger(minimumRetention) ||\n    minimumRetention < 1 ||\n    !storage.capabilities.putConditions.includes(\"create-only\")\n  )\n    return yield* workflowError(\"InvalidContentConfiguration\");\n  const transfers = yield* Transfers.make({ ...options.transfer, maxBytes: options.maxBytes });\n  const binding = digestText(\n    JSON.stringify([options.configurationId, storage.storeId, options.namespace, \"sha256\"]),\n  );\n  yield* store.exclusive(\n    Effect.gen(function* () {\n      const existing = yield* store.read(\"configuration\", Schema.String);\n      if (existing && existing !== binding)\n        return yield* workflowError(\"ReferenceStoreConfigurationConflict\");\n      if (!existing) yield* store.write(\"configuration\", Schema.String, binding);\n    }),\n  );\n  const references = makeReferences(store, binding, storage, random);\n  const collection = makeCollection(store, binding, storage, references, random, minimumRetention);\n  const physicalKey = (record: ContentRecord) =>\n    `${options.namespace}/sha256/${record.id}/${record.generation}`;\n  const verify = Effect.fnUntraced(function* (record: ContentRecord, metadata: ObjectMetadata) {\n    if (\n      metadata.ref.storeId !== storage.storeId ||\n      metadata.ref.key !== physicalKey(record) ||\n      metadata.customMetadata?.[marker] !== binding\n    )\n      return yield* workflowError(\"ForeignContentObject\");\n    const actual = yield* hashObject(storage, metadata);\n    if (actual.sha256 !== record.id || actual.size !== record.size)\n      return yield* workflowError(\"ContentVerificationFailed\");\n    return metadata;\n  });\n  const reconcile = Effect.fnUntraced(function* (id: string) {\n    const record = yield* references.load(id);\n    if (record.state === \"ready\" || record.state === \"deleted\") return record;\n    if (record.state === \"deleting\") {\n      if (!record.object || (yield* references.reachable(record))) return record;\n      yield* deletePinned(storage, record.object);\n      const deleted: ContentRecord = { ...record, state: \"deleted\" };\n      yield* store.write(contentKey(id), ContentRecord, deleted);\n      return deleted;\n    }\n    const observed = yield* headOptional(storage, physicalKey(record));\n    if (!observed) return record;\n    const object = yield* verify(record, observed);\n    const ready: ContentRecord = { ...record, state: \"ready\", object };\n    yield* store.write(contentKey(id), ContentRecord, ready);\n    return ready;\n  });\n  const put = <E = never, R = never>(request: {\n    readonly source: UploadSourceType<E, R>;\n    readonly reference?: string;\n  }) =>\n    store.exclusive(\n      Effect.scoped(\n        Effect.gen(function* () {\n          const staged = yield* stage(request.source.open(), options.maxBytes);\n          if (request.source.length !== undefined && request.source.length !== staged.size)\n            return yield* workflowError(\"SourceLengthMismatch\");\n          const id = staged.checksum.value;\n          let record = yield* store.read(contentKey(id), ContentRecord);\n          if (record && record.binding !== binding)\n            return yield* workflowError(\"ContentConfigurationConflict\");\n          if (record?.state === \"deleting\") return yield* workflowError(\"ContentDeletionPending\");\n          if (record?.state === \"ready\" && record.object)\n            yield* verify(record, yield* storage.head({ ref: record.object.ref }));\n          else {\n            if (!record || record.state === \"deleted\") {\n              const generation = (record?.generation ?? 0) + 1;\n              const next: ContentRecord = {\n                id,\n                binding,\n                generation,\n                state: \"writing\",\n                size: staged.size,\n                createdAt: yield* Clock.currentTimeMillis,\n                retainUntil: (yield* Clock.currentTimeMillis) + minimumRetention,\n                edgeCount: record?.edgeCount ?? 0,\n              };\n              if (yield* headOptional(storage, physicalKey(next)))\n                return yield* workflowError(\"UnreservedDigestKey\");\n              const sequence = (yield* store.read(\"content-sequence\", Schema.Natural)) ?? 0;\n              yield* store.write(\"content-sequence\", Schema.Natural, sequence + 1);\n              yield* store.write(`content-index:${sequence + 1}`, Schema.String, id);\n              yield* store.write(contentKey(id), ContentRecord, next);\n              record = next;\n            }\n            record = yield* reconcile(id);\n            if (record.state !== \"ready\") {\n              yield* transfers.upload({\n                key: physicalKey(record),\n                source: UploadSource.replayable(() => staged.stream(), staged.size),\n                expectedChecksum: staged.checksum,\n                condition: { _tag: \"CreateOnly\" },\n                headers: {\n                  contentType: \"application/octet-stream\",\n                  customMetadata: { [marker]: binding },\n                },\n              });\n              record = yield* reconcile(id);\n            }\n          }\n          const object = record.object;\n          if (!object || record.state !== \"ready\")\n            return yield* workflowError(\"ContentOutcomeUnknown\");\n          record = { ...record, retainUntil: (yield* Clock.currentTimeMillis) + minimumRetention };\n          yield* store.write(contentKey(id), ContentRecord, record);\n          if (request.reference !== undefined) yield* references.update(request.reference, id);\n          return { id, metadata: object, size: record.size, checksum: staged.checksum };\n        }),\n      ),\n    );\n  return {\n    put,\n    head: (id: string) =>\n      store.exclusive(\n        Effect.gen(function* () {\n          const record = yield* references.load(id);\n          if (record.state !== \"ready\" || !record.object)\n            return yield* workflowError(\"ContentNotReady\");\n          return yield* storage.head({ ref: record.object.ref });\n        }),\n      ),\n    get: (id: string) =>\n      store.exclusive(\n        Effect.gen(function* () {\n          const record = yield* references.load(id);\n          if (record.state !== \"ready\" || !record.object)\n            return yield* workflowError(\"ContentNotReady\");\n          return yield* storage.get(yield* pin(record.object));\n        }),\n      ),\n    status: (id: string) => store.exclusive(references.load(id)),\n    reconcile: (id: string) => store.exclusive(reconcile(id)),\n    attach: (request: {\n      readonly contentId: string;\n      readonly reference: string;\n      readonly replace?: boolean;\n    }) => store.exclusive(references.update(request.reference, request.contentId, request.replace)),\n    detach: (request: { readonly reference: string }) =>\n      store.exclusive(references.update(request.reference)),\n    references: (id: string, page?: { readonly offset?: number; readonly limit?: number }) =>\n      store.exclusive(references.inspect(id, page)),\n    reconcileReference: (reference: string) => store.exclusive(references.reconcile(reference)),\n    planGarbageCollection: (request: { readonly olderThan: number }) =>\n      store.exclusive(collection.plan(request)),\n    inspectGarbageCollection: (\n      id: string,\n      page?: { readonly offset?: number; readonly limit?: number },\n    ) => store.exclusive(collection.inspect(id, page)),\n    applyGarbageCollection: (id: string, batch?: { readonly limit?: number }) =>\n      store.exclusive(collection.apply(id, batch)),\n  };\n});\nexport class ContentStore extends Context.Service<\n  ContentStore,\n  Effect.Success<ReturnType<typeof make>>\n>()(\"@effect-kit/storage/ContentStore\") {\n  static readonly make = make;\n  static layer(options: ContentStoreOptions) {\n    return Layer.effect(ContentStore, make(options));\n  }\n}\n"],"mappings":"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"}

package/dist/core/capabilities.d.ts

@@ -0,0 +1,53 @@
+import { ObjectMetadata, ObjectRef } from "./object.js";
+import { StorageError } from "./errors.js";
+import { WriteCondition } from "./requests.js";
+import { Context, DateTime, Effect, Redacted } from "effect";
+export interface StorageCapabilities {
+  readonly putConditions: ReadonlyArray<"create-only" | "if-match">;
+  readonly getConditions: ReadonlyArray<"if-match" | "if-none-match">;
+  readonly deleteConditions: ReadonlyArray<"if-match">;
+  readonly ranges: ReadonlyArray<"bounded" | "from" | "suffix">;
+  readonly versionedReads: "none" | "current-only" | "history";
+  readonly list: {
+    readonly maxPageSize: number;
+    readonly delimiter: boolean;
+    readonly cursorPersistence: "none" | "process" | "provider";
+    readonly snapshot: boolean;
+  };
+}
+export interface GrantConstraint {
+  readonly kind: string;
+  readonly enforcement: "provider" | "backend" | "advisory";
+  readonly value: string | number;
+}
+export interface SignedRequest {
+  readonly method: "GET" | "HEAD" | "PUT" | "DELETE";
+  readonly url: Redacted.Redacted<string>;
+  readonly headers: Redacted.Redacted<Readonly<Record<string, string>>>;
+  readonly expiresAt: DateTime.Utc;
+  readonly ref: ObjectRef;
+  readonly constraints: ReadonlyArray<GrantConstraint>;
+}
+declare const StorageSigning_base: Context.ServiceClass<StorageSigning, "@effect-kit/storage/StorageSigning", {
+  readonly sign: (request: {
+    readonly ref: ObjectRef;
+    readonly method: SignedRequest["method"];
+    readonly expiresInSeconds: number;
+  }) => Effect.Effect<SignedRequest, StorageError>;
+}>;
+export declare class StorageSigning extends StorageSigning_base {}
+declare const StoragePublicUrls_base: Context.ServiceClass<StoragePublicUrls, "@effect-kit/storage/StoragePublicUrls", {
+  /** Resolving a URL does not change the object's visibility. */
+  readonly url: (ref: ObjectRef) => Effect.Effect<string, StorageError>;
+}>;
+export declare class StoragePublicUrls extends StoragePublicUrls_base {}
+declare const StorageCopy_base: Context.ServiceClass<StorageCopy, "@effect-kit/storage/StorageCopy", {
+  readonly copy: (request: {
+    readonly source: ObjectRef;
+    readonly destinationKey: string;
+    readonly condition?: WriteCondition | undefined;
+  }) => Effect.Effect<ObjectMetadata, StorageError>;
+}>;
+export declare class StorageCopy extends StorageCopy_base {}
+export {};
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/core/capabilities.js

@@ -0,0 +1,9 @@
+import { Context } from "effect";
+
+// src/core/capabilities.ts
+var StorageSigning = class extends Context.Service()("@effect-kit/storage/StorageSigning") {};
+var StoragePublicUrls = class extends Context.Service()("@effect-kit/storage/StoragePublicUrls") {};
+var StorageCopy = class extends Context.Service()("@effect-kit/storage/StorageCopy") {};
+
+export { StorageCopy, StoragePublicUrls, StorageSigning };
+//# sourceMappingURL=capabilities.js.map

package/dist/core/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","names":[],"sources":["../../src/core/capabilities.ts"],"sourcesContent":["import { Context } from \"effect\";\nimport type { DateTime, Effect, Redacted } from \"effect\";\n\nimport type { StorageError } from \"./errors.js\";\nimport type { ObjectMetadata, ObjectRef } from \"./object.js\";\nimport type { WriteCondition } from \"./requests.js\";\n\nexport interface StorageCapabilities {\n  readonly putConditions: ReadonlyArray<\"create-only\" | \"if-match\">;\n  readonly getConditions: ReadonlyArray<\"if-match\" | \"if-none-match\">;\n  readonly deleteConditions: ReadonlyArray<\"if-match\">;\n  readonly ranges: ReadonlyArray<\"bounded\" | \"from\" | \"suffix\">;\n  readonly versionedReads: \"none\" | \"current-only\" | \"history\";\n  readonly list: {\n    readonly maxPageSize: number;\n    readonly delimiter: boolean;\n    readonly cursorPersistence: \"none\" | \"process\" | \"provider\";\n    readonly snapshot: boolean;\n  };\n}\n\nexport interface GrantConstraint {\n  readonly kind: string;\n  readonly enforcement: \"provider\" | \"backend\" | \"advisory\";\n  readonly value: string | number;\n}\n\nexport interface SignedRequest {\n  readonly method: \"GET\" | \"HEAD\" | \"PUT\" | \"DELETE\";\n  readonly url: Redacted.Redacted<string>;\n  readonly headers: Redacted.Redacted<Readonly<Record<string, string>>>;\n  readonly expiresAt: DateTime.Utc;\n  readonly ref: ObjectRef;\n  readonly constraints: ReadonlyArray<GrantConstraint>;\n}\n\nexport class StorageSigning extends Context.Service<\n  StorageSigning,\n  {\n    readonly sign: (request: {\n      readonly ref: ObjectRef;\n      readonly method: SignedRequest[\"method\"];\n      readonly expiresInSeconds: number;\n    }) => Effect.Effect<SignedRequest, StorageError>;\n  }\n>()(\"@effect-kit/storage/StorageSigning\") {}\n\nexport class StoragePublicUrls extends Context.Service<\n  StoragePublicUrls,\n  {\n    /** Resolving a URL does not change the object's visibility. */\n    readonly url: (ref: ObjectRef) => Effect.Effect<string, StorageError>;\n  }\n>()(\"@effect-kit/storage/StoragePublicUrls\") {}\n\nexport class StorageCopy extends Context.Service<\n  StorageCopy,\n  {\n    readonly copy: (request: {\n      readonly source: ObjectRef;\n      readonly destinationKey: string;\n      readonly condition?: WriteCondition | undefined;\n    }) => Effect.Effect<ObjectMetadata, StorageError>;\n  }\n>()(\"@effect-kit/storage/StorageCopy\") {}\n"],"mappings":";;;AAoCA,IAAa,iBAAb,cAAoC,QAAQ,QAS1C,CAAC,CAAC,oCAAoC,CAAC,CAAC,CAAC;AAE3C,IAAa,oBAAb,cAAuC,QAAQ,QAM7C,CAAC,CAAC,uCAAuC,CAAC,CAAC,CAAC;AAE9C,IAAa,cAAb,cAAiC,QAAQ,QASvC,CAAC,CAAC,iCAAiC,CAAC,CAAC,CAAC"}

package/dist/core/contracts/multipart.d.ts

@@ -0,0 +1,56 @@
+import { Checksum, ObjectHeaders, ObjectMetadata, ObjectRef } from "../object.js";
+import { StorageError } from "../errors.js";
+import { ListRequest, UploadBody, WriteCondition } from "../requests.js";
+import { Effect, Redacted } from "effect";
+export interface MultipartHandle {
+  readonly ref: ObjectRef;
+  readonly uploadId: Redacted.Redacted<string>;
+}
+export interface MultipartHandleCodec {
+  readonly encode: (handle: MultipartHandle) => Effect.Effect<Redacted.Redacted<string>, StorageError>;
+  readonly decode: (encoded: Redacted.Redacted<string>) => Effect.Effect<MultipartHandle, StorageError>;
+}
+export interface UploadedPart {
+  readonly partNumber: number;
+  readonly etag: string;
+  readonly size?: number | undefined;
+  readonly checksums?: ReadonlyArray<Checksum> | undefined;
+}
+/** S3-style numbered parts; block/offset protocols have separate contracts. */
+export interface MultipartUploads {
+  readonly limits: {
+    readonly minimumPartBytes: number;
+    readonly maximumPartBytes: number;
+    readonly maximumParts: number;
+    /** Omitted retains the full protocol contract; an empty array explicitly forbids conditional completion. */
+    readonly completeConditions?: ReadonlyArray<"create-only" | "if-match">;
+  };
+  readonly initiate: (request: {
+    readonly key: string;
+    readonly headers?: ObjectHeaders;
+  }) => Effect.Effect<MultipartHandle, StorageError>;
+  readonly uploadPart: <E = never, R = never>(request: {
+    readonly upload: MultipartHandle;
+    readonly partNumber: number;
+    readonly body: UploadBody<E, R>;
+    readonly contentLength?: number;
+  }) => Effect.Effect<UploadedPart, StorageError | E, R>;
+  readonly listParts: (request: {
+    readonly upload: MultipartHandle;
+    readonly cursor?: string;
+  }) => Effect.Effect<{
+    readonly parts: ReadonlyArray<UploadedPart>;
+    readonly cursor?: string;
+  }, StorageError>;
+  readonly complete: (request: {
+    readonly upload: MultipartHandle;
+    readonly parts: ReadonlyArray<UploadedPart>;
+    readonly condition?: WriteCondition;
+  }) => Effect.Effect<ObjectMetadata, StorageError>;
+  readonly abort: (upload: MultipartHandle) => Effect.Effect<void, StorageError>;
+  readonly listUploads?: (request: ListRequest) => Effect.Effect<{
+    readonly uploads: ReadonlyArray<MultipartHandle>;
+    readonly cursor?: string;
+  }, StorageError>;
+}
+//# sourceMappingURL=multipart.d.ts.map

package/dist/core/contracts/resumable.d.ts

@@ -0,0 +1,70 @@
+import { ObjectHeaders, ObjectMetadata, ObjectRef } from "../object.js";
+import { StorageError } from "../errors.js";
+import { PutRequest, UploadBody, WriteCondition } from "../requests.js";
+import { Effect, Redacted } from "effect";
+export interface ResumableHandle {
+  readonly protocol: string;
+  readonly ref: ObjectRef;
+  readonly handle: Redacted.Redacted<string>;
+}
+export type ResumableState = {
+  readonly _tag: "Uploading";
+  readonly committedOffset: number;
+} | {
+  readonly _tag: "Completed";
+  readonly metadata: ObjectMetadata;
+} | {
+  readonly _tag: "Expired";
+} | {
+  readonly _tag: "Unknown";
+};
+/** Offset protocols such as GCS/tus, with provider-specific constraints. */
+export interface OffsetUploads {
+  readonly limits: {
+    readonly alignmentBytes: number;
+    readonly maximumChunkBytes: number;
+    readonly fixedChunkBytes?: number;
+  };
+  readonly create: (request: Omit<PutRequest, "body">) => Effect.Effect<ResumableHandle, StorageError>;
+  readonly query: (upload: ResumableHandle) => Effect.Effect<ResumableState, StorageError>;
+  readonly write: <E = never, R = never>(request: {
+    readonly upload: ResumableHandle;
+    readonly offset: number;
+    readonly body: UploadBody<E, R>;
+    readonly contentLength: number;
+    readonly final: boolean;
+  }) => Effect.Effect<ResumableState, StorageError | E, R>;
+  /** Resolve a protocol-only completion receipt in its own budgeted request. */
+  readonly resolveCompletion?: (upload: ResumableHandle) => Effect.Effect<ObjectMetadata, StorageError>;
+  readonly cancel: (upload: ResumableHandle) => Effect.Effect<void, StorageError>;
+}
+/** Azure-style named blocks are not reported as byte offsets or S3 parts. */
+export interface BlockUploads {
+  readonly limits: {
+    readonly maximumBlockBytes: number;
+    readonly maximumBlocks: number;
+  };
+  readonly stage: <E = never, R = never>(request: {
+    readonly ref: ObjectRef;
+    readonly blockId: string;
+    readonly body: UploadBody<E, R>;
+    readonly contentLength: number;
+  }) => Effect.Effect<void, StorageError | E, R>;
+  readonly list: (ref: ObjectRef) => Effect.Effect<{
+    readonly committed: ReadonlyArray<{
+      readonly blockId: string;
+      readonly size: number;
+    }>;
+    readonly uncommitted: ReadonlyArray<{
+      readonly blockId: string;
+      readonly size: number;
+    }>;
+  }, StorageError>;
+  readonly commit: (request: {
+    readonly ref: ObjectRef;
+    readonly blockIds: ReadonlyArray<string>;
+    readonly headers?: ObjectHeaders;
+    readonly condition?: WriteCondition;
+  }) => Effect.Effect<ObjectMetadata, StorageError>;
+}
+//# sourceMappingURL=resumable.d.ts.map

package/dist/core/errors.d.ts

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+export declare const StorageReason: 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", {}>]>;
+export type StorageReason = typeof StorageReason.Type;
+export declare const MutationOutcome: Schema.Literals<readonly ["not-applicable", "not-started", "rejected", "succeeded", "unknown", "partial"]>;
+export type MutationOutcome = typeof MutationOutcome.Type;
+declare const StorageError_base: Schema.Class<StorageError, Schema.TaggedStruct<"StorageError", {
+  readonly operation: Schema.String;
+  readonly provider: Schema.String;
+  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 mutationOutcome: Schema.Literals<readonly ["not-applicable", "not-started", "rejected", "succeeded", "unknown", "partial"]>;
+  readonly requestId: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/** Contains safe operational context only; raw SDK responses and bearer URLs stay private. */
+export declare class StorageError extends StorageError_base {}
+export declare function storageError(operation: string, provider: string, reason: StorageReason, mutationOutcome?: MutationOutcome): StorageError;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/errors.js

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+
+// src/core/errors.ts
+const StorageReason = Schema.Union([
+	Schema.TaggedStruct("InvalidInput", { field: Schema.String }),
+	Schema.TaggedStruct("InvalidConfiguration", { field: Schema.String }),
+	Schema.TaggedStruct("Unsupported", { capability: Schema.String }),
+	Schema.TaggedStruct("NotFound", {}),
+	Schema.TaggedStruct("AccessDenied", {}),
+	Schema.TaggedStruct("PreconditionFailed", {}),
+	Schema.TaggedStruct("NotModified", {}),
+	Schema.TaggedStruct("RangeNotSatisfiable", {}),
+	Schema.TaggedStruct("Expired", {}),
+	Schema.TaggedStruct("Throttled", { retryAfterMillis: Schema.optional(Schema.Natural) }),
+	Schema.TaggedStruct("TransportFailure", { code: Schema.optional(Schema.String) }),
+	Schema.TaggedStruct("ProviderFailure", { code: Schema.optional(Schema.String) }),
+	Schema.TaggedStruct("IntegrityMismatch", {}),
+	Schema.TaggedStruct("LengthMismatch", {
+		expected: Schema.Natural,
+		actual: Schema.Natural
+	}),
+	Schema.TaggedStruct("LimitExceeded", { limit: Schema.Natural }),
+	Schema.TaggedStruct("InvalidSession", {}),
+	Schema.TaggedStruct("QuotaExceeded", { limit: Schema.Natural }),
+	Schema.TaggedStruct("ScopeClosed", {}),
+	Schema.TaggedStruct("BodyConsumed", {}),
+	Schema.TaggedStruct("PartialFailure", {})
+]);
+const MutationOutcome = Schema.Literals([
+	"not-applicable",
+	"not-started",
+	"rejected",
+	"succeeded",
+	"unknown",
+	"partial"
+]);
+/** Contains safe operational context only; raw SDK responses and bearer URLs stay private. */
+var StorageError = class extends Schema.TaggedError()("StorageError", {
+	operation: Schema.String,
+	provider: Schema.String,
+	reason: StorageReason,
+	mutationOutcome: MutationOutcome,
+	requestId: Schema.optional(Schema.String)
+}) {};
+function storageError(operation, provider, reason, mutationOutcome = "not-applicable") {
+	return new StorageError({
+		operation,
+		provider,
+		reason,
+		mutationOutcome
+	});
+}
+
+export { MutationOutcome, StorageError, StorageReason, storageError };
+//# sourceMappingURL=errors.js.map

package/dist/core/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/core/errors.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nexport const StorageReason = Schema.Union([\n  Schema.TaggedStruct(\"InvalidInput\", { field: Schema.String }),\n  Schema.TaggedStruct(\"InvalidConfiguration\", { field: Schema.String }),\n  Schema.TaggedStruct(\"Unsupported\", { capability: Schema.String }),\n  Schema.TaggedStruct(\"NotFound\", {}),\n  Schema.TaggedStruct(\"AccessDenied\", {}),\n  Schema.TaggedStruct(\"PreconditionFailed\", {}),\n  Schema.TaggedStruct(\"NotModified\", {}),\n  Schema.TaggedStruct(\"RangeNotSatisfiable\", {}),\n  Schema.TaggedStruct(\"Expired\", {}),\n  Schema.TaggedStruct(\"Throttled\", { retryAfterMillis: Schema.optional(Schema.Natural) }),\n  Schema.TaggedStruct(\"TransportFailure\", { code: Schema.optional(Schema.String) }),\n  Schema.TaggedStruct(\"ProviderFailure\", { code: Schema.optional(Schema.String) }),\n  Schema.TaggedStruct(\"IntegrityMismatch\", {}),\n  Schema.TaggedStruct(\"LengthMismatch\", { expected: Schema.Natural, actual: Schema.Natural }),\n  Schema.TaggedStruct(\"LimitExceeded\", { limit: Schema.Natural }),\n  Schema.TaggedStruct(\"InvalidSession\", {}),\n  Schema.TaggedStruct(\"QuotaExceeded\", { limit: Schema.Natural }),\n  Schema.TaggedStruct(\"ScopeClosed\", {}),\n  Schema.TaggedStruct(\"BodyConsumed\", {}),\n  Schema.TaggedStruct(\"PartialFailure\", {}),\n]);\n\nexport type StorageReason = typeof StorageReason.Type;\n\nexport const MutationOutcome = Schema.Literals([\n  \"not-applicable\",\n  \"not-started\",\n  \"rejected\",\n  \"succeeded\",\n  \"unknown\",\n  \"partial\",\n]);\n\nexport type MutationOutcome = typeof MutationOutcome.Type;\n\n/** Contains safe operational context only; raw SDK responses and bearer URLs stay private. */\nexport class StorageError extends Schema.TaggedError<StorageError>()(\"StorageError\", {\n  operation: Schema.String,\n  provider: Schema.String,\n  reason: StorageReason,\n  mutationOutcome: MutationOutcome,\n  requestId: Schema.optional(Schema.String),\n}) {}\n\nexport function storageError(\n  operation: string,\n  provider: string,\n  reason: StorageReason,\n  mutationOutcome: MutationOutcome = \"not-applicable\",\n): StorageError {\n  return new StorageError({ operation, provider, reason, mutationOutcome });\n}\n"],"mappings":";;;AAEA,MAAa,gBAAgB,OAAO,MAAM;CACxC,OAAO,aAAa,gBAAgB,EAAE,OAAO,OAAO,OAAO,CAAC;CAC5D,OAAO,aAAa,wBAAwB,EAAE,OAAO,OAAO,OAAO,CAAC;CACpE,OAAO,aAAa,eAAe,EAAE,YAAY,OAAO,OAAO,CAAC;CAChE,OAAO,aAAa,YAAY,CAAC,CAAC;CAClC,OAAO,aAAa,gBAAgB,CAAC,CAAC;CACtC,OAAO,aAAa,sBAAsB,CAAC,CAAC;CAC5C,OAAO,aAAa,eAAe,CAAC,CAAC;CACrC,OAAO,aAAa,uBAAuB,CAAC,CAAC;CAC7C,OAAO,aAAa,WAAW,CAAC,CAAC;CACjC,OAAO,aAAa,aAAa,EAAE,kBAAkB,OAAO,SAAS,OAAO,OAAO,EAAE,CAAC;CACtF,OAAO,aAAa,oBAAoB,EAAE,MAAM,OAAO,SAAS,OAAO,MAAM,EAAE,CAAC;CAChF,OAAO,aAAa,mBAAmB,EAAE,MAAM,OAAO,SAAS,OAAO,MAAM,EAAE,CAAC;CAC/E,OAAO,aAAa,qBAAqB,CAAC,CAAC;CAC3C,OAAO,aAAa,kBAAkB;EAAE,UAAU,OAAO;EAAS,QAAQ,OAAO;CAAQ,CAAC;CAC1F,OAAO,aAAa,iBAAiB,EAAE,OAAO,OAAO,QAAQ,CAAC;CAC9D,OAAO,aAAa,kBAAkB,CAAC,CAAC;CACxC,OAAO,aAAa,iBAAiB,EAAE,OAAO,OAAO,QAAQ,CAAC;CAC9D,OAAO,aAAa,eAAe,CAAC,CAAC;CACrC,OAAO,aAAa,gBAAgB,CAAC,CAAC;CACtC,OAAO,aAAa,kBAAkB,CAAC,CAAC;AAC1C,CAAC;AAID,MAAa,kBAAkB,OAAO,SAAS;CAC7C;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;AAKD,IAAa,eAAb,cAAkC,OAAO,YAA0B,CAAC,CAAC,gBAAgB;CACnF,WAAW,OAAO;CAClB,UAAU,OAAO;CACjB,QAAQ;CACR,iBAAiB;CACjB,WAAW,OAAO,SAAS,OAAO,MAAM;AAC1C,CAAC,CAAC,CAAC,CAAC;AAEJ,SAAgB,aACd,WACA,UACA,QACA,kBAAmC,kBACrB;CACd,OAAO,IAAI,aAAa;EAAE;EAAW;EAAU;EAAQ;CAAgB,CAAC;AAC1E"}

package/dist/core/object.d.ts

@@ -0,0 +1,97 @@
+import { Schema } from "effect";
+/** An opaque key. Provider-specific encoding and limits are checked by adapters. */
+export declare const ObjectKey: Schema.NonEmptyString;
+export type ObjectKey = typeof ObjectKey.Type;
+/** A JSON-safe byte count. Unsafe integers are rejected rather than rounded. */
+export declare const ObjectSize: Schema.Natural;
+export type ObjectSize = typeof ObjectSize.Type;
+export declare const NativeVersion: 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;
+}>]>;
+export type NativeVersion = typeof NativeVersion.Type;
+export declare const ObjectRef: 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;
+  }>]>>;
+}>;
+export type ObjectRef = typeof ObjectRef.Type;
+export declare const Checksum: Schema.Struct<{
+  readonly algorithm: Schema.NonEmptyString;
+  readonly encoding: Schema.Literals<readonly ["hex", "base64"]>;
+  readonly scope: Schema.Literals<readonly ["full-object", "composite"]>;
+  readonly value: Schema.NonEmptyString;
+  readonly partCount: Schema.optional<Schema.Int>;
+}>;
+export type Checksum = typeof Checksum.Type;
+export declare const ObjectValidator: Schema.String;
+export type ObjectValidator = typeof ObjectValidator.Type;
+export declare const ObjectHeaders: Schema.Struct<{
+  readonly contentType: Schema.optional<Schema.String>;
+  readonly contentEncoding: Schema.optional<Schema.String>;
+  readonly contentLanguage: Schema.optional<Schema.String>;
+  readonly contentDisposition: Schema.optional<Schema.String>;
+  readonly cacheControl: Schema.optional<Schema.String>;
+  readonly customMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+}>;
+export type ObjectHeaders = typeof ObjectHeaders.Type;
+/** Type-side timestamps are DateTime.Utc; the encoded representation uses ISO strings. */
+export declare const ObjectMetadata: Schema.Struct<{
+  readonly contentType: Schema.optional<Schema.String>;
+  readonly contentEncoding: Schema.optional<Schema.String>;
+  readonly contentLanguage: Schema.optional<Schema.String>;
+  readonly contentDisposition: Schema.optional<Schema.String>;
+  readonly cacheControl: Schema.optional<Schema.String>;
+  readonly customMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+  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 size: Schema.optional<Schema.Natural>;
+  readonly etag: Schema.optional<Schema.String>;
+  readonly lastModified: Schema.optional<Schema.DateTimeUtcFromString>;
+  readonly checksums: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly algorithm: Schema.NonEmptyString;
+    readonly encoding: Schema.Literals<readonly ["hex", "base64"]>;
+    readonly scope: Schema.Literals<readonly ["full-object", "composite"]>;
+    readonly value: Schema.NonEmptyString;
+    readonly partCount: Schema.optional<Schema.Int>;
+  }>>>;
+  readonly storageClass: Schema.optional<Schema.NonEmptyString>;
+}>;
+export type ObjectMetadata = typeof ObjectMetadata.Type;
+//# sourceMappingURL=object.d.ts.map