@pikku/inspector 0.10.1 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,59 @@
+## 0.11.0
+
+### Minor Changes
+
+- Add workflow inspection and analysis
+- Add enhanced type extraction utilities
+
+
 # @pikku/inspector
 
+## 0.10.2
+
+### Patch Changes
+
+- 1967172: Update code generation to support channel middleware enhancements
+
+  **Code Generation Updates:**
+
+  - Update channel type serialization to include middleware support
+  - Improve WebSocket wrapper generation for middleware handling
+  - Update CLI channel client generation with better type support
+  - Enhance services and schema generation for channel configurations
+
+  **Inspector Updates:**
+
+  - Improve channel metadata extraction for middleware
+  - Better type analysis for channel lifecycle functions
+  - Enhanced post-processing for channel configurations
+
+- 753481a: Add bootstrap command, performance optimizations, and CLI improvements
+
+  **New Features:**
+
+  - Add `pikku bootstrap` command for type-only generation (~13.5% faster than `pikku all`)
+  - Add configurable `ignoreFiles` option to pikku.config.json with sensible defaults (_.gen.ts, _.test.ts, \*.spec.ts)
+  - Export pikkuCLIRender helper from serialize-cli-types.ts with JSDoc documentation
+
+  **Performance Improvements:**
+
+  - Add aggressive TypeScript compiler options (skipDefaultLibCheck, types: []) - ~37% faster TypeScript setup
+  - Add detailed performance timing to inspector phases (--logLevel=debug)
+  - Optimize file inspection with ignore patterns - ~10-20% faster overall
+
+  **Enhancements:**
+
+  - Fix --logLevel flag to properly apply log level to logger
+  - Update middleware logging to use structured log format
+  - Improve CLI renderers to consistently use destructured logger service
+  - Fix middleware file generation when middleware groups exist
+
+- 44d71a8: fix: fixing inspector ensuring pikkuConfig is set
+- Updated dependencies [ea652dc]
+- Updated dependencies [4349ec5]
+- Updated dependencies [44d71a8]
+  - @pikku/core@0.10.2
+
 ## 0.10.1
 
 ### Patch Changes

package/dist/add/add-channel.js

@@ -94,7 +94,15 @@ export function addMessagesRoutes(logger, obj, state, checker) {
             const init = getInitializerOf(routeElem);
             if (!init)
                 continue;
-            const routeKey = routeElem.name.getText();
+            // Get the route key, stripping quotes if it's a string literal
+            const routeName = routeElem.name;
+            if (!routeName)
+                continue;
+            let routeKey = routeName.getText();
+            // For string literals like 'greet' or "greet", strip the quotes
+            if (ts.isStringLiteral(routeName)) {
+                routeKey = routeName.text;
+            }
             // For shorthand properties, we need to resolve the identifier to its declaration
             if (ts.isShorthandPropertyAssignment(routeElem)) {
                 // Get the symbol for the shorthand property
@@ -133,8 +141,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                         // Look up in the registry
                                         const fnMeta = state.functions.meta[handlerName];
                                         if (fnMeta) {
+                                            // Resolve middleware for this route
+                                            const routeTags = ts.isObjectLiteralExpression(init)
+                                                ? getPropertyTags(init, 'channel', channelKey, logger)
+                                                : undefined;
+                                            const routeMiddleware = ts.isObjectLiteralExpression(init)
+                                                ? resolveMiddleware(state, init, routeTags, checker)
+                                                : undefined;
                                             result[channelKey][routeKey] = {
                                                 pikkuFuncName: handlerName,
+                                                middleware: routeMiddleware,
                                             };
                                             continue;
                                         }
@@ -147,8 +163,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                     // Look up in the registry
                                     const fnMeta = state.functions.meta[handlerName];
                                     if (fnMeta) {
+                                        // Resolve middleware for this route
+                                        const routeTags = ts.isObjectLiteralExpression(init)
+                                            ? getPropertyTags(init, 'channel', channelKey, logger)
+                                            : undefined;
+                                        const routeMiddleware = ts.isObjectLiteralExpression(init)
+                                            ? resolveMiddleware(state, init, routeTags, checker)
+                                            : undefined;
                                         result[channelKey][routeKey] = {
                                             pikkuFuncName: handlerName,
+                                            middleware: routeMiddleware,
                                         };
                                         continue;
                                     }
@@ -172,8 +196,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                 const handlerName = pikkuFuncName;
                                                 const fnMeta = state.functions.meta[handlerName];
                                                 if (fnMeta) {
+                                                    // Resolve middleware for this route
+                                                    const routeTags = ts.isObjectLiteralExpression(init)
+                                                        ? getPropertyTags(init, 'channel', channelKey, logger)
+                                                        : undefined;
+                                                    const routeMiddleware = ts.isObjectLiteralExpression(init)
+                                                        ? resolveMiddleware(state, init, routeTags, checker)
+                                                        : undefined;
                                                     result[channelKey][routeKey] = {
                                                         pikkuFuncName: handlerName,
+                                                        middleware: routeMiddleware,
                                                     };
                                                     continue;
                                                 }
@@ -183,8 +215,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                 const handlerName = pikkuFuncName;
                                                 const fnMeta = state.functions.meta[handlerName];
                                                 if (fnMeta) {
+                                                    // Resolve middleware for this route
+                                                    const routeTags = ts.isObjectLiteralExpression(init)
+                                                        ? getPropertyTags(init, 'channel', channelKey, logger)
+                                                        : undefined;
+                                                    const routeMiddleware = ts.isObjectLiteralExpression(init)
+                                                        ? resolveMiddleware(state, init, routeTags, checker)
+                                                        : undefined;
                                                     result[channelKey][routeKey] = {
                                                         pikkuFuncName: handlerName,
+                                                        middleware: routeMiddleware,
                                                     };
                                                     continue;
                                                 }
@@ -239,8 +279,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                             // Now use this handlerName to look up in the registry
                             const fnMeta = state.functions.meta[handlerName];
                             if (fnMeta) {
+                                // Resolve middleware for this route
+                                const routeTags = ts.isObjectLiteralExpression(init)
+                                    ? getPropertyTags(init, 'channel', channelKey, logger)
+                                    : undefined;
+                                const routeMiddleware = ts.isObjectLiteralExpression(init)
+                                    ? resolveMiddleware(state, init, routeTags, checker)
+                                    : undefined;
                                 result[channelKey][routeKey] = {
                                     pikkuFuncName: handlerName,
+                                    middleware: routeMiddleware,
                                 };
                                 continue; // Skip the normal processing below
                             }
@@ -259,8 +307,17 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                 logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for handler '${handlerName}'`);
                 continue;
             }
+            // Resolve middleware and permissions for this route
+            // Check if the route config is an object literal with middleware/permissions
+            const routeTags = ts.isObjectLiteralExpression(init)
+                ? getPropertyTags(init, 'channel', channelKey, logger)
+                : undefined;
+            const routeMiddleware = ts.isObjectLiteralExpression(init)
+                ? resolveMiddleware(state, init, routeTags, checker)
+                : undefined;
             result[channelKey][routeKey] = {
                 pikkuFuncName: handlerName,
+                middleware: routeMiddleware,
             };
         }
     }
@@ -295,24 +352,21 @@ export const addChannel = (logger, node, checker, state, options) => {
     const docs = getPropertyValue(obj, 'docs');
     const tags = getPropertyTags(obj, 'Channel', route, logger);
     const query = getPropertyValue(obj, 'query');
-    const connect = getPropertyAssignmentInitializer(obj, 'onConnect', false, checker);
-    const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', false, checker);
+    const connect = getPropertyAssignmentInitializer(obj, 'onConnect', true, checker);
+    const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', true, checker);
     // default onMessage handler
     let message = null;
-    const onMsgProp = getPropertyAssignmentInitializer(obj, 'onMessage', false, checker);
+    const onMsgProp = getPropertyAssignmentInitializer(obj, 'onMessage', true, checker);
     if (onMsgProp) {
-        const handlerName = onMsgProp &&
-            getHandlerNameFromExpression(onMsgProp, checker, state.rootDir);
-        const fnMeta = handlerName && state.functions.meta[handlerName];
+        const { pikkuFuncName } = extractFunctionName(onMsgProp, checker, state.rootDir);
+        const fnMeta = state.functions.meta[pikkuFuncName];
         if (!fnMeta) {
-            console.error(`No function metadata for onMessage handler '${handlerName}'`);
-            throw new Error();
-        }
-        else {
-            message = {
-                pikkuFuncName: extractFunctionName(onMsgProp, checker, state.rootDir).pikkuFuncName,
-            };
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for onMessage handler '${pikkuFuncName}'`);
+            return;
         }
+        message = {
+            pikkuFuncName,
+        };
     }
     // nested message-routes
     const messageWirings = addMessagesRoutes(logger, obj, state, checker);

package/dist/add/add-functions.js

@@ -233,6 +233,7 @@ export const addFunctions = (logger, node, checker, state) => {
     const { pikkuFuncName, name, explicitName, exportedName } = extractFunctionName(node, checker, state.rootDir);
     let tags;
     let expose;
+    let internal;
     let docs;
     let objectNode;
     // determine the actual handler expression:
@@ -244,6 +245,7 @@ export const addFunctions = (logger, node, checker, state) => {
         objectNode = handlerNode;
         tags = getPropertyValue(handlerNode, 'tags') || undefined;
         expose = getPropertyValue(handlerNode, 'expose');
+        internal = getPropertyValue(handlerNode, 'internal');
         docs = getPropertyValue(handlerNode, 'docs');
         const fnProp = getPropertyAssignmentInitializer(handlerNode, 'func', true, checker);
         if (!fnProp ||
@@ -342,6 +344,7 @@ export const addFunctions = (logger, node, checker, state) => {
         inputs: inputNames.filter((n) => n !== 'void') ?? null,
         outputs: outputNames.filter((n) => n !== 'void') ?? null,
         expose: expose || undefined,
+        internal: internal || undefined,
         tags: tags || undefined,
         docs: docs || undefined,
         isDirectFunction,
@@ -363,6 +366,10 @@ export const addFunctions = (logger, node, checker, state) => {
             logger.error(`• Function with explicit name '${name}' is not exported, this is not allowed.`);
             return;
         }
+        // Mark internal functions as invoked to force bundling
+        if (internal) {
+            state.rpc.invokedFunctions.add(pikkuFuncName);
+        }
         if (expose) {
             state.rpc.exposedMeta[name] = pikkuFuncName;
             state.rpc.exposedFiles.set(name, {
@@ -376,8 +383,8 @@ export const addFunctions = (logger, node, checker, state) => {
         state.rpc.internalMeta[name] = pikkuFuncName;
         // But we only import the actual function if it's actually invoked to keep
         // bundle size down
-        if (state.rpc.invokedFunctions.has(pikkuFuncName) || expose) {
-            state.rpc.internalFiles.set(name, {
+        if (state.rpc.invokedFunctions.has(pikkuFuncName) || expose || internal) {
+            state.rpc.internalFiles.set(pikkuFuncName, {
                 path: node.getSourceFile().fileName,
                 exportedName,
             });

package/dist/add/add-workflow.d.ts

@@ -0,0 +1,6 @@
+import { AddWiring } from '../types.js';
+/**
+ * Inspector for wireWorkflow() calls
+ * Detects workflow registration and extracts metadata
+ */
+export declare const addWorkflow: AddWiring;

package/dist/add/add-workflow.js

@@ -0,0 +1,152 @@
+import * as ts from 'typescript';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer, resolveFunctionDeclaration, } from '../utils/type-utils.js';
+import { resolveMiddleware } from '../utils/middleware.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ErrorCode } from '../error-codes.js';
+import { extractStringLiteral, extractNumberLiteral, extractPropertyString, isStringLike, isFunctionLike, } from '../utils/extract-node-value.js';
+/**
+ * Scan for workflow.do() and workflow.sleep() calls to extract workflow steps
+ */
+function getWorkflowInvocations(node, checker, state, workflowName, steps) {
+    // Look for property access expressions: workflow.do or workflow.sleep
+    if (ts.isPropertyAccessExpression(node)) {
+        const { name } = node;
+        // Check if this is accessing 'do' or 'sleep' property
+        if (name.text === 'do' || name.text === 'sleep') {
+            // Check if the parent is a call expression
+            const parent = node.parent;
+            if (ts.isCallExpression(parent) && parent.expression === node) {
+                const args = parent.arguments;
+                if (name.text === 'do' && args.length >= 2) {
+                    // workflow.do(stepName, rpcName|fn, data?, options?)
+                    const stepNameArg = args[0];
+                    const secondArg = args[1];
+                    const optionsArg = args.length >= 3 ? args[args.length - 1] : undefined;
+                    const stepName = extractStringLiteral(stepNameArg, checker);
+                    const description = extractDescription(optionsArg, checker) ?? undefined;
+                    // Determine form by checking 2nd argument type
+                    if (isStringLike(secondArg, checker)) {
+                        // RPC form: workflow.do(stepName, rpcName, data, options?)
+                        const rpcName = extractStringLiteral(secondArg, checker);
+                        steps.push({
+                            type: 'rpc',
+                            stepName,
+                            rpcName,
+                            description,
+                        });
+                        state.rpc.invokedFunctions.add(rpcName);
+                    }
+                    else if (isFunctionLike(secondArg)) {
+                        // Inline form: workflow.do(stepName, fn, options?)
+                        steps.push({
+                            type: 'inline',
+                            stepName: stepName || '<dynamic>',
+                            description: description || '<dynamic>',
+                        });
+                    }
+                }
+                else if (name.text === 'sleep' && args.length >= 2) {
+                    // workflow.sleep(stepName, duration)
+                    const stepNameArg = args[0];
+                    const durationArg = args[1];
+                    const stepName = extractStringLiteral(stepNameArg, checker);
+                    const duration = extractDuration(durationArg, checker);
+                    steps.push({
+                        type: 'sleep',
+                        stepName: stepName || '<dynamic>',
+                        duration: duration || '<dynamic>',
+                    });
+                }
+            }
+        }
+    }
+    // Don't recurse into nested functions - only look at top-level workflow calls
+    ts.forEachChild(node, (child) => {
+        if (ts.isFunctionDeclaration(child) ||
+            ts.isFunctionExpression(child) ||
+            ts.isArrowFunction(child)) {
+            return;
+        }
+        getWorkflowInvocations(child, checker, state, workflowName, steps);
+    });
+}
+/**
+ * Extract description from options object
+ */
+function extractDescription(optionsNode, checker) {
+    if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
+        return null;
+    }
+    return extractPropertyString(optionsNode, 'description', checker);
+}
+/**
+ * Extract duration value (number or string)
+ */
+function extractDuration(node, checker) {
+    const numValue = extractNumberLiteral(node);
+    if (numValue !== null) {
+        return numValue;
+    }
+    return extractStringLiteral(node, checker);
+}
+/**
+ * Inspector for wireWorkflow() calls
+ * Detects workflow registration and extracts metadata
+ */
+export const addWorkflow = (logger, node, checker, state, options) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    // Check if the call is to wireWorkflow
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireWorkflow') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        const obj = firstArg;
+        const workflowName = getPropertyValue(obj, 'name');
+        const description = getPropertyValue(obj, 'description');
+        const docs = getPropertyValue(obj, 'docs') || undefined;
+        const tags = getPropertyTags(obj, 'Workflow', workflowName, logger);
+        // --- find the referenced function ---
+        const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+        if (!workflowName) {
+            logger.critical(ErrorCode.MISSING_NAME, `Wasn't able to determine 'name' property for workflow wiring.`);
+            return;
+        }
+        if (!funcInitializer) {
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for workflow '${workflowName}'.`);
+            return;
+        }
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        // --- resolve middleware ---
+        const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- track used functions/middleware for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+        state.workflows.files.add(node.getSourceFile().fileName);
+        // Extract workflow steps from function body
+        // Resolve the identifier to the actual function declaration
+        const resolvedFunc = resolveFunctionDeclaration(funcInitializer, checker);
+        const steps = [];
+        if (resolvedFunc) {
+            getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
+        }
+        state.workflows.meta[workflowName] = {
+            pikkuFuncName,
+            workflowName,
+            description,
+            docs,
+            tags,
+            middleware,
+            steps,
+        };
+    }
+};

package/dist/error-codes.d.ts

@@ -17,6 +17,8 @@ export declare enum ErrorCode {
     MISSING_QUEUE_NAME = "PKU384",
     MISSING_CHANNEL_NAME = "PKU400",
     CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = "PKU672",
+    DYNAMIC_STEP_NAME = "PKU529",
+    WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED = "PKU600",
     CONFIG_TYPE_NOT_FOUND = "PKU426",
     CONFIG_TYPE_UNDEFINED = "PKU427",
     SCHEMA_NO_ROOT = "PKU431",
@@ -31,5 +33,6 @@ export declare enum ErrorCode {
     PERMISSION_HANDLER_INVALID = "PKU835",
     PERMISSION_TAG_INVALID = "PKU836",
     PERMISSION_EMPTY_ARRAY = "PKU937",
-    PERMISSION_PATTERN_INVALID = "PKU975"
+    PERMISSION_PATTERN_INVALID = "PKU975",
+    WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED = "PKU901"
 }

package/dist/error-codes.js

@@ -19,6 +19,8 @@ export var ErrorCode;
     ErrorCode["MISSING_QUEUE_NAME"] = "PKU384";
     ErrorCode["MISSING_CHANNEL_NAME"] = "PKU400";
     ErrorCode["CLI_CLIENTSIDE_RENDERER_HAS_SERVICES"] = "PKU672";
+    ErrorCode["DYNAMIC_STEP_NAME"] = "PKU529";
+    ErrorCode["WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED"] = "PKU600";
     // Configuration errors
     ErrorCode["CONFIG_TYPE_NOT_FOUND"] = "PKU426";
     ErrorCode["CONFIG_TYPE_UNDEFINED"] = "PKU427";
@@ -37,4 +39,6 @@ export var ErrorCode;
     ErrorCode["PERMISSION_TAG_INVALID"] = "PKU836";
     ErrorCode["PERMISSION_EMPTY_ARRAY"] = "PKU937";
     ErrorCode["PERMISSION_PATTERN_INVALID"] = "PKU975";
+    // Feature Flag
+    ErrorCode["WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED"] = "PKU901";
 })(ErrorCode || (ErrorCode = {}));

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { inspect } from './inspector.js';
+export { inspect, getInitialInspectorState } from './inspector.js';
 export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export type { TypesMap } from './types-map.js';
 export type * from './types.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { inspect } from './inspector.js';
+export { inspect, getInitialInspectorState } from './inspector.js';
 export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export { ErrorCode } from './error-codes.js';
 export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';

package/dist/inspector.d.ts

@@ -1,2 +1,8 @@
 import { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
+/**
+ * Creates an initial/empty inspector state with all required properties initialized
+ * @param rootDir - The root directory for the project
+ * @returns A fresh InspectorState with empty collections
+ */
+export declare function getInitialInspectorState(rootDir: string): InspectorState;
 export declare const inspect: (logger: InspectorLogger, routeFiles: string[], options?: InspectorOptions) => InspectorState;

package/dist/inspector.js

@@ -1,19 +1,17 @@
 import * as ts from 'typescript';
+import { performance } from 'perf_hooks';
 import { visitSetup, visitRoutes } from './visit.js';
 import { TypesMap } from './types-map.js';
 import { getFilesAndMethods } from './utils/get-files-and-methods.js';
 import { findCommonAncestor } from './utils/find-root-dir.js';
 import { aggregateRequiredServices } from './utils/post-process.js';
-export const inspect = (logger, routeFiles, options = {}) => {
-    const program = ts.createProgram(routeFiles, {
-        target: ts.ScriptTarget.ESNext,
-        module: ts.ModuleKind.CommonJS,
-    });
-    const checker = program.getTypeChecker();
-    const sourceFiles = program.getSourceFiles();
-    // Infer root directory from source files
-    const rootDir = findCommonAncestor(routeFiles);
-    const state = {
+/**
+ * Creates an initial/empty inspector state with all required properties initialized
+ * @param rootDir - The root directory for the project
+ * @returns A fresh InspectorState with empty collections
+ */
+export function getInitialInspectorState(rootDir) {
+    return {
         rootDir,
         singletonServicesTypeImportMap: new Map(),
         sessionServicesTypeImportMap: new Map(),
@@ -58,6 +56,10 @@ export const inspect = (logger, routeFiles, options = {}) => {
             meta: {},
             files: new Set(),
         },
+        workflows: {
+            meta: {},
+            files: new Set(),
+        },
         rpc: {
             internalMeta: {},
             internalFiles: new Map(),
@@ -91,21 +93,57 @@ export const inspect = (logger, routeFiles, options = {}) => {
             usedFunctions: new Set(),
             usedMiddleware: new Set(),
             usedPermissions: new Set(),
+            allSingletonServices: [],
+            allSessionServices: [],
         },
     };
+}
+export const inspect = (logger, routeFiles, options = {}) => {
+    const startProgram = performance.now();
+    const program = ts.createProgram(routeFiles, {
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.CommonJS,
+        skipLibCheck: true,
+        skipDefaultLibCheck: true,
+        moduleResolution: ts.ModuleResolutionKind.Node10,
+        types: [],
+        allowJs: false,
+        checkJs: false,
+    });
+    logger.debug(`Created program in ${(performance.now() - startProgram).toFixed(2)}ms`);
+    const startChecker = performance.now();
+    const checker = program.getTypeChecker();
+    logger.debug(`Got type checker in ${(performance.now() - startChecker).toFixed(2)}ms`);
+    const startSourceFiles = performance.now();
+    const sourceFiles = program.getSourceFiles();
+    logger.debug(`Got source files in ${(performance.now() - startSourceFiles).toFixed(2)}ms`);
+    // Infer root directory from source files
+    const rootDir = findCommonAncestor(routeFiles);
+    const state = getInitialInspectorState(rootDir);
     // First sweep: add all functions
+    const startSetup = performance.now();
     for (const sourceFile of sourceFiles) {
         ts.forEachChild(sourceFile, (child) => visitSetup(logger, checker, child, state, options));
     }
-    // Second sweep: add all transports
-    for (const sourceFile of sourceFiles) {
-        ts.forEachChild(sourceFile, (child) => visitRoutes(logger, checker, child, state, options));
+    logger.debug(`Visit setup phase completed in ${(performance.now() - startSetup).toFixed(2)}ms`);
+    if (!options.setupOnly) {
+        // Second sweep: add all transports
+        const startRoutes = performance.now();
+        for (const sourceFile of sourceFiles) {
+            ts.forEachChild(sourceFile, (child) => visitRoutes(logger, checker, child, state, options));
+        }
+        logger.debug(`Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(2)}ms`);
     }
     // Populate filesAndMethods
+    const startFilesAndMethods = performance.now();
     const { result, errors } = getFilesAndMethods(state, options.types);
     state.filesAndMethods = result;
     state.filesAndMethodsErrors = errors;
-    // Post-processing: Aggregate required services from wired functions/middleware/permissions
-    aggregateRequiredServices(state);
+    logger.debug(`Get files and methods completed in ${(performance.now() - startFilesAndMethods).toFixed(2)}ms`);
+    if (!options.setupOnly) {
+        const startAggregate = performance.now();
+        aggregateRequiredServices(state);
+        logger.debug(`Aggregate required services completed in ${(performance.now() - startAggregate).toFixed(2)}ms`);
+    }
     return state;
 };

package/dist/types.d.ts

@@ -2,7 +2,8 @@ import * as ts from 'typescript';
 import { ChannelsMeta } from '@pikku/core/channel';
 import { HTTPWiringsMeta } from '@pikku/core/http';
 import { ScheduledTasksMeta } from '@pikku/core/scheduler';
-import { queueWorkersMeta } from '@pikku/core/queue';
+import { QueueWorkersMeta } from '@pikku/core/queue';
+import { WorkflowsMeta } from '@pikku/core/workflow';
 import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
 import { CLIMeta } from '@pikku/core/cli';
 import { TypesMap } from './types-map.js';
@@ -86,6 +87,7 @@ export type InspectorFilters = {
     httpMethods?: string[];
 };
 export type InspectorOptions = Partial<{
+    setupOnly: boolean;
     types: Partial<{
         configFileType: string;
         userSessionType: string;
@@ -167,7 +169,11 @@ export interface InspectorState {
         files: Set<string>;
     };
     queueWorkers: {
-        meta: queueWorkersMeta;
+        meta: QueueWorkersMeta;
+        files: Set<string>;
+    };
+    workflows: {
+        meta: WorkflowsMeta;
         files: Set<string>;
     };
     rpc: {
@@ -200,5 +206,7 @@ export interface InspectorState {
         usedFunctions: Set<string>;
         usedMiddleware: Set<string>;
         usedPermissions: Set<string>;
+        allSingletonServices: string[];
+        allSessionServices: string[];
     };
 }

package/dist/utils/extract-node-value.d.ts

@@ -0,0 +1,24 @@
+import * as ts from 'typescript';
+/**
+ * Extract string literal value from a TypeScript node.
+ * Handles string literals, template literals (including placeholders),
+ * and constant variable references.
+ */
+export declare function extractStringLiteral(node: ts.Node, checker: ts.TypeChecker): string;
+/**
+ * Check if node is string-like (string literal or template expression)
+ */
+export declare function isStringLike(node: ts.Node, _checker: ts.TypeChecker): boolean;
+/**
+ * Check if node is function-like (arrow, function expression, or function declaration)
+ */
+export declare function isFunctionLike(node: ts.Node): boolean;
+/**
+ * Extract number literal value from a node
+ */
+export declare function extractNumberLiteral(node: ts.Node): number | null;
+/**
+ * Extract a property value from an object literal expression
+ * Returns the extracted value or null if not found/cannot extract
+ */
+export declare function extractPropertyString(objNode: ts.ObjectLiteralExpression, propertyName: string, checker: ts.TypeChecker): string | null;