@verbatims/sdk 1.0.0

package/src/__tests__/client.test.ts

@@ -0,0 +1,304 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { VerbatimsClient } from '../client'
+import {
+  VerbatimsError,
+  NotFoundError,
+  RateLimitError,
+  ValidationError,
+  AuthError,
+  ForbiddenError,
+} from '../errors'
+
+function mockResponse(data: unknown, status = 200, headers?: Record<string, string>) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { 'Content-Type': 'application/json', ...headers },
+  })
+}
+
+const BASE_URL = 'http://localhost:8080/api/v1'
+
+describe('VerbatimsClient', () => {
+  let fetchFn: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    fetchFn = vi.fn()
+  })
+
+  function createClient(opts?: Partial<ConstructorParameters<typeof VerbatimsClient>[1]>) {
+    return new VerbatimsClient('vbt_test_key', {
+      baseUrl: BASE_URL,
+      retry: { maxRetries: 1, baseDelayMs: 5 },
+      ...opts,
+      fetch: fetchFn,
+    })
+  }
+
+  describe('GET', () => {
+    it('sends GET request with Bearer auth', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: true }))
+      await createClient().get('/test')
+
+      expect(fetchFn).toHaveBeenCalledTimes(1)
+      const [url, opts] = fetchFn.mock.calls[0]
+      expect(url).toContain('/api/v1/test')
+      expect(opts.method).toBe('GET')
+      expect(opts.headers['Authorization']).toBe('Bearer vbt_test_key')
+    })
+
+    it('appends query parameters', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: true }))
+      await createClient().get('/quotes', { params: { page: 1, limit: 10, language: 'fr' } })
+
+      const [url] = fetchFn.mock.calls[0]
+      const parsed = new URL(url, 'http://localhost')
+      expect(parsed.searchParams.get('page')).toBe('1')
+      expect(parsed.searchParams.get('limit')).toBe('10')
+      expect(parsed.searchParams.get('language')).toBe('fr')
+    })
+
+    it('skips undefined and null params', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: true }))
+      await createClient().get('/test', { params: { page: 1, limit: undefined, search: null } })
+
+      const [url] = fetchFn.mock.calls[0]
+      const parsed = new URL(url, 'http://localhost')
+      expect(parsed.searchParams.get('page')).toBe('1')
+      expect(parsed.searchParams.has('limit')).toBe(false)
+      expect(parsed.searchParams.has('search')).toBe(false)
+    })
+  })
+
+  describe('POST', () => {
+    it('sends POST with JSON body and Content-Type', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: true }))
+      const body = { name: 'Test', author_id: 1 }
+      await createClient().post('/quotes', body)
+
+      const [url, opts] = fetchFn.mock.calls[0]
+      expect(url).toContain('/api/v1/quotes')
+      expect(opts.method).toBe('POST')
+      expect(JSON.parse(opts.body)).toEqual(body)
+      expect(opts.headers['Content-Type']).toBe('application/json')
+    })
+
+    it('omits Content-Type when body is empty', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: true }))
+      await createClient().post('/test', undefined)
+
+      const [, opts] = fetchFn.mock.calls[0]
+      expect(opts.headers['Content-Type']).toBeUndefined()
+    })
+  })
+
+  describe('PUT', () => {
+    it('sends PUT with JSON body', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: true }))
+      await createClient().put('/quotes/1', { name: 'Updated' })
+
+      const [, opts] = fetchFn.mock.calls[0]
+      expect(opts.method).toBe('PUT')
+      expect(JSON.parse(opts.body)).toEqual({ name: 'Updated' })
+    })
+  })
+
+  describe('DELETE', () => {
+    it('sends DELETE without body', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: true }))
+      await createClient().delete('/quotes/1')
+
+      const [, opts] = fetchFn.mock.calls[0]
+      expect(opts.method).toBe('DELETE')
+      expect(opts.body).toBeUndefined()
+    })
+  })
+
+  describe('error handling', () => {
+    it('throws ValidationError on 400', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: false, message: 'Bad request', errors: ['invalid'] }, 400))
+      await expect(createClient().get('/test')).rejects.toThrow(ValidationError)
+    })
+
+    it('throws AuthError on 401', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: false }, 401))
+      await expect(createClient().get('/test')).rejects.toThrow(AuthError)
+    })
+
+    it('throws ForbiddenError on 403', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: false }, 403))
+      await expect(createClient().get('/test')).rejects.toThrow(ForbiddenError)
+    })
+
+    it('throws NotFoundError on 404', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: false, message: 'Not found' }, 404))
+      await expect(createClient().get('/test')).rejects.toThrow(NotFoundError)
+    })
+
+    it('throws RateLimitError on 429 with headers', async () => {
+      const now = Math.floor(Date.now() / 1000)
+      fetchFn.mockResolvedValue(
+        mockResponse({ success: false, message: 'Rate limited' }, 429, {
+          'x-ratelimit-limit': '100',
+          'x-ratelimit-remaining': '0',
+          'x-ratelimit-reset': String(now + 30),
+        }),
+      )
+      await expect(createClient({ retry: { maxRetries: 0, baseDelayMs: 5 } }).get('/test')).rejects.toThrow(RateLimitError)
+      expect(fetchFn).toHaveBeenCalledTimes(1)
+    })
+
+    it('throws VerbatimsError on unexpected status', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: false, message: 'Server error' }, 500))
+      await expect(createClient().get('/test')).rejects.toThrow(VerbatimsError)
+    })
+
+    it('throws VerbatimsError on invalid JSON response', async () => {
+      fetchFn.mockResolvedValue(new Response('not json', { status: 200 }))
+      await expect(createClient().get('/test')).rejects.toThrow(VerbatimsError)
+    })
+
+    it('sets error message from response body', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: false, message: 'Custom error' }, 400))
+      await expect(createClient().get('/test')).rejects.toMatchObject({
+        message: 'Custom error',
+      })
+    })
+  })
+
+  describe('retry logic', () => {
+    it('retries GET on network error', async () => {
+      fetchFn
+        .mockRejectedValueOnce(new Error('network error'))
+        .mockResolvedValueOnce(mockResponse({ success: true }))
+
+      await createClient({ retry: { maxRetries: 1, baseDelayMs: 5 } }).get('/test')
+      expect(fetchFn).toHaveBeenCalledTimes(2)
+    })
+
+    it('retries POST once on network error (maxRetries capped at 1 for non-GET)', async () => {
+      fetchFn
+        .mockRejectedValueOnce(new Error('network error'))
+        .mockRejectedValueOnce(new Error('network error'))
+
+      await expect(
+        createClient({ retry: { maxRetries: 3, baseDelayMs: 5 } }).post('/test', {}),
+      ).rejects.toThrow()
+
+      expect(fetchFn).toHaveBeenCalledTimes(2)
+    })
+
+    it('retries PUT once on network error', async () => {
+      fetchFn
+        .mockRejectedValueOnce(new Error('network error'))
+        .mockRejectedValueOnce(new Error('network error'))
+
+      await expect(createClient().put('/test', {})).rejects.toThrow()
+      expect(fetchFn).toHaveBeenCalledTimes(2)
+    })
+
+    it('retries DELETE once on network error', async () => {
+      fetchFn
+        .mockRejectedValueOnce(new Error('network error'))
+        .mockRejectedValueOnce(new Error('network error'))
+
+      await expect(createClient().delete('/test')).rejects.toThrow()
+      expect(fetchFn).toHaveBeenCalledTimes(2)
+    })
+
+    it('retries on 429 and succeeds', async () => {
+      const now = Math.floor(Date.now() / 1000)
+      fetchFn
+        .mockResolvedValueOnce(
+          mockResponse({ success: false, message: 'Rate limited' }, 429, {
+            'x-ratelimit-limit': '100',
+            'x-ratelimit-remaining': '0',
+            'x-ratelimit-reset': String(now + 1),
+          }),
+        )
+        .mockResolvedValueOnce(mockResponse({ success: true }))
+
+      await createClient({ retry: { maxRetries: 1, baseDelayMs: 5 } }).get('/test')
+      expect(fetchFn).toHaveBeenCalledTimes(2)
+    })
+
+    it('stops retrying after max retries exhausted', async () => {
+      fetchFn.mockRejectedValue(new Error('network error'))
+
+      await expect(
+        createClient({ retry: { maxRetries: 2, baseDelayMs: 5 } }).get('/test'),
+      ).rejects.toThrow()
+
+      expect(fetchFn).toHaveBeenCalledTimes(3)
+    })
+
+    it('does not retry non-retryable VerbatimsError', async () => {
+      fetchFn
+        .mockResolvedValueOnce(mockResponse({ success: false }, 403))
+        .mockResolvedValueOnce(mockResponse({ success: true }))
+
+      await expect(createClient().get('/test')).rejects.toThrow(ForbiddenError)
+      expect(fetchFn).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('custom fetch injection', () => {
+    it('uses injected fetch function', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: true }))
+      const client = new VerbatimsClient('key', { fetch: fetchFn })
+      await client.get('/test')
+      expect(fetchFn).toHaveBeenCalled()
+    })
+  })
+
+  describe('baseUrl', () => {
+    it('defaults to /api/v1', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: true }))
+      const client = new VerbatimsClient('key', { fetch: fetchFn })
+      await client.get('/quotes')
+      const [url] = fetchFn.mock.calls[0]
+      expect(url).toContain('/api/v1/quotes')
+    })
+
+    it('uses custom baseUrl', async () => {
+      fetchFn.mockResolvedValue(mockResponse({ success: true }))
+      const client = new VerbatimsClient('key', { baseUrl: '/custom', fetch: fetchFn })
+      await client.get('/quotes')
+      const [url] = fetchFn.mock.calls[0]
+      expect(url).toContain('/custom/quotes')
+    })
+  })
+
+  describe('timeout', () => {
+    it('throws on timeout', async () => {
+      fetchFn.mockImplementation((_url: string, opts?: RequestInit) => {
+        return new Promise((_resolve, reject) => {
+          if (opts?.signal) {
+            ;(opts.signal as AbortSignal).addEventListener('abort', () => {
+              reject(new DOMException('The operation was aborted', 'AbortError'))
+            })
+          }
+        })
+      })
+      const client = new VerbatimsClient('key', {
+        fetch: fetchFn,
+        baseUrl: BASE_URL,
+        timeout: 50,
+        retry: { maxRetries: 0, baseDelayMs: 5 },
+      })
+      await expect(client.get('/test')).rejects.toThrow()
+    })
+  })
+
+  describe('schema validation', () => {
+    it('throws VerbatimsError when Zod schema rejects data', async () => {
+      fetchFn.mockResolvedValue(
+        mockResponse({ success: true, data: { id: 'not-a-number' } }),
+      )
+
+      const { z } = await import('zod/v4')
+      const schema = z.object({ success: z.literal(true), data: z.object({ id: z.number() }) })
+
+      await expect(createClient().get('/test', {}, schema)).rejects.toThrow()
+    })
+  })
+})

package/src/__tests__/errors.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest'
+import {
+  VerbatimsError,
+  NotFoundError,
+  RateLimitError,
+  ValidationError,
+  AuthError,
+  ForbiddenError,
+} from '../errors'
+
+describe('VerbatimsError', () => {
+  it('creates error with message, status code, and optional code', () => {
+    const err = new VerbatimsError('Something went wrong', 500, 'INTERNAL')
+    expect(err).toBeInstanceOf(Error)
+    expect(err.message).toBe('Something went wrong')
+    expect(err.statusCode).toBe(500)
+    expect(err.code).toBe('INTERNAL')
+    expect(err.name).toBe('VerbatimsError')
+  })
+})
+
+describe('NotFoundError', () => {
+  it('creates 404 error with default message', () => {
+    const err = new NotFoundError()
+    expect(err).toBeInstanceOf(VerbatimsError)
+    expect(err.statusCode).toBe(404)
+    expect(err.code).toBe('NOT_FOUND')
+    expect(err.message).toBe('Resource not found')
+    expect(err.name).toBe('NotFoundError')
+  })
+
+  it('creates 404 error with custom message', () => {
+    const err = new NotFoundError('Quote not found')
+    expect(err.message).toBe('Quote not found')
+  })
+})
+
+describe('RateLimitError', () => {
+  it('creates 429 error with rate limit metadata', () => {
+    const err = new RateLimitError('Too many requests', 30, 100, 0, 12345)
+    expect(err.statusCode).toBe(429)
+    expect(err.retryAfter).toBe(30)
+    expect(err.limit).toBe(100)
+    expect(err.remaining).toBe(0)
+    expect(err.reset).toBe(12345)
+    expect(err.code).toBe('RATE_LIMITED')
+    expect(err.name).toBe('RateLimitError')
+  })
+})
+
+describe('ValidationError', () => {
+  it('creates 400 error with errors array', () => {
+    const err = new ValidationError('Invalid data', ['name is required', 'email is invalid'])
+    expect(err.statusCode).toBe(400)
+    expect(err.errors).toEqual(['name is required', 'email is invalid'])
+    expect(err.code).toBe('VALIDATION_ERROR')
+    expect(err.name).toBe('ValidationError')
+  })
+
+  it('creates 400 error without errors array', () => {
+    const err = new ValidationError('Invalid data')
+    expect(err.statusCode).toBe(400)
+    expect(err.errors).toBeUndefined()
+  })
+})
+
+describe('AuthError', () => {
+  it('creates 401 error with default message', () => {
+    const err = new AuthError()
+    expect(err.statusCode).toBe(401)
+    expect(err.code).toBe('AUTH_ERROR')
+    expect(err.message).toBe('Authentication required')
+    expect(err.name).toBe('AuthError')
+  })
+})
+
+describe('ForbiddenError', () => {
+  it('creates 403 error with default message', () => {
+    const err = new ForbiddenError()
+    expect(err.statusCode).toBe(403)
+    expect(err.code).toBe('FORBIDDEN')
+    expect(err.message).toBe('Access denied')
+    expect(err.name).toBe('ForbiddenError')
+  })
+})

package/src/__tests__/pagination.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, vi } from 'vitest'
+import { paginate } from '../pagination'
+
+describe('paginate', () => {
+  it('yields items from a single page', async () => {
+    const fetchPage = vi.fn().mockResolvedValue({
+      data: [{ id: 1 }, { id: 2 }],
+      pagination: { page: 1, limit: 10, total: 2, totalPages: 1, hasMore: false },
+    })
+
+    const results: Array<{ id: number }> = []
+    for await (const item of paginate(fetchPage)) {
+      results.push(item)
+    }
+
+    expect(results).toHaveLength(2)
+    expect(results[0]).toEqual({ id: 1 })
+    expect(results[1]).toEqual({ id: 2 })
+    expect(fetchPage).toHaveBeenCalledTimes(1)
+    expect(fetchPage).toHaveBeenCalledWith(1)
+  })
+
+  it('iterates through multiple pages', async () => {
+    const fetchPage = vi.fn()
+      .mockResolvedValueOnce({
+        data: [{ id: 1 }],
+        pagination: { page: 1, limit: 1, total: 3, totalPages: 3, hasMore: true },
+      })
+      .mockResolvedValueOnce({
+        data: [{ id: 2 }],
+        pagination: { page: 2, limit: 1, total: 3, totalPages: 3, hasMore: true },
+      })
+      .mockResolvedValueOnce({
+        data: [{ id: 3 }],
+        pagination: { page: 3, limit: 1, total: 3, totalPages: 3, hasMore: false },
+      })
+
+    const results: Array<{ id: number }> = []
+    for await (const item of paginate(fetchPage)) {
+      results.push(item)
+    }
+
+    expect(results).toHaveLength(3)
+    expect(fetchPage).toHaveBeenCalledTimes(3)
+    expect(fetchPage).toHaveBeenNthCalledWith(1, 1)
+    expect(fetchPage).toHaveBeenNthCalledWith(2, 2)
+    expect(fetchPage).toHaveBeenNthCalledWith(3, 3)
+  })
+
+  it('stops when data is empty', async () => {
+    const fetchPage = vi.fn().mockResolvedValue({
+      data: [],
+      pagination: { page: 1, limit: 10, total: 0, totalPages: 0, hasMore: false },
+    })
+
+    const results: Array<{ id: number }> = []
+    for await (const item of paginate(fetchPage)) {
+      results.push(item)
+    }
+
+    expect(results).toHaveLength(0)
+    expect(fetchPage).toHaveBeenCalledTimes(1)
+  })
+
+  it('stops when data is undefined', async () => {
+    const fetchPage = vi.fn().mockResolvedValue({
+      data: undefined,
+      pagination: { page: 1, limit: 10, total: 0, totalPages: 0, hasMore: false },
+    })
+
+    const results: Array<{ id: number }> = []
+    for await (const item of paginate(fetchPage)) {
+      results.push(item)
+    }
+
+    expect(results).toHaveLength(0)
+    expect(fetchPage).toHaveBeenCalledTimes(1)
+  })
+
+  it('handles multiple items per page', async () => {
+    const fetchPage = vi.fn()
+      .mockResolvedValueOnce({
+        data: [{ id: 1 }, { id: 2 }],
+        pagination: { page: 1, limit: 2, total: 4, totalPages: 2, hasMore: true },
+      })
+      .mockResolvedValueOnce({
+        data: [{ id: 3 }, { id: 4 }],
+        pagination: { page: 2, limit: 2, total: 4, totalPages: 2, hasMore: false },
+      })
+
+    const results: Array<{ id: number }> = []
+    for await (const item of paginate(fetchPage)) {
+      results.push(item)
+    }
+
+    expect(results).toHaveLength(4)
+    expect(results[0].id).toBe(1)
+    expect(results[3].id).toBe(4)
+  })
+})

package/src/client.ts

@@ -0,0 +1,213 @@
+import { z } from 'zod/v4'
+import { errorResponseSchema, paginationMetaSchema, apiResponseSchema } from './types'
+import { VerbatimsError, NotFoundError, RateLimitError, ValidationError, AuthError, ForbiddenError } from './errors'
+
+export interface ClientOptions {
+  baseUrl?: string
+  timeout?: number
+  retry?: RetryConfig
+  fetch?: typeof globalThis.fetch
+}
+
+export interface RetryConfig {
+  maxRetries: number
+  baseDelayMs: number
+}
+
+const defaultRetry: RetryConfig = {
+  maxRetries: 3,
+  baseDelayMs: 500,
+}
+
+interface RequestOptions {
+  method?: string
+  body?: unknown
+  params?: Record<string, unknown>
+  signal?: AbortSignal
+}
+
+export class VerbatimsClient {
+  private baseUrl: string
+  private apiKey: string
+  private timeout: number
+  private retry: RetryConfig
+  private fetchFn: typeof globalThis.fetch
+
+  constructor(apiKey: string, opts: ClientOptions = {}) {
+    this.apiKey = apiKey
+    this.baseUrl = opts.baseUrl ?? '/api/v1'
+    this.timeout = opts.timeout ?? 15_000
+    this.retry = opts.retry ?? defaultRetry
+    this.fetchFn = opts.fetch ?? globalThis.fetch
+  }
+
+  private buildUrl(path: string, params?: Record<string, unknown>): string {
+    const url = new URL(`${this.baseUrl}${path}`, 'http://localhost')
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null) {
+          url.searchParams.set(key, String(value))
+        }
+      }
+    }
+    return url.pathname + url.search
+  }
+
+  private async request<T>(
+    path: string,
+    opts: RequestOptions = {},
+    schema: z.ZodType<T>,
+  ): Promise<T> {
+    const url = this.buildUrl(path, opts.params)
+    const method = opts.method ?? 'GET'
+    const body = opts.body ? JSON.stringify(opts.body) : undefined
+
+    let lastError: Error | null = null
+    const maxRetries = method === 'GET' ? this.retry.maxRetries : 1
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const controller = new AbortController()
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout)
+
+        const signal = opts.signal
+          ? anySignal([opts.signal, controller.signal])
+          : controller.signal
+
+        const response = await this.fetchFn(url, {
+          method,
+          headers: {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': body ? 'application/json' : undefined,
+            'Accept': 'application/json',
+          } as Record<string, string>,
+          body,
+          signal,
+        })
+
+        clearTimeout(timeoutId)
+
+        const rateLimitHeaders = this.parseRateLimitHeaders(response.headers)
+        const text = await response.text()
+        let json: unknown
+        try {
+          json = JSON.parse(text)
+        } catch {
+          throw new VerbatimsError(`Invalid JSON response: ${text.slice(0, 200)}`, response.status)
+        }
+
+        if (!response.ok) {
+          this.handleError(response.status, json, rateLimitHeaders)
+        }
+
+        const parsed = schema.parse(json)
+        return parsed
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err))
+
+        if (err instanceof VerbatimsError) {
+          if (err.statusCode === 429 && attempt < maxRetries) {
+            const retryAfter = err instanceof RateLimitError ? err.retryAfter : 1
+            await sleep(retryAfter * 1000)
+            continue
+          }
+          throw err
+        }
+
+        if (attempt < maxRetries && isRetryableError(lastError)) {
+          const delay = this.retry.baseDelayMs * Math.pow(2, attempt)
+          await sleep(delay)
+          continue
+        }
+
+        throw lastError
+      }
+    }
+
+    throw lastError ?? new VerbatimsError('Request failed', 0)
+  }
+
+  private parseRateLimitHeaders(headers: Headers): {
+    limit: number
+    remaining: number
+    reset: number
+  } | null {
+    const limit = headers.get('x-ratelimit-limit')
+    const remaining = headers.get('x-ratelimit-remaining')
+    const reset = headers.get('x-ratelimit-reset')
+    if (limit && remaining && reset) {
+      return {
+        limit: Number(limit),
+        remaining: Number(remaining),
+        reset: Number(reset),
+      }
+    }
+    return null
+  }
+
+  private handleError(status: number, json: unknown, rateLimit: { limit: number; remaining: number; reset: number } | null): never {
+    const parsed = errorResponseSchema.safeParse(json)
+    const message = parsed.data?.message ?? `HTTP ${status}`
+    const errors = parsed.data?.errors
+
+    switch (status) {
+      case 400:
+        throw new ValidationError(message, errors)
+      case 401:
+        throw new AuthError(message)
+      case 403:
+        throw new ForbiddenError(message)
+      case 404:
+        throw new NotFoundError(message)
+      case 429:
+        throw new RateLimitError(
+          message,
+          rateLimit?.reset ? rateLimit.reset - Math.floor(Date.now() / 1000) : 1,
+          rateLimit?.limit ?? 0,
+          rateLimit?.remaining ?? 0,
+          rateLimit?.reset ?? 0,
+        )
+      default:
+        throw new VerbatimsError(message, status)
+    }
+  }
+
+  // --- HTTP helpers ---
+
+  async get<T>(path: string, opts?: RequestOptions, schema?: z.ZodType<T>): Promise<T> {
+    return this.request(path, { ...opts, method: 'GET' }, schema ?? z.unknown() as z.ZodType<T>)
+  }
+
+  async post<T>(path: string, body: unknown, opts?: RequestOptions, schema?: z.ZodType<T>): Promise<T> {
+    return this.request(path, { ...opts, method: 'POST', body }, schema ?? z.unknown() as z.ZodType<T>)
+  }
+
+  async put<T>(path: string, body: unknown, opts?: RequestOptions, schema?: z.ZodType<T>): Promise<T> {
+    return this.request(path, { ...opts, method: 'PUT', body }, schema ?? z.unknown() as z.ZodType<T>)
+  }
+
+  async delete<T>(path: string, opts?: RequestOptions, schema?: z.ZodType<T>): Promise<T> {
+    return this.request(path, { ...opts, method: 'DELETE' }, schema ?? z.unknown() as z.ZodType<T>)
+  }
+}
+
+function anySignal(signals: AbortSignal[]): AbortSignal {
+  const controller = new AbortController()
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason)
+      return controller.signal
+    }
+    signal.addEventListener('abort', () => controller.abort(signal.reason), { once: true })
+  }
+  return controller.signal
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+function isRetryableError(err: Error): boolean {
+  if (err instanceof VerbatimsError) return false
+  return err.name === 'AbortError' || err.message.includes('network') || err.message.includes('fetch')
+}