@effect-kit/storage 0.0.0-stage → 0.0.0

package/dist/transfers/part-receipts.js

@@ -0,0 +1,32 @@
+import { Checksum, ObjectSize } from "../core/object.js";
+import { storageError } from "../core/errors.js";
+import { Effect, Schema } from "effect";
+
+// src/transfers/part-receipts.ts
+const Receipt = Schema.Struct({
+	partNumber: Schema.Int.check(Schema.isGreaterThan(0)),
+	etag: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	size: Schema.optional(ObjectSize),
+	checksums: Schema.optional(Schema.Array(Schema.Struct({
+		...Checksum.fields,
+		algorithm: Schema.String.check(Schema.isMaxLength(32)),
+		value: Schema.String.check(Schema.isMaxLength(128))
+	})).check(Schema.isMaxLength(8)))
+});
+/** Bounds identities retained until completion and the subsequent protocol serialization. */
+const partReceipt = Effect.fnUntraced(function* (input, partNumber, size, provider) {
+	const receipt = yield* Schema.decodeUnknownEffect(Receipt)(input).pipe(Effect.mapError(() => storageError("upload.part", provider, { _tag: "IntegrityMismatch" }, "not-started")));
+	if (receipt.partNumber !== partNumber) return yield* storageError("upload.part", provider, { _tag: "IntegrityMismatch" }, "not-started");
+	if (receipt.size !== void 0 && receipt.size !== size) return yield* storageError("upload.part", provider, {
+		_tag: "LengthMismatch",
+		expected: size,
+		actual: receipt.size ?? 0
+	}, "not-started");
+	return {
+		...receipt,
+		size
+	};
+});
+
+export { partReceipt };
+//# sourceMappingURL=part-receipts.js.map

package/dist/transfers/part-receipts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"part-receipts.js","names":[],"sources":["../../src/transfers/part-receipts.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\n\nimport type { UploadedPart } from \"../core/contracts/multipart.js\";\nimport { storageError } from \"../core/errors.js\";\nimport { Checksum, ObjectSize } from \"../core/object.js\";\n\nconst Receipt = Schema.Struct({\n  partNumber: Schema.Int.check(Schema.isGreaterThan(0)),\n  etag: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  size: Schema.optional(ObjectSize),\n  checksums: Schema.optional(\n    Schema.Array(\n      Schema.Struct({\n        ...Checksum.fields,\n        algorithm: Schema.String.check(Schema.isMaxLength(32)),\n        value: Schema.String.check(Schema.isMaxLength(128)),\n      }),\n    ).check(Schema.isMaxLength(8)),\n  ),\n});\n\n/** Bounds identities retained until completion and the subsequent protocol serialization. */\nexport const partReceipt = Effect.fnUntraced(function* (\n  input: UploadedPart,\n  partNumber: number,\n  size: number,\n  provider: string,\n) {\n  const receipt = yield* Schema.decodeUnknownEffect(Receipt)(input).pipe(\n    Effect.mapError(() =>\n      storageError(\"upload.part\", provider, { _tag: \"IntegrityMismatch\" }, \"not-started\"),\n    ),\n  );\n  if (receipt.partNumber !== partNumber)\n    return yield* storageError(\n      \"upload.part\",\n      provider,\n      { _tag: \"IntegrityMismatch\" },\n      \"not-started\",\n    );\n  if (receipt.size !== undefined && receipt.size !== size)\n    return yield* storageError(\n      \"upload.part\",\n      provider,\n      { _tag: \"LengthMismatch\", expected: size, actual: receipt.size ?? 0 },\n      \"not-started\",\n    );\n  return { ...receipt, size };\n});\n"],"mappings":";;;;;AAMA,MAAM,UAAU,OAAO,OAAO;CAC5B,YAAY,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;CACpD,MAAM,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CACzD,MAAM,OAAO,SAAS,UAAU;CAChC,WAAW,OAAO,SAChB,OAAO,MACL,OAAO,OAAO;EACZ,GAAG,SAAS;EACZ,WAAW,OAAO,OAAO,MAAM,OAAO,YAAY,EAAE,CAAC;EACrD,OAAO,OAAO,OAAO,MAAM,OAAO,YAAY,GAAG,CAAC;CACpD,CAAC,CACH,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC,CAC/B;AACF,CAAC;;AAGD,MAAa,cAAc,OAAO,WAAW,WAC3C,OACA,YACA,MACA,UACA;CACA,MAAM,UAAU,OAAO,OAAO,oBAAoB,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,KAChE,OAAO,eACL,aAAa,eAAe,UAAU,EAAE,MAAM,oBAAoB,GAAG,aAAa,CACpF,CACF;CACA,IAAI,QAAQ,eAAe,YACzB,OAAO,OAAO,aACZ,eACA,UACA,EAAE,MAAM,oBAAoB,GAC5B,aACF;CACF,IAAI,QAAQ,SAAS,UAAa,QAAQ,SAAS,MACjD,OAAO,OAAO,aACZ,eACA,UACA;EAAE,MAAM;EAAkB,UAAU;EAAM,QAAQ,QAAQ,QAAQ;CAAE,GACpE,aACF;CACF,OAAO;EAAE,GAAG;EAAS;CAAK;AAC5B,CAAC"}

package/dist/transfers/planner.d.ts

@@ -0,0 +1,19 @@
+import "../core/requests.js";
+import "../index.js";
+import "./models.js";
+import { Effect } from "effect";
+export interface ResolvedPolicy {
+  readonly memoryBudgetBytes: number;
+  readonly partBytes: number;
+  readonly partConcurrency: number;
+  readonly requestConcurrency: number;
+  readonly maxSourceChunkBytes: number;
+  readonly maxBytes: number;
+  readonly deadlineMillis: number;
+  readonly maxAttempts: number;
+  readonly retryBaseMillis: number;
+  readonly retryMaxMillis: number;
+  readonly cleanupTimeoutMillis: number;
+  readonly observerTimeoutMillis: number;
+}
+//# sourceMappingURL=planner.d.ts.map

package/dist/transfers/planner.js

@@ -0,0 +1,153 @@
+import { storageError } from "../core/errors.js";
+import { Effect } from "effect";
+
+// src/transfers/planner.ts
+const MiB = 1048576;
+function resolvePolicy(input, endpoint) {
+	return Effect.gen(function* () {
+		const policy = {
+			memoryBudgetBytes: input.memoryBudgetBytes ?? 64 * MiB,
+			partBytes: input.partBytes ?? 8 * MiB,
+			partConcurrency: input.partConcurrency ?? 3,
+			requestConcurrency: input.requestConcurrency ?? 6,
+			maxSourceChunkBytes: input.maxSourceChunkBytes ?? MiB,
+			maxBytes: input.maxBytes ?? Math.min(endpoint.maximumObjectBytes, 1024 * MiB),
+			deadlineMillis: input.deadlineMillis ?? 9e5,
+			maxAttempts: input.maxAttempts ?? 1e3,
+			retryBaseMillis: input.retryBaseMillis ?? 100,
+			retryMaxMillis: input.retryMaxMillis ?? 1e4,
+			cleanupTimeoutMillis: input.cleanupTimeoutMillis ?? 5e3,
+			observerTimeoutMillis: input.observerTimeoutMillis ?? 100
+		};
+		for (const [field, value] of Object.entries(policy)) if (!Number.isSafeInteger(value) || value < (field === "maxBytes" || field === "retryBaseMillis" ? 0 : 1)) return yield* storageError("transfers.make", endpoint.storage.provider, {
+			_tag: "InvalidConfiguration",
+			field
+		});
+		if ([
+			endpoint.maximumObjectBytes,
+			endpoint.maximumSingleUploadBytes,
+			endpoint.transportOverheadBytes,
+			input.digest?.workspaceBytes
+		].some((value) => !Number.isSafeInteger(value) || value < 0) || !input.digest?.algorithm || typeof input.digest.create !== "function") return yield* storageError("transfers.make", endpoint.storage.provider, {
+			_tag: "InvalidConfiguration",
+			field: "endpoint-or-digest"
+		});
+		if (endpoint.multipart) {
+			const { minimumPartBytes, maximumPartBytes, maximumParts } = endpoint.multipart.limits;
+			if (![
+				minimumPartBytes,
+				maximumPartBytes,
+				maximumParts
+			].every((value) => Number.isSafeInteger(value) && value > 0) || minimumPartBytes > maximumPartBytes) return yield* storageError("transfers.make", endpoint.storage.provider, {
+				_tag: "InvalidConfiguration",
+				field: "multipart.limits"
+			});
+		}
+		return policy;
+	});
+}
+function planUpload(endpoint, policy, length, inputDigestWorkspace, strategy = "auto", serverCopy = false, condition) {
+	return Effect.gen(function* () {
+		const provider = endpoint.storage.provider;
+		const maximumBytes = Math.min(policy.maxBytes, endpoint.maximumObjectBytes);
+		if (length !== void 0 && (!Number.isSafeInteger(length) || length < 0)) return yield* storageError("upload.plan", provider, {
+			_tag: "InvalidInput",
+			field: "source.length"
+		}, "not-started");
+		if (length !== void 0 && length > maximumBytes) return yield* storageError("upload.plan", provider, {
+			_tag: "LimitExceeded",
+			limit: maximumBytes
+		}, "not-started");
+		if (![
+			"auto",
+			"single",
+			"multipart",
+			"offset",
+			"blocks"
+		].includes(strategy)) return yield* storageError("upload.plan", provider, {
+			_tag: "InvalidInput",
+			field: "strategy"
+		}, "not-started");
+		const native = strategy === "offset" || strategy === "blocks" ? strategy : strategy === "auto" && !endpoint.multipart ? endpoint.offsets ? "offset" : endpoint.blocks ? "blocks" : void 0 : void 0;
+		if (native && (native === "offset" ? !endpoint.offsets || length === void 0 : !endpoint.blocks)) return yield* storageError("upload.plan", provider, {
+			_tag: "Unsupported",
+			capability: `${native}-known-source`
+		}, "not-started");
+		const single = strategy === "single" || strategy === "auto" && length !== void 0 && length <= Math.min(policy.partBytes, endpoint.maximumSingleUploadBytes) || !endpoint.multipart && !native;
+		let partBytes;
+		let concurrency;
+		if (single) {
+			partBytes = length ?? maximumBytes;
+			concurrency = 1;
+			if (strategy === "multipart" || partBytes > endpoint.maximumSingleUploadBytes) return yield* storageError("upload.plan", provider, {
+				_tag: "Unsupported",
+				capability: "bounded-single-upload"
+			}, "not-started");
+		} else if (native) {
+			const alignment = native === "offset" ? endpoint.offsets?.limits.alignmentBytes ?? 0 : 1;
+			const maxPart = native === "offset" ? endpoint.offsets?.limits.maximumChunkBytes ?? 0 : endpoint.blocks?.limits.maximumBlockBytes ?? 0;
+			const count = native === "blocks" ? endpoint.blocks?.limits.maximumBlocks ?? 0 : Number.MAX_SAFE_INTEGER;
+			if (![
+				alignment,
+				maxPart,
+				count
+			].every((value) => Number.isSafeInteger(value) && value > 0)) return yield* storageError("upload.plan", provider, {
+				_tag: "InvalidConfiguration",
+				field: "native.limits"
+			}, "not-started");
+			const fixed = native === "offset" ? endpoint.offsets?.limits.fixedChunkBytes : void 0;
+			if (fixed !== void 0 && (!Number.isSafeInteger(fixed) || fixed <= 0 || fixed > maxPart || fixed % alignment !== 0)) return yield* storageError("upload.plan", provider, {
+				_tag: "InvalidConfiguration",
+				field: "native.fixedChunkBytes"
+			}, "not-started");
+			partBytes = fixed ?? Math.ceil(Math.max(policy.partBytes, Math.ceil((length ?? maximumBytes) / count)) / alignment) * alignment;
+			concurrency = 1;
+			if (partBytes > maxPart) return yield* storageError("upload.plan", provider, {
+				_tag: "LimitExceeded",
+				limit: maxPart
+			}, "not-started");
+			if (length !== void 0 && Math.max(1, Math.ceil(length / partBytes)) + 3 > policy.maxAttempts) return yield* storageError("upload.plan", provider, {
+				_tag: "LimitExceeded",
+				limit: policy.maxAttempts
+			}, "not-started");
+		} else {
+			const multipart = endpoint.multipart;
+			if (!multipart) return yield* storageError("upload.plan", provider, {
+				_tag: "Unsupported",
+				capability: "multipart"
+			}, "not-started");
+			const limits = multipart.limits;
+			if (condition && limits.completeConditions && !limits.completeConditions.includes(condition._tag === "CreateOnly" ? "create-only" : "if-match")) return yield* storageError("upload.plan", provider, {
+				_tag: "Unsupported",
+				capability: "multipart-conditional-completion"
+			}, "not-started");
+			partBytes = Math.max(policy.partBytes, limits.minimumPartBytes, Math.ceil((length ?? maximumBytes) / limits.maximumParts));
+			concurrency = policy.partConcurrency;
+			if (partBytes > limits.maximumPartBytes) return yield* storageError("upload.plan", provider, {
+				_tag: "LimitExceeded",
+				limit: limits.maximumPartBytes * limits.maximumParts
+			}, "not-started");
+			if (length !== void 0 && Math.max(1, Math.ceil(length / partBytes)) + 2 > policy.maxAttempts) return yield* storageError("upload.plan", provider, {
+				_tag: "LimitExceeded",
+				limit: policy.maxAttempts
+			}, "not-started");
+		}
+		const receiptBytes = single ? 0 : Math.max(1, Math.ceil((length ?? maximumBytes) / partBytes)) * 8192;
+		const uploadWorkspaceBytes = (serverCopy ? 0 : (concurrency + 1) * Math.max(1, partBytes) + policy.maxSourceChunkBytes) + concurrency * endpoint.transportOverheadBytes + inputDigestWorkspace + receiptBytes;
+		const workspaceBytes = Math.max(uploadWorkspaceBytes, native ? policy.maxSourceChunkBytes * 2 + endpoint.transportOverheadBytes + inputDigestWorkspace : 0);
+		if (!Number.isSafeInteger(workspaceBytes) || workspaceBytes > policy.memoryBudgetBytes) return yield* storageError("upload.plan", provider, {
+			_tag: "QuotaExceeded",
+			limit: policy.memoryBudgetBytes
+		}, "not-started");
+		return {
+			strategy: single ? "single" : native ?? "multipart",
+			partBytes,
+			concurrency,
+			maximumBytes,
+			workspaceBytes
+		};
+	});
+}
+
+export { planUpload, resolvePolicy };
+//# sourceMappingURL=planner.js.map

package/dist/transfers/planner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.js","names":[],"sources":["../../src/transfers/planner.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { storageError } from \"../core/errors.js\";\nimport type { WriteCondition } from \"../core/requests.js\";\nimport type { TransferEndpoint, TransferConfiguration } from \"./models.js\";\n\nconst MiB = 1024 * 1024;\n\nexport interface ResolvedPolicy {\n  readonly memoryBudgetBytes: number;\n  readonly partBytes: number;\n  readonly partConcurrency: number;\n  readonly requestConcurrency: number;\n  readonly maxSourceChunkBytes: number;\n  readonly maxBytes: number;\n  readonly deadlineMillis: number;\n  readonly maxAttempts: number;\n  readonly retryBaseMillis: number;\n  readonly retryMaxMillis: number;\n  readonly cleanupTimeoutMillis: number;\n  readonly observerTimeoutMillis: number;\n}\n\nexport function resolvePolicy(input: TransferConfiguration, endpoint: TransferEndpoint) {\n  return Effect.gen(function* () {\n    const policy: ResolvedPolicy = {\n      memoryBudgetBytes: input.memoryBudgetBytes ?? 64 * MiB,\n      partBytes: input.partBytes ?? 8 * MiB,\n      partConcurrency: input.partConcurrency ?? 3,\n      requestConcurrency: input.requestConcurrency ?? 6,\n      maxSourceChunkBytes: input.maxSourceChunkBytes ?? MiB,\n      maxBytes: input.maxBytes ?? Math.min(endpoint.maximumObjectBytes, 1024 * MiB),\n      deadlineMillis: input.deadlineMillis ?? 15 * 60 * 1000,\n      maxAttempts: input.maxAttempts ?? 1000,\n      retryBaseMillis: input.retryBaseMillis ?? 100,\n      retryMaxMillis: input.retryMaxMillis ?? 10000,\n      cleanupTimeoutMillis: input.cleanupTimeoutMillis ?? 5000,\n      observerTimeoutMillis: input.observerTimeoutMillis ?? 100,\n    };\n    for (const [field, value] of Object.entries(policy)) {\n      if (\n        !Number.isSafeInteger(value) ||\n        value < (field === \"maxBytes\" || field === \"retryBaseMillis\" ? 0 : 1)\n      )\n        return yield* storageError(\"transfers.make\", endpoint.storage.provider, {\n          _tag: \"InvalidConfiguration\",\n          field,\n        });\n    }\n    const limits = [\n      endpoint.maximumObjectBytes,\n      endpoint.maximumSingleUploadBytes,\n      endpoint.transportOverheadBytes,\n      input.digest?.workspaceBytes,\n    ];\n    if (\n      limits.some((value) => !Number.isSafeInteger(value) || value < 0) ||\n      !input.digest?.algorithm ||\n      typeof input.digest.create !== \"function\"\n    )\n      return yield* storageError(\"transfers.make\", endpoint.storage.provider, {\n        _tag: \"InvalidConfiguration\",\n        field: \"endpoint-or-digest\",\n      });\n    if (endpoint.multipart) {\n      const { minimumPartBytes, maximumPartBytes, maximumParts } = endpoint.multipart.limits;\n      if (\n        ![minimumPartBytes, maximumPartBytes, maximumParts].every(\n          (value) => Number.isSafeInteger(value) && value > 0,\n        ) ||\n        minimumPartBytes > maximumPartBytes\n      )\n        return yield* storageError(\"transfers.make\", endpoint.storage.provider, {\n          _tag: \"InvalidConfiguration\",\n          field: \"multipart.limits\",\n        });\n    }\n    return policy;\n  });\n}\n\nexport interface UploadPlan {\n  readonly strategy: \"single\" | \"multipart\" | \"offset\" | \"blocks\";\n  readonly partBytes: number;\n  readonly concurrency: number;\n  readonly maximumBytes: number;\n  readonly workspaceBytes: number;\n}\n\nexport function planUpload(\n  endpoint: TransferEndpoint,\n  policy: ResolvedPolicy,\n  length: number | undefined,\n  inputDigestWorkspace: number,\n  strategy: \"auto\" | \"single\" | \"multipart\" | \"offset\" | \"blocks\" = \"auto\",\n  serverCopy = false,\n  condition?: WriteCondition,\n) {\n  return Effect.gen(function* () {\n    const provider = endpoint.storage.provider;\n    const maximumBytes = Math.min(policy.maxBytes, endpoint.maximumObjectBytes);\n    if (length !== undefined && (!Number.isSafeInteger(length) || length < 0))\n      return yield* storageError(\n        \"upload.plan\",\n        provider,\n        { _tag: \"InvalidInput\", field: \"source.length\" },\n        \"not-started\",\n      );\n    if (length !== undefined && length > maximumBytes)\n      return yield* storageError(\n        \"upload.plan\",\n        provider,\n        { _tag: \"LimitExceeded\", limit: maximumBytes },\n        \"not-started\",\n      );\n    if (![\"auto\", \"single\", \"multipart\", \"offset\", \"blocks\"].includes(strategy))\n      return yield* storageError(\n        \"upload.plan\",\n        provider,\n        { _tag: \"InvalidInput\", field: \"strategy\" },\n        \"not-started\",\n      );\n\n    const native =\n      strategy === \"offset\" || strategy === \"blocks\"\n        ? strategy\n        : strategy === \"auto\" && !endpoint.multipart\n          ? endpoint.offsets\n            ? \"offset\"\n            : endpoint.blocks\n              ? \"blocks\"\n              : undefined\n          : undefined;\n    if (\n      native &&\n      (native === \"offset\" ? !endpoint.offsets || length === undefined : !endpoint.blocks)\n    )\n      return yield* storageError(\n        \"upload.plan\",\n        provider,\n        { _tag: \"Unsupported\", capability: `${native}-known-source` },\n        \"not-started\",\n      );\n    const single =\n      strategy === \"single\" ||\n      (strategy === \"auto\" &&\n        length !== undefined &&\n        length <= Math.min(policy.partBytes, endpoint.maximumSingleUploadBytes)) ||\n      (!endpoint.multipart && !native);\n    let partBytes: number;\n    let concurrency: number;\n    if (single) {\n      partBytes = length ?? maximumBytes;\n      concurrency = 1;\n      if (strategy === \"multipart\" || partBytes > endpoint.maximumSingleUploadBytes)\n        return yield* storageError(\n          \"upload.plan\",\n          provider,\n          { _tag: \"Unsupported\", capability: \"bounded-single-upload\" },\n          \"not-started\",\n        );\n    } else if (native) {\n      const alignment = native === \"offset\" ? (endpoint.offsets?.limits.alignmentBytes ?? 0) : 1;\n      const maxPart =\n        native === \"offset\"\n          ? (endpoint.offsets?.limits.maximumChunkBytes ?? 0)\n          : (endpoint.blocks?.limits.maximumBlockBytes ?? 0);\n      const count =\n        native === \"blocks\"\n          ? (endpoint.blocks?.limits.maximumBlocks ?? 0)\n          : Number.MAX_SAFE_INTEGER;\n      if (![alignment, maxPart, count].every((value) => Number.isSafeInteger(value) && value > 0))\n        return yield* storageError(\n          \"upload.plan\",\n          provider,\n          { _tag: \"InvalidConfiguration\", field: \"native.limits\" },\n          \"not-started\",\n        );\n      const fixed = native === \"offset\" ? endpoint.offsets?.limits.fixedChunkBytes : undefined;\n      if (\n        fixed !== undefined &&\n        (!Number.isSafeInteger(fixed) || fixed <= 0 || fixed > maxPart || fixed % alignment !== 0)\n      )\n        return yield* storageError(\n          \"upload.plan\",\n          provider,\n          { _tag: \"InvalidConfiguration\", field: \"native.fixedChunkBytes\" },\n          \"not-started\",\n        );\n      partBytes =\n        fixed ??\n        Math.ceil(\n          Math.max(policy.partBytes, Math.ceil((length ?? maximumBytes) / count)) / alignment,\n        ) * alignment;\n      concurrency = 1;\n      if (partBytes > maxPart)\n        return yield* storageError(\n          \"upload.plan\",\n          provider,\n          { _tag: \"LimitExceeded\", limit: maxPart },\n          \"not-started\",\n        );\n      if (\n        length !== undefined &&\n        Math.max(1, Math.ceil(length / partBytes)) + 3 > policy.maxAttempts\n      )\n        return yield* storageError(\n          \"upload.plan\",\n          provider,\n          { _tag: \"LimitExceeded\", limit: policy.maxAttempts },\n          \"not-started\",\n        );\n    } else {\n      const multipart = endpoint.multipart;\n      if (!multipart)\n        return yield* storageError(\n          \"upload.plan\",\n          provider,\n          { _tag: \"Unsupported\", capability: \"multipart\" },\n          \"not-started\",\n        );\n      const limits = multipart.limits;\n      if (\n        condition &&\n        limits.completeConditions &&\n        !limits.completeConditions.includes(\n          condition._tag === \"CreateOnly\" ? \"create-only\" : \"if-match\",\n        )\n      )\n        return yield* storageError(\n          \"upload.plan\",\n          provider,\n          { _tag: \"Unsupported\", capability: \"multipart-conditional-completion\" },\n          \"not-started\",\n        );\n      partBytes = Math.max(\n        policy.partBytes,\n        limits.minimumPartBytes,\n        Math.ceil((length ?? maximumBytes) / limits.maximumParts),\n      );\n      concurrency = policy.partConcurrency;\n      if (partBytes > limits.maximumPartBytes)\n        return yield* storageError(\n          \"upload.plan\",\n          provider,\n          { _tag: \"LimitExceeded\", limit: limits.maximumPartBytes * limits.maximumParts },\n          \"not-started\",\n        );\n      if (\n        length !== undefined &&\n        Math.max(1, Math.ceil(length / partBytes)) + 2 > policy.maxAttempts\n      )\n        return yield* storageError(\n          \"upload.plan\",\n          provider,\n          { _tag: \"LimitExceeded\", limit: policy.maxAttempts },\n          \"not-started\",\n        );\n    }\n\n    // One producer buffer, retained worker buffers, one upstream chunk, and explicit transport allowance.\n    const receiptBytes = single\n      ? 0\n      : Math.max(1, Math.ceil((length ?? maximumBytes) / partBytes)) * 8192;\n    const uploadWorkspaceBytes =\n      (serverCopy ? 0 : (concurrency + 1) * Math.max(1, partBytes) + policy.maxSourceChunkBytes) +\n      concurrency * endpoint.transportOverheadBytes +\n      inputDigestWorkspace +\n      receiptBytes;\n    const workspaceBytes = Math.max(\n      uploadWorkspaceBytes,\n      native\n        ? policy.maxSourceChunkBytes * 2 + endpoint.transportOverheadBytes + inputDigestWorkspace\n        : 0,\n    );\n    if (!Number.isSafeInteger(workspaceBytes) || workspaceBytes > policy.memoryBudgetBytes)\n      return yield* storageError(\n        \"upload.plan\",\n        provider,\n        { _tag: \"QuotaExceeded\", limit: policy.memoryBudgetBytes },\n        \"not-started\",\n      );\n    return {\n      strategy: single ? (\"single\" as const) : (native ?? (\"multipart\" as const)),\n      partBytes,\n      concurrency,\n      maximumBytes,\n      workspaceBytes,\n    };\n  });\n}\n"],"mappings":"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"}

package/dist/transfers/reader.js

@@ -0,0 +1,81 @@
+import { storageError } from "../core/errors.js";
+import { Effect, Pull, Stream } from "effect";
+import { Base64, Hex } from "effect/encoding";
+
+// src/transfers/reader.ts
+const failure = (reason) => storageError("source.read", "transfer", reason, "not-started");
+const makeReader = Effect.fnUntraced(function* (source, options) {
+	const pull = yield* Stream.toPull(source.open().pipe(Stream.rechunk(1)));
+	const hash = options.digest.create();
+	let pending;
+	let offset = 0;
+	let total = 0;
+	let ended = false;
+	let checksum;
+	return {
+		next: Effect.fnUntraced(function* (capacity) {
+			if (ended && !pending) return void 0;
+			const buffer = new Uint8Array(Math.max(1, capacity));
+			let used = 0;
+			while (used < buffer.length) {
+				if (!pending) {
+					const chunks = yield* pull.pipe(Pull.catchDone(() => Effect.succeed(void 0)));
+					if (!chunks) {
+						ended = true;
+						if (source.length !== void 0 && total !== source.length) return yield* failure({
+							_tag: "LengthMismatch",
+							expected: source.length,
+							actual: total
+						});
+						checksum = hash.finish();
+						break;
+					}
+					pending = chunks[0];
+					offset = 0;
+					if (!(pending instanceof Uint8Array)) return yield* failure({
+						_tag: "InvalidInput",
+						field: "source.chunk"
+					});
+					if (pending.buffer.byteLength > options.maximumChunkBytes) return yield* failure({
+						_tag: "LimitExceeded",
+						limit: options.maximumChunkBytes
+					});
+					if (pending.byteLength === 0) {
+						pending = void 0;
+						continue;
+					}
+				}
+				const count = Math.min(buffer.length - used, pending.length - offset);
+				if (total + count > options.maximumBytes) return yield* failure({
+					_tag: "LimitExceeded",
+					limit: options.maximumBytes
+				});
+				if (source.length !== void 0 && total + count > source.length) return yield* failure({
+					_tag: "LengthMismatch",
+					expected: source.length,
+					actual: total + count
+				});
+				const slice = pending.subarray(offset, offset + count);
+				buffer.set(slice, used);
+				hash.update(slice);
+				used += count;
+				total += count;
+				offset += count;
+				options.onRead(count);
+				if (offset === pending.length) pending = void 0;
+			}
+			return used === 0 ? void 0 : buffer.subarray(0, used);
+		}),
+		count: () => total,
+		checksum: () => checksum
+	};
+});
+function sameChecksum(actual, expected) {
+	if (expected.scope !== "full-object" || actual.scope !== "full-object" || actual.algorithm !== expected.algorithm) return false;
+	const left = actual.encoding === "hex" ? Hex.decode(actual.value) : Base64.decode(actual.value);
+	const right = expected.encoding === "hex" ? Hex.decode(expected.value) : Base64.decode(expected.value);
+	return left._tag === "Success" && right._tag === "Success" && left.success.length === right.success.length && left.success.every((byte, index) => byte === right.success[index]);
+}
+
+export { makeReader, sameChecksum };
+//# sourceMappingURL=reader.js.map

package/dist/transfers/reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.js","names":[],"sources":["../../src/transfers/reader.ts"],"sourcesContent":["import { Effect, Pull, Stream } from \"effect\";\nimport { Base64, Hex } from \"effect/encoding\";\n\nimport type { StorageError } from \"../core/errors.js\";\nimport { storageError } from \"../core/errors.js\";\nimport type { Checksum } from \"../core/object.js\";\nimport type { TransferDigest } from \"./models.js\";\nimport type { UploadSource } from \"./sources.js\";\n\nconst failure = (reason: StorageError[\"reason\"]) =>\n  storageError(\"source.read\", \"transfer\", reason, \"not-started\");\n\nexport const makeReader = Effect.fnUntraced(function* <E, R>(\n  source: UploadSource<E, R>,\n  options: {\n    readonly maximumBytes: number;\n    readonly maximumChunkBytes: number;\n    readonly digest: TransferDigest;\n    readonly onRead: (count: number) => void;\n  },\n) {\n  const pull = yield* Stream.toPull(source.open().pipe(Stream.rechunk(1)));\n  const hash = options.digest.create();\n  let pending: Uint8Array | undefined;\n  let offset = 0;\n  let total = 0;\n  let ended = false;\n  let checksum: Checksum | undefined;\n\n  const next = Effect.fnUntraced(function* (\n    capacity: number,\n  ): Effect.fn.Return<Uint8Array | undefined, E | StorageError, R> {\n    if (ended && !pending) return undefined;\n    const buffer = new Uint8Array(Math.max(1, capacity));\n    let used = 0;\n    while (used < buffer.length) {\n      if (!pending) {\n        const chunks = yield* pull.pipe(Pull.catchDone(() => Effect.succeed(undefined)));\n        if (!chunks) {\n          ended = true;\n          if (source.length !== undefined && total !== source.length)\n            return yield* failure({\n              _tag: \"LengthMismatch\",\n              expected: source.length,\n              actual: total,\n            });\n          checksum = hash.finish();\n          break;\n        }\n        pending = chunks[0];\n        offset = 0;\n        if (!(pending instanceof Uint8Array))\n          return yield* failure({ _tag: \"InvalidInput\", field: \"source.chunk\" });\n        // A tiny subarray can keep a huge backing allocation alive through a retry.\n        if (pending.buffer.byteLength > options.maximumChunkBytes)\n          return yield* failure({ _tag: \"LimitExceeded\", limit: options.maximumChunkBytes });\n        if (pending.byteLength === 0) {\n          pending = undefined;\n          continue;\n        }\n      }\n\n      const count = Math.min(buffer.length - used, pending.length - offset);\n      if (total + count > options.maximumBytes)\n        return yield* failure({ _tag: \"LimitExceeded\", limit: options.maximumBytes });\n      if (source.length !== undefined && total + count > source.length)\n        return yield* failure({\n          _tag: \"LengthMismatch\",\n          expected: source.length,\n          actual: total + count,\n        });\n      const slice = pending.subarray(offset, offset + count);\n      buffer.set(slice, used);\n      hash.update(slice);\n      used += count;\n      total += count;\n      offset += count;\n      options.onRead(count);\n      if (offset === pending.length) pending = undefined;\n    }\n    return used === 0 ? undefined : buffer.subarray(0, used);\n  });\n\n  return {\n    next,\n    count: () => total,\n    checksum: () => checksum,\n  };\n});\n\nexport function sameChecksum(actual: Checksum, expected: Checksum): boolean {\n  if (\n    expected.scope !== \"full-object\" ||\n    actual.scope !== \"full-object\" ||\n    actual.algorithm !== expected.algorithm\n  )\n    return false;\n  const left = actual.encoding === \"hex\" ? Hex.decode(actual.value) : Base64.decode(actual.value);\n  const right =\n    expected.encoding === \"hex\" ? Hex.decode(expected.value) : Base64.decode(expected.value);\n  return (\n    left._tag === \"Success\" &&\n    right._tag === \"Success\" &&\n    left.success.length === right.success.length &&\n    left.success.every((byte, index) => byte === right.success[index])\n  );\n}\n"],"mappings":";;;;;AASA,MAAM,WAAW,WACf,aAAa,eAAe,YAAY,QAAQ,aAAa;AAE/D,MAAa,aAAa,OAAO,WAAW,WAC1C,QACA,SAMA;CACA,MAAM,OAAO,OAAO,OAAO,OAAO,OAAO,KAAK,CAAC,CAAC,KAAK,OAAO,QAAQ,CAAC,CAAC,CAAC;CACvE,MAAM,OAAO,QAAQ,OAAO,OAAO;CACnC,IAAI;CACJ,IAAI,SAAS;CACb,IAAI,QAAQ;CACZ,IAAI,QAAQ;CACZ,IAAI;CAwDJ,OAAO;EACL,MAvDW,OAAO,WAAW,WAC7B,UAC+D;GAC/D,IAAI,SAAS,CAAC,SAAS,OAAO;GAC9B,MAAM,SAAS,IAAI,WAAW,KAAK,IAAI,GAAG,QAAQ,CAAC;GACnD,IAAI,OAAO;GACX,OAAO,OAAO,OAAO,QAAQ;IAC3B,IAAI,CAAC,SAAS;KACZ,MAAM,SAAS,OAAO,KAAK,KAAK,KAAK,gBAAgB,OAAO,QAAQ,MAAS,CAAC,CAAC;KAC/E,IAAI,CAAC,QAAQ;MACX,QAAQ;MACR,IAAI,OAAO,WAAW,UAAa,UAAU,OAAO,QAClD,OAAO,OAAO,QAAQ;OACpB,MAAM;OACN,UAAU,OAAO;OACjB,QAAQ;MACV,CAAC;MACH,WAAW,KAAK,OAAO;MACvB;KACF;KACA,UAAU,OAAO;KACjB,SAAS;KACT,IAAI,EAAE,mBAAmB,aACvB,OAAO,OAAO,QAAQ;MAAE,MAAM;MAAgB,OAAO;KAAe,CAAC;KAEvE,IAAI,QAAQ,OAAO,aAAa,QAAQ,mBACtC,OAAO,OAAO,QAAQ;MAAE,MAAM;MAAiB,OAAO,QAAQ;KAAkB,CAAC;KACnF,IAAI,QAAQ,eAAe,GAAG;MAC5B,UAAU;MACV;KACF;IACF;IAEA,MAAM,QAAQ,KAAK,IAAI,OAAO,SAAS,MAAM,QAAQ,SAAS,MAAM;IACpE,IAAI,QAAQ,QAAQ,QAAQ,cAC1B,OAAO,OAAO,QAAQ;KAAE,MAAM;KAAiB,OAAO,QAAQ;IAAa,CAAC;IAC9E,IAAI,OAAO,WAAW,UAAa,QAAQ,QAAQ,OAAO,QACxD,OAAO,OAAO,QAAQ;KACpB,MAAM;KACN,UAAU,OAAO;KACjB,QAAQ,QAAQ;IAClB,CAAC;IACH,MAAM,QAAQ,QAAQ,SAAS,QAAQ,SAAS,KAAK;IACrD,OAAO,IAAI,OAAO,IAAI;IACtB,KAAK,OAAO,KAAK;IACjB,QAAQ;IACR,SAAS;IACT,UAAU;IACV,QAAQ,OAAO,KAAK;IACpB,IAAI,WAAW,QAAQ,QAAQ,UAAU;GAC3C;GACA,OAAO,SAAS,IAAI,SAAY,OAAO,SAAS,GAAG,IAAI;EACzD,CAGK;EACH,aAAa;EACb,gBAAgB;CAClB;AACF,CAAC;AAED,SAAgB,aAAa,QAAkB,UAA6B;CAC1E,IACE,SAAS,UAAU,iBACnB,OAAO,UAAU,iBACjB,OAAO,cAAc,SAAS,WAE9B,OAAO;CACT,MAAM,OAAO,OAAO,aAAa,QAAQ,IAAI,OAAO,OAAO,KAAK,IAAI,OAAO,OAAO,OAAO,KAAK;CAC9F,MAAM,QACJ,SAAS,aAAa,QAAQ,IAAI,OAAO,SAAS,KAAK,IAAI,OAAO,OAAO,SAAS,KAAK;CACzF,OACE,KAAK,SAAS,aACd,MAAM,SAAS,aACf,KAAK,QAAQ,WAAW,MAAM,QAAQ,UACtC,KAAK,QAAQ,OAAO,MAAM,UAAU,SAAS,MAAM,QAAQ,MAAM;AAErE"}

package/dist/transfers/runtime.d.ts

@@ -0,0 +1,19 @@
+import { StorageError } from "../core/errors.js";
+import { TransferProgress } from "./models.js";
+import "./planner.js";
+import { Effect } from "effect";
+import { SecureRandom } from "effect/crypto";
+export interface Operation {
+  readonly id: string;
+  readonly progress: { -readonly [K in keyof TransferProgress]: TransferProgress[K]; };
+  readonly startedAt: number;
+  mutationStarted: boolean;
+  committed: boolean;
+  readonly request: <A, E = never, R = never>(effect: Effect.Effect<A, StorageError | E, R>, options?: {
+    readonly retry?: boolean;
+    readonly retryUnknown?: boolean;
+    readonly canRetry?: () => boolean;
+  }) => Effect.Effect<A, StorageError | E, R>;
+  readonly observe: (phase?: TransferProgress["phase"]) => Effect.Effect<void>;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/dist/transfers/runtime.js

@@ -0,0 +1,132 @@
+import { StorageError, storageError } from "../core/errors.js";
+import { makeBudget } from "./budget.js";
+import { Cause, Clock, Effect, Exit, Metric, Random, Semaphore } from "effect";
+
+// src/transfers/runtime.ts
+const operations = Metric.counter("storage.transfer.operations");
+const attempts = Metric.counter("storage.transfer.attempts");
+const retries = Metric.counter("storage.transfer.retries");
+const cleanupDebt = Metric.counter("storage.transfer.cleanup_debt");
+const inFlight = Metric.gauge("storage.transfer.reserved_bytes");
+function makeRuntime(endpoint, input, policy, random) {
+	const budget = makeBudget(policy.memoryBudgetBytes);
+	const requests = Semaphore.makeUnsafe(policy.requestConcurrency);
+	let activeRequests = 0;
+	let peakActiveRequests = 0;
+	let dropped = 0;
+	const diagnostics = [];
+	const diagnostic = (entry) => Effect.gen(function* () {
+		if (diagnostics.length < 128) diagnostics.push(entry);
+		else dropped++;
+		if (entry.kind === "cleanup" || entry.kind === "unknown-outcome") yield* Metric.update(cleanupDebt, 1);
+	});
+	return {
+		endpoint,
+		newId: () => random.uuidV4(),
+		input,
+		policy,
+		begin: Effect.fnUntraced(function* (operation, totalBytes) {
+			const id = yield* random.uuidV4();
+			const startedAt = yield* Clock.currentTimeMillis;
+			const progress = {
+				operation,
+				phase: "running",
+				totalBytes,
+				bytesRead: 0,
+				bytesSent: 0,
+				bytesAcknowledged: 0,
+				bytesVerified: 0,
+				attempts: 0
+			};
+			yield* Metric.update(operations, 1);
+			const state = {
+				id,
+				progress,
+				startedAt,
+				mutationStarted: false,
+				committed: false,
+				request: (effect, options = {}) => Effect.gen(function* () {
+					let retry = 0;
+					while (true) {
+						if (progress.attempts >= policy.maxAttempts) return yield* storageError(operation, endpoint.storage.provider, {
+							_tag: "LimitExceeded",
+							limit: policy.maxAttempts
+						}, state.committed ? "succeeded" : state.mutationStarted ? "unknown" : "not-started");
+						const result = yield* requests.withPermit(Effect.suspend(() => {
+							if (progress.attempts >= policy.maxAttempts) return Effect.fail(storageError(operation, endpoint.storage.provider, {
+								_tag: "LimitExceeded",
+								limit: policy.maxAttempts
+							}, state.committed ? "succeeded" : state.mutationStarted ? "unknown" : "not-started"));
+							progress.attempts++;
+							activeRequests++;
+							peakActiveRequests = Math.max(peakActiveRequests, activeRequests);
+							return Metric.update(attempts, 1).pipe(Effect.andThen(effect), Effect.ensuring(Effect.sync(() => {
+								activeRequests--;
+							})));
+						})).pipe(Effect.result);
+						if (result._tag === "Success") return result.success;
+						const error = result.failure;
+						if (!(error instanceof StorageError)) return yield* Effect.fail(error);
+						const reason = error.reason;
+						const transient = reason._tag === "TransportFailure" || reason._tag === "Throttled" || reason._tag === "ProviderFailure" && [
+							"InternalError",
+							"ServiceUnavailable",
+							"SlowDown",
+							"RequestTimeout"
+						].includes(reason.code ?? "");
+						if (!options.retry || options.canRetry?.() === false || !transient || error.mutationOutcome === "unknown" && !options.retryUnknown || progress.attempts >= policy.maxAttempts) return yield* error;
+						const cap = Math.min(policy.retryMaxMillis, policy.retryBaseMillis * 2 ** Math.min(retry++, 20));
+						const jitter = yield* Random.next;
+						const requested = reason._tag === "Throttled" ? reason.retryAfterMillis ?? 0 : 0;
+						const delay = Math.max(requested, Math.floor(cap * (.5 + jitter * .5)));
+						if ((yield* Clock.currentTimeMillis) + delay >= startedAt + policy.deadlineMillis) return yield* error;
+						yield* Metric.update(retries, 1);
+						yield* Effect.sleep(delay);
+					}
+				}),
+				observe: (phase = progress.phase) => Effect.gen(function* () {
+					progress.phase = phase;
+					const observer = input.observer;
+					if (!observer) return;
+					const result = yield* Effect.exit(Effect.suspend(() => observer({ ...progress })).pipe(Effect.timeout(policy.observerTimeoutMillis)));
+					if (Exit.isFailure(result)) yield* diagnostic({
+						kind: "observer",
+						operationId: id
+					});
+				})
+			};
+			return state;
+		}),
+		diagnostic,
+		diagnostics: Effect.sync(() => ({
+			entries: [...diagnostics],
+			dropped
+		})),
+		resources: Effect.sync(() => ({
+			...budget.snapshot(),
+			activeRequests,
+			peakActiveRequests
+		})),
+		cleanupRequest: (effect) => requests.withPermit(Effect.suspend(() => {
+			activeRequests++;
+			peakActiveRequests = Math.max(peakActiveRequests, activeRequests);
+			return Metric.update(attempts, 1).pipe(Effect.andThen(effect), Effect.ensuring(Effect.sync(() => {
+				activeRequests--;
+			})));
+		})),
+		lease: (bytes, effect) => budget.withLease(bytes, Effect.acquireUseRelease(Metric.modify(inFlight, bytes), () => effect, () => Metric.modify(inFlight, -bytes))),
+		deadline: (operation, effect) => effect.pipe(Effect.onExit((exit) => Exit.isFailure(exit) && Cause.hasInterrupts(exit.cause) && operation.mutationStarted && !operation.committed ? diagnostic({
+			kind: "unknown-outcome",
+			operationId: operation.id
+		}) : Effect.void), Effect.timeoutOrElse({
+			duration: policy.deadlineMillis,
+			orElse: () => Effect.fail(storageError(operation.progress.operation, endpoint.storage.provider, {
+				_tag: "TransportFailure",
+				code: "TransferDeadlineExceeded"
+			}, operation.committed ? "succeeded" : operation.mutationStarted ? "unknown" : "not-started"))
+		}))
+	};
+}
+
+export { makeRuntime };
+//# sourceMappingURL=runtime.js.map

package/dist/transfers/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","names":[],"sources":["../../src/transfers/runtime.ts"],"sourcesContent":["import { Cause, Clock, Effect, Exit, Metric, Random, Semaphore } from \"effect\";\nimport type { SecureRandom } from \"effect/crypto\";\n\nimport { StorageError, storageError } from \"../core/errors.js\";\nimport { makeBudget } from \"./budget.js\";\nimport type {\n  TransferDiagnostic,\n  TransferEndpoint,\n  TransferConfiguration,\n  TransferProgress,\n} from \"./models.js\";\nimport type { ResolvedPolicy } from \"./planner.js\";\n\nconst operations = Metric.counter(\"storage.transfer.operations\");\nconst attempts = Metric.counter(\"storage.transfer.attempts\");\nconst retries = Metric.counter(\"storage.transfer.retries\");\nconst cleanupDebt = Metric.counter(\"storage.transfer.cleanup_debt\");\nconst inFlight = Metric.gauge(\"storage.transfer.reserved_bytes\");\n\nexport interface Operation {\n  readonly id: string;\n  readonly progress: { -readonly [K in keyof TransferProgress]: TransferProgress[K] };\n  readonly startedAt: number;\n  mutationStarted: boolean;\n  committed: boolean;\n  readonly request: <A, E = never, R = never>(\n    effect: Effect.Effect<A, StorageError | E, R>,\n    options?: {\n      readonly retry?: boolean;\n      readonly retryUnknown?: boolean;\n      readonly canRetry?: () => boolean;\n    },\n  ) => Effect.Effect<A, StorageError | E, R>;\n  readonly observe: (phase?: TransferProgress[\"phase\"]) => Effect.Effect<void>;\n}\n\nexport function makeRuntime(\n  endpoint: TransferEndpoint,\n  input: TransferConfiguration,\n  policy: ResolvedPolicy,\n  random: SecureRandom.SecureRandom[\"Service\"],\n) {\n  const budget = makeBudget(policy.memoryBudgetBytes);\n  const requests = Semaphore.makeUnsafe(policy.requestConcurrency);\n  let activeRequests = 0;\n  let peakActiveRequests = 0;\n  let dropped = 0;\n  const diagnostics: Array<TransferDiagnostic> = [];\n\n  const diagnostic = (entry: TransferDiagnostic) =>\n    Effect.gen(function* () {\n      if (diagnostics.length < 128) diagnostics.push(entry);\n      else dropped++;\n      if (entry.kind === \"cleanup\" || entry.kind === \"unknown-outcome\")\n        yield* Metric.update(cleanupDebt, 1);\n    });\n\n  const begin = Effect.fnUntraced(function* (\n    operation: TransferProgress[\"operation\"],\n    totalBytes?: number,\n  ): Effect.fn.Return<Operation> {\n    const id = yield* random.uuidV4();\n    const startedAt = yield* Clock.currentTimeMillis;\n    const progress = {\n      operation,\n      phase: \"running\" as TransferProgress[\"phase\"],\n      totalBytes,\n      bytesRead: 0,\n      bytesSent: 0,\n      bytesAcknowledged: 0,\n      bytesVerified: 0,\n      attempts: 0,\n    };\n    yield* Metric.update(operations, 1);\n\n    const state: Operation = {\n      id,\n      progress,\n      startedAt,\n      mutationStarted: false,\n      committed: false,\n      request: <A, E = never, R = never>(\n        effect: Effect.Effect<A, StorageError | E, R>,\n        options: {\n          readonly retry?: boolean;\n          readonly retryUnknown?: boolean;\n          readonly canRetry?: () => boolean;\n        } = {},\n      ) =>\n        Effect.gen(function* () {\n          let retry = 0;\n          while (true) {\n            if (progress.attempts >= policy.maxAttempts)\n              return yield* storageError(\n                operation,\n                endpoint.storage.provider,\n                { _tag: \"LimitExceeded\", limit: policy.maxAttempts },\n                state.committed ? \"succeeded\" : state.mutationStarted ? \"unknown\" : \"not-started\",\n              );\n            const result = yield* requests\n              .withPermit(\n                Effect.suspend(() => {\n                  if (progress.attempts >= policy.maxAttempts)\n                    return Effect.fail(\n                      storageError(\n                        operation,\n                        endpoint.storage.provider,\n                        { _tag: \"LimitExceeded\", limit: policy.maxAttempts },\n                        state.committed\n                          ? \"succeeded\"\n                          : state.mutationStarted\n                            ? \"unknown\"\n                            : \"not-started\",\n                      ),\n                    );\n                  progress.attempts++;\n                  activeRequests++;\n                  peakActiveRequests = Math.max(peakActiveRequests, activeRequests);\n                  return Metric.update(attempts, 1).pipe(\n                    Effect.andThen(effect),\n                    Effect.ensuring(\n                      Effect.sync(() => {\n                        activeRequests--;\n                      }),\n                    ),\n                  );\n                }),\n              )\n              .pipe(Effect.result);\n            if (result._tag === \"Success\") return result.success;\n\n            const error = result.failure;\n            if (!(error instanceof StorageError)) return yield* Effect.fail(error);\n            const reason = error.reason;\n            const transient =\n              reason._tag === \"TransportFailure\" ||\n              reason._tag === \"Throttled\" ||\n              (reason._tag === \"ProviderFailure\" &&\n                [\"InternalError\", \"ServiceUnavailable\", \"SlowDown\", \"RequestTimeout\"].includes(\n                  reason.code ?? \"\",\n                ));\n            if (\n              !options.retry ||\n              options.canRetry?.() === false ||\n              !transient ||\n              (error.mutationOutcome === \"unknown\" && !options.retryUnknown) ||\n              progress.attempts >= policy.maxAttempts\n            )\n              return yield* error;\n\n            const cap = Math.min(\n              policy.retryMaxMillis,\n              policy.retryBaseMillis * 2 ** Math.min(retry++, 20),\n            );\n            const jitter = yield* Random.next;\n            const requested = reason._tag === \"Throttled\" ? (reason.retryAfterMillis ?? 0) : 0;\n            // Never retry sooner than Retry-After. If it exceeds the operation deadline, fail here.\n            const delay = Math.max(requested, Math.floor(cap * (0.5 + jitter * 0.5)));\n            const now = yield* Clock.currentTimeMillis;\n            if (now + delay >= startedAt + policy.deadlineMillis) return yield* error;\n            yield* Metric.update(retries, 1);\n            yield* Effect.sleep(delay);\n          }\n        }),\n      observe: (phase = progress.phase) =>\n        Effect.gen(function* () {\n          progress.phase = phase;\n          const observer = input.observer;\n          if (!observer) return;\n          const result = yield* Effect.exit(\n            Effect.suspend(() => observer({ ...progress })).pipe(\n              Effect.timeout(policy.observerTimeoutMillis),\n            ),\n          );\n          if (Exit.isFailure(result)) yield* diagnostic({ kind: \"observer\", operationId: id });\n        }),\n    };\n    return state;\n  });\n\n  return {\n    endpoint,\n    newId: () => random.uuidV4(),\n    input,\n    policy,\n    begin,\n    diagnostic,\n    diagnostics: Effect.sync(() => ({ entries: [...diagnostics], dropped })),\n    resources: Effect.sync(() => ({ ...budget.snapshot(), activeRequests, peakActiveRequests })),\n    cleanupRequest: <A, E, R>(effect: Effect.Effect<A, E, R>) =>\n      requests.withPermit(\n        Effect.suspend(() => {\n          activeRequests++;\n          peakActiveRequests = Math.max(peakActiveRequests, activeRequests);\n          return Metric.update(attempts, 1).pipe(\n            Effect.andThen(effect),\n            Effect.ensuring(\n              Effect.sync(() => {\n                activeRequests--;\n              }),\n            ),\n          );\n        }),\n      ),\n    lease: <A, E, R>(bytes: number, effect: Effect.Effect<A, E, R>) =>\n      budget.withLease(\n        bytes,\n        Effect.acquireUseRelease(\n          Metric.modify(inFlight, bytes),\n          () => effect,\n          () => Metric.modify(inFlight, -bytes),\n        ),\n      ),\n    deadline: <A, E, R>(operation: Operation, effect: Effect.Effect<A, E, R>) =>\n      effect.pipe(\n        Effect.onExit((exit) =>\n          Exit.isFailure(exit) &&\n          Cause.hasInterrupts(exit.cause) &&\n          operation.mutationStarted &&\n          !operation.committed\n            ? diagnostic({ kind: \"unknown-outcome\", operationId: operation.id })\n            : Effect.void,\n        ),\n        Effect.timeoutOrElse({\n          duration: policy.deadlineMillis,\n          orElse: () =>\n            Effect.fail(\n              storageError(\n                operation.progress.operation,\n                endpoint.storage.provider,\n                { _tag: \"TransportFailure\", code: \"TransferDeadlineExceeded\" },\n                operation.committed\n                  ? \"succeeded\"\n                  : operation.mutationStarted\n                    ? \"unknown\"\n                    : \"not-started\",\n              ),\n            ),\n        }),\n      ),\n  };\n}\n\nexport type TransferRuntime = ReturnType<typeof makeRuntime>;\n"],"mappings":"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"}

package/dist/transfers/sources.d.ts

@@ -0,0 +1,22 @@
+import { StorageError } from "../core/errors.js";
+import { TransferHash } from "./dependencies.js";
+import { Effect, FileSystem, Stream } from "effect";
+import { PlatformError } from "effect/PlatformError";
+declare namespace sources_d_exports {
+  export { UploadSource, bytes, file, replayable, stream };
+}
+export interface UploadSource<E = never, R = never> {
+  readonly length?: number | undefined;
+  readonly replayable: boolean;
+  readonly workspaceBytes?: number | undefined;
+  readonly open: () => Stream.Stream<Uint8Array, E | StorageError, R>;
+}
+/** Copies the caller's bytes once. This immutable snapshot is outside the engine's workspace. */
+export declare function bytes(input: Uint8Array): UploadSource;
+export declare function stream<E, R>(body: Stream.Stream<Uint8Array, E, R>, length?: number): UploadSource<E, R>;
+/** The factory promises the same representation on every opening. */
+export declare function replayable<E, R>(open: () => Stream.Stream<Uint8Array, E, R>, length?: number): UploadSource<E, R>;
+/** Captures FileSystem once. Every opening checks identity and a full bounded-memory fingerprint. */
+export declare const file: (path: string) => Effect.Effect<UploadSource<PlatformError | StorageError, never>, PlatformError | StorageError, FileSystem.FileSystem | TransferHash>;
+export { sources_d_exports };
+//# sourceMappingURL=sources.d.ts.map

package/dist/transfers/sources.js

@@ -0,0 +1,83 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { storageError } from "../core/errors.js";
+import { TransferHash } from "./dependencies.js";
+import { ByteSize, Cause, Effect, FileSystem, Option, Stream } from "effect";
+
+// src/transfers/sources.ts
+var sources_exports = /* @__PURE__ */ __exportAll({
+	bytes: () => bytes,
+	file: () => file,
+	replayable: () => replayable,
+	stream: () => stream
+});
+const sourceError = (field) => storageError("source", "transfer", {
+	_tag: "InvalidInput",
+	field
+}, "not-started");
+/** Copies the caller's bytes once. This immutable snapshot is outside the engine's workspace. */
+function bytes(input) {
+	const snapshot = Uint8Array.from(input);
+	return replayable(() => Stream.fromIterable((function* () {
+		for (let start = 0; start < snapshot.length; start += 65536) yield snapshot.slice(start, start + 65536);
+	})(), { chunkSize: 1 }), snapshot.length);
+}
+function stream(body, length) {
+	let consumed = false;
+	return {
+		length,
+		replayable: false,
+		open: () => Stream.unwrap(Effect.suspend(() => {
+			if (consumed) return Effect.fail(storageError("source", "transfer", { _tag: "BodyConsumed" }, "not-started"));
+			consumed = true;
+			return Effect.succeed(body);
+		}))
+	};
+}
+/** The factory promises the same representation on every opening. */
+function replayable(open, length) {
+	return {
+		length,
+		replayable: true,
+		open: () => Stream.suspend(open)
+	};
+}
+const identity = (info) => `${String(info.dev)}:${Option.getOrUndefined(info.ino)}:${String(ByteSize.toBigInt(info.size))}:${Option.getOrUndefined(info.mtime)?.getTime()}`;
+/** Captures FileSystem once. Every opening checks identity and a full bounded-memory fingerprint. */
+const file = Effect.fnUntraced(function* (path) {
+	const fs = yield* FileSystem.FileSystem;
+	const digest = yield* TransferHash;
+	const original = yield* fs.stat(path);
+	const length = Number(ByteSize.toBigInt(original.size));
+	if (original.type !== "File" || !Number.isSafeInteger(length)) return yield* sourceError("file");
+	const fingerprint = Effect.scoped(Effect.gen(function* () {
+		const handle = yield* fs.open(path);
+		const state = digest.create();
+		while (true) {
+			const chunk = yield* handle.readAlloc(65536);
+			if (Option.isNone(chunk)) break;
+			state.update(chunk.value);
+		}
+		return state.finish().value;
+	}));
+	const expected = yield* fingerprint;
+	return {
+		...replayable(() => Stream.unwrap(Effect.gen(function* () {
+			const current = yield* fs.stat(path);
+			if (identity(current) !== identity(original) || (yield* fingerprint) !== expected) return yield* sourceError("file.changed");
+			const state = digest.create();
+			const handle = yield* fs.open(path);
+			return Stream.fromPull(Effect.succeed(Effect.gen(function* () {
+				const chunk = yield* handle.readAlloc(65536);
+				if (Option.isNone(chunk)) return yield* Cause.done();
+				return [chunk.value];
+			}))).pipe(Stream.tap((chunk) => Effect.sync(() => state.update(chunk))), Stream.concat(Stream.drain(Stream.fromEffect(Effect.gen(function* () {
+				const after = yield* fs.stat(path);
+				if (identity(after) !== identity(original) || state.finish().value !== expected) return yield* sourceError("file.changed");
+			})))));
+		})), length),
+		workspaceBytes: 65536 + digest.workspaceBytes
+	};
+});
+
+export { bytes, file, replayable, sources_exports, stream };
+//# sourceMappingURL=sources.js.map