@pikku/inspector 0.12.0 → 0.12.1

package/src/utils/contract-hashes.test.ts

@@ -16,12 +16,22 @@ import { ErrorCode } from '../error-codes.js'
 function makeContracts(
   entries: Record<
     string,
-    { functionKey: string; version: number; contractHash: string }
+    {
+      functionKey: string
+      version: number
+      contractHash: string
+      inputHash?: string
+      outputHash?: string
+    }
   >
 ): Map<string, ContractEntry> {
   const map = new Map<string, ContractEntry>()
   for (const [id, entry] of Object.entries(entries)) {
-    map.set(id, entry)
+    map.set(id, {
+      ...entry,
+      inputHash: entry.inputHash ?? entry.contractHash.slice(0, 8),
+      outputHash: entry.outputHash ?? entry.contractHash.slice(0, 8),
+    })
   }
   return map
 }
@@ -414,11 +424,16 @@ describe('updateManifest', () => {
         functionKey: 'createUser',
         version: 1,
         contractHash: 'abc',
+        inputHash: 'in123456',
+        outputHash: 'out1234',
       },
     })
     const result = updateManifest(manifest, contracts)
     assert.strictEqual(result.contracts.createUser.latest, 1)
-    assert.strictEqual(result.contracts.createUser.versions['1'], 'abc')
+    assert.deepStrictEqual(result.contracts.createUser.versions['1'], {
+      inputHash: 'in123456',
+      outputHash: 'out1234',
+    })
   })
 
   test('adds new version to existing function and updates latest', () => {
@@ -433,17 +448,27 @@ describe('updateManifest', () => {
         functionKey: 'createUser',
         version: 1,
         contractHash: 'aaa',
+        inputHash: 'inaaa123',
+        outputHash: 'outaaa12',
       },
       'createUser@v2': {
         functionKey: 'createUser',
         version: 2,
         contractHash: 'bbb',
+        inputHash: 'inbbb123',
+        outputHash: 'outbbb12',
       },
     })
     const result = updateManifest(manifest, contracts)
     assert.strictEqual(result.contracts.createUser.latest, 2)
-    assert.strictEqual(result.contracts.createUser.versions['2'], 'bbb')
-    assert.strictEqual(result.contracts.createUser.versions['1'], 'aaa')
+    assert.deepStrictEqual(result.contracts.createUser.versions['2'], {
+      inputHash: 'inbbb123',
+      outputHash: 'outbbb12',
+    })
+    assert.deepStrictEqual(result.contracts.createUser.versions['1'], {
+      inputHash: 'inaaa123',
+      outputHash: 'outaaa12',
+    })
   })
 
   test('preserves deleted functions', () => {

package/src/utils/contract-hashes.ts

@@ -1,5 +1,6 @@
-import { FunctionsMeta, JSONValue, parseVersionedId } from '@pikku/core'
-import { TypesMap } from '../types-map.js'
+import type { FunctionsMeta, JSONValue } from '@pikku/core'
+import { parseVersionedId } from '@pikku/core'
+import type { TypesMap } from '../types-map.js'
 import { ErrorCode } from '../error-codes.js'
 import { canonicalJSON, hashString } from './hash.js'
 
@@ -7,16 +8,34 @@ export type ContractEntry = {
   functionKey: string
   version: number
   contractHash: string
+  inputHash: string
+  outputHash: string
 }
 
 export type VersionValidateError = {
   code: ErrorCode
   message: string
+  functionKey?: string
+  version?: number
+  previousHash?: string
+  currentHash?: string
+  previousInputHash?: string
+  currentInputHash?: string
+  previousOutputHash?: string
+  currentOutputHash?: string
+  nextVersion?: number
+  latestVersion?: number
+  expectedNextVersion?: number
+}
+
+export type VersionHashEntry = {
+  inputHash: string
+  outputHash: string
 }
 
 export type VersionManifestEntry = {
   latest: number
-  versions: Record<string, string>
+  versions: Record<string, string | VersionHashEntry>
 }
 
 export type VersionManifest = {
@@ -24,6 +43,10 @@ export type VersionManifest = {
   contracts: Record<string, VersionManifestEntry>
 }
 
+function isHashEntry(v: string | VersionHashEntry): v is VersionHashEntry {
+  return typeof v === 'object'
+}
+
 export function createEmptyManifest(): VersionManifest {
   return {
     manifestVersion: 1,
@@ -36,7 +59,7 @@ export function serializeManifest(manifest: VersionManifest): string {
 
   for (const key of Object.keys(manifest.contracts).sort()) {
     const entry = manifest.contracts[key]
-    const sortedVersions: Record<string, string> = {}
+    const sortedVersions: Record<string, string | VersionHashEntry> = {}
     const numericKeys = Object.keys(entry.versions)
       .map(Number)
       .sort((a, b) => a - b)
@@ -65,6 +88,14 @@ export function computeContractHash(data: {
   return hashString(canonicalJSON(data), 16)
 }
 
+function computeInputHash(functionKey: string, inputSchema: unknown): string {
+  return hashString(canonicalJSON({ functionKey, inputSchema }), 8)
+}
+
+function computeOutputHash(functionKey: string, outputSchema: unknown): string {
+  return hashString(canonicalJSON({ functionKey, outputSchema }), 8)
+}
+
 function resolveSchema(
   typeNames: string[] | null | undefined,
   allSchemas: Record<string, JSONValue>,
@@ -120,7 +151,16 @@ export function buildCurrentContracts(
       inputSchema,
       outputSchema,
     })
-    result.set(funcId, { functionKey, version, contractHash })
+    const inputHash = computeInputHash(functionKey, inputSchema)
+    const outputHash = computeOutputHash(functionKey, outputSchema)
+
+    result.set(funcId, {
+      functionKey,
+      version,
+      contractHash,
+      inputHash,
+      outputHash,
+    })
   }
 
   return result
@@ -137,6 +177,8 @@ export function computeContractHashes(
     const meta = functionsMeta[funcId]
     if (meta) {
       meta.contractHash = entry.contractHash
+      meta.inputHash = entry.inputHash
+      meta.outputHash = entry.outputHash
     }
   }
 
@@ -155,6 +197,19 @@ function groupByFunctionKey(
   return grouped
 }
 
+function entryChanged(
+  existing: string | VersionHashEntry,
+  current: ContractEntry
+): boolean {
+  if (isHashEntry(existing)) {
+    return (
+      existing.inputHash !== current.inputHash ||
+      existing.outputHash !== current.outputHash
+    )
+  }
+  return existing !== current.contractHash
+}
+
 export function validateContracts(
   manifest: VersionManifest,
   currentContracts: Map<string, ContractEntry>
@@ -169,15 +224,32 @@ export function validateContracts(
       continue
     }
 
-    for (const { version, contractHash } of entries) {
-      const existingHash = manifestEntry.versions[String(version)]
+    for (const current of entries) {
+      const { version, contractHash, inputHash, outputHash } = current
+      const existingEntry = manifestEntry.versions[String(version)]
 
-      if (existingHash !== undefined) {
-        if (existingHash !== contractHash) {
+      if (existingEntry !== undefined) {
+        if (entryChanged(existingEntry, current)) {
           reportedKeys.add(`${functionKey}@${version}`)
+          const prevInputHash = isHashEntry(existingEntry)
+            ? existingEntry.inputHash
+            : existingEntry
+          const prevOutputHash = isHashEntry(existingEntry)
+            ? existingEntry.outputHash
+            : existingEntry
           errors.push({
             code: ErrorCode.FUNCTION_VERSION_MODIFIED,
-            message: `Contract for ${functionKey}@v${version} has changed (recorded: ${existingHash}, current: ${contractHash}). Existing versions are immutable.`,
+            message: `Contract for ${functionKey}@v${version} has changed (recorded: ${isHashEntry(existingEntry) ? `${existingEntry.inputHash}/${existingEntry.outputHash}` : existingEntry}, current: ${contractHash}). Existing versions are immutable.`,
+            functionKey,
+            version,
+            previousHash: isHashEntry(existingEntry)
+              ? existingEntry.inputHash
+              : existingEntry,
+            currentHash: contractHash,
+            previousInputHash: prevInputHash,
+            currentInputHash: inputHash,
+            previousOutputHash: prevOutputHash,
+            currentOutputHash: outputHash,
           })
         }
       } else {
@@ -185,11 +257,18 @@ export function validateContracts(
           errors.push({
             code: ErrorCode.VERSION_REGRESSION_OR_CONFLICT,
             message: `Version ${version} for ${functionKey} is <= latest (${manifestEntry.latest}) but not recorded. Possible merge conflict.`,
+            functionKey,
+            version,
+            latestVersion: manifestEntry.latest,
           })
         } else if (version > manifestEntry.latest + 1) {
           errors.push({
             code: ErrorCode.VERSION_GAP_NOT_ALLOWED,
             message: `Version ${version} for ${functionKey} skips versions. Latest is ${manifestEntry.latest}, next must be ${manifestEntry.latest + 1}.`,
+            functionKey,
+            version,
+            latestVersion: manifestEntry.latest,
+            expectedNextVersion: manifestEntry.latest + 1,
           })
         }
       }
@@ -199,7 +278,7 @@ export function validateContracts(
   for (const [functionKey, manifestEntry] of Object.entries(
     manifest.contracts
   )) {
-    const latestHash = manifestEntry.versions[String(manifestEntry.latest)]
+    const latestEntry = manifestEntry.versions[String(manifestEntry.latest)]
     const currentEntries = grouped.get(functionKey)
     if (!currentEntries) {
       continue
@@ -210,12 +289,24 @@ export function validateContracts(
     )
     if (
       currentLatest &&
-      currentLatest.contractHash !== latestHash &&
+      entryChanged(latestEntry, currentLatest) &&
       !reportedKeys.has(`${functionKey}@${manifestEntry.latest}`)
     ) {
+      const prevInputHash = isHashEntry(latestEntry)
+        ? latestEntry.inputHash
+        : undefined
+      const prevOutputHash = isHashEntry(latestEntry)
+        ? latestEntry.outputHash
+        : undefined
       errors.push({
         code: ErrorCode.CONTRACT_CHANGED_REQUIRES_BUMP,
         message: `Contract for ${functionKey} changed. Set \`version: ${manifestEntry.latest + 1}\` on the function or run 'pikku versions update'.`,
+        functionKey,
+        previousInputHash: prevInputHash,
+        currentInputHash: currentLatest.inputHash,
+        previousOutputHash: prevOutputHash,
+        currentOutputHash: currentLatest.outputHash,
+        nextVersion: manifestEntry.latest + 1,
       })
     }
   }
@@ -232,6 +323,9 @@ export function validateContracts(
       errors.push({
         code: ErrorCode.MANIFEST_INTEGRITY_ERROR,
         message: `Manifest integrity error for ${functionKey}: latest field (${manifestEntry.latest}) inconsistent with version keys (max: ${maxVersion}).`,
+        functionKey,
+        latestVersion: manifestEntry.latest,
+        expectedNextVersion: maxVersion,
       })
     }
   }
@@ -256,8 +350,8 @@ export function updateManifest(
     }
 
     const entry = manifest.contracts[functionKey]
-    for (const { version, contractHash } of entries) {
-      entry.versions[String(version)] = contractHash
+    for (const { version, inputHash, outputHash } of entries) {
+      entry.versions[String(version)] = { inputHash, outputHash }
       entry.latest = Math.max(entry.latest, version)
     }
   }
@@ -283,6 +377,8 @@ export function extractContractsFromMeta(
       functionKey,
       version,
       contractHash: meta.contractHash,
+      inputHash: meta.inputHash ?? '',
+      outputHash: meta.outputHash ?? '',
     })
   }
 

package/src/utils/custom-types-generator.ts

@@ -1,4 +1,4 @@
-import { TypesMap } from '../types-map.js'
+import type { TypesMap } from '../types-map.js'
 
 /**
  * NOTE: Code generation normally belongs in @pikku/cli, not the inspector.

package/src/utils/detect-schema-vendor.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript'
+import type * as ts from 'typescript'
 import type { SchemaVendor, InspectorLogger } from '../types.js'
 import { ErrorCode } from '../error-codes.js'
 

package/src/utils/does-type-extend-core-type.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript'
+import type * as ts from 'typescript'
 
 export const doesTypeExtendsCore = (
   type: ts.Type,

package/src/utils/ensure-function-metadata.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import { InspectorState } from '../types.js'
+import type { InspectorState } from '../types.js'
 import { funcIdToTypeName } from './extract-function-name.js'
 import { getCommonWireMetaData } from './get-property-value.js'
 import { resolveMiddleware } from './middleware.js'

package/src/utils/extract-services.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import { FunctionServicesMeta, FunctionWiresMeta } from '@pikku/core'
+import type { FunctionServicesMeta, FunctionWiresMeta } from '@pikku/core'
 
 /**
  * Extract services from a function's first parameter destructuring pattern

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

@@ -1,11 +1,9 @@
 import { test, describe } from 'node:test'
 import { strict as assert } from 'node:assert'
 import { filterInspectorState } from './filter-inspector-state.js'
-import { InspectorState, InspectorFilters } from '../types.js'
-import {
-  deserializeInspectorState,
-  SerializableInspectorState,
-} from './serialize-inspector-state.js'
+import type { InspectorState, InspectorFilters } from '../types.js'
+import type { SerializableInspectorState } from './serialize-inspector-state.js'
+import { deserializeInspectorState } from './serialize-inspector-state.js'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'

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

@@ -1,5 +1,10 @@
-import { InspectorState, InspectorFilters, InspectorLogger } from '../types.js'
-import { PikkuWiringTypes, parseVersionedId } from '@pikku/core'
+import type {
+  InspectorState,
+  InspectorFilters,
+  InspectorLogger,
+} from '../types.js'
+import type { PikkuWiringTypes } from '@pikku/core'
+import { parseVersionedId } from '@pikku/core'
 import { aggregateRequiredServices } from './post-process.js'
 
 // Module-level Set to track warned groups across multiple filter calls

package/src/utils/filter-utils.test.ts

@@ -1,6 +1,6 @@
 import { test, describe } from 'node:test'
 import { strict as assert } from 'node:assert'
-import { InspectorFilters } from '../types'
+import type { InspectorFilters } from '../types'
 import { matchesFilters, matchesWildcard } from './filter-utils'
 
 describe('matchesFilters', () => {

package/src/utils/filter-utils.ts

@@ -1,5 +1,5 @@
-import { InspectorFilters, InspectorLogger } from '../types.js'
-import { PikkuWiringTypes } from '@pikku/core'
+import type { InspectorFilters, InspectorLogger } from '../types.js'
+import type { PikkuWiringTypes } from '@pikku/core'
 
 /**
  * Match a value against a pattern with wildcard support

package/src/utils/get-files-and-methods.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   PathToNameAndType,
   InspectorState,
   InspectorOptions,

package/src/utils/middleware.ts

@@ -1,7 +1,7 @@
 import * as ts from 'typescript'
-import { MiddlewareMetadata } from '@pikku/core'
+import type { MiddlewareMetadata } from '@pikku/core'
 import { extractFunctionName } from './extract-function-name.js'
-import { InspectorState } from '../types.js'
+import type { InspectorState } from '../types.js'
 
 export interface MiddlewareRef {
   definitionId: string

package/src/utils/permissions.ts

@@ -1,7 +1,7 @@
 import * as ts from 'typescript'
-import { PermissionMetadata } from '@pikku/core'
+import type { PermissionMetadata } from '@pikku/core'
 import { extractFunctionName } from './extract-function-name.js'
-import { InspectorState } from '../types.js'
+import type { InspectorState } from '../types.js'
 
 /**
  * Extract permission pikkuFuncIds from an expression (array or object literal)

package/src/utils/post-process.ts

@@ -1,13 +1,12 @@
-import {
+import type {
   InspectorState,
   InspectorLogger,
   InspectorOptions,
   InspectorModelConfig,
-  ExternalPackageConfig,
   MiddlewareGroupMeta,
   InspectorDiagnostic,
 } from '../types.js'
-import {
+import type {
   FunctionServicesMeta,
   MiddlewareMetadata,
   PermissionMetadata,
@@ -226,22 +225,46 @@ export function aggregateRequiredServices(
 
 export function validateSecretOverrides(
   logger: InspectorLogger,
-  state: InspectorState | Omit<InspectorState, 'typesLookup'>,
-  externalPackages?: Record<string, ExternalPackageConfig>
+  state: InspectorState | Omit<InspectorState, 'typesLookup'>
 ): void {
-  if (!externalPackages) return
+  const { wireAddonDeclarations } = state.rpc
+  if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) return
 
   const secretNames = new Set(state.secrets.definitions.map((d) => d.name))
 
-  for (const [namespace, pkgConfig] of Object.entries(externalPackages)) {
-    if (!pkgConfig.secretOverrides) continue
+  for (const [namespace, addonDecl] of wireAddonDeclarations.entries()) {
+    if (!addonDecl.secretOverrides) continue
 
-    for (const secretKey of Object.keys(pkgConfig.secretOverrides)) {
+    for (const secretKey of Object.keys(addonDecl.secretOverrides)) {
       if (!secretNames.has(secretKey)) {
         const availableSecrets = Array.from(secretNames)
         logger.critical(
           ErrorCode.INVALID_VALUE,
-          `Secret override '${secretKey}' in external package '${namespace}' (${pkgConfig.package}) does not exist. Available secrets: ${availableSecrets.join(', ') || 'none'}`
+          `Secret override '${secretKey}' in addon '${namespace}' (${addonDecl.package}) does not exist. Available secrets: ${availableSecrets.join(', ') || 'none'}`
+        )
+      }
+    }
+  }
+}
+
+export function validateVariableOverrides(
+  logger: InspectorLogger,
+  state: InspectorState | Omit<InspectorState, 'typesLookup'>
+): void {
+  const { wireAddonDeclarations } = state.rpc
+  if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) return
+
+  const variableNames = new Set(state.variables.definitions.map((d) => d.name))
+
+  for (const [namespace, addonDecl] of wireAddonDeclarations.entries()) {
+    if (!addonDecl.variableOverrides) continue
+
+    for (const variableKey of Object.keys(addonDecl.variableOverrides)) {
+      if (!variableNames.has(variableKey)) {
+        const availableVariables = Array.from(variableNames)
+        logger.critical(
+          ErrorCode.INVALID_VALUE,
+          `Variable override '${variableKey}' in addon '${namespace}' (${addonDecl.package}) does not exist. Available variables: ${availableVariables.join(', ') || 'none'}`
         )
       }
     }
@@ -363,7 +386,7 @@ export function computeRequiredSchemas(
 
   state.requiredSchemas = new Set<string>([
     ...Object.values(functions.meta)
-      .map(({ inputs, outputs }) => {
+      .flatMap(({ inputs, outputs }) => {
         const types: (string | undefined)[] = []
         if (inputs?.[0]) {
           try {
@@ -381,7 +404,6 @@ export function computeRequiredSchemas(
         }
         return types
       })
-      .flat()
       .filter((s): s is string => !!s && !PRIMITIVE_TYPES.has(s)),
     ...functions.typesMap.customTypes.keys(),
     ...(schemasFromTypes || []),

package/src/utils/{resolve-external-package.ts → resolve-addon-package.ts}

@@ -1,21 +1,28 @@
 import * as ts from 'typescript'
-import { ExternalPackageConfig } from '../types.js'
 
 /**
- * Resolve the external package name from an imported identifier.
+ * Resolve the addon package name from an imported identifier.
  * Checks if the identifier's import module specifier matches any
- * configured external package.
+ * configured addon package.
  *
  * This is a general utility — any wire handler that processes a `func`
  * property can use it to detect when the function comes from an
- * external package.
+ * addon package.
  */
-export const resolveExternalPackageName = (
+export const resolveAddonName = (
   identifier: ts.Identifier,
   checker: ts.TypeChecker,
-  externalPackages?: Record<string, ExternalPackageConfig>
+  wireAddonDeclarations?: Map<
+    string,
+    {
+      package: string
+      rpcEndpoint?: string
+      secretOverrides?: Record<string, string>
+      variableOverrides?: Record<string, string>
+    }
+  >
 ): string | null => {
-  if (!externalPackages || Object.keys(externalPackages).length === 0) {
+  if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
     return null
   }
 
@@ -32,9 +39,9 @@ export const resolveExternalPackageName = (
 
   const moduleSpecifier = importDecl.moduleSpecifier.text
 
-  for (const config of Object.values(externalPackages)) {
-    if (config.package === moduleSpecifier) {
-      return config.package
+  for (const addonDecl of wireAddonDeclarations.values()) {
+    if (addonDecl.package === moduleSpecifier) {
+      return addonDecl.package
     }
   }
 

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

@@ -22,7 +22,7 @@ function makeState(
       exposedMeta: {},
       exposedFiles: new Map(),
       invokedFunctions: new Set(),
-      usedExternalPackages: new Set(),
+      usedAddons: new Set(),
     },
     serviceAggregation: {
       usedFunctions: new Set(),

package/src/utils/schema-generator.ts

@@ -4,11 +4,11 @@ import { createGenerator, RootlessError } from 'ts-json-schema-generator'
 import { tsImport } from 'tsx/esm/api'
 import * as z from 'zod'
 import { zodToTs, createAuxiliaryTypeStore } from 'zod-to-ts'
-import { FunctionsMeta, JSONValue } from '@pikku/core'
-import { HTTPWiringsMeta } from '@pikku/core/http'
-import { TypesMap } from '../types-map.js'
+import type { FunctionsMeta, JSONValue } from '@pikku/core'
+import type { HTTPWiringsMeta } from '@pikku/core/http'
+import type { TypesMap } from '../types-map.js'
 import { ErrorCode } from '../error-codes.js'
-import { InspectorLogger, InspectorState, SchemaRef } from '../types.js'
+import type { InspectorLogger, InspectorState, SchemaRef } from '../types.js'
 import { generateCustomTypes } from './custom-types-generator.js'
 
 const PRIMITIVE_TYPES = new Set([

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

@@ -1,5 +1,5 @@
-import { JSONValue } from '@pikku/core'
-import { InspectorDiagnostic, InspectorState } from '../types.js'
+import type { JSONValue } from '@pikku/core'
+import type { InspectorDiagnostic, InspectorState } from '../types.js'
 import { TypesMap } from '../types-map.js'
 
 /**
@@ -142,7 +142,19 @@ export interface SerializableInspectorState {
     exposedMeta: InspectorState['rpc']['exposedMeta']
     exposedFiles: Array<[string, { path: string; exportedName: string }]>
     invokedFunctions: string[]
-    usedExternalPackages: string[]
+    usedAddons: string[]
+    wireAddonDeclarations: Array<
+      [
+        string,
+        {
+          package: string
+          rpcEndpoint?: string
+          secretOverrides?: Record<string, string>
+          variableOverrides?: Record<string, string>
+        },
+      ]
+    >
+    wireAddonFiles: string[]
   }
   mcpEndpoints: {
     resourcesMeta: InspectorState['mcpEndpoints']['resourcesMeta']
@@ -329,7 +341,11 @@ export function serializeInspectorState(
       exposedMeta: state.rpc.exposedMeta,
       exposedFiles: Array.from(state.rpc.exposedFiles.entries()),
       invokedFunctions: Array.from(state.rpc.invokedFunctions),
-      usedExternalPackages: Array.from(state.rpc.usedExternalPackages),
+      usedAddons: Array.from(state.rpc.usedAddons),
+      wireAddonDeclarations: Array.from(
+        state.rpc.wireAddonDeclarations.entries()
+      ),
+      wireAddonFiles: Array.from(state.rpc.wireAddonFiles),
     },
     mcpEndpoints: {
       resourcesMeta: state.mcpEndpoints.resourcesMeta,
@@ -489,7 +505,9 @@ export function deserializeInspectorState(
       exposedMeta: data.rpc.exposedMeta,
       exposedFiles: new Map(data.rpc.exposedFiles),
       invokedFunctions: new Set(data.rpc.invokedFunctions),
-      usedExternalPackages: new Set(data.rpc.usedExternalPackages || []),
+      usedAddons: new Set(data.rpc.usedAddons || []),
+      wireAddonDeclarations: new Map(data.rpc.wireAddonDeclarations || []),
+      wireAddonFiles: new Set(data.rpc.wireAddonFiles || []),
     },
     mcpEndpoints: {
       resourcesMeta: data.mcpEndpoints.resourcesMeta,