@bsv/sdk 2.0.12 → 2.0.13

package/dist/esm/src/auth/transports/__tests__/SimplifiedFetchTransport.additional.test.js

@@ -0,0 +1,619 @@
+import { jest } from '@jest/globals';
+import { SimplifiedFetchTransport } from '../SimplifiedFetchTransport.js';
+import * as Utils from '../../../primitives/utils.js';
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/** Build a serialized general message payload. */
+function buildGeneralPayload({ path = '/api/resource', method = 'GET', search = '', headers = {}, body = null } = {}) {
+    const writer = new Utils.Writer();
+    // requestId: 32 bytes
+    writer.write(new Array(32).fill(0xab));
+    // method
+    if (method.length > 0) {
+        const methodBytes = Utils.toArray(method, 'utf8');
+        writer.writeVarIntNum(methodBytes.length);
+        writer.write(methodBytes);
+    }
+    else {
+        writer.writeVarIntNum(0);
+    }
+    // path
+    if (path.length > 0) {
+        const pathBytes = Utils.toArray(path, 'utf8');
+        writer.writeVarIntNum(pathBytes.length);
+        writer.write(pathBytes);
+    }
+    else {
+        writer.writeVarIntNum(0);
+    }
+    // search
+    if (search.length > 0) {
+        const searchBytes = Utils.toArray(search, 'utf8');
+        writer.writeVarIntNum(searchBytes.length);
+        writer.write(searchBytes);
+    }
+    else {
+        writer.writeVarIntNum(0);
+    }
+    // headers
+    const headerEntries = Object.entries(headers);
+    writer.writeVarIntNum(headerEntries.length);
+    for (const [key, value] of headerEntries) {
+        const keyBytes = Utils.toArray(key, 'utf8');
+        writer.writeVarIntNum(keyBytes.length);
+        writer.write(keyBytes);
+        const valueBytes = Utils.toArray(value, 'utf8');
+        writer.writeVarIntNum(valueBytes.length);
+        writer.write(valueBytes);
+    }
+    // body
+    if (body != null && body.length > 0) {
+        writer.writeVarIntNum(body.length);
+        writer.write(body);
+    }
+    else {
+        writer.writeVarIntNum(0);
+    }
+    return writer.toArray();
+}
+function makeGeneralMessage(overrides = {}) {
+    return {
+        version: '0.1',
+        messageType: 'general',
+        identityKey: 'client-key',
+        nonce: 'cnonce',
+        yourNonce: 'snonce',
+        payload: buildGeneralPayload(),
+        signature: new Array(64).fill(0),
+        ...overrides
+    };
+}
+function makeAuthMessage(messageType, overrides = {}) {
+    return {
+        version: '0.1',
+        messageType,
+        identityKey: 'client-key',
+        nonce: 'cnonce',
+        yourNonce: 'snonce',
+        payload: [],
+        signature: new Array(64).fill(0),
+        ...overrides
+    };
+}
+/** Build a minimal valid general response (all required BSV auth headers). */
+function makeValidGeneralResponse(body = '', extraHeaders = {}) {
+    return new Response(body, {
+        status: 200,
+        headers: {
+            'x-bsv-auth-version': '0.1',
+            'x-bsv-auth-identity-key': 'server-key',
+            'x-bsv-auth-signature': 'aabbcc',
+            'x-bsv-auth-message-type': 'general',
+            ...extraHeaders
+        }
+    });
+}
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+// ─── Constructor ─────────────────────────────────────────────────────────────
+describe('SimplifiedFetchTransport constructor', () => {
+    test('throws when fetchClient is not a function', () => {
+        expect(() => new SimplifiedFetchTransport('https://example.com', 'not-a-function'))
+            .toThrow('SimplifiedFetchTransport requires a fetch implementation.');
+    });
+    test('throws when fetchClient is null', () => {
+        expect(() => new SimplifiedFetchTransport('https://example.com', null))
+            .toThrow('SimplifiedFetchTransport requires a fetch implementation.');
+    });
+    test('stores baseUrl and fetchClient', () => {
+        const mockFetch = jest.fn();
+        const transport = new SimplifiedFetchTransport('https://my.server.com', mockFetch);
+        expect(transport.baseUrl).toBe('https://my.server.com');
+        expect(transport.fetchClient).toBe(mockFetch);
+    });
+});
+// ─── send without onData registered ──────────────────────────────────────────
+describe('SimplifiedFetchTransport send without listener', () => {
+    test('throws "Listen before you start speaking" when no onData registered', async () => {
+        const mockFetch = jest.fn();
+        const transport = new SimplifiedFetchTransport('https://example.com', mockFetch);
+        // Never call onData
+        await expect(transport.send(makeGeneralMessage())).rejects.toThrow('Listen before you start speaking');
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+});
+// ─── send: non-initialRequest auth message paths ─────────────────────────────
+describe('SimplifiedFetchTransport send — non-general auth message', () => {
+    test('non-initialRequest: resolves before response arrives and still calls onDataCallback', async () => {
+        let resolveResponse;
+        const responsePromise = new Promise((res) => { resolveResponse = res; });
+        const mockFetch = jest.fn().mockReturnValue(responsePromise);
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        const received = [];
+        await transport.onData(async (msg) => { received.push(msg); });
+        const sendPromise = transport.send(makeAuthMessage('initialResponse'));
+        // resolve before the fetch response arrives to confirm promise doesn't hang
+        resolveResponse(new Response(JSON.stringify({ version: '0.1', messageType: 'initialResponse', identityKey: 'k', payload: [], signature: [] }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' }
+        }));
+        await sendPromise;
+        // Flush microtask queue so the background response processing completes
+        await new Promise(resolve => setTimeout(resolve, 0));
+        // onDataCallback should have been invoked with the response message
+        expect(received).toHaveLength(1);
+        const firstReceived = received[0];
+        expect(firstReceived).toBeDefined();
+        expect(firstReceived?.messageType).toBe('initialResponse');
+    });
+    test('initialRequest: resolves after the response is processed', async () => {
+        const responseBody = JSON.stringify({ version: '0.1', messageType: 'initialRequest', identityKey: 'server-key', payload: [], signature: [] });
+        const mockFetch = jest.fn().mockResolvedValue(new Response(responseBody, { status: 200, headers: { 'Content-Type': 'application/json' } }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        const received = [];
+        await transport.onData(async (msg) => { received.push(msg); });
+        await transport.send(makeAuthMessage('initialRequest'));
+        expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/.well-known/auth', expect.objectContaining({ method: 'POST' }));
+        expect(received).toHaveLength(1);
+    });
+    test('non-ok response on auth endpoint throws unauthenticated error', async () => {
+        const mockFetch = jest.fn().mockResolvedValue(new Response('Unauthorized', { status: 401, statusText: 'Unauthorized' }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await expect(transport.send(makeAuthMessage('initialRequest'))).rejects.toThrow('Received HTTP 401 Unauthorized from https://api.example.com/.well-known/auth without valid BSV authentication');
+    });
+    test('network failure on auth endpoint wraps error with context', async () => {
+        const mockFetch = jest.fn().mockRejectedValue(new Error('DNS lookup failed'));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await expect(transport.send(makeAuthMessage('initialRequest'))).rejects.toThrow('Network error while sending authenticated request to https://api.example.com/.well-known/auth: DNS lookup failed');
+    });
+    test('non-Error network failure still wraps as Error string', async () => {
+        const mockFetch = jest.fn().mockRejectedValue('plain string error');
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await expect(transport.send(makeAuthMessage('initialRequest'))).rejects.toThrow('Network error while sending authenticated request to https://api.example.com/.well-known/auth: plain string error');
+    });
+});
+// ─── send: general message — body Content-Type handling ──────────────────────
+describe('SimplifiedFetchTransport send — general message body handling', () => {
+    async function sendWithBody(body, contentType) {
+        const payload = buildGeneralPayload({
+            method: 'POST',
+            path: '/data',
+            headers: { 'content-type': contentType },
+            body
+        });
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse());
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await transport.send(makeGeneralMessage({ payload }));
+        return mockFetch.mock.calls[0][1]?.body;
+    }
+    test('application/json body is converted to UTF-8 string', async () => {
+        const body = Utils.toArray('{"hello":"world"}', 'utf8');
+        const payload = buildGeneralPayload({ method: 'POST', path: '/json', headers: { 'content-type': 'application/json' }, body });
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse());
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await transport.send(makeGeneralMessage({ payload }));
+        const sentBody = mockFetch.mock.calls[0][1]?.body;
+        expect(typeof sentBody).toBe('string');
+        expect(sentBody).toContain('hello');
+    });
+    test('application/x-www-form-urlencoded body is converted to UTF-8 string', async () => {
+        const body = Utils.toArray('name=Alice&age=30', 'utf8');
+        const payload = buildGeneralPayload({
+            method: 'POST',
+            path: '/form',
+            headers: { 'content-type': 'application/x-www-form-urlencoded' },
+            body
+        });
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse());
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await transport.send(makeGeneralMessage({ payload }));
+        const sentBody = mockFetch.mock.calls[0][1]?.body;
+        expect(typeof sentBody).toBe('string');
+    });
+    test('text/plain body is converted to UTF-8 string', async () => {
+        const body = Utils.toArray('hello world', 'utf8');
+        const payload = buildGeneralPayload({ method: 'POST', path: '/text', headers: { 'content-type': 'text/plain' }, body });
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse());
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await transport.send(makeGeneralMessage({ payload }));
+        const sentBody = mockFetch.mock.calls[0][1]?.body;
+        expect(typeof sentBody).toBe('string');
+        expect(sentBody).toBe('hello world');
+    });
+    test('binary content-type body is converted to Uint8Array', async () => {
+        const body = [0x89, 0x50, 0x4e, 0x47]; // PNG magic bytes
+        const payload = buildGeneralPayload({ method: 'POST', path: '/upload', headers: { 'content-type': 'image/png' }, body });
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse());
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await transport.send(makeGeneralMessage({ payload }));
+        const sentBody = mockFetch.mock.calls[0][1]?.body;
+        expect(sentBody).toBeInstanceOf(Uint8Array);
+    });
+    test('throws when body is present but content-type header is missing', async () => {
+        // No content-type header, but body present
+        const body = [1, 2, 3, 4];
+        const payload = buildGeneralPayload({ method: 'POST', path: '/no-ct', headers: {}, body });
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse());
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await expect(transport.send(makeGeneralMessage({ payload }))).rejects.toThrow('Content-Type header is required for requests with a body.');
+    });
+});
+// ─── send: general message — response header parsing ─────────────────────────
+describe('SimplifiedFetchTransport send — general message response parsing', () => {
+    test('invokes onDataCallback with parsed AuthMessage', async () => {
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse());
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        const received = [];
+        await transport.onData(async (msg) => { received.push(msg); });
+        await transport.send(makeGeneralMessage());
+        expect(received).toHaveLength(1);
+        expect(received[0].version).toBe('0.1');
+        expect(received[0].identityKey).toBe('server-key');
+        expect(received[0].messageType).toBe('general');
+    });
+    test('sets messageType to certificateRequest when x-bsv-auth-message-type is certificateRequest', async () => {
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse('', { 'x-bsv-auth-message-type': 'certificateRequest' }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        const received = [];
+        await transport.onData(async (msg) => { received.push(msg); });
+        await transport.send(makeGeneralMessage());
+        expect(received[0].messageType).toBe('certificateRequest');
+    });
+    test('parses requestedCertificates header into structured object', async () => {
+        const certSet = { certifiers: ['certKey1'], types: {} };
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse('', { 'x-bsv-auth-requested-certificates': JSON.stringify(certSet) }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        const received = [];
+        await transport.onData(async (msg) => { received.push(msg); });
+        await transport.send(makeGeneralMessage());
+        expect(received[0].requestedCertificates).toEqual(certSet);
+    });
+    test('throws on malformed requestedCertificates header', async () => {
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse('', { 'x-bsv-auth-requested-certificates': '{invalid json' }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await expect(transport.send(makeGeneralMessage())).rejects.toThrow('Failed to parse x-bsv-auth-requested-certificates');
+    });
+    test('includes x-bsv-auth-request-id in payload when present in response', async () => {
+        const requestIdBase64 = Utils.toBase64(new Array(32).fill(0xcc));
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse('', { 'x-bsv-auth-request-id': requestIdBase64 }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        const received = [];
+        await transport.onData(async (msg) => { received.push(msg); });
+        await transport.send(makeGeneralMessage());
+        expect(received[0].payload).toBeDefined();
+        expect(Array.isArray(received[0].payload)).toBe(true);
+    });
+    test('includes x-bsv (non-auth) and authorization headers in signed payload', async () => {
+        const mockFetch = jest.fn().mockResolvedValue(new Response('', {
+            status: 200,
+            headers: {
+                'x-bsv-auth-version': '0.1',
+                'x-bsv-auth-identity-key': 'server-key',
+                'x-bsv-auth-signature': 'deadbeef',
+                'x-bsv-custom-header': 'custom-value', // should be included
+                'authorization': 'Bearer token', // should be included
+                'x-bsv-auth-extra': 'excluded' // should NOT be included (x-bsv-auth prefix)
+            }
+        }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        const received = [];
+        await transport.onData(async (msg) => { received.push(msg); });
+        await transport.send(makeGeneralMessage());
+        // The payload should be non-empty (headers were serialized into it)
+        const firstReceived = received[0];
+        expect(firstReceived).toBeDefined();
+        expect(firstReceived?.payload?.length).toBeGreaterThan(0);
+    });
+    test('network failure on general message wraps error with URL context', async () => {
+        const mockFetch = jest.fn().mockRejectedValue(new Error('timeout'));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await expect(transport.send(makeGeneralMessage())).rejects.toThrow('Network error while sending authenticated request to https://api.example.com/api/resource: timeout');
+    });
+    test('non-Error network failure on general message uses String()', async () => {
+        const mockFetch = jest.fn().mockRejectedValue(42);
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await expect(transport.send(makeGeneralMessage())).rejects.toThrow('Network error while sending authenticated request to https://api.example.com/api/resource: 42');
+    });
+    test('appends headers from httpRequest when headers field is not an object', async () => {
+        // Build a payload where the deserialized httpRequest has no headers field by
+        // providing 0 headers in the encoded payload (the transport then sets headers to {})
+        const payload = buildGeneralPayload({ method: 'GET', path: '/resource', headers: {} });
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse());
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        await transport.send(makeGeneralMessage({ payload }));
+        const requestInit = mockFetch.mock.calls[0][1];
+        expect(requestInit.headers).toMatchObject({
+            'x-bsv-auth-version': '0.1',
+            'x-bsv-auth-identity-key': 'client-key'
+        });
+    });
+});
+// ─── deserializeRequestPayload ────────────────────────────────────────────────
+describe('SimplifiedFetchTransport deserializeRequestPayload', () => {
+    let transport;
+    beforeEach(() => {
+        transport = new SimplifiedFetchTransport('https://example.com', jest.fn());
+    });
+    test('returns GET and empty urlPostfix when method and path lengths are 0', () => {
+        const writer = new Utils.Writer();
+        writer.write(new Array(32).fill(0)); // requestId
+        writer.writeVarIntNum(0); // method length 0
+        writer.writeVarIntNum(0); // path length 0
+        writer.writeVarIntNum(0); // search length 0
+        writer.writeVarIntNum(0); // 0 headers
+        writer.writeVarIntNum(0); // body length 0
+        const result = transport.deserializeRequestPayload(writer.toArray());
+        expect(result.method).toBe('GET');
+        expect(result.urlPostfix).toBe('');
+        expect(result.body).toBeUndefined();
+    });
+    test('combines path and search into urlPostfix', () => {
+        const payload = buildGeneralPayload({ path: '/items', search: '?page=2', method: 'GET' });
+        const result = transport.deserializeRequestPayload(payload);
+        expect(result.urlPostfix).toBe('/items?page=2');
+    });
+    test('deserializes headers correctly', () => {
+        const payload = buildGeneralPayload({
+            headers: { 'x-custom': 'value1', 'accept': 'application/json' }
+        });
+        const result = transport.deserializeRequestPayload(payload);
+        expect(result.headers['x-custom']).toBe('value1');
+        expect(result.headers['accept']).toBe('application/json');
+    });
+    test('deserializes body when present', () => {
+        const bodyBytes = [10, 20, 30, 40];
+        const payload = buildGeneralPayload({
+            method: 'POST',
+            headers: { 'content-type': 'application/octet-stream' },
+            body: bodyBytes
+        });
+        const result = transport.deserializeRequestPayload(payload);
+        expect(result.body).toEqual(bodyBytes);
+    });
+    test('returns undefined body when body length is 0', () => {
+        const payload = buildGeneralPayload({ body: null });
+        const result = transport.deserializeRequestPayload(payload);
+        expect(result.body).toBeUndefined();
+    });
+    test('returns correct requestId as base64', () => {
+        const payload = buildGeneralPayload();
+        const result = transport.deserializeRequestPayload(payload);
+        // The requestId is the base64 of 32 bytes of 0xab
+        expect(typeof result.requestId).toBe('string');
+        expect(result.requestId.length).toBeGreaterThan(0);
+    });
+});
+// ─── onData callback registration ────────────────────────────────────────────
+describe('SimplifiedFetchTransport onData', () => {
+    test('registers callback and errors from callback are swallowed', async () => {
+        const mockFetch = jest.fn().mockResolvedValue(makeValidGeneralResponse());
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async (_msg) => {
+            throw new Error('intentional callback error');
+        });
+        // Should not throw even though callback throws
+        await expect(transport.send(makeGeneralMessage())).resolves.toBeUndefined();
+    });
+});
+// ─── getBodyPreview (via error path in unauthenticated response) ─────────────
+describe('SimplifiedFetchTransport body preview in error messages', () => {
+    test('includes text body preview in unauthenticated error', async () => {
+        const mockFetch = jest.fn();
+        mockFetch.mockResolvedValue(new Response('{"error":"forbidden"}', {
+            status: 403,
+            statusText: 'Forbidden',
+            headers: { 'Content-Type': 'application/json' }
+        }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        let caught;
+        try {
+            await transport.send(makeGeneralMessage());
+        }
+        catch (e) {
+            caught = e;
+        }
+        expect(caught).toBeDefined();
+        expect(caught.message).toContain('forbidden');
+    });
+    test('body preview is omitted when body is empty', async () => {
+        const mockFetch = jest.fn();
+        mockFetch.mockResolvedValue(new Response('', { status: 503, headers: {} }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        let caught;
+        try {
+            await transport.send(makeGeneralMessage());
+        }
+        catch (e) {
+            caught = e;
+        }
+        expect(caught.message).not.toContain('body preview');
+    });
+    test('binary body produces hex preview', async () => {
+        // Binary bytes (low printability ratio)
+        const binaryBytes = new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x80, 0x81, 0xff, 0xfe]);
+        const mockFetch = jest.fn();
+        mockFetch.mockResolvedValue(new Response(binaryBytes.buffer, {
+            status: 401,
+            headers: { 'Content-Type': 'application/octet-stream' }
+        }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        let caught;
+        try {
+            await transport.send(makeGeneralMessage());
+        }
+        catch (e) {
+            caught = e;
+        }
+        // Should contain 0x prefix from binary hex formatting
+        expect(caught.message).toContain('0x');
+    });
+    test('large body (>1024 bytes) is truncated in preview', async () => {
+        const largeBody = 'x'.repeat(2000);
+        const mockFetch = jest.fn();
+        mockFetch.mockResolvedValue(new Response(largeBody, {
+            status: 401,
+            headers: { 'Content-Type': 'text/plain' }
+        }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        let caught;
+        try {
+            await transport.send(makeGeneralMessage());
+        }
+        catch (e) {
+            caught = e;
+        }
+        expect(caught.message).toContain('truncated');
+    });
+    test('preview longer than 512 chars is truncated with ellipsis', async () => {
+        // Body that is textual and between 512 and 1024 chars (not truncated due to length, but truncated for preview)
+        const mediumBody = 'A'.repeat(600);
+        const mockFetch = jest.fn();
+        mockFetch.mockResolvedValue(new Response(mediumBody, {
+            status: 401,
+            headers: { 'Content-Type': 'text/plain' }
+        }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        let caught;
+        try {
+            await transport.send(makeGeneralMessage());
+        }
+        catch (e) {
+            caught = e;
+        }
+        expect(caught.message).toContain('…');
+    });
+    test('status description includes statusText when non-empty', async () => {
+        const mockFetch = jest.fn();
+        mockFetch.mockResolvedValue(new Response('error text', {
+            status: 422,
+            statusText: 'Unprocessable Entity',
+            headers: { 'Content-Type': 'text/plain' }
+        }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        let caught;
+        try {
+            await transport.send(makeGeneralMessage());
+        }
+        catch (e) {
+            caught = e;
+        }
+        expect(caught.message).toContain('422 Unprocessable Entity');
+    });
+    test('error details contains missingHeaders as empty array when all missing', async () => {
+        const mockFetch = jest.fn();
+        mockFetch.mockResolvedValue(new Response('body', { status: 200 }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        let caught;
+        try {
+            await transport.send(makeGeneralMessage());
+        }
+        catch (e) {
+            caught = e;
+        }
+        expect(caught.details.missingHeaders).toEqual([
+            'x-bsv-auth-version',
+            'x-bsv-auth-identity-key',
+            'x-bsv-auth-signature'
+        ]);
+    });
+});
+// ─── createMalformedHeaderError — non-Error cause ────────────────────────────
+describe('SimplifiedFetchTransport malformed header error — non-Error cause', () => {
+    test('formats error when JSON.parse throws a non-Error value (string cause)', async () => {
+        // Spy on JSON.parse to throw a string
+        const originalParse = JSON.parse;
+        jest.spyOn(JSON, 'parse').mockImplementation((text) => {
+            if (text === '{bad}')
+                throw 'string error cause';
+            return originalParse(text);
+        });
+        const mockFetch = jest.fn();
+        mockFetch.mockResolvedValue(new Response('', {
+            status: 200,
+            headers: {
+                'x-bsv-auth-version': '0.1',
+                'x-bsv-auth-identity-key': 'server-key',
+                'x-bsv-auth-signature': 'aabbcc',
+                'x-bsv-auth-requested-certificates': '{bad}'
+            }
+        }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        let caught;
+        try {
+            await transport.send(makeGeneralMessage());
+        }
+        catch (e) {
+            caught = e;
+        }
+        expect(caught).toBeDefined();
+        expect(caught.message).toContain('Failed to parse x-bsv-auth-requested-certificates');
+        expect(caught.message).toContain('string error cause');
+    });
+});
+// ─── isTextualContent heuristics ─────────────────────────────────────────────
+describe('SimplifiedFetchTransport — isTextualContent heuristics (via send response)', () => {
+    async function sendAndCatchError(body, contentType) {
+        const headers = {};
+        if (contentType != null) {
+            headers['Content-Type'] = contentType;
+        }
+        const mockFetch = jest.fn();
+        mockFetch.mockResolvedValue(new Response(body, { status: 401, headers }));
+        const transport = new SimplifiedFetchTransport('https://api.example.com', mockFetch);
+        await transport.onData(async () => { });
+        try {
+            await transport.send(makeGeneralMessage());
+            throw new Error('expected rejection');
+        }
+        catch (e) {
+            return e;
+        }
+    }
+    test('application/problem+json is treated as text', async () => {
+        const err = await sendAndCatchError('{"detail":"bad"}', 'application/problem+json');
+        expect(err.message).toContain('bad');
+    });
+    test('application/xml is treated as text', async () => {
+        const err = await sendAndCatchError('<root>value</root>', 'application/xml');
+        expect(err.message).toContain('root');
+    });
+    test('charset= in content type is treated as text', async () => {
+        const err = await sendAndCatchError('hello chars', 'application/octet-stream; charset=utf-8');
+        expect(err.message).toContain('hello chars');
+    });
+    test('null content type with mostly printable bytes is treated as text', async () => {
+        // >80% printable ASCII
+        const printableBody = 'Hello World from the server! This is all ASCII text.';
+        const err = await sendAndCatchError(printableBody, null);
+        // Should be treated as text, not binary hex
+        expect(err.message).not.toMatch(/^.*0x[0-9a-f]+/);
+    });
+    test('null content type with mostly binary bytes treated as binary', async () => {
+        // Lots of control/non-printable bytes
+        const binaryBytes = new Uint8Array(50).fill(0x01);
+        const err = await sendAndCatchError(binaryBytes.buffer, null);
+        expect(err.message).toContain('0x');
+    });
+});
+//# sourceMappingURL=SimplifiedFetchTransport.additional.test.js.map