@effect-kit/storage 0.0.0-stage → 0.1.0

package/dist/transfers/download.js

@@ -0,0 +1,132 @@
+import { Checksum } from "../core/object.js";
+import { storageError } from "../core/errors.js";
+import { decodeRequest } from "../internal/request-validation.js";
+import { HeadRequest } from "../core/requests.js";
+import { sameChecksum } from "./reader.js";
+import { Effect, Stream } from "effect";
+
+// src/transfers/download.ts
+function pinnedRequest(endpoint, metadata) {
+	const ref = metadata.ref;
+	if (ref.version && endpoint.storage.capabilities.versionedReads !== "none") return { ref };
+	if (metadata.etag && metadata.etag !== "*" && !metadata.etag.startsWith("W/") && endpoint.storage.capabilities.getConditions.includes("if-match")) return {
+		ref: {
+			storeId: ref.storeId,
+			key: ref.key
+		},
+		condition: {
+			_tag: "IfMatch",
+			etag: metadata.etag
+		}
+	};
+}
+const download = Effect.fn("Transfers.download")(function* (runtime, request, existing, selected, reserved = false) {
+	const operation = existing ?? (yield* runtime.begin("download"));
+	const { endpoint, policy } = runtime;
+	const provider = endpoint.storage.provider;
+	const workspace = policy.maxSourceChunkBytes * 2 + endpoint.transportOverheadBytes + runtime.input.digest.workspaceBytes;
+	if (workspace > policy.memoryBudgetBytes) return yield* storageError("download", provider, {
+		_tag: "QuotaExceeded",
+		limit: policy.memoryBudgetBytes
+	});
+	if (request.expectedChecksum && (request.expectedChecksum.scope !== "full-object" || request.expectedChecksum.algorithm !== runtime.input.digest.algorithm)) return yield* storageError("download", provider, {
+		_tag: "Unsupported",
+		capability: "expected-full-object-checksum"
+	});
+	if (!request.target || typeof request.target.write !== "function") return yield* storageError("download", provider, {
+		_tag: "InvalidInput",
+		field: "target"
+	});
+	if (request.expectedChecksum) yield* decodeRequest(Checksum, request.expectedChecksum, "download", provider);
+	const target = yield* decodeRequest(HeadRequest, {
+		...request.key !== void 0 ? { key: request.key } : {},
+		...request.ref !== void 0 ? { ref: request.ref } : {}
+	}, "download", provider);
+	const work = Effect.gen(function* () {
+		const metadata = selected ?? (yield* operation.request(endpoint.storage.head(target), { retry: true }));
+		const pinned = pinnedRequest(endpoint, metadata);
+		const maximum = Math.min(policy.maxBytes, endpoint.maximumObjectBytes);
+		if (metadata.size !== void 0 && metadata.size > maximum) return yield* storageError("download", provider, {
+			_tag: "LimitExceeded",
+			limit: maximum
+		});
+		operation.progress.totalBytes = metadata.size;
+		const hash = runtime.input.digest.create();
+		let offset = 0;
+		let targetFailed = false;
+		let complete = false;
+		yield* operation.request(Effect.suspend(() => Effect.scoped(Effect.gen(function* () {
+			if (offset > 0 && (!pinned || !endpoint.storage.capabilities.ranges.includes("from") || metadata.size === void 0)) return yield* storageError("download", provider, {
+				_tag: "Unsupported",
+				capability: "pinned-download-continuation"
+			});
+			const start = offset;
+			const response = yield* endpoint.storage.get({
+				...pinned ?? target,
+				...offset > 0 ? { range: {
+					_tag: "From",
+					start: offset
+				} } : {}
+			});
+			if (response._tag !== "Object") return yield* storageError("download", provider, { _tag: "NotModified" });
+			if (pinned && metadata.etag !== void 0 && response.metadata.etag !== metadata.etag) return yield* storageError("download", provider, { _tag: "PreconditionFailed" });
+			if (offset > 0 && (!response.range || response.range.start !== offset || response.range.totalSize !== metadata.size)) return yield* storageError("download", provider, { _tag: "IntegrityMismatch" });
+			yield* Stream.runForEach(response.body, (chunk) => Effect.gen(function* () {
+				if (chunk.buffer.byteLength > policy.maxSourceChunkBytes) return yield* storageError("download", provider, {
+					_tag: "LimitExceeded",
+					limit: policy.maxSourceChunkBytes
+				});
+				if (offset + chunk.length > maximum) return yield* storageError("download", provider, {
+					_tag: "LimitExceeded",
+					limit: maximum
+				});
+				if (metadata.size !== void 0 && offset + chunk.length > metadata.size) return yield* storageError("download", provider, {
+					_tag: "LengthMismatch",
+					expected: metadata.size,
+					actual: offset + chunk.length
+				});
+				operation.progress.bytesRead += chunk.length;
+				hash.update(chunk);
+				targetFailed = true;
+				yield* request.target.write(chunk);
+				targetFailed = false;
+				offset += chunk.length;
+				operation.progress.bytesAcknowledged = offset;
+				yield* operation.observe();
+			}));
+			const received = offset - start;
+			if (response.contentLength !== void 0 && received !== response.contentLength) return yield* storageError("download", provider, {
+				_tag: "LengthMismatch",
+				expected: response.contentLength,
+				actual: received
+			});
+			if (metadata.size !== void 0 && offset !== metadata.size) return yield* storageError("download", provider, {
+				_tag: "LengthMismatch",
+				expected: metadata.size,
+				actual: offset
+			});
+			complete = true;
+		}))), {
+			retry: true,
+			canRetry: () => !targetFailed && (offset === 0 || pinned !== void 0 && offset < (metadata.size ?? 0))
+		});
+		const checksum = hash.finish();
+		const expected = request.expectedChecksum ?? metadata.checksums?.find((candidate) => candidate.scope === "full-object" && candidate.algorithm === checksum.algorithm);
+		if (!complete || expected && !sameChecksum(checksum, expected)) return yield* storageError("download", provider, { _tag: "IntegrityMismatch" });
+		operation.progress.bytesVerified = offset;
+		operation.progress.phase = "verified";
+		return {
+			metadata,
+			checksum,
+			strategy: "download",
+			progress: { ...operation.progress }
+		};
+	});
+	const transfer = reserved ? work : runtime.lease(workspace, work);
+	const receipt = yield* existing ? transfer : runtime.deadline(operation, transfer);
+	if (!existing) yield* operation.observe("verified");
+	return receipt;
+});
+
+export { download, pinnedRequest };
+//# sourceMappingURL=download.js.map

package/dist/transfers/download.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"download.js","names":[],"sources":["../../src/transfers/download.ts"],"sourcesContent":["import { Effect, Stream } from \"effect\";\n\nimport type { StorageError } from \"../core/errors.js\";\nimport { storageError } from \"../core/errors.js\";\nimport type { ObjectMetadata } from \"../core/object.js\";\nimport { Checksum } from \"../core/object.js\";\nimport type { GetRequest } from \"../core/requests.js\";\nimport { HeadRequest } from \"../core/requests.js\";\nimport { decodeRequest } from \"../internal/request-validation.js\";\nimport type { DownloadRequest, TransferEndpoint, TransferReceipt } from \"./models.js\";\nimport { sameChecksum } from \"./reader.js\";\nimport type { Operation, TransferRuntime } from \"./runtime.js\";\n\nexport function pinnedRequest(\n  endpoint: TransferEndpoint,\n  metadata: ObjectMetadata,\n): GetRequest | undefined {\n  const ref = metadata.ref;\n  if (ref.version && endpoint.storage.capabilities.versionedReads !== \"none\") return { ref };\n  if (\n    metadata.etag &&\n    metadata.etag !== \"*\" &&\n    !metadata.etag.startsWith(\"W/\") &&\n    endpoint.storage.capabilities.getConditions.includes(\"if-match\")\n  )\n    return {\n      ref: { storeId: ref.storeId, key: ref.key },\n      condition: { _tag: \"IfMatch\", etag: metadata.etag },\n    };\n  return undefined;\n}\n\nexport const download = Effect.fn(\"Transfers.download\")(function* <E, R>(\n  runtime: TransferRuntime,\n  request: DownloadRequest<E, R>,\n  existing?: Operation,\n  selected?: ObjectMetadata,\n  reserved = false,\n): Effect.fn.Return<TransferReceipt, StorageError | E, R> {\n  const operation = existing ?? (yield* runtime.begin(\"download\"));\n  const { endpoint, policy } = runtime;\n  const provider = endpoint.storage.provider;\n  const workspace =\n    policy.maxSourceChunkBytes * 2 +\n    endpoint.transportOverheadBytes +\n    runtime.input.digest.workspaceBytes;\n  if (workspace > policy.memoryBudgetBytes)\n    return yield* storageError(\"download\", provider, {\n      _tag: \"QuotaExceeded\",\n      limit: policy.memoryBudgetBytes,\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(\"download\", provider, {\n      _tag: \"Unsupported\",\n      capability: \"expected-full-object-checksum\",\n    });\n  if (!request.target || typeof request.target.write !== \"function\")\n    return yield* storageError(\"download\", provider, { _tag: \"InvalidInput\", field: \"target\" });\n  if (request.expectedChecksum)\n    yield* decodeRequest(Checksum, request.expectedChecksum, \"download\", provider);\n\n  const target = yield* decodeRequest(\n    HeadRequest,\n    {\n      ...(request.key !== undefined ? { key: request.key } : {}),\n      ...(request.ref !== undefined ? { ref: request.ref } : {}),\n    },\n    \"download\",\n    provider,\n  );\n  const work = Effect.gen(function* () {\n    const metadata =\n      selected ?? (yield* operation.request(endpoint.storage.head(target), { retry: true }));\n    const pinned = pinnedRequest(endpoint, metadata);\n    const maximum = Math.min(policy.maxBytes, endpoint.maximumObjectBytes);\n    if (metadata.size !== undefined && metadata.size > maximum)\n      return yield* storageError(\"download\", provider, { _tag: \"LimitExceeded\", limit: maximum });\n    operation.progress.totalBytes = metadata.size;\n    const hash = runtime.input.digest.create();\n    let offset = 0;\n    let targetFailed = false;\n    let complete = false;\n\n    yield* operation.request(\n      Effect.suspend(() =>\n        Effect.scoped(\n          Effect.gen(function* () {\n            if (\n              offset > 0 &&\n              (!pinned ||\n                !endpoint.storage.capabilities.ranges.includes(\"from\") ||\n                metadata.size === undefined)\n            )\n              return yield* storageError(\"download\", provider, {\n                _tag: \"Unsupported\",\n                capability: \"pinned-download-continuation\",\n              });\n            const start = offset;\n            const response = yield* endpoint.storage.get({\n              ...(pinned ?? target),\n              ...(offset > 0 ? { range: { _tag: \"From\" as const, start: offset } } : {}),\n            });\n            if (response._tag !== \"Object\")\n              return yield* storageError(\"download\", provider, { _tag: \"NotModified\" });\n            if (pinned && metadata.etag !== undefined && response.metadata.etag !== metadata.etag)\n              return yield* storageError(\"download\", provider, { _tag: \"PreconditionFailed\" });\n            if (\n              offset > 0 &&\n              (!response.range ||\n                response.range.start !== offset ||\n                response.range.totalSize !== metadata.size)\n            )\n              return yield* storageError(\"download\", provider, { _tag: \"IntegrityMismatch\" });\n\n            yield* Stream.runForEach(response.body, (chunk) =>\n              Effect.gen(function* () {\n                if (chunk.buffer.byteLength > policy.maxSourceChunkBytes)\n                  return yield* storageError(\"download\", provider, {\n                    _tag: \"LimitExceeded\",\n                    limit: policy.maxSourceChunkBytes,\n                  });\n                if (offset + chunk.length > maximum)\n                  return yield* storageError(\"download\", provider, {\n                    _tag: \"LimitExceeded\",\n                    limit: maximum,\n                  });\n                if (metadata.size !== undefined && offset + chunk.length > metadata.size)\n                  return yield* storageError(\"download\", provider, {\n                    _tag: \"LengthMismatch\",\n                    expected: metadata.size,\n                    actual: offset + chunk.length,\n                  });\n                operation.progress.bytesRead += chunk.length;\n                hash.update(chunk);\n                targetFailed = true;\n                yield* request.target.write(chunk);\n                targetFailed = false;\n                offset += chunk.length;\n                operation.progress.bytesAcknowledged = offset;\n                yield* operation.observe();\n              }),\n            );\n            const received = offset - start;\n            if (response.contentLength !== undefined && received !== response.contentLength)\n              return yield* storageError(\"download\", provider, {\n                _tag: \"LengthMismatch\",\n                expected: response.contentLength,\n                actual: received,\n              });\n            if (metadata.size !== undefined && offset !== metadata.size)\n              return yield* storageError(\"download\", provider, {\n                _tag: \"LengthMismatch\",\n                expected: metadata.size,\n                actual: offset,\n              });\n            complete = true;\n          }),\n        ),\n      ),\n      {\n        retry: true,\n        canRetry: () =>\n          !targetFailed &&\n          (offset === 0 || (pinned !== undefined && offset < (metadata.size ?? 0))),\n      },\n    );\n\n    const checksum = hash.finish();\n    const expected =\n      request.expectedChecksum ??\n      metadata.checksums?.find(\n        (candidate) =>\n          candidate.scope === \"full-object\" && candidate.algorithm === checksum.algorithm,\n      );\n    if (!complete || (expected && !sameChecksum(checksum, expected)))\n      return yield* storageError(\"download\", provider, { _tag: \"IntegrityMismatch\" });\n    operation.progress.bytesVerified = offset;\n    operation.progress.phase = \"verified\";\n    return {\n      metadata,\n      checksum,\n      strategy: \"download\" as const,\n      progress: { ...operation.progress },\n    };\n  });\n  const transfer = reserved ? work : runtime.lease(workspace, work);\n  const bounded = existing ? transfer : runtime.deadline(operation, transfer);\n  const receipt = yield* bounded;\n  if (!existing) yield* operation.observe(\"verified\");\n  return receipt;\n});\n"],"mappings":"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"}

package/dist/transfers/managed-runtime.d.ts

@@ -0,0 +1,34 @@
+import { StorageError } from "../core/errors.js";
+import "../core/storage.js";
+import "../index.js";
+import { TransferConfiguration, TransferDiagnostic, TransferEndpoint } from "./models.js";
+import "./dependencies.js";
+import { ResolvedPolicy } from "./planner.js";
+import { Operation } from "./runtime.js";
+import { Context, Effect } from "effect";
+import { SecureRandom } from "effect/crypto";
+declare const ManagedTransferRuntime_base: Context.ServiceClass<ManagedTransferRuntime, "@effect-kit/storage/internal/ManagedTransferRuntime", {
+  endpoint: TransferEndpoint;
+  newId: () => Effect.Effect<string, never, never>;
+  input: TransferConfiguration;
+  policy: ResolvedPolicy;
+  begin: (operation: "copy" | "download" | "move" | "upload", totalBytes?: number | undefined) => Effect.Effect<Operation, never, never>;
+  diagnostic: (entry: TransferDiagnostic) => Effect.Effect<void, never, never>;
+  diagnostics: Effect.Effect<{
+    entries: TransferDiagnostic[];
+    dropped: number;
+  }, never, never>;
+  resources: Effect.Effect<{
+    reservedBytes: number;
+    peakReservedBytes: number;
+    activeRequests: number;
+    peakActiveRequests: number;
+  }, never, never>;
+  cleanupRequest: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+  lease: <A, E, R>(bytes: number, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+  deadline: <A, E, R>(operation: Operation, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | StorageError, R>;
+}>;
+/** Companion provided by Transfers.layer so sessions share its exact admission state. */
+export declare class ManagedTransferRuntime extends ManagedTransferRuntime_base {}
+export {};
+//# sourceMappingURL=managed-runtime.d.ts.map

package/dist/transfers/managed-runtime.js

@@ -0,0 +1,30 @@
+import { storageError } from "../core/errors.js";
+import { Storage } from "../core/storage.js";
+import { TransferDriver, TransferHash } from "./dependencies.js";
+import { resolvePolicy } from "./planner.js";
+import { makeRuntime } from "./runtime.js";
+import { Context, Effect } from "effect";
+import { SecureRandom } from "effect/crypto";
+
+// src/transfers/managed-runtime.ts
+/** Companion provided by Transfers.layer so sessions share its exact admission state. */
+var ManagedTransferRuntime = class extends Context.Service()("@effect-kit/storage/internal/ManagedTransferRuntime") {};
+const makeManagedRuntime = Effect.fnUntraced(function* (policy = {}) {
+	const storage = yield* Storage;
+	const endpoint = yield* TransferDriver;
+	const digest = yield* TransferHash;
+	const random = yield* SecureRandom.SecureRandom;
+	if (endpoint.storage !== storage) return yield* storageError("transfers.make", storage.provider, {
+		_tag: "InvalidConfiguration",
+		field: "driver.storage"
+	});
+	const input = {
+		...policy,
+		digest
+	};
+	const resolved = yield* resolvePolicy(input, endpoint);
+	return makeRuntime(endpoint, input, resolved, random);
+});
+
+export { ManagedTransferRuntime, makeManagedRuntime };
+//# sourceMappingURL=managed-runtime.js.map

package/dist/transfers/managed-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-runtime.js","names":[],"sources":["../../src/transfers/managed-runtime.ts"],"sourcesContent":["import { Context, Effect } from \"effect\";\nimport { SecureRandom } from \"effect/crypto\";\n\nimport { storageError } from \"../core/errors.js\";\nimport { Storage } from \"../core/storage.js\";\nimport { TransferDriver, TransferHash } from \"./dependencies.js\";\nimport type { TransferPolicy } from \"./models.js\";\nimport { resolvePolicy } from \"./planner.js\";\nimport { makeRuntime } from \"./runtime.js\";\nimport type { TransferRuntime } from \"./runtime.js\";\n\n/** Companion provided by Transfers.layer so sessions share its exact admission state. */\nexport class ManagedTransferRuntime extends Context.Service<\n  ManagedTransferRuntime,\n  TransferRuntime\n>()(\"@effect-kit/storage/internal/ManagedTransferRuntime\") {}\n\nexport const makeManagedRuntime = Effect.fnUntraced(function* (policy: TransferPolicy = {}) {\n  const storage = yield* Storage;\n  const endpoint = yield* TransferDriver;\n  const digest = yield* TransferHash;\n  const random = yield* SecureRandom.SecureRandom;\n\n  if (endpoint.storage !== storage)\n    return yield* storageError(\"transfers.make\", storage.provider, {\n      _tag: \"InvalidConfiguration\",\n      field: \"driver.storage\",\n    });\n\n  const input = { ...policy, digest };\n  const resolved = yield* resolvePolicy(input, endpoint);\n  return makeRuntime(endpoint, input, resolved, random);\n});\n"],"mappings":";;;;;;;;;;AAYA,IAAa,yBAAb,cAA4C,QAAQ,QAGlD,CAAC,CAAC,qDAAqD,CAAC,CAAC,CAAC;AAE5D,MAAa,qBAAqB,OAAO,WAAW,WAAW,SAAyB,CAAC,GAAG;CAC1F,MAAM,UAAU,OAAO;CACvB,MAAM,WAAW,OAAO;CACxB,MAAM,SAAS,OAAO;CACtB,MAAM,SAAS,OAAO,aAAa;CAEnC,IAAI,SAAS,YAAY,SACvB,OAAO,OAAO,aAAa,kBAAkB,QAAQ,UAAU;EAC7D,MAAM;EACN,OAAO;CACT,CAAC;CAEH,MAAM,QAAQ;EAAE,GAAG;EAAQ;CAAO;CAClC,MAAM,WAAW,OAAO,cAAc,OAAO,QAAQ;CACrD,OAAO,YAAY,UAAU,OAAO,UAAU,MAAM;AACtD,CAAC"}

package/dist/transfers/models.d.ts

@@ -0,0 +1,160 @@
+import { Checksum, ObjectHeaders, ObjectMetadata, ObjectRef } from "../core/object.js";
+import { StorageError } from "../core/errors.js";
+import { WriteCondition } from "../core/requests.js";
+import { StorageService } from "../core/storage.js";
+import { MultipartHandle, MultipartHandleCodec, MultipartUploads, UploadedPart } from "../core/contracts/multipart.js";
+import { BlockUploads, OffsetUploads } from "../core/contracts/resumable.js";
+import { UploadSource } from "./sources.js";
+import { Effect, Result, Stream } from "effect";
+/** Implementations must hash incrementally, retaining no input buffers. */
+export interface TransferDigest {
+  readonly algorithm: string;
+  readonly workspaceBytes: number;
+  readonly create: () => {
+    readonly update: (bytes: Uint8Array) => void;
+    readonly finish: () => Checksum;
+    readonly snapshot?: () => Checksum;
+  };
+}
+/** A provider supplies protocol operations, never transfer orchestration or retries. */
+export interface TransferEndpoint {
+  /** Original backend identity retained by facades to reject false cross-store isolation. */
+  readonly underlyingStoreId?: string;
+  /** Physical backends touched by a composite endpoint, including every mirror replica. */
+  readonly underlyingStoreIds?: ReadonlyArray<string>;
+  readonly storage: StorageService;
+  readonly maximumObjectBytes: number;
+  readonly maximumSingleUploadBytes: number;
+  readonly transportOverheadBytes: number;
+  readonly validateUpload?: ((request: {
+    readonly key: string;
+    readonly headers: ObjectHeaders;
+    readonly condition?: WriteCondition | undefined;
+  }) => Effect.Effect<void, StorageError>) | undefined;
+  readonly offsets?: OffsetUploads | undefined;
+  readonly blocks?: BlockUploads | undefined;
+  readonly multipart?: MultipartUploads | undefined;
+  readonly handles?: MultipartHandleCodec | undefined;
+  readonly nativeCopy?: {
+    readonly maximumBytes: number;
+    readonly accepts: (source: TransferEndpoint) => boolean;
+    readonly copy: (request: CopyIntent) => Effect.Effect<ObjectMetadata, StorageError>;
+    readonly part?: (request: CopyIntent & {
+      readonly upload: MultipartHandle;
+      readonly partNumber: number;
+      readonly start: number;
+      readonly end: number;
+    }) => Effect.Effect<UploadedPart, StorageError>;
+  } | undefined;
+  /** Return a receipt only when it proves this exact operation committed. */
+  readonly reconcile?: (intent: {
+    readonly key: string;
+    readonly operationId: string;
+    readonly size: number;
+  }) => Effect.Effect<ObjectMetadata | undefined, StorageError>;
+}
+export interface CopyIntent {
+  readonly source: TransferEndpoint;
+  readonly ref: ObjectRef;
+  readonly etag?: string | undefined;
+  readonly destinationKey: string;
+  readonly headers: ObjectHeaders;
+  readonly condition?: WriteCondition | undefined;
+}
+export interface TransferProgress {
+  readonly operation: "upload" | "download" | "copy" | "move";
+  readonly phase: "running" | "committed" | "verified";
+  readonly totalBytes?: number | undefined;
+  readonly bytesRead: number;
+  /** Payload offered to protocol calls, including retries, rather than socket-level counts. */
+  readonly bytesSent: number;
+  readonly bytesAcknowledged: number;
+  readonly bytesVerified: number;
+  readonly attempts: number;
+}
+export interface TransferPolicy {
+  readonly memoryBudgetBytes?: number;
+  readonly partBytes?: number;
+  readonly partConcurrency?: number;
+  readonly requestConcurrency?: number;
+  readonly maxSourceChunkBytes?: number;
+  readonly maxBytes?: number;
+  readonly deadlineMillis?: number;
+  /** Total protocol requests per logical operation, including HEADs and retries. */
+  readonly maxAttempts?: number;
+  readonly retryBaseMillis?: number;
+  readonly retryMaxMillis?: number;
+  readonly cleanupTimeoutMillis?: number;
+  readonly observerTimeoutMillis?: number;
+  readonly observer?: (progress: TransferProgress) => Effect.Effect<void, unknown>;
+}
+export type TransferConfiguration = TransferPolicy & {
+  readonly digest: TransferDigest;
+};
+export interface UploadRequest<E = never, R = never> {
+  readonly key: string;
+  readonly source: UploadSource<E, R>;
+  readonly headers?: ObjectHeaders;
+  readonly condition?: WriteCondition;
+  readonly expectedChecksum?: Checksum;
+  readonly strategy?: "auto" | "single" | "multipart" | "offset" | "blocks";
+}
+export interface DownloadTarget<E = never, R = never> {
+  /** Completion acknowledges that the entire chunk has been accepted, in order. */
+  readonly write: (bytes: Uint8Array) => Effect.Effect<void, E, R>;
+}
+export interface DownloadRequest<E = never, R = never> {
+  readonly key?: string;
+  readonly ref?: ObjectRef;
+  readonly target: DownloadTarget<E, R>;
+  readonly expectedChecksum?: Checksum;
+}
+export interface CopyRequest {
+  /** Destination header overrides; unspecified source headers are preserved. */
+  readonly headers?: ObjectHeaders;
+  readonly source: TransferEndpoint;
+  readonly ref: ObjectRef;
+  readonly destinationKey: string;
+  readonly condition?: WriteCondition;
+}
+export interface TransferReceipt {
+  readonly metadata: ObjectMetadata;
+  readonly strategy: "single" | "multipart" | "offset" | "blocks" | "download" | "native-copy" | "multipart-copy" | "streamed-copy";
+  readonly checksum: Checksum;
+  readonly progress: TransferProgress;
+}
+export type MoveReceipt = {
+  readonly _tag: "Moved";
+  readonly destination: TransferReceipt;
+} | {
+  readonly _tag: "Copied";
+  readonly destination: TransferReceipt;
+  readonly deleteError: StorageError;
+};
+/** Safe bounded diagnostics. Upload handles remain redacted and are never metric labels. */
+export interface TransferDiagnostic {
+  readonly kind: "observer" | "cleanup" | "unknown-outcome";
+  readonly operationId: string;
+  readonly upload?: MultipartHandle | undefined;
+  readonly error?: StorageError | undefined;
+}
+export interface TransfersService {
+  readonly endpoint: TransferEndpoint;
+  readonly upload: <E = never, R = never>(request: UploadRequest<E, R>) => Effect.Effect<TransferReceipt, StorageError | E, R>;
+  readonly download: <E = never, R = never>(request: DownloadRequest<E, R>) => Effect.Effect<TransferReceipt, StorageError | E, R>;
+  readonly copy: (request: CopyRequest) => Effect.Effect<TransferReceipt, StorageError>;
+  readonly move: (request: CopyRequest) => Effect.Effect<MoveReceipt, StorageError>;
+  readonly uploadMany: <E, R, EX, RX>(requests: Stream.Stream<UploadRequest<E, R>, EX, RX>, concurrency?: number) => Stream.Stream<Result.Result<TransferReceipt, StorageError | E>, EX | StorageError, R | RX>;
+  readonly downloadMany: <E, R, EX, RX>(requests: Stream.Stream<DownloadRequest<E, R>, EX, RX>, concurrency?: number) => Stream.Stream<Result.Result<TransferReceipt, StorageError | E>, EX | StorageError, R | RX>;
+  readonly diagnostics: Effect.Effect<{
+    readonly entries: ReadonlyArray<TransferDiagnostic>;
+    readonly dropped: number;
+  }>;
+  readonly resources: Effect.Effect<{
+    readonly reservedBytes: number;
+    readonly peakReservedBytes: number;
+    readonly activeRequests: number;
+    readonly peakActiveRequests: number;
+  }>;
+}
+//# sourceMappingURL=models.d.ts.map

package/dist/transfers/native-upload.js

@@ -0,0 +1,195 @@
+import { Checksum, ObjectRef } from "../core/object.js";
+import { storageError } from "../core/errors.js";
+import { makeReader, sameChecksum } from "./reader.js";
+import { Effect, Schema } from "effect";
+import { Base64 } from "effect/encoding";
+
+// src/transfers/native-upload.ts
+const NativeHandle = Schema.Struct({
+	protocol: Schema.String,
+	ref: ObjectRef,
+	handle: Schema.Redacted(Schema.String)
+});
+const SavedBlock = Schema.Struct({
+	blockId: Schema.String,
+	size: Schema.Natural,
+	sourceChecksum: Checksum
+});
+/** Offset cursors and named blocks retain their own reconciliation semantics. */
+const nativeUpload = Effect.fnUntraced(function* (runtime, request, headers, operation, plan, journal) {
+	const { endpoint, policy } = runtime;
+	const fail = (capability) => storageError("upload", endpoint.storage.provider, {
+		_tag: "Unsupported",
+		capability
+	}, "not-started");
+	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.fnUntraced(function* () {
+		if ((yield* reader.next(1)) !== void 0) return yield* storageError("upload", endpoint.storage.provider, {
+			_tag: "LengthMismatch",
+			expected: request.source.length ?? reader.count() - 1,
+			actual: reader.count()
+		}, "not-started");
+		const checksum = reader.checksum();
+		if (!checksum || 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 === "offset") {
+		const offsets = endpoint.offsets;
+		const length = request.source.length;
+		if (!offsets || length === void 0) return yield* fail("offset-known-source");
+		if (length === 0) yield* verify();
+		if (journal) yield* journal.initiating;
+		const handle = journal?.handle ?? (yield* operation.request(offsets.create({
+			key: request.key,
+			...headers,
+			contentLength: length,
+			...request.condition ? { condition: request.condition } : {}
+		}).pipe(Effect.catch((error) => Effect.gen(function* () {
+			if (error.mutationOutcome === "unknown") yield* runtime.diagnostic({
+				kind: "unknown-outcome",
+				operationId: operation.id
+			});
+			return yield* error;
+		})))));
+		if (journal && !journal.handle) yield* journal.initiated(handle);
+		let completionStarted = false;
+		let committed = false;
+		if (!journal) yield* Effect.addFinalizer(() => committed || completionStarted ? Effect.void : runtime.cleanupRequest(offsets.cancel(handle)).pipe(Effect.timeout(policy.cleanupTimeoutMillis), Effect.result, Effect.flatMap((result) => result._tag === "Failure" ? runtime.diagnostic({
+			kind: "cleanup",
+			operationId: operation.id
+		}) : Effect.void)));
+		let remote = yield* operation.request(offsets.query(handle), { retry: true });
+		let position = 0;
+		let pending = /* @__PURE__ */ new Uint8Array();
+		while (remote._tag === "Uploading") {
+			const offset = remote.committedOffset;
+			if (!Number.isSafeInteger(offset) || offset < position || offset > length || offset > position + pending.length && position !== 0) return yield* storageError("query", endpoint.storage.provider, { _tag: "InvalidSession" }, "unknown");
+			if (position === 0 && pending.length === 0 && offset > 0) {
+				while (reader.count() < offset) if (!(yield* reader.next(Math.min(plan.partBytes, offset - reader.count())))) return yield* storageError("upload", endpoint.storage.provider, { _tag: "IntegrityMismatch" }, "not-started");
+			} else pending = pending.slice(offset - position);
+			position = offset;
+			if (pending.length < plan.partBytes && reader.count() < length) {
+				const next = yield* reader.next(Math.min(plan.partBytes - pending.length, length - reader.count()));
+				if (!next) return yield* storageError("upload", endpoint.storage.provider, {
+					_tag: "LengthMismatch",
+					expected: length,
+					actual: reader.count()
+				}, "not-started");
+				const joined = new Uint8Array(pending.length + next.length);
+				joined.set(pending);
+				joined.set(next, pending.length);
+				pending = joined;
+			}
+			const final = position + pending.length === length;
+			if (final) {
+				yield* verify();
+				if (journal) yield* journal.completing;
+				completionStarted = true;
+				operation.mutationStarted = true;
+			}
+			const offeredEnd = position + pending.length;
+			remote = yield* operation.request(Effect.suspend(() => {
+				operation.progress.bytesSent += pending.length;
+				return offsets.write({
+					upload: handle,
+					offset: position,
+					body: pending,
+					contentLength: pending.length,
+					final
+				});
+			})).pipe(Effect.catch((error) => error.mutationOutcome === "unknown" || error.reason._tag === "TransportFailure" ? operation.request(offsets.query(handle), { retry: true }) : Effect.fail(error)));
+			if (remote._tag === "Uploading" && (remote.committedOffset < position || remote.committedOffset > offeredEnd)) return yield* storageError("query", endpoint.storage.provider, { _tag: "InvalidSession" }, "unknown");
+			if (journal && remote._tag === "Uploading") yield* journal.acknowledged(remote.committedOffset);
+			if (remote._tag === "Uploading") operation.progress.bytesAcknowledged = remote.committedOffset;
+			yield* operation.observe();
+		}
+		if (remote._tag !== "Completed") return yield* storageError("upload", endpoint.storage.provider, { _tag: remote._tag === "Expired" ? "Expired" : "InvalidSession" }, "unknown");
+		while (reader.count() < length) if (!(yield* reader.next(Math.min(plan.partBytes, length - reader.count())))) break;
+		checksum = yield* verify();
+		metadata = offsets.resolveCompletion ? yield* operation.request(offsets.resolveCompletion(handle), { retry: true }) : remote.metadata;
+		committed = true;
+	} else {
+		const blocks = endpoint.blocks;
+		if (!blocks) return yield* fail("blocks");
+		const ref = {
+			storeId: endpoint.storage.storeId,
+			key: request.key
+		};
+		const inventory = yield* operation.request(blocks.list(ref), { retry: true });
+		const observed = new Map([...inventory.committed, ...inventory.uncommitted].map((block) => [block.blockId, block.size]));
+		const ids = [];
+		while (true) {
+			const body = yield* reader.next(plan.partBytes);
+			if (!body) break;
+			if (ids.length >= blocks.limits.maximumBlocks) return yield* fail("maximum-blocks");
+			const blockId = Base64.encode(new TextEncoder().encode(operation.id.slice(0, 32).padEnd(32, "0") + ids.length.toString(16).padStart(8, "0")));
+			ids.push(blockId);
+			const digest = runtime.input.digest.create();
+			digest.update(body);
+			const sourceChecksum = digest.finish();
+			const saved = journal?.blocks.find((block) => block.blockId === blockId);
+			if (!saved || saved.size !== body.length || !sameChecksum(saved.sourceChecksum, sourceChecksum) || observed.get(blockId) !== body.length) yield* operation.request(Effect.suspend(() => {
+				operation.progress.bytesSent += body.length;
+				return blocks.stage({
+					ref,
+					blockId,
+					body,
+					contentLength: body.length
+				});
+			}), {
+				retry: true,
+				retryUnknown: true
+			});
+			if (journal) yield* journal.acknowledged(reader.count(), {
+				blockId,
+				size: body.length,
+				sourceChecksum
+			});
+			operation.progress.bytesAcknowledged = reader.count();
+			yield* operation.observe();
+		}
+		checksum = yield* verify();
+		if (journal) yield* journal.completing;
+		operation.mutationStarted = true;
+		metadata = yield* operation.request(blocks.commit({
+			ref,
+			blockIds: ids,
+			headers,
+			...request.condition ? { condition: request.condition } : {}
+		})).pipe(Effect.catch((error) => {
+			if (error.mutationOutcome !== "unknown" || !endpoint.reconcile) return Effect.fail(error);
+			return operation.request(endpoint.reconcile({
+				key: request.key,
+				operationId: operation.id,
+				size: reader.count()
+			})).pipe(Effect.flatMap((found) => found ? Effect.succeed(found) : Effect.fail(error)));
+		}));
+		metadata = {
+			...metadata,
+			size: reader.count()
+		};
+	}
+	if (metadata.ref.storeId !== endpoint.storage.storeId || metadata.ref.key !== request.key || metadata.size !== void 0 && metadata.size !== reader.count()) return yield* storageError("upload", endpoint.storage.provider, { _tag: "IntegrityMismatch" }, "unknown");
+	operation.committed = true;
+	operation.progress.bytesAcknowledged = reader.count();
+	operation.progress.phase = "committed";
+	if (journal) yield* journal.committed(metadata);
+	return {
+		metadata,
+		checksum,
+		strategy: plan.strategy,
+		progress: { ...operation.progress }
+	};
+});
+
+export { NativeHandle, SavedBlock, nativeUpload };
+//# sourceMappingURL=native-upload.js.map

package/dist/transfers/native-upload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-upload.js","names":[],"sources":["../../src/transfers/native-upload.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\nimport { Base64 } from \"effect/encoding\";\n\nimport type { ResumableHandle } from \"../core/contracts/resumable.js\";\nimport type { StorageError } from \"../core/errors.js\";\nimport { storageError } from \"../core/errors.js\";\nimport { Checksum, ObjectRef } from \"../core/object.js\";\nimport type { ObjectHeaders, ObjectMetadata } from \"../core/object.js\";\nimport type { UploadRequest } from \"./models.js\";\nimport type { UploadPlan } from \"./planner.js\";\nimport { makeReader, sameChecksum } from \"./reader.js\";\nimport type { Operation, TransferRuntime } from \"./runtime.js\";\n\nexport const NativeHandle = Schema.Struct({\n  protocol: Schema.String,\n  ref: ObjectRef,\n  handle: Schema.Redacted(Schema.String),\n});\nexport const SavedBlock = Schema.Struct({\n  blockId: Schema.String,\n  size: Schema.Natural,\n  sourceChecksum: Checksum,\n});\nexport type SavedBlock = typeof SavedBlock.Type;\nexport interface NativeJournal {\n  readonly handle?: ResumableHandle | undefined;\n  readonly blocks: ReadonlyArray<SavedBlock>;\n  readonly initiating: Effect.Effect<void, StorageError>;\n  readonly initiated: (handle: ResumableHandle) => Effect.Effect<void, StorageError>;\n  readonly acknowledged: (offset: number, block?: SavedBlock) => Effect.Effect<void, StorageError>;\n  readonly completing: Effect.Effect<void, StorageError>;\n  readonly committed: (metadata: ObjectMetadata) => Effect.Effect<void, StorageError>;\n}\n\n/** Offset cursors and named blocks retain their own reconciliation semantics. */\nexport const nativeUpload = Effect.fnUntraced(function* <E, R>(\n  runtime: TransferRuntime,\n  request: UploadRequest<E, R>,\n  headers: ObjectHeaders,\n  operation: Operation,\n  plan: UploadPlan,\n  journal?: NativeJournal,\n) {\n  const { endpoint, policy } = runtime;\n  const fail = (capability: string) =>\n    storageError(\n      \"upload\",\n      endpoint.storage.provider,\n      { _tag: \"Unsupported\", capability },\n      \"not-started\",\n    );\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 = Effect.fnUntraced(function* () {\n    if ((yield* reader.next(1)) !== undefined)\n      return yield* storageError(\n        \"upload\",\n        endpoint.storage.provider,\n        {\n          _tag: \"LengthMismatch\",\n          expected: request.source.length ?? reader.count() - 1,\n          actual: reader.count(),\n        },\n        \"not-started\",\n      );\n    const checksum = reader.checksum();\n    if (\n      !checksum ||\n      (request.expectedChecksum && !sameChecksum(checksum, request.expectedChecksum))\n    )\n      return yield* storageError(\n        \"upload\",\n        endpoint.storage.provider,\n        { _tag: \"IntegrityMismatch\" },\n        \"not-started\",\n      );\n    return checksum;\n  });\n  let metadata: ObjectMetadata;\n  let checksum: Checksum;\n  if (plan.strategy === \"offset\") {\n    const offsets = endpoint.offsets;\n    const length = request.source.length;\n    if (!offsets || length === undefined) return yield* fail(\"offset-known-source\");\n    // A zero-total status probe can also finalize an empty native upload.\n    if (length === 0) yield* verify();\n    if (journal) yield* journal.initiating;\n    const handle =\n      journal?.handle ??\n      (yield* operation.request(\n        offsets\n          .create({\n            key: request.key,\n            ...headers,\n            contentLength: length,\n            ...(request.condition ? { condition: request.condition } : {}),\n          })\n          .pipe(\n            Effect.catch((error) =>\n              Effect.gen(function* () {\n                if (error.mutationOutcome === \"unknown\")\n                  yield* runtime.diagnostic({ kind: \"unknown-outcome\", operationId: operation.id });\n                return yield* error;\n              }),\n            ),\n          ),\n      ));\n    if (journal && !journal.handle) yield* journal.initiated(handle);\n    let completionStarted = false;\n    let committed = false;\n    if (!journal)\n      yield* Effect.addFinalizer(() =>\n        committed || completionStarted\n          ? Effect.void\n          : runtime.cleanupRequest(offsets.cancel(handle)).pipe(\n              Effect.timeout(policy.cleanupTimeoutMillis),\n              Effect.result,\n              Effect.flatMap((result) =>\n                result._tag === \"Failure\"\n                  ? runtime.diagnostic({ kind: \"cleanup\", operationId: operation.id })\n                  : Effect.void,\n              ),\n            ),\n      );\n    let remote = yield* operation.request(offsets.query(handle), { retry: true });\n    let position = 0;\n    let pending = new Uint8Array();\n    while (remote._tag === \"Uploading\") {\n      const offset = remote.committedOffset;\n      if (\n        !Number.isSafeInteger(offset) ||\n        offset < position ||\n        offset > length ||\n        (offset > position + pending.length && position !== 0)\n      )\n        return yield* storageError(\n          \"query\",\n          endpoint.storage.provider,\n          { _tag: \"InvalidSession\" },\n          \"unknown\",\n        );\n      if (position === 0 && pending.length === 0 && offset > 0) {\n        while (reader.count() < offset) {\n          const discarded = yield* reader.next(Math.min(plan.partBytes, offset - reader.count()));\n          if (!discarded)\n            return yield* storageError(\n              \"upload\",\n              endpoint.storage.provider,\n              { _tag: \"IntegrityMismatch\" },\n              \"not-started\",\n            );\n        }\n      } else pending = pending.slice(offset - position);\n      position = offset;\n      if (pending.length < plan.partBytes && reader.count() < length) {\n        const next = yield* reader.next(\n          Math.min(plan.partBytes - pending.length, length - reader.count()),\n        );\n        if (!next)\n          return yield* storageError(\n            \"upload\",\n            endpoint.storage.provider,\n            { _tag: \"LengthMismatch\", expected: length, actual: reader.count() },\n            \"not-started\",\n          );\n        const joined = new Uint8Array(pending.length + next.length);\n        joined.set(pending);\n        joined.set(next, pending.length);\n        pending = joined;\n      }\n      const final = position + pending.length === length;\n      if (final) {\n        yield* verify();\n        if (journal) yield* journal.completing;\n        completionStarted = true;\n        operation.mutationStarted = true;\n      }\n      const offeredEnd = position + pending.length;\n      remote = yield* operation\n        .request(\n          Effect.suspend(() => {\n            operation.progress.bytesSent += pending.length;\n            return offsets.write({\n              upload: handle,\n              offset: position,\n              body: pending,\n              contentLength: pending.length,\n              final,\n            });\n          }),\n        )\n        .pipe(\n          Effect.catch((error) =>\n            error.mutationOutcome === \"unknown\" || error.reason._tag === \"TransportFailure\"\n              ? operation.request(offsets.query(handle), { retry: true })\n              : Effect.fail(error),\n          ),\n        );\n      if (\n        remote._tag === \"Uploading\" &&\n        (remote.committedOffset < position || remote.committedOffset > offeredEnd)\n      )\n        return yield* storageError(\n          \"query\",\n          endpoint.storage.provider,\n          { _tag: \"InvalidSession\" },\n          \"unknown\",\n        );\n      if (journal && remote._tag === \"Uploading\")\n        yield* journal.acknowledged(remote.committedOffset);\n      if (remote._tag === \"Uploading\")\n        operation.progress.bytesAcknowledged = remote.committedOffset;\n      yield* operation.observe();\n    }\n    if (remote._tag !== \"Completed\")\n      return yield* storageError(\n        \"upload\",\n        endpoint.storage.provider,\n        { _tag: remote._tag === \"Expired\" ? \"Expired\" : \"InvalidSession\" },\n        \"unknown\",\n      );\n    // A lost final response can be resolved by query; source validation still precedes the receipt.\n    while (reader.count() < length) {\n      if (!(yield* reader.next(Math.min(plan.partBytes, length - reader.count())))) break;\n    }\n    checksum = yield* verify();\n    metadata = offsets.resolveCompletion\n      ? yield* operation.request(offsets.resolveCompletion(handle), { retry: true })\n      : remote.metadata;\n    committed = true;\n  } else {\n    const blocks = endpoint.blocks;\n    if (!blocks) return yield* fail(\"blocks\");\n    const ref = { storeId: endpoint.storage.storeId, key: request.key };\n    const inventory = yield* operation.request(blocks.list(ref), { retry: true });\n    const observed = new Map(\n      [...inventory.committed, ...inventory.uncommitted].map((block) => [\n        block.blockId,\n        block.size,\n      ]),\n    );\n    const ids: string[] = [];\n    while (true) {\n      const body = yield* reader.next(plan.partBytes);\n      if (!body) break;\n      if (ids.length >= blocks.limits.maximumBlocks) return yield* fail(\"maximum-blocks\");\n      const blockId = Base64.encode(\n        new TextEncoder().encode(\n          operation.id.slice(0, 32).padEnd(32, \"0\") + ids.length.toString(16).padStart(8, \"0\"),\n        ),\n      );\n      ids.push(blockId);\n      const digest = runtime.input.digest.create();\n      digest.update(body);\n      const sourceChecksum = digest.finish();\n      const saved = journal?.blocks.find((block) => block.blockId === blockId);\n      if (\n        !saved ||\n        saved.size !== body.length ||\n        !sameChecksum(saved.sourceChecksum, sourceChecksum) ||\n        observed.get(blockId) !== body.length\n      )\n        yield* operation.request(\n          Effect.suspend(() => {\n            operation.progress.bytesSent += body.length;\n            return blocks.stage({ ref, blockId, body, contentLength: body.length });\n          }),\n          { retry: true, retryUnknown: true },\n        );\n      if (journal)\n        yield* journal.acknowledged(reader.count(), { blockId, size: body.length, sourceChecksum });\n      operation.progress.bytesAcknowledged = reader.count();\n      yield* operation.observe();\n    }\n    checksum = yield* verify();\n    if (journal) yield* journal.completing;\n    operation.mutationStarted = true;\n    metadata = yield* operation\n      .request(\n        blocks.commit({\n          ref,\n          blockIds: ids,\n          headers,\n          ...(request.condition ? { condition: request.condition } : {}),\n        }),\n      )\n      .pipe(\n        Effect.catch((error) => {\n          if (error.mutationOutcome !== \"unknown\" || !endpoint.reconcile) return Effect.fail(error);\n          return operation\n            .request(\n              endpoint.reconcile({\n                key: request.key,\n                operationId: operation.id,\n                size: reader.count(),\n              }),\n            )\n            .pipe(Effect.flatMap((found) => (found ? Effect.succeed(found) : Effect.fail(error))));\n        }),\n      );\n    metadata = { ...metadata, size: reader.count() };\n  }\n  if (\n    metadata.ref.storeId !== endpoint.storage.storeId ||\n    metadata.ref.key !== request.key ||\n    (metadata.size !== undefined && metadata.size !== reader.count())\n  )\n    return yield* storageError(\n      \"upload\",\n      endpoint.storage.provider,\n      { _tag: \"IntegrityMismatch\" },\n      \"unknown\",\n    );\n  operation.committed = true;\n  operation.progress.bytesAcknowledged = reader.count();\n  operation.progress.phase = \"committed\";\n  if (journal) yield* journal.committed(metadata);\n  return { metadata, checksum, strategy: plan.strategy, progress: { ...operation.progress } };\n});\n"],"mappings":"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"}