@tranquilload/adapters 0.1.0

package/dist/s3-multipart-upload.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3-multipart-upload.mjs","names":[],"sources":["../src/protocols/s3-multipart-upload.ts"],"sourcesContent":["import { CompleteUploadError, PartUploadError, PresignedUrlError } from \"@tranquilload/core/errors\"\nimport type { CompletedPart } from \"@tranquilload/core/multipart\"\n\nexport const S3_MIN_PART_SIZE = 5 * 1024 * 1024 // 5 MiB\n\nexport interface S3Client {\n  createMultipartUpload(params: {\n    Bucket: string\n    Key: string\n  }): Promise<{ UploadId?: string }>\n\n  completeMultipartUpload(params: {\n    Bucket: string\n    Key: string\n    UploadId: string\n    MultipartUpload: { Parts: ReadonlyArray<{ PartNumber: number; ETag: string }> }\n  }): Promise<unknown>\n}\n\nexport interface S3MultipartUploadOptions {\n  bucket: string\n  key: string\n  chunkSize?: number\n  getPresignedUrl: (partNumber: number, uploadId: string) => string | Promise<string>\n  s3Client: S3Client\n}\n\nexport function s3MultipartUpload(options: S3MultipartUploadOptions): {\n  chunkSize: number\n  initiate: () => Promise<{ uploadId: string }>\n  uploadPart: (partNumber: number, chunk: Uint8Array) => Promise<string>\n  completeUpload: (uploadId: string, parts: ReadonlyArray<CompletedPart>) => Promise<void>\n} {\n  const { bucket, key, chunkSize = S3_MIN_PART_SIZE, getPresignedUrl, s3Client } = options\n\n  if (chunkSize < S3_MIN_PART_SIZE) {\n    throw new Error(\n      `S3 requires chunkSize >= ${S3_MIN_PART_SIZE} bytes (5 MiB), received ${chunkSize} bytes`\n    )\n  }\n\n  let storedUploadId = \"\"\n\n  const initiate = async (): Promise<{ uploadId: string }> => {\n    const result = await s3Client.createMultipartUpload({ Bucket: bucket, Key: key })\n    if (!result.UploadId) throw new Error(\"S3 CreateMultipartUpload did not return an UploadId\")\n    storedUploadId = result.UploadId\n    return { uploadId: storedUploadId }\n  }\n\n  const uploadPart = async (partNumber: number, chunk: Uint8Array): Promise<string> => {\n    let url: string\n    try {\n      url = await Promise.resolve(getPresignedUrl(partNumber, storedUploadId))\n    } catch (cause) {\n      throw new PresignedUrlError(cause)\n    }\n    const response = await fetch(url, { method: \"PUT\", body: chunk as unknown as BodyInit })\n    if (!response.ok) {\n      throw new PartUploadError(\n        partNumber,\n        0,\n        new Error(`S3 PUT failed: HTTP ${response.status} ${response.statusText}`)\n      )\n    }\n    const rawEtag = response.headers.get(\"ETag\")\n    if (!rawEtag) {\n      throw new PartUploadError(partNumber, 0, new Error(\"S3 response missing ETag header\"))\n    }\n    return rawEtag.replace(/\"/g, \"\")\n  }\n\n  const completeUpload = async (\n    uploadId: string,\n    parts: ReadonlyArray<CompletedPart>\n  ): Promise<void> => {\n    try {\n      await s3Client.completeMultipartUpload({\n        Bucket: bucket,\n        Key: key,\n        UploadId: uploadId,\n        MultipartUpload: {\n          Parts: parts.map((p) => ({ PartNumber: p.partNumber, ETag: p.etag })),\n        },\n      })\n    } catch (cause) {\n      throw new CompleteUploadError(cause)\n    }\n  }\n\n  return { chunkSize, initiate, uploadPart, completeUpload }\n}\n"],"mappings":";;AAGA,MAAa,mBAAmB,IAAI,OAAO;AAwB3C,SAAgB,kBAAkB,SAKhC;CACA,MAAM,EAAE,QAAQ,KAAK,YAAY,kBAAkB,iBAAiB,aAAa;AAEjF,KAAI,YAAA,QACF,OAAM,IAAI,MACR,4BAA4B,iBAAiB,2BAA2B,UAAU,QACnF;CAGH,IAAI,iBAAiB;CAErB,MAAM,WAAW,YAA2C;EAC1D,MAAM,SAAS,MAAM,SAAS,sBAAsB;GAAE,QAAQ;GAAQ,KAAK;GAAK,CAAC;AACjF,MAAI,CAAC,OAAO,SAAU,OAAM,IAAI,MAAM,sDAAsD;AAC5F,mBAAiB,OAAO;AACxB,SAAO,EAAE,UAAU,gBAAgB;;CAGrC,MAAM,aAAa,OAAO,YAAoB,UAAuC;EACnF,IAAI;AACJ,MAAI;AACF,SAAM,MAAM,QAAQ,QAAQ,gBAAgB,YAAY,eAAe,CAAC;WACjE,OAAO;AACd,SAAM,IAAI,kBAAkB,MAAM;;EAEpC,MAAM,WAAW,MAAM,MAAM,KAAK;GAAE,QAAQ;GAAO,MAAM;GAA8B,CAAC;AACxF,MAAI,CAAC,SAAS,GACZ,OAAM,IAAI,gBACR,YACA,mBACA,IAAI,MAAM,uBAAuB,SAAS,OAAO,GAAG,SAAS,aAAa,CAC3E;EAEH,MAAM,UAAU,SAAS,QAAQ,IAAI,OAAO;AAC5C,MAAI,CAAC,QACH,OAAM,IAAI,gBAAgB,YAAY,mBAAG,IAAI,MAAM,kCAAkC,CAAC;AAExF,SAAO,QAAQ,QAAQ,MAAM,GAAG;;CAGlC,MAAM,iBAAiB,OACrB,UACA,UACkB;AAClB,MAAI;AACF,SAAM,SAAS,wBAAwB;IACrC,QAAQ;IACR,KAAK;IACL,UAAU;IACV,iBAAiB,EACf,OAAO,MAAM,KAAK,OAAO;KAAE,YAAY,EAAE;KAAY,MAAM,EAAE;KAAM,EAAE,EACtE;IACF,CAAC;WACK,OAAO;AACd,SAAM,IAAI,oBAAoB,MAAM;;;AAIxC,QAAO;EAAE;EAAW;EAAU;EAAY;EAAgB"}

package/dist/simple-http-upload.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _tranquilload_core_errors = require("@tranquilload/core/errors");
+//#region src/protocols/simple-http-upload.ts
+function simpleHttpUpload(options) {
+	const { url, method = "PUT", headers, signal } = options;
+	const upload = async (stream) => {
+		let response;
+		try {
+			response = await fetch(url, {
+				method,
+				headers,
+				body: stream,
+				signal
+			});
+		} catch (cause) {
+			if (cause instanceof Error && cause.name === "AbortError") throw new _tranquilload_core_errors.AbortError();
+			throw new _tranquilload_core_errors.CompleteUploadError(cause);
+		}
+		if (!response.ok) throw new _tranquilload_core_errors.CompleteUploadError(/* @__PURE__ */ new Error(`HTTP ${response.status} ${response.statusText}`));
+	};
+	return { upload };
+}
+//#endregion
+exports.simpleHttpUpload = simpleHttpUpload;
+
+//# sourceMappingURL=simple-http-upload.cjs.map

package/dist/simple-http-upload.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-http-upload.cjs","names":["AbortError","CompleteUploadError"],"sources":["../src/protocols/simple-http-upload.ts"],"sourcesContent":["import { AbortError, CompleteUploadError } from \"@tranquilload/core/errors\"\n\nexport interface SimpleHttpUploadOptions {\n  url: string\n  method?: \"PUT\" | \"POST\"\n  headers?: Record<string, string>\n  signal?: AbortSignal\n}\n\nexport function simpleHttpUpload(options: SimpleHttpUploadOptions): {\n  upload: (stream: ReadableStream<Uint8Array>) => Promise<void>\n} {\n  const { url, method = \"PUT\", headers, signal } = options\n\n  const upload = async (stream: ReadableStream<Uint8Array>): Promise<void> => {\n    let response: Response\n    try {\n      response = await fetch(url, {\n        method,\n        headers,\n        body: stream as unknown as BodyInit,\n        signal,\n      })\n    } catch (cause) {\n      if (cause instanceof Error && cause.name === \"AbortError\") {\n        throw new AbortError()\n      }\n      throw new CompleteUploadError(cause)\n    }\n    if (!response.ok) {\n      throw new CompleteUploadError(\n        new Error(`HTTP ${response.status} ${response.statusText}`)\n      )\n    }\n  }\n\n  return { upload }\n}\n"],"mappings":";;;AASA,SAAgB,iBAAiB,SAE/B;CACA,MAAM,EAAE,KAAK,SAAS,OAAO,SAAS,WAAW;CAEjD,MAAM,SAAS,OAAO,WAAsD;EAC1E,IAAI;AACJ,MAAI;AACF,cAAW,MAAM,MAAM,KAAK;IAC1B;IACA;IACA,MAAM;IACN;IACD,CAAC;WACK,OAAO;AACd,OAAI,iBAAiB,SAAS,MAAM,SAAS,aAC3C,OAAM,IAAIA,0BAAAA,YAAY;AAExB,SAAM,IAAIC,0BAAAA,oBAAoB,MAAM;;AAEtC,MAAI,CAAC,SAAS,GACZ,OAAM,IAAIA,0BAAAA,oCACR,IAAI,MAAM,QAAQ,SAAS,OAAO,GAAG,SAAS,aAAa,CAC5D;;AAIL,QAAO,EAAE,QAAQ"}

package/dist/simple-http-upload.d.cts

@@ -0,0 +1,13 @@
+//#region src/protocols/simple-http-upload.d.ts
+interface SimpleHttpUploadOptions {
+  url: string;
+  method?: "PUT" | "POST";
+  headers?: Record<string, string>;
+  signal?: AbortSignal;
+}
+declare function simpleHttpUpload(options: SimpleHttpUploadOptions): {
+  upload: (stream: ReadableStream<Uint8Array>) => Promise<void>;
+};
+//#endregion
+export { SimpleHttpUploadOptions, simpleHttpUpload };
+//# sourceMappingURL=simple-http-upload.d.cts.map

package/dist/simple-http-upload.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-http-upload.d.cts","names":[],"sources":["../src/protocols/simple-http-upload.ts"],"mappings":";UAEiB,uBAAA;EACf,GAAA;EACA,MAAA;EACA,OAAA,GAAU,MAAA;EACV,MAAA,GAAS,WAAA;AAAA;AAAA,iBAGK,gBAAA,CAAiB,OAAA,EAAS,uBAAA;EACxC,MAAA,GAAS,MAAA,EAAQ,cAAA,CAAe,UAAA,MAAgB,OAAA;AAAA"}

package/dist/simple-http-upload.d.mts

@@ -0,0 +1,13 @@
+//#region src/protocols/simple-http-upload.d.ts
+interface SimpleHttpUploadOptions {
+  url: string;
+  method?: "PUT" | "POST";
+  headers?: Record<string, string>;
+  signal?: AbortSignal;
+}
+declare function simpleHttpUpload(options: SimpleHttpUploadOptions): {
+  upload: (stream: ReadableStream<Uint8Array>) => Promise<void>;
+};
+//#endregion
+export { SimpleHttpUploadOptions, simpleHttpUpload };
+//# sourceMappingURL=simple-http-upload.d.mts.map

package/dist/simple-http-upload.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-http-upload.d.mts","names":[],"sources":["../src/protocols/simple-http-upload.ts"],"mappings":";UAEiB,uBAAA;EACf,GAAA;EACA,MAAA;EACA,OAAA,GAAU,MAAA;EACV,MAAA,GAAS,WAAA;AAAA;AAAA,iBAGK,gBAAA,CAAiB,OAAA,EAAS,uBAAA;EACxC,MAAA,GAAS,MAAA,EAAQ,cAAA,CAAe,UAAA,MAAgB,OAAA;AAAA"}

package/dist/simple-http-upload.mjs

@@ -0,0 +1,25 @@
+import { AbortError, CompleteUploadError } from "@tranquilload/core/errors";
+//#region src/protocols/simple-http-upload.ts
+function simpleHttpUpload(options) {
+	const { url, method = "PUT", headers, signal } = options;
+	const upload = async (stream) => {
+		let response;
+		try {
+			response = await fetch(url, {
+				method,
+				headers,
+				body: stream,
+				signal
+			});
+		} catch (cause) {
+			if (cause instanceof Error && cause.name === "AbortError") throw new AbortError();
+			throw new CompleteUploadError(cause);
+		}
+		if (!response.ok) throw new CompleteUploadError(/* @__PURE__ */ new Error(`HTTP ${response.status} ${response.statusText}`));
+	};
+	return { upload };
+}
+//#endregion
+export { simpleHttpUpload };
+
+//# sourceMappingURL=simple-http-upload.mjs.map

package/dist/simple-http-upload.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-http-upload.mjs","names":[],"sources":["../src/protocols/simple-http-upload.ts"],"sourcesContent":["import { AbortError, CompleteUploadError } from \"@tranquilload/core/errors\"\n\nexport interface SimpleHttpUploadOptions {\n  url: string\n  method?: \"PUT\" | \"POST\"\n  headers?: Record<string, string>\n  signal?: AbortSignal\n}\n\nexport function simpleHttpUpload(options: SimpleHttpUploadOptions): {\n  upload: (stream: ReadableStream<Uint8Array>) => Promise<void>\n} {\n  const { url, method = \"PUT\", headers, signal } = options\n\n  const upload = async (stream: ReadableStream<Uint8Array>): Promise<void> => {\n    let response: Response\n    try {\n      response = await fetch(url, {\n        method,\n        headers,\n        body: stream as unknown as BodyInit,\n        signal,\n      })\n    } catch (cause) {\n      if (cause instanceof Error && cause.name === \"AbortError\") {\n        throw new AbortError()\n      }\n      throw new CompleteUploadError(cause)\n    }\n    if (!response.ok) {\n      throw new CompleteUploadError(\n        new Error(`HTTP ${response.status} ${response.statusText}`)\n      )\n    }\n  }\n\n  return { upload }\n}\n"],"mappings":";;AASA,SAAgB,iBAAiB,SAE/B;CACA,MAAM,EAAE,KAAK,SAAS,OAAO,SAAS,WAAW;CAEjD,MAAM,SAAS,OAAO,WAAsD;EAC1E,IAAI;AACJ,MAAI;AACF,cAAW,MAAM,MAAM,KAAK;IAC1B;IACA;IACA,MAAM;IACN;IACD,CAAC;WACK,OAAO;AACd,OAAI,iBAAiB,SAAS,MAAM,SAAS,aAC3C,OAAM,IAAI,YAAY;AAExB,SAAM,IAAI,oBAAoB,MAAM;;AAEtC,MAAI,CAAC,SAAS,GACZ,OAAM,IAAI,oCACR,IAAI,MAAM,QAAQ,SAAS,OAAO,GAAG,SAAS,aAAa,CAC5D;;AAIL,QAAO,EAAE,QAAQ"}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@tranquilload/adapters",
+  "version": "0.1.0",
+  "description": "Adapters for Tranquilload (S3, File, Node, HTTP)",
+  "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": {
+    "./fromFile": {
+      "types": "./dist/from-file.d.mts",
+      "import": "./dist/from-file.mjs",
+      "require": "./dist/from-file.cjs"
+    },
+    "./fromNodeReadable": {
+      "types": "./dist/from-node-readable.d.mts",
+      "import": "./dist/from-node-readable.mjs",
+      "require": "./dist/from-node-readable.cjs"
+    },
+    "./s3MultipartUpload": {
+      "types": "./dist/s3-multipart-upload.d.mts",
+      "import": "./dist/s3-multipart-upload.mjs",
+      "require": "./dist/s3-multipart-upload.cjs"
+    },
+    "./simpleHttpUpload": {
+      "types": "./dist/simple-http-upload.d.mts",
+      "import": "./dist/simple-http-upload.mjs",
+      "require": "./dist/simple-http-upload.cjs"
+    },
+    "./networkMultiplier": {
+      "types": "./dist/network-multiplier.d.mts",
+      "import": "./dist/network-multiplier.mjs",
+      "require": "./dist/network-multiplier.cjs"
+    },
+    "./optimalPartSize": {
+      "types": "./dist/optimal-part-size.d.mts",
+      "import": "./dist/optimal-part-size.mjs",
+      "require": "./dist/optimal-part-size.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "effect": ">=3.19.19",
+    "@tranquilload/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@effect/vitest": "^0.27.0",
+    "effect": "3.19.19",
+    "tsdown": "^0.21.0",
+    "typescript": "^5.5.0",
+    "vitest": "^3.2.0",
+    "@tranquilload/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/protocols/s3-multipart-upload.test.ts

@@ -0,0 +1,127 @@
+import { afterEach, describe, expect, it, vi } from "vitest"
+import { CompleteUploadError, PresignedUrlError } from "@tranquilload/core/errors"
+import { s3MultipartUpload, S3_MIN_PART_SIZE } from "./s3-multipart-upload.js"
+
+const makeMockS3Client = (overrides = {}) => ({
+  createMultipartUpload: vi.fn().mockResolvedValue({ UploadId: "upload-123" }),
+  completeMultipartUpload: vi.fn().mockResolvedValue({}),
+  ...overrides,
+})
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+describe("s3MultipartUpload", () => {
+  it("throws synchronously when chunkSize < 5 MiB", () => {
+    expect(() =>
+      s3MultipartUpload({
+        bucket: "b",
+        key: "k",
+        chunkSize: 1024,
+        getPresignedUrl: vi.fn(),
+        s3Client: makeMockS3Client(),
+      })
+    ).toThrow("S3 requires chunkSize >= 5242880 bytes (5 MiB)")
+  })
+
+  it("initiate calls createMultipartUpload with bucket and key", async () => {
+    const s3Client = makeMockS3Client()
+    const adapter = s3MultipartUpload({
+      bucket: "my-bucket",
+      key: "my-key",
+      getPresignedUrl: vi.fn(),
+      s3Client,
+    })
+    const result = await adapter.initiate()
+    expect(s3Client.createMultipartUpload).toHaveBeenCalledWith({
+      Bucket: "my-bucket",
+      Key: "my-key",
+    })
+    expect(result).toEqual({ uploadId: "upload-123" })
+  })
+
+  it("uploadPart calls getPresignedUrl with partNumber and uploadId then PUTs chunk", async () => {
+    const getPresignedUrl = vi.fn().mockResolvedValue("https://s3.example.com/presigned")
+    const s3Client = makeMockS3Client()
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      headers: new Headers({ ETag: '"etag-abc"' }),
+    })
+    vi.stubGlobal("fetch", fetchMock)
+
+    const adapter = s3MultipartUpload({ bucket: "b", key: "k", getPresignedUrl, s3Client })
+    await adapter.initiate()
+    const etag = await adapter.uploadPart(1, new Uint8Array([1, 2, 3]))
+
+    expect(getPresignedUrl).toHaveBeenCalledWith(1, "upload-123")
+    expect(fetchMock).toHaveBeenCalledWith("https://s3.example.com/presigned", {
+      method: "PUT",
+      body: expect.any(Uint8Array),
+    })
+    expect(etag).toBe("etag-abc")
+  })
+
+  it("uploadPart returns ETag stripped of quotes", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        headers: new Headers({ ETag: '"quoted-etag"' }),
+      })
+    )
+    const adapter = s3MultipartUpload({
+      bucket: "b",
+      key: "k",
+      getPresignedUrl: vi.fn().mockResolvedValue("https://s3.example.com/presigned"),
+      s3Client: makeMockS3Client(),
+    })
+    await adapter.initiate()
+    const etag = await adapter.uploadPart(1, new Uint8Array())
+    expect(etag).toBe("quoted-etag")
+  })
+
+  it("uploadPart rejects with PresignedUrlError when getPresignedUrl rejects", async () => {
+    const getPresignedUrl = vi.fn().mockRejectedValue(new Error("no URL"))
+    const adapter = s3MultipartUpload({
+      bucket: "b",
+      key: "k",
+      getPresignedUrl,
+      s3Client: makeMockS3Client(),
+    })
+    await adapter.initiate()
+    await expect(adapter.uploadPart(1, new Uint8Array())).rejects.toBeInstanceOf(PresignedUrlError)
+  })
+
+  it("completeUpload calls s3Client.completeMultipartUpload with correct structure", async () => {
+    const s3Client = makeMockS3Client()
+    const adapter = s3MultipartUpload({
+      bucket: "b",
+      key: "k",
+      getPresignedUrl: vi.fn(),
+      s3Client,
+    })
+    await adapter.completeUpload("upload-123", [{ partNumber: 1, etag: "etag-1" }])
+    expect(s3Client.completeMultipartUpload).toHaveBeenCalledWith({
+      Bucket: "b",
+      Key: "k",
+      UploadId: "upload-123",
+      MultipartUpload: { Parts: [{ PartNumber: 1, ETag: "etag-1" }] },
+    })
+  })
+
+  it("completeUpload rejects with CompleteUploadError when s3Client fails", async () => {
+    const s3Client = makeMockS3Client({
+      completeMultipartUpload: vi.fn().mockRejectedValue(new Error("S3 error")),
+    })
+    const adapter = s3MultipartUpload({
+      bucket: "b",
+      key: "k",
+      getPresignedUrl: vi.fn(),
+      s3Client,
+    })
+    await expect(
+      adapter.completeUpload("upload-123", [{ partNumber: 1, etag: "etag-1" }])
+    ).rejects.toBeInstanceOf(CompleteUploadError)
+  })
+})

package/src/protocols/s3-multipart-upload.ts

@@ -0,0 +1,92 @@
+import { CompleteUploadError, PartUploadError, PresignedUrlError } from "@tranquilload/core/errors"
+import type { CompletedPart } from "@tranquilload/core/multipart"
+
+export const S3_MIN_PART_SIZE = 5 * 1024 * 1024 // 5 MiB
+
+export interface S3Client {
+  createMultipartUpload(params: {
+    Bucket: string
+    Key: string
+  }): Promise<{ UploadId?: string }>
+
+  completeMultipartUpload(params: {
+    Bucket: string
+    Key: string
+    UploadId: string
+    MultipartUpload: { Parts: ReadonlyArray<{ PartNumber: number; ETag: string }> }
+  }): Promise<unknown>
+}
+
+export interface S3MultipartUploadOptions {
+  bucket: string
+  key: string
+  chunkSize?: number
+  getPresignedUrl: (partNumber: number, uploadId: string) => string | Promise<string>
+  s3Client: S3Client
+}
+
+export function s3MultipartUpload(options: S3MultipartUploadOptions): {
+  chunkSize: number
+  initiate: () => Promise<{ uploadId: string }>
+  uploadPart: (partNumber: number, chunk: Uint8Array) => Promise<string>
+  completeUpload: (uploadId: string, parts: ReadonlyArray<CompletedPart>) => Promise<void>
+} {
+  const { bucket, key, chunkSize = S3_MIN_PART_SIZE, getPresignedUrl, s3Client } = options
+
+  if (chunkSize < S3_MIN_PART_SIZE) {
+    throw new Error(
+      `S3 requires chunkSize >= ${S3_MIN_PART_SIZE} bytes (5 MiB), received ${chunkSize} bytes`
+    )
+  }
+
+  let storedUploadId = ""
+
+  const initiate = async (): Promise<{ uploadId: string }> => {
+    const result = await s3Client.createMultipartUpload({ Bucket: bucket, Key: key })
+    if (!result.UploadId) throw new Error("S3 CreateMultipartUpload did not return an UploadId")
+    storedUploadId = result.UploadId
+    return { uploadId: storedUploadId }
+  }
+
+  const uploadPart = async (partNumber: number, chunk: Uint8Array): Promise<string> => {
+    let url: string
+    try {
+      url = await Promise.resolve(getPresignedUrl(partNumber, storedUploadId))
+    } catch (cause) {
+      throw new PresignedUrlError(cause)
+    }
+    const response = await fetch(url, { method: "PUT", body: chunk as unknown as BodyInit })
+    if (!response.ok) {
+      throw new PartUploadError(
+        partNumber,
+        0,
+        new Error(`S3 PUT failed: HTTP ${response.status} ${response.statusText}`)
+      )
+    }
+    const rawEtag = response.headers.get("ETag")
+    if (!rawEtag) {
+      throw new PartUploadError(partNumber, 0, new Error("S3 response missing ETag header"))
+    }
+    return rawEtag.replace(/"/g, "")
+  }
+
+  const completeUpload = async (
+    uploadId: string,
+    parts: ReadonlyArray<CompletedPart>
+  ): Promise<void> => {
+    try {
+      await s3Client.completeMultipartUpload({
+        Bucket: bucket,
+        Key: key,
+        UploadId: uploadId,
+        MultipartUpload: {
+          Parts: parts.map((p) => ({ PartNumber: p.partNumber, ETag: p.etag })),
+        },
+      })
+    } catch (cause) {
+      throw new CompleteUploadError(cause)
+    }
+  }
+
+  return { chunkSize, initiate, uploadPart, completeUpload }
+}

package/src/protocols/simple-http-upload.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi, afterEach } from "vitest"
+import { AbortError, CompleteUploadError } from "@tranquilload/core/errors"
+import { simpleHttpUpload } from "./simple-http-upload.js"
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+describe("simpleHttpUpload", () => {
+  it("upload calls fetch with url, method, headers, and stream as body", async () => {
+    const stream = new ReadableStream<Uint8Array>()
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal("fetch", fetchMock)
+
+    const adapter = simpleHttpUpload({
+      url: "https://example.com/upload",
+      method: "PUT",
+      headers: { "x-foo": "bar" },
+    })
+    await adapter.upload(stream)
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://example.com/upload",
+      expect.objectContaining({
+        method: "PUT",
+        headers: { "x-foo": "bar" },
+        body: stream,
+      })
+    )
+  })
+
+  it("method defaults to PUT when omitted", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal("fetch", fetchMock)
+
+    const adapter = simpleHttpUpload({ url: "https://example.com/upload" })
+    await adapter.upload(new ReadableStream())
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://example.com/upload",
+      expect.objectContaining({ method: "PUT" })
+    )
+  })
+
+  it("rejects with CompleteUploadError when response is not ok", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({ ok: false, status: 403, statusText: "Forbidden" })
+    )
+
+    const adapter = simpleHttpUpload({ url: "https://example.com/upload" })
+    const error = await adapter.upload(new ReadableStream()).catch((e) => e)
+    expect(error).toBeInstanceOf(CompleteUploadError)
+    expect(error.cause).toBeInstanceOf(Error)
+    expect((error.cause as Error).message).toBe("HTTP 403 Forbidden")
+  })
+
+  it("rejects with AbortError when fetch is aborted", async () => {
+    const abortError = new DOMException("The operation was aborted.", "AbortError")
+    vi.stubGlobal("fetch", vi.fn().mockRejectedValue(abortError))
+
+    const adapter = simpleHttpUpload({ url: "https://example.com/upload" })
+    await expect(adapter.upload(new ReadableStream())).rejects.toBeInstanceOf(AbortError)
+  })
+
+  it("rejects with CompleteUploadError on network failure", async () => {
+    const networkError = new Error("Failed to fetch")
+    vi.stubGlobal("fetch", vi.fn().mockRejectedValue(networkError))
+
+    const adapter = simpleHttpUpload({ url: "https://example.com/upload" })
+    const error = await adapter.upload(new ReadableStream()).catch((e) => e)
+    expect(error).toBeInstanceOf(CompleteUploadError)
+    expect(error.cause).toBe(networkError)
+  })
+})

package/src/protocols/simple-http-upload.ts

@@ -0,0 +1,38 @@
+import { AbortError, CompleteUploadError } from "@tranquilload/core/errors"
+
+export interface SimpleHttpUploadOptions {
+  url: string
+  method?: "PUT" | "POST"
+  headers?: Record<string, string>
+  signal?: AbortSignal
+}
+
+export function simpleHttpUpload(options: SimpleHttpUploadOptions): {
+  upload: (stream: ReadableStream<Uint8Array>) => Promise<void>
+} {
+  const { url, method = "PUT", headers, signal } = options
+
+  const upload = async (stream: ReadableStream<Uint8Array>): Promise<void> => {
+    let response: Response
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: stream as unknown as BodyInit,
+        signal,
+      })
+    } catch (cause) {
+      if (cause instanceof Error && cause.name === "AbortError") {
+        throw new AbortError()
+      }
+      throw new CompleteUploadError(cause)
+    }
+    if (!response.ok) {
+      throw new CompleteUploadError(
+        new Error(`HTTP ${response.status} ${response.statusText}`)
+      )
+    }
+  }
+
+  return { upload }
+}

package/src/resilience/network-multiplier.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest'
+import { networkMultiplier } from './network-multiplier.js'
+
+describe('networkMultiplier', () => {
+  it('returns 1.0 when no samples have been recorded', () => {
+    const m = networkMultiplier()
+    expect(m.factor()).toBe(1.0)
+  })
+
+  it('returns 1.0 when throughput >= target', () => {
+    const target = 10_000 // bytes/ms
+    const m = networkMultiplier({ targetBytesPerMs: target })
+    // Record sample at exactly target speed
+    m.record(10_000, 1)
+    expect(m.factor()).toBe(1.0)
+    // Record sample faster than target
+    m.record(20_000, 1)
+    expect(m.factor()).toBe(1.0)
+  })
+
+  it('returns 0.1 when throughput is 10% of target', () => {
+    const target = 10_000
+    const m = networkMultiplier({ targetBytesPerMs: target })
+    m.record(1_000, 1) // 1000 bytes/ms = 10% of target
+    expect(m.factor()).toBeCloseTo(0.1, 5)
+  })
+
+  it('clamps below 0.1 when throughput is very low', () => {
+    const target = 10_000
+    const m = networkMultiplier({ targetBytesPerMs: target })
+    m.record(100, 1) // 1% of target
+    expect(m.factor()).toBe(0.1)
+  })
+
+  it('rolling window evicts oldest sample', () => {
+    const target = 10_000
+    const m = networkMultiplier({ windowSize: 3, targetBytesPerMs: target })
+    // Fill window with slow samples (1000 bytes/ms = 0.1 factor)
+    m.record(1_000, 1)
+    m.record(1_000, 1)
+    m.record(1_000, 1)
+    expect(m.factor()).toBeCloseTo(0.1, 5)
+    // Now push 3 fast samples to evict all slow ones
+    m.record(10_000, 1)
+    m.record(10_000, 1)
+    m.record(10_000, 1)
+    expect(m.factor()).toBe(1.0)
+  })
+
+  it('skips sample when durationMs <= 0', () => {
+    const m = networkMultiplier()
+    m.record(1_000, 0)
+    m.record(1_000, -5)
+    // No valid samples → factor stays 1.0
+    expect(m.factor()).toBe(1.0)
+  })
+})

package/src/resilience/network-multiplier.ts

@@ -0,0 +1,52 @@
+/**
+ * Network throughput multiplier adapter.
+ *
+ * Measures upload throughput via a sliding window and returns a factor
+ * in [0.1, 1.0] to scale chunk size dynamically.
+ *
+ * @module
+ */
+
+export interface NetworkMultiplierInstance {
+  /** Record a completed upload measurement. Skips if durationMs <= 0. */
+  record(bytes: number, durationMs: number): void
+  /** Returns current throughput factor [0.1, 1.0]. Returns 1.0 with no samples. */
+  factor(): number
+}
+
+export interface NetworkMultiplierOptions {
+  /** Number of recent samples to average. Default: 5 */
+  windowSize?: number
+  /** Throughput (bytes/ms) that maps to factor=1.0. Default: ~10 MB/s */
+  targetBytesPerMs?: number
+}
+
+const DEFAULT_WINDOW_SIZE = 5
+const DEFAULT_TARGET_BYTES_PER_MS = (10 * 1024 * 1024) / 1000
+
+export function networkMultiplier(
+  options?: NetworkMultiplierOptions
+): NetworkMultiplierInstance {
+  const windowSize = options?.windowSize ?? DEFAULT_WINDOW_SIZE
+  const targetBytesPerMs =
+    options?.targetBytesPerMs ?? DEFAULT_TARGET_BYTES_PER_MS
+  const samples: number[] = []
+
+  return {
+    record(bytes: number, durationMs: number): void {
+      if (durationMs <= 0) return
+      const throughput = bytes / durationMs
+      if (samples.length >= windowSize) {
+        samples.shift()
+      }
+      samples.push(throughput)
+    },
+
+    factor(): number {
+      if (samples.length === 0) return 1.0
+      const avg =
+        samples.reduce((sum, s) => sum + s, 0) / samples.length
+      return Math.max(0.1, Math.min(1.0, avg / targetBytesPerMs))
+    },
+  }
+}