ts-procedures 6.2.0 → 7.0.0-beta.1

package/README.md

@@ -52,6 +52,8 @@ const user2 = await procedure({}, { userId: '456' })
 
 - **[Typed Error Handling](docs/http-integrations.md#error-handling)** — Declarative `defineErrorTaxonomy` maps thrown error classes to HTTP responses across every builder; generated clients throw typed class instances you can catch with `instanceof`.
 
+- **[Client Error Handling](docs/client-error-handling.md)** — Normalized framework error classes (`ClientHttpError`, `ClientNetworkError`, `ClientTimeoutError`, `ClientAbortError`, `ClientParseError`), `.safe()` Result API for exhaustive narrowing without try/catch, and augmentable `ClientErrorMap` for custom error categories.
+
 - **[AI Agent Setup](docs/ai-agent-setup.md)** — Built-in configuration for Claude Code, Cursor, and GitHub Copilot. Auto-updates on `npm install`.
 
 Full documentation is available on [GitHub](https://github.com/thermsio/ts-procedures).

package/agent_config/claude-code/skills/ts-procedures/SKILL.md

@@ -175,7 +175,8 @@ The npm package ships user-facing documentation with narrative explanations and
 | `docs/streaming.md` | Streaming procedures, AbortSignal, SSE patterns |
 | `docs/http-integrations.md` | Express RPC, Hono RPC/Stream/API builders, **error taxonomy (canonical)**, DocRegistry (unified constructor, `.documentError()`) |
 | `docs/client-and-codegen.md` | Client code generation, `createApiClient`/`createClient`, typed error dispatch, per-route `Errors` unions, per-call options, client-level defaults, typed RequestMeta augmentation, CLI options |
-| `CHANGELOG.md` | Release notes — see `[6.0.0]` for the current peer error-handling model (taxonomy + `onError` + `onRequestError`), per-route errors, and client runtime error classes. |
+| `docs/client-error-handling.md` | **Canonical guide** for 7.0+ client error surface: normalized error classes, `.safe()` Result API, `ClientErrorMap` augmentation, custom `ErrorClassifier`, migration from `ClientRequestError`. |
+| `CHANGELOG.md` | Release notes — see `[7.0.0]` for the safe-result API, new error classes, and `ClientRequestError` → `ClientHttpError` rename. See `[6.0.0]` for the peer error-handling model (taxonomy + `onError` + `onRequestError`). |
 
 ## Workflow
 

package/agent_config/claude-code/skills/ts-procedures/anti-patterns.md

@@ -612,7 +612,7 @@ Create('GetUser', {
 
 ## 20. Hand-writing `onError` instanceof ladders
 
-**Problem:** Writing manual `instanceof` ladders inside `onError` to map each error class to a status + body. Every builder gets its own copy; generated clients see opaque `ClientRequestError` objects instead of typed instances; response shapes drift between routes.
+**Problem:** Writing manual `instanceof` ladders inside `onError` to map each error class to a status + body. Every builder gets its own copy; generated clients see opaque `ClientHttpError` objects instead of typed instances; response shapes drift between routes.
 
 ```typescript
 // BAD — duplicated across builders, invisible to generated clients
@@ -659,6 +659,42 @@ The same `errors` / `unknownError` shape plugs into every builder (`HonoAPIAppBu
 
 ---
 
+## 21. Catching raw `DOMException` or `TypeError` from generated callables
+
+**Problem:** Checking `instanceof DOMException` or `instanceof TypeError` in `catch` blocks after calling a generated RPC/API callable. The framework normalizes these platform errors into typed framework classes at the `executeCall` boundary — after 7.0.0, raw platform errors will not reach your `catch` block from a generated callable. The original platform error is preserved on `error.cause` if you need it.
+
+```typescript
+// BAD — platform error classes won't reach here from a generated callable
+catch (e) {
+  if (e instanceof DOMException && e.name === 'AbortError') {
+    // Was this a timeout or a user cancel? Hard to tell.
+  }
+  if (e instanceof TypeError) {
+    // Network failure? Something else?
+  }
+}
+```
+
+**Fix:** Catch the framework error classes instead.
+
+```typescript
+// GOOD
+import { ClientTimeoutError, ClientAbortError, ClientNetworkError } from 'ts-procedures/client'
+
+catch (e) {
+  if (e instanceof ClientTimeoutError)  Alerts.error('Timed out')
+  else if (e instanceof ClientAbortError)  { /* user cancelled — silent */ }
+  else if (e instanceof ClientNetworkError)  Alerts.error('Network error')
+  else throw e  // unknown — let it propagate
+}
+```
+
+Or use the `.safe()` sibling for exhaustive Result-based narrowing (see `patterns.md` — "Handling errors in client code").
+
+**Why:** The framework wraps `AbortError` (from timeout or signal) into `ClientTimeoutError` / `ClientAbortError` and `TypeError`/fetch network failures into `ClientNetworkError`. This gives you distinct, meaningful types and removes ambiguity. Streams keep the throwing form — `.safe()` is only available on RPC and API callables.
+
+---
+
 ## Summary Table
 
 | # | Anti-Pattern | Risk | Severity |
@@ -683,3 +719,4 @@ The same `errors` / `unknownError` shape plugs into every builder (`HonoAPIAppBu
 | 18 | Both schema.params and schema.input | ProcedureRegistrationError at startup | CRITICAL |
 | 19 | Mismatched path param names | Build-time error or confusing validation failures | CRITICAL |
 | 20 | Hand-writing onError instanceof ladders | Drifting response shapes, untyped client errors | WARNING |
+| 21 | Catching raw DOMException/TypeError from generated callables | Framework normalizes these; raw platform errors won't reach catch blocks after 7.0.0 | WARNING |

package/agent_config/claude-code/skills/ts-procedures/api-reference.md

@@ -354,7 +354,7 @@ Returns a typed error instance when:
 - `body` is an object with a string `name`, AND
 - `registry[body.name].fromResponse(body, meta)` returns an `Error` subclass.
 
-Otherwise returns `null`; callers fall back to `ClientRequestError`.
+Otherwise returns `null`; callers fall back to `ClientHttpError`.
 
 ### CreateClientConfig.errorRegistry
 
@@ -369,6 +369,227 @@ Threaded into both `executeCall` and `executeStream`. The generated `create${Ser
 
 ---
 
+## Client Error Classes (7.0+)
+
+All framework errors are normalized at the `executeCall` / `executeStream` boundary — raw `TypeError` and `DOMException` from the platform never reach consumer catch blocks.
+
+### ClientHttpError
+
+```typescript
+class ClientHttpError extends Error {
+  readonly status: number
+  readonly cause?: unknown
+}
+```
+
+Thrown for non-2xx HTTP responses whose body does not match any registry entry (or when no registry is configured). Renamed from `ClientRequestError` in 7.0.0; the old name is re-exported as a deprecated alias for one minor cycle.
+
+### ClientNetworkError
+
+```typescript
+class ClientNetworkError extends Error {
+  readonly cause?: unknown
+}
+```
+
+Thrown when the network request itself fails (e.g., DNS failure, connection refused — a `TypeError` from `fetch`). The original error is available on `cause`.
+
+### ClientTimeoutError
+
+```typescript
+class ClientTimeoutError extends Error {
+  readonly cause?: unknown
+}
+```
+
+Thrown when the request is aborted by a timeout (`AbortSignal.timeout`). The original `DOMException` is available on `cause`.
+
+### ClientAbortError
+
+```typescript
+class ClientAbortError extends Error {
+  readonly cause?: unknown
+}
+```
+
+Thrown when the request is aborted by a caller-supplied `AbortSignal`. The original `DOMException` is available on `cause`.
+
+### ClientParseError
+
+```typescript
+class ClientParseError extends Error {
+  readonly cause?: unknown
+}
+```
+
+Thrown when the response body cannot be parsed as JSON (e.g., the server returned HTML for a non-2xx status). The parse error is available on `cause`.
+
+### ClientPathParamError
+
+```typescript
+class ClientPathParamError extends Error {}
+```
+
+Thrown at call time when a required path parameter is missing in the options. This is a programming error (the generated callable could not interpolate the URL path).
+
+### ClientStreamError
+
+```typescript
+class ClientStreamError extends Error {
+  readonly cause?: unknown
+}
+```
+
+Thrown for stream-level transport errors (SSE connection failures, unexpected stream termination).
+
+---
+
+## Safe-Result API (7.0+)
+
+### Result\<T, ETyped\>
+
+```typescript
+type Result<T, ETyped = never> =
+  | { ok: true; value: T }
+  | FrameworkFailure<ETyped>
+```
+
+Returned by every generated `.safe()` callable. When `ok` is `true`, `value` is the typed response. When `ok` is `false`, the failure is discriminated by `kind`.
+
+### ResultNoTyped\<T\>
+
+```typescript
+type ResultNoTyped<T> = Result<T, never>
+```
+
+Convenience alias when no typed error registry is wired (all failures are framework-level).
+
+### FrameworkFailure\<ETyped\>
+
+```typescript
+type FrameworkFailure<ETyped = never> =
+  | { ok: false; kind: 'typed';   error: ETyped }
+  | { ok: false; kind: 'http';    error: ClientHttpError }
+  | { ok: false; kind: 'network'; error: ClientNetworkError }
+  | { ok: false; kind: 'timeout'; error: ClientTimeoutError }
+  | { ok: false; kind: 'aborted'; error: ClientAbortError }
+  | { ok: false; kind: 'parse';   error: ClientParseError }
+  | { ok: false; kind: 'usage';   error: ClientPathParamError }
+  | { ok: false; kind: 'unknown'; error: unknown }
+  // + any augmented kinds from ClientErrorMap
+```
+
+The failure branch of `Result`. Discriminate on `kind` to narrow `error`.
+
+### ClientErrorMap
+
+```typescript
+interface ClientErrorMap {
+  // empty — designed for declaration merging
+}
+```
+
+Augment this interface to add custom `kind` entries to `FrameworkFailure`. Example:
+
+```typescript
+declare module 'ts-procedures/client' {
+  interface ClientErrorMap {
+    rateLimit: RateLimitError
+  }
+}
+```
+
+After augmentation, `r.kind === 'rateLimit'` is a valid branch in a `switch` over `FrameworkFailure`.
+
+### ClientInstance.safeCall\<TResponse, ETyped\>(descriptor, options)
+
+```typescript
+interface ClientInstance {
+  safeCall<TResponse, ETyped = never>(
+    descriptor: CallDescriptor,
+    options?: ProcedureCallOptions
+  ): Promise<Result<TResponse, ETyped>>
+}
+```
+
+The underlying method that all generated `.safe()` callables delegate to. When `ETyped` is provided, it is the type of the `typed` failure branch (the registry-dispatched error class). Streams do not expose a `.safe()` sibling — `safeCall` applies to RPC and API calls only.
+
+### ClientInstance.bindCallable / bindCallableTyped
+
+Helper methods used by codegen to wire each generated callable. Returns a callable function with a `.safe` sibling. The returned function's `.name` is set to `descriptor.name` for nicer stack traces.
+
+```typescript
+// For routes without typed errors
+bindCallable<TParams, TResponse>(
+  descriptor: Omit<CallDescriptor, 'params'>,
+): {
+  (params: TParams, options?: ProcedureCallOptions): Promise<TResponse>
+  safe(params: TParams, options?: ProcedureCallOptions): Promise<ResultNoTyped<TResponse>>
+}
+
+// For routes with typed errors
+bindCallableTyped<TParams, TResponse, ETyped>(
+  descriptor: Omit<CallDescriptor, 'params'>,
+): {
+  (params: TParams, options?: ProcedureCallOptions): Promise<TResponse>
+  safe(params: TParams, options?: ProcedureCallOptions): Promise<Result<TResponse, ETyped>>
+}
+```
+
+`descriptor` is `Omit<CallDescriptor, 'params'>` — params is supplied at call time. Codegen emits a compact one-liner per route:
+
+```typescript
+// Generated (no declared errors):
+GetUser: client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>({
+  name: 'GetUser', scope: 'users', path: '/users/1', method: 'post', kind: 'rpc',
+}),
+
+// Generated (with declared errors):
+GetUser: client.bindCallableTyped<Users.GetUser.Params, Users.GetUser.Response, Users.GetUser.Errors>({
+  name: 'GetUser', scope: 'users', path: '/users/1', method: 'post', kind: 'rpc',
+}),
+```
+
+Hand-written clients that mimic the codegen pattern can also use these helpers directly on the `ClientInstance` passed to the `scopes` factory.
+
+---
+
+## Error Classifier API (7.0+)
+
+### defaultClassifyError
+
+```typescript
+function defaultClassifyError(err: unknown, ctx: ClassifyErrorContext): ClassifiedError | null
+```
+
+The built-in classifier that maps raw platform errors to framework classes. Returns a `ClassifiedError` (with `kind` + `error`) when the error is recognized, or `null` to fall through to `unknown`. Pass a custom `ErrorClassifier` to `createFetchAdapter` / `ClientAdapter` to override or extend.
+
+### ErrorClassifier
+
+```typescript
+type ErrorClassifier = (err: unknown, ctx: ClassifyErrorContext) => ClassifiedError | null
+```
+
+### ClassifyErrorContext
+
+```typescript
+interface ClassifyErrorContext {
+  request: AdapterRequest
+  signal?: AbortSignal
+}
+```
+
+### ClassifiedError
+
+```typescript
+interface ClassifiedError {
+  kind: keyof ClientErrorMap | 'network' | 'timeout' | 'aborted' | 'parse' | 'unknown'
+  error: Error
+}
+```
+
+---
+
 ## Schema Utilities
 
 ### extractJsonSchema(libSchema)
@@ -986,12 +1207,14 @@ Creates a `ClientAdapter` using the global `fetch` API.
 ```typescript
 function createFetchAdapter(options?: {
   fetch?: typeof globalThis.fetch
+  classifyError?: ErrorClassifier
 }): ClientAdapter
 ```
 
 ### Parameters
 
 - `options.fetch` — Optional custom fetch implementation. Defaults to `globalThis.fetch`.
+- `options.classifyError` — Optional classifier override. When provided, replaces `defaultClassifyError` for mapping raw platform errors to framework classes. Use this to add custom `ClientErrorMap` categories or to adjust the default mapping.
 
 ### Return Value
 
@@ -1212,8 +1435,35 @@ import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
 import type { APIConfig, APIHttpRouteDoc, APIInput, HttpMethod } from 'ts-procedures/hono-api'
 
 // Client
-import { createClient, createFetchAdapter } from 'ts-procedures/client'
-import type { ClientAdapter, ClientHooks, ClientInstance, TypedStream } from 'ts-procedures/client'
+import {
+  createClient,
+  createFetchAdapter,
+  dispatchTypedError,
+  defaultClassifyError,
+  // Error classes (7.0+)
+  ClientHttpError,       // renamed from ClientRequestError; deprecated alias retained one cycle
+  ClientNetworkError,
+  ClientTimeoutError,
+  ClientAbortError,
+  ClientParseError,
+  ClientPathParamError,
+  ClientStreamError,
+} from 'ts-procedures/client'
+import type {
+  ClientAdapter,
+  ClientHooks,
+  ClientInstance,
+  TypedStream,
+  // Safe-result types (7.0+)
+  Result,
+  ResultNoTyped,
+  FrameworkFailure,
+  ClientErrorMap,
+  // Classifier types (7.0+)
+  ErrorClassifier,
+  ClassifyErrorContext,
+  ClassifiedError,
+} from 'ts-procedures/client'
 
 // Code generation
 import { generateClient } from 'ts-procedures/codegen'

package/agent_config/claude-code/skills/ts-procedures/patterns.md

@@ -242,7 +242,7 @@ try {
   } else if (err instanceof ApiErrors.ApiProcedureError) {
     // Catch-all for any generated service error.
   } else {
-    // Transport error (network, non-JSON body) — still a ClientRequestError.
+    // Transport error (network, non-JSON body) — still a ClientHttpError.
   }
 }
 ```
@@ -263,13 +263,71 @@ export namespace Users {
 catch (err: unknown) {
   // Cast is manual today (TS has no typed throws); the union documents
   // which errors this specific route can throw.
-  const e = err as Users.GetUser.Errors | ClientRequestError
+  const e = err as Users.GetUser.Errors | ClientHttpError
   if (e instanceof ApiErrors.UseCaseError) { /* ... */ }
 }
 ```
 
 ---
 
+## Handling errors in client code
+
+The framework normalizes platform errors (`TypeError`, `DOMException`) into framework error classes at the `executeCall` boundary. Consumers see typed framework classes, not raw platform errors.
+
+### Throwing form (canonical)
+
+```typescript
+import { ClientHttpError, ClientTimeoutError, ClientNetworkError, ClientAbortError } from 'ts-procedures/client'
+import { createApiClient, ApiErrors, createFetchAdapter } from './generated'
+
+const api = createApiClient({ adapter: createFetchAdapter(), basePath: 'https://api.example.com' })
+
+try {
+  const response = await api.records.DownloadRecord(params, { timeout: 60_000 })
+  if (response.pdfBase64) downloadBase64AsPdf(response.pdfBase64)
+} catch (err) {
+  if (err instanceof ApiErrors.UseCaseError) {
+    Alerts.error(err.body.message)
+  } else if (err instanceof ClientHttpError) {
+    Alerts.error(`Server returned ${err.status}`)
+  } else if (err instanceof ClientTimeoutError) {
+    Alerts.error('Request timed out')
+  } else if (err instanceof ClientNetworkError) {
+    Alerts.error('Network error')
+  } else if (err instanceof ClientAbortError) {
+    // user cancelled — silent
+  } else {
+    throw err  // programmer/framework bug
+  }
+}
+```
+
+### Safe form (Result-returning, exhaustive narrowing)
+
+Every RPC and API callable has a `.safe()` sibling that returns `Result<T, ETyped>` instead of throwing:
+
+```typescript
+const r = await api.records.DownloadRecord.safe(params, { timeout: 60_000 })
+if (r.ok) {
+  if (r.value.pdfBase64) downloadBase64AsPdf(r.value.pdfBase64)
+  return
+}
+switch (r.kind) {
+  case 'typed':    /* registry-dispatched typed error, e.g. ApiErrors.UseCaseError */; break
+  case 'http':     Alerts.error(`Server ${r.error.status}`); break
+  case 'network':  Alerts.error('Network error'); break
+  case 'timeout':  Alerts.error('Timed out'); break
+  case 'aborted':  break  // user cancelled
+  case 'parse':
+  case 'usage':    throw r.error  // programmer/framework bug
+  case 'unknown':  console.error(r.error); break
+}
+```
+
+Streams keep the throwing form (no `.safe`). Custom error categories can be added via `ClientErrorMap` interface augmentation — see `docs/client-error-handling.md`.
+
+---
+
 ## Stream Procedures
 
 ```typescript

package/agent_config/claude-code/skills/ts-procedures-scaffold/templates/client.md

@@ -50,7 +50,7 @@ export const {{name}}Client = createApiClient({
 // } catch (err) {
 //   if (err instanceof ApiErrors.UseCaseError) { /* err.body typed; err.status, procedureName, scope */ }
 //   else if (err instanceof ApiErrors.ApiProcedureError) { /* catch-all for service errors */ }
-//   else { /* transport error — ClientRequestError */ }
+//   else { /* transport error — ClientHttpError */ }
 // }
 
 // --- RPC call example ---

package/agent_config/copilot/copilot-instructions.md

@@ -280,6 +280,8 @@ try {
 
 Per-route error unions: routes with `errors: [...]` get an `Errors` type in their namespace (e.g. `Users.GetUser.Errors = ApiErrors.UseCaseError | ApiErrors.AuthError`).
 
+- Generated client error handling: catch the framework classes (`ClientHttpError`, `ClientNetworkError`, `ClientTimeoutError`, `ClientAbortError`), not raw `DOMException`/`TypeError` — the framework normalizes platform errors at the `executeCall` boundary, so raw platform errors no longer reach `catch` blocks after 7.0.0 (original is on `error.cause`). Use the `.safe()` sibling on RPC/API callables for an exhaustive `Result<T, E>` switch (`ok`, `typed`, `http`, `network`, `timeout`, `aborted`, `parse`, `usage`, `unknown`). Streams keep the throwing form — no `.safe()`.
+
 ## Lifecycle Hook Order
 
 ### Standard RPC
@@ -327,6 +329,7 @@ onRequestStart → factoryContext() → validation → onStreamStart → handler
 9. **Never assume extra params fields survive** — `removeAdditional: true` strips them
 10. **Never manually parse types AJV coerces** — `coerceTypes: true` handles it
 11. **Never define both schema.params and schema.input** — mutually exclusive, throws ProcedureRegistrationError
+12. **Never catch raw DOMException/TypeError from generated callables** — catch `ClientTimeoutError`, `ClientAbortError`, `ClientNetworkError` instead; or use `.safe()` for Result-based narrowing
 
 ## Testing
 

package/agent_config/cursor/cursorrules

@@ -280,6 +280,8 @@ try {
 
 Per-route error unions: routes with `errors: [...]` get an `Errors` type in their namespace (e.g. `Users.GetUser.Errors = ApiErrors.UseCaseError | ApiErrors.AuthError`).
 
+- Generated client error handling: catch the framework classes (`ClientHttpError`, `ClientNetworkError`, `ClientTimeoutError`, `ClientAbortError`), not raw `DOMException`/`TypeError` — the framework normalizes platform errors at the `executeCall` boundary, so raw platform errors no longer reach `catch` blocks after 7.0.0 (original is on `error.cause`). Use the `.safe()` sibling on RPC/API callables for an exhaustive `Result<T, E>` switch (`ok`, `typed`, `http`, `network`, `timeout`, `aborted`, `parse`, `usage`, `unknown`). Streams keep the throwing form — no `.safe()`.
+
 ## Lifecycle Hook Order
 
 ### Standard RPC
@@ -327,6 +329,7 @@ onRequestStart → factoryContext() → validation → onStreamStart → handler
 9. **Never assume extra params fields survive** — `removeAdditional: true` strips them
 10. **Never manually parse types AJV coerces** — `coerceTypes: true` handles it
 11. **Never define both schema.params and schema.input** — mutually exclusive, throws ProcedureRegistrationError
+12. **Never catch raw DOMException/TypeError from generated callables** — catch `ClientTimeoutError`, `ClientAbortError`, `ClientNetworkError` instead; or use `.safe()` for Result-based narrowing
 
 ## Testing
 

package/build/client/augment-error-map.test-d.d.ts

@@ -0,0 +1,10 @@
+declare class RateLimitError extends Error {
+    retryAfter: number;
+    constructor(retryAfter: number);
+}
+declare module './types.js' {
+    interface ClientErrorMap {
+        rateLimited: RateLimitError;
+    }
+}
+export {};

package/build/client/augment-error-map.test-d.js

@@ -0,0 +1,14 @@
+import { describe, it, expectTypeOf } from 'vitest';
+class RateLimitError extends Error {
+    retryAfter;
+    constructor(retryAfter) {
+        super('rate limited');
+        this.retryAfter = retryAfter;
+    }
+}
+describe('ClientErrorMap augmentation', () => {
+    it('adds rateLimited kind to Result', () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+});
+//# sourceMappingURL=augment-error-map.test-d.js.map

package/build/client/augment-error-map.test-d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"augment-error-map.test-d.js","sourceRoot":"","sources":["../../src/client/augment-error-map.test-d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAGnD,MAAM,cAAe,SAAQ,KAAK;IACb;IAAnB,YAAmB,UAAkB;QACnC,KAAK,CAAC,cAAc,CAAC,CAAA;QADJ,eAAU,GAAV,UAAU,CAAQ;IAErC,CAAC;CACF;AAQD,QAAQ,CAAC,6BAA6B,EAAE,GAAG,EAAE;IAC3C,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE;QAGzC,YAAY,EAAwB,CAAC,aAAa,EAAkB,CAAA;IACtE,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/build/client/bind-callable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/client/bind-callable.test.js

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createClient } from './index.js';
+import { ClientHttpError, ClientNetworkError } from './errors.js';
+const okAdapter = {
+    request: vi.fn(async () => ({ status: 200, headers: {}, body: { id: '42' } })),
+    stream: vi.fn(async () => { throw new Error('n/a'); }),
+};
+describe('ClientInstance.bindCallable', () => {
+    it('returns a callable that throws on failure', async () => {
+        const client = createClient({
+            adapter: { request: vi.fn(async () => { throw new TypeError('x'); }), stream: vi.fn(async () => { throw new Error('n/a'); }) },
+            basePath: 'https://api.x',
+            scopes: (c) => ({
+                getUser: c.bindCallable({
+                    name: 'GetUser', scope: 'users', path: '/users/:id', method: 'get', kind: 'rpc',
+                }),
+            }),
+        });
+        await expect(client.getUser({ id: '1' })).rejects.toBeInstanceOf(ClientNetworkError);
+    });
+    it('exposes .safe returning ResultNoTyped', async () => {
+        const client = createClient({
+            adapter: { request: vi.fn(async () => ({ status: 500, headers: {}, body: {} })), stream: vi.fn(async () => { throw new Error('n/a'); }) },
+            basePath: 'https://api.x',
+            scopes: (c) => ({
+                getUser: c.bindCallable({
+                    name: 'GetUser', scope: 'users', path: '/users/:id', method: 'get', kind: 'rpc',
+                }),
+            }),
+        });
+        const r = await client.getUser.safe({ id: '1' });
+        expect(r.ok).toBe(false);
+        if (!r.ok) {
+            expect(r.kind).toBe('http');
+            expect(r.error).toBeInstanceOf(ClientHttpError);
+        }
+    });
+    it('preserves descriptor.name as fn.name for stack traces', () => {
+        const client = createClient({
+            adapter: okAdapter,
+            basePath: 'https://api.x',
+            scopes: (c) => ({
+                getUser: c.bindCallable({
+                    name: 'GetUser', scope: 'users', path: '/users/:id', method: 'get', kind: 'rpc',
+                }),
+            }),
+        });
+        expect(client.getUser.name).toBe('GetUser');
+    });
+    it('resolves the response value on success', async () => {
+        const client = createClient({
+            adapter: { request: vi.fn(async () => ({ status: 200, headers: {}, body: { id: '42' } })), stream: vi.fn(async () => { throw new Error('n/a'); }) },
+            basePath: 'https://api.x',
+            scopes: (c) => ({
+                getUser: c.bindCallable({
+                    name: 'GetUser', scope: 'users', path: '/users/:id', method: 'get', kind: 'rpc',
+                }),
+            }),
+        });
+        const result = await client.getUser({ id: '1' });
+        expect(result).toEqual({ id: '42' });
+    });
+    it('.safe resolves with ok: true on success', async () => {
+        const client = createClient({
+            adapter: { request: vi.fn(async () => ({ status: 200, headers: {}, body: { id: '42' } })), stream: vi.fn(async () => { throw new Error('n/a'); }) },
+            basePath: 'https://api.x',
+            scopes: (c) => ({
+                getUser: c.bindCallable({
+                    name: 'GetUser', scope: 'users', path: '/users/:id', method: 'get', kind: 'rpc',
+                }),
+            }),
+        });
+        const r = await client.getUser.safe({ id: '1' });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.value).toEqual({ id: '42' });
+        }
+    });
+});
+describe('ClientInstance.bindCallableTyped', () => {
+    it('exposes .safe returning Result with typed errors', async () => {
+        class ApiUseCaseError extends Error {
+            status;
+            constructor(status) {
+                super('use-case');
+                this.status = status;
+            }
+        }
+        const client = createClient({
+            adapter: { request: vi.fn(async () => ({ status: 500, headers: {}, body: {} })), stream: vi.fn(async () => { throw new Error('n/a'); }) },
+            basePath: 'https://api.x',
+            scopes: (c) => ({
+                getUser: c.bindCallableTyped({
+                    name: 'GetUser', scope: 'users', path: '/users/:id', method: 'get', kind: 'rpc',
+                }),
+            }),
+        });
+        const r = await client.getUser.safe({ id: '1' });
+        expect(r.ok).toBe(false);
+        // Falls through to 'http' since no registry was wired — the test verifies
+        // the .safe surface exists, not the typed dispatch path.
+        if (!r.ok) {
+            expect(['http', 'typed', 'network', 'timeout', 'aborted', 'parse', 'usage', 'unknown']).toContain(r.kind);
+        }
+    });
+    it('preserves descriptor.name as fn.name for stack traces', () => {
+        const client = createClient({
+            adapter: okAdapter,
+            basePath: 'https://api.x',
+            scopes: (c) => ({
+                getUser: c.bindCallableTyped({
+                    name: 'GetUser', scope: 'users', path: '/users/:id', method: 'get', kind: 'rpc',
+                }),
+            }),
+        });
+        expect(client.getUser.name).toBe('GetUser');
+    });
+    it('resolves the response value on success', async () => {
+        const client = createClient({
+            adapter: { request: vi.fn(async () => ({ status: 200, headers: {}, body: { id: '99' } })), stream: vi.fn(async () => { throw new Error('n/a'); }) },
+            basePath: 'https://api.x',
+            scopes: (c) => ({
+                getUser: c.bindCallableTyped({
+                    name: 'GetUser', scope: 'users', path: '/users/:id', method: 'get', kind: 'rpc',
+                }),
+            }),
+        });
+        const result = await client.getUser({ id: '1' });
+        expect(result).toEqual({ id: '99' });
+    });
+});
+//# sourceMappingURL=bind-callable.test.js.map