@pikku/inspector 0.12.8 → 0.12.10

package/dist/utils/workflow/dsl/validation.js

@@ -12,7 +12,7 @@ import * as ts from 'typescript';
  * - ThrowStatement (for WorkflowCancelledException)
  * - Block (containers)
  */
-export function validateNoDisallowedPatterns(node) {
+export function validateNoDisallowedPatterns(node, options) {
     const errors = [];
     function visitBlock(block) {
         for (const statement of block.statements) {
@@ -30,7 +30,7 @@ export function validateNoDisallowedPatterns(node) {
                 // Unknown/disallowed statement type
                 const nodeType = ts.SyntaxKind[statement.kind];
                 errors.push({
-                    message: `Statement type '${nodeType}' is not allowed in simple workflows. Allowed: const/let, if/else, switch/case, for..of, return, throw, and workflow calls. If this should be supported, please report the node type: ${nodeType}`,
+                    message: `Statement type '${nodeType}' is not allowed in DSL workflows. Allowed: const/let, if/else, switch/case, for..of, return, throw, and workflow calls. If this should be supported, please report the node type: ${nodeType}`,
                     node: statement,
                 });
             }
@@ -40,7 +40,7 @@ export function validateNoDisallowedPatterns(node) {
         // Disallow while and do-while
         if (ts.isWhileStatement(node) || ts.isDoStatement(node)) {
             errors.push({
-                message: 'while and do-while loops are not allowed in simple workflows',
+                message: 'while and do-while loops are not allowed in DSL workflows',
                 node,
             });
             return;
@@ -48,13 +48,13 @@ export function validateNoDisallowedPatterns(node) {
         // Disallow for and for-in loops
         if (ts.isForInStatement(node) || ts.isForStatement(node)) {
             errors.push({
-                message: 'for and for-in loops are not allowed in simple workflows. Use for-of instead.',
+                message: 'for and for-in loops are not allowed in DSL workflows. Use for-of instead.',
                 node,
             });
             return;
         }
         // Check for inline workflow.do
-        if (ts.isCallExpression(node)) {
+        if (!options?.allowInline && ts.isCallExpression(node)) {
             if (ts.isPropertyAccessExpression(node.expression)) {
                 const propAccess = node.expression;
                 if (propAccess.name.text === 'do' &&
@@ -65,7 +65,7 @@ export function validateNoDisallowedPatterns(node) {
                         (ts.isArrowFunction(secondArg) ||
                             ts.isFunctionExpression(secondArg))) {
                         errors.push({
-                            message: 'Inline workflow.do with function argument is not allowed in simple workflows. Use RPC form instead.',
+                            message: 'Inline workflow.do with function argument is not allowed in DSL workflows. Use pikkuWorkflowComplexFunc instead.',
                             node,
                         });
                         return;
@@ -97,11 +97,19 @@ export function validateAwaitedCalls(node) {
             if (propAccess.name.text === 'all' &&
                 ts.isIdentifier(propAccess.expression) &&
                 propAccess.expression.text === 'Promise') {
-                // console.log('[DEBUG] Found Promise.all, setting insidePromiseAll=true')
-                // Visit children with insidePromiseAll = true
                 ts.forEachChild(node, (child) => visit(child, parentIsAwait, true));
                 return;
             }
+            // .push() on an array — workflow.do() inside is collecting promises
+            if (propAccess.name.text === 'push') {
+                ts.forEachChild(node, (child) => visit(child, parentIsAwait, true));
+                return;
+            }
+        }
+        // Array literal — workflow.do() inside is collecting promises
+        if (ts.isArrayLiteralExpression(node)) {
+            ts.forEachChild(node, (child) => visit(child, parentIsAwait, true));
+            return;
         }
         // Now check for workflow calls
         if (ts.isCallExpression(node)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.8",
+  "version": "0.12.10",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.15",
+    "@pikku/core": "^0.12.18",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",
     "tsx": "^4.21.0",

package/src/add/add-functions.ts

@@ -339,6 +339,7 @@ export const addFunctions: AddWiring = (
   let remote: boolean | undefined
   let mcp: boolean | undefined
   let readonly_: boolean | undefined
+  let deploy: 'serverless' | 'server' | 'auto' | undefined
   let approvalRequired: boolean | undefined
   let approvalDescription: string | undefined
   let version: number | undefined
@@ -422,6 +423,11 @@ export const addFunctions: AddWiring = (
     remote = getPropertyValue(firstArg, 'remote') as boolean | undefined
     mcp = getPropertyValue(firstArg, 'mcp') as boolean | undefined
     readonly_ = getPropertyValue(firstArg, 'readonly') as boolean | undefined
+    deploy = getPropertyValue(firstArg, 'deploy') as
+      | 'serverless'
+      | 'server'
+      | 'auto'
+      | undefined
     approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
       | boolean
       | undefined
@@ -783,6 +789,7 @@ export const addFunctions: AddWiring = (
     remote: remote || undefined,
     mcp: mcpEnabled || undefined,
     readonly: readonly_ || undefined,
+    deploy: deploy || undefined,
     approvalRequired: approvalRequired || undefined,
     approvalDescription: approvalDescription || undefined,
     version,
@@ -817,18 +824,14 @@ export const addFunctions: AddWiring = (
 
   if (mcpEnabled) {
     if (!description) {
-      logger.critical(
-        ErrorCode.MISSING_DESCRIPTION,
-        `MCP tool '${name}' is missing a description.`
-      )
-      return
+      logger.warn(`MCP tool '${name}' is missing a description.`)
     }
     state.mcpEndpoints.files.add(node.getSourceFile().fileName)
     state.mcpEndpoints.toolsMeta[name] = {
       pikkuFuncId,
       name,
       title: title || undefined,
-      description,
+      description: description || undefined,
       summary,
       errors,
       tags,

package/src/add/add-mcp-prompt.ts

@@ -114,6 +114,11 @@ export const addMCPPrompt: AddWiring = (
     const inputSchema = fnMeta.inputs?.[0] || null
     const outputSchema = fnMeta.outputs?.[0] || null
 
+    if (!fnMeta.outputSchemaName) {
+      fnMeta.outputSchemaName = 'MCPPromptResponse'
+      fnMeta.outputs = ['MCPPromptResponse']
+    }
+
     // --- resolve middleware ---
     const middleware = resolveMiddleware(state, obj, tags, checker)
 

package/src/add/add-mcp-resource.ts

@@ -131,6 +131,11 @@ export const addMCPResource: AddWiring = (
     const inputSchema = fnMeta.inputs?.[0] || null
     const outputSchema = fnMeta.outputs?.[0] || null
 
+    if (!fnMeta.outputSchemaName) {
+      fnMeta.outputSchemaName = 'MCPResourceResponse'
+      fnMeta.outputs = ['MCPResourceResponse']
+    }
+
     // --- resolve middleware ---
     const middleware = resolveMiddleware(state, obj, tags, checker)
 

package/src/add/add-workflow.ts

@@ -97,7 +97,7 @@ function getWorkflowInvocations(
           const stepNameArg = args[0]
           const secondArg = args[1]
           const optionsArg =
-            args.length >= 3 ? args[args.length - 1] : undefined
+            args.length >= 4 ? args[args.length - 1] : undefined
 
           const stepName = extractStringLiteral(stepNameArg, checker)
           const description =
@@ -155,7 +155,7 @@ function getWorkflowInvocations(
 }
 
 /**
- * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
+ * Inspector for pikkuWorkflowFunc() and pikkuWorkflowComplexFunc() calls
  * Detects workflow registration and extracts metadata
  */
 export const addWorkflow: AddWiring = (logger, node, checker, state) => {
@@ -171,11 +171,11 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
     return
   }
 
-  let wrapperType: 'dsl' | 'regular' | null = null
+  let wrapperType: 'dsl' | 'complex' | null = null
   if (expression.text === 'pikkuWorkflowFunc') {
     wrapperType = 'dsl'
   } else if (expression.text === 'pikkuWorkflowComplexFunc') {
-    wrapperType = 'regular'
+    wrapperType = 'complex'
   } else {
     return
   }
@@ -267,7 +267,9 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
 
   // Try DSL workflow extraction first
   // Pass the whole CallExpression node so findWorkflowFunction can find the arrow function
-  const result = extractDSLWorkflow(node, checker)
+  const result = extractDSLWorkflow(node, checker, {
+    allowInline: wrapperType === 'complex',
+  })
 
   if (result.status === 'ok' && result.steps) {
     // Extraction succeeded
@@ -305,7 +307,7 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
       getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps)
       logger.critical(
         ErrorCode.INVALID_DSL_WORKFLOW,
-        `Workflow '${workflowName}' uses pikkuWorkflowFunc but does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`
+        `Workflow '${workflowName}' does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`
       )
       return
     } else {
@@ -317,12 +319,10 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
     }
   }
 
-  /**
-   * For non-dsl workflows or pikkuWorkflowComplexFunc, run basic extraction
-   * to ensure all RPC invocations are tracked for function registration.
-   * This catches RPCs in Promise.all callbacks and other patterns DSL can't extract.
-   */
-  if (!dsl || wrapperType === 'regular') {
+  // For pikkuWorkflowComplexFunc, also run basic extraction so RPCs in
+  // patterns the DSL extractor doesn't handle (array+push, nested Promise.all
+  // with identifier args, etc.) are still registered as invoked functions.
+  if (wrapperType === 'complex') {
     getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps)
   }
 

package/src/utils/extract-function-name.ts

@@ -1,5 +1,6 @@
 import * as ts from 'typescript'
 import { randomUUID } from 'crypto'
+import { formatVersionedId } from '@pikku/core'
 
 export type ExtractedFunctionName = {
   pikkuFuncId: string
@@ -8,6 +9,7 @@ export type ExtractedFunctionName = {
   exportedName: string | null
   propertyName: string | null
   isHelper: boolean
+  version: number | null
 }
 
 export function makeContextBasedId(
@@ -40,6 +42,7 @@ export function extractFunctionName(
     propertyName: null,
     explicitName: null,
     isHelper: false,
+    version: null,
   }
 
   const workflowHelpers = new Set([
@@ -143,18 +146,7 @@ export function extractFunctionName(
       // Check for object with 'name' property in first argument
       const firstArg = args[0]
       if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-        for (const prop of firstArg.properties) {
-          if (
-            ts.isPropertyAssignment(prop) &&
-            ts.isIdentifier(prop.name) &&
-            prop.name.text === 'override' &&
-            ts.isStringLiteral(prop.initializer)
-          ) {
-            // Priority 1: Object with override property
-            result.explicitName = prop.initializer.text
-            break
-          }
-        }
+        extractOverrideAndVersion(firstArg, result)
       }
 
       // Special handling for pikkuSessionlessFunc pattern - use the arrow function directly
@@ -367,21 +359,9 @@ export function extractFunctionName(
             ts.isIdentifier(decl.initializer.expression) &&
             decl.initializer.expression.text.startsWith('pikku')
           ) {
-            // Check for object with 'override' property in first argument
             const firstArg = decl.initializer.arguments[0]
             if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-              for (const prop of firstArg.properties) {
-                if (
-                  ts.isPropertyAssignment(prop) &&
-                  ts.isIdentifier(prop.name) &&
-                  prop.name.text === 'override' &&
-                  ts.isStringLiteral(prop.initializer)
-                ) {
-                  // Priority 1: Object with override property
-                  result.explicitName = prop.initializer.text
-                  break
-                }
-              }
+              extractOverrideAndVersion(firstArg, result)
             }
 
             if (decl.initializer.expression.text.startsWith('pikku')) {
@@ -448,18 +428,7 @@ export function extractFunctionName(
   else if (ts.isCallExpression(callExpr)) {
     const firstArg = callExpr.arguments[0]
     if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
-      for (const prop of firstArg.properties) {
-        if (
-          ts.isPropertyAssignment(prop) &&
-          ts.isIdentifier(prop.name) &&
-          prop.name.text === 'override' &&
-          ts.isStringLiteral(prop.initializer) &&
-          !result.explicitName // Only set if not already set
-        ) {
-          result.explicitName = prop.initializer.text
-          break
-        }
-      }
+      extractOverrideAndVersion(firstArg, result)
     }
   }
 
@@ -474,6 +443,10 @@ export function extractFunctionName(
     result.pikkuFuncId = `__temp_${randomUUID()}`
   }
 
+  if (result.version !== null) {
+    result.pikkuFuncId = formatVersionedId(result.pikkuFuncId, result.version)
+  }
+
   return result
 }
 
@@ -539,3 +512,29 @@ export function isNamedExport(
 
   return false
 }
+
+function extractOverrideAndVersion(
+  objLiteral: ts.ObjectLiteralExpression,
+  result: ExtractedFunctionName
+): void {
+  for (const prop of objLiteral.properties) {
+    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+      if (
+        prop.name.text === 'override' &&
+        ts.isStringLiteral(prop.initializer) &&
+        !result.explicitName
+      ) {
+        result.explicitName = prop.initializer.text
+      } else if (
+        prop.name.text === 'version' &&
+        ts.isNumericLiteral(prop.initializer) &&
+        result.version === null
+      ) {
+        const parsed = Number(prop.initializer.text)
+        if (Number.isInteger(parsed) && parsed >= 1) {
+          result.version = parsed
+        }
+      }
+    }
+  }
+}

package/src/utils/extract-node-value.test.ts

@@ -0,0 +1,67 @@
+import { test, describe } from 'node:test'
+import { strict as assert } from 'node:assert'
+import * as ts from 'typescript'
+import { extractDescription } from './extract-node-value'
+
+const createChecker = (source: string) => {
+  const sourceFile = ts.createSourceFile(
+    'test.ts',
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  )
+  const host = ts.createCompilerHost({})
+  const originalGetSourceFile = host.getSourceFile
+  host.getSourceFile = (fileName, target) => {
+    if (fileName === 'test.ts') return sourceFile
+    return originalGetSourceFile.call(host, fileName, target)
+  }
+  const program = ts.createProgram(['test.ts'], {}, host)
+  return { checker: program.getTypeChecker(), sourceFile }
+}
+
+const findObjectLiteral = (
+  node: ts.Node
+): ts.ObjectLiteralExpression | undefined => {
+  if (ts.isObjectLiteralExpression(node)) return node
+  let result: ts.ObjectLiteralExpression | undefined
+  ts.forEachChild(node, (child) => {
+    if (!result) result = findObjectLiteral(child)
+  })
+  return result
+}
+
+describe('extractDescription', () => {
+  test('returns null when node is undefined', () => {
+    const { checker } = createChecker('')
+    assert.equal(extractDescription(undefined, checker), null)
+  })
+
+  test('extracts string literal description', () => {
+    const { checker, sourceFile } = createChecker(
+      `const opts = { description: 'my step' }`
+    )
+    const obj = findObjectLiteral(sourceFile)!
+    assert.equal(extractDescription(obj, checker), 'my step')
+  })
+
+  test('returns null for non-literal description value without crashing', () => {
+    const { checker, sourceFile } = createChecker(
+      `const name = 'test'; const data = { description: name + ' addon' }`
+    )
+    const objs: ts.ObjectLiteralExpression[] = []
+    const visit = (node: ts.Node) => {
+      if (ts.isObjectLiteralExpression(node)) objs.push(node)
+      ts.forEachChild(node, visit)
+    }
+    ts.forEachChild(sourceFile, visit)
+    const dataObj = objs[objs.length - 1]!
+    assert.equal(extractDescription(dataObj, checker), null)
+  })
+
+  test('returns null for non-object node', () => {
+    const { checker, sourceFile } = createChecker(`const x = 42`)
+    assert.equal(extractDescription(sourceFile, checker), null)
+  })
+})

package/src/utils/extract-node-value.ts

@@ -27,6 +27,11 @@ export function extractStringLiteral(
     return result
   }
 
+  // Unwrap type assertions: `expr as Type` or `<Type>expr`
+  if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+    return extractStringLiteral(node.expression, checker)
+  }
+
   // Try to evaluate constant identifiers
   if (ts.isIdentifier(node)) {
     const symbol = checker.getSymbolAtLocation(node)
@@ -110,7 +115,11 @@ export function extractDescription(
   if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
     return null
   }
-  return extractPropertyString(optionsNode, 'description', checker)
+  try {
+    return extractPropertyString(optionsNode, 'description', checker)
+  } catch {
+    return null
+  }
 }
 
 /**

package/src/utils/filter-inspector-state.ts

@@ -730,11 +730,15 @@ export function filterInspectorState(
     }
   }
 
-  // Post-filter version expansion: include all versions of matched functions
+  // Post-filter version expansion: when an unversioned base name is matched,
+  // include all its versions. Specific version matches (e.g. analyzeData@v1)
+  // do NOT expand to include other versions.
   const includedBaseNames = new Set<string>()
   for (const funcId of filteredState.serviceAggregation.usedFunctions) {
-    const { baseName } = parseVersionedId(funcId)
-    includedBaseNames.add(baseName)
+    const { baseName, version } = parseVersionedId(funcId)
+    if (version === null) {
+      includedBaseNames.add(baseName)
+    }
   }
   if (includedBaseNames.size > 0) {
     for (const funcId of Object.keys(state.functions.meta)) {

package/src/utils/resolve-versions.test.ts

@@ -215,6 +215,147 @@ describe('resolveLatestVersions', () => {
     assert.strictEqual(errors.length, 0)
   })
 
+  test('exposedMeta propagates all versions when base name is exposed', () => {
+    const state = makeState({
+      'createUser@v1': {
+        pikkuFuncId: 'createUser@v1',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 1,
+      },
+      createUser: {
+        pikkuFuncId: 'createUser',
+        inputSchemaName: null,
+        outputSchemaName: null,
+      },
+    })
+    state.rpc.exposedMeta['createUser'] = 'createUser'
+    state.rpc.internalFiles.set('createUser@v1', {
+      path: '/src/user.ts',
+      exportedName: 'createUserV1',
+    })
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    assert.strictEqual(state.rpc.exposedMeta['createUser'], 'createUser@v2')
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v1'], 'createUser@v1')
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v2'], 'createUser@v2')
+  })
+
+  test('exposedFiles propagated for versioned exposed functions', () => {
+    const state = makeState({
+      'createUser@v1': {
+        pikkuFuncId: 'createUser@v1',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 1,
+      },
+      createUser: {
+        pikkuFuncId: 'createUser',
+        inputSchemaName: null,
+        outputSchemaName: null,
+      },
+    })
+    state.rpc.exposedMeta['createUser'] = 'createUser'
+    state.rpc.internalFiles.set('createUser@v1', {
+      path: '/src/user-v1.ts',
+      exportedName: 'createUserV1',
+    })
+    state.rpc.internalFiles.set('createUser', {
+      path: '/src/user.ts',
+      exportedName: 'createUser',
+    })
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    assert.ok(state.rpc.exposedFiles.has('createUser@v1'))
+    assert.strictEqual(
+      state.rpc.exposedFiles.get('createUser@v1')!.exportedName,
+      'createUserV1'
+    )
+    assert.ok(state.rpc.exposedFiles.has('createUser@v2'))
+  })
+
+  test('exposedMeta unchanged when base name is not exposed', () => {
+    const state = makeState({
+      'createUser@v1': {
+        pikkuFuncId: 'createUser@v1',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 1,
+      },
+      createUser: {
+        pikkuFuncId: 'createUser',
+        inputSchemaName: null,
+        outputSchemaName: null,
+      },
+    })
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v1'], undefined)
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v2'], undefined)
+  })
+
+  test('exposedMeta propagates when only explicit versions exist', () => {
+    const state = makeState({
+      'createUser@v1': {
+        pikkuFuncId: 'createUser@v1',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 1,
+      },
+      'createUser@v2': {
+        pikkuFuncId: 'createUser@v2',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 2,
+      },
+    })
+    state.rpc.exposedMeta['createUser'] = 'createUser@v1'
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    assert.strictEqual(state.rpc.exposedMeta['createUser'], 'createUser@v2')
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v1'], 'createUser@v1')
+    assert.strictEqual(state.rpc.exposedMeta['createUser@v2'], 'createUser@v2')
+  })
+
+  test('updates HTTP meta pikkuFuncId when renaming unversioned', () => {
+    const state = makeState({
+      'createUser@v1': {
+        pikkuFuncId: 'createUser@v1',
+        inputSchemaName: null,
+        outputSchemaName: null,
+        version: 1,
+      },
+      createUser: {
+        pikkuFuncId: 'createUser',
+        inputSchemaName: null,
+        outputSchemaName: null,
+      },
+    })
+    ;(state as any).http = {
+      meta: {
+        post: {
+          '/api/users': { pikkuFuncId: 'createUser', route: '/api/users' },
+        },
+      },
+    }
+    const { logger } = makeLogger()
+
+    resolveLatestVersions(state, logger)
+
+    assert.strictEqual(
+      (state as any).http.meta.post['/api/users'].pikkuFuncId,
+      'createUser@v2'
+    )
+  })
+
   test('renames files entries when renaming unversioned to versioned', () => {
     const state = makeState({
       'createUser@v1': {

package/src/utils/resolve-versions.ts

@@ -91,6 +91,8 @@ export function resolveLatestVersions(
       if (state.rpc.exposedMeta[baseName] === oldId) {
         state.rpc.exposedMeta[baseName] = newId
       }
+
+      updateWiringReferences(state, oldId, newId)
     } else {
       const latest = group.explicit.reduce((a, b) =>
         a.version > b.version ? a : b
@@ -98,8 +100,43 @@ export function resolveLatestVersions(
       state.rpc.internalMeta[baseName] = latest.id
     }
 
+    if (state.rpc.exposedMeta[baseName]) {
+      const latestId = state.rpc.internalMeta[baseName]!
+      state.rpc.exposedMeta[baseName] = latestId
+      for (const entry of group.explicit) {
+        state.rpc.exposedMeta[entry.id] = entry.id
+        const fileEntry = state.rpc.internalFiles.get(entry.id)
+        if (fileEntry) {
+          state.rpc.exposedFiles.set(entry.id, fileEntry)
+        }
+      }
+      if (group.unversioned) {
+        state.rpc.exposedMeta[latestId] = latestId
+        const fileEntry = state.rpc.internalFiles.get(latestId)
+        if (fileEntry) {
+          state.rpc.exposedFiles.set(latestId, fileEntry)
+        }
+      }
+    }
+
     for (const entry of group.explicit) {
       state.rpc.invokedFunctions.add(entry.id)
     }
   }
 }
+
+function updateWiringReferences(
+  state: InspectorState,
+  oldId: string,
+  newId: string
+): void {
+  if (state.http) {
+    for (const methods of Object.values(state.http.meta)) {
+      for (const meta of Object.values(methods)) {
+        if (meta.pikkuFuncId === oldId) {
+          meta.pikkuFuncId = newId
+        }
+      }
+    }
+  }
+}