@pikku/core 0.12.107 → 0.12.112

package/src/wirings/rpc/rpc-runner.test.ts

@@ -1,1130 +0,0 @@
-import { beforeEach, describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { addFunction } from '../../function/function-runner.js'
-import { pikkuState, resetPikkuState } from '../../pikku-state.js'
-import {
-  ContextAwareRPCService,
-  RPCNotFoundError,
-  RemoteAddonRequestError,
-  resolveNamespace,
-  rpcService,
-} from './rpc-runner.js'
-import { RemoteAddonAuthError } from '../addon/remote-addon-auth.js'
-import { wireAddon } from '../addon/wire-addon.js'
-import { wireRemoteAddon } from '../addon/wire-remote-addon.js'
-import { createSecretValue } from '../../classification/secret-value.js'
-
-const createLogger = () => ({
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-})
-
-const registerFunction = (
-  funcName: string,
-  func: (services: any, data: any, wire: any) => Promise<unknown> | unknown,
-  {
-    packageName = null,
-    expose,
-    pikkuFuncId,
-    tags,
-    scenarioStep,
-  }: {
-    packageName?: string | null
-    expose?: boolean
-    pikkuFuncId?: string
-    tags?: string[]
-    scenarioStep?: boolean
-  } = {}
-) => {
-  addFunction(funcName, { func } as never, packageName)
-  pikkuState(packageName, 'function', 'meta')[funcName] = {
-    name: funcName,
-    pikkuFuncId,
-    sessionless: true,
-    permissions: [],
-    expose,
-    tags,
-    scenarioStep,
-  } as never
-}
-
-const createServices = (overrides: Record<string, unknown> = {}) =>
-  ({
-    logger: createLogger(),
-    ...overrides,
-  }) as never
-
-beforeEach(() => {
-  resetPikkuState()
-  pikkuState(null, 'package', 'singletonServices', createServices())
-})
-
-describe('resolveNamespace', () => {
-  test('returns null for non-namespaced functions', () => {
-    assert.equal(resolveNamespace('plainFunction'), null)
-  })
-
-  test('returns null when namespace is not registered', () => {
-    assert.equal(resolveNamespace('missing:func'), null)
-  })
-
-  test('resolves addon namespace to package and function', () => {
-    pikkuState(null, 'addons', 'packages').set('stripe', {
-      package: '@addon/stripe',
-      auth: true,
-      tags: ['addon-tag'],
-    } as never)
-
-    assert.deepEqual(resolveNamespace('stripe:createCharge'), {
-      package: '@addon/stripe',
-      function: 'createCharge',
-      addonConfig: {
-        package: '@addon/stripe',
-        auth: true,
-        tags: ['addon-tag'],
-      },
-    })
-  })
-})
-
-describe('ContextAwareRPCService.rpc', () => {
-  test('runs bare rpc functions through root rpc metadata', async () => {
-    pikkuState(null, 'rpc', 'meta').echo = 'echoFunc'
-    registerFunction('echoFunc', async (_services, data, wire) => ({
-      data,
-      traceId: wire.traceId,
-    }))
-
-    const service = new ContextAwareRPCService(
-      createServices(),
-      { traceId: 'trace-1' } as never,
-      { requiresAuth: false }
-    )
-
-    const result = await service.rpc('echo', { hello: 'world' })
-
-    assert.deepEqual(result, {
-      data: { hello: 'world' },
-      traceId: 'trace-1',
-    })
-  })
-
-  test('uses package-scoped function meta before root rpc metadata', async () => {
-    pikkuState(null, 'rpc', 'meta').echo = 'rootEchoFunc'
-    registerFunction('rootEchoFunc', async () => ({ source: 'root' }))
-    registerFunction(
-      'packageEchoFunc',
-      async () => ({ source: '@addon/pkg' }),
-      {
-        packageName: '@addon/pkg',
-      }
-    )
-    pikkuState('@addon/pkg', 'function', 'meta').echo = {
-      name: 'echo',
-      pikkuFuncId: 'packageEchoFunc',
-      sessionless: true,
-      permissions: [],
-    } as never
-
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {},
-      '@addon/pkg'
-    )
-
-    const result = await service.rpc('echo', {})
-
-    assert.deepEqual(result, { source: '@addon/pkg' })
-  })
-
-  test('falls back from versioned rpc names to the base metadata entry', async () => {
-    pikkuState(null, 'rpc', 'meta').echo = 'echoFunc'
-    registerFunction('echoFunc', async (_services, data) => data)
-
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    const result = await service.rpc('echo@v2', { ok: true })
-
-    assert.deepEqual(result, { ok: true })
-  })
-
-  test('resolves internal root functions that are registered outside rpc metadata', async () => {
-    registerFunction('pikkuWorkflowSleeper', async (_services, data) => ({
-      sleeper: true,
-      data,
-    }))
-
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    const result = await service.rpc('pikkuWorkflowSleeper', {
-      runId: 'run-1',
-      stepId: 'step-1',
-    })
-
-    assert.deepEqual(result, {
-      sleeper: true,
-      data: {
-        runId: 'run-1',
-        stepId: 'step-1',
-      },
-    })
-  })
-
-  test('invokes addon functions with addon auth and tags', async () => {
-    pikkuState(null, 'addons', 'packages').set('stripe', {
-      package: '@addon/stripe',
-      auth: false,
-      tags: ['addon-tag'],
-    } as never)
-    registerFunction(
-      'createCharge',
-      async (_services, data, wire) => ({
-        data,
-        auth: wire.wireType,
-      }),
-      {
-        packageName: '@addon/stripe',
-        tags: ['function-tag'],
-      }
-    )
-
-    pikkuState('@addon/stripe', 'function', 'meta').createCharge = {
-      name: 'createCharge',
-      sessionless: true,
-      permissions: [],
-      tags: ['function-tag'],
-    } as never
-
-    const service = new ContextAwareRPCService(
-      createServices({
-        logger: createLogger(),
-      }),
-      { wireType: 'http', wireId: 'wire-1' } as never,
-      { requiresAuth: true }
-    )
-
-    const result = await service.rpc('stripe:createCharge', { amount: 10 })
-
-    assert.deepEqual(result, {
-      data: { amount: 10 },
-      auth: 'http',
-    })
-  })
-
-  test('falls back to deploymentService when rpc meta is missing', async () => {
-    const calls: unknown[][] = []
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            calls.push(args)
-            return { remote: true }
-          },
-        },
-      }),
-      {
-        traceId: 'trace-2',
-        getSession: async () => ({ userId: 'user-1' }),
-      } as never,
-      {}
-    )
-
-    const result = await service.rpc('missingRpc', { value: 1 })
-
-    assert.deepEqual(result, { remote: true })
-    assert.deepEqual(calls, [
-      ['missingRpc', { value: 1 }, { userId: 'user-1' }, 'trace-2'],
-    ])
-  })
-
-  test('throws RPCNotFoundError when rpc is missing and no deploymentService exists', async () => {
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    await assert.rejects(() => service.rpc('missingRpc', {}), RPCNotFoundError)
-  })
-})
-
-describe('RPCNotFoundError raised from inside a resolved function', () => {
-  test('a local function that throws RPCNotFoundError is not re-dispatched remotely', async () => {
-    const sideEffects: string[] = []
-    const remoteCalls: unknown[][] = []
-
-    pikkuState(null, 'rpc', 'meta').chargeCard = 'chargeCardFunc'
-    registerFunction('chargeCardFunc', async () => {
-      sideEffects.push('charged')
-      throw new RPCNotFoundError('doesNotExist')
-    })
-
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            remoteCalls.push(args)
-            return { remote: true }
-          },
-        },
-      }),
-      {} as never,
-      {}
-    )
-
-    await assert.rejects(
-      () => service.rpc('chargeCard', { amount: 10 }),
-      (error: unknown) => {
-        assert.ok(error instanceof RPCNotFoundError)
-        assert.equal(error.rpcName, 'doesNotExist')
-        return true
-      }
-    )
-
-    assert.deepEqual(sideEffects, ['charged'])
-    assert.deepEqual(remoteCalls, [])
-  })
-
-  test('an addon function that throws RPCNotFoundError is not retried locally or remotely', async () => {
-    const sideEffects: string[] = []
-    const remoteCalls: unknown[][] = []
-
-    pikkuState(null, 'addons', 'packages').set('stripe', {
-      package: '@addon/stripe',
-    } as never)
-    registerFunction(
-      'createCharge',
-      async () => {
-        sideEffects.push('charged')
-        throw new RPCNotFoundError('doesNotExist')
-      },
-      { packageName: '@addon/stripe' }
-    )
-
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            remoteCalls.push(args)
-            return { remote: true }
-          },
-        },
-      }),
-      {} as never,
-      {}
-    )
-
-    await assert.rejects(
-      () => service.rpc('stripe:createCharge', { amount: 10 }),
-      (error: unknown) => {
-        assert.ok(error instanceof RPCNotFoundError)
-        assert.equal(error.rpcName, 'doesNotExist')
-        return true
-      }
-    )
-
-    assert.deepEqual(sideEffects, ['charged'])
-    assert.deepEqual(remoteCalls, [])
-  })
-
-  test('rpcWithWire does not re-dispatch a local function that throws RPCNotFoundError', async () => {
-    const sideEffects: string[] = []
-    const remoteCalls: unknown[][] = []
-
-    pikkuState(null, 'rpc', 'meta').chargeCard = 'chargeCardFunc'
-    registerFunction('chargeCardFunc', async () => {
-      sideEffects.push('charged')
-      throw new RPCNotFoundError('doesNotExist')
-    })
-
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            remoteCalls.push(args)
-            return { remote: true }
-          },
-        },
-      }),
-      {} as never,
-      {}
-    )
-
-    await assert.rejects(
-      () => service.rpcWithWire('chargeCard', { amount: 10 }, {} as never),
-      RPCNotFoundError
-    )
-
-    assert.deepEqual(sideEffects, ['charged'])
-    assert.deepEqual(remoteCalls, [])
-  })
-
-  test('a genuinely missing namespaced rpc still throws RPCNotFoundError', async () => {
-    pikkuState(null, 'addons', 'packages').set('stripe', {
-      package: '@addon/stripe',
-    } as never)
-
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    await assert.rejects(
-      () => service.rpc('stripe:missingFunc', {}),
-      (error: unknown) => {
-        assert.ok(error instanceof RPCNotFoundError)
-        assert.equal(
-          error.message,
-          'RPC function not found: stripe:missingFunc'
-        )
-        return true
-      }
-    )
-  })
-
-  test('a missing namespaced rpc still reaches deploymentService when one is configured', async () => {
-    const remoteCalls: unknown[][] = []
-    pikkuState(null, 'addons', 'packages').set('stripe', {
-      package: '@addon/stripe',
-    } as never)
-
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            remoteCalls.push(args)
-            return { remote: true }
-          },
-        },
-      }),
-      { traceId: 'trace-addon' } as never,
-      {}
-    )
-
-    const result = await service.rpc('stripe:missingFunc', { value: 3 })
-
-    assert.deepEqual(result, { remote: true })
-    assert.deepEqual(remoteCalls, [
-      ['stripe:missingFunc', { value: 3 }, undefined, 'trace-addon'],
-    ])
-  })
-
-  test('an unknown namespace still falls through to the local/remote lookup', async () => {
-    const remoteCalls: unknown[][] = []
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            remoteCalls.push(args)
-            return { remote: true }
-          },
-        },
-      }),
-      { traceId: 'trace-ns' } as never,
-      {}
-    )
-
-    const result = await service.rpc('unknownNs:someFunc', { value: 1 })
-
-    assert.deepEqual(result, { remote: true })
-    assert.deepEqual(remoteCalls, [
-      ['unknownNs:someFunc', { value: 1 }, undefined, 'trace-ns'],
-    ])
-  })
-})
-
-describe('ContextAwareRPCService.rpcExposed', () => {
-  test('resolves unversioned exposed rpc names through latest rpc metadata', async () => {
-    pikkuState(null, 'rpc', 'meta').listCards = 'listCards@v2'
-    registerFunction(
-      'listCards@v2',
-      async (_services, data) => ({ data, version: 2 }),
-      {
-        expose: true,
-      }
-    )
-
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    const result = await service.rpcExposed('listCards', { ok: true })
-
-    assert.deepEqual(result, {
-      data: { ok: true },
-      version: 2,
-    })
-  })
-
-  test('throws when the function does not exist', async () => {
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    await assert.rejects(
-      () => service.rpcExposed('missingRpc', {}),
-      RPCNotFoundError
-    )
-  })
-
-  test('throws RPCNotFoundError when the function is not exposed', async () => {
-    pikkuState(null, 'rpc', 'meta').hiddenFunc = 'hiddenFunc'
-    registerFunction('hiddenFunc', async () => ({ ok: true }), {
-      expose: false,
-    })
-
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    await assert.rejects(
-      () => service.rpcExposed('hiddenFunc', {}),
-      RPCNotFoundError
-    )
-  })
-
-  test('a scenario step is not callable over the network, even if marked exposed', async () => {
-    pikkuState(null, 'rpc', 'meta').seesAddonCard = 'seesAddonCard'
-    registerFunction('seesAddonCard', async () => ({ visible: true }), {
-      expose: true,
-      scenarioStep: true,
-    })
-
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    await assert.rejects(
-      () => service.rpcExposed('seesAddonCard', {}),
-      RPCNotFoundError
-    )
-  })
-
-  test('runs exposed addon functions', async () => {
-    pikkuState(null, 'addons', 'packages').set('addon', {
-      package: '@addon/pkg',
-    } as never)
-    registerFunction(
-      'visibleFunc',
-      async (_services, data) => ({ data, source: 'addon' }),
-      {
-        packageName: '@addon/pkg',
-        expose: true,
-      }
-    )
-
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    const result = await service.rpcExposed('addon:visibleFunc', {
-      ok: true,
-    })
-
-    assert.deepEqual(result, { data: { ok: true }, source: 'addon' })
-  })
-})
-
-describe('ContextAwareRPCService.rpcWithWire', () => {
-  test('merges wire data for local rpc calls', async () => {
-    pikkuState(null, 'rpc', 'meta').echo = 'echoFunc'
-    registerFunction('echoFunc', async (_services, _data, wire) => ({
-      traceId: wire.traceId,
-      custom: wire.custom,
-    }))
-
-    const service = new ContextAwareRPCService(
-      createServices(),
-      { traceId: 'base-trace' } as never,
-      {}
-    )
-
-    const result = await service.rpcWithWire('echo', {}, {
-      custom: 'merged',
-    } as never)
-
-    assert.deepEqual(result, {
-      traceId: 'base-trace',
-      custom: 'merged',
-    })
-  })
-
-  test('falls back to deploymentService for rpcWithWire when local rpc is missing', async () => {
-    const calls: unknown[][] = []
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            calls.push(args)
-            return { remote: true }
-          },
-        },
-      }),
-      { traceId: 'trace-3', session: { userId: 'user-2' } } as never,
-      {}
-    )
-
-    const result = await service.rpcWithWire('missingRpc', { value: 2 }, {
-      custom: 'wire',
-    } as never)
-
-    assert.deepEqual(result, { remote: true })
-    assert.deepEqual(calls, [
-      ['missingRpc', { value: 2 }, { userId: 'user-2' }, 'trace-3'],
-    ])
-  })
-
-  test('a missing namespaced rpc still reaches deploymentService through rpcWithWire', async () => {
-    const remoteCalls: unknown[][] = []
-    pikkuState(null, 'addons', 'packages').set('stripe', {
-      package: '@addon/stripe',
-    } as never)
-
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            remoteCalls.push(args)
-            return { remote: true }
-          },
-        },
-      }),
-      { traceId: 'trace-addon-wire' } as never,
-      {}
-    )
-
-    const result = await service.rpcWithWire(
-      'stripe:missingFunc',
-      { value: 3 },
-      { custom: 'wire' } as never
-    )
-
-    assert.deepEqual(result, { remote: true })
-    assert.deepEqual(remoteCalls, [
-      ['stripe:missingFunc', { value: 3 }, undefined, 'trace-addon-wire'],
-    ])
-  })
-
-  test('an unknown namespace still falls through to the local/remote lookup', async () => {
-    const remoteCalls: unknown[][] = []
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            remoteCalls.push(args)
-            return { remote: true }
-          },
-        },
-      }),
-      { traceId: 'trace-ns-wire' } as never,
-      {}
-    )
-
-    const result = await service.rpcWithWire(
-      'unknownNs:someFunc',
-      { value: 1 },
-      { custom: 'wire' } as never
-    )
-
-    assert.deepEqual(result, { remote: true })
-    assert.deepEqual(remoteCalls, [
-      ['unknownNs:someFunc', { value: 1 }, undefined, 'trace-ns-wire'],
-    ])
-  })
-
-  test('the deployment fallback runs under the wire the caller passed, not the ambient one', async () => {
-    const remoteCalls: unknown[][] = []
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            remoteCalls.push(args)
-            return { remote: true }
-          },
-        },
-      }),
-      {
-        traceId: 'ambient-trace',
-        session: { userId: 'ambient-user' },
-      } as never,
-      {}
-    )
-
-    const result = await service.rpcWithWire(
-      'unknownNs:someFunc',
-      { value: 1 },
-      {
-        traceId: 'caller-trace',
-        session: { userId: 'caller-user' },
-      } as never
-    )
-
-    assert.deepEqual(result, { remote: true })
-    assert.deepEqual(
-      remoteCalls,
-      [
-        [
-          'unknownNs:someFunc',
-          { value: 1 },
-          { userId: 'caller-user' },
-          'caller-trace',
-        ],
-      ],
-      'the remote hop ran under the ambient wire, so an explicit wire is honoured locally but dropped across the deployment boundary'
-    )
-  })
-})
-
-describe('ContextAwareRPCService.startWorkflow', () => {
-  test('throws when workflowService is unavailable', async () => {
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    await assert.rejects(
-      () => service.startWorkflow('workflowA', {}),
-      /WorkflowService service not available/
-    )
-  })
-
-  test('passes derived wire metadata into workflowService.startWorkflow', async () => {
-    const calls: unknown[][] = []
-    const service = new ContextAwareRPCService(
-      createServices({
-        workflowService: {
-          startWorkflow: async (...args: unknown[]) => {
-            calls.push(args)
-            return { runId: 'run-1' }
-          },
-        },
-      }),
-      {
-        wireType: 'rpc',
-        wireId: 'rpc-1',
-        pikkuUserId: 'user-3',
-        workflowStep: { runId: 'parent-run-1' },
-      } as never,
-      {}
-    )
-
-    const result = await service.startWorkflow('workflowA', { ok: true })
-
-    assert.deepEqual(result, { runId: 'run-1' })
-    assert.deepEqual(calls[0]?.slice(0, 3), [
-      'workflowA',
-      { ok: true },
-      {
-        type: 'rpc',
-        id: 'rpc-1',
-        parentRunId: 'parent-run-1',
-        pikkuUserId: 'user-3',
-      },
-    ])
-  })
-})
-
-describe('ContextAwareRPCService.remote', () => {
-  test('throws when deploymentService is unavailable', async () => {
-    const service = new ContextAwareRPCService(
-      createServices(),
-      {} as never,
-      {}
-    )
-
-    await assert.rejects(
-      () => service.remote('remoteFunc', {}),
-      /No DeploymentService configured for remote RPC: remoteFunc/
-    )
-  })
-
-  test('uses deploymentService with session and trace id', async () => {
-    const calls: unknown[][] = []
-    const service = new ContextAwareRPCService(
-      createServices({
-        deploymentService: {
-          invoke: async (...args: unknown[]) => {
-            calls.push(args)
-            return { ok: true }
-          },
-        },
-      }),
-      {
-        traceId: 'trace-4',
-        getSession: async () => ({ userId: 'user-4' }),
-      } as never,
-      {}
-    )
-
-    const result = await service.remote('remoteFunc', { hi: true })
-
-    assert.deepEqual(result, { ok: true })
-    assert.deepEqual(calls, [
-      ['remoteFunc', { hi: true }, { userId: 'user-4' }, 'trace-4'],
-    ])
-  })
-})
-
-describe('multi-instance addons', () => {
-  const createSecretService = () => ({
-    getSecret: async (key: string) => createSecretValue(`secret:${key}`),
-    hasSecret: async () => true,
-    setSecret: async () => {},
-    deleteSecret: async () => {},
-    getSecrets: async () => ({}),
-  })
-
-  test('resolves per-instance secretOverrides and caches singletons per namespace', async () => {
-    const createdServices: any[] = []
-    pikkuState('@addon/slack', 'package', 'factories', {
-      createSingletonServices: async (_config: any, parent: any) => {
-        const token = (await parent.secrets.getSecret('slackToken')).reveal()
-        const svc = { logger: createLogger(), token }
-        createdServices.push(svc)
-        return svc
-      },
-    } as never)
-    pikkuState('@addon/slack', 'package', 'declaredSecrets', ['slackToken'])
-    registerFunction(
-      'send',
-      async (services: any) => ({ token: services.token }),
-      {
-        packageName: '@addon/slack',
-      }
-    )
-
-    wireAddon({
-      name: 'slack-marketing',
-      package: '@addon/slack',
-      secretOverrides: { slackToken: 'marketing_secret' },
-    })
-    wireAddon({
-      name: 'slack-support',
-      package: '@addon/slack',
-      secretOverrides: { slackToken: 'support_secret' },
-    })
-
-    const service = new ContextAwareRPCService(
-      createServices({ secrets: createSecretService() }),
-      {} as never,
-      { requiresAuth: false }
-    )
-
-    const marketing = await service.rpc('slack-marketing:send', {})
-    const support = await service.rpc('slack-support:send', {})
-
-    assert.deepEqual(marketing, { token: 'secret:marketing_secret' })
-    assert.deepEqual(support, { token: 'secret:support_secret' })
-    assert.equal(createdServices.length, 2)
-    assert.notEqual(createdServices[0], createdServices[1])
-  })
-
-  test('reuses the same per-namespace singleton across intra-addon sibling calls', async () => {
-    let factoryCalls = 0
-    pikkuState('@addon/slack', 'package', 'factories', {
-      createSingletonServices: async (_config: any, parent: any) => {
-        factoryCalls++
-        return {
-          logger: createLogger(),
-          token: (await parent.secrets.getSecret('slackToken')).reveal(),
-        }
-      },
-    } as never)
-    pikkuState('@addon/slack', 'package', 'declaredSecrets', ['slackToken'])
-
-    registerFunction(
-      'leaf',
-      async (services: any) => ({ token: services.token }),
-      {
-        packageName: '@addon/slack',
-      }
-    )
-    registerFunction(
-      'root',
-      async (_services: any, _data: any, wire: any) =>
-        wire.rpc.invoke('leaf', {}),
-      { packageName: '@addon/slack' }
-    )
-
-    wireAddon({
-      name: 'slack-marketing',
-      package: '@addon/slack',
-      secretOverrides: { slackToken: 'marketing_secret' },
-    })
-
-    const service = new ContextAwareRPCService(
-      createServices({ secrets: createSecretService() }),
-      {} as never,
-      { requiresAuth: false }
-    )
-
-    const result = await service.rpc('slack-marketing:root', {})
-
-    assert.deepEqual(result, { token: 'secret:marketing_secret' })
-    assert.equal(factoryCalls, 1)
-  })
-
-  test('resolves per-instance credentialOverrides via wire.getCredential', async () => {
-    pikkuState('@addon/slack', 'package', 'factories', {
-      createSingletonServices: async () => ({ logger: createLogger() }),
-    } as never)
-    registerFunction(
-      'whoami',
-      async (_services: any, _data: any, wire: any) => ({
-        cred: await wire.getCredential('slack'),
-      }),
-      { packageName: '@addon/slack' }
-    )
-
-    wireAddon({
-      name: 'slack-marketing',
-      package: '@addon/slack',
-      credentialOverrides: { slack: 'marketing_cred' },
-    })
-    wireAddon({
-      name: 'slack-support',
-      package: '@addon/slack',
-      credentialOverrides: { slack: 'support_cred' },
-    })
-
-    const credentialService = {
-      getAll: async (_userId: string) => ({
-        marketing_cred: { token: 'm' },
-        support_cred: { token: 's' },
-      }),
-    }
-
-    const service = new ContextAwareRPCService(
-      createServices({ credentialService }),
-      { pikkuUserId: 'user-1' } as never,
-      { requiresAuth: false }
-    )
-
-    const marketing = await service.rpc('slack-marketing:whoami', {})
-    const support = await service.rpc('slack-support:whoami', {})
-
-    assert.deepEqual(marketing, { cred: { token: 'm' } })
-    assert.deepEqual(support, { cred: { token: 's' } })
-  })
-})
-
-describe('wireRemoteAddon dispatch', () => {
-  const realFetch = globalThis.fetch
-  let calls: Array<{ url: string; init: any }> = []
-
-  const stubFetch = (
-    response: { status?: number; body?: unknown } = {}
-  ): void => {
-    const { status = 200, body = { ok: true } } = response
-    calls = []
-    globalThis.fetch = (async (url: any, init: any) => {
-      calls.push({ url: String(url), init })
-      return {
-        ok: status >= 200 && status < 300,
-        status,
-        text: async () => (body === undefined ? '' : JSON.stringify(body)),
-      }
-    }) as any
-  }
-
-  const restoreFetch = () => {
-    globalThis.fetch = realFetch
-  }
-
-  const secretService = () =>
-    ({
-      getSecret: async (key: string) =>
-        createSecretValue(`secret-value-for-${key}`),
-      getSecrets: async () => ({}),
-      hasSecret: async () => true,
-      setSecret: async () => {},
-      deleteSecret: async () => {},
-    }) as never
-
-  test('POSTs to /remote/rpc/<fn> with { rpcName, data } and a platform bearer token', async () => {
-    stubFetch({ body: { echoed: 42 } })
-    try {
-      wireRemoteAddon({
-        name: 'registry',
-        package: '@pikkufabric/addon-registry',
-        serverUrl: 'https://api.example.com/',
-        auth: { secretId: 'REGISTRY_TOKEN' },
-      })
-
-      const service = new ContextAwareRPCService(
-        createServices({ secrets: secretService() }),
-        { traceId: 'trace-r' } as never,
-        {}
-      )
-
-      const result = await service.rpc('registry:getOpenApi', {
-        name: 'stripe',
-      })
-
-      assert.deepEqual(result, { echoed: 42 })
-      assert.equal(calls.length, 1)
-      assert.equal(
-        calls[0]!.url,
-        'https://api.example.com/remote/rpc/getOpenApi'
-      )
-      assert.equal(calls[0]!.init.method, 'POST')
-      assert.deepEqual(JSON.parse(calls[0]!.init.body), {
-        rpcName: 'getOpenApi',
-        data: { name: 'stripe' },
-      })
-      assert.equal(
-        calls[0]!.init.headers.authorization,
-        'Bearer secret-value-for-REGISTRY_TOKEN'
-      )
-      assert.equal(
-        calls[0]!.init.headers['x-request-id'],
-        'trace-r',
-        'a remote RPC must send the trace id under the header the receiving ' +
-          'runner reads, or the trace chain breaks at the hop'
-      )
-    } finally {
-      restoreFetch()
-    }
-  })
-
-  test('resolves a per-user credential token via wire.getCredential', async () => {
-    stubFetch()
-    try {
-      wireRemoteAddon({
-        name: 'registry',
-        package: '@pikkufabric/addon-registry',
-        serverUrl: () => 'https://api.example.com',
-        auth: { credentialId: 'fabricRegistryToken' },
-      })
-
-      const service = new ContextAwareRPCService(
-        createServices(),
-        {
-          pikkuUserId: 'user-9',
-          getCredential: async (name: string) =>
-            name === 'fabricRegistryToken' ? 'user-token-9' : null,
-        } as never,
-        {}
-      )
-
-      await service.rpc('registry:getOpenApi', {})
-      assert.equal(calls[0]!.init.headers.authorization, 'Bearer user-token-9')
-    } finally {
-      restoreFetch()
-    }
-  })
-
-  test('omits the Authorization header for a public (no auth) surface', async () => {
-    stubFetch()
-    try {
-      wireRemoteAddon({
-        name: 'registry',
-        package: '@pikkufabric/addon-registry',
-        serverUrl: 'https://api.example.com',
-      })
-
-      const service = new ContextAwareRPCService(
-        createServices(),
-        {} as never,
-        {}
-      )
-
-      await service.rpc('registry:listOpenApis', {})
-      assert.equal(calls[0]!.init.headers.authorization, undefined)
-    } finally {
-      restoreFetch()
-    }
-  })
-
-  test('fails closed when a bound credential resolves empty', async () => {
-    stubFetch()
-    try {
-      wireRemoteAddon({
-        name: 'registry',
-        package: '@pikkufabric/addon-registry',
-        serverUrl: 'https://api.example.com',
-        auth: { credentialId: 'fabricRegistryToken' },
-      })
-
-      const service = new ContextAwareRPCService(
-        createServices(),
-        { getCredential: async () => null } as never,
-        {}
-      )
-
-      await assert.rejects(
-        () => service.rpc('registry:getOpenApi', {}),
-        RemoteAddonAuthError
-      )
-      assert.equal(calls.length, 0)
-    } finally {
-      restoreFetch()
-    }
-  })
-
-  test('throws RemoteAddonRequestError on a non-2xx response', async () => {
-    stubFetch({ status: 503, body: { error: 'down' } })
-    try {
-      wireRemoteAddon({
-        name: 'registry',
-        package: '@pikkufabric/addon-registry',
-        serverUrl: 'https://api.example.com',
-      })
-
-      const service = new ContextAwareRPCService(
-        createServices(),
-        {} as never,
-        {}
-      )
-
-      await assert.rejects(
-        () => service.rpc('registry:getOpenApi', {}),
-        RemoteAddonRequestError
-      )
-    } finally {
-      restoreFetch()
-    }
-  })
-})
-
-describe('rpcService.getContextRPCService', () => {
-  test('builds a typed rpc facade with depth and bound methods', async () => {
-    pikkuState(null, 'rpc', 'meta').echo = 'echoFunc'
-    registerFunction('echoFunc', async (_services, data) => data)
-
-    const rpc = rpcService.getContextRPCService(
-      createServices(),
-      {} as never,
-      false,
-      7
-    )
-
-    assert.equal(rpc.depth, 7)
-    assert.equal(rpc.global, false)
-    assert.deepEqual(await rpc.invoke('echo', { ok: true }), { ok: true })
-  })
-})