@tranquilload/core 0.1.0

package/dist/upload-error-zDvpxT9X.mjs

@@ -0,0 +1,72 @@
+//#region src/errors/upload-error.ts
+var PartUploadError = class extends Error {
+	_tag = "PartUploadError";
+	constructor(partNumber, attempt, cause) {
+		super(`Part ${partNumber} failed on attempt ${attempt}`);
+		this.partNumber = partNumber;
+		this.attempt = attempt;
+		this.cause = cause;
+		this.name = "PartUploadError";
+	}
+};
+var MaxRetriesExceededError = class extends Error {
+	_tag = "MaxRetriesExceededError";
+	constructor(partNumber, totalAttempts, cause) {
+		super(`Part ${partNumber} failed after ${totalAttempts} attempts`);
+		this.partNumber = partNumber;
+		this.totalAttempts = totalAttempts;
+		this.cause = cause;
+		this.name = "MaxRetriesExceededError";
+	}
+};
+var PresignedUrlError = class extends Error {
+	_tag = "PresignedUrlError";
+	constructor(cause) {
+		super("Failed to obtain pre-signed URL");
+		this.cause = cause;
+		this.name = "PresignedUrlError";
+	}
+};
+var InitiateUploadError = class extends Error {
+	_tag = "InitiateUploadError";
+	constructor(cause) {
+		super("Failed to initiate multipart upload");
+		this.cause = cause;
+		this.name = "InitiateUploadError";
+	}
+};
+var ReconcileError = class extends Error {
+	_tag = "ReconcileError";
+	constructor(cause) {
+		super("Failed to reconcile completed parts");
+		this.cause = cause;
+		this.name = "ReconcileError";
+	}
+};
+var CompleteUploadError = class extends Error {
+	_tag = "CompleteUploadError";
+	constructor(cause) {
+		super("Failed to complete multipart upload");
+		this.cause = cause;
+		this.name = "CompleteUploadError";
+	}
+};
+var AbortError = class extends Error {
+	_tag = "AbortError";
+	constructor() {
+		super("Upload aborted");
+		this.name = "AbortError";
+	}
+};
+var CircuitOpenError = class extends Error {
+	_tag = "CircuitOpenError";
+	constructor(failedParts) {
+		super(`Circuit breaker opened after ${failedParts} consecutive part failures`);
+		this.failedParts = failedParts;
+		this.name = "CircuitOpenError";
+	}
+};
+//#endregion
+export { MaxRetriesExceededError as a, ReconcileError as c, InitiateUploadError as i, CircuitOpenError as n, PartUploadError as o, CompleteUploadError as r, PresignedUrlError as s, AbortError as t };
+
+//# sourceMappingURL=upload-error-zDvpxT9X.mjs.map

package/dist/upload-error-zDvpxT9X.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-error-zDvpxT9X.mjs","names":[],"sources":["../src/errors/upload-error.ts"],"sourcesContent":["export class PartUploadError extends Error {\n  readonly _tag = \"PartUploadError\" as const\n\n  constructor(\n    readonly partNumber: number,\n    readonly attempt: number,\n    override readonly cause: unknown\n  ) {\n    super(`Part ${partNumber} failed on attempt ${attempt}`)\n    this.name = \"PartUploadError\"\n  }\n}\n\nexport class MaxRetriesExceededError extends Error {\n  readonly _tag = \"MaxRetriesExceededError\" as const\n\n  constructor(\n    readonly partNumber: number,\n    readonly totalAttempts: number,\n    override readonly cause: unknown\n  ) {\n    super(`Part ${partNumber} failed after ${totalAttempts} attempts`)\n    this.name = \"MaxRetriesExceededError\"\n  }\n}\n\nexport class PresignedUrlError extends Error {\n  readonly _tag = \"PresignedUrlError\" as const\n\n  constructor(override readonly cause: unknown) {\n    super(\"Failed to obtain pre-signed URL\")\n    this.name = \"PresignedUrlError\"\n  }\n}\n\nexport class InitiateUploadError extends Error {\n  readonly _tag = \"InitiateUploadError\" as const\n\n  constructor(override readonly cause: unknown) {\n    super(\"Failed to initiate multipart upload\")\n    this.name = \"InitiateUploadError\"\n  }\n}\n\nexport class ReconcileError extends Error {\n  readonly _tag = \"ReconcileError\" as const\n\n  constructor(override readonly cause: unknown) {\n    super(\"Failed to reconcile completed parts\")\n    this.name = \"ReconcileError\"\n  }\n}\n\nexport class CompleteUploadError extends Error {\n  readonly _tag = \"CompleteUploadError\" as const\n\n  constructor(override readonly cause: unknown) {\n    super(\"Failed to complete multipart upload\")\n    this.name = \"CompleteUploadError\"\n  }\n}\n\nexport class AbortError extends Error {\n  readonly _tag = \"AbortError\" as const\n\n  constructor() {\n    super(\"Upload aborted\")\n    this.name = \"AbortError\"\n  }\n}\n\nexport class CircuitOpenError extends Error {\n  readonly _tag = \"CircuitOpenError\" as const\n\n  constructor(readonly failedParts: number) {\n    super(`Circuit breaker opened after ${failedParts} consecutive part failures`)\n    this.name = \"CircuitOpenError\"\n  }\n}\n\nexport type UploadError =\n  | PartUploadError\n  | MaxRetriesExceededError\n  | PresignedUrlError\n  | InitiateUploadError\n  | ReconcileError\n  | CompleteUploadError\n  | AbortError\n  | CircuitOpenError\n"],"mappings":";AAAA,IAAa,kBAAb,cAAqC,MAAM;CACzC,OAAgB;CAEhB,YACE,YACA,SACA,OACA;AACA,QAAM,QAAQ,WAAW,qBAAqB,UAAU;AAJ/C,OAAA,aAAA;AACA,OAAA,UAAA;AACS,OAAA,QAAA;AAGlB,OAAK,OAAO;;;AAIhB,IAAa,0BAAb,cAA6C,MAAM;CACjD,OAAgB;CAEhB,YACE,YACA,eACA,OACA;AACA,QAAM,QAAQ,WAAW,gBAAgB,cAAc,WAAW;AAJzD,OAAA,aAAA;AACA,OAAA,gBAAA;AACS,OAAA,QAAA;AAGlB,OAAK,OAAO;;;AAIhB,IAAa,oBAAb,cAAuC,MAAM;CAC3C,OAAgB;CAEhB,YAAY,OAAkC;AAC5C,QAAM,kCAAkC;AADZ,OAAA,QAAA;AAE5B,OAAK,OAAO;;;AAIhB,IAAa,sBAAb,cAAyC,MAAM;CAC7C,OAAgB;CAEhB,YAAY,OAAkC;AAC5C,QAAM,sCAAsC;AADhB,OAAA,QAAA;AAE5B,OAAK,OAAO;;;AAIhB,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;CAEhB,YAAY,OAAkC;AAC5C,QAAM,sCAAsC;AADhB,OAAA,QAAA;AAE5B,OAAK,OAAO;;;AAIhB,IAAa,sBAAb,cAAyC,MAAM;CAC7C,OAAgB;CAEhB,YAAY,OAAkC;AAC5C,QAAM,sCAAsC;AADhB,OAAA,QAAA;AAE5B,OAAK,OAAO;;;AAIhB,IAAa,aAAb,cAAgC,MAAM;CACpC,OAAgB;CAEhB,cAAc;AACZ,QAAM,iBAAiB;AACvB,OAAK,OAAO;;;AAIhB,IAAa,mBAAb,cAAsC,MAAM;CAC1C,OAAgB;CAEhB,YAAY,aAA8B;AACxC,QAAM,gCAAgC,YAAY,4BAA4B;AAD3D,OAAA,cAAA;AAEnB,OAAK,OAAO"}

package/dist/upload-event-C9TOVp5l.d.mts

@@ -0,0 +1,36 @@
+import { Option } from "effect";
+
+//#region src/progress/upload-event.d.ts
+interface UploadInitiated {
+  readonly _tag: "UploadInitiated";
+  readonly uploadId: string;
+  readonly timestamp: number;
+}
+interface UploadCompleted {
+  readonly _tag: "UploadCompleted";
+  readonly uploadId: string;
+  readonly totalParts: number;
+  readonly timestamp: number;
+}
+interface PartCompleted {
+  readonly _tag: "PartCompleted";
+  readonly partNumber: number;
+  readonly etag: string;
+  readonly bytesUploaded: number;
+  readonly timestamp: number;
+}
+interface CircuitOpen {
+  readonly _tag: "CircuitOpen";
+  readonly failedParts: number;
+  readonly timestamp: number;
+}
+interface ProgressTick {
+  readonly _tag: "ProgressTick";
+  readonly bytesUploaded: number;
+  readonly totalBytes: Option.Option<number>;
+  readonly timestamp: number;
+}
+type UploadEvent = UploadInitiated | UploadCompleted | PartCompleted | ProgressTick | CircuitOpen;
+//#endregion
+export { UploadEvent as a, UploadCompleted as i, PartCompleted as n, UploadInitiated as o, ProgressTick as r, CircuitOpen as t };
+//# sourceMappingURL=upload-event-C9TOVp5l.d.mts.map

package/dist/upload-event-C9TOVp5l.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-event-C9TOVp5l.d.mts","names":[],"sources":["../src/progress/upload-event.ts"],"mappings":";;;UAEiB,eAAA;EAAA,SACN,IAAA;EAAA,SACA,QAAA;EAAA,SACA,SAAA;AAAA;AAAA,UAGM,eAAA;EAAA,SACN,IAAA;EAAA,SACA,QAAA;EAAA,SACA,UAAA;EAAA,SACA,SAAA;AAAA;AAAA,UAGM,aAAA;EAAA,SACN,IAAA;EAAA,SACA,UAAA;EAAA,SACA,IAAA;EAAA,SACA,aAAA;EAAA,SACA,SAAA;AAAA;AAAA,UAGM,WAAA;EAAA,SACN,IAAA;EAAA,SACA,WAAA;EAAA,SACA,SAAA;AAAA;AAAA,UAGM,YAAA;EAAA,SACN,IAAA;EAAA,SACA,aAAA;EAAA,SACA,UAAA,EAAY,MAAA,CAAO,MAAA;EAAA,SACnB,SAAA;AAAA;AAAA,KAGC,WAAA,GAAc,eAAA,GAAkB,eAAA,GAAkB,aAAA,GAAgB,YAAA,GAAe,WAAA"}

package/dist/upload-event-D77olieX.d.cts

@@ -0,0 +1,36 @@
+import { Option } from "effect";
+
+//#region src/progress/upload-event.d.ts
+interface UploadInitiated {
+  readonly _tag: "UploadInitiated";
+  readonly uploadId: string;
+  readonly timestamp: number;
+}
+interface UploadCompleted {
+  readonly _tag: "UploadCompleted";
+  readonly uploadId: string;
+  readonly totalParts: number;
+  readonly timestamp: number;
+}
+interface PartCompleted {
+  readonly _tag: "PartCompleted";
+  readonly partNumber: number;
+  readonly etag: string;
+  readonly bytesUploaded: number;
+  readonly timestamp: number;
+}
+interface CircuitOpen {
+  readonly _tag: "CircuitOpen";
+  readonly failedParts: number;
+  readonly timestamp: number;
+}
+interface ProgressTick {
+  readonly _tag: "ProgressTick";
+  readonly bytesUploaded: number;
+  readonly totalBytes: Option.Option<number>;
+  readonly timestamp: number;
+}
+type UploadEvent = UploadInitiated | UploadCompleted | PartCompleted | ProgressTick | CircuitOpen;
+//#endregion
+export { UploadEvent as a, UploadCompleted as i, PartCompleted as n, UploadInitiated as o, ProgressTick as r, CircuitOpen as t };
+//# sourceMappingURL=upload-event-D77olieX.d.cts.map

package/dist/upload-event-D77olieX.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload-event-D77olieX.d.cts","names":[],"sources":["../src/progress/upload-event.ts"],"mappings":";;;UAEiB,eAAA;EAAA,SACN,IAAA;EAAA,SACA,QAAA;EAAA,SACA,SAAA;AAAA;AAAA,UAGM,eAAA;EAAA,SACN,IAAA;EAAA,SACA,QAAA;EAAA,SACA,UAAA;EAAA,SACA,SAAA;AAAA;AAAA,UAGM,aAAA;EAAA,SACN,IAAA;EAAA,SACA,UAAA;EAAA,SACA,IAAA;EAAA,SACA,aAAA;EAAA,SACA,SAAA;AAAA;AAAA,UAGM,WAAA;EAAA,SACN,IAAA;EAAA,SACA,WAAA;EAAA,SACA,SAAA;AAAA;AAAA,UAGM,YAAA;EAAA,SACN,IAAA;EAAA,SACA,aAAA;EAAA,SACA,UAAA,EAAY,MAAA,CAAO,MAAA;EAAA,SACnB,SAAA;AAAA;AAAA,KAGC,WAAA,GAAc,eAAA,GAAkB,eAAA,GAAkB,aAAA,GAAgB,YAAA,GAAe,WAAA"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@tranquilload/core",
+  "version": "0.1.0",
+  "description": "Type-safe upload library built on Effect",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Schrubitteflau/Tranquilload.git"
+  },
+  "author": {
+    "name": "Schrubitteflau",
+    "url": "https://github.com/Schrubitteflau"
+  },
+  "bugs": {
+    "url": "https://github.com/Schrubitteflau/Tranquilload/issues"
+  },
+  "homepage": "https://github.com/Schrubitteflau/Tranquilload#readme",
+  "type": "module",
+  "exports": {
+    "./multipart": {
+      "types": "./dist/multipart.d.mts",
+      "import": "./dist/multipart.mjs",
+      "require": "./dist/multipart.cjs"
+    },
+    "./oneshot": {
+      "types": "./dist/oneshot.d.mts",
+      "import": "./dist/oneshot.mjs",
+      "require": "./dist/oneshot.cjs"
+    },
+    "./pipeline": {
+      "types": "./dist/pipeline.d.mts",
+      "import": "./dist/pipeline.mjs",
+      "require": "./dist/pipeline.cjs"
+    },
+    "./services": {
+      "types": "./dist/services.d.mts",
+      "import": "./dist/services.mjs",
+      "require": "./dist/services.cjs"
+    },
+    "./errors": {
+      "types": "./dist/errors.d.mts",
+      "import": "./dist/errors.mjs",
+      "require": "./dist/errors.cjs"
+    },
+    "./progress": {
+      "types": "./dist/progress.d.mts",
+      "import": "./dist/progress.mjs",
+      "require": "./dist/progress.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "effect": ">=3.19.19"
+  },
+  "devDependencies": {
+    "@effect/vitest": "^0.27.0",
+    "effect": "3.19.19",
+    "tsdown": "^0.21.0",
+    "typescript": "^5.5.0",
+    "vitest": "^3.2.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/errors/index.ts

@@ -0,0 +1,10 @@
+export {
+  PartUploadError,
+  MaxRetriesExceededError,
+  PresignedUrlError,
+  InitiateUploadError,
+  ReconcileError,
+  CompleteUploadError,
+  AbortError,
+  type UploadError,
+} from "./upload-error.js"

package/src/errors/upload-error.test.ts

@@ -0,0 +1,218 @@
+import { it, describe, expect } from 'vitest'
+import {
+  PartUploadError,
+  MaxRetriesExceededError,
+  PresignedUrlError,
+  InitiateUploadError,
+  ReconcileError,
+  CompleteUploadError,
+  AbortError,
+  CircuitOpenError,
+  type UploadError,
+} from './upload-error.js'
+
+describe("PartUploadError", () => {
+  it("is instanceof Error", () => {
+    const err = new PartUploadError(1, 1, new Error("network"))
+    expect(err instanceof Error).toBe(true)
+  })
+  it("has correct _tag", () => {
+    const err = new PartUploadError(1, 1, new Error("network"))
+    expect(err._tag).toBe("PartUploadError")
+  })
+  it("has human-readable message", () => {
+    const err = new PartUploadError(3, 2, new Error("timeout"))
+    expect(err.message).toBe("Part 3 failed on attempt 2")
+  })
+  it("name equals _tag for logger compat", () => {
+    const err = new PartUploadError(1, 1, new Error("x"))
+    expect(err.name).toBe("PartUploadError")
+  })
+  it("preserves cause", () => {
+    const cause = new Error("network failure")
+    const err = new PartUploadError(1, 1, cause)
+    expect(err.cause).toBe(cause)
+  })
+  it("preserves partNumber and attempt", () => {
+    const err = new PartUploadError(5, 3, null)
+    expect(err.partNumber).toBe(5)
+    expect(err.attempt).toBe(3)
+  })
+})
+
+describe("MaxRetriesExceededError", () => {
+  it("is instanceof Error", () => {
+    const err = new MaxRetriesExceededError(2, 4, new Error("exhausted"))
+    expect(err instanceof Error).toBe(true)
+  })
+  it("has correct _tag", () => {
+    const err = new MaxRetriesExceededError(2, 4, new Error("exhausted"))
+    expect(err._tag).toBe("MaxRetriesExceededError")
+  })
+  it("has human-readable message", () => {
+    const err = new MaxRetriesExceededError(2, 4, new Error("exhausted"))
+    expect(err.message).toBe("Part 2 failed after 4 attempts")
+  })
+  it("name equals _tag for logger compat", () => {
+    const err = new MaxRetriesExceededError(2, 4, null)
+    expect(err.name).toBe("MaxRetriesExceededError")
+  })
+  it("preserves partNumber and totalAttempts", () => {
+    const err = new MaxRetriesExceededError(7, 10, null)
+    expect(err.partNumber).toBe(7)
+    expect(err.totalAttempts).toBe(10)
+  })
+  it("preserves cause", () => {
+    const cause = new Error("last attempt failed")
+    const err = new MaxRetriesExceededError(2, 4, cause)
+    expect(err.cause).toBe(cause)
+  })
+})
+
+describe("PresignedUrlError", () => {
+  it("is instanceof Error", () => {
+    const err = new PresignedUrlError(new Error("403 Forbidden"))
+    expect(err instanceof Error).toBe(true)
+  })
+  it("has correct _tag", () => {
+    const err = new PresignedUrlError(new Error("403 Forbidden"))
+    expect(err._tag).toBe("PresignedUrlError")
+  })
+  it("has human-readable message", () => {
+    const err = new PresignedUrlError(null)
+    expect(err.message).toBe("Failed to obtain pre-signed URL")
+  })
+  it("name equals _tag for logger compat", () => {
+    const err = new PresignedUrlError(null)
+    expect(err.name).toBe("PresignedUrlError")
+  })
+  it("preserves cause", () => {
+    const cause = new Error("403 Forbidden")
+    const err = new PresignedUrlError(cause)
+    expect(err.cause).toBe(cause)
+  })
+})
+
+describe("InitiateUploadError", () => {
+  it("is instanceof Error", () => {
+    const err = new InitiateUploadError(new Error("S3 failure"))
+    expect(err instanceof Error).toBe(true)
+  })
+  it("has correct _tag", () => {
+    const err = new InitiateUploadError(new Error("S3 failure"))
+    expect(err._tag).toBe("InitiateUploadError")
+  })
+  it("has human-readable message", () => {
+    const err = new InitiateUploadError(null)
+    expect(err.message).toBe("Failed to initiate multipart upload")
+  })
+  it("name equals _tag for logger compat", () => {
+    const err = new InitiateUploadError(null)
+    expect(err.name).toBe("InitiateUploadError")
+  })
+  it("preserves cause", () => {
+    const cause = new Error("S3 failure")
+    const err = new InitiateUploadError(cause)
+    expect(err.cause).toBe(cause)
+  })
+})
+
+describe("ReconcileError", () => {
+  it("is instanceof Error", () => {
+    const err = new ReconcileError(new Error("storage unavailable"))
+    expect(err instanceof Error).toBe(true)
+  })
+  it("has correct _tag", () => {
+    const err = new ReconcileError(new Error("storage unavailable"))
+    expect(err._tag).toBe("ReconcileError")
+  })
+  it("has human-readable message", () => {
+    const err = new ReconcileError(null)
+    expect(err.message).toBe("Failed to reconcile completed parts")
+  })
+  it("name equals _tag for logger compat", () => {
+    const err = new ReconcileError(null)
+    expect(err.name).toBe("ReconcileError")
+  })
+  it("preserves cause", () => {
+    const cause = new Error("storage unavailable")
+    const err = new ReconcileError(cause)
+    expect(err.cause).toBe(cause)
+  })
+})
+
+describe("CompleteUploadError", () => {
+  it("is instanceof Error", () => {
+    const err = new CompleteUploadError(new Error("500 Internal"))
+    expect(err instanceof Error).toBe(true)
+  })
+  it("has correct _tag", () => {
+    const err = new CompleteUploadError(new Error("500 Internal"))
+    expect(err._tag).toBe("CompleteUploadError")
+  })
+  it("has human-readable message", () => {
+    const err = new CompleteUploadError(null)
+    expect(err.message).toBe("Failed to complete multipart upload")
+  })
+  it("name equals _tag for logger compat", () => {
+    const err = new CompleteUploadError(null)
+    expect(err.name).toBe("CompleteUploadError")
+  })
+  it("preserves cause", () => {
+    const cause = new Error("500 Internal")
+    const err = new CompleteUploadError(cause)
+    expect(err.cause).toBe(cause)
+  })
+})
+
+describe("AbortError", () => {
+  it("is instanceof Error", () => {
+    const err = new AbortError()
+    expect(err instanceof Error).toBe(true)
+  })
+  it("has correct _tag", () => {
+    const err = new AbortError()
+    expect(err._tag).toBe("AbortError")
+  })
+  it("has human-readable message", () => {
+    const err = new AbortError()
+    expect(err.message).toBe("Upload aborted")
+  })
+  it("name equals _tag for logger compat", () => {
+    const err = new AbortError()
+    expect(err.name).toBe("AbortError")
+  })
+  it("has no cause (abort is intentional, not an error chain)", () => {
+    const err = new AbortError()
+    expect(err.cause).toBeUndefined()
+  })
+})
+
+it("UploadError union is exhaustive", () => {
+  const check = (err: UploadError): string => {
+    switch (err._tag) {
+      case "PartUploadError": return "part"
+      case "MaxRetriesExceededError": return "maxRetries"
+      case "PresignedUrlError": return "presigned"
+      case "InitiateUploadError": return "initiate"
+      case "ReconcileError": return "reconcile"
+      case "CompleteUploadError": return "complete"
+      case "AbortError": return "abort"
+      case "CircuitOpenError": return "circuitOpen"
+      default: {
+        // If a new variant is added to UploadError without a matching case above,
+        // TypeScript will error here: "Type 'NewVariant' is not assignable to type 'never'"
+        const _exhaustive: never = err
+        return _exhaustive
+      }
+    }
+  }
+  expect(check(new AbortError())).toBe("abort")
+  expect(check(new PresignedUrlError(null))).toBe("presigned")
+  expect(check(new InitiateUploadError(null))).toBe("initiate")
+  expect(check(new ReconcileError(null))).toBe("reconcile")
+  expect(check(new CompleteUploadError(null))).toBe("complete")
+  expect(check(new PartUploadError(1, 1, null))).toBe("part")
+  expect(check(new MaxRetriesExceededError(1, 1, null))).toBe("maxRetries")
+  expect(check(new CircuitOpenError(3))).toBe("circuitOpen")
+})

package/src/errors/upload-error.ts

@@ -0,0 +1,89 @@
+export class PartUploadError extends Error {
+  readonly _tag = "PartUploadError" as const
+
+  constructor(
+    readonly partNumber: number,
+    readonly attempt: number,
+    override readonly cause: unknown
+  ) {
+    super(`Part ${partNumber} failed on attempt ${attempt}`)
+    this.name = "PartUploadError"
+  }
+}
+
+export class MaxRetriesExceededError extends Error {
+  readonly _tag = "MaxRetriesExceededError" as const
+
+  constructor(
+    readonly partNumber: number,
+    readonly totalAttempts: number,
+    override readonly cause: unknown
+  ) {
+    super(`Part ${partNumber} failed after ${totalAttempts} attempts`)
+    this.name = "MaxRetriesExceededError"
+  }
+}
+
+export class PresignedUrlError extends Error {
+  readonly _tag = "PresignedUrlError" as const
+
+  constructor(override readonly cause: unknown) {
+    super("Failed to obtain pre-signed URL")
+    this.name = "PresignedUrlError"
+  }
+}
+
+export class InitiateUploadError extends Error {
+  readonly _tag = "InitiateUploadError" as const
+
+  constructor(override readonly cause: unknown) {
+    super("Failed to initiate multipart upload")
+    this.name = "InitiateUploadError"
+  }
+}
+
+export class ReconcileError extends Error {
+  readonly _tag = "ReconcileError" as const
+
+  constructor(override readonly cause: unknown) {
+    super("Failed to reconcile completed parts")
+    this.name = "ReconcileError"
+  }
+}
+
+export class CompleteUploadError extends Error {
+  readonly _tag = "CompleteUploadError" as const
+
+  constructor(override readonly cause: unknown) {
+    super("Failed to complete multipart upload")
+    this.name = "CompleteUploadError"
+  }
+}
+
+export class AbortError extends Error {
+  readonly _tag = "AbortError" as const
+
+  constructor() {
+    super("Upload aborted")
+    this.name = "AbortError"
+  }
+}
+
+export class CircuitOpenError extends Error {
+  readonly _tag = "CircuitOpenError" as const
+
+  constructor(readonly failedParts: number) {
+    super(`Circuit breaker opened after ${failedParts} consecutive part failures`)
+    this.name = "CircuitOpenError"
+  }
+}
+
+export type UploadError =
+  | PartUploadError
+  | MaxRetriesExceededError
+  | PresignedUrlError
+  | InitiateUploadError
+  | ReconcileError
+  | CompleteUploadError
+  | AbortError
+  | CircuitOpenError

package/src/multipart/chunk-stream.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Effect, Stream } from "effect"
+import { chunkStream } from "./chunk-stream.js"
+
+// Helper: create a ReadableStream from a Uint8Array (single chunk)
+const fromBytes = (bytes: Uint8Array): ReadableStream<Uint8Array> =>
+  new ReadableStream({
+    start(controller) {
+      controller.enqueue(bytes)
+      controller.close()
+    },
+  })
+
+// Helper: run chunkStream and collect chunks as a plain Array
+const collectChunks = (
+  stream: ReadableStream<Uint8Array>,
+  chunkSize: number
+): Effect.Effect<Uint8Array[], unknown> =>
+  Stream.runCollect(chunkStream(stream, chunkSize)).pipe(
+    Effect.map((chunk) => Array.from(chunk))
+  )
+
+describe("chunkStream", () => {
+  it.effect("splits into chunkSize chunks, last chunk smaller", () =>
+    Effect.gen(function* () {
+      // 10 bytes, chunkSize 3 → chunks: [3, 3, 3, 1]
+      const data = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+      const chunks = yield* collectChunks(fromBytes(data), 3)
+
+      expect(chunks).toHaveLength(4)
+      expect(chunks[0]).toEqual(new Uint8Array([0, 1, 2]))
+      expect(chunks[1]).toEqual(new Uint8Array([3, 4, 5]))
+      expect(chunks[2]).toEqual(new Uint8Array([6, 7, 8]))
+      expect(chunks[3]).toEqual(new Uint8Array([9]))
+    })
+  )
+
+  it.effect("preserves all bytes across chunks", () =>
+    Effect.gen(function* () {
+      const data = new Uint8Array(100).map((_, i) => i % 256)
+      const chunks = yield* collectChunks(fromBytes(data), 7)
+
+      const totalLength = chunks.reduce((sum, c) => sum + c.length, 0)
+      expect(totalLength).toBe(100)
+
+      // Verify byte values are intact
+      const reconstructed = new Uint8Array(100)
+      let offset = 0
+      for (const chunk of chunks) {
+        reconstructed.set(chunk, offset)
+        offset += chunk.length
+      }
+      expect(reconstructed).toEqual(data)
+    })
+  )
+
+  it.effect("emits single chunk when stream is smaller than chunkSize", () =>
+    Effect.gen(function* () {
+      const data = new Uint8Array([10, 20, 30])
+      const chunks = yield* collectChunks(fromBytes(data), 100)
+
+      expect(chunks).toHaveLength(1)
+      expect(chunks[0]).toEqual(new Uint8Array([10, 20, 30]))
+    })
+  )
+
+  it.effect("emits no trailing empty chunk on exact multiple", () =>
+    Effect.gen(function* () {
+      const data = new Uint8Array(9).fill(5) // 9 = 3 * 3
+      const chunks = yield* collectChunks(fromBytes(data), 3)
+
+      expect(chunks).toHaveLength(3)
+      for (const chunk of chunks) {
+        expect(chunk).toHaveLength(3)
+        expect(chunk).toEqual(new Uint8Array([5, 5, 5]))
+      }
+    })
+  )
+})

package/src/multipart/chunk-stream.ts

@@ -0,0 +1,37 @@
+import { Stream } from "effect"
+
+export const chunkStream = (
+  stream: ReadableStream<Uint8Array>,
+  chunkSize: number
+): Stream.Stream<Uint8Array, unknown> => {
+  let buffer = new Uint8Array(0)
+
+  const transform = new TransformStream<Uint8Array, Uint8Array>({
+    transform(chunk, controller) {
+      // Concatenate incoming chunk into the buffer
+      const merged = new Uint8Array(buffer.length + chunk.length)
+      merged.set(buffer)
+      merged.set(chunk, buffer.length)
+      buffer = merged
+
+      // Emit every full-size chunk
+      while (buffer.length >= chunkSize) {
+        controller.enqueue(buffer.slice(0, chunkSize))
+        buffer = buffer.slice(chunkSize)
+      }
+    },
+    flush(controller) {
+      // Emit remaining bytes (last partial chunk)
+      if (buffer.length > 0) {
+        controller.enqueue(buffer)
+      }
+    },
+  })
+
+  const chunked = stream.pipeThrough(transform)
+
+  return Stream.fromReadableStream(
+    () => chunked,
+    (e) => e
+  )
+}