@tranquilload/core 0.1.0

package/dist/multipart.cjs

@@ -0,0 +1,244 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_compression_service = require("./compression-service-Bn86iTJe.cjs");
+const require_logger_service = require("./logger-service-cx8vzkXs.cjs");
+const require_upload_error = require("./upload-error-BUexBh08.cjs");
+const require_normalize_callback = require("./normalize-callback-BNBZZ1jT.cjs");
+let effect = require("effect");
+//#region src/multipart/circuit-breaker.ts
+const makeCircuitBreaker = (config) => effect.Effect.gen(function* () {
+	const refState = yield* effect.Ref.make({
+		_tag: "Closed",
+		consecutiveFailures: 0
+	});
+	return {
+		guard: effect.Effect.gen(function* () {
+			if (yield* effect.Ref.modify(refState, (state) => {
+				if (state._tag !== "Open") return [false, state];
+				if (Date.now() - state.openedAt < config.cooldown) return [true, state];
+				return [false, { _tag: "HalfOpen" }];
+			})) return yield* effect.Effect.fail(new require_upload_error.CircuitOpenError(config.threshold));
+		}),
+		onSuccess: effect.Ref.update(refState, (state) => state._tag === "HalfOpen" || state._tag === "Closed" ? {
+			_tag: "Closed",
+			consecutiveFailures: 0
+		} : state),
+		onFailure: effect.Ref.modify(refState, (state) => {
+			if (state._tag === "Closed") {
+				const newFailures = state.consecutiveFailures + 1;
+				if (newFailures >= config.threshold) return [{
+					_tag: "CircuitOpen",
+					failedParts: newFailures,
+					timestamp: Date.now()
+				}, {
+					_tag: "Open",
+					openedAt: Date.now()
+				}];
+				return [null, {
+					_tag: "Closed",
+					consecutiveFailures: newFailures
+				}];
+			}
+			if (state._tag === "HalfOpen") return [{
+				_tag: "CircuitOpen",
+				failedParts: config.threshold,
+				timestamp: Date.now()
+			}, {
+				_tag: "Open",
+				openedAt: Date.now()
+			}];
+			return [null, state];
+		})
+	};
+});
+//#endregion
+//#region src/multipart/chunk-stream.ts
+const chunkStream = (stream, chunkSize) => {
+	let buffer = new Uint8Array(0);
+	const transform = new TransformStream({
+		transform(chunk, controller) {
+			const merged = new Uint8Array(buffer.length + chunk.length);
+			merged.set(buffer);
+			merged.set(chunk, buffer.length);
+			buffer = merged;
+			while (buffer.length >= chunkSize) {
+				controller.enqueue(buffer.slice(0, chunkSize));
+				buffer = buffer.slice(chunkSize);
+			}
+		},
+		flush(controller) {
+			if (buffer.length > 0) controller.enqueue(buffer);
+		}
+	});
+	const chunked = stream.pipeThrough(transform);
+	return effect.Stream.fromReadableStream(() => chunked, (e) => e);
+};
+//#endregion
+//#region src/multipart/upload-stream.ts
+const DEFAULT_MAX_CONCURRENCY = 4;
+const DEFAULT_RETRY_SCHEDULE = effect.Schedule.exponential("100 millis").pipe(effect.Schedule.compose(effect.Schedule.recurs(2)));
+const uploadMultipartEffect = (options) => {
+	const { stream, chunkSize, uploadPart, completeUpload, initiate, reconcileCompletedParts, maxConcurrency = DEFAULT_MAX_CONCURRENCY, signal, retrySchedule = DEFAULT_RETRY_SCHEDULE } = options;
+	return effect.Stream.unwrap(effect.Effect.gen(function* () {
+		const logger = yield* require_logger_service.LoggerService;
+		const semaphore = yield* effect.Effect.makeSemaphore(maxConcurrency);
+		const refParts = yield* effect.Ref.make([]);
+		const refBytesUploaded = yield* effect.Ref.make(0);
+		const refUploadId = yield* effect.Ref.make("");
+		const breaker = options.circuitBreaker ? yield* makeCircuitBreaker(options.circuitBreaker) : null;
+		const reconciledMap = reconcileCompletedParts ? new Map((yield* require_normalize_callback.normalizeCallback(reconcileCompletedParts).pipe(effect.Effect.mapError((cause) => new require_upload_error.ReconcileError(cause)))).map((p) => [p.partNumber, p.etag])) : /* @__PURE__ */ new Map();
+		const initiateStream = initiate ? effect.Stream.fromEffect(require_normalize_callback.normalizeCallback(initiate).pipe(effect.Effect.mapError((cause) => new require_upload_error.InitiateUploadError(cause)), effect.Effect.flatMap(({ uploadId }) => effect.Ref.set(refUploadId, uploadId).pipe(effect.Effect.as({
+			_tag: "UploadInitiated",
+			uploadId,
+			timestamp: Date.now()
+		}))))) : effect.Stream.empty;
+		const makeUploadOne = (partNumber, chunk) => effect.Effect.gen(function* () {
+			const reconciledEtag = reconciledMap.get(partNumber);
+			if (reconciledEtag !== void 0) {
+				const event = {
+					_tag: "PartCompleted",
+					partNumber,
+					etag: reconciledEtag,
+					bytesUploaded: chunk.length,
+					timestamp: Date.now()
+				};
+				yield* effect.Ref.update(refParts, (parts) => [...parts, {
+					partNumber,
+					etag: reconciledEtag
+				}]);
+				yield* effect.Effect.sync(() => logger.log("info", `Part ${partNumber} skipped (reconciled)`));
+				return event;
+			}
+			const refAttempts = yield* effect.Ref.make(0);
+			const single = effect.Effect.gen(function* () {
+				yield* effect.Ref.update(refAttempts, (n) => n + 1);
+				const attempt = yield* effect.Ref.get(refAttempts);
+				return yield* require_normalize_callback.normalizeCallback(() => uploadPart(partNumber, chunk)).pipe(effect.Effect.mapError((cause) => new require_upload_error.PartUploadError(partNumber, attempt, cause)));
+			});
+			const etag = yield* effect.Effect.retry(single, retrySchedule).pipe(effect.Effect.catchAll((err) => effect.Effect.gen(function* () {
+				const totalAttempts = yield* effect.Ref.get(refAttempts);
+				if (totalAttempts <= 1) return yield* effect.Effect.fail(err);
+				return yield* effect.Effect.fail(new require_upload_error.MaxRetriesExceededError(partNumber, totalAttempts, err.cause));
+			})));
+			const event = {
+				_tag: "PartCompleted",
+				partNumber,
+				etag,
+				bytesUploaded: chunk.length,
+				timestamp: Date.now()
+			};
+			yield* effect.Ref.update(refParts, (parts) => [...parts, {
+				partNumber,
+				etag
+			}]);
+			yield* effect.Effect.sync(() => logger.log("info", `Part ${partNumber} completed`));
+			return event;
+		});
+		const partsStream = chunkStream(stream, chunkSize).pipe(effect.Stream.mapError((cause) => new require_upload_error.PartUploadError(0, 0, cause)), effect.Stream.zipWithIndex, effect.Stream.mapEffect(([chunk, idx]) => {
+			const partNumber = Number(idx) + 1;
+			if (!breaker) {
+				const partEffect = semaphore.withPermits(1)(makeUploadOne(partNumber, chunk));
+				return signal ? effect.Effect.raceFirst(partEffect, require_normalize_callback.fromAbortSignal(signal)) : partEffect;
+			}
+			const partEffect = effect.Effect.gen(function* () {
+				yield* breaker.guard;
+				return yield* semaphore.withPermits(1)(effect.Effect.gen(function* () {
+					const exit = yield* effect.Effect.exit(makeUploadOne(partNumber, chunk));
+					if (effect.Exit.isSuccess(exit)) {
+						yield* breaker.onSuccess;
+						return exit.value;
+					}
+					const circuitEvent = yield* breaker.onFailure;
+					if (circuitEvent !== null) return yield* effect.Effect.fail(new require_upload_error.CircuitOpenError(circuitEvent.failedParts));
+					return yield* effect.Effect.fail(effect.Cause.squash(exit.cause));
+				}));
+			});
+			return signal ? effect.Effect.raceFirst(partEffect, require_normalize_callback.fromAbortSignal(signal)) : partEffect;
+		}, { concurrency: "unbounded" }), effect.Stream.flatMap((event) => {
+			const tickEffect = effect.Ref.updateAndGet(refBytesUploaded, (n) => n + event.bytesUploaded).pipe(effect.Effect.map((total) => ({
+				_tag: "ProgressTick",
+				bytesUploaded: total,
+				totalBytes: effect.Option.none(),
+				timestamp: Date.now()
+			})));
+			return effect.Stream.concat(effect.Stream.make(event), effect.Stream.fromEffect(tickEffect));
+		}), effect.Stream.catchAll((err) => {
+			if (breaker && err._tag === "CircuitOpenError") {
+				const event = {
+					_tag: "CircuitOpen",
+					failedParts: err.failedParts,
+					timestamp: Date.now()
+				};
+				return effect.Stream.concat(effect.Stream.succeed(event), effect.Stream.fail(err));
+			}
+			return effect.Stream.fail(err);
+		}));
+		const finalEffect = effect.Effect.gen(function* () {
+			const uploadId = yield* effect.Ref.get(refUploadId);
+			const parts = yield* effect.Ref.get(refParts);
+			yield* require_normalize_callback.normalizeCallback(() => completeUpload(uploadId, parts)).pipe(effect.Effect.mapError((cause) => new require_upload_error.CompleteUploadError(cause)));
+			yield* effect.Effect.sync(() => logger.log("info", "Multipart upload completed"));
+			return {
+				_tag: "UploadCompleted",
+				uploadId,
+				totalParts: parts.length,
+				timestamp: Date.now()
+			};
+		});
+		return effect.Stream.concat(initiateStream, partsStream.pipe(effect.Stream.concat(effect.Stream.fromEffect(finalEffect))));
+	}));
+};
+//#endregion
+//#region src/multipart/index.ts
+const uploadMultipart = (options) => {
+	const refProgress = effect.Effect.runSync(effect.Ref.make({
+		bytesUploaded: 0,
+		totalBytes: options.totalBytes !== void 0 ? effect.Option.some(options.totalBytes) : effect.Option.none()
+	}));
+	let resolveUploadId;
+	const uploadIdPromise = new Promise((resolve) => {
+		resolveUploadId = resolve;
+	});
+	const collected = (async () => {
+		let processedStream = options.stream;
+		if (options.pipeline !== void 0) if (typeof options.pipeline === "function") processedStream = options.pipeline(options.stream);
+		else processedStream = (await effect.Effect.runPromise(effect.Effect.provide(options.pipeline, require_compression_service.CompressionServiceLive)))(options.stream);
+		const program = uploadMultipartEffect({
+			...options,
+			stream: processedStream
+		}).pipe(effect.Stream.tap((event) => {
+			if (event._tag === "UploadInitiated") return effect.Effect.sync(() => resolveUploadId(event.uploadId));
+			if (event._tag === "PartCompleted") return effect.Ref.update(refProgress, (p) => ({
+				...p,
+				bytesUploaded: p.bytesUploaded + event.bytesUploaded
+			}));
+			return effect.Effect.void;
+		}), effect.Stream.provideLayer(require_logger_service.LoggerServiceLive));
+		const exit = await effect.Stream.runCollect(program).pipe(effect.Effect.map((chunk) => Array.from(chunk)), effect.Effect.runPromiseExit);
+		if (effect.Exit.isSuccess(exit)) return exit.value;
+		return Promise.reject(effect.Cause.squash(exit.cause));
+	})();
+	collected.finally(() => resolveUploadId("")).catch(() => {});
+	return {
+		events: new ReadableStream({ async start(controller) {
+			try {
+				const evts = await collected;
+				for (const event of evts) controller.enqueue(event);
+				controller.close();
+			} catch (_) {
+				controller.close();
+			}
+		} }),
+		result: collected.then((evts) => {
+			const last = evts[evts.length - 1];
+			if (last === void 0) return Promise.reject(/* @__PURE__ */ new Error("uploadMultipart: stream ended without emitting an event"));
+			return last;
+		}),
+		getProgress: Object.assign(() => effect.Effect.runPromise(effect.Ref.get(refProgress)), { effect: effect.Ref.get(refProgress) }),
+		uploadId: uploadIdPromise
+	};
+};
+uploadMultipart.effect = uploadMultipartEffect;
+//#endregion
+exports.uploadMultipart = uploadMultipart;
+
+//# sourceMappingURL=multipart.cjs.map

package/dist/multipart.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"multipart.cjs","names":["Effect","Ref","CircuitOpenError","Stream","Schedule","Stream","Effect","LoggerService","Ref","normalizeCallback","ReconcileError","InitiateUploadError","PartUploadError","MaxRetriesExceededError","fromAbortSignal","Exit","CircuitOpenError","Cause","Option","CompleteUploadError","Effect","Ref","Option","CompressionServiceLive","Stream","LoggerServiceLive","Exit","Cause"],"sources":["../src/multipart/circuit-breaker.ts","../src/multipart/chunk-stream.ts","../src/multipart/upload-stream.ts","../src/multipart/index.ts"],"sourcesContent":["import { Effect, Ref } from \"effect\"\nimport { CircuitOpenError } from \"../errors/upload-error.js\"\nimport type { CircuitOpen } from \"../progress/upload-event.js\"\n\nexport interface CircuitBreakerConfig {\n  readonly threshold: number\n  readonly cooldown: number\n}\n\ntype CircuitState =\n  | { readonly _tag: \"Closed\"; readonly consecutiveFailures: number }\n  | { readonly _tag: \"Open\"; readonly openedAt: number }\n  | { readonly _tag: \"HalfOpen\" }\n\nexport interface CircuitBreaker {\n  readonly guard: Effect.Effect<void, CircuitOpenError>\n  readonly onSuccess: Effect.Effect<void>\n  readonly onFailure: Effect.Effect<CircuitOpen | null>\n}\n\nexport const makeCircuitBreaker = (config: CircuitBreakerConfig): Effect.Effect<CircuitBreaker> =>\n  Effect.gen(function* () {\n    const refState = yield* Ref.make<CircuitState>({ _tag: \"Closed\", consecutiveFailures: 0 })\n\n    const guard: Effect.Effect<void, CircuitOpenError> = Effect.gen(function* () {\n      const blocked = yield* Ref.modify(refState, (state): [boolean, CircuitState] => {\n        if (state._tag !== \"Open\") return [false, state]\n        const elapsed = Date.now() - state.openedAt\n        if (elapsed < config.cooldown) return [true, state]\n        return [false, { _tag: \"HalfOpen\" as const }]\n      })\n      if (blocked) {\n        return yield* Effect.fail(new CircuitOpenError(config.threshold))\n      }\n    })\n\n    const onSuccess: Effect.Effect<void> = Ref.update(refState, state =>\n      state._tag === \"HalfOpen\" || state._tag === \"Closed\"\n        ? { _tag: \"Closed\" as const, consecutiveFailures: 0 }\n        : state\n    )\n\n    const onFailure: Effect.Effect<CircuitOpen | null> = Ref.modify(refState, (state): [CircuitOpen | null, CircuitState] => {\n      if (state._tag === \"Closed\") {\n        const newFailures = state.consecutiveFailures + 1\n        if (newFailures >= config.threshold) {\n          const event: CircuitOpen = {\n            _tag: \"CircuitOpen\",\n            failedParts: newFailures,\n            timestamp: Date.now(),\n          }\n          return [event, { _tag: \"Open\" as const, openedAt: Date.now() }]\n        }\n        return [null, { _tag: \"Closed\" as const, consecutiveFailures: newFailures }]\n      }\n      if (state._tag === \"HalfOpen\") {\n        const event: CircuitOpen = {\n          _tag: \"CircuitOpen\",\n          failedParts: config.threshold,\n          timestamp: Date.now(),\n        }\n        return [event, { _tag: \"Open\" as const, openedAt: Date.now() }]\n      }\n      return [null, state]\n    })\n\n    return { guard, onSuccess, onFailure }\n  })\n","import { Stream } from \"effect\"\n\nexport const chunkStream = (\n  stream: ReadableStream<Uint8Array>,\n  chunkSize: number\n): Stream.Stream<Uint8Array, unknown> => {\n  let buffer = new Uint8Array(0)\n\n  const transform = new TransformStream<Uint8Array, Uint8Array>({\n    transform(chunk, controller) {\n      // Concatenate incoming chunk into the buffer\n      const merged = new Uint8Array(buffer.length + chunk.length)\n      merged.set(buffer)\n      merged.set(chunk, buffer.length)\n      buffer = merged\n\n      // Emit every full-size chunk\n      while (buffer.length >= chunkSize) {\n        controller.enqueue(buffer.slice(0, chunkSize))\n        buffer = buffer.slice(chunkSize)\n      }\n    },\n    flush(controller) {\n      // Emit remaining bytes (last partial chunk)\n      if (buffer.length > 0) {\n        controller.enqueue(buffer)\n      }\n    },\n  })\n\n  const chunked = stream.pipeThrough(transform)\n\n  return Stream.fromReadableStream(\n    () => chunked,\n    (e) => e\n  )\n}\n","import { Cause, Effect, Exit, Option, Ref, Schedule, Stream } from \"effect\"\nimport type { UploadError } from \"../errors/upload-error.js\"\nimport { CircuitOpenError, CompleteUploadError, InitiateUploadError, MaxRetriesExceededError, PartUploadError, ReconcileError } from \"../errors/upload-error.js\"\nimport type { CircuitOpen, PartCompleted, ProgressTick, UploadCompleted, UploadEvent, UploadInitiated } from \"../progress/upload-event.js\"\nimport { LoggerService } from \"../services/logger-service.js\"\nimport { fromAbortSignal } from \"../utils/abort-interop.js\"\nimport { normalizeCallback } from \"../utils/normalize-callback.js\"\nimport { makeCircuitBreaker, type CircuitBreakerConfig } from \"./circuit-breaker.js\"\nimport { chunkStream } from \"./chunk-stream.js\"\n\nexport interface CompletedPart {\n  readonly partNumber: number\n  readonly etag: string\n}\n\nexport interface UploadMultipartOptions {\n  readonly stream: ReadableStream<Uint8Array>\n  readonly chunkSize: number\n  readonly uploadPart: (\n    partNumber: number,\n    chunk: Uint8Array\n  ) => string | Promise<string> | Effect.Effect<string, UploadError>\n  readonly completeUpload: (\n    uploadId: string,\n    parts: ReadonlyArray<CompletedPart>\n  ) => void | Promise<void> | Effect.Effect<void, UploadError>\n  readonly initiate?: () =>\n    | { uploadId: string }\n    | Promise<{ uploadId: string }>\n    | Effect.Effect<{ uploadId: string }, UploadError>\n  readonly reconcileCompletedParts?: () =>\n    | ReadonlyArray<CompletedPart>\n    | Promise<ReadonlyArray<CompletedPart>>\n    | Effect.Effect<ReadonlyArray<CompletedPart>, UploadError>\n  readonly maxConcurrency?: number\n  readonly signal?: AbortSignal\n  readonly retrySchedule?: Schedule.Schedule<unknown, PartUploadError>\n  readonly circuitBreaker?: CircuitBreakerConfig\n}\n\nconst DEFAULT_MAX_CONCURRENCY = 4\n\n// 3 total attempts: 1 initial + 2 retries, with exponential backoff\nconst DEFAULT_RETRY_SCHEDULE = Schedule.exponential(\"100 millis\").pipe(\n  Schedule.compose(Schedule.recurs(2))\n)\n\nexport const uploadMultipartEffect = (\n  options: UploadMultipartOptions\n): Stream.Stream<UploadEvent, UploadError, LoggerService> => {\n  const {\n    stream,\n    chunkSize,\n    uploadPart,\n    completeUpload,\n    initiate,\n    reconcileCompletedParts,\n    maxConcurrency = DEFAULT_MAX_CONCURRENCY,\n    signal,\n    retrySchedule = DEFAULT_RETRY_SCHEDULE,\n  } = options\n\n  return Stream.unwrap(\n    Effect.gen(function* () {\n      const logger = yield* LoggerService\n      const semaphore = yield* Effect.makeSemaphore(maxConcurrency)\n      const refParts = yield* Ref.make<CompletedPart[]>([])\n      const refBytesUploaded = yield* Ref.make(0)\n      const refUploadId = yield* Ref.make(\"\")\n      const breaker = options.circuitBreaker\n        ? yield* makeCircuitBreaker(options.circuitBreaker)\n        : null\n\n      const reconciledMap: Map<number, string> = reconcileCompletedParts\n        ? new Map(\n            (yield* normalizeCallback(reconcileCompletedParts).pipe(\n              Effect.mapError((cause): UploadError => new ReconcileError(cause))\n            )).map(p => [p.partNumber, p.etag])\n          )\n        : new Map()\n\n      const initiateStream: Stream.Stream<UploadEvent, UploadError, never> = initiate\n        ? Stream.fromEffect(\n            normalizeCallback(initiate).pipe(\n              Effect.mapError((cause): UploadError => new InitiateUploadError(cause)),\n              Effect.flatMap(({ uploadId }) =>\n                Ref.set(refUploadId, uploadId).pipe(\n                  Effect.as({\n                    _tag: \"UploadInitiated\" as const,\n                    uploadId,\n                    timestamp: Date.now(),\n                  } satisfies UploadInitiated)\n                )\n              )\n            )\n          )\n        : Stream.empty\n\n      const makeUploadOne = (\n        partNumber: number,\n        chunk: Uint8Array\n      ): Effect.Effect<PartCompleted, UploadError> =>\n        Effect.gen(function* () {\n          const reconciledEtag = reconciledMap.get(partNumber)\n          if (reconciledEtag !== undefined) {\n            const event: PartCompleted = {\n              _tag: \"PartCompleted\" as const,\n              partNumber,\n              etag: reconciledEtag,\n              bytesUploaded: chunk.length,\n              timestamp: Date.now(),\n            }\n            yield* Ref.update(refParts, parts => [...parts, { partNumber, etag: reconciledEtag }])\n            yield* Effect.sync(() => logger.log(\"info\", `Part ${partNumber} skipped (reconciled)`))\n            return event\n          }\n\n          const refAttempts = yield* Ref.make(0)\n\n          const single: Effect.Effect<string, PartUploadError> = Effect.gen(function* () {\n            yield* Ref.update(refAttempts, n => n + 1)\n            const attempt = yield* Ref.get(refAttempts)\n            return yield* normalizeCallback(() => uploadPart(partNumber, chunk)).pipe(\n              Effect.mapError(\n                (cause): PartUploadError => new PartUploadError(partNumber, attempt, cause)\n              )\n            )\n          })\n\n          const etag = yield* Effect.retry(single, retrySchedule).pipe(\n            Effect.catchAll(err =>\n              Effect.gen(function* () {\n                const totalAttempts = yield* Ref.get(refAttempts)\n                if (totalAttempts <= 1) {\n                  return yield* Effect.fail(err)\n                }\n                return yield* Effect.fail(\n                  new MaxRetriesExceededError(partNumber, totalAttempts, err.cause)\n                )\n              })\n            )\n          )\n\n          const event: PartCompleted = {\n            _tag: \"PartCompleted\" as const,\n            partNumber,\n            etag,\n            bytesUploaded: chunk.length,\n            timestamp: Date.now(),\n          }\n\n          yield* Ref.update(refParts, parts => [...parts, { partNumber, etag }])\n          yield* Effect.sync(() => logger.log(\"info\", `Part ${partNumber} completed`))\n          return event\n        })\n\n      const partsStream: Stream.Stream<UploadEvent, UploadError, never> = chunkStream(\n        stream,\n        chunkSize\n      ).pipe(\n        Stream.mapError((cause): UploadError => new PartUploadError(0, 0, cause)),\n        Stream.zipWithIndex,\n        Stream.mapEffect(\n          ([chunk, idx]) => {\n            const partNumber = Number(idx) + 1\n\n            if (!breaker) {\n              const partEffect = semaphore.withPermits(1)(\n                makeUploadOne(partNumber, chunk)\n              )\n              return signal ? Effect.raceFirst(partEffect, fromAbortSignal(signal)) : partEffect\n            }\n\n            const partEffect = Effect.gen(function* () {\n              yield* breaker.guard\n              return yield* semaphore.withPermits(1)(\n                Effect.gen(function* () {\n                  const exit = yield* Effect.exit(makeUploadOne(partNumber, chunk))\n                  if (Exit.isSuccess(exit)) {\n                    yield* breaker.onSuccess\n                    return exit.value\n                  }\n                  const circuitEvent = yield* breaker.onFailure\n                  if (circuitEvent !== null) {\n                    return yield* Effect.fail(new CircuitOpenError(circuitEvent.failedParts))\n                  }\n                  return yield* Effect.fail(Cause.squash(exit.cause) as UploadError)\n                })\n              )\n            })\n\n            return signal ? Effect.raceFirst(partEffect, fromAbortSignal(signal)) : partEffect\n          },\n          { concurrency: \"unbounded\" }\n        ),\n        Stream.flatMap(\n          (event): Stream.Stream<UploadEvent, UploadError, never> => {\n            const tickEffect = Ref.updateAndGet(refBytesUploaded, (n) => n + event.bytesUploaded).pipe(\n              Effect.map(\n                (total): ProgressTick => ({\n                  _tag: \"ProgressTick\" as const,\n                  bytesUploaded: total,\n                  totalBytes: Option.none(),\n                  timestamp: Date.now(),\n                })\n              )\n            )\n            return Stream.concat(Stream.make(event), Stream.fromEffect(tickEffect))\n          }\n        ),\n        Stream.catchAll((err: UploadError): Stream.Stream<UploadEvent, UploadError, never> => {\n          if (breaker && err._tag === \"CircuitOpenError\") {\n            const event: UploadEvent = {\n              _tag: \"CircuitOpen\",\n              failedParts: err.failedParts,\n              timestamp: Date.now(),\n            }\n            return Stream.concat(Stream.succeed(event), Stream.fail(err))\n          }\n          return Stream.fail(err)\n        })\n      )\n\n      const finalEffect: Effect.Effect<UploadEvent, UploadError, never> = Effect.gen(\n        function* () {\n          const uploadId = yield* Ref.get(refUploadId)\n          const parts = yield* Ref.get(refParts)\n          yield* normalizeCallback(() => completeUpload(uploadId, parts)).pipe(\n            Effect.mapError(\n              (cause): UploadError => new CompleteUploadError(cause)\n            )\n          )\n          yield* Effect.sync(() => logger.log(\"info\", \"Multipart upload completed\"))\n          return {\n            _tag: \"UploadCompleted\" as const,\n            uploadId,\n            totalParts: parts.length,\n            timestamp: Date.now(),\n          } satisfies UploadCompleted\n        }\n      )\n\n      return Stream.concat(initiateStream, partsStream.pipe(Stream.concat(Stream.fromEffect(finalEffect))))\n    })\n  )\n}\n","import { Cause, Effect, Exit, Option, Ref, Stream } from \"effect\"\nimport type { UploadCompleted, UploadEvent } from \"../progress/upload-event.js\"\nimport type { Transform } from \"../pipeline/middleware.js\"\nimport { CompressionServiceLive } from \"../services/compression-service.js\"\nimport { LoggerServiceLive } from \"../services/logger-service.js\"\nimport { uploadMultipartEffect, type CompletedPart, type UploadMultipartOptions } from \"./upload-stream.js\"\n\nexport type UploadResult = UploadCompleted\nexport type { CompletedPart, UploadMultipartOptions }\n\nexport interface Progress {\n  readonly bytesUploaded: number\n  readonly totalBytes: Option.Option<number>\n}\n\nexport interface MultipartPublicOptions extends UploadMultipartOptions {\n  readonly totalBytes?: number\n  readonly pipeline?: Transform | Effect.Effect<Transform, unknown, unknown>\n}\n\nexport const uploadMultipart = (\n  options: MultipartPublicOptions\n): {\n  events: ReadableStream<UploadEvent>\n  result: Promise<UploadResult>\n  getProgress: (() => Promise<Progress>) & { effect: Effect.Effect<Progress> }\n  uploadId: Promise<string>\n} => {\n  const refProgress = Effect.runSync(\n    Ref.make<Progress>({\n      bytesUploaded: 0,\n      totalBytes: options.totalBytes !== undefined ? Option.some(options.totalBytes) : Option.none(),\n    })\n  )\n\n  let resolveUploadId!: (id: string) => void\n  const uploadIdPromise: Promise<string> = new Promise<string>((resolve) => {\n    resolveUploadId = resolve\n  })\n\n  const collected: Promise<ReadonlyArray<UploadEvent>> = (async () => {\n    // Step 1: resolve pipeline to get the processed stream\n    let processedStream = options.stream\n    if (options.pipeline !== undefined) {\n      if (typeof options.pipeline === \"function\") {\n        processedStream = options.pipeline(options.stream)\n      } else {\n        // Effect pipeline — resolve with CompressionServiceLive\n        const transform = await Effect.runPromise(\n          Effect.provide(\n            options.pipeline as Effect.Effect<Transform, unknown, never>,\n            CompressionServiceLive\n          )\n        )\n        processedStream = transform(options.stream)\n      }\n    }\n\n    // Step 2: run upload with processedStream\n    const program = uploadMultipartEffect({ ...options, stream: processedStream }).pipe(\n      Stream.tap((event) => {\n        if (event._tag === \"UploadInitiated\") {\n          return Effect.sync(() => resolveUploadId(event.uploadId))\n        }\n        if (event._tag === \"PartCompleted\") {\n          return Ref.update(refProgress, (p) => ({\n            ...p,\n            bytesUploaded: p.bytesUploaded + event.bytesUploaded,\n          }))\n        }\n        return Effect.void\n      }),\n      Stream.provideLayer(LoggerServiceLive)\n    )\n\n    const exit = await Stream.runCollect(program).pipe(\n      Effect.map((chunk) => Array.from(chunk)),\n      Effect.runPromiseExit\n    )\n    if (Exit.isSuccess(exit)) return exit.value\n    return Promise.reject(Cause.squash(exit.cause))\n  })()\n\n  // Rejection is surfaced via `result`; suppress the propagated rejection from .finally()\n  collected.finally(() => resolveUploadId(\"\")).catch(() => {})\n\n  // events: ReadableStream built from collected array; closes cleanly on error\n  const events = new ReadableStream<UploadEvent>({\n    async start(controller) {\n      try {\n        const evts = await collected\n        for (const event of evts) controller.enqueue(event)\n        controller.close()\n      } catch (_) {\n        // Close cleanly — upload errors surface via `result` only\n        controller.close()\n      }\n    },\n  })\n\n  // result: resolves with UploadCompleted, rejects with UploadError on failure\n  const result: Promise<UploadResult> = collected.then((evts) => {\n    const last = evts[evts.length - 1]\n    if (last === undefined) {\n      return Promise.reject(new Error(\"uploadMultipart: stream ended without emitting an event\"))\n    }\n    return last as UploadResult\n  })\n\n  const getProgress = Object.assign(\n    (): Promise<Progress> => Effect.runPromise(Ref.get(refProgress)),\n    { effect: Ref.get(refProgress) }\n  )\n\n  return { events, result, getProgress, uploadId: uploadIdPromise }\n}\n\n// Effect escape hatch — LoggerService layer left open for user composition\nuploadMultipart.effect = uploadMultipartEffect\n"],"mappings":"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"}

package/dist/multipart.d.cts

@@ -0,0 +1,2 @@
+import { a as CompletedPart, i as uploadMultipart, n as Progress, o as UploadMultipartOptions, r as UploadResult, t as MultipartPublicOptions } from "./index-Ch8xM6Xt.cjs";
+export { CompletedPart, MultipartPublicOptions, Progress, UploadMultipartOptions, UploadResult, uploadMultipart };

package/dist/multipart.d.mts

@@ -0,0 +1,2 @@
+import { a as CompletedPart, i as uploadMultipart, n as Progress, o as UploadMultipartOptions, r as UploadResult, t as MultipartPublicOptions } from "./index-DBGtgXEd.mjs";
+export { CompletedPart, MultipartPublicOptions, Progress, UploadMultipartOptions, UploadResult, uploadMultipart };

package/dist/multipart.mjs

@@ -0,0 +1,243 @@
+import { n as CompressionServiceLive } from "./compression-service-Bm1VBnhT.mjs";
+import { n as LoggerServiceLive, t as LoggerService } from "./logger-service-1J5r_akj.mjs";
+import { a as MaxRetriesExceededError, c as ReconcileError, i as InitiateUploadError, n as CircuitOpenError, o as PartUploadError, r as CompleteUploadError } from "./upload-error-zDvpxT9X.mjs";
+import { n as fromAbortSignal, t as normalizeCallback } from "./normalize-callback-DQ6C4gaV.mjs";
+import { Cause, Effect, Exit, Option, Ref, Schedule, Stream } from "effect";
+//#region src/multipart/circuit-breaker.ts
+const makeCircuitBreaker = (config) => Effect.gen(function* () {
+	const refState = yield* Ref.make({
+		_tag: "Closed",
+		consecutiveFailures: 0
+	});
+	return {
+		guard: Effect.gen(function* () {
+			if (yield* Ref.modify(refState, (state) => {
+				if (state._tag !== "Open") return [false, state];
+				if (Date.now() - state.openedAt < config.cooldown) return [true, state];
+				return [false, { _tag: "HalfOpen" }];
+			})) return yield* Effect.fail(new CircuitOpenError(config.threshold));
+		}),
+		onSuccess: Ref.update(refState, (state) => state._tag === "HalfOpen" || state._tag === "Closed" ? {
+			_tag: "Closed",
+			consecutiveFailures: 0
+		} : state),
+		onFailure: Ref.modify(refState, (state) => {
+			if (state._tag === "Closed") {
+				const newFailures = state.consecutiveFailures + 1;
+				if (newFailures >= config.threshold) return [{
+					_tag: "CircuitOpen",
+					failedParts: newFailures,
+					timestamp: Date.now()
+				}, {
+					_tag: "Open",
+					openedAt: Date.now()
+				}];
+				return [null, {
+					_tag: "Closed",
+					consecutiveFailures: newFailures
+				}];
+			}
+			if (state._tag === "HalfOpen") return [{
+				_tag: "CircuitOpen",
+				failedParts: config.threshold,
+				timestamp: Date.now()
+			}, {
+				_tag: "Open",
+				openedAt: Date.now()
+			}];
+			return [null, state];
+		})
+	};
+});
+//#endregion
+//#region src/multipart/chunk-stream.ts
+const chunkStream = (stream, chunkSize) => {
+	let buffer = new Uint8Array(0);
+	const transform = new TransformStream({
+		transform(chunk, controller) {
+			const merged = new Uint8Array(buffer.length + chunk.length);
+			merged.set(buffer);
+			merged.set(chunk, buffer.length);
+			buffer = merged;
+			while (buffer.length >= chunkSize) {
+				controller.enqueue(buffer.slice(0, chunkSize));
+				buffer = buffer.slice(chunkSize);
+			}
+		},
+		flush(controller) {
+			if (buffer.length > 0) controller.enqueue(buffer);
+		}
+	});
+	const chunked = stream.pipeThrough(transform);
+	return Stream.fromReadableStream(() => chunked, (e) => e);
+};
+//#endregion
+//#region src/multipart/upload-stream.ts
+const DEFAULT_MAX_CONCURRENCY = 4;
+const DEFAULT_RETRY_SCHEDULE = Schedule.exponential("100 millis").pipe(Schedule.compose(Schedule.recurs(2)));
+const uploadMultipartEffect = (options) => {
+	const { stream, chunkSize, uploadPart, completeUpload, initiate, reconcileCompletedParts, maxConcurrency = DEFAULT_MAX_CONCURRENCY, signal, retrySchedule = DEFAULT_RETRY_SCHEDULE } = options;
+	return Stream.unwrap(Effect.gen(function* () {
+		const logger = yield* LoggerService;
+		const semaphore = yield* Effect.makeSemaphore(maxConcurrency);
+		const refParts = yield* Ref.make([]);
+		const refBytesUploaded = yield* Ref.make(0);
+		const refUploadId = yield* Ref.make("");
+		const breaker = options.circuitBreaker ? yield* makeCircuitBreaker(options.circuitBreaker) : null;
+		const reconciledMap = reconcileCompletedParts ? new Map((yield* normalizeCallback(reconcileCompletedParts).pipe(Effect.mapError((cause) => new ReconcileError(cause)))).map((p) => [p.partNumber, p.etag])) : /* @__PURE__ */ new Map();
+		const initiateStream = initiate ? Stream.fromEffect(normalizeCallback(initiate).pipe(Effect.mapError((cause) => new InitiateUploadError(cause)), Effect.flatMap(({ uploadId }) => Ref.set(refUploadId, uploadId).pipe(Effect.as({
+			_tag: "UploadInitiated",
+			uploadId,
+			timestamp: Date.now()
+		}))))) : Stream.empty;
+		const makeUploadOne = (partNumber, chunk) => Effect.gen(function* () {
+			const reconciledEtag = reconciledMap.get(partNumber);
+			if (reconciledEtag !== void 0) {
+				const event = {
+					_tag: "PartCompleted",
+					partNumber,
+					etag: reconciledEtag,
+					bytesUploaded: chunk.length,
+					timestamp: Date.now()
+				};
+				yield* Ref.update(refParts, (parts) => [...parts, {
+					partNumber,
+					etag: reconciledEtag
+				}]);
+				yield* Effect.sync(() => logger.log("info", `Part ${partNumber} skipped (reconciled)`));
+				return event;
+			}
+			const refAttempts = yield* Ref.make(0);
+			const single = Effect.gen(function* () {
+				yield* Ref.update(refAttempts, (n) => n + 1);
+				const attempt = yield* Ref.get(refAttempts);
+				return yield* normalizeCallback(() => uploadPart(partNumber, chunk)).pipe(Effect.mapError((cause) => new PartUploadError(partNumber, attempt, cause)));
+			});
+			const etag = yield* Effect.retry(single, retrySchedule).pipe(Effect.catchAll((err) => Effect.gen(function* () {
+				const totalAttempts = yield* Ref.get(refAttempts);
+				if (totalAttempts <= 1) return yield* Effect.fail(err);
+				return yield* Effect.fail(new MaxRetriesExceededError(partNumber, totalAttempts, err.cause));
+			})));
+			const event = {
+				_tag: "PartCompleted",
+				partNumber,
+				etag,
+				bytesUploaded: chunk.length,
+				timestamp: Date.now()
+			};
+			yield* Ref.update(refParts, (parts) => [...parts, {
+				partNumber,
+				etag
+			}]);
+			yield* Effect.sync(() => logger.log("info", `Part ${partNumber} completed`));
+			return event;
+		});
+		const partsStream = chunkStream(stream, chunkSize).pipe(Stream.mapError((cause) => new PartUploadError(0, 0, cause)), Stream.zipWithIndex, Stream.mapEffect(([chunk, idx]) => {
+			const partNumber = Number(idx) + 1;
+			if (!breaker) {
+				const partEffect = semaphore.withPermits(1)(makeUploadOne(partNumber, chunk));
+				return signal ? Effect.raceFirst(partEffect, fromAbortSignal(signal)) : partEffect;
+			}
+			const partEffect = Effect.gen(function* () {
+				yield* breaker.guard;
+				return yield* semaphore.withPermits(1)(Effect.gen(function* () {
+					const exit = yield* Effect.exit(makeUploadOne(partNumber, chunk));
+					if (Exit.isSuccess(exit)) {
+						yield* breaker.onSuccess;
+						return exit.value;
+					}
+					const circuitEvent = yield* breaker.onFailure;
+					if (circuitEvent !== null) return yield* Effect.fail(new CircuitOpenError(circuitEvent.failedParts));
+					return yield* Effect.fail(Cause.squash(exit.cause));
+				}));
+			});
+			return signal ? Effect.raceFirst(partEffect, fromAbortSignal(signal)) : partEffect;
+		}, { concurrency: "unbounded" }), Stream.flatMap((event) => {
+			const tickEffect = Ref.updateAndGet(refBytesUploaded, (n) => n + event.bytesUploaded).pipe(Effect.map((total) => ({
+				_tag: "ProgressTick",
+				bytesUploaded: total,
+				totalBytes: Option.none(),
+				timestamp: Date.now()
+			})));
+			return Stream.concat(Stream.make(event), Stream.fromEffect(tickEffect));
+		}), Stream.catchAll((err) => {
+			if (breaker && err._tag === "CircuitOpenError") {
+				const event = {
+					_tag: "CircuitOpen",
+					failedParts: err.failedParts,
+					timestamp: Date.now()
+				};
+				return Stream.concat(Stream.succeed(event), Stream.fail(err));
+			}
+			return Stream.fail(err);
+		}));
+		const finalEffect = Effect.gen(function* () {
+			const uploadId = yield* Ref.get(refUploadId);
+			const parts = yield* Ref.get(refParts);
+			yield* normalizeCallback(() => completeUpload(uploadId, parts)).pipe(Effect.mapError((cause) => new CompleteUploadError(cause)));
+			yield* Effect.sync(() => logger.log("info", "Multipart upload completed"));
+			return {
+				_tag: "UploadCompleted",
+				uploadId,
+				totalParts: parts.length,
+				timestamp: Date.now()
+			};
+		});
+		return Stream.concat(initiateStream, partsStream.pipe(Stream.concat(Stream.fromEffect(finalEffect))));
+	}));
+};
+//#endregion
+//#region src/multipart/index.ts
+const uploadMultipart = (options) => {
+	const refProgress = Effect.runSync(Ref.make({
+		bytesUploaded: 0,
+		totalBytes: options.totalBytes !== void 0 ? Option.some(options.totalBytes) : Option.none()
+	}));
+	let resolveUploadId;
+	const uploadIdPromise = new Promise((resolve) => {
+		resolveUploadId = resolve;
+	});
+	const collected = (async () => {
+		let processedStream = options.stream;
+		if (options.pipeline !== void 0) if (typeof options.pipeline === "function") processedStream = options.pipeline(options.stream);
+		else processedStream = (await Effect.runPromise(Effect.provide(options.pipeline, CompressionServiceLive)))(options.stream);
+		const program = uploadMultipartEffect({
+			...options,
+			stream: processedStream
+		}).pipe(Stream.tap((event) => {
+			if (event._tag === "UploadInitiated") return Effect.sync(() => resolveUploadId(event.uploadId));
+			if (event._tag === "PartCompleted") return Ref.update(refProgress, (p) => ({
+				...p,
+				bytesUploaded: p.bytesUploaded + event.bytesUploaded
+			}));
+			return Effect.void;
+		}), Stream.provideLayer(LoggerServiceLive));
+		const exit = await Stream.runCollect(program).pipe(Effect.map((chunk) => Array.from(chunk)), Effect.runPromiseExit);
+		if (Exit.isSuccess(exit)) return exit.value;
+		return Promise.reject(Cause.squash(exit.cause));
+	})();
+	collected.finally(() => resolveUploadId("")).catch(() => {});
+	return {
+		events: new ReadableStream({ async start(controller) {
+			try {
+				const evts = await collected;
+				for (const event of evts) controller.enqueue(event);
+				controller.close();
+			} catch (_) {
+				controller.close();
+			}
+		} }),
+		result: collected.then((evts) => {
+			const last = evts[evts.length - 1];
+			if (last === void 0) return Promise.reject(/* @__PURE__ */ new Error("uploadMultipart: stream ended without emitting an event"));
+			return last;
+		}),
+		getProgress: Object.assign(() => Effect.runPromise(Ref.get(refProgress)), { effect: Ref.get(refProgress) }),
+		uploadId: uploadIdPromise
+	};
+};
+uploadMultipart.effect = uploadMultipartEffect;
+//#endregion
+export { uploadMultipart };
+
+//# sourceMappingURL=multipart.mjs.map

package/dist/multipart.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"multipart.mjs","names":[],"sources":["../src/multipart/circuit-breaker.ts","../src/multipart/chunk-stream.ts","../src/multipart/upload-stream.ts","../src/multipart/index.ts"],"sourcesContent":["import { Effect, Ref } from \"effect\"\nimport { CircuitOpenError } from \"../errors/upload-error.js\"\nimport type { CircuitOpen } from \"../progress/upload-event.js\"\n\nexport interface CircuitBreakerConfig {\n  readonly threshold: number\n  readonly cooldown: number\n}\n\ntype CircuitState =\n  | { readonly _tag: \"Closed\"; readonly consecutiveFailures: number }\n  | { readonly _tag: \"Open\"; readonly openedAt: number }\n  | { readonly _tag: \"HalfOpen\" }\n\nexport interface CircuitBreaker {\n  readonly guard: Effect.Effect<void, CircuitOpenError>\n  readonly onSuccess: Effect.Effect<void>\n  readonly onFailure: Effect.Effect<CircuitOpen | null>\n}\n\nexport const makeCircuitBreaker = (config: CircuitBreakerConfig): Effect.Effect<CircuitBreaker> =>\n  Effect.gen(function* () {\n    const refState = yield* Ref.make<CircuitState>({ _tag: \"Closed\", consecutiveFailures: 0 })\n\n    const guard: Effect.Effect<void, CircuitOpenError> = Effect.gen(function* () {\n      const blocked = yield* Ref.modify(refState, (state): [boolean, CircuitState] => {\n        if (state._tag !== \"Open\") return [false, state]\n        const elapsed = Date.now() - state.openedAt\n        if (elapsed < config.cooldown) return [true, state]\n        return [false, { _tag: \"HalfOpen\" as const }]\n      })\n      if (blocked) {\n        return yield* Effect.fail(new CircuitOpenError(config.threshold))\n      }\n    })\n\n    const onSuccess: Effect.Effect<void> = Ref.update(refState, state =>\n      state._tag === \"HalfOpen\" || state._tag === \"Closed\"\n        ? { _tag: \"Closed\" as const, consecutiveFailures: 0 }\n        : state\n    )\n\n    const onFailure: Effect.Effect<CircuitOpen | null> = Ref.modify(refState, (state): [CircuitOpen | null, CircuitState] => {\n      if (state._tag === \"Closed\") {\n        const newFailures = state.consecutiveFailures + 1\n        if (newFailures >= config.threshold) {\n          const event: CircuitOpen = {\n            _tag: \"CircuitOpen\",\n            failedParts: newFailures,\n            timestamp: Date.now(),\n          }\n          return [event, { _tag: \"Open\" as const, openedAt: Date.now() }]\n        }\n        return [null, { _tag: \"Closed\" as const, consecutiveFailures: newFailures }]\n      }\n      if (state._tag === \"HalfOpen\") {\n        const event: CircuitOpen = {\n          _tag: \"CircuitOpen\",\n          failedParts: config.threshold,\n          timestamp: Date.now(),\n        }\n        return [event, { _tag: \"Open\" as const, openedAt: Date.now() }]\n      }\n      return [null, state]\n    })\n\n    return { guard, onSuccess, onFailure }\n  })\n","import { Stream } from \"effect\"\n\nexport const chunkStream = (\n  stream: ReadableStream<Uint8Array>,\n  chunkSize: number\n): Stream.Stream<Uint8Array, unknown> => {\n  let buffer = new Uint8Array(0)\n\n  const transform = new TransformStream<Uint8Array, Uint8Array>({\n    transform(chunk, controller) {\n      // Concatenate incoming chunk into the buffer\n      const merged = new Uint8Array(buffer.length + chunk.length)\n      merged.set(buffer)\n      merged.set(chunk, buffer.length)\n      buffer = merged\n\n      // Emit every full-size chunk\n      while (buffer.length >= chunkSize) {\n        controller.enqueue(buffer.slice(0, chunkSize))\n        buffer = buffer.slice(chunkSize)\n      }\n    },\n    flush(controller) {\n      // Emit remaining bytes (last partial chunk)\n      if (buffer.length > 0) {\n        controller.enqueue(buffer)\n      }\n    },\n  })\n\n  const chunked = stream.pipeThrough(transform)\n\n  return Stream.fromReadableStream(\n    () => chunked,\n    (e) => e\n  )\n}\n","import { Cause, Effect, Exit, Option, Ref, Schedule, Stream } from \"effect\"\nimport type { UploadError } from \"../errors/upload-error.js\"\nimport { CircuitOpenError, CompleteUploadError, InitiateUploadError, MaxRetriesExceededError, PartUploadError, ReconcileError } from \"../errors/upload-error.js\"\nimport type { CircuitOpen, PartCompleted, ProgressTick, UploadCompleted, UploadEvent, UploadInitiated } from \"../progress/upload-event.js\"\nimport { LoggerService } from \"../services/logger-service.js\"\nimport { fromAbortSignal } from \"../utils/abort-interop.js\"\nimport { normalizeCallback } from \"../utils/normalize-callback.js\"\nimport { makeCircuitBreaker, type CircuitBreakerConfig } from \"./circuit-breaker.js\"\nimport { chunkStream } from \"./chunk-stream.js\"\n\nexport interface CompletedPart {\n  readonly partNumber: number\n  readonly etag: string\n}\n\nexport interface UploadMultipartOptions {\n  readonly stream: ReadableStream<Uint8Array>\n  readonly chunkSize: number\n  readonly uploadPart: (\n    partNumber: number,\n    chunk: Uint8Array\n  ) => string | Promise<string> | Effect.Effect<string, UploadError>\n  readonly completeUpload: (\n    uploadId: string,\n    parts: ReadonlyArray<CompletedPart>\n  ) => void | Promise<void> | Effect.Effect<void, UploadError>\n  readonly initiate?: () =>\n    | { uploadId: string }\n    | Promise<{ uploadId: string }>\n    | Effect.Effect<{ uploadId: string }, UploadError>\n  readonly reconcileCompletedParts?: () =>\n    | ReadonlyArray<CompletedPart>\n    | Promise<ReadonlyArray<CompletedPart>>\n    | Effect.Effect<ReadonlyArray<CompletedPart>, UploadError>\n  readonly maxConcurrency?: number\n  readonly signal?: AbortSignal\n  readonly retrySchedule?: Schedule.Schedule<unknown, PartUploadError>\n  readonly circuitBreaker?: CircuitBreakerConfig\n}\n\nconst DEFAULT_MAX_CONCURRENCY = 4\n\n// 3 total attempts: 1 initial + 2 retries, with exponential backoff\nconst DEFAULT_RETRY_SCHEDULE = Schedule.exponential(\"100 millis\").pipe(\n  Schedule.compose(Schedule.recurs(2))\n)\n\nexport const uploadMultipartEffect = (\n  options: UploadMultipartOptions\n): Stream.Stream<UploadEvent, UploadError, LoggerService> => {\n  const {\n    stream,\n    chunkSize,\n    uploadPart,\n    completeUpload,\n    initiate,\n    reconcileCompletedParts,\n    maxConcurrency = DEFAULT_MAX_CONCURRENCY,\n    signal,\n    retrySchedule = DEFAULT_RETRY_SCHEDULE,\n  } = options\n\n  return Stream.unwrap(\n    Effect.gen(function* () {\n      const logger = yield* LoggerService\n      const semaphore = yield* Effect.makeSemaphore(maxConcurrency)\n      const refParts = yield* Ref.make<CompletedPart[]>([])\n      const refBytesUploaded = yield* Ref.make(0)\n      const refUploadId = yield* Ref.make(\"\")\n      const breaker = options.circuitBreaker\n        ? yield* makeCircuitBreaker(options.circuitBreaker)\n        : null\n\n      const reconciledMap: Map<number, string> = reconcileCompletedParts\n        ? new Map(\n            (yield* normalizeCallback(reconcileCompletedParts).pipe(\n              Effect.mapError((cause): UploadError => new ReconcileError(cause))\n            )).map(p => [p.partNumber, p.etag])\n          )\n        : new Map()\n\n      const initiateStream: Stream.Stream<UploadEvent, UploadError, never> = initiate\n        ? Stream.fromEffect(\n            normalizeCallback(initiate).pipe(\n              Effect.mapError((cause): UploadError => new InitiateUploadError(cause)),\n              Effect.flatMap(({ uploadId }) =>\n                Ref.set(refUploadId, uploadId).pipe(\n                  Effect.as({\n                    _tag: \"UploadInitiated\" as const,\n                    uploadId,\n                    timestamp: Date.now(),\n                  } satisfies UploadInitiated)\n                )\n              )\n            )\n          )\n        : Stream.empty\n\n      const makeUploadOne = (\n        partNumber: number,\n        chunk: Uint8Array\n      ): Effect.Effect<PartCompleted, UploadError> =>\n        Effect.gen(function* () {\n          const reconciledEtag = reconciledMap.get(partNumber)\n          if (reconciledEtag !== undefined) {\n            const event: PartCompleted = {\n              _tag: \"PartCompleted\" as const,\n              partNumber,\n              etag: reconciledEtag,\n              bytesUploaded: chunk.length,\n              timestamp: Date.now(),\n            }\n            yield* Ref.update(refParts, parts => [...parts, { partNumber, etag: reconciledEtag }])\n            yield* Effect.sync(() => logger.log(\"info\", `Part ${partNumber} skipped (reconciled)`))\n            return event\n          }\n\n          const refAttempts = yield* Ref.make(0)\n\n          const single: Effect.Effect<string, PartUploadError> = Effect.gen(function* () {\n            yield* Ref.update(refAttempts, n => n + 1)\n            const attempt = yield* Ref.get(refAttempts)\n            return yield* normalizeCallback(() => uploadPart(partNumber, chunk)).pipe(\n              Effect.mapError(\n                (cause): PartUploadError => new PartUploadError(partNumber, attempt, cause)\n              )\n            )\n          })\n\n          const etag = yield* Effect.retry(single, retrySchedule).pipe(\n            Effect.catchAll(err =>\n              Effect.gen(function* () {\n                const totalAttempts = yield* Ref.get(refAttempts)\n                if (totalAttempts <= 1) {\n                  return yield* Effect.fail(err)\n                }\n                return yield* Effect.fail(\n                  new MaxRetriesExceededError(partNumber, totalAttempts, err.cause)\n                )\n              })\n            )\n          )\n\n          const event: PartCompleted = {\n            _tag: \"PartCompleted\" as const,\n            partNumber,\n            etag,\n            bytesUploaded: chunk.length,\n            timestamp: Date.now(),\n          }\n\n          yield* Ref.update(refParts, parts => [...parts, { partNumber, etag }])\n          yield* Effect.sync(() => logger.log(\"info\", `Part ${partNumber} completed`))\n          return event\n        })\n\n      const partsStream: Stream.Stream<UploadEvent, UploadError, never> = chunkStream(\n        stream,\n        chunkSize\n      ).pipe(\n        Stream.mapError((cause): UploadError => new PartUploadError(0, 0, cause)),\n        Stream.zipWithIndex,\n        Stream.mapEffect(\n          ([chunk, idx]) => {\n            const partNumber = Number(idx) + 1\n\n            if (!breaker) {\n              const partEffect = semaphore.withPermits(1)(\n                makeUploadOne(partNumber, chunk)\n              )\n              return signal ? Effect.raceFirst(partEffect, fromAbortSignal(signal)) : partEffect\n            }\n\n            const partEffect = Effect.gen(function* () {\n              yield* breaker.guard\n              return yield* semaphore.withPermits(1)(\n                Effect.gen(function* () {\n                  const exit = yield* Effect.exit(makeUploadOne(partNumber, chunk))\n                  if (Exit.isSuccess(exit)) {\n                    yield* breaker.onSuccess\n                    return exit.value\n                  }\n                  const circuitEvent = yield* breaker.onFailure\n                  if (circuitEvent !== null) {\n                    return yield* Effect.fail(new CircuitOpenError(circuitEvent.failedParts))\n                  }\n                  return yield* Effect.fail(Cause.squash(exit.cause) as UploadError)\n                })\n              )\n            })\n\n            return signal ? Effect.raceFirst(partEffect, fromAbortSignal(signal)) : partEffect\n          },\n          { concurrency: \"unbounded\" }\n        ),\n        Stream.flatMap(\n          (event): Stream.Stream<UploadEvent, UploadError, never> => {\n            const tickEffect = Ref.updateAndGet(refBytesUploaded, (n) => n + event.bytesUploaded).pipe(\n              Effect.map(\n                (total): ProgressTick => ({\n                  _tag: \"ProgressTick\" as const,\n                  bytesUploaded: total,\n                  totalBytes: Option.none(),\n                  timestamp: Date.now(),\n                })\n              )\n            )\n            return Stream.concat(Stream.make(event), Stream.fromEffect(tickEffect))\n          }\n        ),\n        Stream.catchAll((err: UploadError): Stream.Stream<UploadEvent, UploadError, never> => {\n          if (breaker && err._tag === \"CircuitOpenError\") {\n            const event: UploadEvent = {\n              _tag: \"CircuitOpen\",\n              failedParts: err.failedParts,\n              timestamp: Date.now(),\n            }\n            return Stream.concat(Stream.succeed(event), Stream.fail(err))\n          }\n          return Stream.fail(err)\n        })\n      )\n\n      const finalEffect: Effect.Effect<UploadEvent, UploadError, never> = Effect.gen(\n        function* () {\n          const uploadId = yield* Ref.get(refUploadId)\n          const parts = yield* Ref.get(refParts)\n          yield* normalizeCallback(() => completeUpload(uploadId, parts)).pipe(\n            Effect.mapError(\n              (cause): UploadError => new CompleteUploadError(cause)\n            )\n          )\n          yield* Effect.sync(() => logger.log(\"info\", \"Multipart upload completed\"))\n          return {\n            _tag: \"UploadCompleted\" as const,\n            uploadId,\n            totalParts: parts.length,\n            timestamp: Date.now(),\n          } satisfies UploadCompleted\n        }\n      )\n\n      return Stream.concat(initiateStream, partsStream.pipe(Stream.concat(Stream.fromEffect(finalEffect))))\n    })\n  )\n}\n","import { Cause, Effect, Exit, Option, Ref, Stream } from \"effect\"\nimport type { UploadCompleted, UploadEvent } from \"../progress/upload-event.js\"\nimport type { Transform } from \"../pipeline/middleware.js\"\nimport { CompressionServiceLive } from \"../services/compression-service.js\"\nimport { LoggerServiceLive } from \"../services/logger-service.js\"\nimport { uploadMultipartEffect, type CompletedPart, type UploadMultipartOptions } from \"./upload-stream.js\"\n\nexport type UploadResult = UploadCompleted\nexport type { CompletedPart, UploadMultipartOptions }\n\nexport interface Progress {\n  readonly bytesUploaded: number\n  readonly totalBytes: Option.Option<number>\n}\n\nexport interface MultipartPublicOptions extends UploadMultipartOptions {\n  readonly totalBytes?: number\n  readonly pipeline?: Transform | Effect.Effect<Transform, unknown, unknown>\n}\n\nexport const uploadMultipart = (\n  options: MultipartPublicOptions\n): {\n  events: ReadableStream<UploadEvent>\n  result: Promise<UploadResult>\n  getProgress: (() => Promise<Progress>) & { effect: Effect.Effect<Progress> }\n  uploadId: Promise<string>\n} => {\n  const refProgress = Effect.runSync(\n    Ref.make<Progress>({\n      bytesUploaded: 0,\n      totalBytes: options.totalBytes !== undefined ? Option.some(options.totalBytes) : Option.none(),\n    })\n  )\n\n  let resolveUploadId!: (id: string) => void\n  const uploadIdPromise: Promise<string> = new Promise<string>((resolve) => {\n    resolveUploadId = resolve\n  })\n\n  const collected: Promise<ReadonlyArray<UploadEvent>> = (async () => {\n    // Step 1: resolve pipeline to get the processed stream\n    let processedStream = options.stream\n    if (options.pipeline !== undefined) {\n      if (typeof options.pipeline === \"function\") {\n        processedStream = options.pipeline(options.stream)\n      } else {\n        // Effect pipeline — resolve with CompressionServiceLive\n        const transform = await Effect.runPromise(\n          Effect.provide(\n            options.pipeline as Effect.Effect<Transform, unknown, never>,\n            CompressionServiceLive\n          )\n        )\n        processedStream = transform(options.stream)\n      }\n    }\n\n    // Step 2: run upload with processedStream\n    const program = uploadMultipartEffect({ ...options, stream: processedStream }).pipe(\n      Stream.tap((event) => {\n        if (event._tag === \"UploadInitiated\") {\n          return Effect.sync(() => resolveUploadId(event.uploadId))\n        }\n        if (event._tag === \"PartCompleted\") {\n          return Ref.update(refProgress, (p) => ({\n            ...p,\n            bytesUploaded: p.bytesUploaded + event.bytesUploaded,\n          }))\n        }\n        return Effect.void\n      }),\n      Stream.provideLayer(LoggerServiceLive)\n    )\n\n    const exit = await Stream.runCollect(program).pipe(\n      Effect.map((chunk) => Array.from(chunk)),\n      Effect.runPromiseExit\n    )\n    if (Exit.isSuccess(exit)) return exit.value\n    return Promise.reject(Cause.squash(exit.cause))\n  })()\n\n  // Rejection is surfaced via `result`; suppress the propagated rejection from .finally()\n  collected.finally(() => resolveUploadId(\"\")).catch(() => {})\n\n  // events: ReadableStream built from collected array; closes cleanly on error\n  const events = new ReadableStream<UploadEvent>({\n    async start(controller) {\n      try {\n        const evts = await collected\n        for (const event of evts) controller.enqueue(event)\n        controller.close()\n      } catch (_) {\n        // Close cleanly — upload errors surface via `result` only\n        controller.close()\n      }\n    },\n  })\n\n  // result: resolves with UploadCompleted, rejects with UploadError on failure\n  const result: Promise<UploadResult> = collected.then((evts) => {\n    const last = evts[evts.length - 1]\n    if (last === undefined) {\n      return Promise.reject(new Error(\"uploadMultipart: stream ended without emitting an event\"))\n    }\n    return last as UploadResult\n  })\n\n  const getProgress = Object.assign(\n    (): Promise<Progress> => Effect.runPromise(Ref.get(refProgress)),\n    { effect: Ref.get(refProgress) }\n  )\n\n  return { events, result, getProgress, uploadId: uploadIdPromise }\n}\n\n// Effect escape hatch — LoggerService layer left open for user composition\nuploadMultipart.effect = uploadMultipartEffect\n"],"mappings":";;;;;;AAoBA,MAAa,sBAAsB,WACjC,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAO,IAAI,KAAmB;EAAE,MAAM;EAAU,qBAAqB;EAAG,CAAC;AA4C1F,QAAO;EAAE,OA1C4C,OAAO,IAAI,aAAa;AAO3E,OANgB,OAAO,IAAI,OAAO,WAAW,UAAmC;AAC9E,QAAI,MAAM,SAAS,OAAQ,QAAO,CAAC,OAAO,MAAM;AAEhD,QADgB,KAAK,KAAK,GAAG,MAAM,WACrB,OAAO,SAAU,QAAO,CAAC,MAAM,MAAM;AACnD,WAAO,CAAC,OAAO,EAAE,MAAM,YAAqB,CAAC;KAC7C,CAEA,QAAO,OAAO,OAAO,KAAK,IAAI,iBAAiB,OAAO,UAAU,CAAC;IAEnE;EAgCc,WA9BuB,IAAI,OAAO,WAAU,UAC1D,MAAM,SAAS,cAAc,MAAM,SAAS,WACxC;GAAE,MAAM;GAAmB,qBAAqB;GAAG,GACnD,MACL;EA0B0B,WAxB0B,IAAI,OAAO,WAAW,UAA8C;AACvH,OAAI,MAAM,SAAS,UAAU;IAC3B,MAAM,cAAc,MAAM,sBAAsB;AAChD,QAAI,eAAe,OAAO,UAMxB,QAAO,CALoB;KACzB,MAAM;KACN,aAAa;KACb,WAAW,KAAK,KAAK;KACtB,EACc;KAAE,MAAM;KAAiB,UAAU,KAAK,KAAK;KAAE,CAAC;AAEjE,WAAO,CAAC,MAAM;KAAE,MAAM;KAAmB,qBAAqB;KAAa,CAAC;;AAE9E,OAAI,MAAM,SAAS,WAMjB,QAAO,CALoB;IACzB,MAAM;IACN,aAAa,OAAO;IACpB,WAAW,KAAK,KAAK;IACtB,EACc;IAAE,MAAM;IAAiB,UAAU,KAAK,KAAK;IAAE,CAAC;AAEjE,UAAO,CAAC,MAAM,MAAM;IACpB;EAEoC;EACtC;;;ACjEJ,MAAa,eACX,QACA,cACuC;CACvC,IAAI,SAAS,IAAI,WAAW,EAAE;CAE9B,MAAM,YAAY,IAAI,gBAAwC;EAC5D,UAAU,OAAO,YAAY;GAE3B,MAAM,SAAS,IAAI,WAAW,OAAO,SAAS,MAAM,OAAO;AAC3D,UAAO,IAAI,OAAO;AAClB,UAAO,IAAI,OAAO,OAAO,OAAO;AAChC,YAAS;AAGT,UAAO,OAAO,UAAU,WAAW;AACjC,eAAW,QAAQ,OAAO,MAAM,GAAG,UAAU,CAAC;AAC9C,aAAS,OAAO,MAAM,UAAU;;;EAGpC,MAAM,YAAY;AAEhB,OAAI,OAAO,SAAS,EAClB,YAAW,QAAQ,OAAO;;EAG/B,CAAC;CAEF,MAAM,UAAU,OAAO,YAAY,UAAU;AAE7C,QAAO,OAAO,yBACN,UACL,MAAM,EACR;;;;ACKH,MAAM,0BAA0B;AAGhC,MAAM,yBAAyB,SAAS,YAAY,aAAa,CAAC,KAChE,SAAS,QAAQ,SAAS,OAAO,EAAE,CAAC,CACrC;AAED,MAAa,yBACX,YAC2D;CAC3D,MAAM,EACJ,QACA,WACA,YACA,gBACA,UACA,yBACA,iBAAiB,yBACjB,QACA,gBAAgB,2BACd;AAEJ,QAAO,OAAO,OACZ,OAAO,IAAI,aAAa;EACtB,MAAM,SAAS,OAAO;EACtB,MAAM,YAAY,OAAO,OAAO,cAAc,eAAe;EAC7D,MAAM,WAAW,OAAO,IAAI,KAAsB,EAAE,CAAC;EACrD,MAAM,mBAAmB,OAAO,IAAI,KAAK,EAAE;EAC3C,MAAM,cAAc,OAAO,IAAI,KAAK,GAAG;EACvC,MAAM,UAAU,QAAQ,iBACpB,OAAO,mBAAmB,QAAQ,eAAe,GACjD;EAEJ,MAAM,gBAAqC,0BACvC,IAAI,KACD,OAAO,kBAAkB,wBAAwB,CAAC,KACjD,OAAO,UAAU,UAAuB,IAAI,eAAe,MAAM,CAAC,CACnE,EAAE,KAAI,MAAK,CAAC,EAAE,YAAY,EAAE,KAAK,CAAC,CACpC,mBACD,IAAI,KAAK;EAEb,MAAM,iBAAiE,WACnE,OAAO,WACL,kBAAkB,SAAS,CAAC,KAC1B,OAAO,UAAU,UAAuB,IAAI,oBAAoB,MAAM,CAAC,EACvE,OAAO,SAAS,EAAE,eAChB,IAAI,IAAI,aAAa,SAAS,CAAC,KAC7B,OAAO,GAAG;GACR,MAAM;GACN;GACA,WAAW,KAAK,KAAK;GACtB,CAA2B,CAC7B,CACF,CACF,CACF,GACD,OAAO;EAEX,MAAM,iBACJ,YACA,UAEA,OAAO,IAAI,aAAa;GACtB,MAAM,iBAAiB,cAAc,IAAI,WAAW;AACpD,OAAI,mBAAmB,KAAA,GAAW;IAChC,MAAM,QAAuB;KAC3B,MAAM;KACN;KACA,MAAM;KACN,eAAe,MAAM;KACrB,WAAW,KAAK,KAAK;KACtB;AACD,WAAO,IAAI,OAAO,WAAU,UAAS,CAAC,GAAG,OAAO;KAAE;KAAY,MAAM;KAAgB,CAAC,CAAC;AACtF,WAAO,OAAO,WAAW,OAAO,IAAI,QAAQ,QAAQ,WAAW,uBAAuB,CAAC;AACvF,WAAO;;GAGT,MAAM,cAAc,OAAO,IAAI,KAAK,EAAE;GAEtC,MAAM,SAAiD,OAAO,IAAI,aAAa;AAC7E,WAAO,IAAI,OAAO,cAAa,MAAK,IAAI,EAAE;IAC1C,MAAM,UAAU,OAAO,IAAI,IAAI,YAAY;AAC3C,WAAO,OAAO,wBAAwB,WAAW,YAAY,MAAM,CAAC,CAAC,KACnE,OAAO,UACJ,UAA2B,IAAI,gBAAgB,YAAY,SAAS,MAAM,CAC5E,CACF;KACD;GAEF,MAAM,OAAO,OAAO,OAAO,MAAM,QAAQ,cAAc,CAAC,KACtD,OAAO,UAAS,QACd,OAAO,IAAI,aAAa;IACtB,MAAM,gBAAgB,OAAO,IAAI,IAAI,YAAY;AACjD,QAAI,iBAAiB,EACnB,QAAO,OAAO,OAAO,KAAK,IAAI;AAEhC,WAAO,OAAO,OAAO,KACnB,IAAI,wBAAwB,YAAY,eAAe,IAAI,MAAM,CAClE;KACD,CACH,CACF;GAED,MAAM,QAAuB;IAC3B,MAAM;IACN;IACA;IACA,eAAe,MAAM;IACrB,WAAW,KAAK,KAAK;IACtB;AAED,UAAO,IAAI,OAAO,WAAU,UAAS,CAAC,GAAG,OAAO;IAAE;IAAY;IAAM,CAAC,CAAC;AACtE,UAAO,OAAO,WAAW,OAAO,IAAI,QAAQ,QAAQ,WAAW,YAAY,CAAC;AAC5E,UAAO;IACP;EAEJ,MAAM,cAA8D,YAClE,QACA,UACD,CAAC,KACA,OAAO,UAAU,UAAuB,IAAI,gBAAgB,GAAG,GAAG,MAAM,CAAC,EACzE,OAAO,cACP,OAAO,WACJ,CAAC,OAAO,SAAS;GAChB,MAAM,aAAa,OAAO,IAAI,GAAG;AAEjC,OAAI,CAAC,SAAS;IACZ,MAAM,aAAa,UAAU,YAAY,EAAE,CACzC,cAAc,YAAY,MAAM,CACjC;AACD,WAAO,SAAS,OAAO,UAAU,YAAY,gBAAgB,OAAO,CAAC,GAAG;;GAG1E,MAAM,aAAa,OAAO,IAAI,aAAa;AACzC,WAAO,QAAQ;AACf,WAAO,OAAO,UAAU,YAAY,EAAE,CACpC,OAAO,IAAI,aAAa;KACtB,MAAM,OAAO,OAAO,OAAO,KAAK,cAAc,YAAY,MAAM,CAAC;AACjE,SAAI,KAAK,UAAU,KAAK,EAAE;AACxB,aAAO,QAAQ;AACf,aAAO,KAAK;;KAEd,MAAM,eAAe,OAAO,QAAQ;AACpC,SAAI,iBAAiB,KACnB,QAAO,OAAO,OAAO,KAAK,IAAI,iBAAiB,aAAa,YAAY,CAAC;AAE3E,YAAO,OAAO,OAAO,KAAK,MAAM,OAAO,KAAK,MAAM,CAAgB;MAClE,CACH;KACD;AAEF,UAAO,SAAS,OAAO,UAAU,YAAY,gBAAgB,OAAO,CAAC,GAAG;KAE1E,EAAE,aAAa,aAAa,CAC7B,EACD,OAAO,SACJ,UAA0D;GACzD,MAAM,aAAa,IAAI,aAAa,mBAAmB,MAAM,IAAI,MAAM,cAAc,CAAC,KACpF,OAAO,KACJ,WAAyB;IACxB,MAAM;IACN,eAAe;IACf,YAAY,OAAO,MAAM;IACzB,WAAW,KAAK,KAAK;IACtB,EACF,CACF;AACD,UAAO,OAAO,OAAO,OAAO,KAAK,MAAM,EAAE,OAAO,WAAW,WAAW,CAAC;IAE1E,EACD,OAAO,UAAU,QAAqE;AACpF,OAAI,WAAW,IAAI,SAAS,oBAAoB;IAC9C,MAAM,QAAqB;KACzB,MAAM;KACN,aAAa,IAAI;KACjB,WAAW,KAAK,KAAK;KACtB;AACD,WAAO,OAAO,OAAO,OAAO,QAAQ,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;;AAE/D,UAAO,OAAO,KAAK,IAAI;IACvB,CACH;EAED,MAAM,cAA8D,OAAO,IACzE,aAAa;GACX,MAAM,WAAW,OAAO,IAAI,IAAI,YAAY;GAC5C,MAAM,QAAQ,OAAO,IAAI,IAAI,SAAS;AACtC,UAAO,wBAAwB,eAAe,UAAU,MAAM,CAAC,CAAC,KAC9D,OAAO,UACJ,UAAuB,IAAI,oBAAoB,MAAM,CACvD,CACF;AACD,UAAO,OAAO,WAAW,OAAO,IAAI,QAAQ,6BAA6B,CAAC;AAC1E,UAAO;IACL,MAAM;IACN;IACA,YAAY,MAAM;IAClB,WAAW,KAAK,KAAK;IACtB;IAEJ;AAED,SAAO,OAAO,OAAO,gBAAgB,YAAY,KAAK,OAAO,OAAO,OAAO,WAAW,YAAY,CAAC,CAAC,CAAC;GACrG,CACH;;;;AChOH,MAAa,mBACX,YAMG;CACH,MAAM,cAAc,OAAO,QACzB,IAAI,KAAe;EACjB,eAAe;EACf,YAAY,QAAQ,eAAe,KAAA,IAAY,OAAO,KAAK,QAAQ,WAAW,GAAG,OAAO,MAAM;EAC/F,CAAC,CACH;CAED,IAAI;CACJ,MAAM,kBAAmC,IAAI,SAAiB,YAAY;AACxE,oBAAkB;GAClB;CAEF,MAAM,aAAkD,YAAY;EAElE,IAAI,kBAAkB,QAAQ;AAC9B,MAAI,QAAQ,aAAa,KAAA,EACvB,KAAI,OAAO,QAAQ,aAAa,WAC9B,mBAAkB,QAAQ,SAAS,QAAQ,OAAO;MASlD,oBANkB,MAAM,OAAO,WAC7B,OAAO,QACL,QAAQ,UACR,uBACD,CACF,EAC2B,QAAQ,OAAO;EAK/C,MAAM,UAAU,sBAAsB;GAAE,GAAG;GAAS,QAAQ;GAAiB,CAAC,CAAC,KAC7E,OAAO,KAAK,UAAU;AACpB,OAAI,MAAM,SAAS,kBACjB,QAAO,OAAO,WAAW,gBAAgB,MAAM,SAAS,CAAC;AAE3D,OAAI,MAAM,SAAS,gBACjB,QAAO,IAAI,OAAO,cAAc,OAAO;IACrC,GAAG;IACH,eAAe,EAAE,gBAAgB,MAAM;IACxC,EAAE;AAEL,UAAO,OAAO;IACd,EACF,OAAO,aAAa,kBAAkB,CACvC;EAED,MAAM,OAAO,MAAM,OAAO,WAAW,QAAQ,CAAC,KAC5C,OAAO,KAAK,UAAU,MAAM,KAAK,MAAM,CAAC,EACxC,OAAO,eACR;AACD,MAAI,KAAK,UAAU,KAAK,CAAE,QAAO,KAAK;AACtC,SAAO,QAAQ,OAAO,MAAM,OAAO,KAAK,MAAM,CAAC;KAC7C;AAGJ,WAAU,cAAc,gBAAgB,GAAG,CAAC,CAAC,YAAY,GAAG;AA8B5D,QAAO;EAAE,QA3BM,IAAI,eAA4B,EAC7C,MAAM,MAAM,YAAY;AACtB,OAAI;IACF,MAAM,OAAO,MAAM;AACnB,SAAK,MAAM,SAAS,KAAM,YAAW,QAAQ,MAAM;AACnD,eAAW,OAAO;YACX,GAAG;AAEV,eAAW,OAAO;;KAGvB,CAAC;EAgBe,QAbqB,UAAU,MAAM,SAAS;GAC7D,MAAM,OAAO,KAAK,KAAK,SAAS;AAChC,OAAI,SAAS,KAAA,EACX,QAAO,QAAQ,uBAAO,IAAI,MAAM,0DAA0D,CAAC;AAE7F,UAAO;IACP;EAOuB,aALL,OAAO,aACA,OAAO,WAAW,IAAI,IAAI,YAAY,CAAC,EAChE,EAAE,QAAQ,IAAI,IAAI,YAAY,EAAE,CACjC;EAEqC,UAAU;EAAiB;;AAInE,gBAAgB,SAAS"}

package/dist/normalize-callback-BNBZZ1jT.cjs

@@ -0,0 +1,44 @@
+const require_upload_error = require("./upload-error-BUexBh08.cjs");
+let effect = require("effect");
+//#region src/utils/abort-interop.ts
+const fromAbortSignal = (signal) => effect.Effect.async((resume) => {
+	if (!signal) return;
+	if (signal.aborted) {
+		resume(effect.Effect.fail(new require_upload_error.AbortError()));
+		return;
+	}
+	const handler = () => resume(effect.Effect.fail(new require_upload_error.AbortError()));
+	signal.addEventListener("abort", handler, { once: true });
+	return effect.Effect.sync(() => signal.removeEventListener("abort", handler));
+});
+//#endregion
+//#region src/utils/normalize-callback.ts
+const normalizeCallback = (fn) => effect.Effect.suspend(() => {
+	let result;
+	try {
+		result = fn();
+	} catch (e) {
+		return effect.Effect.fail(e);
+	}
+	if (effect.Effect.isEffect(result)) return result;
+	if (result instanceof Promise) return effect.Effect.tryPromise({
+		try: () => result,
+		catch: (e) => e
+	});
+	return effect.Effect.succeed(result);
+});
+//#endregion
+Object.defineProperty(exports, "fromAbortSignal", {
+	enumerable: true,
+	get: function() {
+		return fromAbortSignal;
+	}
+});
+Object.defineProperty(exports, "normalizeCallback", {
+	enumerable: true,
+	get: function() {
+		return normalizeCallback;
+	}
+});
+
+//# sourceMappingURL=normalize-callback-BNBZZ1jT.cjs.map