@tranquilload/adapters 0.1.0 → 0.1.1

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @tranquilload/adapters@0.1.0 build /home/runner/work/Tranquilload/Tranquilload/packages/tranquilload-adapters
+> @tranquilload/adapters@0.1.1 build /home/runner/work/Tranquilload/Tranquilload/packages/tranquilload-adapters
 > tsdown
 
 ℹ tsdown v0.21.0 powered by rolldown v1.0.0-rc.7
@@ -8,55 +8,61 @@
 ℹ tsconfig: tsconfig.json
 ℹ Build start
 ℹ [CJS] dist/s3-multipart-upload.cjs      2.15 kB │ gzip: 0.90 kB
-ℹ [CJS] dist/simple-http-upload.cjs       0.93 kB │ gzip: 0.49 kB
+ℹ [CJS] dist/simple-http-upload.cjs       1.54 kB │ gzip: 0.69 kB
 ℹ [CJS] dist/network-multiplier.cjs       0.92 kB │ gzip: 0.49 kB
 ℹ [CJS] dist/optimal-part-size.cjs        0.59 kB │ gzip: 0.32 kB
 ℹ [CJS] dist/from-node-readable.cjs       0.35 kB │ gzip: 0.23 kB
 ℹ [CJS] dist/from-file.cjs                0.28 kB │ gzip: 0.22 kB
 ℹ [CJS] dist/s3-multipart-upload.cjs.map  4.38 kB │ gzip: 1.64 kB
+ℹ [CJS] dist/simple-http-upload.cjs.map   4.18 kB │ gzip: 1.80 kB
 ℹ [CJS] dist/network-multiplier.cjs.map   2.21 kB │ gzip: 1.00 kB
-ℹ [CJS] dist/simple-http-upload.cjs.map   1.65 kB │ gzip: 0.80 kB
 ℹ [CJS] dist/optimal-part-size.cjs.map    1.45 kB │ gzip: 0.71 kB
 ℹ [CJS] dist/from-node-readable.cjs.map   0.41 kB │ gzip: 0.26 kB
 ℹ [CJS] dist/from-file.cjs.map            0.38 kB │ gzip: 0.27 kB
-ℹ [CJS] 12 files, total: 15.69 kB
+ℹ [CJS] 12 files, total: 18.83 kB
+[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugin `tsdown:report`. See https://rolldown.rs/options/checks#plugintimings for more details.
+
 ℹ [CJS] dist/s3-multipart-upload.d.cts.map  0.69 kB │ gzip: 0.33 kB
+ℹ [CJS] dist/simple-http-upload.d.cts.map   0.34 kB │ gzip: 0.21 kB
 ℹ [CJS] dist/network-multiplier.d.cts.map   0.31 kB │ gzip: 0.22 kB
-ℹ [CJS] dist/simple-http-upload.d.cts.map   0.30 kB │ gzip: 0.20 kB
 ℹ [CJS] dist/optimal-part-size.d.cts.map    0.25 kB │ gzip: 0.19 kB
 ℹ [CJS] dist/from-file.d.cts.map            0.18 kB │ gzip: 0.15 kB
 ℹ [CJS] dist/from-node-readable.d.cts.map   0.18 kB │ gzip: 0.15 kB
+ℹ [CJS] dist/simple-http-upload.d.cts       1.41 kB │ gzip: 0.74 kB
 ℹ [CJS] dist/s3-multipart-upload.d.cts      1.20 kB │ gzip: 0.49 kB
 ℹ [CJS] dist/network-multiplier.d.cts       0.97 kB │ gzip: 0.49 kB
 ℹ [CJS] dist/optimal-part-size.d.cts        0.87 kB │ gzip: 0.46 kB
-ℹ [CJS] dist/simple-http-upload.d.cts       0.44 kB │ gzip: 0.28 kB
 ℹ [CJS] dist/from-node-readable.d.cts       0.26 kB │ gzip: 0.18 kB
 ℹ [CJS] dist/from-file.d.cts                0.21 kB │ gzip: 0.18 kB
-ℹ [CJS] 12 files, total: 5.86 kB
-✔ Build complete in 2822ms
+ℹ [CJS] 12 files, total: 6.87 kB
+[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugin `rolldown-plugin-dts:generate`. See https://rolldown.rs/options/checks#plugintimings for more details.
+
+✔ Build complete in 3501ms
 ℹ [ESM] dist/s3-multipart-upload.mjs        1.96 kB │ gzip: 0.84 kB
+ℹ [ESM] dist/simple-http-upload.mjs         1.33 kB │ gzip: 0.62 kB
 ℹ [ESM] dist/network-multiplier.mjs         0.83 kB │ gzip: 0.44 kB
-ℹ [ESM] dist/simple-http-upload.mjs         0.77 kB │ gzip: 0.43 kB
 ℹ [ESM] dist/optimal-part-size.mjs          0.49 kB │ gzip: 0.27 kB
 ℹ [ESM] dist/from-node-readable.mjs         0.25 kB │ gzip: 0.17 kB
 ℹ [ESM] dist/from-file.mjs                  0.20 kB │ gzip: 0.17 kB
 ℹ [ESM] dist/s3-multipart-upload.mjs.map    4.29 kB │ gzip: 1.62 kB
+ℹ [ESM] dist/simple-http-upload.mjs.map     4.10 kB │ gzip: 1.78 kB
 ℹ [ESM] dist/network-multiplier.mjs.map     2.21 kB │ gzip: 1.00 kB
-ℹ [ESM] dist/simple-http-upload.mjs.map     1.59 kB │ gzip: 0.78 kB
 ℹ [ESM] dist/optimal-part-size.mjs.map      1.44 kB │ gzip: 0.71 kB
 ℹ [ESM] dist/s3-multipart-upload.d.mts.map  0.69 kB │ gzip: 0.33 kB
 ℹ [ESM] dist/from-node-readable.mjs.map     0.39 kB │ gzip: 0.25 kB
 ℹ [ESM] dist/from-file.mjs.map              0.38 kB │ gzip: 0.27 kB
+ℹ [ESM] dist/simple-http-upload.d.mts.map   0.34 kB │ gzip: 0.21 kB
 ℹ [ESM] dist/network-multiplier.d.mts.map   0.31 kB │ gzip: 0.22 kB
-ℹ [ESM] dist/simple-http-upload.d.mts.map   0.30 kB │ gzip: 0.20 kB
 ℹ [ESM] dist/optimal-part-size.d.mts.map    0.25 kB │ gzip: 0.19 kB
 ℹ [ESM] dist/from-file.d.mts.map            0.18 kB │ gzip: 0.15 kB
 ℹ [ESM] dist/from-node-readable.d.mts.map   0.18 kB │ gzip: 0.15 kB
+ℹ [ESM] dist/simple-http-upload.d.mts       1.41 kB │ gzip: 0.74 kB
 ℹ [ESM] dist/s3-multipart-upload.d.mts      1.20 kB │ gzip: 0.49 kB
 ℹ [ESM] dist/network-multiplier.d.mts       0.97 kB │ gzip: 0.49 kB
 ℹ [ESM] dist/optimal-part-size.d.mts        0.87 kB │ gzip: 0.46 kB
-ℹ [ESM] dist/simple-http-upload.d.mts       0.44 kB │ gzip: 0.28 kB
 ℹ [ESM] dist/from-node-readable.d.mts       0.26 kB │ gzip: 0.18 kB
 ℹ [ESM] dist/from-file.d.mts                0.21 kB │ gzip: 0.18 kB
-ℹ [ESM] 24 files, total: 20.66 kB
-✔ Build complete in 2826ms
+ℹ [ESM] 24 files, total: 24.74 kB
+[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugin `rolldown-plugin-dts:generate`. See https://rolldown.rs/options/checks#plugintimings for more details.
+
+✔ Build complete in 3514ms

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# @tranquilload/adapters
+
+## 0.1.1
+
+### Patch Changes
+
+- 6ca9186: `simpleHttpUpload`: add `bufferMode` option + set `duplex: 'half'` on streaming uploads.
+
+  The streaming PUT path now sets `duplex: 'half'`, which modern browsers and
+  Node 22+ require to accept a `ReadableStream` as a `fetch` body. **Streaming
+  PUT now requires an HTTP/2 endpoint** — HTTP/1.x will reject the request.
+
+  For HTTP/1.x targets (or environments where the `duplex` flag is unavailable),
+  opt in to `bufferMode: true`. The adapter drains the entire source stream
+  into a `Blob` before issuing the request:
+
+  ```ts
+  const adapter = simpleHttpUpload({
+    url: "https://legacy-http1.example.com/upload",
+    bufferMode: true,
+  });
+  ```
+
+  **Memory caveat.** `bufferMode: true` buffers the whole source into memory —
+  do not enable for files larger than available memory. Use it as the HTTP/1.x
+  escape hatch, not as a default.
+
+  The drain loop is signal-aware: aborting via `AbortSignal` between read
+  iterations rejects with `AbortError` (not `CompleteUploadError`), preserving
+  the abort phase mapping.
+
+- Updated dependencies [6ca9186]
+- Updated dependencies [6ca9186]
+  - @tranquilload/core@0.1.1

package/dist/simple-http-upload.cjs

@@ -2,17 +2,39 @@ 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 { url, method = "PUT", headers, signal, bufferMode = false } = options;
 	const upload = async (stream) => {
 		let response;
 		try {
-			response = await fetch(url, {
+			if (bufferMode) {
+				const reader = stream.getReader();
+				const chunks = [];
+				try {
+					while (true) {
+						if (signal?.aborted) throw new _tranquilload_core_errors.AbortError();
+						const { done, value } = await reader.read();
+						if (done) break;
+						if (value) chunks.push(value);
+					}
+				} finally {
+					reader.releaseLock();
+				}
+				const blob = new Blob(chunks);
+				response = await fetch(url, {
+					method,
+					headers,
+					body: blob,
+					signal
+				});
+			} else response = await fetch(url, {
 				method,
 				headers,
 				body: stream,
-				signal
+				signal,
+				duplex: "half"
 			});
 		} catch (cause) {
+			if (cause instanceof _tranquilload_core_errors.AbortError) throw cause;
 			if (cause instanceof Error && cause.name === "AbortError") throw new _tranquilload_core_errors.AbortError();
 			throw new _tranquilload_core_errors.CompleteUploadError(cause);
 		}

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

@@ -1 +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"}
+{"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\n/**\n * Adapter for the simplest possible HTTP upload: PUT/POST a stream of bytes\n * directly to a single URL.\n *\n * **Streaming PUT requires HTTP/2 and `duplex: 'half'`.** This is the default\n * mode and is the most memory-efficient option. If your target only speaks\n * HTTP/1.x, or your runtime does not understand `duplex: 'half'`, set\n * `bufferMode: true` to buffer the whole source into a `Blob` before sending.\n */\nexport interface SimpleHttpUploadOptions {\n  url: string\n  method?: \"PUT\" | \"POST\"\n  headers?: Record<string, string>\n  signal?: AbortSignal\n  /**\n   * When `true`, drains the entire source stream into a `Blob` before issuing\n   * the PUT/POST request. The request is then a normal buffered upload (no\n   * `duplex: 'half'` required, works on HTTP/1.x).\n   *\n   * **Memory usage equals the source size — DO NOT enable for files larger\n   * than available memory.** Use only when streaming PUT isn't supported\n   * (HTTP/1.x, environments where `duplex: 'half'` is unavailable).\n   *\n   * Default: `false` (streaming with `duplex: 'half'`, requires HTTP/2).\n   */\n  bufferMode?: boolean\n}\n\nexport function simpleHttpUpload(options: SimpleHttpUploadOptions): {\n  upload: (stream: ReadableStream<Uint8Array>) => Promise<void>\n} {\n  const { url, method = \"PUT\", headers, signal, bufferMode = false } = options\n\n  const upload = async (stream: ReadableStream<Uint8Array>): Promise<void> => {\n    let response: Response\n    try {\n      if (bufferMode) {\n        const reader = stream.getReader()\n        const chunks: Uint8Array[] = []\n        try {\n          // Manual drain loop with per-iteration abort check: `Response#blob()`\n          // ignores AbortSignal, so we cannot rely on `new Response(stream).blob()`.\n          while (true) {\n            if (signal?.aborted) {\n              throw new AbortError()\n            }\n            const { done, value } = await reader.read()\n            if (done) break\n            if (value) chunks.push(value)\n          }\n        } finally {\n          reader.releaseLock()\n        }\n        const blob = new Blob(chunks as BlobPart[])\n        response = await fetch(url, {\n          method,\n          headers,\n          body: blob,\n          signal,\n        })\n      } else {\n        // duplex: 'half' is not in lib.dom.d.ts but is required by modern\n        // browsers/Node 22+ to accept a ReadableStream as a fetch body.\n        response = await fetch(url, {\n          method,\n          headers,\n          body: stream as unknown as BodyInit,\n          signal,\n          duplex: \"half\",\n        } as RequestInit & { duplex: \"half\" })\n      }\n    } catch (cause) {\n      if (cause instanceof AbortError) {\n        throw cause\n      }\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":";;;AA8BA,SAAgB,iBAAiB,SAE/B;CACA,MAAM,EAAE,KAAK,SAAS,OAAO,SAAS,QAAQ,aAAa,UAAU;CAErE,MAAM,SAAS,OAAO,WAAsD;EAC1E,IAAI;AACJ,MAAI;AACF,OAAI,YAAY;IACd,MAAM,SAAS,OAAO,WAAW;IACjC,MAAM,SAAuB,EAAE;AAC/B,QAAI;AAGF,YAAO,MAAM;AACX,UAAI,QAAQ,QACV,OAAM,IAAIA,0BAAAA,YAAY;MAExB,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;AAC3C,UAAI,KAAM;AACV,UAAI,MAAO,QAAO,KAAK,MAAM;;cAEvB;AACR,YAAO,aAAa;;IAEtB,MAAM,OAAO,IAAI,KAAK,OAAqB;AAC3C,eAAW,MAAM,MAAM,KAAK;KAC1B;KACA;KACA,MAAM;KACN;KACD,CAAC;SAIF,YAAW,MAAM,MAAM,KAAK;IAC1B;IACA;IACA,MAAM;IACN;IACA,QAAQ;IACT,CAAqC;WAEjC,OAAO;AACd,OAAI,iBAAiBA,0BAAAA,WACnB,OAAM;AAER,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

@@ -1,9 +1,30 @@
 //#region src/protocols/simple-http-upload.d.ts
+/**
+ * Adapter for the simplest possible HTTP upload: PUT/POST a stream of bytes
+ * directly to a single URL.
+ *
+ * **Streaming PUT requires HTTP/2 and `duplex: 'half'`.** This is the default
+ * mode and is the most memory-efficient option. If your target only speaks
+ * HTTP/1.x, or your runtime does not understand `duplex: 'half'`, set
+ * `bufferMode: true` to buffer the whole source into a `Blob` before sending.
+ */
 interface SimpleHttpUploadOptions {
   url: string;
   method?: "PUT" | "POST";
   headers?: Record<string, string>;
   signal?: AbortSignal;
+  /**
+   * When `true`, drains the entire source stream into a `Blob` before issuing
+   * the PUT/POST request. The request is then a normal buffered upload (no
+   * `duplex: 'half'` required, works on HTTP/1.x).
+   *
+   * **Memory usage equals the source size — DO NOT enable for files larger
+   * than available memory.** Use only when streaming PUT isn't supported
+   * (HTTP/1.x, environments where `duplex: 'half'` is unavailable).
+   *
+   * Default: `false` (streaming with `duplex: 'half'`, requires HTTP/2).
+   */
+  bufferMode?: boolean;
 }
 declare function simpleHttpUpload(options: SimpleHttpUploadOptions): {
   upload: (stream: ReadableStream<Uint8Array>) => Promise<void>;

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

@@ -1 +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"}
+{"version":3,"file":"simple-http-upload.d.cts","names":[],"sources":["../src/protocols/simple-http-upload.ts"],"mappings":";;AAWA;;;;;;;;UAAiB,uBAAA;EACf,GAAA;EACA,MAAA;EACA,OAAA,GAAU,MAAA;EACV,MAAA,GAAS,WAAA;EAeK;;;;;;;;;;;EAHd,UAAA;AAAA;AAAA,iBAGc,gBAAA,CAAiB,OAAA,EAAS,uBAAA;EACxC,MAAA,GAAS,MAAA,EAAQ,cAAA,CAAe,UAAA,MAAgB,OAAA;AAAA"}

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

@@ -1,9 +1,30 @@
 //#region src/protocols/simple-http-upload.d.ts
+/**
+ * Adapter for the simplest possible HTTP upload: PUT/POST a stream of bytes
+ * directly to a single URL.
+ *
+ * **Streaming PUT requires HTTP/2 and `duplex: 'half'`.** This is the default
+ * mode and is the most memory-efficient option. If your target only speaks
+ * HTTP/1.x, or your runtime does not understand `duplex: 'half'`, set
+ * `bufferMode: true` to buffer the whole source into a `Blob` before sending.
+ */
 interface SimpleHttpUploadOptions {
   url: string;
   method?: "PUT" | "POST";
   headers?: Record<string, string>;
   signal?: AbortSignal;
+  /**
+   * When `true`, drains the entire source stream into a `Blob` before issuing
+   * the PUT/POST request. The request is then a normal buffered upload (no
+   * `duplex: 'half'` required, works on HTTP/1.x).
+   *
+   * **Memory usage equals the source size — DO NOT enable for files larger
+   * than available memory.** Use only when streaming PUT isn't supported
+   * (HTTP/1.x, environments where `duplex: 'half'` is unavailable).
+   *
+   * Default: `false` (streaming with `duplex: 'half'`, requires HTTP/2).
+   */
+  bufferMode?: boolean;
 }
 declare function simpleHttpUpload(options: SimpleHttpUploadOptions): {
   upload: (stream: ReadableStream<Uint8Array>) => Promise<void>;

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

@@ -1 +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"}
+{"version":3,"file":"simple-http-upload.d.mts","names":[],"sources":["../src/protocols/simple-http-upload.ts"],"mappings":";;AAWA;;;;;;;;UAAiB,uBAAA;EACf,GAAA;EACA,MAAA;EACA,OAAA,GAAU,MAAA;EACV,MAAA,GAAS,WAAA;EAeK;;;;;;;;;;;EAHd,UAAA;AAAA;AAAA,iBAGc,gBAAA,CAAiB,OAAA,EAAS,uBAAA;EACxC,MAAA,GAAS,MAAA,EAAQ,cAAA,CAAe,UAAA,MAAgB,OAAA;AAAA"}

package/dist/simple-http-upload.mjs

@@ -1,17 +1,39 @@
 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 { url, method = "PUT", headers, signal, bufferMode = false } = options;
 	const upload = async (stream) => {
 		let response;
 		try {
-			response = await fetch(url, {
+			if (bufferMode) {
+				const reader = stream.getReader();
+				const chunks = [];
+				try {
+					while (true) {
+						if (signal?.aborted) throw new AbortError();
+						const { done, value } = await reader.read();
+						if (done) break;
+						if (value) chunks.push(value);
+					}
+				} finally {
+					reader.releaseLock();
+				}
+				const blob = new Blob(chunks);
+				response = await fetch(url, {
+					method,
+					headers,
+					body: blob,
+					signal
+				});
+			} else response = await fetch(url, {
 				method,
 				headers,
 				body: stream,
-				signal
+				signal,
+				duplex: "half"
 			});
 		} catch (cause) {
+			if (cause instanceof AbortError) throw cause;
 			if (cause instanceof Error && cause.name === "AbortError") throw new AbortError();
 			throw new CompleteUploadError(cause);
 		}

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

@@ -1 +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"}
+{"version":3,"file":"simple-http-upload.mjs","names":[],"sources":["../src/protocols/simple-http-upload.ts"],"sourcesContent":["import { AbortError, CompleteUploadError } from \"@tranquilload/core/errors\"\n\n/**\n * Adapter for the simplest possible HTTP upload: PUT/POST a stream of bytes\n * directly to a single URL.\n *\n * **Streaming PUT requires HTTP/2 and `duplex: 'half'`.** This is the default\n * mode and is the most memory-efficient option. If your target only speaks\n * HTTP/1.x, or your runtime does not understand `duplex: 'half'`, set\n * `bufferMode: true` to buffer the whole source into a `Blob` before sending.\n */\nexport interface SimpleHttpUploadOptions {\n  url: string\n  method?: \"PUT\" | \"POST\"\n  headers?: Record<string, string>\n  signal?: AbortSignal\n  /**\n   * When `true`, drains the entire source stream into a `Blob` before issuing\n   * the PUT/POST request. The request is then a normal buffered upload (no\n   * `duplex: 'half'` required, works on HTTP/1.x).\n   *\n   * **Memory usage equals the source size — DO NOT enable for files larger\n   * than available memory.** Use only when streaming PUT isn't supported\n   * (HTTP/1.x, environments where `duplex: 'half'` is unavailable).\n   *\n   * Default: `false` (streaming with `duplex: 'half'`, requires HTTP/2).\n   */\n  bufferMode?: boolean\n}\n\nexport function simpleHttpUpload(options: SimpleHttpUploadOptions): {\n  upload: (stream: ReadableStream<Uint8Array>) => Promise<void>\n} {\n  const { url, method = \"PUT\", headers, signal, bufferMode = false } = options\n\n  const upload = async (stream: ReadableStream<Uint8Array>): Promise<void> => {\n    let response: Response\n    try {\n      if (bufferMode) {\n        const reader = stream.getReader()\n        const chunks: Uint8Array[] = []\n        try {\n          // Manual drain loop with per-iteration abort check: `Response#blob()`\n          // ignores AbortSignal, so we cannot rely on `new Response(stream).blob()`.\n          while (true) {\n            if (signal?.aborted) {\n              throw new AbortError()\n            }\n            const { done, value } = await reader.read()\n            if (done) break\n            if (value) chunks.push(value)\n          }\n        } finally {\n          reader.releaseLock()\n        }\n        const blob = new Blob(chunks as BlobPart[])\n        response = await fetch(url, {\n          method,\n          headers,\n          body: blob,\n          signal,\n        })\n      } else {\n        // duplex: 'half' is not in lib.dom.d.ts but is required by modern\n        // browsers/Node 22+ to accept a ReadableStream as a fetch body.\n        response = await fetch(url, {\n          method,\n          headers,\n          body: stream as unknown as BodyInit,\n          signal,\n          duplex: \"half\",\n        } as RequestInit & { duplex: \"half\" })\n      }\n    } catch (cause) {\n      if (cause instanceof AbortError) {\n        throw cause\n      }\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":";;AA8BA,SAAgB,iBAAiB,SAE/B;CACA,MAAM,EAAE,KAAK,SAAS,OAAO,SAAS,QAAQ,aAAa,UAAU;CAErE,MAAM,SAAS,OAAO,WAAsD;EAC1E,IAAI;AACJ,MAAI;AACF,OAAI,YAAY;IACd,MAAM,SAAS,OAAO,WAAW;IACjC,MAAM,SAAuB,EAAE;AAC/B,QAAI;AAGF,YAAO,MAAM;AACX,UAAI,QAAQ,QACV,OAAM,IAAI,YAAY;MAExB,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;AAC3C,UAAI,KAAM;AACV,UAAI,MAAO,QAAO,KAAK,MAAM;;cAEvB;AACR,YAAO,aAAa;;IAEtB,MAAM,OAAO,IAAI,KAAK,OAAqB;AAC3C,eAAW,MAAM,MAAM,KAAK;KAC1B;KACA;KACA,MAAM;KACN;KACD,CAAC;SAIF,YAAW,MAAM,MAAM,KAAK;IAC1B;IACA;IACA,MAAM;IACN;IACA,QAAQ;IACT,CAAqC;WAEjC,OAAO;AACd,OAAI,iBAAiB,WACnB,OAAM;AAER,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

@@ -1,6 +1,6 @@
 {
   "name": "@tranquilload/adapters",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Adapters for Tranquilload (S3, File, Node, HTTP)",
   "license": "MIT",
   "repository": {
@@ -53,7 +53,7 @@
   },
   "peerDependencies": {
     "effect": ">=3.19.19",
-    "@tranquilload/core": "^0.1.0"
+    "@tranquilload/core": "^0.1.1"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
@@ -62,7 +62,7 @@
     "tsdown": "^0.21.0",
     "typescript": "^5.5.0",
     "vitest": "^3.2.0",
-    "@tranquilload/core": "0.1.0"
+    "@tranquilload/core": "0.1.1"
   },
   "scripts": {
     "build": "tsdown",

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

@@ -72,4 +72,92 @@ describe("simpleHttpUpload", () => {
     expect(error).toBeInstanceOf(CompleteUploadError)
     expect(error.cause).toBe(networkError)
   })
+
+  it("passes duplex: 'half' on streaming uploads (default)", 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" })
+    await adapter.upload(stream)
+
+    const [, init] = fetchMock.mock.calls[0]!
+    expect(init.duplex).toBe("half")
+    expect(init.body).toBe(stream)
+  })
+
+  it("buffers the stream into a Blob when bufferMode is true", async () => {
+    const chunkA = new Uint8Array([1, 2, 3])
+    const chunkB = new Uint8Array([4, 5])
+    const stream = new ReadableStream<Uint8Array>({
+      start(c) {
+        c.enqueue(chunkA)
+        c.enqueue(chunkB)
+        c.close()
+      },
+    })
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal("fetch", fetchMock)
+
+    const adapter = simpleHttpUpload({
+      url: "https://example.com/upload",
+      bufferMode: true,
+    })
+    await adapter.upload(stream)
+
+    const [, init] = fetchMock.mock.calls[0]!
+    expect(init.body).toBeInstanceOf(Blob)
+    expect((init.body as Blob).size).toBe(chunkA.length + chunkB.length)
+    expect(init.duplex).toBeUndefined()
+  })
+
+  it("rejects with CompleteUploadError on mid-stream read errors when bufferMode is true", async () => {
+    const readError = new Error("source read failed")
+    const stream = new ReadableStream<Uint8Array>({
+      start(c) {
+        c.enqueue(new Uint8Array([1, 2, 3]))
+      },
+      pull(c) {
+        c.error(readError)
+      },
+    })
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal("fetch", fetchMock)
+
+    const adapter = simpleHttpUpload({
+      url: "https://example.com/upload",
+      bufferMode: true,
+    })
+    const error = await adapter.upload(stream).catch((e) => e)
+    expect(error).toBeInstanceOf(CompleteUploadError)
+    expect((error as CompleteUploadError).cause).toBe(readError)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it("rejects with AbortError when signal aborts during bufferMode drain", async () => {
+    const controller = new AbortController()
+    const stream = new ReadableStream<Uint8Array>({
+      start(c) {
+        c.enqueue(new Uint8Array([1, 2, 3]))
+      },
+      pull(c) {
+        // After the first chunk is consumed, abort before the next read resolves.
+        controller.abort()
+        // Then leave the stream pending so the loop checks `signal.aborted` first.
+        setTimeout(() => c.enqueue(new Uint8Array([4, 5])), 10)
+      },
+    })
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal("fetch", fetchMock)
+
+    const adapter = simpleHttpUpload({
+      url: "https://example.com/upload",
+      bufferMode: true,
+      signal: controller.signal,
+    })
+    const error = await adapter.upload(stream).catch((e) => e)
+    expect(error).toBeInstanceOf(AbortError)
+    expect(error).not.toBeInstanceOf(CompleteUploadError)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
 })

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

@@ -1,27 +1,80 @@
 import { AbortError, CompleteUploadError } from "@tranquilload/core/errors"
 
+/**
+ * Adapter for the simplest possible HTTP upload: PUT/POST a stream of bytes
+ * directly to a single URL.
+ *
+ * **Streaming PUT requires HTTP/2 and `duplex: 'half'`.** This is the default
+ * mode and is the most memory-efficient option. If your target only speaks
+ * HTTP/1.x, or your runtime does not understand `duplex: 'half'`, set
+ * `bufferMode: true` to buffer the whole source into a `Blob` before sending.
+ */
 export interface SimpleHttpUploadOptions {
   url: string
   method?: "PUT" | "POST"
   headers?: Record<string, string>
   signal?: AbortSignal
+  /**
+   * When `true`, drains the entire source stream into a `Blob` before issuing
+   * the PUT/POST request. The request is then a normal buffered upload (no
+   * `duplex: 'half'` required, works on HTTP/1.x).
+   *
+   * **Memory usage equals the source size — DO NOT enable for files larger
+   * than available memory.** Use only when streaming PUT isn't supported
+   * (HTTP/1.x, environments where `duplex: 'half'` is unavailable).
+   *
+   * Default: `false` (streaming with `duplex: 'half'`, requires HTTP/2).
+   */
+  bufferMode?: boolean
 }
 
 export function simpleHttpUpload(options: SimpleHttpUploadOptions): {
   upload: (stream: ReadableStream<Uint8Array>) => Promise<void>
 } {
-  const { url, method = "PUT", headers, signal } = options
+  const { url, method = "PUT", headers, signal, bufferMode = false } = 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,
-      })
+      if (bufferMode) {
+        const reader = stream.getReader()
+        const chunks: Uint8Array[] = []
+        try {
+          // Manual drain loop with per-iteration abort check: `Response#blob()`
+          // ignores AbortSignal, so we cannot rely on `new Response(stream).blob()`.
+          while (true) {
+            if (signal?.aborted) {
+              throw new AbortError()
+            }
+            const { done, value } = await reader.read()
+            if (done) break
+            if (value) chunks.push(value)
+          }
+        } finally {
+          reader.releaseLock()
+        }
+        const blob = new Blob(chunks as BlobPart[])
+        response = await fetch(url, {
+          method,
+          headers,
+          body: blob,
+          signal,
+        })
+      } else {
+        // duplex: 'half' is not in lib.dom.d.ts but is required by modern
+        // browsers/Node 22+ to accept a ReadableStream as a fetch body.
+        response = await fetch(url, {
+          method,
+          headers,
+          body: stream as unknown as BodyInit,
+          signal,
+          duplex: "half",
+        } as RequestInit & { duplex: "half" })
+      }
     } catch (cause) {
+      if (cause instanceof AbortError) {
+        throw cause
+      }
       if (cause instanceof Error && cause.name === "AbortError") {
         throw new AbortError()
       }