@pikku/inspector 0.10.2 → 0.11.1

package/dist/utils/extract-service-metadata.js

@@ -0,0 +1,244 @@
+import * as ts from 'typescript';
+import * as path from 'path';
+import * as fs from 'fs';
+/**
+ * Extract JSDoc comment information from a TypeScript node
+ */
+function extractJSDoc(node) {
+    const jsDocTags = ts.getJSDocTags(node);
+    const jsDocComments = ts.getJSDocCommentsAndTags(node);
+    let summary = '';
+    let description = '';
+    const summaryTag = jsDocTags.find((tag) => tag.tagName.text === 'summary');
+    if (summaryTag && summaryTag.comment) {
+        summary =
+            typeof summaryTag.comment === 'string'
+                ? summaryTag.comment
+                : summaryTag.comment.map((c) => c.text).join('');
+    }
+    for (const comment of jsDocComments) {
+        if (ts.isJSDoc(comment) && comment.comment) {
+            const commentText = typeof comment.comment === 'string'
+                ? comment.comment
+                : comment.comment.map((c) => c.text).join('');
+            if (!summary && commentText) {
+                const lines = commentText
+                    .split('\n')
+                    .map((l) => l.trim())
+                    .filter(Boolean);
+                if (lines.length > 0) {
+                    summary = lines[0];
+                    if (lines.length > 1) {
+                        description = lines.slice(1).join('\n').trim();
+                    }
+                }
+            }
+            else {
+                description = commentText;
+            }
+            break;
+        }
+    }
+    return { summary, description };
+}
+/**
+ * Serialize a TypeScript type to a string representation
+ */
+function serializeTypeToString(node, sourceFile, checker) {
+    const nodeSourceFile = node.getSourceFile();
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+        return node.getText(nodeSourceFile);
+    }
+    if (ts.isClassDeclaration(node)) {
+        return serializePublicClassMembers(node, nodeSourceFile, checker);
+    }
+    const type = checker.getTypeAtLocation(node);
+    return checker.typeToString(type, node, ts.TypeFormatFlags.NoTruncation);
+}
+/**
+ * Extract public members from a class and serialize them
+ */
+function serializePublicClassMembers(classNode, sourceFile, checker) {
+    const className = classNode.name?.text || 'UnnamedClass';
+    const publicMembers = [];
+    for (const member of classNode.members) {
+        const modifiers = ts.canHaveModifiers(member)
+            ? ts.getModifiers(member)
+            : undefined;
+        const isPublic = !modifiers?.some((mod) => mod.kind === ts.SyntaxKind.PrivateKeyword ||
+            mod.kind === ts.SyntaxKind.ProtectedKeyword);
+        if (!isPublic)
+            continue;
+        if (ts.isMethodDeclaration(member) ||
+            ts.isPropertyDeclaration(member) ||
+            ts.isConstructorDeclaration(member)) {
+            const memberSignature = getMemberSignature(member, sourceFile, checker);
+            if (memberSignature) {
+                publicMembers.push(memberSignature);
+            }
+        }
+    }
+    return `class ${className} {\n  ${publicMembers.join('\n  ')}\n}`;
+}
+/**
+ * Extract a clean signature for a class member (without implementation)
+ */
+function getMemberSignature(member, sourceFile, checker) {
+    if (ts.isPropertyDeclaration(member)) {
+        const name = member.name.getText(sourceFile);
+        const type = member.type ? member.type.getText(sourceFile) : 'any';
+        const optional = member.questionToken ? '?' : '';
+        return `${name}${optional}: ${type};`;
+    }
+    if (ts.isMethodDeclaration(member)) {
+        const name = member.name.getText(sourceFile);
+        const typeParams = member.typeParameters
+            ? `<${member.typeParameters.map((tp) => tp.getText(sourceFile)).join(', ')}>`
+            : '';
+        const params = member.parameters
+            .map((p) => p.getText(sourceFile))
+            .join(', ');
+        const returnType = member.type ? member.type.getText(sourceFile) : 'void';
+        const optional = member.questionToken ? '?' : '';
+        return `${name}${optional}${typeParams}(${params}): ${returnType};`;
+    }
+    if (ts.isConstructorDeclaration(member)) {
+        const params = member.parameters
+            .map((p) => p.getText(sourceFile))
+            .join(', ');
+        return `constructor(${params});`;
+    }
+    return null;
+}
+/**
+ * Find the nearest package.json and extract package name and version
+ */
+function getPackageInfo(filePath) {
+    let currentDir = path.dirname(filePath);
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+                return {
+                    packageName: packageJson.name || 'unknown',
+                    version: packageJson.version || '0.0.0',
+                };
+            }
+            catch (err) {
+                // If we can't parse the package.json, continue searching
+            }
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return { packageName: 'unknown', version: '0.0.0' };
+}
+/**
+ * Expand a type to show all its properties including inherited ones
+ * Returns a Record mapping property names to their type strings
+ */
+function expandInterfaceProperties(type, checker, maxDepth = 2, currentDepth = 0, visited = new Set()) {
+    const result = {};
+    if (visited.has(type) || currentDepth >= maxDepth) {
+        return result;
+    }
+    visited.add(type);
+    const properties = type.getProperties();
+    for (const prop of properties) {
+        const propName = prop.getName();
+        const propDecl = prop.valueDeclaration || prop.declarations?.[0];
+        if (!propDecl)
+            continue;
+        try {
+            const propType = checker.getTypeOfSymbolAtLocation(prop, propDecl);
+            const isOptional = !!(prop.flags & ts.SymbolFlags.Optional);
+            let typeString = checker.typeToString(propType, propDecl, ts.TypeFormatFlags.NoTruncation |
+                ts.TypeFormatFlags.UseFullyQualifiedType);
+            if (isOptional && !typeString.includes('undefined')) {
+                typeString = `${typeString} | undefined`;
+            }
+            result[propName] = typeString;
+        }
+        catch (err) {
+            result[propName] = 'any';
+        }
+    }
+    return result;
+}
+/**
+ * Extract metadata for a service from its TypeScript declaration
+ */
+export function extractServiceMetadata(serviceName, type, checker, rootDir) {
+    const property = type.getProperty(serviceName);
+    if (!property) {
+        return null;
+    }
+    const declaration = property.valueDeclaration || property.declarations?.[0];
+    if (!declaration) {
+        return null;
+    }
+    const sourceFile = declaration.getSourceFile();
+    const filePath = sourceFile.fileName;
+    const serviceType = checker.getTypeOfSymbolAtLocation(property, declaration);
+    let typeDeclaration = null;
+    if (serviceType.symbol) {
+        const typeDecl = serviceType.symbol.valueDeclaration ||
+            serviceType.symbol.declarations?.[0];
+        if (typeDecl &&
+            (ts.isInterfaceDeclaration(typeDecl) ||
+                ts.isClassDeclaration(typeDecl) ||
+                ts.isTypeAliasDeclaration(typeDecl))) {
+            typeDeclaration = typeDecl;
+        }
+    }
+    let summary = '';
+    let description = '';
+    if (typeDeclaration) {
+        const jsDoc = extractJSDoc(typeDeclaration);
+        summary = jsDoc.summary;
+        description = jsDoc.description;
+    }
+    else if (ts.isPropertySignature(declaration) ||
+        ts.isPropertyDeclaration(declaration)) {
+        const jsDoc = extractJSDoc(declaration);
+        summary = jsDoc.summary;
+        description = jsDoc.description;
+    }
+    let interfaceString = '';
+    if (typeDeclaration) {
+        interfaceString = serializeTypeToString(typeDeclaration, sourceFile, checker);
+    }
+    else {
+        interfaceString = checker.typeToString(serviceType, declaration, ts.TypeFormatFlags.NoTruncation);
+    }
+    const { packageName, version } = getPackageInfo(filePath);
+    const relativePath = path.relative(rootDir, filePath);
+    const expandedProperties = expandInterfaceProperties(serviceType, checker);
+    return {
+        name: serviceName,
+        summary,
+        description,
+        package: packageName,
+        path: relativePath,
+        version,
+        interface: interfaceString,
+        expandedProperties,
+    };
+}
+/**
+ * Extract metadata for all services in a type
+ */
+export function extractAllServiceMetadata(servicesType, checker, rootDir) {
+    const metadata = [];
+    const serviceNames = servicesType
+        .getProperties()
+        .map((prop) => prop.getName());
+    for (const serviceName of serviceNames) {
+        const serviceMeta = extractServiceMetadata(serviceName, servicesType, checker, rootDir);
+        if (serviceMeta) {
+            metadata.push(serviceMeta);
+        }
+    }
+    return metadata;
+}

package/dist/utils/get-files-and-methods.d.ts

@@ -7,15 +7,15 @@ interface Meta {
 }
 export type FilesAndMethods = {
     userSessionType: Meta;
-    sessionServicesType: Meta;
+    wireServicesType: Meta;
     singletonServicesType: Meta;
     pikkuConfigType: Meta;
     pikkuConfigFactory: Meta;
     singletonServicesFactory: Meta;
-    sessionServicesFactory: Meta;
+    wireServicesFactory: Meta;
 };
 export type FilesAndMethodsErrors = Map<string, PathToNameAndType>;
-export declare const getFilesAndMethods: ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, }?: InspectorOptions["types"]) => {
+export declare const getFilesAndMethods: ({ singletonServicesTypeImportMap, wireServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, wireServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, { configFileType, userSessionType, singletonServicesFactoryType, wireServicesFactoryType, }?: InspectorOptions["types"]) => {
     result: Partial<FilesAndMethods>;
     errors: FilesAndMethodsErrors;
 };

package/dist/utils/get-files-and-methods.js

@@ -46,16 +46,16 @@ const getMetaTypes = (type, map, desiredType, errors) => {
     }
     return;
 };
-export const getFilesAndMethods = ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, } = {}) => {
+export const getFilesAndMethods = ({ singletonServicesTypeImportMap, wireServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, wireServicesFactories, singletonServicesFactories, configFactories, }, { configFileType, userSessionType, singletonServicesFactoryType, wireServicesFactoryType, } = {}) => {
     const errors = new Map();
     const result = {
         userSessionType: getMetaTypes('CoreUserSession', userSessionTypeImportMap, userSessionType, errors),
         singletonServicesType: getMetaTypes('CoreSingletonServices', singletonServicesTypeImportMap, undefined, errors),
-        sessionServicesType: getMetaTypes('CoreServices', sessionServicesTypeImportMap, undefined, errors),
+        wireServicesType: getMetaTypes('CoreServices', wireServicesTypeImportMap, undefined, errors),
         pikkuConfigType: getMetaTypes('CoreConfig', configTypeImportMap, undefined, errors),
         pikkuConfigFactory: getMetaTypes('CoreConfig', configFactories, configFileType, errors),
         singletonServicesFactory: getMetaTypes('CreateSingletonServices', singletonServicesFactories, singletonServicesFactoryType, errors),
-        sessionServicesFactory: getMetaTypes('CreateSessionServices', sessionServicesFactories, sessionServicesFactoryType, errors),
+        wireServicesFactory: getMetaTypes('CreateWireServices', wireServicesFactories, wireServicesFactoryType, errors),
     };
     return { result, errors };
 };

package/dist/utils/get-property-value.d.ts

@@ -1,12 +1,19 @@
-import { PikkuDocs } from '@pikku/core';
 import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
-export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string | string[] | null | PikkuDocs | boolean;
+export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string | string[] | null | boolean;
 /**
- * Gets the 'tags' property from an object and validates it's an array.
- * Logs a critical error if tags is not an array but still returns the value.
+ * Extracts common wire metadata (tags, summary, description, errors) directly from an object
+ * @param obj - The TypeScript object literal expression to extract metadata from
+ * @param wiringType - The type of wiring (e.g., 'HTTP route', 'Channel', 'Queue worker')
+ * @param wiringName - The name/identifier of the wiring (e.g., route path, channel name)
  * @param logger - Optional logger instance; if not provided, uses console.error
+ * @returns Object containing the common wire metadata fields
  */
-export declare const getPropertyTags: (obj: ts.ObjectLiteralExpression, wiringType: string, wiringName: string | null, logger?: {
+export declare const getCommonWireMetaData: (obj: ts.ObjectLiteralExpression, wiringType: string, wiringName: string | null, logger?: {
     critical: (code: ErrorCode, message: string) => void;
-}) => string[] | undefined;
+}) => {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    errors?: string[];
+};

package/dist/utils/get-property-value.js

@@ -19,35 +19,6 @@ export const getPropertyValue = (obj, propertyName) => {
                 .filter((item) => item !== null); // Filter non-null and assert type
             return stringArray.length > 0 ? stringArray : null;
         }
-        // Special handling for 'docs' -> expect RouteDocs
-        if (propertyName === 'docs' && ts.isObjectLiteralExpression(initializer)) {
-            const docs = {};
-            initializer.properties.forEach((prop) => {
-                if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-                    const propName = prop.name.text;
-                    if (propName === 'summary' && ts.isStringLiteral(prop.initializer)) {
-                        docs.summary = prop.initializer.text;
-                    }
-                    else if (propName === 'description' &&
-                        ts.isStringLiteral(prop.initializer)) {
-                        docs.description = prop.initializer.text;
-                    }
-                    else if (propName === 'tags' &&
-                        ts.isArrayLiteralExpression(prop.initializer)) {
-                        docs.tags = prop.initializer.elements
-                            .filter(ts.isStringLiteral)
-                            .map((element) => element.text);
-                    }
-                    else if (propName === 'errors' &&
-                        ts.isArrayLiteralExpression(prop.initializer)) {
-                        docs.errors = prop.initializer.elements
-                            .filter(ts.isIdentifier)
-                            .map((element) => element.text);
-                    }
-                }
-            });
-            return docs;
-        }
         // booleans -> true/false
         if (initializer.kind === ts.SyntaxKind.TrueKeyword) {
             return true;
@@ -66,21 +37,58 @@ export const getPropertyValue = (obj, propertyName) => {
     return null;
 };
 /**
- * Gets the 'tags' property from an object and validates it's an array.
- * Logs a critical error if tags is not an array but still returns the value.
+ * Extracts common wire metadata (tags, summary, description, errors) directly from an object
+ * @param obj - The TypeScript object literal expression to extract metadata from
+ * @param wiringType - The type of wiring (e.g., 'HTTP route', 'Channel', 'Queue worker')
+ * @param wiringName - The name/identifier of the wiring (e.g., route path, channel name)
  * @param logger - Optional logger instance; if not provided, uses console.error
+ * @returns Object containing the common wire metadata fields
  */
-export const getPropertyTags = (obj, wiringType, wiringName, logger) => {
-    const tagsValue = getPropertyValue(obj, 'tags');
-    if (tagsValue !== null && !Array.isArray(tagsValue)) {
-        const errorMsg = `${wiringType} '${wiringName}' has invalid 'tags' property - must be an array of strings.`;
-        if (logger) {
-            logger.critical(ErrorCode.INVALID_TAGS_TYPE, errorMsg);
-        }
-        else {
-            console.error(errorMsg);
+export const getCommonWireMetaData = (obj, wiringType, wiringName, logger) => {
+    const metadata = {};
+    obj.properties.forEach((prop) => {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            const propName = prop.name.text;
+            if (propName === 'summary' && ts.isStringLiteral(prop.initializer)) {
+                metadata.summary = prop.initializer.text;
+            }
+            else if (propName === 'description' &&
+                ts.isStringLiteral(prop.initializer)) {
+                metadata.description = prop.initializer.text;
+            }
+            else if (propName === 'tags') {
+                if (ts.isArrayLiteralExpression(prop.initializer)) {
+                    metadata.tags = prop.initializer.elements
+                        .filter(ts.isStringLiteral)
+                        .map((element) => element.text);
+                }
+                else {
+                    const errorMsg = `${wiringType} '${wiringName}' has invalid 'tags' property - must be an array of strings.`;
+                    if (logger) {
+                        logger.critical(ErrorCode.INVALID_TAGS_TYPE, errorMsg);
+                    }
+                    else {
+                        console.error(errorMsg);
+                    }
+                }
+            }
+            else if (propName === 'errors') {
+                if (ts.isArrayLiteralExpression(prop.initializer)) {
+                    metadata.errors = prop.initializer.elements
+                        .filter(ts.isIdentifier)
+                        .map((element) => element.text);
+                }
+                else {
+                    const errorMsg = `${wiringType} '${wiringName}' has invalid 'errors' property - must be an array of error identifiers.`;
+                    if (logger) {
+                        logger.critical(ErrorCode.INVALID_TAGS_TYPE, errorMsg);
+                    }
+                    else {
+                        console.error(errorMsg);
+                    }
+                }
+            }
         }
-        // Return undefined but don't stop processing - error will be caught by the exit handler
-    }
-    return Array.isArray(tagsValue) ? tagsValue : undefined;
+    });
+    return metadata;
 };

package/dist/utils/post-process.d.ts

@@ -1,3 +1,4 @@
+import * as ts from 'typescript';
 import { InspectorState } from '../types.js';
 import { MiddlewareMetadata, PermissionMetadata } from '@pikku/core';
 /**
@@ -14,3 +15,11 @@ export declare function extractWireNames(list?: MiddlewareMetadata[] | Permissio
  * in the add-* methods during AST traversal for efficiency.
  */
 export declare function aggregateRequiredServices(state: InspectorState | Omit<InspectorState, 'typesLookup'>): void;
+/**
+ * Extract service interface metadata for all user-defined services.
+ * This extracts metadata for services in SingletonServices and Services types
+ * to generate documentation for AI consumption.
+ *
+ * Must be called after aggregateRequiredServices() to ensure types are loaded.
+ */
+export declare function extractServiceInterfaceMetadata(state: InspectorState | Omit<InspectorState, 'typesLookup'>, checker: ts.TypeChecker): void;

package/dist/utils/post-process.js

@@ -1,4 +1,5 @@
 import { extractTypeKeys } from './type-utils.js';
+import { extractAllServiceMetadata, } from './extract-service-metadata.js';
 /**
  * Helper to extract wire-level middleware/permission names from metadata.
  * Only extracts type:'wire' variants (individual middleware/permissions).
@@ -60,9 +61,9 @@ function extractAllServices(state) {
     const servicesTypes = state.typesLookup.get('Services');
     if (servicesTypes && servicesTypes.length > 0) {
         const allServiceNames = extractTypeKeys(servicesTypes[0]);
-        // Session services are those in Services but not in SingletonServices
+        // Wire services are those in Services but not in SingletonServices
         const singletonSet = new Set(state.serviceAggregation.allSingletonServices);
-        state.serviceAggregation.allSessionServices = allServiceNames
+        state.serviceAggregation.allWireServices = allServiceNames
             .filter((name) => !singletonSet.has(name))
             .sort();
     }
@@ -152,7 +153,7 @@ export function aggregateRequiredServices(state) {
         expandAndAddGroupServices(resourceMeta.permissions, state, addServices, false);
     }
     // 5. Services from session service factories
-    for (const singletonServices of state.sessionServicesMeta.values()) {
+    for (const singletonServices of state.wireServicesMeta.values()) {
         singletonServices.forEach((service) => {
             if (!internalServices.has(service)) {
                 requiredServices.add(service);
@@ -160,3 +161,29 @@ export function aggregateRequiredServices(state) {
         });
     }
 }
+/**
+ * Extract service interface metadata for all user-defined services.
+ * This extracts metadata for services in SingletonServices and Services types
+ * to generate documentation for AI consumption.
+ *
+ * Must be called after aggregateRequiredServices() to ensure types are loaded.
+ */
+export function extractServiceInterfaceMetadata(state, checker) {
+    if (!('typesLookup' in state)) {
+        return;
+    }
+    const allMetadata = [];
+    const singletonServicesTypes = state.typesLookup.get('SingletonServices');
+    if (singletonServicesTypes && singletonServicesTypes.length > 0) {
+        const singletonMeta = extractAllServiceMetadata(singletonServicesTypes[0], checker, state.rootDir);
+        allMetadata.push(...singletonMeta);
+    }
+    const servicesTypes = state.typesLookup.get('Services');
+    if (servicesTypes && servicesTypes.length > 0) {
+        const wireServicesMeta = extractAllServiceMetadata(servicesTypes[0], checker, state.rootDir);
+        const singletonNames = new Set(state.serviceAggregation.allSingletonServices);
+        const uniqueWireServices = wireServicesMeta.filter((meta) => !singletonNames.has(meta.name));
+        allMetadata.push(...uniqueWireServices);
+    }
+    state.serviceMetadata = allMetadata;
+}

package/dist/utils/serialize-inspector-state.d.ts

@@ -13,7 +13,7 @@ export interface SerializableInspectorState {
             typePath: string | null;
         }[]
     ]>;
-    sessionServicesTypeImportMap: Array<[
+    wireServicesTypeImportMap: Array<[
         string,
         {
             variable: string;
@@ -45,7 +45,7 @@ export interface SerializableInspectorState {
             typePath: string | null;
         }[]
     ]>;
-    sessionServicesFactories: Array<[
+    wireServicesFactories: Array<[
         string,
         {
             variable: string;
@@ -53,7 +53,7 @@ export interface SerializableInspectorState {
             typePath: string | null;
         }[]
     ]>;
-    sessionServicesMeta: Array<[string, string[]]>;
+    wireServicesMeta: Array<[string, string[]]>;
     configFactories: Array<[
         string,
         {
@@ -123,6 +123,13 @@ export interface SerializableInspectorState {
         meta: InspectorState['queueWorkers']['meta'];
         files: string[];
     };
+    workflows: {
+        meta: InspectorState['workflows']['meta'];
+        files: Array<[string, {
+            path: string;
+            exportedName: string;
+        }]>;
+    };
     rpc: {
         internalMeta: InspectorState['rpc']['internalMeta'];
         internalFiles: Array<[string, {
@@ -166,8 +173,18 @@ export interface SerializableInspectorState {
         usedMiddleware: string[];
         usedPermissions: string[];
         allSingletonServices: string[];
-        allSessionServices: string[];
+        allWireServices: string[];
     };
+    serviceMetadata: Array<{
+        name: string;
+        summary: string;
+        description: string;
+        package: string;
+        path: string;
+        version: string;
+        interface: string;
+        expandedProperties: Record<string, string>;
+    }>;
 }
 /**
  * Serializes InspectorState to a JSON-compatible format

package/dist/utils/serialize-inspector-state.js

@@ -17,12 +17,12 @@ export function serializeInspectorState(state) {
     return {
         rootDir: state.rootDir,
         singletonServicesTypeImportMap: Array.from(state.singletonServicesTypeImportMap.entries()),
-        sessionServicesTypeImportMap: Array.from(state.sessionServicesTypeImportMap.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()),
-        sessionServicesFactories: Array.from(state.sessionServicesFactories.entries()),
-        sessionServicesMeta: Array.from(state.sessionServicesMeta.entries()),
+        wireServicesFactories: Array.from(state.wireServicesFactories.entries()),
+        wireServicesMeta: Array.from(state.wireServicesMeta.entries()),
         configFactories: Array.from(state.configFactories.entries()),
         filesAndMethods: state.filesAndMethods,
         filesAndMethodsErrors: Array.from(state.filesAndMethodsErrors.entries()).map(([key, mapValue]) => [key, Array.from(mapValue.entries())]),
@@ -50,6 +50,10 @@ export function serializeInspectorState(state) {
             meta: state.queueWorkers.meta,
             files: Array.from(state.queueWorkers.files),
         },
+        workflows: {
+            meta: state.workflows.meta,
+            files: Array.from(state.workflows.files.entries()),
+        },
         rpc: {
             internalMeta: state.rpc.internalMeta,
             internalFiles: Array.from(state.rpc.internalFiles.entries()),
@@ -81,8 +85,9 @@ export function serializeInspectorState(state) {
             usedMiddleware: Array.from(state.serviceAggregation.usedMiddleware),
             usedPermissions: Array.from(state.serviceAggregation.usedPermissions),
             allSingletonServices: state.serviceAggregation.allSingletonServices,
-            allSessionServices: state.serviceAggregation.allSessionServices,
+            allWireServices: state.serviceAggregation.allWireServices,
         },
+        serviceMetadata: state.serviceMetadata,
     };
 }
 /**
@@ -101,12 +106,12 @@ export function deserializeInspectorState(data) {
     return {
         rootDir: data.rootDir,
         singletonServicesTypeImportMap: new Map(data.singletonServicesTypeImportMap),
-        sessionServicesTypeImportMap: new Map(data.sessionServicesTypeImportMap),
+        wireServicesTypeImportMap: new Map(data.wireServicesTypeImportMap),
         userSessionTypeImportMap: new Map(data.userSessionTypeImportMap),
         configTypeImportMap: new Map(data.configTypeImportMap),
         singletonServicesFactories: new Map(data.singletonServicesFactories),
-        sessionServicesFactories: new Map(data.sessionServicesFactories),
-        sessionServicesMeta: new Map(data.sessionServicesMeta),
+        wireServicesFactories: new Map(data.wireServicesFactories),
+        wireServicesMeta: new Map(data.wireServicesMeta),
         configFactories: new Map(data.configFactories),
         filesAndMethods: data.filesAndMethods,
         filesAndMethodsErrors: new Map(data.filesAndMethodsErrors.map(([key, entries]) => [
@@ -137,6 +142,10 @@ export function deserializeInspectorState(data) {
             meta: data.queueWorkers.meta,
             files: new Set(data.queueWorkers.files),
         },
+        workflows: {
+            meta: data.workflows.meta,
+            files: new Map(data.workflows.files),
+        },
         rpc: {
             internalMeta: data.rpc.internalMeta,
             internalFiles: new Map(data.rpc.internalFiles),
@@ -168,7 +177,8 @@ export function deserializeInspectorState(data) {
             usedMiddleware: new Set(data.serviceAggregation.usedMiddleware),
             usedPermissions: new Set(data.serviceAggregation.usedPermissions),
             allSingletonServices: data.serviceAggregation.allSingletonServices,
-            allSessionServices: data.serviceAggregation.allSessionServices,
+            allWireServices: data.serviceAggregation.allWireServices,
         },
+        serviceMetadata: data.serviceMetadata || [],
     };
 }

package/dist/utils/type-utils.d.ts

@@ -1,3 +1,7 @@
 import * as ts from 'typescript';
 export declare const extractTypeKeys: (type: ts.Type) => string[];
+/**
+ * Resolve an identifier or call expression to the actual function declaration
+ */
+export declare function resolveFunctionDeclaration(node: ts.Node, checker: ts.TypeChecker): ts.Node | null;
 export declare function getPropertyAssignmentInitializer(obj: ts.ObjectLiteralExpression, propName: string, followShorthand?: boolean, checker?: ts.TypeChecker): ts.Expression | undefined;