@pikku/inspector 0.12.75 → 0.12.81

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

@@ -1,742 +0,0 @@
-import type { SecretUsage } from './extract-secret-usage.js'
-import type { JSONValue } from '@pikku/core/utils'
-import type {
-  InspectorDiagnostic,
-  InspectorFeature,
-  InspectorState,
-} from '../types.js'
-import { TypesMap } from '../types-map.js'
-
-/**
- * Serializable version of InspectorState that can be saved to JSON
- * Omits typesLookup (contains non-serializable ts.Type objects) and converts Maps/Sets to arrays
- */
-export interface SerializableInspectorState {
-  rootDir: string
-  singletonServicesTypeImportMap: Array<
-    [
-      string,
-      { variable: string; type: string | null; typePath: string | null }[],
-    ]
-  >
-  wireServicesTypeImportMap: Array<
-    [
-      string,
-      { variable: string; type: string | null; typePath: string | null }[],
-    ]
-  >
-  userSessionTypeImportMap: Array<
-    [
-      string,
-      { variable: string; type: string | null; typePath: string | null }[],
-    ]
-  >
-  configTypeImportMap: Array<
-    [
-      string,
-      { variable: string; type: string | null; typePath: string | null }[],
-    ]
-  >
-  singletonServicesFactories: Array<
-    [
-      string,
-      { variable: string; type: string | null; typePath: string | null }[],
-    ]
-  >
-  wireServicesFactories: Array<
-    [
-      string,
-      { variable: string; type: string | null; typePath: string | null }[],
-    ]
-  >
-  wireServicesMeta: Array<[string, string[]]>
-  addonRequiredParentServices: string[]
-  addonCreatedServices: string[]
-  addonServicesFactorySeen: boolean
-  addonServerlessIncompatible: Array<[string, string[]]>
-  configFactories: Array<
-    [
-      string,
-      { variable: string; type: string | null; typePath: string | null }[],
-    ]
-  >
-  serverLifecycleFactories: Array<
-    [
-      string,
-      { variable: string; type: string | null; typePath: string | null }[],
-    ]
-  >
-  filesAndMethods: InspectorState['filesAndMethods']
-  filesAndMethodsErrors: Array<
-    [
-      string,
-      Array<
-        [
-          string,
-          { variable: string; type: string | null; typePath: string | null }[],
-        ]
-      >,
-    ]
-  >
-  schemaLookup: Array<
-    [
-      string,
-      {
-        variableName: string
-        sourceFile: string
-        vendor?: 'zod' | 'valibot' | 'arktype' | 'effect' | 'unknown'
-      },
-    ]
-  >
-  schemas: Record<string, JSONValue>
-  functions: {
-    typesMap: {
-      map: Array<[string, { originalName: string; path: string | null }]>
-      customTypes: Array<[string, { type: string; references: string[] }]>
-    }
-    meta: InspectorState['functions']['meta']
-    files: Array<[string, { path: string; exportedName: string }]>
-    approvalDescriptions: InspectorState['functions']['approvalDescriptions']
-  }
-  http: {
-    metaInputTypes: Array<
-      [
-        string,
-        {
-          query: string[] | undefined
-          params: string[] | undefined
-          body: string[] | undefined
-        },
-      ]
-    >
-    meta: InspectorState['http']['meta']
-    files: string[]
-    routeMiddleware: Array<
-      [
-        string,
-        InspectorState['http']['routeMiddleware'] extends Map<string, infer V>
-          ? V
-          : never,
-      ]
-    >
-  }
-  channels: {
-    files: string[]
-    meta: InspectorState['channels']['meta']
-  }
-  gateways: {
-    meta: InspectorState['gateways']['meta']
-    files: string[]
-  }
-  triggers: {
-    meta: InspectorState['triggers']['meta']
-    sourceMeta: InspectorState['triggers']['sourceMeta']
-    files: string[]
-  }
-  scheduledTasks: {
-    meta: InspectorState['scheduledTasks']['meta']
-    files: string[]
-  }
-  queueWorkers: {
-    meta: InspectorState['queueWorkers']['meta']
-    files: string[]
-  }
-  workflows: {
-    meta: InspectorState['workflows']['meta']
-    files: Array<[string, { path: string; exportedName: string }]>
-    graphMeta: InspectorState['workflows']['graphMeta']
-    graphFiles: Array<[string, { path: string; exportedName: string }]>
-    featureFiles: Array<[string, InspectorFeature]>
-    invokedWorkflows: string[]
-  }
-  rpc: {
-    internalMeta: InspectorState['rpc']['internalMeta']
-    internalFiles: Array<[string, { path: string; exportedName: string }]>
-    exposedMeta: InspectorState['rpc']['exposedMeta']
-    exposedFiles: Array<[string, { path: string; exportedName: string }]>
-    remoteMeta: InspectorState['rpc']['remoteMeta']
-    remoteFiles: Array<[string, { path: string; exportedName: string }]>
-    invokedFunctions: string[]
-    invokedFunctionsByFile?: Array<[string, string[]]>
-    usedAddons: string[]
-    wireAddonDeclarations: Array<
-      [
-        string,
-        {
-          package: string
-          rpcEndpoint?: string
-          remote?: boolean
-          hasAuth?: boolean
-          authCredentialId?: string
-          authSecretId?: string
-          secretOverrides?: Record<string, string>
-          variableOverrides?: Record<string, string>
-          credentialOverrides?: Record<string, string>
-          secretGrants?: string[]
-          credentialGrants?: string[]
-          globalSecrets?: string
-          globalCredentials?: string
-        },
-      ]
-    >
-    wireAddonFiles: string[]
-  }
-  mcpEndpoints: {
-    resourcesMeta: InspectorState['mcpEndpoints']['resourcesMeta']
-    toolsMeta: InspectorState['mcpEndpoints']['toolsMeta']
-    promptsMeta: InspectorState['mcpEndpoints']['promptsMeta']
-    files: string[]
-  }
-  agents: {
-    invokedAgentsByFile?: Array<[string, string[]]>
-    agentsMeta: InspectorState['agents']['agentsMeta']
-    files: [string, { path: string; exportedName: string }][]
-  }
-  scorers: {
-    scorersMeta: InspectorState['scorers']['scorersMeta']
-    files: [string, { path: string; exportedName: string }][]
-  }
-  cli: {
-    meta: InspectorState['cli']['meta']
-    files: string[]
-  }
-  nodes: {
-    meta: InspectorState['nodes']['meta']
-    files: string[]
-  }
-  auth: {
-    providers: string[]
-    plugins: string[]
-    files: string[]
-    definition: InspectorState['auth']['definition']
-  }
-  secrets: {
-    definitions: InspectorState['secrets']['definitions']
-    files: string[]
-    usage: Record<string, SecretUsage>
-  }
-  surfaceUsage: InspectorState['surfaceUsage']
-  credentials: {
-    definitions: InspectorState['credentials']['definitions']
-    files: string[]
-  }
-  scopes: {
-    definitions: InspectorState['scopes']['definitions']
-    files: string[]
-  }
-  systemRoles: {
-    definitions: InspectorState['systemRoles']['definitions']
-    files: string[]
-  }
-  personas: {
-    definitions: InspectorState['personas']['definitions']
-    files: string[]
-  }
-  variables: {
-    definitions: InspectorState['variables']['definitions']
-    files: string[]
-  }
-  manifest: InspectorState['manifest']
-  middleware: {
-    definitions: InspectorState['middleware']['definitions']
-    instances: InspectorState['middleware']['instances']
-    tagMiddleware: Array<
-      [
-        string,
-        InspectorState['middleware']['tagMiddleware'] extends Map<
-          string,
-          infer V
-        >
-          ? V
-          : never,
-      ]
-    >
-  }
-  channelMiddleware: {
-    definitions: InspectorState['channelMiddleware']['definitions']
-    instances: InspectorState['channelMiddleware']['instances']
-    tagMiddleware: Array<
-      [
-        string,
-        InspectorState['channelMiddleware']['tagMiddleware'] extends Map<
-          string,
-          infer V
-        >
-          ? V
-          : never,
-      ]
-    >
-  }
-  agentMiddleware: {
-    definitions: InspectorState['agentMiddleware']['definitions']
-  }
-  permissions: {
-    definitions: InspectorState['permissions']['definitions']
-    instances: InspectorState['permissions']['instances']
-  }
-  serviceAggregation: {
-    requiredServices: string[]
-    usedFunctions: string[]
-    usedMiddleware: string[]
-    usedPermissions: string[]
-    allSingletonServices: string[]
-    allWireServices: string[]
-  }
-  resolvedIOTypes: Record<string, { inputType: string; outputType: string }>
-  middlewareGroupsMeta: InspectorState['middlewareGroupsMeta']
-  permissionsGroupsMeta: InspectorState['permissionsGroupsMeta']
-  requiredSchemas: string[]
-  openAPISpec: Record<string, any> | null
-  diagnostics: InspectorDiagnostic[]
-  addonFunctions: InspectorState['addonFunctions']
-  exportedContracts: InspectorState['exportedContracts']
-}
-
-/**
- * Serializes InspectorState to a JSON-compatible format
- * Omits typesLookup (not needed for filtering/generation) and converts Maps/Sets to arrays
- */
-export function serializeInspectorState(
-  state: InspectorState
-): SerializableInspectorState {
-  // Helper to serialize TypesMap
-  const serializeTypesMap = (
-    typesMap: TypesMap
-  ): {
-    map: Array<[string, { originalName: string; path: string | null }]>
-    customTypes: Array<[string, { type: string; references: string[] }]>
-  } => {
-    // Access private map via type assertion
-    const mapEntries: Array<
-      [string, { originalName: string; path: string | null }]
-    > = Array.from((typesMap as any).map.entries())
-    const customTypesEntries: Array<
-      [string, { type: string; references: string[] }]
-    > = Array.from(typesMap.customTypes.entries())
-
-    return {
-      map: mapEntries,
-      customTypes: customTypesEntries,
-    }
-  }
-
-  return {
-    rootDir: state.rootDir,
-    singletonServicesTypeImportMap: Array.from(
-      state.singletonServicesTypeImportMap.entries()
-    ),
-    wireServicesTypeImportMap: Array.from(
-      state.wireServicesTypeImportMap.entries()
-    ),
-    userSessionTypeImportMap: Array.from(
-      state.userSessionTypeImportMap.entries()
-    ),
-    configTypeImportMap: Array.from(state.configTypeImportMap.entries()),
-    singletonServicesFactories: Array.from(
-      state.singletonServicesFactories.entries()
-    ),
-    wireServicesFactories: Array.from(state.wireServicesFactories.entries()),
-    wireServicesMeta: Array.from(state.wireServicesMeta.entries()),
-    addonRequiredParentServices: state.addonRequiredParentServices,
-    addonCreatedServices: state.addonCreatedServices,
-    addonServicesFactorySeen: state.addonServicesFactorySeen,
-    addonServerlessIncompatible: Array.from(
-      state.addonServerlessIncompatible.entries()
-    ),
-    configFactories: Array.from(state.configFactories.entries()),
-    serverLifecycleFactories: Array.from(
-      state.serverLifecycleFactories.entries()
-    ),
-    filesAndMethods: state.filesAndMethods,
-    filesAndMethodsErrors: Array.from(
-      state.filesAndMethodsErrors.entries()
-    ).map(([key, mapValue]) => [key, Array.from(mapValue.entries())] as const),
-    schemaLookup: Array.from(state.schemaLookup.entries()),
-    schemas: state.schemas,
-    functions: {
-      typesMap: serializeTypesMap(state.functions.typesMap),
-      meta: state.functions.meta,
-      files: Array.from(state.functions.files.entries()),
-      approvalDescriptions: state.functions.approvalDescriptions,
-    },
-    http: {
-      metaInputTypes: Array.from(state.http.metaInputTypes.entries()),
-      meta: state.http.meta,
-      files: Array.from(state.http.files),
-      routeMiddleware: Array.from(state.http.routeMiddleware.entries()),
-    },
-    channels: {
-      files: Array.from(state.channels.files),
-      meta: state.channels.meta,
-    },
-    gateways: {
-      meta: state.gateways.meta,
-      files: Array.from(state.gateways.files),
-    },
-    triggers: {
-      meta: state.triggers.meta,
-      sourceMeta: state.triggers.sourceMeta,
-      files: Array.from(state.triggers.files),
-    },
-    scheduledTasks: {
-      meta: state.scheduledTasks.meta,
-      files: Array.from(state.scheduledTasks.files),
-    },
-    queueWorkers: {
-      meta: state.queueWorkers.meta,
-      files: Array.from(state.queueWorkers.files),
-    },
-    workflows: {
-      meta: state.workflows.meta,
-      files: Array.from(state.workflows.files.entries()),
-      graphMeta: state.workflows.graphMeta,
-      graphFiles: Array.from(state.workflows.graphFiles.entries()),
-      featureFiles: Array.from(state.workflows.featureFiles.entries()),
-      invokedWorkflows: Array.from(state.workflows.invokedWorkflows),
-    },
-    rpc: {
-      internalMeta: state.rpc.internalMeta,
-      internalFiles: Array.from(state.rpc.internalFiles.entries()),
-      exposedMeta: state.rpc.exposedMeta,
-      exposedFiles: Array.from(state.rpc.exposedFiles.entries()),
-      remoteMeta: state.rpc.remoteMeta,
-      remoteFiles: Array.from(state.rpc.remoteFiles.entries()),
-      invokedFunctions: Array.from(state.rpc.invokedFunctions),
-      invokedFunctionsByFile: Array.from(
-        (
-          state.rpc.invokedFunctionsByFile ?? new Map<string, Set<string>>()
-        ).entries()
-      ).map(([file, fns]): [string, string[]] => [file, Array.from(fns)]),
-      usedAddons: Array.from(state.rpc.usedAddons),
-      wireAddonDeclarations: Array.from(
-        state.rpc.wireAddonDeclarations.entries()
-      ),
-      wireAddonFiles: Array.from(state.rpc.wireAddonFiles),
-    },
-    mcpEndpoints: {
-      resourcesMeta: state.mcpEndpoints.resourcesMeta,
-      toolsMeta: state.mcpEndpoints.toolsMeta,
-      promptsMeta: state.mcpEndpoints.promptsMeta,
-      files: Array.from(state.mcpEndpoints.files),
-    },
-    agents: {
-      agentsMeta: state.agents?.agentsMeta ?? {},
-      files: Array.from(state.agents?.files?.entries() ?? []),
-      invokedAgentsByFile: Array.from(
-        (
-          state.agents?.invokedAgentsByFile ?? new Map<string, Set<string>>()
-        ).entries()
-      ).map(([file, agents]): [string, string[]] => [file, Array.from(agents)]),
-    },
-    scorers: {
-      scorersMeta: state.scorers?.scorersMeta ?? {},
-      files: Array.from(state.scorers?.files?.entries() ?? []),
-    },
-    cli: {
-      meta: state.cli.meta,
-      files: Array.from(state.cli.files),
-    },
-    nodes: {
-      meta: state.nodes.meta,
-      files: Array.from(state.nodes.files),
-    },
-    auth: {
-      providers: state.auth.providers,
-      plugins: state.auth.plugins,
-      files: Array.from(state.auth.files),
-      definition: state.auth.definition,
-    },
-    secrets: {
-      definitions: state.secrets.definitions,
-      files: Array.from(state.secrets.files),
-      usage: Object.fromEntries(state.secrets.usage),
-    },
-    surfaceUsage: state.surfaceUsage,
-    credentials: {
-      definitions: state.credentials.definitions,
-      files: Array.from(state.credentials.files),
-    },
-    scopes: {
-      definitions: state.scopes.definitions,
-      files: Array.from(state.scopes.files),
-    },
-    systemRoles: {
-      definitions: state.systemRoles.definitions,
-      files: Array.from(state.systemRoles.files),
-    },
-    personas: {
-      definitions: state.personas.definitions,
-      files: Array.from(state.personas.files),
-    },
-    variables: {
-      definitions: state.variables.definitions,
-      files: Array.from(state.variables.files),
-    },
-    manifest: state.manifest,
-    middleware: {
-      definitions: state.middleware.definitions,
-      instances: state.middleware.instances,
-      tagMiddleware: Array.from(state.middleware.tagMiddleware.entries()),
-    },
-    channelMiddleware: {
-      definitions: state.channelMiddleware.definitions,
-      instances: state.channelMiddleware.instances,
-      tagMiddleware: Array.from(
-        state.channelMiddleware.tagMiddleware.entries()
-      ),
-    },
-    agentMiddleware: {
-      definitions: state.agentMiddleware.definitions,
-    },
-    permissions: {
-      definitions: state.permissions.definitions,
-      instances: state.permissions.instances,
-    },
-    serviceAggregation: {
-      requiredServices: Array.from(state.serviceAggregation.requiredServices),
-      usedFunctions: Array.from(state.serviceAggregation.usedFunctions),
-      usedMiddleware: Array.from(state.serviceAggregation.usedMiddleware),
-      usedPermissions: Array.from(state.serviceAggregation.usedPermissions),
-      allSingletonServices: state.serviceAggregation.allSingletonServices,
-      allWireServices: state.serviceAggregation.allWireServices,
-    },
-    resolvedIOTypes: state.resolvedIOTypes,
-    middlewareGroupsMeta: state.middlewareGroupsMeta,
-    permissionsGroupsMeta: state.permissionsGroupsMeta,
-    requiredSchemas: Array.from(state.requiredSchemas),
-    openAPISpec: state.openAPISpec,
-    diagnostics: state.diagnostics,
-    addonFunctions: state.addonFunctions,
-    exportedContracts: state.exportedContracts,
-  }
-}
-
-/**
- * Deserializes JSON data back to InspectorState
- * Creates a partial state suitable for filtering/generation (without typesLookup)
- */
-export function deserializeInspectorState(
-  data: SerializableInspectorState
-): Omit<InspectorState, 'typesLookup' | 'schemaLookup'> & {
-  schemaLookup: Map<
-    string,
-    {
-      variableName: string
-      sourceFile: string
-      vendor?: 'zod' | 'valibot' | 'arktype' | 'effect' | 'unknown'
-    }
-  >
-} {
-  // Helper to deserialize TypesMap
-  const deserializeTypesMap = (
-    serialized: SerializableInspectorState['functions']['typesMap']
-  ): TypesMap => {
-    const typesMap = new TypesMap()
-
-    // Restore private map
-    ;(typesMap as any).map = new Map(serialized.map)
-
-    // Restore public customTypes
-    typesMap.customTypes = new Map(serialized.customTypes)
-
-    return typesMap
-  }
-
-  return {
-    rootDir: data.rootDir,
-    singletonServicesTypeImportMap: new Map(
-      data.singletonServicesTypeImportMap
-    ),
-    wireServicesTypeImportMap: new Map(data.wireServicesTypeImportMap),
-    userSessionTypeImportMap: new Map(data.userSessionTypeImportMap),
-    configTypeImportMap: new Map(data.configTypeImportMap),
-    singletonServicesFactories: new Map(data.singletonServicesFactories),
-    wireServicesFactories: new Map(data.wireServicesFactories),
-    wireServicesMeta: new Map(data.wireServicesMeta),
-    addonRequiredParentServices: data.addonRequiredParentServices || [],
-    addonCreatedServices: data.addonCreatedServices || [],
-    addonServicesFactorySeen: data.addonServicesFactorySeen ?? false,
-    addonServerlessIncompatible: new Map(
-      data.addonServerlessIncompatible || []
-    ),
-    configFactories: new Map(data.configFactories),
-    serverLifecycleFactories: new Map(data.serverLifecycleFactories),
-    filesAndMethods: data.filesAndMethods,
-    filesAndMethodsErrors: new Map(
-      data.filesAndMethodsErrors.map(([key, entries]) => [
-        key,
-        new Map(entries),
-      ])
-    ),
-    schemaLookup: new Map(data.schemaLookup || []),
-    schemas: data.schemas || {},
-    functions: {
-      typesMap: deserializeTypesMap(data.functions.typesMap),
-      meta: data.functions.meta,
-      files: new Map(data.functions.files),
-      approvalDescriptions: (data.functions as any).approvalDescriptions || {},
-      dynamicImportIds: new Set(),
-    },
-    http: {
-      metaInputTypes: new Map(data.http.metaInputTypes),
-      meta: data.http.meta,
-      files: new Set(data.http.files),
-      routeMiddleware: new Map(data.http.routeMiddleware),
-    },
-    channels: {
-      files: new Set(data.channels.files),
-      meta: data.channels.meta,
-    },
-    gateways: {
-      meta: data.gateways?.meta ?? {},
-      files: new Set(data.gateways?.files ?? []),
-    },
-    triggers: {
-      meta: data.triggers?.meta ?? {},
-      sourceMeta: data.triggers?.sourceMeta ?? {},
-      files: new Set(data.triggers?.files ?? []),
-    },
-    scheduledTasks: {
-      meta: data.scheduledTasks.meta,
-      files: new Set(data.scheduledTasks.files),
-    },
-    queueWorkers: {
-      meta: data.queueWorkers.meta,
-      files: new Set(data.queueWorkers.files),
-    },
-    workflows: {
-      meta: data.workflows.meta,
-      files: new Map(data.workflows.files),
-      graphMeta: data.workflows.graphMeta || {},
-      graphFiles: new Map(data.workflows.graphFiles || []),
-      featureFiles: new Map(data.workflows.featureFiles || []),
-      invokedWorkflows: new Set(data.workflows.invokedWorkflows || []),
-    },
-    rpc: {
-      internalMeta: data.rpc.internalMeta,
-      internalFiles: new Map(data.rpc.internalFiles),
-      exposedMeta: data.rpc.exposedMeta,
-      exposedFiles: new Map(data.rpc.exposedFiles),
-      remoteMeta: data.rpc.remoteMeta ?? {},
-      remoteFiles: new Map(data.rpc.remoteFiles ?? []),
-      invokedFunctions: new Set(data.rpc.invokedFunctions),
-      invokedFunctionsByFile: new Map(
-        (data.rpc.invokedFunctionsByFile || []).map(
-          ([file, fns]): [string, Set<string>] => [file, new Set(fns)]
-        )
-      ),
-      usedAddons: new Set(data.rpc.usedAddons || []),
-      wireAddonDeclarations: new Map(data.rpc.wireAddonDeclarations || []),
-      wireAddonFiles: new Set(data.rpc.wireAddonFiles || []),
-    },
-    mcpEndpoints: {
-      resourcesMeta: data.mcpEndpoints.resourcesMeta,
-      toolsMeta: data.mcpEndpoints.toolsMeta,
-      promptsMeta: data.mcpEndpoints.promptsMeta,
-      files: new Set(data.mcpEndpoints.files),
-    },
-    agents: {
-      agentsMeta: data.agents?.agentsMeta || {},
-      files: new Map(data.agents?.files || []),
-      invokedAgentsByFile: new Map(
-        (data.agents?.invokedAgentsByFile || []).map(
-          ([file, agents]): [string, Set<string>] => [file, new Set(agents)]
-        )
-      ),
-    },
-    scorers: {
-      scorersMeta: data.scorers?.scorersMeta || {},
-      files: new Map(data.scorers?.files || []),
-    },
-    cli: {
-      meta: data.cli.meta,
-      files: new Set(data.cli.files),
-    },
-    nodes: {
-      meta: data.nodes?.meta || {},
-      files: new Set(data.nodes?.files || []),
-    },
-    auth: {
-      providers: data.auth?.providers || [],
-      plugins: data.auth?.plugins || [],
-      files: new Set(data.auth?.files || []),
-      definition: data.auth?.definition || null,
-    },
-    secrets: {
-      definitions: data.secrets?.definitions || [],
-      files: new Set(data.secrets?.files || []),
-      usage: new Map(Object.entries(data.secrets?.usage || {})),
-    },
-    surfaceUsage: data.surfaceUsage || {},
-    credentials: {
-      definitions: data.credentials?.definitions || [],
-      files: new Set(data.credentials?.files || []),
-    },
-    scopes: {
-      definitions: data.scopes?.definitions || [],
-      files: new Set(data.scopes?.files || []),
-    },
-    systemRoles: {
-      definitions: data.systemRoles?.definitions || [],
-      files: new Set(data.systemRoles?.files || []),
-    },
-    personas: {
-      definitions: data.personas?.definitions || [],
-      files: new Set(data.personas?.files || []),
-    },
-    variables: {
-      definitions: data.variables?.definitions || [],
-      files: new Set(data.variables?.files || []),
-    },
-    manifest: data.manifest || { initial: null, current: null, errors: [] },
-    middleware: {
-      definitions: data.middleware.definitions,
-      instances: data.middleware.instances || {},
-      tagMiddleware: new Map(data.middleware.tagMiddleware),
-    },
-    channelMiddleware: {
-      definitions: data.channelMiddleware?.definitions || {},
-      instances: data.channelMiddleware?.instances || {},
-      tagMiddleware: new Map(data.channelMiddleware?.tagMiddleware || []),
-    },
-    agentMiddleware: {
-      definitions: data.agentMiddleware?.definitions || {},
-    },
-    permissions: {
-      definitions: data.permissions.definitions,
-      instances: data.permissions.instances || {},
-    },
-    serviceAggregation: {
-      requiredServices: new Set(data.serviceAggregation.requiredServices),
-      usedFunctions: new Set(data.serviceAggregation.usedFunctions),
-      usedMiddleware: new Set(data.serviceAggregation.usedMiddleware),
-      usedPermissions: new Set(data.serviceAggregation.usedPermissions),
-      allSingletonServices: data.serviceAggregation.allSingletonServices,
-      allWireServices: data.serviceAggregation.allWireServices,
-    },
-    resolvedIOTypes: data.resolvedIOTypes || {},
-    middlewareGroupsMeta: data.middlewareGroupsMeta || {
-      definitions: {},
-      instances: {},
-      httpGroups: {},
-      tagGroups: {},
-      channelMiddleware: { definitions: {}, instances: {}, tagGroups: {} },
-    },
-    permissionsGroupsMeta: data.permissionsGroupsMeta || {
-      definitions: {},
-    },
-    requiredSchemas: new Set(data.requiredSchemas || []),
-    openAPISpec: data.openAPISpec || null,
-    diagnostics: data.diagnostics || [],
-    addonFunctions: data.addonFunctions || {},
-    exportedContracts: data.exportedContracts || {
-      http: {},
-      cli: {},
-      channel: {},
-      addonHttp: {},
-      addonCli: {},
-      addonChannel: {},
-    },
-    program: null,
-  }
-}