feat(node): add clone() support to ImpitResponse (#419)

## Summary

Implements `Response.clone()` on `ImpitResponse` using
`ReadableStream.tee()`, making impit compatible with libraries like
[ky](https://github.com/sindresorhus/ky) that call `response.clone()`
internally.

## Approach

When `.clone()` is called:

1. `this.body.tee()` splits the underlying `ReadableStream` into two
independent streams (synchronous, no eager buffering)
2. The original response's `.body` getter and body methods (`text`,
`json`, `arrayBuffer`, `bytes`) are re-patched to read from one stream
3. A standard `Response` is returned as the clone, backed by the other
stream

Multiple clones are supported (matching the Fetch spec) — each call tees
the current branch, so the original and all clones can be read
independently.

Charset-aware `text()` decoding is preserved on the original via
`decodeBuffer`. The clone uses standard `Response.text()` (UTF-8).

Throws `TypeError` on clone after body consumption, matching Fetch API
semantics.

## Changes

- **`index.wrapper.js`** — add `clone()` in `#wrapResponse`, re-patch
`.body` getter and body methods with `configurable: true` so subsequent
clones work
- **`dts-header.d.ts`** — add `clone(): Response` to `ImpitResponse` via
declaration merging
- **`test/basics.test.ts`** — tests covering: return type, url/header
preservation, independent body reads, text() on both, multiple clones,
body streaming after clone, clone-after-consume error, arrayBuffer on
both, read ordering, non-200 status

---------

Co-authored-by: Jindřich Bär <jindrichbar@gmail.com>

Author: privatenumber

impit-node/index.d.ts

@@ -224,6 +224,18 @@ export declare class ImpitResponse {
    * ```
    */
   get body(): ReadableStream<Uint8Array>
+  /**
+   * Creates a copy of the response.
+   *
+   * The original response's body methods are re-bound to one half of the
+   * tee'd stream; the returned clone is a standard `Response` backed by the
+   * other half.
+   *
+   * Calling `clone()` after the body has been consumed throws a `TypeError`.
+   *
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Response/clone | Fetch API `Response.clone()`}
+   */
+  clone(): Response
   /**
    * Aborts the response.
    *

impit-node/index.wrapper.js

@@ -272,34 +272,120 @@ class Impit extends native.Impit {
         }
 
         Object.defineProperty(originalResponse, 'text', {
-            value: ResponsePatches.text.bind(originalResponse)
+            value: ResponsePatches.text.bind(originalResponse),
+            configurable: true,
         });
 
+        let bodyConsumed = false;
+
         const nativeBytes = originalResponse.bytes.bind(originalResponse);
         Object.defineProperty(originalResponse, 'bytes', {
             value: async function() {
+                bodyConsumed = true;
                 try { return await nativeBytes(); } finally { cleanup(); }
-            }
+            },
+            configurable: true,
         });
 
         const nativeArrayBuffer = originalResponse.arrayBuffer.bind(originalResponse);
         Object.defineProperty(originalResponse, 'arrayBuffer', {
             value: async function() {
+                bodyConsumed = true;
                 try { return await nativeArrayBuffer(); } finally { cleanup(); }
-            }
+            },
+            configurable: true,
         });
 
         const nativeJson = originalResponse.json.bind(originalResponse);
         Object.defineProperty(originalResponse, 'json', {
             value: async function() {
+                bodyConsumed = true;
                 try { return await nativeJson(); } finally { cleanup(); }
-            }
+            },
+            configurable: true,
         });
 
         Object.defineProperty(originalResponse, 'headers', {
             value: new Headers(originalResponse.headers)
         });
 
+        Object.defineProperty(originalResponse, 'clone', {
+            value: function () {
+                if (bodyConsumed) {
+                    throw new TypeError('Response body has already been consumed');
+                }
+
+                const [stream1, stream2] = this.body.tee();
+
+                // Create a delegate Response from stream1 for the original's body methods
+                const delegate = new Response(stream1, {
+                    status: this.status,
+                    statusText: this.statusText,
+                    headers: this.headers,
+                });
+
+                // Re-patch original's body getter to return the delegate's stream
+                // (the original stream is now locked after tee)
+                Object.defineProperty(this, 'body', {
+                    get: () => delegate.body,
+                    configurable: true,
+                });
+
+                // Re-patch original's body methods to read from the delegate
+                const decodeBuffer = this.decodeBuffer.bind(this);
+                Object.defineProperty(this, 'arrayBuffer', {
+                    value: async function () {
+                        bodyConsumed = true;
+                        try { return await delegate.arrayBuffer(); } finally { cleanup(); }
+                    },
+                    configurable: true,
+                });
+                Object.defineProperty(this, 'bytes', {
+                    value: async function () {
+                        bodyConsumed = true;
+                        try { return await delegate.bytes(); } finally { cleanup(); }
+                    },
+                    configurable: true,
+                });
+                Object.defineProperty(this, 'json', {
+                    value: async function () {
+                        bodyConsumed = true;
+                        try { return await delegate.json(); } finally { cleanup(); }
+                    },
+                    configurable: true,
+                });
+                Object.defineProperty(this, 'text', {
+                    value: async function () {
+                        bodyConsumed = true;
+                        try {
+                            const buffer = await delegate.arrayBuffer();
+                            return decodeBuffer(Buffer.from(buffer));
+                        } finally { cleanup(); }
+                    },
+                    configurable: true,
+                });
+
+                // Create the clone from stream2
+                const clone = new Response(stream2, {
+                    status: this.status,
+                    statusText: this.statusText,
+                    headers: this.headers,
+                });
+                Object.defineProperty(clone, 'url', {
+                    value: this.url,
+                    enumerable: true,
+                });
+                Object.defineProperty(clone, 'text', {
+                    value: async function () {
+                        const buffer = await clone.arrayBuffer();
+                        return decodeBuffer(Buffer.from(buffer));
+                    },
+                });
+
+                return clone;
+            },
+        });
+
         return originalResponse;
     }
 }

impit-node/src/response.rs

@@ -311,6 +311,23 @@ impl<'env> ImpitResponse {
     response.get_named_property("body")
   }
 
+  /// Creates a copy of the response.
+  ///
+  /// The original response's body methods are re-bound to one half of the
+  /// tee'd stream; the returned clone is a standard `Response` backed by the
+  /// other half.
+  ///
+  /// Calling `clone()` after the body has been consumed throws a `TypeError`.
+  ///
+  /// @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Response/clone | Fetch API `Response.clone()`}
+  #[napi(js_name = "clone", ts_return_type = "Response")]
+  pub fn clone_response(&self) -> Result<()> {
+    Err(napi::Error::new(
+      napi::Status::GenericFailure,
+      "clone() is implemented in the JavaScript wrapper".to_string(),
+    ))
+  }
+
   /// Aborts the response.
   ///
   /// This API is called internally and can change without notice.

impit-node/test/basics.test.ts

@@ -623,6 +623,121 @@ describe.each([
         });
     });
 
+    describe('Response.clone()', () => {
+        test('clone returns a standard Response', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/get'));
+            const clone = response.clone();
+
+            expect(clone).toBeInstanceOf(Response);
+            expect(clone.status).toBe(200);
+            expect(clone.ok).toBe(true);
+        });
+
+        test('clone preserves url', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/get'));
+            const clone = response.clone();
+
+            expect(clone.url).toBe(response.url);
+        });
+
+        test('clone preserves headers', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/get'));
+            const clone = response.clone();
+
+            expect(clone.headers.get('content-type')).toBe(
+                response.headers.get('content-type'),
+            );
+        });
+
+        test('both original and clone bodies are independently readable', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/get'));
+            const clone = response.clone();
+
+            const cloneData = await clone.json();
+            const originalData = await response.json();
+
+            expect(cloneData).toEqual(originalData);
+        });
+
+        test('text() works on both original and clone', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/get'));
+            const clone = response.clone();
+
+            const cloneText = await clone.text();
+            const originalText = await response.text();
+
+            expect(cloneText.length).toBeGreaterThan(0);
+            expect(cloneText).toBe(originalText);
+        });
+
+        test('multiple clones produce independent readable bodies', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/get'));
+            const clone1 = response.clone();
+            const clone2 = response.clone();
+
+            const [original, first, second] = await Promise.all([
+                response.json(),
+                clone1.json(),
+                clone2.json(),
+            ]);
+
+            expect(original).toEqual(first);
+            expect(original).toEqual(second);
+        });
+
+        test('clone() after body consumed throws TypeError', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/get'));
+            await response.text();
+
+            expect(() => response.clone()).toThrow(TypeError);
+            expect(() => response.clone()).toThrow(/body has already been consumed/);
+        });
+
+        test('response.body is streamable after clone', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/get'));
+            response.clone();
+
+            const reader = response.body.getReader();
+            const chunks: Uint8Array[] = [];
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                chunks.push(value);
+            }
+
+            expect(chunks.length).toBeGreaterThan(0);
+        });
+
+        test('arrayBuffer() works on both original and clone', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/get'));
+            const clone = response.clone();
+
+            const cloneBuf = await clone.arrayBuffer();
+            const originalBuf = await response.arrayBuffer();
+
+            expect(cloneBuf.byteLength).toBeGreaterThan(0);
+            expect(cloneBuf.byteLength).toBe(originalBuf.byteLength);
+        });
+
+        test('reading original first, then clone', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/get'));
+            const clone = response.clone();
+
+            const originalData = await response.json();
+            const cloneData = await clone.json();
+
+            expect(originalData).toEqual(cloneData);
+        });
+
+        test('clone preserves non-200 status', async () => {
+            const response = await impit.fetch(getHttpBinUrl('/status/404'));
+            const clone = response.clone();
+
+            expect(clone.status).toBe(404);
+            expect(clone.ok).toBe(false);
+        });
+    });
+
     describe('Redirects', () => {
         test('follows redirects by default', async () => {
             const response = await impit.fetch('http://localhost:3001/redirect/1');