@pikku/inspector 0.12.60 → 0.12.61

package/dist/utils/workflow/graph/serialize-workflow-graph.js

@@ -1,4 +1,4 @@
-import { isRef } from '@pikku/core/ecosystem/workflow';
+import { isRef, template } from '@pikku/core/workflow';
 /**
  * Convert a RefValue (from runtime) to DataRef (serialized)
  */
@@ -23,6 +23,22 @@ function serializeInputMapping(input) {
     }
     return result;
 }
+/**
+ * Convert a `forEach` source — a bare node id, a ref, or a `(ref) => ref(...)`
+ * callback — to the serialized DataRef form
+ */
+function serializeForEach(forEach, createRef) {
+    if (forEach === undefined)
+        return undefined;
+    if (typeof forEach === 'string')
+        return { $ref: forEach };
+    if (typeof forEach === 'function') {
+        return serializeForEach(forEach(createRef), createRef);
+    }
+    if (isRef(forEach))
+        return convertRef(forEach);
+    return undefined;
+}
 /**
  * Convert next config from runtime format to serialized format
  * Runtime uses Record<string, string | string[]> for branching with graph.branch()
@@ -59,6 +75,7 @@ export function serializeWorkflowGraph(definition, options) {
         nodeId,
         path,
     });
+    const createItemRef = (path) => createRef('$item', path);
     // Track which nodes have incoming edges
     const hasIncomingEdge = new Set();
     // First pass: identify nodes with incoming edges
@@ -88,7 +105,7 @@ export function serializeWorkflowGraph(definition, options) {
         // Evaluate input callback to get the mapping
         let input = {};
         if (node.input) {
-            const rawInput = node.input(createRef);
+            const rawInput = node.input(createRef, template, createItemRef);
             input = serializeInputMapping(rawInput);
         }
         // Get RPC name from func
@@ -100,6 +117,13 @@ export function serializeWorkflowGraph(definition, options) {
             next: serializeNext(node.next),
             onError: node.onError,
         };
+        const forEach = serializeForEach(node.forEach, createRef);
+        if (forEach) {
+            funcNode.forEach = forEach;
+            if (node.mode !== undefined) {
+                funcNode.mode = node.mode;
+            }
+        }
         if (node.notes !== undefined) {
             funcNode.notes = node.notes;
         }

package/dist/utils/workflow/graph/workflow-graph.types.d.ts

@@ -67,8 +67,8 @@ export interface NodeOptions {
  * Flow node types for control flow (no RPC call)
  */
 export type FlowType = 'sleep' | 'suspend' | 'approval' | 'branch' | 'parallel' | 'fanout' | 'inline' | 'switch' | 'filter' | 'arrayPredicate' | 'return' | 'cancel' | 'set';
-import type { ContextVariable, WorkflowContext, WorkflowPlannedStep } from '@pikku/core/ecosystem/workflow';
-import type { ScenarioStepPhase } from '@pikku/core/ecosystem/scenario';
+import type { ContextVariable, WorkflowContext, WorkflowPlannedStep } from '@pikku/core/workflow';
+import type { ScenarioStepPhase } from '@pikku/core/scenario';
 export type { ContextVariable, WorkflowContext };
 /**
  * Base node properties shared by all node types
@@ -90,11 +90,20 @@ interface BaseNode {
 /**
  * Function node - calls an RPC
  */
+/** How the per-item instances of a `forEach` node run */
+export type ForEachMode = 'parallel' | 'sequential';
 export interface FunctionNode extends BaseNode {
     /** RPC function name */
     rpcName: string;
     /** Input mapping - values can be literals or DataRefs */
     input?: Record<string, unknown | DataRef>;
+    /**
+     * Run this node once per element of the referenced array. The node's own
+     * result becomes the ordered array of per-item results.
+     */
+    forEach?: DataRef;
+    /** How the per-item instances run. Defaults to 'parallel'. */
+    mode?: ForEachMode;
     /** Output variable name for storing result */
     outputVar?: string;
     /** Hash of nodeId + RPC input/output schemas for version detection */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.60",
+  "version": "0.12.61",
   "description": "TypeScript inspector for Pikku — discovers functions and wirings to drive code generation",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
@@ -35,23 +35,23 @@
     "prepublishOnly": "yarn build"
   },
   "dependencies": {
-    "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
+    "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.4",
     "openapi-types": "^12.1.3",
-    "path-to-regexp": "^8.3.0",
-    "ts-json-schema-generator": "2.9.1-next.16",
-    "tsx": "^4.21.0",
+    "path-to-regexp": "^8.4.2",
+    "ts-json-schema-generator": "2.9.1-next.18",
+    "tsx": "^4.23.12",
     "typescript": "^6.0.3",
-    "zod": "^4.3.6",
+    "zod": "^4.4.3",
     "zod-to-ts": "^2.1.0"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.84"
+    "@pikku/core": "^0.12.85"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.84",
-    "@types/node": "^24.11.0"
+    "@pikku/core": "^0.12.85",
+    "@types/node": "^24.13.3"
   },
   "engines": {
     "node": ">=24"
   }
-}
+}

package/src/add/add-agent.ts

@@ -395,14 +395,12 @@ export const addAgent: AddWiring = (logger, node, checker, state, options) => {
 
     const roleValue = getPropertyValue(obj, 'role') as string | null
     const personalityValue = getPropertyValue(obj, 'personality') as
-      | string
-      | null
+      string | null
     const goalValue = getPropertyValue(obj, 'goal') as string | null
 
     const maxStepsValue = getPropertyValue(obj, 'maxSteps') as number | null
     const temperatureValue = getPropertyValue(obj, 'temperature') as
-      | number
-      | null
+      number | null
     const toolChoiceValue = getPropertyValue(obj, 'toolChoice') as string | null
     const scorersValue = resolveScorerNames(obj, nameValue || '', logger)
     const toolsValue = resolveToolReferences(

package/src/add/add-auth.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import type { FunctionServicesMeta } from '@pikku/core/ecosystem/types'
+import type { FunctionServicesMeta } from '@pikku/core/function'
 import type { AddWiring } from '../types.js'
 import { ErrorCode } from '../error-codes.js'
 import { extractServicesFromFunction } from '../utils/extract-services.js'
@@ -89,7 +89,7 @@ const readArrayProp = (
 
 /**
  * Read the callee name of a `plugins: [...]` entry. better-auth plugins are
- * factory calls (`bearer()`, `twoFactor({ ... })`, `admin()`); the entry's id
+ * factory calls (`bearer()`, `twoFactor({ ... })`, `ban()`); the entry's id
  * is the called function's name. Member-expression callees (`foo.bar()`) and
  * non-call entries are ignored.
  */

package/src/add/add-channel.ts

@@ -10,10 +10,7 @@ import {
   makeContextBasedId,
 } from '../utils/extract-function-name.js'
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
-import type {
-  ChannelMessageMeta,
-  ChannelMeta,
-} from '@pikku/core/ecosystem/channel'
+import type { ChannelMessageMeta, ChannelMeta } from '@pikku/core/channel'
 import type { InspectorState, AddWiring } from '../types.js'
 import {
   resolveMiddleware,

package/src/add/add-cli.ts

@@ -6,7 +6,7 @@ import type {
   InspectorOptions,
   InspectorState,
 } from '../types.js'
-import type { CLIProgramMeta, CLICommandMeta } from '@pikku/core/ecosystem/cli'
+import type { CLIProgramMeta, CLICommandMeta } from '@pikku/core/cli'
 import {
   extractFunctionName,
   makeContextBasedId,
@@ -630,6 +630,12 @@ function processOptions(
             }
             break
 
+          case 'type':
+            if (ts.isStringLiteral(optProp.initializer)) {
+              option.type = optProp.initializer.text
+            }
+            break
+
           case 'default':
             // Extract default value from expression
             if (ts.isStringLiteral(optProp.initializer)) {

package/src/add/add-credential.ts

@@ -39,11 +39,9 @@ export const addCredential: AddWiring = (
 
     const nameValue = getPropertyValue(obj, 'name') as string | null
     const displayNameValue = getPropertyValue(obj, 'displayName') as
-      | string
-      | null
+      string | null
     const descriptionValue = getPropertyValue(obj, 'description') as
-      | string
-      | null
+      string | null
     const typeValue = getPropertyValue(obj, 'type') as string | null
     const docsUrlValue = getPropertyValue(obj, 'docsUrl') as string | null
 
@@ -126,8 +124,7 @@ export const addCredential: AddWiring = (
         'appCredentialSecretId'
       ) as string | null
       const tokenSecretId = getPropertyValue(oauth2Obj, 'tokenSecretId') as
-        | string
-        | null
+        string | null
       const authorizationUrl = getPropertyValue(
         oauth2Obj,
         'authorizationUrl'

package/src/add/add-file-with-factory.ts

@@ -61,9 +61,7 @@ export const addFileWithFactory = (
           if (state && callExpression.arguments.length > 0) {
             const firstArg = callExpression.arguments[0]
             let functionNode:
-              | ts.ArrowFunction
-              | ts.FunctionExpression
-              | undefined
+              ts.ArrowFunction | ts.FunctionExpression | undefined
 
             if (ts.isArrowFunction(firstArg)) {
               functionNode = firstArg
@@ -179,9 +177,7 @@ export const addFileWithFactory = (
             node.initializer
           ) {
             let functionNode:
-              | ts.ArrowFunction
-              | ts.FunctionExpression
-              | undefined
+              ts.ArrowFunction | ts.FunctionExpression | undefined
             if (ts.isArrowFunction(node.initializer)) {
               functionNode = node.initializer
             } else if (ts.isFunctionExpression(node.initializer)) {

package/src/add/add-functions.ts

@@ -8,14 +8,10 @@ import {
 } from '../utils/extract-function-name.js'
 import { extractFunctionNode } from '../utils/extract-function-node.js'
 import { extractUsedWires } from '../utils/extract-services.js'
-import type { AuditDurability } from '@pikku/core/ecosystem/services'
-import type { FunctionServicesMeta } from '@pikku/core/ecosystem/types'
-import type { ScenarioSurface } from '@pikku/core/scenario'
-import type { ScenarioStepKind } from '@pikku/core/ecosystem/scenario'
-import {
-  formatVersionedId,
-  parseVersionedId,
-} from '@pikku/core/ecosystem/types'
+import type { AuditDurability } from '@pikku/core/services'
+import type { FunctionServicesMeta } from '@pikku/core/function'
+import type { ScenarioSurface, ScenarioStepKind } from '@pikku/core/scenario'
+import { formatVersionedId, parseVersionedId } from '@pikku/core/utils'
 
 /** Binding keys a `pikkuScenarioStep` may declare, in report order. */
 const SCENARIO_SURFACE_KEYS: readonly ScenarioSurface[] = [
@@ -49,7 +45,7 @@ import { ErrorCode } from '../error-codes.js'
 import { findPiiPaths } from '../utils/check-pii-output.js'
 import { findRevealedSecretSinks } from '../utils/check-secret-sinks.js'
 import { isScenarioInstrumentationFunction } from './scenario-instrumentation.js'
-import type { NodeType } from '@pikku/core/ecosystem/node'
+import type { NodeType } from '@pikku/core/node'
 
 const isValidVariableName = (name: string) => {
   const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/
@@ -597,6 +593,7 @@ export const addFunctions: AddWiring = (
   let workflowRetries: number | undefined
   let workflowTimeout: string | undefined
   let scenarioStepSurfaces: ScenarioSurface[] | undefined
+  let scenarioStepRequiresActor: boolean | undefined
   let scenarioStepAddon: string | undefined
   let scenarioStepTemplate: string | undefined
   let scopes: string[] | undefined
@@ -688,8 +685,7 @@ export const addFunctions: AddWiring = (
     mcp = getPropertyValue(firstArg, 'mcp') as boolean | undefined
     auth = getPropertyValue(firstArg, 'auth') as boolean | undefined
     permissionsInBody = getPropertyValue(firstArg, 'permissionsInBody') as
-      | boolean
-      | undefined
+      boolean | undefined
     if (permissionsInBody && !options.allow?.permissionsInBody) {
       logger.critical(
         ErrorCode.PERMISSIONS_IN_BODY_NOT_ALLOWED,
@@ -726,22 +722,15 @@ export const addFunctions: AddWiring = (
     }
     readonly_ = getPropertyValue(firstArg, 'readonly') as boolean | undefined
     deploy = getPropertyValue(firstArg, 'deploy') as
-      | 'serverless'
-      | 'server'
-      | 'auto'
-      | undefined
+      'serverless' | 'server' | 'auto' | undefined
     approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
-      | boolean
-      | undefined
+      boolean | undefined
     workflowQueued = getPropertyValue(firstArg, 'workflowQueued') as
-      | boolean
-      | undefined
+      boolean | undefined
     workflowRetries = getPropertyValue(firstArg, 'workflowRetries') as
-      | number
-      | undefined
+      number | undefined
     workflowTimeout = getPropertyValue(firstArg, 'workflowTimeout') as
-      | string
-      | undefined
+      string | undefined
     // A step declares one implementation per surface it supports; the binding
     // keys that are present ARE the declaration, so there is nothing to read a
     // value from — only names to collect.
@@ -772,8 +761,7 @@ export const addFunctions: AddWiring = (
       scenarioStepSurfaces = ['default']
       if (scenarioStepKind === 'addon') {
         scenarioStepAddon = getPropertyValue(firstArg, 'addon') as
-          | string
-          | undefined
+          string | undefined
         if (!scenarioStepAddon) {
           logger.error(
             `• pikkuAddonScenarioStep('${name}') needs a string literal \`addon\` naming the addon whose system acts — the same name its wireAddon declares.`
@@ -785,10 +773,16 @@ export const addFunctions: AddWiring = (
       scenarioStepSurfaces = declaredSurfaces.length
         ? declaredSurfaces
         : undefined
+      // A browser binding cannot be provisioned without a window to open, so it
+      // requires an actor whether or not the step said so.
+      scenarioStepRequiresActor =
+        getPropertyValue(firstArg, 'actor') === true ||
+        declaredSurfaces.includes('browser')
+          ? true
+          : undefined
     }
     scenarioStepTemplate = getPropertyValue(firstArg, 'template') as
-      | string
-      | undefined
+      string | undefined
     scopes = getArrayPropertyValue(firstArg, 'scopes') ?? undefined
 
     // Extract approvalDescription identifier reference
@@ -832,13 +826,11 @@ export const addFunctions: AddWiring = (
       ) {
         const nodeObj = prop.initializer
         nodeDisplayName = getPropertyValue(nodeObj, 'displayName') as
-          | string
-          | null
+          string | null
         nodeCategory = getPropertyValue(nodeObj, 'category') as string | null
         nodeType = getPropertyValue(nodeObj, 'type') as NodeType | null
         nodeErrorOutput = getPropertyValue(nodeObj, 'errorOutput') as
-          | boolean
-          | null
+          boolean | null
 
         if (!nodeDisplayName) {
           logger.critical(
@@ -1381,6 +1373,7 @@ export const addFunctions: AddWiring = (
     workflowRetries: workflowRetries ?? undefined,
     workflowTimeout: workflowTimeout ?? undefined,
     scenarioStepSurfaces,
+    scenarioStepRequiresActor,
     // `persona` is the default reading of an unmarked step, so it is left off
     // rather than written into every step meta a project already has.
     scenarioStepKind:

package/src/add/add-gateway.ts

@@ -13,7 +13,7 @@ import { ensureInlineWiringFunction } from '../utils/ensure-function-metadata.js
 import { resolveMiddleware } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
 import { resolveAddonName } from '../utils/resolve-addon-package.js'
-import type { GatewayTransportType } from '@pikku/core/ecosystem/gateway'
+import type { GatewayTransportType } from '@pikku/core/gateway'
 
 import { ErrorCode } from '../error-codes.js'
 

package/src/add/add-http-route-ref.test.ts

@@ -0,0 +1,149 @@
+import { strict as assert } from 'assert'
+import { describe, test, before, after } from 'node:test'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { inspect } from '../inspector.js'
+import { filterInspectorState } from '../utils/filter-inspector-state.js'
+import type { InspectorLogger, InspectorState } from '../types.js'
+
+const ADDON_PACKAGE = '@addon/greeter'
+const NAMESPACE = 'ext'
+const TARGET = `${NAMESPACE}:greet`
+
+const logger: InspectorLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  diagnostic: () => {},
+  critical: () => {},
+  hasCriticalErrors: () => false,
+} as unknown as InspectorLogger
+
+const writeAddonFixture = (rootDir: string) => {
+  writeFileSync(
+    join(rootDir, 'package.json'),
+    JSON.stringify({ name: 'consumer' })
+  )
+  const addonDir = join(rootDir, 'node_modules', ADDON_PACKAGE)
+  const pikku = join(addonDir, '.pikku')
+  mkdirSync(join(pikku, 'function'), { recursive: true })
+  mkdirSync(join(pikku, 'schemas', 'schemas'), { recursive: true })
+  writeFileSync(
+    join(addonDir, 'package.json'),
+    JSON.stringify({ name: ADDON_PACKAGE })
+  )
+  writeFileSync(
+    join(pikku, 'function', 'pikku-functions-meta.gen.json'),
+    JSON.stringify({
+      greet: {
+        pikkuFuncId: 'greet',
+        name: 'greet',
+        sessionless: true,
+        inputSchemaName: 'GreetInput',
+        outputSchemaName: 'GreetOutput',
+        inputs: ['GreetInput'],
+        outputs: ['GreetOutput'],
+        services: { optimized: true, services: ['logger'] },
+      },
+    })
+  )
+  writeFileSync(
+    join(pikku, 'schemas', 'schemas', 'GreetInput.schema.json'),
+    JSON.stringify({
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        loud: { type: 'boolean' },
+        name: { type: 'string' },
+      },
+    })
+  )
+}
+
+const writeWiring = (rootDir: string): string => {
+  const file = join(rootDir, 'greet.wiring.ts')
+  writeFileSync(
+    file,
+    [
+      `import { ref, wireAddon } from '@pikku/core'`,
+      `import { wireHTTP } from '@pikku/core/http'`,
+      ``,
+      `wireAddon({ name: '${NAMESPACE}', package: '${ADDON_PACKAGE}' })`,
+      ``,
+      `wireHTTP({`,
+      `  auth: false,`,
+      `  method: 'get',`,
+      `  route: '/greet/:id',`,
+      `  func: ref('${TARGET}'),`,
+      `})`,
+      ``,
+      `wireHTTP({`,
+      `  auth: false,`,
+      `  method: 'post',`,
+      `  route: '/greet',`,
+      `  query: ['loud'],`,
+      `  func: ref('${TARGET}'),`,
+      `})`,
+    ].join('\n')
+  )
+  return file
+}
+
+describe('an HTTP route wired with ref() to an addon function', () => {
+  let rootDir: string
+  let state: InspectorState
+
+  before(async () => {
+    rootDir = mkdtempSync(join(tmpdir(), 'pikku-http-ref-'))
+    writeAddonFixture(rootDir)
+    const file = writeWiring(rootDir)
+    state = await inspect(logger, [file], { rootDir })
+  })
+
+  after(() => {
+    rmSync(rootDir, { recursive: true, force: true })
+  })
+
+  test('records the ref target as the route function id', () => {
+    assert.equal(state.http.meta.get['/greet/:id']?.pikkuFuncId, TARGET)
+    assert.equal(state.http.meta.post['/greet']?.pikkuFuncId, TARGET)
+  })
+
+  // packageName names the package a wire runs in — its middleware, its
+  // services, its scoped credentials. The route belongs to the consuming app
+  // however its function is reached, so tagging it with the addon's package
+  // would silently swap the app's global middleware for the addon's.
+  test("leaves the route in the consuming app's package", () => {
+    assert.equal(state.http.meta.get['/greet/:id']?.packageName, undefined)
+    assert.equal(state.http.meta.post['/greet']?.packageName, undefined)
+  })
+
+  test('mints no wrapper function metadata for the route', () => {
+    const wrapperIds = Object.keys(state.functions.meta).filter((id) =>
+      id.startsWith('http:')
+    )
+    assert.deepEqual(wrapperIds, [])
+    assert.equal(state.functions.meta[TARGET], undefined)
+  })
+
+  test('keeps each route its own params and query', () => {
+    assert.deepEqual(state.http.meta.get['/greet/:id']?.params, ['id'])
+    assert.equal(state.http.meta.get['/greet/:id']?.query, undefined)
+    assert.equal(state.http.meta.post['/greet']?.params, undefined)
+    assert.deepEqual(state.http.meta.post['/greet']?.query, ['loud'])
+  })
+
+  test('marks the addon target as used so tree-shaking keeps it', () => {
+    assert.ok(state.serviceAggregation.usedFunctions.has(TARGET))
+  })
+
+  test('survives a filtered bundle together with its addon declaration', () => {
+    const filtered = filterInspectorState(state, { names: [TARGET] }, logger)
+    assert.equal(filtered.http.meta.get['/greet/:id']?.pikkuFuncId, TARGET)
+    assert.equal(filtered.http.meta.post['/greet']?.pikkuFuncId, TARGET)
+    assert.ok(filtered.rpc.wireAddonDeclarations.has(NAMESPACE))
+    assert.ok(filtered.serviceAggregation.usedFunctions.has(TARGET))
+  })
+})

package/src/add/add-http-route.ts

@@ -4,7 +4,7 @@ import {
   getCommonWireMetaData,
 } from '../utils/get-property-value.js'
 import { pathToRegexp } from 'path-to-regexp'
-import type { HTTPMethod } from '@pikku/core/ecosystem/http'
+import type { HTTPMethod } from '@pikku/core/http'
 import {
   extractFunctionName,
   makeContextBasedId,
@@ -243,6 +243,17 @@ export function registerHTTPRoute({
       )
     : null
 
+  // A ref()-wired route points straight at the addon function, the same way the
+  // CLI and channel adders record one. The addon's own metadata is the contract
+  // — and it is authoritative where the checker is not: `ref('ns:fn')` only
+  // types precisely once the consumer's own rpc map already lists the addon's
+  // functions, so a cold run inferred the whole `FlattenedRPCMap` and a warm one
+  // inferred the real input. The addon's metadata says which it is either way.
+  //
+  // The route stays the consuming app's all the same, so it records no
+  // packageName: that names the package a wire *runs in*, and running this one
+  // inside the addon would hand it the addon's middleware and services instead
+  // of the app's. `ref` reaches the addon over RPC, which enters it properly.
   if (refAddonTarget) {
     const targetMeta = resolveFunctionMeta(state, refAddonTarget)
     if (!targetMeta) {
@@ -251,25 +262,16 @@ export function registerHTTPRoute({
       )
       return
     }
-  }
-
-  ensureFunctionMetadata(
-    state,
-    funcName,
-    fullRoute,
-    funcInitializer,
-    checker,
-    extracted.isHelper
-  )
-
-  // Propagate sessionless from the addon target so the runtime can correctly
-  // determine whether a session is required for ref()-based routes.
-  if (refAddonTarget) {
-    const targetMeta = resolveFunctionMeta(state, refAddonTarget)
-    const inlineMeta = state.functions.meta[funcName]
-    if (targetMeta && inlineMeta && targetMeta.sessionless !== undefined) {
-      inlineMeta.sessionless = targetMeta.sessionless
-    }
+    funcName = refAddonTarget
+  } else {
+    ensureFunctionMetadata(
+      state,
+      funcName,
+      fullRoute,
+      funcInitializer,
+      checker,
+      extracted.isHelper
+    )
   }
 
   // The route's own `auth`, falling back to the group's. Recorded on the meta
@@ -322,13 +324,12 @@ export function registerHTTPRoute({
   const input = fnMeta.inputs?.[0] || null
 
   const getRouteInputKeys = (): string[] | null => {
-    const targetFuncName = refAddonTarget ?? funcName
-    const inputTypes = state.typesLookup.get(targetFuncName)
+    const inputTypes = state.typesLookup.get(funcName)
     if (inputTypes && inputTypes.length > 0) {
       return extractTypeKeys(inputTypes[0])
     }
 
-    const targetMeta = resolveFunctionMeta(state, targetFuncName)
+    const targetMeta = resolveFunctionMeta(state, funcName)
     if (targetMeta?.inputSchemaName) {
       const schema = state.schemas[targetMeta.inputSchemaName] as any
       const properties = schema?.properties
@@ -354,7 +355,7 @@ export function registerHTTPRoute({
           logger.critical(
             ErrorCode.ROUTE_PARAM_MISMATCH,
             `Route '${fullRoute}' has path parameter(s) [${missingParams.join(', ')}] ` +
-              `not found in function '${refAddonTarget ?? funcName}' input type. ` +
+              `not found in function '${funcName}' input type. ` +
               `Input type has: [${inputKeys.join(', ')}]`
           )
           return
@@ -368,7 +369,7 @@ export function registerHTTPRoute({
           logger.critical(
             ErrorCode.ROUTE_QUERY_MISMATCH,
             `Route '${fullRoute}' has query parameter(s) [${missingQuery.join(', ')}] ` +
-              `not found in function '${refAddonTarget ?? funcName}' input type. ` +
+              `not found in function '${funcName}' input type. ` +
               `Input type has: [${inputKeys.join(', ')}]`
           )
           return
@@ -393,9 +394,6 @@ export function registerHTTPRoute({
   const permissions = resolvePermissions(state, obj, tags, checker)
 
   state.serviceAggregation.usedFunctions.add(funcName)
-  if (refAddonTarget) {
-    state.serviceAggregation.usedFunctions.add(refAddonTarget)
-  }
   extractWireNames(middleware).forEach((name) =>
     state.serviceAggregation.usedMiddleware.add(name)
   )
@@ -420,7 +418,6 @@ export function registerHTTPRoute({
   state.http.files.add(sourceFile.fileName)
   state.http.meta[method][fullRoute] = {
     pikkuFuncId: funcName,
-    ...(refAddonTarget && { refTarget: refAddonTarget }),
     ...(packageName && { packageName }),
     route: fullRoute,
     sourceFile: sourceFile.fileName,