svelte-ag 1.0.58 → 1.0.60

package/dist/lib/api/query/entrypoint.unit.test.js

@@ -1,8 +1,16 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createApiRequest } from 'ts-ag';
+import * as v from 'valibot';
+const API_URL = 'https://api.example.test';
+const schemas = {
+    '/users': {
+        POST: v.union([v.object({ id: v.number(), group: v.optional(v.string()) }), v.object({ ids: v.array(v.number()) })])
+    }
+};
 function getUserId(input) {
     return 'id' in input ? input.id : input.ids[0];
 }
-function jsonResponse(body, status = 200) {
+function jsonFetchResponse(body, status = 200) {
     return new Response(JSON.stringify(body), {
         status,
         headers: { 'content-type': 'application/json' }
@@ -17,40 +25,50 @@ describe('createQueryFunction', () => {
     afterEach(() => {
         vi.useRealTimers();
         vi.restoreAllMocks();
+        vi.unstubAllGlobals();
     });
     it('returns the same query instance for the same path, method, and input', async () => {
         const { createQueryFunction } = await import('./entrypoint.svelte.js');
-        const requestMock = vi.fn(async () => jsonResponse({ ok: true }));
-        const request = requestMock;
+        const request = createApiRequest(schemas, API_URL, 'test');
         const createQuery = createQueryFunction(request, {});
-        const query1 = createQuery('/users', 'GET', { id: 1 });
-        const query2 = createQuery('/users', 'GET', { id: 1 });
-        const query3 = createQuery('/users', 'GET', { id: 2 });
+        const query1 = createQuery('/users', 'POST', { id: 1 });
+        const query2 = createQuery('/users', 'POST', { id: 1 });
+        const query3 = createQuery('/users', 'POST', { id: 2 });
         expect(query1).toBe(query2);
         expect(query3).not.toBe(query1);
     });
     it('reuses requestors so separate queries can batch together', async () => {
         const { createQueryFunction } = await import('./entrypoint.svelte.js');
-        const requestMock = vi.fn(async () => jsonResponse({ ok: true }));
-        const request = requestMock;
+        const fetchMock = vi.fn(async () => jsonFetchResponse({ 1: 'one', 2: 'two' }));
+        vi.stubGlobal('fetch', fetchMock);
+        vi.stubGlobal('fetch', fetchMock);
+        const request = createApiRequest(schemas, API_URL, 'test');
         const createQuery = createQueryFunction(request, {
             '/users': {
-                GET: {
+                POST: {
                     canBatch: () => 'users',
                     batchInput: (inputs) => ({ ids: inputs.map(getUserId) }),
-                    unBatchOutput: (inputs) => inputs.map((input) => jsonResponse({ id: getUserId(input) }))
+                    unBatchOutput: async (inputs, outputs) => {
+                        return inputs.map(() => {
+                            return outputs;
+                        });
+                    }
                 }
             }
         });
-        const query1 = createQuery('/users', 'GET', { id: 1 });
-        const query2 = createQuery('/users', 'GET', { id: 2 });
+        const query1 = createQuery('/users', 'POST', { id: 1 });
+        const query2 = createQuery('/users', 'POST', { id: 2 });
         const p1 = query1.request();
         const p2 = query2.request();
         await vi.advanceTimersByTimeAsync(100);
-        expect(requestMock).toHaveBeenCalledTimes(1);
-        expect(requestMock).toHaveBeenCalledWith('/users', 'GET', { ids: [1, 2] });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledWith(`${API_URL}//users`, expect.objectContaining({
+            method: 'POST',
+            body: JSON.stringify({ ids: [1, 2] }),
+            credentials: 'include'
+        }));
         const [response1, response2] = await Promise.all([p1, p2]);
-        await expect(response1.json()).resolves.toEqual({ id: 1 });
-        await expect(response2.json()).resolves.toEqual({ id: 2 });
+        await expect(response1.json()).resolves.toEqual({ 1: 'one', 2: 'two' });
+        await expect(response2.json()).resolves.toEqual({ 1: 'one', 2: 'two' });
     });
 });

package/dist/lib/api/query/query.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.svelte.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/query/query.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,kBAAkB,EAAE,cAAc,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAGnH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAG5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAenE,qBAAa,KAAK,CAChB,GAAG,SAAS,YAAY,EACxB,IAAI,SAAS,GAAG,CAAC,MAAM,CAAC,EACxB,MAAM,SAAS,OAAO,CAAC,GAAG,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,QAAQ,CAAC;;gBAyBzC,EACV,IAAI,EACJ,MAAM,EACN,KAAK,EACL,SAAS,EACT,KAAK,EACL,IAAI,EACL,EAAE;QACD,IAAI,EAAE,IAAI,CAAC;QACX,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACnC,SAAS,EAAE,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACxC,KAAK,EAAE,KAAK,CAAC;QACb,IAAI,CAAC,EAAE;YACL,KAAK,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC1C,CAAC;KACH;IAgBK,OAAO,IAAI,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IAyCxD,IAAI,QAAQ,WAEX;IACD,IAAI,QAAQ,YAEX;IACD,UAAU;IAMV,IAAI,MAAM,gBAET;IACD,IAAI,IAAI,IAAI,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,CAEnD;IACD,IAAI,SAAS,IAAI,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,CAEtD;CACF;AAED,qBAAa,SAAS,CACpB,GAAG,SAAS,YAAY,EACxB,IAAI,SAAS,GAAG,CAAC,MAAM,CAAC,EACxB,MAAM,SAAS,OAAO,CAAC,GAAG,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,QAAQ,CAAC;;gBA6BnD,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,kBAAkB,CAAC,GAAG,CAAC,EAChC,MAAM,EAAE,KAAK,EACb,YAAY,CAAC,EAAE,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC;YAelC,KAAK;IAOnB;;;OAGG;YACW,eAAe;IA2BvB,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;CAmB3F"}
+{"version":3,"file":"query.svelte.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/query/query.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,kBAAkB,EAAE,cAAc,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAGnH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAG5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnE,qBAAa,KAAK,CAChB,GAAG,SAAS,YAAY,EACxB,IAAI,SAAS,GAAG,CAAC,MAAM,CAAC,EACxB,MAAM,SAAS,OAAO,CAAC,GAAG,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,QAAQ,CAAC;;gBAyBzC,EACV,IAAI,EACJ,MAAM,EACN,KAAK,EACL,SAAS,EACT,KAAK,EACL,IAAI,EACL,EAAE;QACD,IAAI,EAAE,IAAI,CAAC;QACX,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACnC,SAAS,EAAE,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACxC,KAAK,EAAE,KAAK,CAAC;QACb,IAAI,CAAC,EAAE;YACL,KAAK,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC1C,CAAC;KACH;IAgBK,OAAO,IAAI,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IAyCxD,IAAI,QAAQ,WAEX;IACD,IAAI,QAAQ,YAEX;IACD,UAAU;IAMV,IAAI,MAAM,gBAET;IACD,IAAI,IAAI,IAAI,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,CAEnD;IACD,IAAI,SAAS,IAAI,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,CAEtD;CACF;AAED,qBAAa,SAAS,CACpB,GAAG,SAAS,YAAY,EACxB,IAAI,SAAS,GAAG,CAAC,MAAM,CAAC,EACxB,MAAM,SAAS,OAAO,CAAC,GAAG,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,QAAQ,CAAC;;gBA6BnD,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,kBAAkB,CAAC,GAAG,CAAC,EAChC,MAAM,EAAE,KAAK,EACb,YAAY,CAAC,EAAE,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC;YAelC,KAAK;IAOnB;;;OAGG;YACW,eAAe;IA6BvB,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;CAmB3F"}

package/dist/lib/api/query/query.svelte.js

@@ -1,15 +1,6 @@
 import { stringify } from 'devalue';
 import { cacheKey } from './utils.svelte.js';
 import { RateLimiter } from './rate.svelte';
-function cloneResponse(response) {
-    if (response !== null &&
-        typeof response === 'object' &&
-        'clone' in response &&
-        typeof response.clone === 'function') {
-        return response.clone();
-    }
-    return response;
-}
 export class Query {
     // -------- Constants --------
     #TIMEOUT = 1000 * 60 * 5; // 5 minutes
@@ -43,7 +34,7 @@ export class Query {
     async request() {
         const cachedValue = this.#cache.get(this.#cacheKey);
         if (cachedValue !== null) {
-            return cloneResponse(cachedValue);
+            return cachedValue;
         }
         this.#status = 'loading';
         if (this.#pendingRequest === null) {
@@ -60,9 +51,9 @@ export class Query {
         finally {
             this.#pendingRequest = null;
         }
-        const responseForState = cloneResponse(res);
-        const responseForCaller = cloneResponse(res);
-        this.#cache.set(this.#cacheKey, cloneResponse(res));
+        const responseForState = res;
+        const responseForCaller = res;
+        this.#cache.set(this.#cacheKey, res);
         if (responseForState.ok === false) {
             const body = await responseForState.json();
             this.#status = 'error';
@@ -137,6 +128,8 @@ export class Requestor {
      */
     async flushBatchQueue(batchId) {
         const queue = this.#batchQueue[batchId].splice(0);
+        // TODO maybe remove the unBatchOutput function and just always return the
+        // same response and then its on each consumer of each query to find the relevant records
         try {
             const batchedInput = this.#batchInput(queue.map((q) => q.input));
             const res = await this.fetch(batchedInput);

package/dist/lib/api/query/query.unit.test.js

@@ -1,15 +1,49 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createApiRequest } from 'ts-ag';
 import { Cache } from './cache.svelte.js';
 import { Query, Requestor } from './query.svelte.js';
+import { stringify } from 'devalue';
+import * as v from 'valibot';
+const API_URL = 'https://api.example.test';
+const plainSchemas = {
+    '/users': {
+        GET: v.object({ id: v.number() })
+    }
+};
+const batchedSchemas = {
+    '/users': {
+        POST: v.union([v.object({ id: v.number(), group: v.optional(v.string()) }), v.object({ ids: v.array(v.number()) })])
+    }
+};
 function getSingleId(input) {
     return 'id' in input ? input.id : input.ids[0];
 }
-function jsonResponse(body, status = 200) {
+function jsonFetchResponse(body, status = 200) {
     return new Response(JSON.stringify(body), {
         status,
         headers: { 'content-type': 'application/json' }
     });
 }
+function jsonResponse(body, status = 200) {
+    return jsonFetchResponse(body, status);
+}
+function devalueFetchResponse(body, status = 200) {
+    return new Response(stringify(body), {
+        status,
+        headers: { 'content-type': 'application/devalue' }
+    });
+}
+function withResponseOverrides(response) {
+    Object.defineProperty(response, 'extra', {
+        configurable: true,
+        value: () => 'copied'
+    });
+    Object.defineProperty(response, 'meta', {
+        configurable: true,
+        value: { source: 'custom' }
+    });
+    return response;
+}
 function deferred() {
     let resolve;
     let reject;
@@ -19,6 +53,18 @@ function deferred() {
     });
     return { promise, resolve, reject };
 }
+function createPlainRequest() {
+    return createApiRequest(plainSchemas, API_URL, 'test');
+}
+function createBatchedRequest() {
+    return createApiRequest(batchedSchemas, API_URL, 'test');
+}
+function createPlainRequestor() {
+    return new Requestor('/users', 'GET', createPlainRequest(), new Cache());
+}
+function createBatchedRequestor(batchDetails) {
+    return new Requestor('/users', 'POST', createBatchedRequest(), new Cache(), batchDetails);
+}
 describe('Requestor', () => {
     beforeEach(() => {
         vi.useFakeTimers();
@@ -27,20 +73,36 @@ describe('Requestor', () => {
     afterEach(() => {
         vi.useRealTimers();
         vi.restoreAllMocks();
+        vi.unstubAllGlobals();
     });
     it('passes through non-batched requests', async () => {
-        const requestMock = vi.fn(async () => jsonResponse({ id: 1 }));
-        const request = requestMock;
-        const requestor = new Requestor('/users', 'GET', request, new Cache());
+        const fetchMock = vi.fn(async () => jsonFetchResponse({ id: 1 }));
+        vi.stubGlobal('fetch', fetchMock);
+        const requestor = createPlainRequestor();
         const response = await requestor.request({ id: 1 });
-        expect(requestMock).toHaveBeenCalledTimes(1);
-        expect(requestMock).toHaveBeenCalledWith('/users', 'GET', { id: 1 });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledWith(`${API_URL}//users?id=1`, expect.objectContaining({
+            method: 'GET',
+            credentials: 'include'
+        }));
+        await expect(response.json()).resolves.toEqual({ id: 1 });
+    });
+    it('devalue response', async () => {
+        const fetchMock = vi.fn(async () => devalueFetchResponse({ id: 1 }));
+        vi.stubGlobal('fetch', fetchMock);
+        const requestor = createPlainRequestor();
+        const response = await requestor.request({ id: 1 });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledWith(`${API_URL}//users?id=1`, expect.objectContaining({
+            method: 'GET',
+            credentials: 'include'
+        }));
         await expect(response.json()).resolves.toEqual({ id: 1 });
     });
     it('batches requests with the same batch id and preserves response order', async () => {
-        const requestMock = vi.fn(async () => jsonResponse({ ok: true }));
-        const request = requestMock;
-        const requestor = new Requestor('/users', 'GET', request, new Cache(), {
+        const fetchMock = vi.fn(async () => jsonFetchResponse({ ok: true }));
+        vi.stubGlobal('fetch', fetchMock);
+        const requestor = createBatchedRequestor({
             canBatch: (input) => ('group' in input && input.group) || false,
             batchInput: (inputs) => ({ ids: inputs.map(getSingleId) }),
             unBatchOutput: (inputs) => inputs.map((input) => jsonResponse({ id: getSingleId(input) }))
@@ -48,25 +110,29 @@ describe('Requestor', () => {
         const p1 = requestor.request({ id: 1, group: 'team' });
         const p2 = requestor.request({ id: 2, group: 'team' });
         await vi.advanceTimersByTimeAsync(99);
-        expect(requestMock).not.toHaveBeenCalled();
+        expect(fetchMock).not.toHaveBeenCalled();
         await vi.advanceTimersByTimeAsync(1);
-        expect(requestMock).toHaveBeenCalledTimes(1);
-        expect(requestMock).toHaveBeenCalledWith('/users', 'GET', { ids: [1, 2] });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledWith(`${API_URL}//users`, expect.objectContaining({
+            method: 'POST',
+            body: JSON.stringify({ ids: [1, 2] }),
+            credentials: 'include'
+        }));
         const [response1, response2] = await Promise.all([p1, p2]);
         await expect(response1.json()).resolves.toEqual({ id: 1 });
         await expect(response2.json()).resolves.toEqual({ id: 2 });
     });
     it('rate limits separate batches by start time rather than completion time', async () => {
         const starts = [];
-        const requestMock = vi.fn(async (_path, _method, input) => {
+        const fetchMock = vi.fn(async (_url, init) => {
             starts.push(Date.now());
-            if ('ids' in input && input.ids[0] === 1) {
+            if (init?.body === JSON.stringify({ ids: [1] })) {
                 await new Promise((resolve) => setTimeout(resolve, 200));
             }
-            return jsonResponse({ ids: 'ids' in input ? input.ids : [input.id] });
+            return jsonFetchResponse({ ok: true });
         });
-        const request = requestMock;
-        const requestor = new Requestor('/users', 'GET', request, new Cache(), {
+        vi.stubGlobal('fetch', fetchMock);
+        const requestor = createBatchedRequestor({
             canBatch: (input) => ('group' in input && input.group) || false,
             batchInput: (inputs) => ({ ids: inputs.map(getSingleId) }),
             unBatchOutput: (_inputs, output) => [output]
@@ -79,13 +145,13 @@ describe('Requestor', () => {
         expect(starts).toEqual([100, 200]);
         await vi.runAllTimersAsync();
         const [response1, response2] = await Promise.all([p1, p2]);
-        await expect(response1.json()).resolves.toEqual({ ids: [1] });
-        await expect(response2.json()).resolves.toEqual({ ids: [2] });
+        await expect(response1.json()).resolves.toEqual({ ok: true });
+        await expect(response2.json()).resolves.toEqual({ ok: true });
     });
     it('returns batched error responses without rejecting them', async () => {
-        const requestMock = vi.fn(async () => jsonResponse({ ok: false }, 207));
-        const request = requestMock;
-        const requestor = new Requestor('/users', 'GET', request, new Cache(), {
+        const fetchMock = vi.fn(async () => jsonFetchResponse({ ok: false }, 207));
+        vi.stubGlobal('fetch', fetchMock);
+        const requestor = createBatchedRequestor({
             canBatch: () => 'team',
             batchInput: (inputs) => ({ ids: inputs.map(getSingleId) }),
             unBatchOutput: () => [jsonResponse({ message: 'bad request' }, 400)]
@@ -98,11 +164,11 @@ describe('Requestor', () => {
         await expect(response.json()).resolves.toEqual({ message: 'bad request' });
     });
     it('rejects all queued callers when a batched fetch throws', async () => {
-        const requestMock = vi.fn(async () => {
+        const fetchMock = vi.fn(async () => {
             throw new Error('network down');
         });
-        const request = requestMock;
-        const requestor = new Requestor('/users', 'GET', request, new Cache(), {
+        vi.stubGlobal('fetch', fetchMock);
+        const requestor = createBatchedRequestor({
             canBatch: () => 'team',
             batchInput: (inputs) => ({ ids: inputs.map(getSingleId) }),
             unBatchOutput: (_inputs, output) => [output]
@@ -123,57 +189,95 @@ describe('Query', () => {
     afterEach(() => {
         vi.useRealTimers();
         vi.restoreAllMocks();
+        vi.unstubAllGlobals();
     });
     it('deduplicates concurrent requests and returns readable responses to each caller', async () => {
         const pending = deferred();
-        const requestMock = vi.fn().mockReturnValue(pending.promise);
-        const requestor = {
-            request: requestMock
-        };
+        const fetchMock = vi.fn().mockReturnValue(pending.promise);
+        vi.stubGlobal('fetch', fetchMock);
         const query = new Query({
             path: '/users',
             method: 'GET',
             input: { id: 1 },
-            requestor,
+            requestor: createPlainRequestor(),
             cache: new Cache()
         });
         const p1 = query.request();
         const p2 = query.request();
-        expect(requestMock).toHaveBeenCalledTimes(1);
-        pending.resolve(jsonResponse({ id: 1 }));
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        pending.resolve(jsonFetchResponse({ id: 1 }));
         const [response1, response2] = await Promise.all([p1, p2]);
         await expect(response1.json()).resolves.toEqual({ id: 1 });
         await expect(response2.json()).resolves.toEqual({ id: 1 });
     });
-    it('caches responses and returns a fresh readable clone on cache hits', async () => {
-        const requestMock = vi.fn().mockResolvedValue(jsonResponse({ id: 1, name: 'Ada' }));
-        const requestor = {
-            request: requestMock
-        };
+    it('caches responses and returns readable responses on cache hits', async () => {
+        const fetchMock = vi.fn(async () => jsonFetchResponse({ id: 1, name: 'Ada' }));
+        vi.stubGlobal('fetch', fetchMock);
         const query = new Query({
             path: '/users',
             method: 'GET',
             input: { id: 1 },
-            requestor,
+            requestor: createPlainRequestor(),
             cache: new Cache()
         });
         const first = await query.request();
         const second = await query.request();
-        expect(requestMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
         expect(query.isCached).toBe(true);
         await expect(first.json()).resolves.toEqual({ id: 1, name: 'Ada' });
         await expect(second.json()).resolves.toEqual({ id: 1, name: 'Ada' });
     });
+    it('preserves devalue parsing for query state, returned responses, and cache hits', async () => {
+        const fetchMock = vi.fn(async () => devalueFetchResponse({ id: 1, createdAt: new Date('2024-01-01T00:00:00.000Z') }));
+        vi.stubGlobal('fetch', fetchMock);
+        const query = new Query({
+            path: '/users',
+            method: 'GET',
+            input: { id: 1 },
+            requestor: createPlainRequestor(),
+            cache: new Cache()
+        });
+        const firstResponse = await query.request();
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(query.status).toBe('success');
+        expect(query.data).toEqual({ id: 1, createdAt: new Date('2024-01-01T00:00:00.000Z') });
+        await expect(firstResponse.json()).resolves.toEqual({
+            id: 1,
+            createdAt: new Date('2024-01-01T00:00:00.000Z')
+        });
+        const cachedResponse = await query.request();
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        await expect(cachedResponse.json()).resolves.toEqual({
+            id: 1,
+            createdAt: new Date('2024-01-01T00:00:00.000Z')
+        });
+    });
+    it('preserves arbitrary response overrides across query responses and cache hits', async () => {
+        const fetchMock = vi.fn(async () => withResponseOverrides(jsonFetchResponse({ id: 1 })));
+        vi.stubGlobal('fetch', fetchMock);
+        const query = new Query({
+            path: '/users',
+            method: 'GET',
+            input: { id: 1 },
+            requestor: createPlainRequestor(),
+            cache: new Cache()
+        });
+        const first = (await query.request());
+        const second = (await query.request());
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(first.extra()).toBe('copied');
+        expect(first.meta).toEqual({ source: 'custom' });
+        expect(second.extra()).toBe('copied');
+        expect(second.meta).toEqual({ source: 'custom' });
+    });
     it('updates success state from successful responses', async () => {
-        const requestMock = vi.fn().mockResolvedValue(jsonResponse({ id: 1, active: true }));
-        const requestor = {
-            request: requestMock
-        };
+        const fetchMock = vi.fn(async () => jsonFetchResponse({ id: 1, active: true }));
+        vi.stubGlobal('fetch', fetchMock);
         const query = new Query({
             path: '/users',
             method: 'GET',
             input: { id: 1 },
-            requestor,
+            requestor: createPlainRequestor(),
             cache: new Cache()
         });
         const response = await query.request();
@@ -183,15 +287,13 @@ describe('Query', () => {
         await expect(response.json()).resolves.toEqual({ id: 1, active: true });
     });
     it('updates error state from error responses without throwing', async () => {
-        const requestMock = vi.fn().mockResolvedValue(jsonResponse({ message: 'missing' }, 404));
-        const requestor = {
-            request: requestMock
-        };
+        const fetchMock = vi.fn(async () => jsonFetchResponse({ message: 'missing' }, 404));
+        vi.stubGlobal('fetch', fetchMock);
         const query = new Query({
             path: '/users',
             method: 'GET',
             input: { id: 99 },
-            requestor,
+            requestor: createPlainRequestor(),
             cache: new Cache()
         });
         const response = await query.request();
@@ -202,62 +304,66 @@ describe('Query', () => {
         await expect(response.json()).resolves.toEqual({ message: 'missing' });
     });
     it('clears the pending request when the request throws so later retries can succeed', async () => {
-        const requestMock = vi
-            .fn()
-            .mockRejectedValueOnce(new Error('network down'))
-            .mockResolvedValueOnce(jsonResponse({ id: 1, recovered: true }));
-        const requestor = {
-            request: requestMock
-        };
+        let callCount = 0;
+        const fetchMock = vi.fn(async () => {
+            callCount += 1;
+            if (callCount === 1) {
+                throw new Error('network down');
+            }
+            return jsonFetchResponse({ id: 1, recovered: true });
+        });
+        vi.stubGlobal('fetch', fetchMock);
         const query = new Query({
             path: '/users',
             method: 'GET',
             input: { id: 1 },
-            requestor,
+            requestor: createPlainRequestor(),
             cache: new Cache()
         });
         await expect(query.request()).rejects.toThrow('network down');
         expect(query.status).toBe('error');
-        const response = await query.request();
-        expect(requestMock).toHaveBeenCalledTimes(2);
+        const responsePromise = query.request();
+        await vi.advanceTimersByTimeAsync(100);
+        const response = await responsePromise;
+        expect(fetchMock).toHaveBeenCalledTimes(2);
         expect(query.status).toBe('success');
         await expect(response.json()).resolves.toEqual({ id: 1, recovered: true });
     });
     it('resetCache forces the next request to fetch again', async () => {
-        const requestMock = vi
-            .fn()
-            .mockResolvedValueOnce(jsonResponse({ call: 1 }))
-            .mockResolvedValueOnce(jsonResponse({ call: 2 }));
-        const requestor = {
-            request: requestMock
-        };
+        let callCount = 0;
+        const fetchMock = vi.fn(async () => {
+            callCount += 1;
+            return jsonFetchResponse({ call: callCount });
+        });
+        vi.stubGlobal('fetch', fetchMock);
         const query = new Query({
             path: '/users',
             method: 'GET',
             input: { id: 1 },
-            requestor,
+            requestor: createPlainRequestor(),
             cache: new Cache()
         });
         const first = await query.request();
         query.resetCache();
-        const second = await query.request();
-        expect(requestMock).toHaveBeenCalledTimes(2);
+        const secondPromise = query.request();
+        await vi.advanceTimersByTimeAsync(100);
+        const second = await secondPromise;
+        expect(fetchMock).toHaveBeenCalledTimes(2);
         await expect(first.json()).resolves.toEqual({ call: 1 });
         await expect(second.json()).resolves.toEqual({ call: 2 });
     });
     it('honors custom cache timeout options', async () => {
-        const requestMock = vi
-            .fn()
-            .mockResolvedValueOnce(jsonResponse({ call: 1 }))
-            .mockResolvedValueOnce(jsonResponse({ call: 2 }));
-        const requestor = {
-            request: requestMock
-        };
+        let callCount = 0;
+        const fetchMock = vi.fn(async () => {
+            callCount += 1;
+            return jsonFetchResponse({ call: callCount });
+        });
+        vi.stubGlobal('fetch', fetchMock);
         const query = new Query({
             path: '/users',
             method: 'GET',
             input: { id: 1 },
-            requestor,
+            requestor: createPlainRequestor(),
             cache: new Cache(),
             opts: {
                 cache: { timeout: 50 }
@@ -267,8 +373,10 @@ describe('Query', () => {
         vi.advanceTimersByTime(49);
         const cached = await query.request();
         vi.advanceTimersByTime(1);
-        const refreshed = await query.request();
-        expect(requestMock).toHaveBeenCalledTimes(2);
+        const refreshedPromise = query.request();
+        await vi.advanceTimersByTimeAsync(50);
+        const refreshed = await refreshedPromise;
+        expect(fetchMock).toHaveBeenCalledTimes(2);
         await expect(first.json()).resolves.toEqual({ call: 1 });
         await expect(cached.json()).resolves.toEqual({ call: 1 });
         await expect(refreshed.json()).resolves.toEqual({ call: 2 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-ag",
-  "version": "1.0.58",
+  "version": "1.0.60",
   "description": "Useful svelte components",
   "bugs": "https://github.com/ageorgeh/svelte-ag/issues",
   "repository": {
@@ -41,8 +41,7 @@
     "svelte:sync": "svelte-kit sync",
     "test": "vitest --run",
     "test:e2e": "playwright test",
-    "test:e2e:ui": "playwright test --ui",
-    "test:e2e:update": "playwright test --update-snapshots",
+    "test:e2e-local": "PW_TEST_CONNECT_WS_ENDPOINT=ws://127.0.0.1:3005/ pnpm test:e2e",
     "watch": "svelte-package -i src -w"
   },
   "dependencies": {
@@ -71,7 +70,7 @@
     "@iconify/types": "^2.0.0",
     "@internationalized/date": "^3.12.0",
     "@lucide/svelte": "^1.7.0",
-    "@playwright/test": "1.57.0",
+    "@playwright/test": "1.58.2",
     "@sveltejs/kit": "^2.55.0",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",

package/src/lib/api/query/entrypoint.unit.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { ApiEndpoints, ApiRequestFunction } from 'ts-ag';
+import { createApiRequest, type ApiEndpoints } from 'ts-ag';
+import * as v from 'valibot';
 
 type TestResponse = ApiEndpoints['response'];
 
@@ -8,23 +9,29 @@ type BatchedInput = { ids: number[] };
 
 type UsersApi = {
   path: '/users';
-  method: 'GET';
+  method: 'POST';
   requestInput: UserInput | BatchedInput;
   requestOutput: null;
   response: TestResponse;
 };
 
-type UsersRequest = ApiRequestFunction<UsersApi>;
+const API_URL = 'https://api.example.test';
+
+const schemas = {
+  '/users': {
+    POST: v.union([v.object({ id: v.number(), group: v.optional(v.string()) }), v.object({ ids: v.array(v.number()) })])
+  }
+};
 
 function getUserId(input: UsersApi['requestInput']): number {
   return 'id' in input ? input.id : input.ids[0]!;
 }
 
-function jsonResponse(body: unknown, status = 200): TestResponse {
+function jsonFetchResponse(body: unknown, status = 200): Response {
   return new Response(JSON.stringify(body), {
     status,
     headers: { 'content-type': 'application/json' }
-  }) as TestResponse;
+  });
 }
 
 describe('createQueryFunction', () => {
@@ -37,17 +44,17 @@ describe('createQueryFunction', () => {
   afterEach(() => {
     vi.useRealTimers();
     vi.restoreAllMocks();
+    vi.unstubAllGlobals();
   });
 
   it('returns the same query instance for the same path, method, and input', async () => {
     const { createQueryFunction } = await import('./entrypoint.svelte.js');
-    const requestMock = vi.fn(async () => jsonResponse({ ok: true }));
-    const request = requestMock as unknown as UsersRequest;
+    const request = createApiRequest<UsersApi>(schemas, API_URL, 'test');
     const createQuery = createQueryFunction<UsersApi>(request, {});
 
-    const query1 = createQuery('/users', 'GET', { id: 1 });
-    const query2 = createQuery('/users', 'GET', { id: 1 });
-    const query3 = createQuery('/users', 'GET', { id: 2 });
+    const query1 = createQuery('/users', 'POST', { id: 1 });
+    const query2 = createQuery('/users', 'POST', { id: 1 });
+    const query3 = createQuery('/users', 'POST', { id: 2 });
 
     expect(query1).toBe(query2);
     expect(query3).not.toBe(query1);
@@ -55,31 +62,44 @@ describe('createQueryFunction', () => {
 
   it('reuses requestors so separate queries can batch together', async () => {
     const { createQueryFunction } = await import('./entrypoint.svelte.js');
-    const requestMock = vi.fn(async () => jsonResponse({ ok: true }));
-    const request = requestMock as unknown as UsersRequest;
+    const fetchMock = vi.fn(async () => jsonFetchResponse({ 1: 'one', 2: 'two' }));
+    vi.stubGlobal('fetch', fetchMock);
+    vi.stubGlobal('fetch', fetchMock);
+    const request = createApiRequest<UsersApi>(schemas, API_URL, 'test');
     const createQuery = createQueryFunction<UsersApi>(request, {
       '/users': {
-        GET: {
+        POST: {
           canBatch: () => 'users',
           batchInput: (inputs) => ({ ids: inputs.map(getUserId) }),
-          unBatchOutput: (inputs) => inputs.map((input) => jsonResponse({ id: getUserId(input) }))
+          unBatchOutput: async (inputs, outputs) => {
+            return inputs.map(() => {
+              return outputs;
+            });
+          }
         }
       }
     });
 
-    const query1 = createQuery('/users', 'GET', { id: 1 });
-    const query2 = createQuery('/users', 'GET', { id: 2 });
+    const query1 = createQuery('/users', 'POST', { id: 1 });
+    const query2 = createQuery('/users', 'POST', { id: 2 });
 
     const p1 = query1.request();
     const p2 = query2.request();
 
     await vi.advanceTimersByTimeAsync(100);
 
-    expect(requestMock).toHaveBeenCalledTimes(1);
-    expect(requestMock).toHaveBeenCalledWith('/users', 'GET', { ids: [1, 2] });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      `${API_URL}//users`,
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({ ids: [1, 2] }),
+        credentials: 'include'
+      })
+    );
 
     const [response1, response2] = await Promise.all([p1, p2]);
-    await expect(response1.json()).resolves.toEqual({ id: 1 });
-    await expect(response2.json()).resolves.toEqual({ id: 2 });
+    await expect(response1.json()).resolves.toEqual({ 1: 'one', 2: 'two' });
+    await expect(response2.json()).resolves.toEqual({ 1: 'one', 2: 'two' });
   });
 });

package/src/lib/api/query/query.svelte.ts

@@ -9,19 +9,6 @@ import { RateLimiter } from './rate.svelte';
 
 export type QueryStatus = 'idle' | 'loading' | 'success' | 'error';
 
-function cloneResponse<T>(response: T): T {
-  if (
-    response !== null &&
-    typeof response === 'object' &&
-    'clone' in response &&
-    typeof response.clone === 'function'
-  ) {
-    return response.clone();
-  }
-
-  return response;
-}
-
 export class Query<
   API extends ApiEndpoints,
   Path extends API['path'],
@@ -85,7 +72,7 @@ export class Query<
   async request(): Promise<ApiResponse<API, Path, Method>> {
     const cachedValue = this.#cache.get(this.#cacheKey);
     if (cachedValue !== null) {
-      return cloneResponse(cachedValue);
+      return cachedValue;
     }
 
     this.#status = 'loading';
@@ -104,9 +91,9 @@ export class Query<
       this.#pendingRequest = null;
     }
 
-    const responseForState = cloneResponse(res);
-    const responseForCaller = cloneResponse(res);
-    this.#cache.set(this.#cacheKey, cloneResponse(res));
+    const responseForState = res;
+    const responseForCaller = res;
+    this.#cache.set(this.#cacheKey, res);
 
     if (responseForState.ok === false) {
       const body = await responseForState.json();
@@ -211,6 +198,8 @@ export class Requestor<
   private async flushBatchQueue(batchId: string): Promise<void> {
     const queue = this.#batchQueue[batchId].splice(0);
 
+    // TODO maybe remove the unBatchOutput function and just always return the
+    // same response and then its on each consumer of each query to find the relevant records
     try {
       const batchedInput = this.#batchInput(queue.map((q) => q.input));
 
@@ -240,8 +229,8 @@ export class Requestor<
     if (batchId !== false) {
       return new Promise((resolve, reject) => {
         if (!this.#batchQueue[batchId]) this.#batchQueue[batchId] = [];
-
         this.#batchQueue[batchId].push({ input, resolve, reject });
+
         if (!this.#batchTimers[batchId]) {
           this.#batchTimers[batchId] = setTimeout(() => {
             void this.flushBatchQueue(batchId).finally(() => {

package/src/lib/api/query/query.unit.test.ts

@@ -1,7 +1,9 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { ApiEndpoints, ApiRequestFunction } from 'ts-ag';
+import { createApiRequest, type ApiEndpoints } from 'ts-ag';
 import { Cache } from './cache.svelte.js';
 import { Query, Requestor } from './query.svelte.js';
+import { stringify } from 'devalue';
+import * as v from 'valibot';
 
 type PlainUserInput = { id: number };
 type BatchedUserInput = { id: number; group?: string };
@@ -19,25 +21,67 @@ type PlainUsersApi = {
 
 type BatchedUsersApi = {
   path: '/users';
-  method: 'GET';
+  method: 'POST';
   requestInput: BatchedUserInput | BatchedRequestInput;
   requestOutput: null;
   response: TestResponse;
 };
 
-type PlainUsersRequestor = Requestor<PlainUsersApi, '/users', 'GET'>;
-type PlainUsersRequest = ApiRequestFunction<PlainUsersApi>;
-type BatchedUsersRequest = ApiRequestFunction<BatchedUsersApi>;
+const API_URL = 'https://api.example.test';
+
+const plainSchemas = {
+  '/users': {
+    GET: v.object({ id: v.number() })
+  }
+};
+
+const batchedSchemas = {
+  '/users': {
+    POST: v.union([v.object({ id: v.number(), group: v.optional(v.string()) }), v.object({ ids: v.array(v.number()) })])
+  }
+};
 
 function getSingleId(input: BatchedUsersApi['requestInput']): number {
   return 'id' in input ? input.id : input.ids[0]!;
 }
 
-function jsonResponse(body: unknown, status = 200): TestResponse {
+function jsonFetchResponse(body: unknown, status = 200): Response {
   return new Response(JSON.stringify(body), {
     status,
     headers: { 'content-type': 'application/json' }
-  }) as TestResponse;
+  });
+}
+
+function jsonResponse(body: unknown, status = 200): TestResponse {
+  return jsonFetchResponse(body, status) as TestResponse;
+}
+
+function devalueFetchResponse(body: unknown, status = 200): Response {
+  return new Response(stringify(body), {
+    status,
+    headers: { 'content-type': 'application/devalue' }
+  });
+}
+
+function withResponseOverrides<T extends Response>(
+  response: T
+): T & {
+  extra: () => string;
+  meta: { source: string };
+} {
+  Object.defineProperty(response, 'extra', {
+    configurable: true,
+    value: () => 'copied'
+  });
+  Object.defineProperty(response, 'meta', {
+    configurable: true,
+    value: { source: 'custom' }
+  });
+
+  return response as T & {
+    extra: () => string;
+    meta: { source: string };
+  };
 }
 
 function deferred<T>() {
@@ -51,6 +95,30 @@ function deferred<T>() {
   return { promise, resolve, reject };
 }
 
+function createPlainRequest() {
+  return createApiRequest<PlainUsersApi>(plainSchemas, API_URL, 'test');
+}
+
+function createBatchedRequest() {
+  return createApiRequest<BatchedUsersApi>(batchedSchemas, API_URL, 'test');
+}
+
+function createPlainRequestor() {
+  return new Requestor<PlainUsersApi, '/users', 'GET'>('/users', 'GET', createPlainRequest(), new Cache());
+}
+
+function createBatchedRequestor(
+  batchDetails?: ConstructorParameters<typeof Requestor<BatchedUsersApi, '/users', 'POST'>>[4]
+) {
+  return new Requestor<BatchedUsersApi, '/users', 'POST'>(
+    '/users',
+    'POST',
+    createBatchedRequest(),
+    new Cache(),
+    batchDetails
+  );
+}
+
 describe('Requestor', () => {
   beforeEach(() => {
     vi.useFakeTimers();
@@ -60,24 +128,49 @@ describe('Requestor', () => {
   afterEach(() => {
     vi.useRealTimers();
     vi.restoreAllMocks();
+    vi.unstubAllGlobals();
   });
 
   it('passes through non-batched requests', async () => {
-    const requestMock = vi.fn(async () => jsonResponse({ id: 1 }));
-    const request = requestMock as unknown as PlainUsersRequest;
-    const requestor = new Requestor<PlainUsersApi, '/users', 'GET'>('/users', 'GET', request, new Cache());
+    const fetchMock = vi.fn(async () => jsonFetchResponse({ id: 1 }));
+    vi.stubGlobal('fetch', fetchMock);
+    const requestor = createPlainRequestor();
+
+    const response = await requestor.request({ id: 1 });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      `${API_URL}//users?id=1`,
+      expect.objectContaining({
+        method: 'GET',
+        credentials: 'include'
+      })
+    );
+    await expect(response.json()).resolves.toEqual({ id: 1 });
+  });
+
+  it('devalue response', async () => {
+    const fetchMock = vi.fn(async () => devalueFetchResponse({ id: 1 }));
+    vi.stubGlobal('fetch', fetchMock);
+    const requestor = createPlainRequestor();
 
     const response = await requestor.request({ id: 1 });
 
-    expect(requestMock).toHaveBeenCalledTimes(1);
-    expect(requestMock).toHaveBeenCalledWith('/users', 'GET', { id: 1 });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      `${API_URL}//users?id=1`,
+      expect.objectContaining({
+        method: 'GET',
+        credentials: 'include'
+      })
+    );
     await expect(response.json()).resolves.toEqual({ id: 1 });
   });
 
   it('batches requests with the same batch id and preserves response order', async () => {
-    const requestMock = vi.fn(async () => jsonResponse({ ok: true }));
-    const request = requestMock as unknown as BatchedUsersRequest;
-    const requestor = new Requestor<BatchedUsersApi, '/users', 'GET'>('/users', 'GET', request, new Cache(), {
+    const fetchMock = vi.fn(async () => jsonFetchResponse({ ok: true }));
+    vi.stubGlobal('fetch', fetchMock);
+    const requestor = createBatchedRequestor({
       canBatch: (input) => ('group' in input && input.group) || false,
       batchInput: (inputs) => ({ ids: inputs.map(getSingleId) }),
       unBatchOutput: (inputs) => inputs.map((input) => jsonResponse({ id: getSingleId(input) }))
@@ -87,11 +180,18 @@ describe('Requestor', () => {
     const p2 = requestor.request({ id: 2, group: 'team' });
 
     await vi.advanceTimersByTimeAsync(99);
-    expect(requestMock).not.toHaveBeenCalled();
+    expect(fetchMock).not.toHaveBeenCalled();
 
     await vi.advanceTimersByTimeAsync(1);
-    expect(requestMock).toHaveBeenCalledTimes(1);
-    expect(requestMock).toHaveBeenCalledWith('/users', 'GET', { ids: [1, 2] });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      `${API_URL}//users`,
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({ ids: [1, 2] }),
+        credentials: 'include'
+      })
+    );
 
     const [response1, response2] = await Promise.all([p1, p2]);
     await expect(response1.json()).resolves.toEqual({ id: 1 });
@@ -100,18 +200,17 @@ describe('Requestor', () => {
 
   it('rate limits separate batches by start time rather than completion time', async () => {
     const starts: number[] = [];
-    const requestMock = vi.fn(async (_path: '/users', _method: 'GET', input: BatchedUsersApi['requestInput']) => {
+    const fetchMock = vi.fn(async (_url: string, init?: RequestInit) => {
       starts.push(Date.now());
 
-      if ('ids' in input && input.ids[0] === 1) {
+      if (init?.body === JSON.stringify({ ids: [1] })) {
         await new Promise((resolve) => setTimeout(resolve, 200));
       }
 
-      return jsonResponse({ ids: 'ids' in input ? input.ids : [input.id] });
+      return jsonFetchResponse({ ok: true });
     });
-    const request = requestMock as unknown as BatchedUsersRequest;
-
-    const requestor = new Requestor<BatchedUsersApi, '/users', 'GET'>('/users', 'GET', request, new Cache(), {
+    vi.stubGlobal('fetch', fetchMock);
+    const requestor = createBatchedRequestor({
       canBatch: (input) => ('group' in input && input.group) || false,
       batchInput: (inputs) => ({ ids: inputs.map(getSingleId) }),
       unBatchOutput: (_inputs, output) => [output]
@@ -129,14 +228,14 @@ describe('Requestor', () => {
     await vi.runAllTimersAsync();
 
     const [response1, response2] = await Promise.all([p1, p2]);
-    await expect(response1.json()).resolves.toEqual({ ids: [1] });
-    await expect(response2.json()).resolves.toEqual({ ids: [2] });
+    await expect(response1.json()).resolves.toEqual({ ok: true });
+    await expect(response2.json()).resolves.toEqual({ ok: true });
   });
 
   it('returns batched error responses without rejecting them', async () => {
-    const requestMock = vi.fn(async () => jsonResponse({ ok: false }, 207));
-    const request = requestMock as unknown as BatchedUsersRequest;
-    const requestor = new Requestor<BatchedUsersApi, '/users', 'GET'>('/users', 'GET', request, new Cache(), {
+    const fetchMock = vi.fn(async () => jsonFetchResponse({ ok: false }, 207));
+    vi.stubGlobal('fetch', fetchMock);
+    const requestor = createBatchedRequestor({
       canBatch: () => 'team',
       batchInput: (inputs) => ({ ids: inputs.map(getSingleId) }),
       unBatchOutput: () => [jsonResponse({ message: 'bad request' }, 400)]
@@ -153,11 +252,11 @@ describe('Requestor', () => {
   });
 
   it('rejects all queued callers when a batched fetch throws', async () => {
-    const requestMock = vi.fn(async () => {
+    const fetchMock = vi.fn(async () => {
       throw new Error('network down');
     });
-    const request = requestMock as unknown as BatchedUsersRequest;
-    const requestor = new Requestor<BatchedUsersApi, '/users', 'GET'>('/users', 'GET', request, new Cache(), {
+    vi.stubGlobal('fetch', fetchMock);
+    const requestor = createBatchedRequestor({
       canBatch: () => 'team',
       batchInput: (inputs) => ({ ids: inputs.map(getSingleId) }),
       unBatchOutput: (_inputs, output) => [output]
@@ -183,69 +282,120 @@ describe('Query', () => {
   afterEach(() => {
     vi.useRealTimers();
     vi.restoreAllMocks();
+    vi.unstubAllGlobals();
   });
 
   it('deduplicates concurrent requests and returns readable responses to each caller', async () => {
     const pending = deferred<Response>();
-    const requestMock = vi.fn().mockReturnValue(pending.promise);
-    const requestor = {
-      request: requestMock as PlainUsersRequest
-    } as unknown as PlainUsersRequestor;
-
+    const fetchMock = vi.fn().mockReturnValue(pending.promise);
+    vi.stubGlobal('fetch', fetchMock);
     const query = new Query<PlainUsersApi, '/users', 'GET'>({
       path: '/users',
       method: 'GET',
       input: { id: 1 },
-      requestor,
+      requestor: createPlainRequestor(),
       cache: new Cache()
     });
 
     const p1 = query.request();
     const p2 = query.request();
 
-    expect(requestMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
 
-    pending.resolve(jsonResponse({ id: 1 }));
+    pending.resolve(jsonFetchResponse({ id: 1 }));
 
     const [response1, response2] = await Promise.all([p1, p2]);
     await expect(response1.json()).resolves.toEqual({ id: 1 });
     await expect(response2.json()).resolves.toEqual({ id: 1 });
   });
 
-  it('caches responses and returns a fresh readable clone on cache hits', async () => {
-    const requestMock = vi.fn().mockResolvedValue(jsonResponse({ id: 1, name: 'Ada' }));
-    const requestor = {
-      request: requestMock as PlainUsersRequest
-    } as unknown as PlainUsersRequestor;
-
+  it('caches responses and returns readable responses on cache hits', async () => {
+    const fetchMock = vi.fn(async () => jsonFetchResponse({ id: 1, name: 'Ada' }));
+    vi.stubGlobal('fetch', fetchMock);
     const query = new Query<PlainUsersApi, '/users', 'GET'>({
       path: '/users',
       method: 'GET',
       input: { id: 1 },
-      requestor,
+      requestor: createPlainRequestor(),
       cache: new Cache()
     });
 
     const first = await query.request();
     const second = await query.request();
 
-    expect(requestMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
     expect(query.isCached).toBe(true);
     await expect(first.json()).resolves.toEqual({ id: 1, name: 'Ada' });
     await expect(second.json()).resolves.toEqual({ id: 1, name: 'Ada' });
   });
 
-  it('updates success state from successful responses', async () => {
-    const requestMock = vi.fn().mockResolvedValue(jsonResponse({ id: 1, active: true }));
-    const requestor = {
-      request: requestMock as PlainUsersRequest
-    } as unknown as PlainUsersRequestor;
+  it('preserves devalue parsing for query state, returned responses, and cache hits', async () => {
+    const fetchMock = vi.fn(async () =>
+      devalueFetchResponse({ id: 1, createdAt: new Date('2024-01-01T00:00:00.000Z') })
+    );
+    vi.stubGlobal('fetch', fetchMock);
+    const query = new Query<PlainUsersApi, '/users', 'GET'>({
+      path: '/users',
+      method: 'GET',
+      input: { id: 1 },
+      requestor: createPlainRequestor(),
+      cache: new Cache()
+    });
+
+    const firstResponse = await query.request();
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(query.status).toBe('success');
+    expect(query.data).toEqual({ id: 1, createdAt: new Date('2024-01-01T00:00:00.000Z') });
+    await expect(firstResponse.json()).resolves.toEqual({
+      id: 1,
+      createdAt: new Date('2024-01-01T00:00:00.000Z')
+    });
 
+    const cachedResponse = await query.request();
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    await expect(cachedResponse.json()).resolves.toEqual({
+      id: 1,
+      createdAt: new Date('2024-01-01T00:00:00.000Z')
+    });
+  });
+
+  it('preserves arbitrary response overrides across query responses and cache hits', async () => {
+    const fetchMock = vi.fn(async () => withResponseOverrides(jsonFetchResponse({ id: 1 })));
+    vi.stubGlobal('fetch', fetchMock);
     const query = new Query<PlainUsersApi, '/users', 'GET'>({
       path: '/users',
       method: 'GET',
       input: { id: 1 },
-      requestor,
+      requestor: createPlainRequestor(),
+      cache: new Cache()
+    });
+
+    const first = (await query.request()) as Response & {
+      extra: () => string;
+      meta: { source: string };
+    };
+    const second = (await query.request()) as Response & {
+      extra: () => string;
+      meta: { source: string };
+    };
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(first.extra()).toBe('copied');
+    expect(first.meta).toEqual({ source: 'custom' });
+    expect(second.extra()).toBe('copied');
+    expect(second.meta).toEqual({ source: 'custom' });
+  });
+
+  it('updates success state from successful responses', async () => {
+    const fetchMock = vi.fn(async () => jsonFetchResponse({ id: 1, active: true }));
+    vi.stubGlobal('fetch', fetchMock);
+    const query = new Query<PlainUsersApi, '/users', 'GET'>({
+      path: '/users',
+      method: 'GET',
+      input: { id: 1 },
+      requestor: createPlainRequestor(),
       cache: new Cache()
     });
 
@@ -258,16 +408,13 @@ describe('Query', () => {
   });
 
   it('updates error state from error responses without throwing', async () => {
-    const requestMock = vi.fn().mockResolvedValue(jsonResponse({ message: 'missing' }, 404));
-    const requestor = {
-      request: requestMock as PlainUsersRequest
-    } as unknown as PlainUsersRequestor;
-
+    const fetchMock = vi.fn(async () => jsonFetchResponse({ message: 'missing' }, 404));
+    vi.stubGlobal('fetch', fetchMock);
     const query = new Query<PlainUsersApi, '/users', 'GET'>({
       path: '/users',
       method: 'GET',
       input: { id: 99 },
-      requestor,
+      requestor: createPlainRequestor(),
       cache: new Cache()
     });
 
@@ -281,72 +428,75 @@ describe('Query', () => {
   });
 
   it('clears the pending request when the request throws so later retries can succeed', async () => {
-    const requestMock = vi
-      .fn()
-      .mockRejectedValueOnce(new Error('network down'))
-      .mockResolvedValueOnce(jsonResponse({ id: 1, recovered: true }));
-    const requestor = {
-      request: requestMock as PlainUsersRequest
-    } as unknown as PlainUsersRequestor;
+    let callCount = 0;
+    const fetchMock = vi.fn(async () => {
+      callCount += 1;
+
+      if (callCount === 1) {
+        throw new Error('network down');
+      }
 
+      return jsonFetchResponse({ id: 1, recovered: true });
+    });
+    vi.stubGlobal('fetch', fetchMock);
     const query = new Query<PlainUsersApi, '/users', 'GET'>({
       path: '/users',
       method: 'GET',
       input: { id: 1 },
-      requestor,
+      requestor: createPlainRequestor(),
       cache: new Cache()
     });
 
     await expect(query.request()).rejects.toThrow('network down');
     expect(query.status).toBe('error');
 
-    const response = await query.request();
+    const responsePromise = query.request();
+    await vi.advanceTimersByTimeAsync(100);
+    const response = await responsePromise;
 
-    expect(requestMock).toHaveBeenCalledTimes(2);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
     expect(query.status).toBe('success');
     await expect(response.json()).resolves.toEqual({ id: 1, recovered: true });
   });
 
   it('resetCache forces the next request to fetch again', async () => {
-    const requestMock = vi
-      .fn()
-      .mockResolvedValueOnce(jsonResponse({ call: 1 }))
-      .mockResolvedValueOnce(jsonResponse({ call: 2 }));
-    const requestor = {
-      request: requestMock as PlainUsersRequest
-    } as unknown as PlainUsersRequestor;
-
+    let callCount = 0;
+    const fetchMock = vi.fn(async () => {
+      callCount += 1;
+      return jsonFetchResponse({ call: callCount });
+    });
+    vi.stubGlobal('fetch', fetchMock);
     const query = new Query<PlainUsersApi, '/users', 'GET'>({
       path: '/users',
       method: 'GET',
       input: { id: 1 },
-      requestor,
+      requestor: createPlainRequestor(),
       cache: new Cache()
     });
 
     const first = await query.request();
     query.resetCache();
-    const second = await query.request();
+    const secondPromise = query.request();
+    await vi.advanceTimersByTimeAsync(100);
+    const second = await secondPromise;
 
-    expect(requestMock).toHaveBeenCalledTimes(2);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
     await expect(first.json()).resolves.toEqual({ call: 1 });
     await expect(second.json()).resolves.toEqual({ call: 2 });
   });
 
   it('honors custom cache timeout options', async () => {
-    const requestMock = vi
-      .fn()
-      .mockResolvedValueOnce(jsonResponse({ call: 1 }))
-      .mockResolvedValueOnce(jsonResponse({ call: 2 }));
-    const requestor = {
-      request: requestMock as PlainUsersRequest
-    } as unknown as PlainUsersRequestor;
-
+    let callCount = 0;
+    const fetchMock = vi.fn(async () => {
+      callCount += 1;
+      return jsonFetchResponse({ call: callCount });
+    });
+    vi.stubGlobal('fetch', fetchMock);
     const query = new Query<PlainUsersApi, '/users', 'GET'>({
       path: '/users',
       method: 'GET',
       input: { id: 1 },
-      requestor,
+      requestor: createPlainRequestor(),
       cache: new Cache(),
       opts: {
         cache: { timeout: 50 }
@@ -357,9 +507,11 @@ describe('Query', () => {
     vi.advanceTimersByTime(49);
     const cached = await query.request();
     vi.advanceTimersByTime(1);
-    const refreshed = await query.request();
+    const refreshedPromise = query.request();
+    await vi.advanceTimersByTimeAsync(50);
+    const refreshed = await refreshedPromise;
 
-    expect(requestMock).toHaveBeenCalledTimes(2);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
     await expect(first.json()).resolves.toEqual({ call: 1 });
     await expect(cached.json()).resolves.toEqual({ call: 1 });
     await expect(refreshed.json()).resolves.toEqual({ call: 2 });