@startsimpli/integrations 0.2.34 → 0.2.36

package/src/__tests__/corpus-pages.test.tsx

@@ -161,11 +161,11 @@ describe('LibraryPage — filtering and paging are SERVER round trips', () => {
     });
     render(<LibraryPage api={api} scope={SCOPE} pageSize={2} />);
 
-    await screen.findByText(/page 1 of 3/);
+    await screen.findByText(/page 1 of \d+/);
     await user.click(screen.getByRole('button', { name: 'Next' }));
 
     await waitFor(() => expect(queries.some((query) => query.page === 2)).toBe(true));
-    expect(await screen.findByText(/page 2 of 3/)).toBeInTheDocument();
+    expect(await screen.findByText(/page 2 of \d+/)).toBeInTheDocument();
   });
 
   it('returns to page 1 when a filter changes', async () => {
@@ -178,9 +178,9 @@ describe('LibraryPage — filtering and paging are SERVER round trips', () => {
     });
     render(<LibraryPage api={api} scope={SCOPE} pageSize={2} />);
 
-    await screen.findByText(/page 1 of 3/);
+    await screen.findByText(/page 1 of \d+/);
     await user.click(screen.getByRole('button', { name: 'Next' }));
-    await screen.findByText(/page 2 of 3/);
+    await screen.findByText(/page 2 of \d+/);
 
     await user.selectOptions(screen.getByLabelText('Source'), 'dropbox');
 

package/src/__tests__/ingest.test.ts

@@ -0,0 +1,127 @@
+// @vitest-environment node
+/**
+ * Server-side ingest helpers (crochet_patterns-llmj, design D1/PK2): readable
+ * text from a fetched page, and the text layer of a stored PDF.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { extractPdfText, looksScanned, readableText, SCANNED_CHARS_PER_PAGE } from '../ingest';
+
+describe('readableText', () => {
+  const article = (rounds: number) =>
+    '<html><head><title>Amigurumi Bunny | Hook Blog</title><style>.ad{color:red}</style></head><body>' +
+    '<header><nav><a href="/">Home</a> <a href="/shop">Shop</a></nav></header>' +
+    '<aside class="sidebar">Subscribe to our newsletter for weekly deals</aside>' +
+    '<article><h1>Amigurumi Bunny</h1><p>A small bunny worked in the round with worsted yarn and a 3.5 mm hook.</p><ul>' +
+    Array.from({ length: rounds }, (_, i) => `<li>Rnd ${i + 1}: sc in each st around, working in a spiral without joining (${6 * (i + 1)})</li>`).join('') +
+    '</ul><p>Fasten off and stuff firmly.</p></article>' +
+    '<footer>Copyright 2026 Hook Blog</footer><script>trackEverything()</script></body></html>';
+
+  it('keeps the article, one round per line, and drops scripts, styles, nav and footer', () => {
+    const { title, text } = readableText(article(12), 'https://blog.test/bunny');
+    expect(title).toContain('Amigurumi Bunny');
+    const lines = text.split('\n').map((l) => l.trim()).filter(Boolean);
+    expect(lines).toContain('Rnd 1: sc in each st around, working in a spiral without joining (6)');
+    expect(lines).toContain('Rnd 12: sc in each st around, working in a spiral without joining (72)');
+    expect(text).toContain('Fasten off and stuff firmly.');
+    for (const junk of ['trackEverything', 'color:red', 'Copyright 2026', 'newsletter', 'Shop']) {
+      expect(text).not.toContain(junk);
+    }
+  });
+
+  it('falls back to the page body when the page is too short for an article, still one round per line', () => {
+    const { text } = readableText(
+      '<html><head><title>Tiny</title><script>x()</script></head><body><p>Rnd 1: 6 sc in MR<br>Rnd 2: inc x6 (12)</p><div>Rnd 3: sc around (12)</div></body></html>',
+    );
+    const lines = text.split('\n').map((l) => l.trim()).filter(Boolean);
+    expect(lines).toEqual(['Rnd 1: 6 sc in MR', 'Rnd 2: inc x6 (12)', 'Rnd 3: sc around (12)']);
+  });
+
+  it('reads a bare fragment', () => {
+    expect(readableText('Rnd 1: 6 sc<br>Rnd 2: inc').text).toBe('Rnd 1: 6 sc\nRnd 2: inc');
+  });
+
+  it('collapses inline whitespace and decodes entities', () => {
+    const { text } = readableText('<body><p>Rnd&nbsp;1:   6   sc\n  in   <b>MR</b> &amp; join</p></body>');
+    expect(text).toBe('Rnd 1: 6 sc in MR & join');
+  });
+});
+
+/** A minimal, valid PDF with one Helvetica text line per entry of `pages[i]`. */
+function makePdf(pages: string[][]): Uint8Array {
+  const esc = (s: string) => s.replace(/[\\()]/g, (c) => `\\${c}`);
+  const objs: string[] = [];
+  const n = pages.length;
+  // 1 catalog, 2 pages, 3 font, then (page, content) pairs
+  objs.push('<< /Type /Catalog /Pages 2 0 R >>');
+  objs.push(`<< /Type /Pages /Count ${n} /Kids [${pages.map((_, i) => `${4 + 2 * i} 0 R`).join(' ')}] >>`);
+  objs.push('<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>');
+  pages.forEach((lines, i) => {
+    const stream = lines.length
+      ? `BT /F1 11 Tf 14 TL 72 720 Td ${lines.map((l) => `(${esc(l)}) Tj T*`).join(' ')} ET`
+      : '';
+    objs.push(
+      `<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 3 0 R >> >> /Contents ${5 + 2 * i} 0 R >>`,
+    );
+    objs.push(`<< /Length ${stream.length} >>\nstream\n${stream}\nendstream`);
+  });
+  let out = '%PDF-1.4\n';
+  const offsets: number[] = [];
+  objs.forEach((body, i) => {
+    offsets.push(out.length);
+    out += `${i + 1} 0 obj\n${body}\nendobj\n`;
+  });
+  const xref = out.length;
+  out += `xref\n0 ${objs.length + 1}\n0000000000 65535 f \n`;
+  for (const o of offsets) out += `${String(o).padStart(10, '0')} 00000 n \n`;
+  out += `trailer\n<< /Size ${objs.length + 1} /Root 1 0 R >>\nstartxref\n${xref}\n%%EOF\n`;
+  return new TextEncoder().encode(out);
+}
+
+const ROUNDS = Array.from({ length: 12 }, (_, i) => `Rnd ${i + 1}: sc in each st around (${6 * (i + 1)})`);
+
+describe('extractPdfText', () => {
+  it('returns the text layer page by page', async () => {
+    const bytes = makePdf([ROUNDS.slice(0, 6), ROUNDS.slice(6)]);
+    const r = await extractPdfText(bytes);
+    expect(r.pages).toHaveLength(2);
+    expect(r.pages[0]).toContain('Rnd 1: sc in each st around (6)');
+    expect(r.pages[0]).toContain('Rnd 6: sc in each st around (36)');
+    expect(r.pages[0]).not.toContain('Rnd 7:');
+    expect(r.pages[1]).toContain('Rnd 12: sc in each st around (72)');
+    expect(r.totalChars).toBe(r.pages[0]!.length + r.pages[1]!.length);
+  });
+
+  it('a page with a full text layer does not look scanned', async () => {
+    const r = await extractPdfText(makePdf([ROUNDS]));
+    expect(r.totalChars).toBeGreaterThanOrEqual(SCANNED_CHARS_PER_PAGE);
+    expect(looksScanned(r)).toBe(false);
+  });
+
+  it('does not detach or alter the caller’s buffer (the stored original)', async () => {
+    const bytes = makePdf([ROUNDS]);
+    const copy = bytes.slice();
+    await extractPdfText(bytes);
+    expect(bytes.byteLength).toBe(copy.byteLength);
+    expect(Buffer.from(bytes).equals(Buffer.from(copy))).toBe(true);
+  });
+
+  it('a PDF with no text layer reads as empty and looks scanned', async () => {
+    const r = await extractPdfText(makePdf([[], []]));
+    expect(r.pages).toEqual(['', '']);
+    expect(r.totalChars).toBe(0);
+    expect(looksScanned(r)).toBe(true);
+  });
+
+  it('rejects bytes that are not a PDF', async () => {
+    await expect(extractPdfText(new TextEncoder().encode('<html>not a pdf</html>'))).rejects.toThrow();
+  });
+});
+
+describe('looksScanned', () => {
+  it(`is true below ${SCANNED_CHARS_PER_PAGE} chars per page on average, false at or above`, () => {
+    expect(looksScanned({ pages: [], totalChars: 0 })).toBe(true);
+    expect(looksScanned({ pages: ['a', 'b'], totalChars: 2 * SCANNED_CHARS_PER_PAGE - 1 })).toBe(true);
+    expect(looksScanned({ pages: ['a', 'b'], totalChars: 2 * SCANNED_CHARS_PER_PAGE })).toBe(false);
+  });
+});

package/src/__tests__/safe-fetch-pinning.test.ts

@@ -0,0 +1,198 @@
+// @vitest-environment node
+/**
+ * safeFetch DNS pinning (crochet_patterns-yfj8 #1, design D5) and the address
+ * blocklist. The connection must go to the address that was validated: a
+ * record that answers public at pre-flight and private at connect is refused at
+ * connect. Uses a loopback http server only — no external network.
+ */
+import { createServer, type Server } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { Agent, fetch as undiciFetch } from 'undici';
+
+import { isBlockedAddress, pinnedLookup, safeFetch, SafeFetchError, type ResolvedAddress } from '../safe-fetch';
+
+const PUBLIC = '93.184.216.34';
+const asAddrs = (...addrs: string[]): ResolvedAddress[] =>
+  addrs.map((address) => ({ address, family: address.includes(':') ? 6 : 4 }));
+
+describe('isBlockedAddress', () => {
+  it.each([
+    '127.0.0.1',
+    '127.255.0.9',
+    '0.0.0.0',
+    '0.1.2.3',
+    '10.9.8.7',
+    '100.64.0.1', // CGNAT
+    '100.127.255.255',
+    '169.254.169.254',
+    '172.16.0.1',
+    '172.31.255.255',
+    '192.0.0.8',
+    '192.168.0.1',
+    '198.18.0.1', // benchmarking
+    '198.19.255.255',
+    '224.0.0.1', // multicast
+    '239.255.255.250',
+    '240.0.0.1', // reserved
+    '255.255.255.255',
+    '::',
+    '::1',
+    '[::1]',
+    'fc00::1',
+    'fd12:3456::1',
+    'fe80::1',
+    'fe80::1%en0',
+    'fec0::1',
+    'ff02::1',
+    '::ffff:169.254.169.254',
+    '::ffff:a9fe:a9fe', // the form WHATWG URL rewrites the above to
+    '::ffff:127.0.0.1',
+    '::127.0.0.1', // v4-compatible
+    '64:ff9b::a9fe:a9fe', // NAT64 of the metadata address
+    '64:ff9b::10.0.0.1',
+    '64:ff9b:1::1', // local-use NAT64
+    '2002:7f00:0001::1', // 6to4 of 127.0.0.1
+    '2002:c0a8:0101::', // 6to4 of 192.168.1.1
+    'not-an-ip',
+    '',
+  ])('blocks %s', (addr) => {
+    expect(isBlockedAddress(addr)).toBe(true);
+  });
+
+  it.each([
+    PUBLIC,
+    '8.8.8.8',
+    '1.1.1.1',
+    '172.32.0.1',
+    '172.15.255.255',
+    '100.128.0.1',
+    '100.63.255.255',
+    '198.20.0.1',
+    '223.255.255.255',
+    '2606:4700:4700::1111',
+    '2001:4860:4860::8888',
+    '::ffff:8.8.8.8',
+    '64:ff9b::808:808', // NAT64 of 8.8.8.8
+    '2002:0808:0808::1', // 6to4 of 8.8.8.8
+  ])('allows %s', (addr) => {
+    expect(isBlockedAddress(addr)).toBe(false);
+  });
+});
+
+describe('safeFetch url hygiene', () => {
+  it.each(['https://user:pass@blog.test/', 'https://user@blog.test/'])('refuses credentials in %s', async (url) => {
+    const fetch = vi.fn();
+    const err = await safeFetch(url, { fetch, lookup: async () => asAddrs(PUBLIC) }).catch((e: unknown) => e);
+    expect(err).toBeInstanceOf(SafeFetchError);
+    expect((err as SafeFetchError).code).toBe('BAD_URL');
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ['decimal', 'http://2130706433/'],
+    ['hex', 'http://0x7f.0.0.1/'],
+    ['NAT64 metadata literal', 'http://[64:ff9b::169.254.169.254]/'],
+    ['6to4 loopback literal', 'http://[2002:7f00:1::1]/'],
+  ])('refuses the %s form of an internal IP literal without resolving it', async (_label, url) => {
+    const fetch = vi.fn();
+    const lookup = vi.fn(async () => asAddrs(PUBLIC));
+    const err = await safeFetch(url, { fetch, lookup }).catch((e: unknown) => e);
+    expect((err as SafeFetchError).code).toBe('BLOCKED_ADDRESS');
+    expect(lookup).not.toHaveBeenCalled();
+    expect(fetch).not.toHaveBeenCalled();
+  });
+});
+
+function callLookup(fn: ReturnType<typeof pinnedLookup>, host: string, options: object) {
+  return new Promise<{ err: NodeJS.ErrnoException | null; address: unknown; family?: number }>((resolve) => {
+    fn(host, options as never, (err, address, family) => resolve({ err, address, family }));
+  });
+}
+
+describe('pinnedLookup', () => {
+  it('hands back exactly the validated answer in the {all:true} form, resolving once', async () => {
+    const resolve = vi.fn(async () => asAddrs(PUBLIC, '2606:4700:4700::1111'));
+    const r = await callLookup(pinnedLookup(resolve), 'blog.test', { all: true });
+    expect(r.err).toBeNull();
+    expect(r.address).toEqual([
+      { address: PUBLIC, family: 4 },
+      { address: '2606:4700:4700::1111', family: 6 },
+    ]);
+    expect(resolve).toHaveBeenCalledTimes(1);
+    expect(resolve).toHaveBeenCalledWith('blog.test');
+  });
+
+  it('uses the (address, family) form without all, and honours options.family', async () => {
+    const resolve = async () => asAddrs('2606:4700:4700::1111', PUBLIC);
+    const plain = await callLookup(pinnedLookup(resolve), 'blog.test', {});
+    expect(plain).toMatchObject({ err: null, address: '2606:4700:4700::1111', family: 6 });
+    const v4 = await callLookup(pinnedLookup(resolve), 'blog.test', { family: 4 });
+    expect(v4).toMatchObject({ err: null, address: PUBLIC, family: 4 });
+  });
+
+  it('refuses the whole answer when any address is blocked', async () => {
+    const r = await callLookup(pinnedLookup(async () => asAddrs(PUBLIC, '169.254.169.254')), 'mixed.test', {
+      all: true,
+    });
+    expect(r.err).toBeInstanceOf(SafeFetchError);
+    expect((r.err as unknown as SafeFetchError).code).toBe('BLOCKED_ADDRESS');
+  });
+});
+
+describe('safeFetch connects only to the address it validated (no injected fetch)', () => {
+  let server: Server;
+  let port: number;
+  let connections = 0;
+
+  beforeAll(async () => {
+    server = createServer((_req, res) => {
+      res.writeHead(200, { 'content-type': 'text/html' });
+      res.end('<html><body>internal</body></html>');
+    });
+    server.on('connection', () => {
+      connections++;
+    });
+    await new Promise<void>((r) => server.listen(0, '127.0.0.1', r));
+    port = (server.address() as AddressInfo).port;
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((r) => server.close(() => r()));
+  });
+
+  it('control: an undici Agent connect.lookup decides where the socket goes', async () => {
+    // Proves the loopback server is reachable through a custom lookup, so the
+    // zero-connection assertion below is caused by pinning, not by an unreachable host.
+    const before = connections;
+    const agent = new Agent({
+      connect: {
+        lookup: (_h, opts, cb) =>
+          (opts as { all?: boolean }).all
+            ? (cb as (e: null, a: Array<{ address: string; family: number }>) => void)(null, [
+                { address: '127.0.0.1', family: 4 },
+              ])
+            : cb(null, '127.0.0.1', 4),
+      },
+    });
+    try {
+      const res = await undiciFetch(`http://rebind.test:${port}/`, { dispatcher: agent });
+      expect(await res.text()).toContain('internal');
+    } finally {
+      await agent.close();
+    }
+    expect(connections).toBe(before + 1);
+  });
+
+  it('a record that answers public at pre-flight and private at connect is refused at connect', async () => {
+    const before = connections;
+    const answers = [asAddrs(PUBLIC), asAddrs('127.0.0.1')];
+    const lookup = vi.fn(async () => answers.shift() ?? asAddrs('127.0.0.1'));
+    const err = await safeFetch(`http://rebind.test:${port}/`, { lookup, timeoutMs: 5000 }).catch((e: unknown) => e);
+    expect(err).toBeInstanceOf(SafeFetchError);
+    expect((err as SafeFetchError).code).toBe('BLOCKED_ADDRESS');
+    // Once for the pre-flight, once inside connect.lookup — the socket used the second, checked answer.
+    expect(lookup).toHaveBeenCalledTimes(2);
+    expect(connections).toBe(before);
+  });
+});

package/src/__tests__/safe-fetch.test.ts

@@ -0,0 +1,186 @@
+// @vitest-environment node
+/**
+ * safeFetch SSRF guards (crochet_patterns-llmj — "paste a link to a pattern").
+ * DNS and fetch are injected fakes: no real network.
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+import { safeFetch, SafeFetchError, type ResolvedAddress } from '../safe-fetch';
+
+const PUBLIC = '93.184.216.34';
+
+function fakeDns(map: Record<string, string[]> = {}) {
+  return vi.fn(async (host: string): Promise<ResolvedAddress[]> => {
+    const addrs = map[host] ?? [PUBLIC];
+    return addrs.map((address) => ({ address, family: address.includes(':') ? 6 : 4 }));
+  });
+}
+
+const html = (body = '<html><body>Rnd 1: 6 sc in magic ring</body></html>', type = 'text/html; charset=utf-8') =>
+  new Response(body, { status: 200, headers: { 'content-type': type } });
+const redirect = (location: string) => new Response(null, { status: 302, headers: { location } });
+
+function fakeFetch(...responses: Array<Response | ((init?: RequestInit) => Promise<Response>)>) {
+  return vi.fn(async (_url: string | URL | Request, init?: RequestInit) => {
+    const next = responses.shift();
+    if (!next) throw new Error('fake fetch: no more responses');
+    return typeof next === 'function' ? next(init) : next;
+  });
+}
+
+async function refusal(p: Promise<unknown>): Promise<SafeFetchError> {
+  const err = await p.then(
+    () => undefined,
+    (e: unknown) => e,
+  );
+  expect(err).toBeInstanceOf(SafeFetchError);
+  return err as SafeFetchError;
+}
+
+describe('safeFetch refuses internal addresses', () => {
+  it.each([
+    ['loopback v4', 'http://127.0.0.1/pattern'],
+    ['loopback v6', 'http://[::1]/pattern'],
+    ['cloud metadata', 'http://169.254.169.254/latest/meta-data/'],
+    ['10/8', 'http://10.0.0.5/'],
+    ['172.16/12 low end', 'http://172.16.0.1/'],
+    ['172.16/12 high end', 'http://172.31.255.255/'],
+    ['192.168/16', 'http://192.168.1.1/'],
+    ['unspecified', 'http://0.0.0.0/'],
+    ['v4-mapped v6 metadata', 'http://[::ffff:169.254.169.254]/'],
+  ])('%s (%s) as an IP literal, without fetching', async (_label, url) => {
+    const fetch = fakeFetch(html());
+    const err = await refusal(safeFetch(url, { fetch, lookup: fakeDns() }));
+    expect(err.code).toBe('BLOCKED_ADDRESS');
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('a DNS name that resolves to a private IP', async () => {
+    const fetch = fakeFetch(html());
+    const lookup = fakeDns({ 'patterns.evil.test': ['10.1.2.3'] });
+    const err = await refusal(safeFetch('https://patterns.evil.test/bunny', { fetch, lookup }));
+    expect(err.code).toBe('BLOCKED_ADDRESS');
+    expect(lookup).toHaveBeenCalledWith('patterns.evil.test');
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('a DNS name where ANY of its addresses is private', async () => {
+    const fetch = fakeFetch(html());
+    const lookup = fakeDns({ 'mixed.test': [PUBLIC, '192.168.0.9'] });
+    const err = await refusal(safeFetch('https://mixed.test/', { fetch, lookup }));
+    expect(err.code).toBe('BLOCKED_ADDRESS');
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('a redirect hop to a host that resolves privately', async () => {
+    const fetch = fakeFetch(redirect('http://internal.test/admin'), html());
+    const lookup = fakeDns({ 'internal.test': ['192.168.0.10'] });
+    const err = await refusal(safeFetch('https://blog.test/bunny', { fetch, lookup }));
+    expect(err.code).toBe('BLOCKED_ADDRESS');
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('a redirect hop straight to the metadata IP', async () => {
+    const fetch = fakeFetch(redirect('http://169.254.169.254/latest/meta-data/'), html());
+    const err = await refusal(safeFetch('https://blog.test/bunny', { fetch, lookup: fakeDns() }));
+    expect(err.code).toBe('BLOCKED_ADDRESS');
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('a non-http scheme', async () => {
+    const fetch = fakeFetch(html());
+    const err = await refusal(safeFetch('file:///etc/passwd', { fetch, lookup: fakeDns() }));
+    expect(err.code).toBe('BAD_URL');
+    expect(fetch).not.toHaveBeenCalled();
+  });
+});
+
+describe('safeFetch fetches public pages', () => {
+  it('returns the body of a public html page, fetched with redirect: manual', async () => {
+    const fetch = fakeFetch(html());
+    const res = await safeFetch('https://blog.test/bunny', { fetch, lookup: fakeDns() });
+    expect(res.status).toBe(200);
+    expect(res.contentType).toBe('text/html');
+    expect(new TextDecoder().decode(res.body)).toContain('6 sc in magic ring');
+    expect(fetch.mock.calls[0]![1]?.redirect).toBe('manual');
+  });
+
+  it('allows 172.32.0.1 (just outside 172.16/12)', async () => {
+    const fetch = fakeFetch(html());
+    await expect(safeFetch('http://172.32.0.1/', { fetch, lookup: fakeDns() })).resolves.toMatchObject({ status: 200 });
+  });
+
+  it('follows 3 redirects (relative Location resolved), re-checking every hop with redirect: manual', async () => {
+    const fetch = fakeFetch(redirect('https://a.test/1'), redirect('/2'), redirect('https://c.test/3'), html());
+    const lookup = fakeDns();
+    const res = await safeFetch('https://start.test/', { fetch, lookup });
+    expect(res.finalUrl).toBe('https://c.test/3');
+    expect(fetch).toHaveBeenCalledTimes(4);
+    expect(String(fetch.mock.calls[2]![0])).toBe('https://a.test/2');
+    for (const call of fetch.mock.calls) expect(call[1]?.redirect).toBe('manual');
+    expect(lookup.mock.calls.map((c) => c[0])).toEqual(expect.arrayContaining(['start.test', 'a.test', 'c.test']));
+  });
+
+  it('refuses a 4th redirect', async () => {
+    const fetch = fakeFetch(redirect('/1'), redirect('/2'), redirect('/3'), redirect('/4'), html());
+    const err = await refusal(safeFetch('https://start.test/', { fetch, lookup: fakeDns() }));
+    expect(err.code).toBe('TOO_MANY_REDIRECTS');
+    expect(fetch).toHaveBeenCalledTimes(4);
+  });
+});
+
+describe('safeFetch content limits', () => {
+  it('accepts application/pdf', async () => {
+    const fetch = fakeFetch(new Response(new Uint8Array([0x25, 0x50, 0x44, 0x46]), { headers: { 'content-type': 'application/pdf' } }));
+    const res = await safeFetch('https://blog.test/bunny.pdf', { fetch, lookup: fakeDns() });
+    expect(res.contentType).toBe('application/pdf');
+    expect(res.body.byteLength).toBe(4);
+  });
+
+  it.each(['application/json', 'image/png', 'application/octet-stream'])('refuses %s', async (type) => {
+    const fetch = fakeFetch(html('{}', type));
+    const err = await refusal(safeFetch('https://blog.test/x', { fetch, lookup: fakeDns() }));
+    expect(err.code).toBe('UNSUPPORTED_TYPE');
+  });
+
+  it('refuses a response with no content type', async () => {
+    const fetch = fakeFetch(new Response(new Uint8Array([1, 2, 3]), { status: 200 }));
+    const err = await refusal(safeFetch('https://blog.test/x', { fetch, lookup: fakeDns() }));
+    expect(err.code).toBe('UNSUPPORTED_TYPE');
+  });
+
+  it('refuses a declared content-length over maxBytes', async () => {
+    const fetch = fakeFetch(
+      new Response('x'.repeat(10), { headers: { 'content-type': 'text/html', 'content-length': '5000000' } }),
+    );
+    const err = await refusal(safeFetch('https://blog.test/x', { fetch, lookup: fakeDns(), maxBytes: 1000 }));
+    expect(err.code).toBe('TOO_LARGE');
+  });
+
+  it('aborts a streamed body (no content-length) once it passes maxBytes', async () => {
+    let pulled = 0;
+    const stream = new ReadableStream<Uint8Array>({
+      pull(c) {
+        pulled++;
+        if (pulled > 1000) return c.close();
+        c.enqueue(new Uint8Array(512));
+      },
+    });
+    const fetch = fakeFetch(new Response(stream, { headers: { 'content-type': 'text/html' } }));
+    const err = await refusal(safeFetch('https://blog.test/x', { fetch, lookup: fakeDns(), maxBytes: 2048 }));
+    expect(err.code).toBe('TOO_LARGE');
+    expect(pulled).toBeLessThan(1000);
+  });
+
+  it('aborts on timeout', async () => {
+    const hang = (init?: RequestInit) =>
+      new Promise<Response>((_resolve, reject) => {
+        init?.signal?.addEventListener('abort', () => reject(new DOMException('aborted', 'AbortError')));
+      });
+    const fetch = fakeFetch(hang);
+    const started = Date.now();
+    const err = await refusal(safeFetch('https://slow.test/', { fetch, lookup: fakeDns(), timeoutMs: 50 }));
+    expect(err.code).toBe('TIMEOUT');
+    expect(Date.now() - started).toBeLessThan(2000);
+  });
+});