ts-procedures 7.0.0-beta.0 → 7.0.0

package/src/client/bind-callable.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi } from 'vitest'
+import { createClient } from './index.js'
+import { ClientHttpError, ClientNetworkError } from './errors.js'
+import type { ClientAdapter } from './types.js'
+
+const okAdapter: ClientAdapter = {
+  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<{ id: string }, { id: string }>({
+          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<{ id: string }, { id: string }>({
+          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<{ id: string }, { id: string }>({
+          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<{ id: string }, { id: string }>({
+          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<{ id: string }, { id: string }>({
+          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 {
+      constructor(public status: number) { super('use-case') }
+    }
+    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<{ id: string }, { id: string }, ApiUseCaseError>({
+          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<{ id: string }, { id: string }, Error>({
+          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<{ id: string }, { id: string }, Error>({
+          name: 'GetUser', scope: 'users', path: '/users/:id', method: 'get', kind: 'rpc',
+        }),
+      }),
+    })
+    const result = await client.getUser({ id: '1' })
+    expect(result).toEqual({ id: '99' })
+  })
+})

package/src/client/index.ts

@@ -8,6 +8,7 @@ import type {
   ProcedureCallOptions,
   TypedStream,
   Result,
+  ResultNoTyped,
 } from './types.js'
 
 // ── createClient ──────────────────────────────────────────
@@ -72,6 +73,26 @@ export function createClient<TScopes>(config: CreateClientConfig<TScopes>): TSco
       })
     },
 
+    bindCallable<TParams, TResponse>(descriptor: Omit<CallDescriptor, 'params'>) {
+      const call = (params: TParams, options?: ProcedureCallOptions) =>
+        instance.call<TResponse>({ ...descriptor, params }, options)
+      Object.defineProperty(call, 'name', { value: descriptor.name, configurable: true })
+      return Object.assign(call, {
+        safe: (params: TParams, options?: ProcedureCallOptions) =>
+          instance.safeCall<TResponse>({ ...descriptor, params }, options) as Promise<ResultNoTyped<TResponse>>,
+      })
+    },
+
+    bindCallableTyped<TParams, TResponse, ETyped>(descriptor: Omit<CallDescriptor, 'params'>) {
+      const call = (params: TParams, options?: ProcedureCallOptions) =>
+        instance.call<TResponse>({ ...descriptor, params }, options)
+      Object.defineProperty(call, 'name', { value: descriptor.name, configurable: true })
+      return Object.assign(call, {
+        safe: (params: TParams, options?: ProcedureCallOptions) =>
+          instance.safeCall<TResponse, ETyped>({ ...descriptor, params }, options),
+      })
+    },
+
     stream<TYield, TReturn>(
       descriptor: StreamDescriptor,
       options?: ProcedureCallOptions,

package/src/client/types.ts

@@ -237,6 +237,31 @@ export interface ClientInstance {
     options?: ProcedureCallOptions,
   ): Promise<Result<TResponse, ETyped>>
   stream<TYield, TReturn>(descriptor: StreamDescriptor, options?: ProcedureCallOptions): TypedStream<TYield, TReturn>
+  /**
+   * Wires a callable with a `.safe` sibling for routes without declared typed errors.
+   * Used by codegen to produce a compact one-line callable per route.
+   *
+   * The returned function's `.name` is set to `descriptor.name` for nicer stack traces.
+   */
+  bindCallable<TParams, TResponse>(
+    descriptor: Omit<CallDescriptor, 'params'>,
+  ): {
+    (params: TParams, options?: ProcedureCallOptions): Promise<TResponse>
+    safe(params: TParams, options?: ProcedureCallOptions): Promise<ResultNoTyped<TResponse>>
+  }
+  /**
+   * Wires a callable with a `.safe` sibling for routes with declared typed errors.
+   * The `.safe` form returns `Result<TResponse, ETyped>` where `ETyped` is the
+   * union of route-declared error classes.
+   *
+   * The returned function's `.name` is set to `descriptor.name` for nicer stack traces.
+   */
+  bindCallableTyped<TParams, TResponse, ETyped>(
+    descriptor: Omit<CallDescriptor, 'params'>,
+  ): {
+    (params: TParams, options?: ProcedureCallOptions): Promise<TResponse>
+    safe(params: TParams, options?: ProcedureCallOptions): Promise<Result<TResponse, ETyped>>
+  }
 }
 
 // ── createClient Config ──────────────────────────────────

package/src/codegen/bundle-size.test.ts

@@ -59,7 +59,9 @@ describe('bundle size budget', () => {
     // and link back to spec section "Tests / item 10". For now this guard
     // catches catastrophic regressions only, not subtle bloat.
     //
-    // PERROUTEDELTA_BASELINE: 613.2
+    // PERROUTEDELTA_BASELINE: 613.2 (7.0.0-beta.0, Object.assign inline emission)
+    // After bindCallable refactor (beta.1): baseline dropped to 218.8 (~64% reduction)
+    // — Object.assign + duplicated descriptor removed; one helper call per route.
     expect(perRouteDelta).toBeLessThan(1500)
   })
 

package/src/codegen/e2e.test.ts

@@ -223,12 +223,12 @@ describe('E2E: generateClient full pipeline', () => {
     expect(content).toContain('bindUsersScope')
   })
 
-  it('users.ts uses client.call for RPC route', async () => {
+  it('users.ts uses client.bindCallable for RPC route', async () => {
     tmpDir = makeTmpDir()
     await generateClient({ envelope, outDir: tmpDir })
 
     const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
-    expect(content).toContain('client.call')
+    expect(content).toContain('client.bindCallable<')
   })
 
   // ── events.ts — Stream route ───────────────────────────────────────────────
@@ -764,10 +764,9 @@ void run
       await generateClient({ envelope, outDir: tmpDir, namespaceTypes: true })
 
       const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
-      expect(content).toContain('params: Users.GetUser.Params')
-      expect(content).toContain('Promise<Users.GetUser.Response>')
-      expect(content).toContain('params: Users.UpdateUser.Params')
-      expect(content).toContain('Promise<Users.UpdateUser.Response>')
+      // New emission: client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>({...})
+      expect(content).toContain('client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>')
+      expect(content).toContain('client.bindCallable<Users.UpdateUser.Params, Users.UpdateUser.Response>')
     })
 
     it('events.ts wraps stream types in namespace', async () => {

package/src/codegen/emit-client-runtime.ts

@@ -27,6 +27,7 @@ const TYPES_IMPORT = `import type {
   ClassifyErrorContext,
   ClassifiedError,
   Result,
+  ResultNoTyped,
   ClientErrorMap,
   FrameworkFailure,
 } from './_types'`

package/src/codegen/emit-scope.test.ts

@@ -272,7 +272,7 @@ describe('emitScopeFile', () => {
 
     it('imports ClientInstance and ProcedureCallOptions but not TypedStream', async () => {
       const output = await emitScopeFile(rpcGroup)
-      expect(output).toContain("import type { ClientInstance, ProcedureCallOptions, Result, ResultNoTyped } from 'ts-procedures/client'")
+      expect(output).toContain("import type { ClientInstance, ProcedureCallOptions } from 'ts-procedures/client'")
       expect(output).not.toContain('TypedStream')
     })
 
@@ -291,10 +291,10 @@ describe('emitScopeFile', () => {
       expect(output).toContain('export function bindUsersScope(client: ClientInstance)')
     })
 
-    it('callable uses client.call with kind: rpc', async () => {
+    it('callable uses client.bindCallable with kind: rpc', async () => {
       const output = await emitScopeFile(rpcGroup)
       expect(output).toContain("kind: 'rpc'")
-      expect(output).toContain('client.call')
+      expect(output).toContain('client.bindCallable<')
     })
 
     it('callable includes JSDoc with method and path', async () => {
@@ -323,10 +323,10 @@ describe('emitScopeFile', () => {
       expect(output).toContain('export type UpdatePostResponse')
     })
 
-    it('callable uses client.call with kind: api', async () => {
+    it('callable uses client.bindCallable with kind: api', async () => {
       const output = await emitScopeFile(apiGroup)
       expect(output).toContain("kind: 'api'")
-      expect(output).toContain('client.call')
+      expect(output).toContain('client.bindCallable<')
     })
 
     it('callable includes JSDoc with method and fullPath', async () => {
@@ -346,7 +346,7 @@ describe('emitScopeFile', () => {
     it('imports TypedStream when stream routes are present', async () => {
       const output = await emitScopeFile(streamGroup)
       expect(output).toContain('TypedStream')
-      expect(output).toContain("import type { ClientInstance, ProcedureCallOptions, TypedStream, Result, ResultNoTyped } from 'ts-procedures/client'")
+      expect(output).toContain("import type { ClientInstance, ProcedureCallOptions, TypedStream } from 'ts-procedures/client'")
     })
 
     it('unwraps SSE envelope for yieldType', async () => {
@@ -427,8 +427,8 @@ describe('emitScopeFile', () => {
 
       it('callable references fully qualified namespace types', async () => {
         const output = await emitScopeFile(rpcGroup, { namespaceTypes: true })
-        expect(output).toContain('params: Users.GetUser.Params')
-        expect(output).toContain('Promise<Users.GetUser.Response>')
+        // New emission: GetUser: client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>({...})
+        expect(output).toContain('client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>')
       })
 
       it('still emits the bind function', async () => {
@@ -454,8 +454,8 @@ describe('emitScopeFile', () => {
 
       it('callable references fully qualified namespace types', async () => {
         const output = await emitScopeFile(apiGroup, { namespaceTypes: true })
-        expect(output).toContain('params: Posts.UpdatePost.Params')
-        expect(output).toContain('Promise<Posts.UpdatePost.Response>')
+        // New emission: UpdatePost: client.bindCallable<Posts.UpdatePost.Params, Posts.UpdatePost.Response>({...})
+        expect(output).toContain('client.bindCallable<Posts.UpdatePost.Params, Posts.UpdatePost.Response>')
       })
     })
 
@@ -528,12 +528,14 @@ describe('emitScopeFile', () => {
 
       it('v1 callable has no version suffix', async () => {
         const output = await emitScopeFile(rpcVersionedGroup)
-        expect(output).toContain('GetUser(params: GetUserParams')
+        // New emission: GetUser: client.bindCallable<GetUserParams, GetUserResponse>({...})
+        expect(output).toContain('GetUser: client.bindCallable<GetUserParams, GetUserResponse>')
       })
 
       it('v2 callable uses V2 suffix', async () => {
         const output = await emitScopeFile(rpcVersionedGroup)
-        expect(output).toContain('GetUserV2(params: GetUserV2Params')
+        // New emission: GetUserV2: client.bindCallable<GetUserV2Params, GetUserV2Response>({...})
+        expect(output).toContain('GetUserV2: client.bindCallable<GetUserV2Params, GetUserV2Response>')
       })
 
       it('v1 callable uses its own path', async () => {
@@ -591,14 +593,14 @@ describe('emitScopeFile', () => {
 
       it('v1 callable references unversioned namespace types', async () => {
         const output = await emitScopeFile(rpcVersionedGroup, { namespaceTypes: true })
-        expect(output).toContain('params: Users.GetUser.Params')
-        expect(output).toContain('Promise<Users.GetUser.Response>')
+        // New emission: GetUser: client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>({...})
+        expect(output).toContain('client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>')
       })
 
       it('v2 callable references versioned namespace types', async () => {
         const output = await emitScopeFile(rpcVersionedGroup, { namespaceTypes: true })
-        expect(output).toContain('params: Users.GetUserV2.Params')
-        expect(output).toContain('Promise<Users.GetUserV2.Response>')
+        // New emission: GetUserV2: client.bindCallable<Users.GetUserV2.Params, Users.GetUserV2.Response>({...})
+        expect(output).toContain('client.bindCallable<Users.GetUserV2.Params, Users.GetUserV2.Response>')
       })
     })
   })
@@ -683,75 +685,74 @@ const rpcGroupNoErrors: ScopeGroup = {
 }
 
 describe('emitScopeFile .safe sibling on RPC', () => {
-  it('emits .safe property on RPC callable when route has errors', async () => {
+  it('emits bindCallableTyped for RPC callable when route has errors', async () => {
     const out = await emitScopeFile(rpcGroupWithErrors, {
       namespaceTypes: true,
       errorKeys: new Set(['NotFound']),
       serviceName: 'Api',
     })
-    // The callable should use Object.assign
-    expect(out).toMatch(/Object\.assign/)
-    // The safe variant should be a method
-    expect(out).toMatch(/\bsafe\(/)
-    // The safe variant's return type should be Result<Response, RouteErrors> (namespace-qualified)
-    expect(out).toMatch(/Promise<Result<.*\.Response,.*\.Errors>>/)
+    // With errors: uses bindCallableTyped<Params, Response, Errors>
+    expect(out).toContain('client.bindCallableTyped<')
+    // No Object.assign in generated output
+    expect(out).not.toContain('Object.assign')
   })
 
-  it('emits .safe with ResultNoTyped when route has no errors', async () => {
+  it('emits bindCallable for RPC callable when route has no errors', async () => {
     const out = await emitScopeFile(rpcGroupNoErrors, {
       namespaceTypes: true,
       serviceName: 'Api',
     })
-    // The callable should use Object.assign
-    expect(out).toMatch(/Object\.assign/)
-    // The safe variant should be a method
-    expect(out).toMatch(/\bsafe\(/)
-    // Without declared errors, use ResultNoTyped (namespace-qualified)
-    expect(out).toMatch(/Promise<ResultNoTyped<.*\.Response>>/)
+    // Without errors: uses bindCallable<Params, Response>
+    expect(out).toContain('client.bindCallable<')
+    // No Object.assign in generated output
+    expect(out).not.toContain('Object.assign')
   })
 
-  it('imports Result and ResultNoTyped from client path', async () => {
+  it('scope files no longer directly import Result/ResultNoTyped (inferred from helper)', async () => {
     const out = await emitScopeFile(rpcGroupNoErrors, {
       serviceName: 'Api',
     })
-    expect(out).toContain('Result')
-    expect(out).toContain('ResultNoTyped')
+    // Result/ResultNoTyped are inferred from ClientInstance.bindCallable return type
+    expect(out).not.toContain('ResultNoTyped')
+    expect(out).not.toMatch(/import.*Result.*from/)
     expect(out).toContain("from 'ts-procedures/client'")
   })
 
-  it('namespace mode: safe return type uses route Errors namespace alias', async () => {
+  it('namespace mode: uses route Errors namespace alias as third type arg', async () => {
     const out = await emitScopeFile(rpcGroupWithErrors, {
       namespaceTypes: true,
       errorKeys: new Set(['NotFound']),
       serviceName: 'Api',
     })
     // errorsRef in namespace mode is the route's Errors type alias: Scope.Route.Errors
-    expect(out).toMatch(/Promise<Result<Users\.GetUser\.Response, Users\.GetUser\.Errors>>/)
+    expect(out).toContain('client.bindCallableTyped<Users.GetUser.Params, Users.GetUser.Response, Users.GetUser.Errors>')
   })
 
-  it('flat mode: safe return type uses route Errors type alias', async () => {
+  it('flat mode: uses route Errors type alias as third type arg', async () => {
     const out = await emitScopeFile(rpcGroupWithErrors, {
       namespaceTypes: false,
       errorKeys: new Set(['NotFound']),
       serviceName: 'Api',
     })
     // errorsRef in flat mode is the injected GetUserErrors type alias
-    expect(out).toMatch(/Promise<Result<GetUserResponse, GetUserErrors>>/)
+    expect(out).toContain('client.bindCallableTyped<GetUserParams, GetUserResponse, GetUserErrors>')
   })
 
-  it('safe sibling calls client.safeCall with typed error param when errors present', async () => {
+  it('route with errors uses bindCallableTyped', async () => {
     const out = await emitScopeFile(rpcGroupWithErrors, {
       errorKeys: new Set(['NotFound']),
       serviceName: 'Api',
     })
-    expect(out).toContain('client.safeCall')
+    expect(out).toContain('client.bindCallableTyped<')
+    expect(out).not.toContain('client.bindCallable<')
   })
 
-  it('safe sibling calls client.safeCall without typed error param when no errors', async () => {
+  it('route without errors uses bindCallable (not bindCallableTyped)', async () => {
     const out = await emitScopeFile(rpcGroupNoErrors, {
       serviceName: 'Api',
     })
-    expect(out).toContain('client.safeCall')
+    expect(out).toContain('client.bindCallable<')
+    expect(out).not.toContain('client.bindCallableTyped<')
   })
 })
 
@@ -825,78 +826,74 @@ const apiGroupNoErrors: ScopeGroup = {
 }
 
 describe('emitScopeFile .safe sibling on API', () => {
-  it('emits .safe property on API callable when route has errors', async () => {
+  it('emits bindCallableTyped for API callable when route has errors', async () => {
     const out = await emitScopeFile(apiGroupWithErrors, {
       namespaceTypes: true,
       errorKeys: new Set(['NotFound']),
       serviceName: 'Api',
     })
-    // The callable should use Object.assign
-    expect(out).toMatch(/Object\.assign/)
-    // The safe variant should be a method
-    expect(out).toMatch(/\bsafe\(/)
-    // The safe variant's return type should be Result<Response, RouteErrors> (namespace-qualified)
-    expect(out).toMatch(/Promise<Result<.*\.Response,.*\.Errors>>/)
+    // With errors: uses bindCallableTyped<Params, Response, Errors>
+    expect(out).toContain('client.bindCallableTyped<')
+    // No Object.assign in generated output
+    expect(out).not.toContain('Object.assign')
   })
 
-  it('emits .safe with ResultNoTyped when API route has no errors', async () => {
+  it('emits bindCallable for API callable when route has no errors', async () => {
     const out = await emitScopeFile(apiGroupNoErrors, {
       namespaceTypes: true,
       serviceName: 'Api',
     })
-    // The callable should use Object.assign
-    expect(out).toMatch(/Object\.assign/)
-    // The safe variant should be a method
-    expect(out).toMatch(/\bsafe\(/)
-    // Without declared errors, use ResultNoTyped (namespace-qualified)
-    expect(out).toMatch(/Promise<ResultNoTyped<.*\.Response>>/)
+    // Without errors: uses bindCallable<Params, Response>
+    expect(out).toContain('client.bindCallable<')
+    // No Object.assign in generated output
+    expect(out).not.toContain('Object.assign')
   })
 
-  it('namespace mode: safe return type uses route Errors namespace alias', async () => {
+  it('namespace mode: uses route Errors namespace alias as third type arg', async () => {
     const out = await emitScopeFile(apiGroupWithErrors, {
       namespaceTypes: true,
       errorKeys: new Set(['NotFound']),
       serviceName: 'Api',
     })
     // errorsRef in namespace mode is the route's Errors type alias: Scope.Route.Errors
-    expect(out).toMatch(/Promise<Result<Posts\.UpdatePost\.Response, Posts\.UpdatePost\.Errors>>/)
+    expect(out).toContain('client.bindCallableTyped<Posts.UpdatePost.Params, Posts.UpdatePost.Response, Posts.UpdatePost.Errors>')
   })
 
-  it('flat mode: safe return type uses route Errors type alias', async () => {
+  it('flat mode: uses route Errors type alias as third type arg', async () => {
     const out = await emitScopeFile(apiGroupWithErrors, {
       namespaceTypes: false,
       errorKeys: new Set(['NotFound']),
       serviceName: 'Api',
     })
     // errorsRef in flat mode is the injected UpdatePostErrors type alias
-    expect(out).toMatch(/Promise<Result<UpdatePostResponse, UpdatePostErrors>>/)
+    expect(out).toContain('client.bindCallableTyped<UpdatePostParams, UpdatePostResponse, UpdatePostErrors>')
   })
 
-  it('safe sibling calls client.safeCall when API route has errors', async () => {
+  it('route with errors uses bindCallableTyped', async () => {
     const out = await emitScopeFile(apiGroupWithErrors, {
       errorKeys: new Set(['NotFound']),
       serviceName: 'Api',
     })
-    expect(out).toContain('client.safeCall')
+    expect(out).toContain('client.bindCallableTyped<')
+    expect(out).not.toContain('client.bindCallable<')
   })
 
-  it('safe sibling calls client.safeCall when API route has no errors', async () => {
+  it('route without errors uses bindCallable (not bindCallableTyped)', async () => {
     const out = await emitScopeFile(apiGroupNoErrors, {
       serviceName: 'Api',
     })
-    expect(out).toContain('client.safeCall')
+    expect(out).toContain('client.bindCallable<')
+    expect(out).not.toContain('client.bindCallableTyped<')
   })
 
-  it('callable uses fullPath not path in both main and safe sibling', async () => {
+  it('callable uses fullPath not path in the descriptor', async () => {
     const out = await emitScopeFile(apiGroupWithErrors, {
       errorKeys: new Set(['NotFound']),
       serviceName: 'Api',
     })
-    // Both the main call and safeCall should reference the fullPath
-    const safeCallIdx = out.indexOf('client.safeCall')
-    expect(safeCallIdx).toBeGreaterThan(-1)
-    const afterSafeCall = out.slice(safeCallIdx)
-    expect(afterSafeCall).toContain("path: '/api/posts/:id'")
+    // The descriptor in the helper call should reference the fullPath
+    expect(out).toContain("path: '/api/posts/:id'")
+    expect(out).not.toContain("path: '/posts/:id'")
   })
 })
 
@@ -916,6 +913,8 @@ describe('emitScopeFile streams omit .safe sibling', () => {
     expect(out).not.toContain('WatchEvents.safe')
     // Object.assign wrapper is not used for stream routes
     expect(out).not.toMatch(/WatchEvents\s*:\s*Object\.assign/)
+    // bindCallable helpers are not used for stream routes
+    expect(out).not.toMatch(/WatchEvents\s*:\s*client\.bindCallable/)
   })
 
   it('stream callable returns TypedStream, not Result', async () => {
@@ -942,5 +941,7 @@ describe('emitScopeFile streams omit .safe sibling', () => {
     // But still no .safe property
     expect(out).not.toContain('WatchEvents.safe')
     expect(out).not.toMatch(/WatchEvents\s*:\s*Object\.assign/)
+    // bindCallable helpers are not used for stream routes
+    expect(out).not.toMatch(/WatchEvents\s*:\s*client\.bindCallable/)
   })
 })