ts-procedures 6.2.0 → 7.0.0-beta.0

package/src/client/classify-error.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest'
+import { defaultClassifyError } from './classify-error.js'
+import {
+  ClientNetworkError,
+  ClientTimeoutError,
+  ClientAbortError,
+} from './errors.js'
+
+const meta = { procedureName: 'GetUser', scope: 'users' }
+
+describe('defaultClassifyError', () => {
+  it('classifies fetch TypeError as network', () => {
+    const result = defaultClassifyError(new TypeError('Failed to fetch'), { ...meta })
+    expect(result?.kind).toBe('network')
+    expect(result?.error).toBeInstanceOf(ClientNetworkError)
+    expect(result?.error.cause).toBeInstanceOf(TypeError)
+  })
+
+  it('classifies AbortError as timeout when timeout signal fired', () => {
+    const timeoutSignal = AbortSignal.timeout(0)
+    // wait a tick for the timeout to fire
+    return new Promise<void>((resolve) => setTimeout(() => {
+      const abortErr = new DOMException('aborted', 'AbortError')
+      const result = defaultClassifyError(abortErr, { ...meta, timeoutSignal, timeoutMs: 5000 })
+      expect(result?.kind).toBe('timeout')
+      expect(result?.error).toBeInstanceOf(ClientTimeoutError)
+      expect((result?.error as ClientTimeoutError).timeoutMs).toBe(5000)
+      resolve()
+    }, 1))
+  })
+
+  it('classifies AbortError as aborted when user signal fired', () => {
+    const userController = new AbortController()
+    userController.abort('user-cancelled')
+    const abortErr = new DOMException('aborted', 'AbortError')
+    const result = defaultClassifyError(abortErr, { ...meta, userSignal: userController.signal })
+    expect(result?.kind).toBe('aborted')
+    expect(result?.error).toBeInstanceOf(ClientAbortError)
+    expect((result?.error as ClientAbortError).reason).toBe('user-cancelled')
+  })
+
+  it('classifies AbortError as timeout when both fired (timeout precedence)', () => {
+    const timeoutSignal = AbortSignal.timeout(0)
+    const userController = new AbortController()
+    return new Promise<void>((resolve) => setTimeout(() => {
+      userController.abort('user')
+      const abortErr = new DOMException('aborted', 'AbortError')
+      const result = defaultClassifyError(abortErr, {
+        ...meta, timeoutSignal, timeoutMs: 1, userSignal: userController.signal,
+      })
+      expect(result?.kind).toBe('timeout')
+      resolve()
+    }, 1))
+  })
+
+  it('returns null for unknown errors', () => {
+    const result = defaultClassifyError(new Error('weird'), { ...meta })
+    expect(result).toBeNull()
+  })
+
+  it('returns null for non-Error throws', () => {
+    expect(defaultClassifyError('string-thrown', { ...meta })).toBeNull()
+    expect(defaultClassifyError(42, { ...meta })).toBeNull()
+  })
+})

package/src/client/classify-error.ts

@@ -0,0 +1,59 @@
+import {
+  ClientNetworkError,
+  ClientTimeoutError,
+  ClientAbortError,
+} from './errors.js'
+import type { ErrorClassifier } from './types.js'
+
+/**
+ * Default classifier — recognizes:
+ *   - `TypeError` from fetch → `ClientNetworkError`
+ *   - `DOMException` with `name: 'AbortError'` + timeout-signal-aborted → `ClientTimeoutError`
+ *   - `DOMException` with `name: 'AbortError'` + user-signal-aborted → `ClientAbortError`
+ *
+ * Returns `null` for anything else. Timeout precedence: when both signals
+ * fired, classifies as `timeout`.
+ */
+export const defaultClassifyError: ErrorClassifier = (raw, ctx) => {
+  const meta = { procedureName: ctx.procedureName, scope: ctx.scope }
+
+  if (raw instanceof TypeError) {
+    return {
+      kind: 'network',
+      error: new ClientNetworkError({ ...meta, cause: raw, message: raw.message }),
+    }
+  }
+
+  if (
+    raw instanceof DOMException &&
+    raw.name === 'AbortError'
+  ) {
+    if (ctx.timeoutSignal?.aborted) {
+      return {
+        kind: 'timeout',
+        error: new ClientTimeoutError({
+          ...meta,
+          timeoutMs: ctx.timeoutMs ?? 0,
+          cause: raw,
+        }),
+      }
+    }
+    if (ctx.userSignal?.aborted) {
+      return {
+        kind: 'aborted',
+        error: new ClientAbortError({
+          ...meta,
+          reason: ctx.userSignal.reason,
+          cause: raw,
+        }),
+      }
+    }
+    // AbortError without a tracked source — treat as user abort with no reason.
+    return {
+      kind: 'aborted',
+      error: new ClientAbortError({ ...meta, cause: raw }),
+    }
+  }
+
+  return null
+}

package/src/client/error-dispatch.ts

@@ -9,7 +9,7 @@ import type { ErrorRegistry, ErrorResponseMeta } from './types.js'
  *   - `fromResponse` returns a non-Error value (defensive — registry entries
  *     are expected to return `Error` subclasses).
  *
- * Callers fall back to `ClientRequestError` when this returns `null`.
+ * Callers fall back to `ClientHttpError` when this returns `null`.
  */
 export function dispatchTypedError(
   registry: ErrorRegistry | undefined,

package/src/client/errors.test.ts

@@ -1,9 +1,40 @@
 import { describe, it, expect } from 'vitest'
-import { ClientRequestError, ClientPathParamError, ClientStreamError } from './errors.js'
+import {
+  ClientHttpError,
+  ClientRequestError,
+  ClientPathParamError,
+  ClientStreamError,
+  ClientNetworkError,
+  ClientTimeoutError,
+  ClientAbortError,
+  ClientParseError,
+} from './errors.js'
+
+describe('ClientHttpError', () => {
+  it('exposes status, headers, body, procedureName, scope', () => {
+    const err = new ClientHttpError({
+      status: 500, headers: { 'x-trace': 'abc' }, body: { error: 'boom' },
+      procedureName: 'GetUser', scope: 'users',
+    })
+    expect(err.status).toBe(500)
+    expect(err.headers['x-trace']).toBe('abc')
+    expect(err.body).toEqual({ error: 'boom' })
+    expect(err.procedureName).toBe('GetUser')
+    expect(err.scope).toBe('users')
+    expect(err.name).toBe('ClientHttpError')
+  })
+
+  it('accepts cause', () => {
+    const cause = new Error('underlying')
+    const err = new ClientHttpError({
+      status: 500, headers: {}, body: null,
+      procedureName: 'X', scope: 'y', cause,
+    })
+    expect(err.cause).toBe(cause)
+  })
 
-describe('ClientRequestError', () => {
   it('includes status, headers, and body', () => {
-    const err = new ClientRequestError({
+    const err = new ClientHttpError({
       status: 401,
       headers: { 'x-request-id': 'abc' },
       body: { message: 'Unauthorized' },
@@ -11,7 +42,7 @@ describe('ClientRequestError', () => {
       scope: 'users',
     })
     expect(err).toBeInstanceOf(Error)
-    expect(err.name).toBe('ClientRequestError')
+    expect(err.name).toBe('ClientHttpError')
     expect(err.status).toBe(401)
     expect(err.headers['x-request-id']).toBe('abc')
     expect(err.body).toEqual({ message: 'Unauthorized' })
@@ -21,6 +52,23 @@ describe('ClientRequestError', () => {
   })
 })
 
+describe('ClientRequestError deprecated alias', () => {
+  it('is identical to ClientHttpError', () => {
+    expect(ClientRequestError).toBe(ClientHttpError)
+  })
+
+  it('instanceof check works against thrown ClientHttpError', () => {
+    // Consumers on the previous major used `catch (e) { if (e instanceof
+    // ClientRequestError) ... }`. The alias must keep that pattern working
+    // until the alias is removed in the next minor cycle's deprecation window.
+    const err = new ClientHttpError({
+      status: 500, headers: {}, body: null,
+      procedureName: 'X', scope: 'y',
+    })
+    expect(err instanceof ClientRequestError).toBe(true)
+  })
+})
+
 describe('ClientPathParamError', () => {
   it('reports missing param', () => {
     const err = new ClientPathParamError('id', '/users/:id', 'GetUser')
@@ -29,6 +77,12 @@ describe('ClientPathParamError', () => {
     expect(err.message).toContain('id')
     expect(err.message).toContain('/users/:id')
   })
+
+  it('accepts and stores cause', () => {
+    const cause = new TypeError('underlying')
+    const err = new ClientPathParamError('id', '/u/:id', 'GetUser', cause)
+    expect(err.cause).toBe(cause)
+  })
 })
 
 describe('ClientStreamError', () => {
@@ -40,4 +94,54 @@ describe('ClientStreamError', () => {
     expect(err.scope).toBe('events')
     expect(err.message).toBe('stream interrupted')
   })
+
+  it('accepts and stores cause', () => {
+    const cause = new Error('underlying')
+    const err = new ClientStreamError('boom', 'StreamUsers', 'users', cause)
+    expect(err.cause).toBe(cause)
+  })
+})
+
+describe('ClientNetworkError', () => {
+  it('carries procedureName, scope, cause', () => {
+    const cause = new TypeError('fetch failed')
+    const err = new ClientNetworkError({
+      procedureName: 'X', scope: 'y', cause,
+    })
+    expect(err.name).toBe('ClientNetworkError')
+    expect(err.procedureName).toBe('X')
+    expect(err.scope).toBe('y')
+    expect(err.cause).toBe(cause)
+  })
+})
+
+describe('ClientTimeoutError', () => {
+  it('carries timeoutMs', () => {
+    const err = new ClientTimeoutError({
+      procedureName: 'X', scope: 'y', timeoutMs: 5000,
+    })
+    expect(err.name).toBe('ClientTimeoutError')
+    expect(err.timeoutMs).toBe(5000)
+  })
+})
+
+describe('ClientAbortError', () => {
+  it('carries reason from abort signal', () => {
+    const err = new ClientAbortError({
+      procedureName: 'X', scope: 'y', reason: 'user-cancelled',
+    })
+    expect(err.name).toBe('ClientAbortError')
+    expect(err.reason).toBe('user-cancelled')
+  })
+})
+
+describe('ClientParseError', () => {
+  it('carries procedureName, scope, cause', () => {
+    const cause = new SyntaxError('Unexpected token')
+    const err = new ClientParseError({
+      procedureName: 'X', scope: 'y', cause,
+    })
+    expect(err.name).toBe('ClientParseError')
+    expect(err.cause).toBe(cause)
+  })
 })

package/src/client/errors.ts

@@ -1,5 +1,5 @@
-export class ClientRequestError extends Error {
-  readonly name = 'ClientRequestError'
+export class ClientHttpError extends Error {
+  readonly name = 'ClientHttpError'
   readonly status: number
   readonly headers: Record<string, string>
   readonly body: unknown
@@ -12,8 +12,12 @@ export class ClientRequestError extends Error {
     body: unknown
     procedureName: string
     scope: string
+    cause?: unknown
   }) {
-    super(`${opts.procedureName} (${opts.scope}) failed with status ${opts.status}`)
+    super(
+      `${opts.procedureName} (${opts.scope}) failed with status ${opts.status}`,
+      { cause: opts.cause }
+    )
     this.status = opts.status
     this.headers = opts.headers
     this.body = opts.body
@@ -22,11 +26,18 @@ export class ClientRequestError extends Error {
   }
 }
 
+/** @deprecated Renamed to `ClientHttpError`. The alias is retained for one minor release after the 7.0.0 major bump and will be removed in a subsequent minor (e.g. 7.1.0). Migrate to `ClientHttpError` now. */
+// eslint-disable-next-line no-redeclare
+export const ClientRequestError = ClientHttpError
+/** @deprecated Renamed to `ClientHttpError`. The alias is retained for one minor release after the 7.0.0 major bump and will be removed in a subsequent minor (e.g. 7.1.0). Migrate to `ClientHttpError` now. */
+// eslint-disable-next-line no-redeclare
+export type ClientRequestError = ClientHttpError
+
 export class ClientPathParamError extends Error {
   readonly name = 'ClientPathParamError'
 
-  constructor(param: string, path: string, procedureName: string) {
-    super(`Missing path parameter "${param}" in "${path}" for procedure ${procedureName}`)
+  constructor(param: string, path: string, procedureName: string, cause?: unknown) {
+    super(`Missing path parameter "${param}" in "${path}" for procedure ${procedureName}`, { cause })
   }
 }
 
@@ -35,9 +46,61 @@ export class ClientStreamError extends Error {
   readonly procedureName: string
   readonly scope: string
 
-  constructor(message: string, procedureName: string, scope: string) {
-    super(message)
+  constructor(message: string, procedureName: string, scope: string, cause?: unknown) {
+    super(message, { cause })
     this.procedureName = procedureName
     this.scope = scope
   }
 }
+
+export class ClientNetworkError extends Error {
+  readonly name = 'ClientNetworkError'
+  readonly procedureName: string
+  readonly scope: string
+
+  constructor(opts: { procedureName: string; scope: string; cause?: unknown; message?: string }) {
+    super(opts.message ?? `${opts.procedureName} (${opts.scope}) failed: network error`, { cause: opts.cause })
+    this.procedureName = opts.procedureName
+    this.scope = opts.scope
+  }
+}
+
+export class ClientTimeoutError extends Error {
+  readonly name = 'ClientTimeoutError'
+  readonly procedureName: string
+  readonly scope: string
+  readonly timeoutMs: number
+
+  constructor(opts: { procedureName: string; scope: string; timeoutMs: number; cause?: unknown }) {
+    super(`${opts.procedureName} (${opts.scope}) timed out after ${opts.timeoutMs}ms`, { cause: opts.cause })
+    this.procedureName = opts.procedureName
+    this.scope = opts.scope
+    this.timeoutMs = opts.timeoutMs
+  }
+}
+
+export class ClientAbortError extends Error {
+  readonly name = 'ClientAbortError'
+  readonly procedureName: string
+  readonly scope: string
+  readonly reason: unknown
+
+  constructor(opts: { procedureName: string; scope: string; reason?: unknown; cause?: unknown }) {
+    super(`${opts.procedureName} (${opts.scope}) aborted`, { cause: opts.cause })
+    this.procedureName = opts.procedureName
+    this.scope = opts.scope
+    this.reason = opts.reason
+  }
+}
+
+export class ClientParseError extends Error {
+  readonly name = 'ClientParseError'
+  readonly procedureName: string
+  readonly scope: string
+
+  constructor(opts: { procedureName: string; scope: string; cause?: unknown; message?: string }) {
+    super(opts.message ?? `${opts.procedureName} (${opts.scope}) response could not be parsed`, { cause: opts.cause })
+    this.procedureName = opts.procedureName
+    this.scope = opts.scope
+  }
+}

package/src/client/fetch-adapter.test.ts

@@ -338,3 +338,18 @@ describe('createFetchAdapter — stream()', () => {
     expect(items).toEqual([{ data: { ok: true }, event: 'message', id: undefined }])
   })
 })
+
+// ── classifyError config ──────────────────────────────
+
+describe('createFetchAdapter classifyError', () => {
+  it('passes through to adapter.classifyError', () => {
+    const customClassifier = vi.fn()
+    const adapter = createFetchAdapter({ classifyError: customClassifier })
+    expect(adapter.classifyError).toBe(customClassifier)
+  })
+
+  it('does not set classifyError when not provided', () => {
+    const adapter = createFetchAdapter()
+    expect(adapter.classifyError).toBeUndefined()
+  })
+})

package/src/client/fetch-adapter.ts

@@ -1,9 +1,10 @@
-import type { ClientAdapter, AdapterRequest, AdapterResponse, AdapterStreamResponse } from './types.js'
+import type { ClientAdapter, AdapterRequest, AdapterResponse, AdapterStreamResponse, ErrorClassifier } from './types.js'
 
 // ── Config ────────────────────────────────────────────────
 
 export interface FetchAdapterConfig {
   headers?: Record<string, string>
+  classifyError?: ErrorClassifier
 }
 
 // ── SSE parser ────────────────────────────────────────────
@@ -180,7 +181,7 @@ export function createFetchAdapter(config?: FetchAdapterConfig): ClientAdapter {
 
       // Non-2xx responses on a stream endpoint are JSON, not SSE. Parse the
       // body eagerly and surface it via errorBody so the client can dispatch
-      // a typed error (or fall back to ClientRequestError with a real body).
+      // a typed error (or fall back to ClientHttpError with a real body).
       if (response.status < 200 || response.status >= 300) {
         const errorBody = await parseResponseBody(response)
         return { status: response.status, headers, body: emptyBody, errorBody }
@@ -193,5 +194,7 @@ export function createFetchAdapter(config?: FetchAdapterConfig): ClientAdapter {
       const body = parseSseStream(response.body as ReadableStream<Uint8Array>)
       return { status: response.status, headers, body }
     },
+
+    classifyError: config?.classifyError,
   }
 }

package/src/client/index.ts

@@ -1,4 +1,4 @@
-import { executeCall } from './call.js'
+import { executeCall, executeSafeCall } from './call.js'
 import { executeStream, createTypedStream } from './stream.js'
 import type {
   CreateClientConfig,
@@ -7,6 +7,7 @@ import type {
   StreamDescriptor,
   ProcedureCallOptions,
   TypedStream,
+  Result,
 } from './types.js'
 
 // ── createClient ──────────────────────────────────────────
@@ -56,6 +57,21 @@ export function createClient<TScopes>(config: CreateClientConfig<TScopes>): TSco
       })
     },
 
+    safeCall<TResponse, ETyped = never>(
+      descriptor: CallDescriptor,
+      options?: ProcedureCallOptions,
+    ): Promise<Result<TResponse, ETyped>> {
+      return executeSafeCall<TResponse, ETyped>({
+        descriptor,
+        basePath,
+        adapter,
+        hooks: globalHooks,
+        defaults: globalDefaults,
+        options,
+        errorRegistry,
+      })
+    },
+
     stream<TYield, TReturn>(
       descriptor: StreamDescriptor,
       options?: ProcedureCallOptions,
@@ -133,15 +149,35 @@ export type {
   ErrorRegistry,
   ErrorFactory,
   ErrorResponseMeta,
+  ClientErrorMap,
+  FrameworkFailure,
+  Result,
+  ResultNoTyped,
 } from './types.js'
 
 export { dispatchTypedError } from './error-dispatch.js'
 
-export { ClientRequestError, ClientPathParamError, ClientStreamError } from './errors.js'
+export {
+  ClientHttpError,
+  ClientRequestError,
+  ClientPathParamError,
+  ClientStreamError,
+  ClientNetworkError,
+  ClientTimeoutError,
+  ClientAbortError,
+  ClientParseError,
+} from './errors.js'
 
 export { createTypedStream } from './stream.js'
-export { executeCall } from './call.js'
+export { executeCall, executeSafeCall } from './call.js'
 export { executeStream } from './stream.js'
 
 export { createFetchAdapter } from './fetch-adapter.js'
 export type { FetchAdapterConfig } from './fetch-adapter.js'
+
+export { defaultClassifyError } from './classify-error.js'
+export type {
+  ErrorClassifier,
+  ClassifyErrorContext,
+  ClassifiedError,
+} from './types.js'

package/src/client/resolve-options.test.ts

@@ -5,6 +5,7 @@ import {
   resolveHeaders,
   resolveMeta,
   resolveSignal,
+  resolveSignalSources,
 } from './resolve-options.js'
 import type { AdapterRequest, ProcedureCallDefaults, ProcedureCallOptions } from './types.js'
 
@@ -141,8 +142,72 @@ describe('resolveSignal', () => {
   })
 })
 
+// ── resolveSignalSources ──────────────────────────────────
+
+describe('resolveSignalSources', () => {
+  it('returns timeout signal alongside combined', () => {
+    const result = resolveSignalSources(undefined, { timeout: 100 })
+    expect(result.timeoutSignal).toBeInstanceOf(AbortSignal)
+    expect(result.timeoutMs).toBe(100)
+    expect(result.combined).toBeInstanceOf(AbortSignal)
+    expect(result.userSignal).toBeUndefined()
+  })
+
+  it('returns user signal alongside combined', () => {
+    const ctrl = new AbortController()
+    const result = resolveSignalSources(undefined, { signal: ctrl.signal })
+    expect(result.userSignal).toBe(ctrl.signal)
+    expect(result.timeoutSignal).toBeUndefined()
+  })
+
+  it('combines both via AbortSignal.any', () => {
+    const ctrl = new AbortController()
+    const result = resolveSignalSources(undefined, { signal: ctrl.signal, timeout: 100 })
+    expect(result.timeoutSignal).toBeInstanceOf(AbortSignal)
+    expect(result.userSignal).toBe(ctrl.signal)
+    expect(result.combined).toBeInstanceOf(AbortSignal)
+  })
+
+  it('returns undefined combined when no signals', () => {
+    const result = resolveSignalSources(undefined, undefined)
+    expect(result.combined).toBeUndefined()
+  })
+
+  it('per-call timeout: 0 disables inherited default timeout', () => {
+    const result = resolveSignalSources({ timeout: 1000 }, { timeout: 0 })
+    expect(result.timeoutSignal).toBeUndefined()
+    expect(result.timeoutMs).toBe(0)
+    expect(result.combined).toBeUndefined()
+  })
+
+  it('merges default signal with per-call signal', () => {
+    const defaultCtrl = new AbortController()
+    const callCtrl = new AbortController()
+    const result = resolveSignalSources(
+      { signal: defaultCtrl.signal },
+      { signal: callCtrl.signal },
+    )
+    // userSignal is the per-call signal (takes precedence)
+    expect(result.userSignal).toBe(callCtrl.signal)
+    // combined should be a new AbortSignal.any
+    expect(result.combined).toBeInstanceOf(AbortSignal)
+    expect(result.combined).not.toBe(callCtrl.signal)
+    expect(result.combined).not.toBe(defaultCtrl.signal)
+    // aborting either source aborts the combined signal
+    defaultCtrl.abort()
+    expect(result.combined!.aborted).toBe(true)
+  })
+})
+
 // ── applyRequestOptions ───────────────────────────────────
 
+// Helper so existing tests can destructure .request without boilerplate
+const apply = (
+  req: AdapterRequest,
+  d: ProcedureCallDefaults | undefined,
+  o: ProcedureCallOptions | undefined,
+) => applyRequestOptions(req, d, o).request
+
 describe('applyRequestOptions', () => {
   const baseRequest: AdapterRequest = {
     url: 'https://api.example.com/foo',
@@ -151,7 +216,7 @@ describe('applyRequestOptions', () => {
   }
 
   it('returns the request unchanged when nothing is provided', () => {
-    const result = applyRequestOptions(baseRequest, undefined, undefined)
+    const result = apply(baseRequest, undefined, undefined)
     expect(result.url).toBe(baseRequest.url)
     expect(result.body).toEqual({ hello: 'world' })
     expect(result.headers).toBeUndefined()
@@ -164,7 +229,7 @@ describe('applyRequestOptions', () => {
       ...baseRequest,
       headers: { 'content-type': 'application/json', 'x-route': 'declared' },
     }
-    const result = applyRequestOptions(
+    const result = apply(
       reqWithHeaders,
       { headers: { 'x-default': 'd', 'x-route': 'from-default' } },
       { headers: { 'x-call': 'c', 'x-route': 'from-call' } },
@@ -179,7 +244,7 @@ describe('applyRequestOptions', () => {
   })
 
   it('attaches meta to the request when provided', () => {
-    const result = applyRequestOptions(baseRequest, undefined, {
+    const result = apply(baseRequest, undefined, {
       meta: { traceId: 'abc' } as never,
     })
     expect(result.meta).toEqual({ traceId: 'abc' })
@@ -187,14 +252,14 @@ describe('applyRequestOptions', () => {
 
   it('passes per-call signal through', () => {
     const controller = new AbortController()
-    const result = applyRequestOptions(baseRequest, undefined, { signal: controller.signal })
+    const result = apply(baseRequest, undefined, { signal: controller.signal })
     expect(result.signal).toBe(controller.signal)
   })
 
   it('attaches a signal when per-call timeout is set', () => {
     const spy = vi.spyOn(AbortSignal, 'timeout')
     try {
-      const result = applyRequestOptions(baseRequest, undefined, { timeout: 100 })
+      const result = apply(baseRequest, undefined, { timeout: 100 })
       expect(spy).toHaveBeenCalledWith(100)
       expect(result.signal).toBeDefined()
       expect(result.signal?.aborted).toBe(false)
@@ -202,4 +267,17 @@ describe('applyRequestOptions', () => {
       spy.mockRestore()
     }
   })
+
+  it('exposes signalSources alongside the request', () => {
+    const ctrl = new AbortController()
+    const { request, signalSources } = applyRequestOptions(baseRequest, undefined, {
+      signal: ctrl.signal,
+      timeout: 500,
+    })
+    expect(request.signal).toBeInstanceOf(AbortSignal)
+    expect(signalSources.userSignal).toBe(ctrl.signal)
+    expect(signalSources.timeoutSignal).toBeInstanceOf(AbortSignal)
+    expect(signalSources.timeoutMs).toBe(500)
+    expect(signalSources.combined).toBe(request.signal)
+  })
 })