@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/transfers/sources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sources.js","names":[],"sources":["../../src/transfers/sources.ts"],"sourcesContent":["import { ByteSize, Cause, Effect, FileSystem, Option, Stream } from \"effect\";\nimport type { PlatformError } from \"effect/PlatformError\";\n\nimport type { StorageError } from \"../core/errors.js\";\nimport { storageError } from \"../core/errors.js\";\nimport { TransferHash } from \"./dependencies.js\";\n\nexport interface UploadSource<E = never, R = never> {\n  readonly length?: number | undefined;\n  readonly replayable: boolean;\n  readonly workspaceBytes?: number | undefined;\n  readonly open: () => Stream.Stream<Uint8Array, E | StorageError, R>;\n}\n\nconst sourceError = (field: string) =>\n  storageError(\"source\", \"transfer\", { _tag: \"InvalidInput\", field }, \"not-started\");\n\n/** Copies the caller's bytes once. This immutable snapshot is outside the engine's workspace. */\nexport function bytes(input: Uint8Array): UploadSource {\n  const snapshot = Uint8Array.from(input);\n  return replayable(\n    () =>\n      Stream.fromIterable(\n        (function* () {\n          for (let start = 0; start < snapshot.length; start += 65536)\n            yield snapshot.slice(start, start + 65536);\n        })(),\n        { chunkSize: 1 },\n      ),\n    snapshot.length,\n  );\n}\n\nexport function stream<E, R>(\n  body: Stream.Stream<Uint8Array, E, R>,\n  length?: number,\n): UploadSource<E, R> {\n  let consumed = false;\n  return {\n    length,\n    replayable: false,\n    open: () =>\n      Stream.unwrap(\n        Effect.suspend(() => {\n          if (consumed)\n            return Effect.fail(\n              storageError(\"source\", \"transfer\", { _tag: \"BodyConsumed\" }, \"not-started\"),\n            );\n          consumed = true;\n          return Effect.succeed(body);\n        }),\n      ),\n  };\n}\n\n/** The factory promises the same representation on every opening. */\nexport function replayable<E, R>(\n  open: () => Stream.Stream<Uint8Array, E, R>,\n  length?: number,\n): UploadSource<E, R> {\n  return { length, replayable: true, open: () => Stream.suspend(open) };\n}\n\nconst identity = (info: FileSystem.File.Info) =>\n  `${String(info.dev)}:${Option.getOrUndefined(info.ino)}:${String(ByteSize.toBigInt(info.size))}:${Option.getOrUndefined(info.mtime)?.getTime()}`;\n\n/** Captures FileSystem once. Every opening checks identity and a full bounded-memory fingerprint. */\nexport const file = Effect.fnUntraced(function* (\n  path: string,\n): Effect.fn.Return<\n  UploadSource<PlatformError | StorageError>,\n  PlatformError | StorageError,\n  FileSystem.FileSystem | TransferHash\n> {\n  const fs = yield* FileSystem.FileSystem;\n  const digest = yield* TransferHash;\n  const original = yield* fs.stat(path);\n  const length = Number(ByteSize.toBigInt(original.size));\n  if (original.type !== \"File\" || !Number.isSafeInteger(length)) return yield* sourceError(\"file\");\n\n  const fingerprint = Effect.scoped(\n    Effect.gen(function* () {\n      const handle = yield* fs.open(path);\n      const state = digest.create();\n      while (true) {\n        const chunk = yield* handle.readAlloc(65536);\n        if (Option.isNone(chunk)) break;\n        state.update(chunk.value);\n      }\n      return state.finish().value;\n    }),\n  );\n  const expected = yield* fingerprint;\n\n  const source = replayable(\n    () =>\n      Stream.unwrap(\n        Effect.gen(function* () {\n          const current = yield* fs.stat(path);\n          if (identity(current) !== identity(original) || (yield* fingerprint) !== expected)\n            return yield* sourceError(\"file.changed\");\n\n          const state = digest.create();\n          const handle = yield* fs.open(path);\n          const body = Stream.fromPull(\n            Effect.succeed(\n              Effect.gen(function* () {\n                const chunk = yield* handle.readAlloc(65536);\n                if (Option.isNone(chunk)) return yield* Cause.done();\n                return [chunk.value] as const;\n              }),\n            ),\n          );\n          return body.pipe(\n            Stream.tap((chunk) => Effect.sync(() => state.update(chunk))),\n            Stream.concat(\n              Stream.drain(\n                Stream.fromEffect(\n                  Effect.gen(function* () {\n                    const after = yield* fs.stat(path);\n                    if (identity(after) !== identity(original) || state.finish().value !== expected)\n                      return yield* sourceError(\"file.changed\");\n                  }),\n                ),\n              ),\n            ),\n          );\n        }),\n      ),\n    length,\n  );\n  return { ...source, workspaceBytes: 65536 + digest.workspaceBytes };\n});\n"],"mappings":"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"}

package/dist/transfers/upload.js

@@ -0,0 +1,235 @@
+import { Checksum, ObjectHeaders, ObjectKey } from "../core/object.js";
+import { StorageError, storageError } from "../core/errors.js";
+import { decodeRequest } from "../internal/request-validation.js";
+import { WriteCondition } from "../core/requests.js";
+import { makeReader, sameChecksum } from "./reader.js";
+import { download } from "./download.js";
+import { partReceipt } from "./part-receipts.js";
+import { planUpload } from "./planner.js";
+import { nativeUpload } from "./native-upload.js";
+import { Cause, Effect, Exit, Option, Stream } from "effect";
+
+// src/transfers/upload.ts
+const operationMetadataKey = "effect-storage-operation";
+const validateUpload = Effect.fnUntraced(function* (runtime, request) {
+	const { provider } = runtime.endpoint.storage;
+	if (!request.source || typeof request.source.open !== "function" || request.source.workspaceBytes !== void 0 && (!Number.isSafeInteger(request.source.workspaceBytes) || request.source.workspaceBytes < 0)) return yield* storageError("upload", provider, {
+		_tag: "InvalidInput",
+		field: "source"
+	}, "not-started");
+	yield* decodeRequest(ObjectKey, request.key, "upload", provider, true);
+	const headers = yield* decodeRequest(ObjectHeaders, request.headers ?? {}, "upload", provider, true);
+	if (request.condition) yield* decodeRequest(WriteCondition, request.condition, "upload", provider, true);
+	if (request.expectedChecksum) yield* decodeRequest(Checksum, request.expectedChecksum, "upload", provider, true);
+	if (headers.customMetadata?.["effect-storage-operation"] !== void 0) return yield* storageError("upload", provider, {
+		_tag: "InvalidInput",
+		field: `headers.customMetadata.${operationMetadataKey}`
+	}, "not-started");
+	if (request.expectedChecksum && (request.expectedChecksum.scope !== "full-object" || request.expectedChecksum.algorithm !== runtime.input.digest.algorithm)) return yield* storageError("upload", provider, {
+		_tag: "Unsupported",
+		capability: "expected-full-object-checksum"
+	}, "not-started");
+	const condition = request.condition?._tag === "CreateOnly" ? "create-only" : "if-match";
+	if (request.condition && !runtime.endpoint.storage.capabilities.putConditions.includes(condition)) return yield* storageError("upload", provider, {
+		_tag: "Unsupported",
+		capability: condition
+	}, "not-started");
+	if (runtime.endpoint.validateUpload) yield* runtime.endpoint.validateUpload({
+		key: request.key,
+		headers,
+		condition: request.condition
+	});
+	return headers;
+});
+const initiateMultipart = Effect.fnUntraced(function* (runtime, operation, multipart, key, headers) {
+	let started = false;
+	return yield* operation.request(Effect.suspend(() => {
+		started = true;
+		return multipart.initiate({
+			key,
+			headers
+		});
+	}), { retry: true }).pipe(Effect.onExit((exit) => {
+		if (!started || Exit.isSuccess(exit)) return Effect.void;
+		const error = Option.getOrUndefined(Cause.findErrorOption(exit.cause));
+		return error instanceof StorageError && error.mutationOutcome !== "unknown" ? Effect.void : runtime.diagnostic({
+			kind: "unknown-outcome",
+			operationId: operation.id
+		});
+	}));
+});
+const reconcile = Effect.fnUntraced(function* (runtime, operation, key, size, error) {
+	if (error.mutationOutcome !== "unknown") return yield* error;
+	if (runtime.endpoint.reconcile) {
+		const result = yield* operation.request(runtime.endpoint.reconcile({
+			key,
+			operationId: operation.id,
+			size
+		})).pipe(Effect.result);
+		if (result._tag === "Success" && result.success) return result.success;
+	}
+	yield* runtime.diagnostic({
+		kind: "unknown-outcome",
+		operationId: operation.id,
+		error
+	});
+	return yield* error;
+});
+/** Finalizers run after mapEffect has joined its scoped producer and part workers. */
+function cleanupMultipart(runtime, operation, upload, multipart) {
+	return Effect.gen(function* () {
+		const result = yield* Effect.exit(runtime.cleanupRequest(multipart.abort(upload)).pipe(Effect.interruptible, Effect.timeout(runtime.policy.cleanupTimeoutMillis)));
+		if (Exit.isFailure(result)) {
+			const error = Option.getOrUndefined(Cause.findErrorOption(result.cause));
+			yield* runtime.diagnostic({
+				kind: "cleanup",
+				operationId: operation.id,
+				upload,
+				error: error?._tag === "StorageError" ? error : void 0
+			});
+		}
+	});
+}
+const upload = Effect.fn("Transfers.upload")(function* (runtime, request, existing, reserved = false) {
+	const headers = yield* validateUpload(runtime, request);
+	const plan = yield* planUpload(runtime.endpoint, runtime.policy, request.source.length, runtime.input.digest.workspaceBytes + (request.source.workspaceBytes ?? 0), request.strategy, false, request.condition);
+	const operation = existing ?? (yield* runtime.begin("upload", request.source.length));
+	const { endpoint, policy } = runtime;
+	const intentHeaders = {
+		...headers,
+		customMetadata: {
+			...headers.customMetadata,
+			[operationMetadataKey]: operation.id
+		}
+	};
+	const work = Effect.scoped(Effect.gen(function* () {
+		if (plan.strategy === "offset" || plan.strategy === "blocks") return yield* nativeUpload(runtime, request, intentHeaders, operation, plan);
+		const reader = yield* makeReader(request.source, {
+			maximumBytes: plan.maximumBytes,
+			maximumChunkBytes: policy.maxSourceChunkBytes,
+			digest: runtime.input.digest,
+			onRead: (count) => {
+				operation.progress.bytesRead += count;
+			}
+		});
+		const verify = () => Effect.gen(function* () {
+			const checksum = reader.checksum();
+			if (!checksum) return yield* storageError("upload", endpoint.storage.provider, { _tag: "IntegrityMismatch" }, "not-started");
+			if (request.expectedChecksum && !sameChecksum(checksum, request.expectedChecksum)) return yield* storageError("upload", endpoint.storage.provider, { _tag: "IntegrityMismatch" }, "not-started");
+			return checksum;
+		});
+		let metadata;
+		let checksum;
+		if (plan.strategy === "single") {
+			const body = (yield* reader.next(plan.partBytes)) ?? /* @__PURE__ */ new Uint8Array();
+			if ((yield* reader.next(1)) !== void 0) return yield* storageError("upload", endpoint.storage.provider, {
+				_tag: "LimitExceeded",
+				limit: plan.partBytes
+			}, "not-started");
+			checksum = yield* verify();
+			const put = Effect.suspend(() => {
+				operation.mutationStarted = true;
+				operation.progress.bytesSent += body.length;
+				return endpoint.storage.put({
+					key: request.key,
+					...intentHeaders,
+					condition: request.condition,
+					contentLength: body.length,
+					body
+				});
+			});
+			metadata = yield* operation.request(put, { retry: true }).pipe(Effect.catch((error) => reconcile(runtime, operation, request.key, body.length, error)));
+			operation.progress.bytesAcknowledged = body.length;
+		} else {
+			const multipart = endpoint.multipart;
+			if (!multipart) return yield* storageError("upload", endpoint.storage.provider, {
+				_tag: "Unsupported",
+				capability: "multipart"
+			}, "not-started");
+			const handle = yield* initiateMultipart(runtime, operation, multipart, request.key, intentHeaders);
+			let completed = false;
+			let unknownCompletion = false;
+			yield* Effect.addFinalizer(() => completed ? Effect.void : unknownCompletion ? runtime.diagnostic({
+				kind: "unknown-outcome",
+				operationId: operation.id,
+				upload: handle
+			}) : cleanupMultipart(runtime, operation, handle, multipart));
+			let partNumber = 0;
+			const parts = yield* Stream.fromPull(Effect.succeed(Effect.gen(function* () {
+				const body = yield* reader.next(plan.partBytes);
+				if (!body && partNumber > 0) return yield* Cause.done();
+				if (!body) {
+					partNumber++;
+					return [{
+						body: /* @__PURE__ */ new Uint8Array(),
+						partNumber
+					}];
+				}
+				return [{
+					body,
+					partNumber: ++partNumber
+				}];
+			}))).pipe(Stream.mapEffect(({ body, partNumber: number }) => operation.request(Effect.suspend(() => {
+				operation.progress.bytesSent += body.length;
+				return multipart.uploadPart({
+					upload: handle,
+					partNumber: number,
+					body,
+					contentLength: body.length
+				});
+			}), {
+				retry: true,
+				retryUnknown: true
+			}).pipe(Effect.flatMap((receipt) => partReceipt(receipt, number, body.length, endpoint.storage.provider)), Effect.tap(() => Effect.gen(function* () {
+				operation.progress.bytesAcknowledged += body.length;
+				yield* operation.observe();
+			}))), {
+				concurrency: plan.concurrency,
+				unordered: true
+			}), Stream.runCollect);
+			checksum = yield* verify();
+			metadata = yield* operation.request(Effect.suspend(() => {
+				unknownCompletion = true;
+				operation.mutationStarted = true;
+				return multipart.complete({
+					upload: handle,
+					parts: parts.toSorted((a, b) => a.partNumber - b.partNumber),
+					...request.condition ? { condition: request.condition } : {}
+				});
+			}), { retry: true }).pipe(Effect.catch((error) => Effect.gen(function* () {
+				unknownCompletion = error.mutationOutcome === "unknown";
+				return yield* reconcile(runtime, operation, request.key, reader.count(), error);
+			})));
+			completed = true;
+		}
+		operation.committed = true;
+		operation.progress.phase = "committed";
+		return {
+			metadata,
+			checksum,
+			strategy: plan.strategy,
+			progress: { ...operation.progress }
+		};
+	}));
+	const transfer = reserved ? work : runtime.lease(plan.workspaceBytes, work);
+	const verified = Effect.gen(function* () {
+		const receipt = yield* transfer;
+		if (existing || plan.strategy !== "offset" && plan.strategy !== "blocks") return receipt;
+		const checked = yield* download(runtime, {
+			ref: receipt.metadata.ref,
+			expectedChecksum: receipt.checksum,
+			target: { write: () => Effect.void }
+		}, operation, receipt.metadata).pipe(Effect.mapError((error) => storageError("upload.verify", endpoint.storage.provider, error.reason, "succeeded")));
+		return {
+			...receipt,
+			metadata: checked.metadata,
+			progress: { ...operation.progress }
+		};
+	});
+	const receipt = yield* existing ? verified : runtime.deadline(operation, verified);
+	if (!existing) yield* operation.observe(operation.progress.phase);
+	return receipt;
+});
+
+export { cleanupMultipart, initiateMultipart, operationMetadataKey, reconcile, upload, validateUpload };
+//# sourceMappingURL=upload.js.map

package/dist/transfers/upload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.js","names":[],"sources":["../../src/transfers/upload.ts"],"sourcesContent":["import { Cause, Effect, Exit, Option, Stream } from \"effect\";\n\nimport type { MultipartHandle, MultipartUploads } from \"../core/contracts/multipart.js\";\nimport { StorageError, storageError } from \"../core/errors.js\";\nimport { Checksum, ObjectHeaders, ObjectKey } from \"../core/object.js\";\nimport type { ObjectMetadata } from \"../core/object.js\";\nimport { WriteCondition } from \"../core/requests.js\";\nimport { decodeRequest } from \"../internal/request-validation.js\";\nimport { download } from \"./download.js\";\nimport type { TransferReceipt, UploadRequest } from \"./models.js\";\nimport { nativeUpload } from \"./native-upload.js\";\nimport { partReceipt } from \"./part-receipts.js\";\nimport { planUpload } from \"./planner.js\";\nimport { makeReader, sameChecksum } from \"./reader.js\";\nimport type { Operation, TransferRuntime } from \"./runtime.js\";\n\nexport const operationMetadataKey = \"effect-storage-operation\";\n\nexport const validateUpload = Effect.fnUntraced(function* <E, R>(\n  runtime: TransferRuntime,\n  request: UploadRequest<E, R>,\n) {\n  const { provider } = runtime.endpoint.storage;\n  if (\n    !request.source ||\n    typeof request.source.open !== \"function\" ||\n    (request.source.workspaceBytes !== undefined &&\n      (!Number.isSafeInteger(request.source.workspaceBytes) || request.source.workspaceBytes < 0))\n  )\n    return yield* storageError(\n      \"upload\",\n      provider,\n      { _tag: \"InvalidInput\", field: \"source\" },\n      \"not-started\",\n    );\n  yield* decodeRequest(ObjectKey, request.key, \"upload\", provider, true);\n  const headers = yield* decodeRequest(\n    ObjectHeaders,\n    request.headers ?? {},\n    \"upload\",\n    provider,\n    true,\n  );\n  if (request.condition)\n    yield* decodeRequest(WriteCondition, request.condition, \"upload\", provider, true);\n  if (request.expectedChecksum)\n    yield* decodeRequest(Checksum, request.expectedChecksum, \"upload\", provider, true);\n  if (headers.customMetadata?.[operationMetadataKey] !== undefined)\n    return yield* storageError(\n      \"upload\",\n      provider,\n      { _tag: \"InvalidInput\", field: `headers.customMetadata.${operationMetadataKey}` },\n      \"not-started\",\n    );\n  if (\n    request.expectedChecksum &&\n    (request.expectedChecksum.scope !== \"full-object\" ||\n      request.expectedChecksum.algorithm !== runtime.input.digest.algorithm)\n  )\n    return yield* storageError(\n      \"upload\",\n      provider,\n      { _tag: \"Unsupported\", capability: \"expected-full-object-checksum\" },\n      \"not-started\",\n    );\n  const condition = request.condition?._tag === \"CreateOnly\" ? \"create-only\" : \"if-match\";\n  if (request.condition && !runtime.endpoint.storage.capabilities.putConditions.includes(condition))\n    return yield* storageError(\n      \"upload\",\n      provider,\n      { _tag: \"Unsupported\", capability: condition },\n      \"not-started\",\n    );\n  if (runtime.endpoint.validateUpload)\n    yield* runtime.endpoint.validateUpload({\n      key: request.key,\n      headers,\n      condition: request.condition,\n    });\n  return headers;\n});\n\nexport const initiateMultipart = Effect.fnUntraced(function* (\n  runtime: TransferRuntime,\n  operation: Operation,\n  multipart: MultipartUploads,\n  key: string,\n  headers: ObjectHeaders,\n) {\n  let started = false;\n  return yield* operation\n    .request(\n      Effect.suspend(() => {\n        started = true;\n        return multipart.initiate({ key, headers });\n      }),\n      { retry: true },\n    )\n    .pipe(\n      Effect.onExit((exit) => {\n        if (!started || Exit.isSuccess(exit)) return Effect.void;\n        const error = Option.getOrUndefined(Cause.findErrorOption(exit.cause));\n        return error instanceof StorageError && error.mutationOutcome !== \"unknown\"\n          ? Effect.void\n          : runtime.diagnostic({ kind: \"unknown-outcome\", operationId: operation.id });\n      }),\n    );\n});\n\nexport const reconcile = Effect.fnUntraced(function* (\n  runtime: TransferRuntime,\n  operation: Operation,\n  key: string,\n  size: number,\n  error: StorageError,\n) {\n  if (error.mutationOutcome !== \"unknown\") return yield* error;\n  if (runtime.endpoint.reconcile) {\n    const result = yield* operation\n      .request(runtime.endpoint.reconcile({ key, operationId: operation.id, size }))\n      .pipe(Effect.result);\n    if (result._tag === \"Success\" && result.success) return result.success;\n  }\n  yield* runtime.diagnostic({ kind: \"unknown-outcome\", operationId: operation.id, error });\n  return yield* error;\n});\n\n/** Finalizers run after mapEffect has joined its scoped producer and part workers. */\nexport function cleanupMultipart(\n  runtime: TransferRuntime,\n  operation: Operation,\n  upload: MultipartHandle,\n  multipart: MultipartUploads,\n) {\n  return Effect.gen(function* () {\n    const result = yield* Effect.exit(\n      runtime\n        .cleanupRequest(multipart.abort(upload))\n        .pipe(Effect.interruptible, Effect.timeout(runtime.policy.cleanupTimeoutMillis)),\n    );\n    if (Exit.isFailure(result)) {\n      const error = Option.getOrUndefined(Cause.findErrorOption(result.cause));\n      yield* runtime.diagnostic({\n        kind: \"cleanup\",\n        operationId: operation.id,\n        upload,\n        error: error?._tag === \"StorageError\" ? error : undefined,\n      });\n    }\n  });\n}\n\nexport const upload = Effect.fn(\"Transfers.upload\")(function* <E, R>(\n  runtime: TransferRuntime,\n  request: UploadRequest<E, R>,\n  existing?: Operation,\n  reserved = false,\n): Effect.fn.Return<TransferReceipt, StorageError | E, R> {\n  const headers = yield* validateUpload(runtime, request);\n  const plan = yield* planUpload(\n    runtime.endpoint,\n    runtime.policy,\n    request.source.length,\n    runtime.input.digest.workspaceBytes + (request.source.workspaceBytes ?? 0),\n    request.strategy,\n    false,\n    request.condition,\n  );\n  const operation = existing ?? (yield* runtime.begin(\"upload\", request.source.length));\n  const { endpoint, policy } = runtime;\n  const intentHeaders = {\n    ...headers,\n    customMetadata: { ...headers.customMetadata, [operationMetadataKey]: operation.id },\n  };\n\n  const work = Effect.scoped(\n    Effect.gen(function* () {\n      if (plan.strategy === \"offset\" || plan.strategy === \"blocks\")\n        return yield* nativeUpload(runtime, request, intentHeaders, operation, plan);\n      const reader = yield* makeReader(request.source, {\n        maximumBytes: plan.maximumBytes,\n        maximumChunkBytes: policy.maxSourceChunkBytes,\n        digest: runtime.input.digest,\n        onRead: (count) => {\n          operation.progress.bytesRead += count;\n        },\n      });\n      const verify = () =>\n        Effect.gen(function* () {\n          const checksum = reader.checksum();\n          if (!checksum)\n            return yield* storageError(\n              \"upload\",\n              endpoint.storage.provider,\n              { _tag: \"IntegrityMismatch\" },\n              \"not-started\",\n            );\n          if (request.expectedChecksum && !sameChecksum(checksum, request.expectedChecksum))\n            return yield* storageError(\n              \"upload\",\n              endpoint.storage.provider,\n              { _tag: \"IntegrityMismatch\" },\n              \"not-started\",\n            );\n          return checksum;\n        });\n\n      let metadata: ObjectMetadata;\n      let checksum: Checksum;\n      if (plan.strategy === \"single\") {\n        const body = (yield* reader.next(plan.partBytes)) ?? new Uint8Array();\n        // Read EOF before publication, including exact-sized and empty objects.\n        if ((yield* reader.next(1)) !== undefined)\n          return yield* storageError(\n            \"upload\",\n            endpoint.storage.provider,\n            { _tag: \"LimitExceeded\", limit: plan.partBytes },\n            \"not-started\",\n          );\n        checksum = yield* verify();\n        const put = Effect.suspend(() => {\n          operation.mutationStarted = true;\n          operation.progress.bytesSent += body.length;\n          return endpoint.storage.put({\n            key: request.key,\n            ...intentHeaders,\n            condition: request.condition,\n            contentLength: body.length,\n            body,\n          });\n        });\n        metadata = yield* operation\n          .request(put, { retry: true })\n          .pipe(\n            Effect.catch((error) => reconcile(runtime, operation, request.key, body.length, error)),\n          );\n        operation.progress.bytesAcknowledged = body.length;\n      } else {\n        const multipart = endpoint.multipart;\n        if (!multipart)\n          return yield* storageError(\n            \"upload\",\n            endpoint.storage.provider,\n            { _tag: \"Unsupported\", capability: \"multipart\" },\n            \"not-started\",\n          );\n        const handle = yield* initiateMultipart(\n          runtime,\n          operation,\n          multipart,\n          request.key,\n          intentHeaders,\n        );\n        let completed = false;\n        let unknownCompletion = false;\n        yield* Effect.addFinalizer(() =>\n          completed\n            ? Effect.void\n            : unknownCompletion\n              ? runtime.diagnostic({\n                  kind: \"unknown-outcome\",\n                  operationId: operation.id,\n                  upload: handle,\n                })\n              : cleanupMultipart(runtime, operation, handle, multipart),\n        );\n        let partNumber = 0;\n        const parts = yield* Stream.fromPull(\n          Effect.succeed(\n            Effect.gen(function* () {\n              const body = yield* reader.next(plan.partBytes);\n              if (!body && partNumber > 0) return yield* Cause.done();\n              if (!body) {\n                partNumber++;\n                return [{ body: new Uint8Array(), partNumber }] as const;\n              }\n              return [{ body, partNumber: ++partNumber }] as const;\n            }),\n          ),\n        ).pipe(\n          Stream.mapEffect(\n            ({ body, partNumber: number }) =>\n              operation\n                .request(\n                  Effect.suspend(() => {\n                    operation.progress.bytesSent += body.length;\n                    return multipart.uploadPart({\n                      upload: handle,\n                      partNumber: number,\n                      body,\n                      contentLength: body.length,\n                    });\n                  }),\n                  { retry: true, retryUnknown: true },\n                )\n                .pipe(\n                  Effect.flatMap((receipt) =>\n                    partReceipt(receipt, number, body.length, endpoint.storage.provider),\n                  ),\n                  Effect.tap(() =>\n                    Effect.gen(function* () {\n                      operation.progress.bytesAcknowledged += body.length;\n                      yield* operation.observe();\n                    }),\n                  ),\n                ),\n            { concurrency: plan.concurrency, unordered: true },\n          ),\n          Stream.runCollect,\n        );\n        checksum = yield* verify();\n        metadata = yield* operation\n          .request(\n            Effect.suspend(() => {\n              unknownCompletion = true;\n              operation.mutationStarted = true;\n              return multipart.complete({\n                upload: handle,\n                parts: parts.toSorted((a, b) => a.partNumber - b.partNumber),\n                ...(request.condition ? { condition: request.condition } : {}),\n              });\n            }),\n            { retry: true },\n          )\n          .pipe(\n            Effect.catch((error) =>\n              Effect.gen(function* () {\n                unknownCompletion = error.mutationOutcome === \"unknown\";\n                return yield* reconcile(runtime, operation, request.key, reader.count(), error);\n              }),\n            ),\n          );\n        completed = true;\n      }\n\n      operation.committed = true;\n      operation.progress.phase = \"committed\";\n      return { metadata, checksum, strategy: plan.strategy, progress: { ...operation.progress } };\n    }),\n  );\n  const transfer = reserved ? work : runtime.lease(plan.workspaceBytes, work);\n  const verified = Effect.gen(function* () {\n    const receipt = yield* transfer;\n    if (existing || (plan.strategy !== \"offset\" && plan.strategy !== \"blocks\")) return receipt;\n    const checked = yield* download(\n      runtime,\n      {\n        ref: receipt.metadata.ref,\n        expectedChecksum: receipt.checksum,\n        target: { write: () => Effect.void },\n      },\n      operation,\n      receipt.metadata,\n    ).pipe(\n      Effect.mapError((error) =>\n        storageError(\"upload.verify\", endpoint.storage.provider, error.reason, \"succeeded\"),\n      ),\n    );\n    return { ...receipt, metadata: checked.metadata, progress: { ...operation.progress } };\n  });\n  const bounded = existing ? verified : runtime.deadline(operation, verified);\n  const receipt = yield* bounded;\n  if (!existing) yield* operation.observe(operation.progress.phase);\n  return receipt;\n});\n"],"mappings":"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"}

package/dist/transfers.d.ts

@@ -0,0 +1,31 @@
+import { Checksum, ObjectRef } from "./core/object.js";
+import { StorageError } from "./core/errors.js";
+import { Storage } from "./core/storage.js";
+import { MultipartHandleCodec } from "./core/contracts/multipart.js";
+import "./index.js";
+import { UploadSource, sources_d_exports } from "./transfers/sources.js";
+import { CopyIntent, CopyRequest, DownloadRequest, DownloadTarget, MoveReceipt, TransferDiagnostic, TransferDigest, TransferEndpoint, TransferPolicy, TransferProgress, TransferReceipt, TransfersService, UploadRequest } from "./transfers/models.js";
+import { TransferDriver, TransferHash } from "./transfers/dependencies.js";
+import { ManagedTransferRuntime } from "./transfers/managed-runtime.js";
+import { Context, Effect, FileSystem, Layer, Path, Stream } from "effect";
+declare const Transfers_base: Context.ServiceClass<Transfers, "@effect-kit/storage/Transfers", TransfersService>;
+export declare class Transfers extends Transfers_base {
+  static readonly make: (policy?: TransferPolicy | undefined) => Effect.Effect<TransfersService, StorageError, import("effect/crypto/SecureRandom").SecureRandom | Storage | TransferDriver | TransferHash>;
+  private static fromRuntime;
+  static layer(policy?: TransferPolicy): Layer.Layer<ManagedTransferRuntime | Transfers, StorageError, import("effect/crypto/SecureRandom").SecureRandom | Storage | TransferDriver | TransferHash>;
+  static upload<E, R>(request: UploadRequest<E, R>): Effect.Effect<TransferReceipt, E | StorageError, R | Transfers>;
+  static download<E, R>(request: DownloadRequest<E, R>): Effect.Effect<TransferReceipt, E | StorageError, R | Transfers>;
+  static copy(request: CopyRequest): Effect.Effect<TransferReceipt, StorageError, Transfers>;
+  static move(request: CopyRequest): Effect.Effect<MoveReceipt, StorageError, Transfers>;
+  static uploadMany<E, R, EX, RX>(requests: Stream.Stream<UploadRequest<E, R>, EX, RX>, concurrency?: number): Stream.Stream<import("effect/Result").Result<TransferReceipt, E | StorageError>, EX | StorageError, R | RX | Transfers>;
+  static downloadMany<E, R, EX, RX>(requests: Stream.Stream<DownloadRequest<E, R>, EX, RX>, concurrency?: number): Stream.Stream<import("effect/Result").Result<TransferReceipt, E | StorageError>, EX | StorageError, R | RX | Transfers>;
+  /** Stages beside the destination, closes the file, then atomically renames after verification. */
+  static readonly downloadFile: (request: {
+    readonly path: string;
+    readonly key?: string;
+    readonly ref?: ObjectRef;
+    readonly expectedChecksum?: Checksum;
+  }) => Effect.Effect<TransferReceipt, import("effect/PlatformError").PlatformError | StorageError, FileSystem.FileSystem | Path.Path | Transfers>;
+}
+export { type CopyIntent, type CopyRequest, type DownloadRequest, type DownloadTarget, type MoveReceipt, type MultipartHandleCodec, type TransferDiagnostic, type TransferDigest, TransferDriver, type TransferEndpoint, TransferHash, type TransferPolicy, type TransferProgress, type TransferReceipt, type TransfersService, type UploadRequest, sources_d_exports as UploadSource, type UploadSource as UploadSourceType };
+//# sourceMappingURL=transfers.d.ts.map

package/dist/transfers.js

@@ -0,0 +1,82 @@
+import { storageError } from "./core/errors.js";
+import { TransferDriver, TransferHash } from "./transfers/dependencies.js";
+import { download } from "./transfers/download.js";
+import { sources_exports } from "./transfers/sources.js";
+import { upload } from "./transfers/upload.js";
+import { copyOrMove } from "./transfers/copy.js";
+import { ManagedTransferRuntime, makeManagedRuntime } from "./transfers/managed-runtime.js";
+import { Context, Effect, FileSystem, Layer, Path, Stream } from "effect";
+
+// src/transfers/index.ts
+var Transfers = class Transfers extends Context.Service()("@effect-kit/storage/Transfers") {
+	static make = Effect.fnUntraced(function* (policy = {}) {
+		return Transfers.fromRuntime(yield* makeManagedRuntime(policy));
+	});
+	static fromRuntime(runtime) {
+		const { endpoint, policy } = runtime;
+		const many = (requests, run, concurrency) => {
+			if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 1024) return Stream.fail(storageError("transfers.many", endpoint.storage.provider, {
+				_tag: "InvalidInput",
+				field: "concurrency"
+			}, "not-started"));
+			return requests.pipe(Stream.mapEffect((request) => Effect.result(run(request)), { concurrency }));
+		};
+		return Transfers.of({
+			endpoint,
+			upload: (request) => upload(runtime, request),
+			download: (request) => download(runtime, request),
+			copy: (request) => copyOrMove(runtime, request, false),
+			move: (request) => copyOrMove(runtime, request, true),
+			uploadMany: (requests, concurrency = policy.partConcurrency) => many(requests, (request) => upload(runtime, request), concurrency),
+			downloadMany: (requests, concurrency = policy.partConcurrency) => many(requests, (request) => download(runtime, request), concurrency),
+			diagnostics: runtime.diagnostics,
+			resources: runtime.resources
+		});
+	}
+	static layer(policy = {}) {
+		return Layer.effectContext(Effect.map(makeManagedRuntime(policy), (runtime) => Context.make(Transfers, Transfers.fromRuntime(runtime)).pipe(Context.add(ManagedTransferRuntime, runtime))));
+	}
+	static upload(request) {
+		return Effect.flatMap(Transfers, (transfers) => transfers.upload(request));
+	}
+	static download(request) {
+		return Effect.flatMap(Transfers, (transfers) => transfers.download(request));
+	}
+	static copy(request) {
+		return Effect.flatMap(Transfers, (transfers) => transfers.copy(request));
+	}
+	static move(request) {
+		return Effect.flatMap(Transfers, (transfers) => transfers.move(request));
+	}
+	static uploadMany(requests, concurrency) {
+		return Stream.unwrap(Effect.map(Transfers, (transfers) => transfers.uploadMany(requests, concurrency)));
+	}
+	static downloadMany(requests, concurrency) {
+		return Stream.unwrap(Effect.map(Transfers, (transfers) => transfers.downloadMany(requests, concurrency)));
+	}
+	/** Stages beside the destination, closes the file, then atomically renames after verification. */
+	static downloadFile = Effect.fn("Transfers.downloadFile")(function* (request) {
+		const transfers = yield* Transfers;
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		return yield* Effect.scoped(Effect.gen(function* () {
+			const temporary = yield* fs.makeTempFileScoped({
+				directory: path.dirname(request.path),
+				prefix: ".effect-storage-"
+			});
+			const receipt = yield* Effect.scoped(Effect.gen(function* () {
+				const file = yield* fs.open(temporary, { flag: "w" });
+				return yield* transfers.download({
+					...request.ref ? { ref: request.ref } : { key: request.key ?? "" },
+					...request.expectedChecksum ? { expectedChecksum: request.expectedChecksum } : {},
+					target: { write: (bytes) => file.writeAll(bytes) }
+				});
+			}));
+			yield* fs.rename(temporary, request.path);
+			return receipt;
+		}));
+	});
+};
+
+export { TransferDriver, TransferHash, Transfers, sources_exports as UploadSource };
+//# sourceMappingURL=transfers.js.map

package/dist/transfers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfers.js","names":[],"sources":["../src/transfers/index.ts"],"sourcesContent":["import { Context, Effect, FileSystem, Layer, Path, Stream } from \"effect\";\n\nimport { storageError } from \"../core/errors.js\";\nimport type { Checksum, ObjectRef } from \"../core/object.js\";\nimport { copyOrMove } from \"./copy.js\";\nimport { download } from \"./download.js\";\nimport { ManagedTransferRuntime, makeManagedRuntime } from \"./managed-runtime.js\";\nimport type {\n  CopyRequest,\n  DownloadRequest,\n  TransferPolicy,\n  TransfersService,\n  UploadRequest,\n} from \"./models.js\";\nimport type { TransferRuntime } from \"./runtime.js\";\nimport { upload } from \"./upload.js\";\n\nexport { TransferDriver, TransferHash } from \"./dependencies.js\";\nexport type { MultipartHandleCodec } from \"../core/contracts/multipart.js\";\n\nexport * as UploadSource from \"./sources.js\";\nexport type {\n  TransferDigest,\n  TransferEndpoint,\n  CopyIntent,\n  TransferProgress,\n  TransferPolicy,\n  UploadRequest,\n  DownloadTarget,\n  DownloadRequest,\n  CopyRequest,\n  TransferReceipt,\n  MoveReceipt,\n  TransferDiagnostic,\n  TransfersService,\n} from \"./models.js\";\nexport type { UploadSource as UploadSourceType } from \"./sources.js\";\n\nexport class Transfers extends Context.Service<Transfers, TransfersService>()(\n  \"@effect-kit/storage/Transfers\",\n) {\n  static readonly make = Effect.fnUntraced(function* (policy: TransferPolicy = {}) {\n    return Transfers.fromRuntime(yield* makeManagedRuntime(policy));\n  });\n\n  private static fromRuntime(runtime: TransferRuntime) {\n    const { endpoint, policy } = runtime;\n    const many = <A, B, E, R, EX, RX>(\n      requests: Stream.Stream<A, EX, RX>,\n      run: (request: A) => Effect.Effect<B, E, R>,\n      concurrency: number,\n    ) => {\n      if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 1024)\n        return Stream.fail(\n          storageError(\n            \"transfers.many\",\n            endpoint.storage.provider,\n            { _tag: \"InvalidInput\", field: \"concurrency\" },\n            \"not-started\",\n          ),\n        );\n      return requests.pipe(\n        Stream.mapEffect((request) => Effect.result(run(request)), { concurrency }),\n      );\n    };\n    return Transfers.of({\n      endpoint,\n      upload: (request) => upload(runtime, request),\n      download: (request) => download(runtime, request),\n      copy: (request) => copyOrMove(runtime, request, false),\n      move: (request) => copyOrMove(runtime, request, true),\n      uploadMany: (requests, concurrency = policy.partConcurrency) =>\n        many(requests, (request) => upload(runtime, request), concurrency),\n      downloadMany: (requests, concurrency = policy.partConcurrency) =>\n        many(requests, (request) => download(runtime, request), concurrency),\n      diagnostics: runtime.diagnostics,\n      resources: runtime.resources,\n    });\n  }\n\n  static layer(policy: TransferPolicy = {}) {\n    return Layer.effectContext(\n      Effect.map(makeManagedRuntime(policy), (runtime) =>\n        Context.make(Transfers, Transfers.fromRuntime(runtime)).pipe(\n          Context.add(ManagedTransferRuntime, runtime),\n        ),\n      ),\n    );\n  }\n\n  static upload<E, R>(request: UploadRequest<E, R>) {\n    return Effect.flatMap(Transfers, (transfers) => transfers.upload(request));\n  }\n\n  static download<E, R>(request: DownloadRequest<E, R>) {\n    return Effect.flatMap(Transfers, (transfers) => transfers.download(request));\n  }\n\n  static copy(request: CopyRequest) {\n    return Effect.flatMap(Transfers, (transfers) => transfers.copy(request));\n  }\n\n  static move(request: CopyRequest) {\n    return Effect.flatMap(Transfers, (transfers) => transfers.move(request));\n  }\n\n  static uploadMany<E, R, EX, RX>(\n    requests: Stream.Stream<UploadRequest<E, R>, EX, RX>,\n    concurrency?: number,\n  ) {\n    return Stream.unwrap(\n      Effect.map(Transfers, (transfers) => transfers.uploadMany(requests, concurrency)),\n    );\n  }\n\n  static downloadMany<E, R, EX, RX>(\n    requests: Stream.Stream<DownloadRequest<E, R>, EX, RX>,\n    concurrency?: number,\n  ) {\n    return Stream.unwrap(\n      Effect.map(Transfers, (transfers) => transfers.downloadMany(requests, concurrency)),\n    );\n  }\n\n  /** Stages beside the destination, closes the file, then atomically renames after verification. */\n  static readonly downloadFile = Effect.fn(\"Transfers.downloadFile\")(function* (request: {\n    readonly path: string;\n    readonly key?: string;\n    readonly ref?: ObjectRef;\n    readonly expectedChecksum?: Checksum;\n  }) {\n    const transfers = yield* Transfers;\n    const fs = yield* FileSystem.FileSystem;\n    const path = yield* Path.Path;\n    return yield* Effect.scoped(\n      Effect.gen(function* () {\n        const temporary = yield* fs.makeTempFileScoped({\n          directory: path.dirname(request.path),\n          prefix: \".effect-storage-\",\n        });\n        const receipt = yield* Effect.scoped(\n          Effect.gen(function* () {\n            const file = yield* fs.open(temporary, { flag: \"w\" });\n            return yield* transfers.download({\n              ...(request.ref ? { ref: request.ref } : { key: request.key ?? \"\" }),\n              ...(request.expectedChecksum ? { expectedChecksum: request.expectedChecksum } : {}),\n              target: { write: (bytes) => file.writeAll(bytes) },\n            });\n          }),\n        );\n        yield* fs.rename(temporary, request.path);\n        return receipt;\n      }),\n    );\n  });\n}\n"],"mappings":"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"}

package/dist/uploads/driver.d.ts

@@ -0,0 +1,22 @@
+import { UploadGrant, UploadRecord, failUpload } from "./schema.js";
+import { StorageError } from "../core/errors.js";
+import { Context, Effect, Layer } from "effect";
+export type UploadFailure = StorageError | ReturnType<typeof failUpload>;
+export interface UploadGrantDriverService {
+  readonly maximumGrantLifetimeMillis?: number;
+  readonly confirmsTermination?: boolean;
+  readonly begin: (record: UploadRecord) => Effect.Effect<unknown, UploadFailure>;
+  readonly grant: (record: UploadRecord, expiresAt: number) => Effect.Effect<UploadGrant, UploadFailure>;
+  readonly part?: (record: UploadRecord, partNumber: number, expiresAt: number, sha256?: string) => Effect.Effect<UploadGrant, UploadFailure>;
+  readonly complete?: (record: UploadRecord, parts: ReadonlyArray<{
+    readonly partNumber: number;
+    readonly receipt: string;
+  }>) => Effect.Effect<void, UploadFailure>;
+  readonly abort: (record: UploadRecord) => Effect.Effect<void, UploadFailure>;
+}
+declare const UploadGrantDriver_base: Context.ServiceClass<UploadGrantDriver, "@effect-kit/storage/UploadGrantDriver", UploadGrantDriverService>;
+export declare class UploadGrantDriver extends UploadGrantDriver_base {
+  static readonly proxy: Layer.Layer<UploadGrantDriver, never, never>;
+}
+export {};
+//# sourceMappingURL=driver.d.ts.map

package/dist/uploads/driver.js

@@ -0,0 +1,18 @@
+import { failUpload } from "./schema.js";
+import { Context, Effect, Layer } from "effect";
+
+// src/uploads/driver.ts
+var UploadGrantDriver = class UploadGrantDriver extends Context.Service()("@effect-kit/storage/UploadGrantDriver") {
+	static proxy = Layer.succeed(UploadGrantDriver, {
+		confirmsTermination: true,
+		begin: (record) => ["auto", "proxy"].includes(record.input.strategy ?? "auto") ? Effect.succeed(null) : Effect.fail(failUpload("Unsupported")),
+		grant: (_record, expiresAt) => Effect.succeed({
+			_tag: "Proxy",
+			expiresAt
+		}),
+		abort: () => Effect.void
+	});
+};
+
+export { UploadGrantDriver };
+//# sourceMappingURL=driver.js.map

package/dist/uploads/driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.js","names":[],"sources":["../../src/uploads/driver.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\n\nimport type { StorageError } from \"../core/errors.js\";\nimport { failUpload } from \"./schema.js\";\nimport type { UploadGrant, UploadRecord } from \"./schema.js\";\nexport type UploadFailure = StorageError | ReturnType<typeof failUpload>;\nexport interface UploadGrantDriverService {\n  readonly maximumGrantLifetimeMillis?: number;\n  readonly confirmsTermination?: boolean;\n  readonly begin: (record: UploadRecord) => Effect.Effect<unknown, UploadFailure>;\n  readonly grant: (\n    record: UploadRecord,\n    expiresAt: number,\n  ) => Effect.Effect<UploadGrant, UploadFailure>;\n  readonly part?: (\n    record: UploadRecord,\n    partNumber: number,\n    expiresAt: number,\n    sha256?: string,\n  ) => Effect.Effect<UploadGrant, UploadFailure>;\n  readonly complete?: (\n    record: UploadRecord,\n    parts: ReadonlyArray<{ readonly partNumber: number; readonly receipt: string }>,\n  ) => Effect.Effect<void, UploadFailure>;\n  readonly abort: (record: UploadRecord) => Effect.Effect<void, UploadFailure>;\n}\nexport class UploadGrantDriver extends Context.Service<\n  UploadGrantDriver,\n  UploadGrantDriverService\n>()(\"@effect-kit/storage/UploadGrantDriver\") {\n  static readonly proxy = Layer.succeed(UploadGrantDriver, {\n    confirmsTermination: true,\n    begin: (record) =>\n      [\"auto\", \"proxy\"].includes(record.input.strategy ?? \"auto\")\n        ? Effect.succeed(null)\n        : Effect.fail(failUpload(\"Unsupported\")),\n    grant: (_record, expiresAt) => Effect.succeed({ _tag: \"Proxy\" as const, expiresAt }),\n    abort: () => Effect.void,\n  });\n}\n"],"mappings":";;;;AA0BA,IAAa,oBAAb,MAAa,0BAA0B,QAAQ,QAG7C,CAAC,CAAC,uCAAuC,CAAC,CAAC;CAC3C,OAAgB,QAAQ,MAAM,QAAQ,mBAAmB;EACvD,qBAAqB;EACrB,QAAQ,WACN,CAAC,QAAQ,OAAO,CAAC,CAAC,SAAS,OAAO,MAAM,YAAY,MAAM,IACtD,OAAO,QAAQ,IAAI,IACnB,OAAO,KAAK,WAAW,aAAa,CAAC;EAC3C,QAAQ,SAAS,cAAc,OAAO,QAAQ;GAAE,MAAM;GAAkB;EAAU,CAAC;EACnF,aAAa,OAAO;CACtB,CAAC;AACH"}

package/dist/uploads/policy.d.ts

@@ -0,0 +1,39 @@
+import { ObjectMetadata } from "../core/object.js";
+import { UploadActor, UploadInput, UploadRecord, failUpload } from "./schema.js";
+import { StorageError } from "../core/errors.js";
+import { Effect } from "effect";
+export type UploadAction = "create" | "grant" | "status" | "complete" | "abort" | "reconcile" | "content";
+export interface UploadDecision {
+  readonly key: string;
+  readonly maxBytes: number;
+  readonly allowedContentTypes: ReadonlyArray<string>;
+  readonly expiresInSeconds: number;
+  readonly context: Readonly<Record<string, string>>;
+}
+export interface UploadOptions<R = never> {
+  /** Both staging and unpublished final objects must be inaccessible to application readers. */
+  readonly quarantine: "private";
+  readonly grantSeconds?: number;
+  readonly authorize: (input: {
+    readonly actor: UploadActor;
+    readonly input: UploadInput;
+    readonly uploadId: string;
+    readonly action: UploadAction;
+  }) => Effect.Effect<UploadDecision, ReturnType<typeof failUpload>, R>;
+  /** Must be idempotent using the supplied key in the application's transaction/outbox. */
+  readonly publish: (input: {
+    readonly idempotencyKey: string;
+    readonly object: ObjectMetadata;
+    readonly context: Readonly<Record<string, string>>;
+  }) => Effect.Effect<unknown, ReturnType<typeof failUpload>, R>;
+  readonly inspect?: (input: {
+    readonly object: ObjectMetadata;
+    readonly file: UploadInput["file"];
+  }) => Effect.Effect<void, ReturnType<typeof failUpload> | StorageError, R>;
+  readonly quota?: {
+    readonly reserve: (input: UploadRecord) => Effect.Effect<void, ReturnType<typeof failUpload>, R>;
+    readonly settle: (input: UploadRecord) => Effect.Effect<void, ReturnType<typeof failUpload>, R>;
+    readonly release: (input: UploadRecord) => Effect.Effect<void, ReturnType<typeof failUpload>, R>;
+  };
+}
+//# sourceMappingURL=policy.d.ts.map