@pikku/inspector 0.9.6-next.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @pikku/inspector
 
+## 0.10.0
+
+This release includes significant improvements across the framework including tree-shaking support, middleware/permission factories, enhanced CLI functionality, improved TypeScript type safety, and comprehensive test strategies.
+
+For complete details, see https://pikku.dev/changelogs/0_10_0.md
+
 ## 0.9.6-next.0
 
 ### Patch Changes

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

@@ -1,11 +1,15 @@
 import * as ts from 'typescript';
+import { ErrorCode } from '../error-codes.js';
 import type { ChannelMeta } from '@pikku/core/channel';
 import type { InspectorState, AddWiring } from '../types.js';
 /**
  * Build out the nested message-routes by looking up each handler
  * in state.functions.meta instead of re-inferring it here.
  */
-export declare function addMessagesRoutes(obj: ts.ObjectLiteralExpression, state: InspectorState, checker: ts.TypeChecker): ChannelMeta['messageWirings'];
+export declare function addMessagesRoutes(logger: {
+    error: (msg: string) => void;
+    critical: (code: ErrorCode, msg: string) => void;
+}, obj: ts.ObjectLiteralExpression, state: InspectorState, checker: ts.TypeChecker): ChannelMeta['messageWirings'];
 /**
  * Inspect addChannel calls, look up all handlers in state.functions.meta,
  * and emit one entry into state.channels.meta.

package/dist/add/add-channel.js

@@ -1,11 +1,11 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
+import { ErrorCode } from '../error-codes.js';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
-import { PikkuWiringTypes } from '@pikku/core';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { matchesFilters } from '../utils/filter-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { extractWireNames } from '../utils/post-process.js';
 /**
  * Safely get the "initializer" expression of a property-like AST node:
  * - for `foo: expr`, returns `expr`
@@ -25,7 +25,7 @@ function getInitializerOf(elem) {
  * Resolve a handler expression (Identifier, CallExpression, or { func })
  * into its underlying function name.
  */
-function getHandlerNameFromExpression(expr, checker) {
+function getHandlerNameFromExpression(expr, checker, rootDir) {
     // Handle direct identifier case (which includes shorthand properties)
     if (ts.isIdentifier(expr)) {
         const sym = checker.getSymbolAtLocation(expr);
@@ -44,31 +44,31 @@ function getHandlerNameFromExpression(expr, checker) {
                         ts.isArrowFunction(decl.initializer) ||
                         ts.isFunctionExpression(decl.initializer)) {
                         // Extract function name from the declaration's initializer
-                        const { pikkuFuncName } = extractFunctionName(decl.initializer, checker);
+                        const { pikkuFuncName } = extractFunctionName(decl.initializer, checker, rootDir);
                         return pikkuFuncName;
                     }
                 }
                 // For function declarations, use directly
                 else if (ts.isFunctionDeclaration(decl)) {
-                    const { pikkuFuncName } = extractFunctionName(decl, checker);
+                    const { pikkuFuncName } = extractFunctionName(decl, checker, rootDir);
                     return pikkuFuncName;
                 }
             }
         }
         // Fallback: try to extract directly from the identifier
-        const { pikkuFuncName } = extractFunctionName(expr, checker);
+        const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir);
         return pikkuFuncName;
     }
     // Handle call expressions
     if (ts.isCallExpression(expr)) {
-        const { pikkuFuncName } = extractFunctionName(expr, checker);
+        const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir);
         return pikkuFuncName;
     }
     // Handle object literals with 'func' property
     if (ts.isObjectLiteralExpression(expr)) {
         const fnProp = getPropertyAssignmentInitializer(expr, 'func', true, checker);
         if (fnProp) {
-            return getHandlerNameFromExpression(fnProp, checker);
+            return getHandlerNameFromExpression(fnProp, checker, rootDir);
         }
     }
     return null;
@@ -77,7 +77,7 @@ function getHandlerNameFromExpression(expr, checker) {
  * Build out the nested message-routes by looking up each handler
  * in state.functions.meta instead of re-inferring it here.
  */
-export function addMessagesRoutes(obj, state, checker) {
+export function addMessagesRoutes(logger, obj, state, checker) {
     const result = {};
     const onMsgRouteProp = getPropertyAssignmentInitializer(obj, 'onMessageWiring', true, checker);
     if (!onMsgRouteProp)
@@ -128,7 +128,7 @@ export function addMessagesRoutes(obj, state, checker) {
                                     if (ts.isArrowFunction(importDecl.initializer) ||
                                         ts.isFunctionExpression(importDecl.initializer) ||
                                         ts.isCallExpression(importDecl.initializer)) {
-                                        const { pikkuFuncName } = extractFunctionName(importDecl.initializer, checker);
+                                        const { pikkuFuncName } = extractFunctionName(importDecl.initializer, checker, state.rootDir);
                                         const handlerName = pikkuFuncName;
                                         // Look up in the registry
                                         const fnMeta = state.functions.meta[handlerName];
@@ -142,7 +142,7 @@ export function addMessagesRoutes(obj, state, checker) {
                                 }
                                 else if (ts.isFunctionDeclaration(importDecl)) {
                                     // Extract from the function declaration
-                                    const { pikkuFuncName } = extractFunctionName(importDecl, checker);
+                                    const { pikkuFuncName } = extractFunctionName(importDecl, checker, state.rootDir);
                                     const handlerName = pikkuFuncName;
                                     // Look up in the registry
                                     const fnMeta = state.functions.meta[handlerName];
@@ -168,7 +168,7 @@ export function addMessagesRoutes(obj, state, checker) {
                                             const exportDecl = exportDecls[0];
                                             if (ts.isVariableDeclaration(exportDecl) &&
                                                 exportDecl.initializer) {
-                                                const { pikkuFuncName } = extractFunctionName(exportDecl.initializer, checker);
+                                                const { pikkuFuncName } = extractFunctionName(exportDecl.initializer, checker, state.rootDir);
                                                 const handlerName = pikkuFuncName;
                                                 const fnMeta = state.functions.meta[handlerName];
                                                 if (fnMeta) {
@@ -179,7 +179,7 @@ export function addMessagesRoutes(obj, state, checker) {
                                                 }
                                             }
                                             else if (ts.isFunctionDeclaration(exportDecl)) {
-                                                const { pikkuFuncName } = extractFunctionName(exportDecl, checker);
+                                                const { pikkuFuncName } = extractFunctionName(exportDecl, checker, state.rootDir);
                                                 const handlerName = pikkuFuncName;
                                                 const fnMeta = state.functions.meta[handlerName];
                                                 if (fnMeta) {
@@ -205,7 +205,7 @@ export function addMessagesRoutes(obj, state, checker) {
                         if (possibleMatch) {
                             const fnMeta = state.functions.meta[possibleMatch];
                             if (!fnMeta) {
-                                console.error(`No function metadata found for handler '${possibleMatch}'`);
+                                logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for handler '${possibleMatch}'`);
                                 continue;
                             }
                             result[channelKey][routeKey] = {
@@ -234,7 +234,7 @@ export function addMessagesRoutes(obj, state, checker) {
                         // If we found the actual function, extract its name
                         if (actualFunction) {
                             // Extract the function name directly from the actual function
-                            const { pikkuFuncName } = extractFunctionName(actualFunction, checker);
+                            const { pikkuFuncName } = extractFunctionName(actualFunction, checker, state.rootDir);
                             const handlerName = pikkuFuncName;
                             // Now use this handlerName to look up in the registry
                             const fnMeta = state.functions.meta[handlerName];
@@ -249,14 +249,14 @@ export function addMessagesRoutes(obj, state, checker) {
                 }
             }
             // Normal processing for non-shorthand properties
-            const handlerName = getHandlerNameFromExpression(init, checker);
+            const handlerName = getHandlerNameFromExpression(init, checker, state.rootDir);
             if (!handlerName) {
-                console.error(`Could not resolve handler for message route '${routeKey}'`);
+                logger.error(`Could not resolve handler for message route '${routeKey}'`);
                 continue;
             }
             const fnMeta = state.functions.meta[handlerName];
             if (!fnMeta) {
-                console.error(`No function metadata found for handler '${handlerName}'`);
+                logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for handler '${handlerName}'`);
                 continue;
             }
             result[channelKey][routeKey] = {
@@ -271,7 +271,6 @@ export function addMessagesRoutes(obj, state, checker) {
  * and emit one entry into state.channels.meta.
  */
 export const addChannel = (logger, node, checker, state, options) => {
-    const filters = options.filters || {};
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args } = node;
@@ -284,7 +283,7 @@ export const addChannel = (logger, node, checker, state, options) => {
     const name = getPropertyValue(obj, 'name');
     const route = getPropertyValue(obj, 'route') ?? '';
     if (!name) {
-        console.error('Channel name is required');
+        logger.critical(ErrorCode.MISSING_CHANNEL_NAME, 'Channel name is required');
         return;
     }
     // path parameters
@@ -294,18 +293,16 @@ export const addChannel = (logger, node, checker, state, options) => {
             .map((k) => k.name)
         : [];
     const docs = getPropertyValue(obj, 'docs');
-    const tags = getPropertyValue(obj, 'tags');
+    const tags = getPropertyTags(obj, 'Channel', route, logger);
     const query = getPropertyValue(obj, 'query');
-    const filePath = node.getSourceFile().fileName;
-    if (!matchesFilters(filters, { tags }, { type: PikkuWiringTypes.channel, name, filePath }, logger))
-        return;
     const connect = getPropertyAssignmentInitializer(obj, 'onConnect', false, checker);
     const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', false, checker);
     // default onMessage handler
     let message = null;
     const onMsgProp = getPropertyAssignmentInitializer(obj, 'onMessage', false, checker);
     if (onMsgProp) {
-        const handlerName = onMsgProp && getHandlerNameFromExpression(onMsgProp, checker);
+        const handlerName = onMsgProp &&
+            getHandlerNameFromExpression(onMsgProp, checker, state.rootDir);
         const fnMeta = handlerName && state.functions.meta[handlerName];
         if (!fnMeta) {
             console.error(`No function metadata for onMessage handler '${handlerName}'`);
@@ -313,15 +310,35 @@ export const addChannel = (logger, node, checker, state, options) => {
         }
         else {
             message = {
-                pikkuFuncName: extractFunctionName(onMsgProp, checker)
-                    .pikkuFuncName,
+                pikkuFuncName: extractFunctionName(onMsgProp, checker, state.rootDir).pikkuFuncName,
             };
         }
     }
     // nested message-routes
-    const messageWirings = addMessagesRoutes(obj, state, checker);
+    const messageWirings = addMessagesRoutes(logger, obj, state, checker);
     // --- resolve middleware ---
     const middleware = resolveMiddleware(state, obj, tags, checker);
+    // --- track used functions/middleware for service aggregation ---
+    // Track connect/disconnect/message handlers
+    if (connect) {
+        const connectFuncName = extractFunctionName(connect, checker, state.rootDir).pikkuFuncName;
+        state.serviceAggregation.usedFunctions.add(connectFuncName);
+    }
+    if (disconnect) {
+        const disconnectFuncName = extractFunctionName(disconnect, checker, state.rootDir).pikkuFuncName;
+        state.serviceAggregation.usedFunctions.add(disconnectFuncName);
+    }
+    if (message) {
+        state.serviceAggregation.usedFunctions.add(message.pikkuFuncName);
+    }
+    // Track message wiring handlers
+    for (const channelHandlers of Object.values(messageWirings)) {
+        for (const handler of Object.values(channelHandlers)) {
+            state.serviceAggregation.usedFunctions.add(handler.pikkuFuncName);
+        }
+    }
+    // Track middleware
+    extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
     // record into state
     state.channels.files.add(node.getSourceFile().fileName);
     state.channels.meta[name] = {
@@ -338,12 +355,14 @@ export const addChannel = (logger, node, checker, state, options) => {
         //   params
         // ),
         connect: connect
-            ? { pikkuFuncName: extractFunctionName(connect, checker).pikkuFuncName }
+            ? {
+                pikkuFuncName: extractFunctionName(connect, checker, state.rootDir)
+                    .pikkuFuncName,
+            }
             : null,
         disconnect: disconnect
             ? {
-                pikkuFuncName: extractFunctionName(disconnect, checker)
-                    .pikkuFuncName,
+                pikkuFuncName: extractFunctionName(disconnect, checker, state.rootDir).pikkuFuncName,
             }
             : null,
         message,

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

@@ -3,3 +3,7 @@ import { AddWiring } from '../types.js';
  * Adds CLI command metadata to the inspector state
  */
 export declare const addCLI: AddWiring;
+/**
+ * Adds CLI renderer metadata to the inspector state
+ */
+export declare const addCLIRenderers: AddWiring;

package/dist/add/add-cli.js

@@ -1,7 +1,10 @@
 import ts from 'typescript';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { extractWireNames } from '../utils/post-process.js';
 import { getPropertyValue } from '../utils/get-property-value.js';
+// Track if we've warned about missing Config type to avoid duplicate warnings
+const configTypeWarningShown = new Set();
 /**
  * Adds CLI command metadata to the inspector state
  */
@@ -33,18 +36,39 @@ export const addCLI = (logger, node, typeChecker, inspectorState, options) => {
         return;
     }
     // Add this program to the CLI metadata
-    inspectorState.cli.meta[cliConfig.programName] = cliConfig.programMeta;
+    inspectorState.cli.meta.programs[cliConfig.programName] =
+        cliConfig.programMeta;
 };
 /**
  * Processes a CLI configuration object
  */
 function processCLIConfig(logger, node, sourceFile, typeChecker, inspectorState, options) {
     let programName = '';
+    let programTags;
     const programMeta = {
         program: '',
         commands: {},
         options: {},
     };
+    // First pass: extract program name and tags
+    for (const prop of node.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        if (!ts.isIdentifier(prop.name))
+            continue;
+        const propName = prop.name.text;
+        if (propName === 'program' && ts.isStringLiteral(prop.initializer)) {
+            programName = prop.initializer.text;
+            programMeta.program = programName;
+        }
+        else if (propName === 'tags') {
+            programTags = getPropertyValue(node, 'tags') || undefined;
+        }
+    }
+    if (!programName) {
+        return null;
+    }
+    // Second pass: process other properties with program tags available
     for (const prop of node.properties) {
         if (!ts.isPropertyAssignment(prop))
             continue;
@@ -53,14 +77,12 @@ function processCLIConfig(logger, node, sourceFile, typeChecker, inspectorState,
         const propName = prop.name.text;
         switch (propName) {
             case 'program':
-                if (ts.isStringLiteral(prop.initializer)) {
-                    programName = prop.initializer.text;
-                    programMeta.program = programName;
-                }
+            case 'tags':
+                // Already handled in first pass
                 break;
             case 'commands':
                 if (ts.isObjectLiteralExpression(prop.initializer)) {
-                    programMeta.commands = processCommands(logger, prop.initializer, sourceFile, typeChecker, programName, inspectorState, options);
+                    programMeta.commands = processCommands(logger, prop.initializer, sourceFile, typeChecker, programName, inspectorState, options, programTags);
                 }
                 break;
             case 'options':
@@ -69,30 +91,39 @@ function processCLIConfig(logger, node, sourceFile, typeChecker, inspectorState,
                 }
                 break;
             case 'render':
-                // Track that a default renderer exists
-                programMeta.defaultRenderName = 'defaultRenderer';
+                // Extract the actual renderer function name
+                programMeta.defaultRenderName = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncName;
                 break;
         }
     }
-    if (!programName) {
-        return null;
-    }
     return { programName, programMeta };
 }
 /**
  * Processes the commands object
  */
-function processCommands(logger, node, sourceFile, typeChecker, programName, inspectorState, options) {
+function processCommands(logger, node, sourceFile, typeChecker, programName, inspectorState, options, programTags) {
     const commands = {};
+    let defaultCommandName = null;
     for (const prop of node.properties) {
         if (!ts.isPropertyAssignment(prop))
             continue;
         const commandName = getPropertyName(prop);
         if (!commandName)
             continue;
-        const commandMeta = processCommand(logger, inspectorState, options, commandName, prop.initializer, sourceFile, typeChecker, programName);
+        const commandMeta = processCommand(logger, inspectorState, options, commandName, prop.initializer, sourceFile, typeChecker, programName, [], programTags);
         if (commandMeta) {
             commands[commandName] = commandMeta;
+            // Validate only one default command
+            if (commandMeta.isDefault) {
+                if (defaultCommandName !== null) {
+                    const position = prop.getStart(sourceFile);
+                    const { line, character } = sourceFile.getLineAndCharacterOfPosition(position);
+                    throw new Error(`Multiple default commands found in CLI program "${programName}" at ${sourceFile.fileName}:${line + 1}:${character + 1}.\n` +
+                        `Commands "${defaultCommandName}" and "${commandName}" are both marked as default.\n` +
+                        `Only one command can be marked as default per program.`);
+                }
+                defaultCommandName = commandName;
+            }
         }
     }
     return commands;
@@ -100,14 +131,14 @@ function processCommands(logger, node, sourceFile, typeChecker, programName, ins
 /**
  * Processes a single command
  */
-function processCommand(logger, inspectorState, options, name, node, sourceFile, typeChecker, programName, parentPath = []) {
+function processCommand(logger, inspectorState, options, name, node, sourceFile, typeChecker, programName, parentPath = [], programTags) {
     const fullPath = [...parentPath, name];
     // Handle shorthand (just a function)
     if (ts.isIdentifier(node) ||
         ts.isArrowFunction(node) ||
         ts.isFunctionExpression(node)) {
         return {
-            pikkuFuncName: extractFunctionName(node, typeChecker).pikkuFuncName,
+            pikkuFuncName: extractFunctionName(node, typeChecker, inspectorState.rootDir).pikkuFuncName,
             positionals: [],
             options: {},
         };
@@ -120,7 +151,7 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
             node.arguments.length > 0 &&
             ts.isObjectLiteralExpression(node.arguments[0])) {
             // Process the object literal argument
-            return processCommand(logger, inspectorState, options, name, node.arguments[0], sourceFile, typeChecker, programName, parentPath);
+            return processCommand(logger, inspectorState, options, name, node.arguments[0], sourceFile, typeChecker, programName, parentPath, programTags);
         }
         return null;
     }
@@ -144,7 +175,7 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
             continue;
         const propName = prop.name.text;
         if (propName === 'func') {
-            pikkuFuncName = extractFunctionName(prop.initializer, typeChecker).pikkuFuncName;
+            pikkuFuncName = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncName;
             meta.pikkuFuncName = pikkuFuncName;
         }
         else if (propName === 'options' &&
@@ -155,11 +186,17 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
             tags = getPropertyValue(node, 'tags') || undefined;
         }
     }
+    // Merge program-level tags with command-level tags
+    const allTags = [...(programTags || []), ...(tags || [])];
     // Resolve middleware
-    const middleware = resolveMiddleware(inspectorState, node, tags, typeChecker);
+    const middleware = resolveMiddleware(inspectorState, node, allTags.length > 0 ? allTags : undefined, typeChecker);
     if (middleware) {
         meta.middleware = middleware;
     }
+    // Add merged tags to metadata
+    if (allTags.length > 0) {
+        meta.tags = allTags;
+    }
     // Second pass: process all properties
     for (const prop of node.properties) {
         if (!ts.isPropertyAssignment(prop))
@@ -183,7 +220,7 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                 // Already handled in first pass
                 break;
             case 'render':
-                meta.renderName = extractFunctionName(prop.initializer, typeChecker).pikkuFuncName;
+                meta.renderName = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncName;
                 break;
             case 'options':
                 // Process with pikkuFuncName from first pass
@@ -200,15 +237,25 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                         const subName = getPropertyName(subProp);
                         if (!subName)
                             continue;
-                        const subCommand = processCommand(logger, inspectorState, options, subName, subProp.initializer, sourceFile, typeChecker, programName, fullPath);
+                        const subCommand = processCommand(logger, inspectorState, options, subName, subProp.initializer, sourceFile, typeChecker, programName, fullPath, programTags);
                         if (subCommand) {
                             meta.subcommands[subName] = subCommand;
                         }
                     }
                 }
                 break;
+            case 'isDefault':
+                if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+                    prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                    meta.isDefault = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
+                }
+                break;
         }
     }
+    // --- track used functions/middleware for service aggregation ---
+    inspectorState.serviceAggregation.usedFunctions.add(meta.pikkuFuncName);
+    extractWireNames(meta.middleware).forEach((name) => inspectorState.serviceAggregation.usedMiddleware.add(name));
+    // Note: subcommands are tracked recursively when they're processed
     return meta;
 }
 /**
@@ -382,14 +429,21 @@ function extractEnumFromConfigType(logger, propertyName, typeChecker, inspectorS
     // Look for Config type in typesLookup
     const configTypes = inspectorState.typesLookup.get('Config');
     if (!configTypes || configTypes.length === 0) {
-        logger.warn(`Warning: Could not find Config type in typesLookup for option "${propertyName}". ` +
-            `Make sure you have a Config interface extending CoreConfig in your codebase.`);
+        // Only warn once per CLI file to avoid spamming logs
+        if (!configTypeWarningShown.has('missing-config-type')) {
+            configTypeWarningShown.add('missing-config-type');
+            logger.warn(`Could not find Config type in typesLookup. ` +
+                `Make sure you have a Config interface extending CoreConfig in your codebase.`);
+        }
         return null;
     }
     // Use the first Config type (there should only be one)
     const configType = configTypes[0];
     if (!configType) {
-        logger.warn(`Warning: Config type is undefined in typesLookup for option "${propertyName}".`);
+        if (!configTypeWarningShown.has('undefined-config-type')) {
+            configTypeWarningShown.add('undefined-config-type');
+            logger.warn(`Config type is undefined in typesLookup.`);
+        }
         return null;
     }
     // Extract enum from the property
@@ -459,3 +513,54 @@ function parseCommandPattern(pattern) {
     }
     return positionals;
 }
+/**
+ * Adds CLI renderer metadata to the inspector state
+ */
+export const addCLIRenderers = (logger, node, typeChecker, inspectorState, options) => {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args, typeArguments } = node;
+    // Only handle pikkuCLIRender calls
+    if (!ts.isIdentifier(expression) || expression.text !== 'pikkuCLIRender') {
+        return;
+    }
+    if (args.length === 0)
+        return;
+    // Extract renderer name
+    const { pikkuFuncName, exportedName } = extractFunctionName(node, typeChecker, inspectorState.rootDir);
+    // Get the source file path
+    const sourceFile = node.getSourceFile();
+    const filePath = sourceFile.fileName;
+    // Extract services from type parameters (second type param is Services)
+    const services = {
+        optimized: true,
+        services: [],
+    };
+    if (typeArguments && typeArguments.length >= 2) {
+        // Second type parameter is the Services type
+        const servicesTypeNode = typeArguments[1];
+        if (servicesTypeNode) {
+            const servicesType = typeChecker.getTypeFromTypeNode(servicesTypeNode);
+            // Extract property names from the Services type
+            const properties = servicesType.getProperties();
+            for (const prop of properties) {
+                services.services.push(prop.getName());
+            }
+            // If no specific services found, it might be using the full services object
+            if (properties.length === 0) {
+                services.optimized = false;
+            }
+        }
+    }
+    // Store renderer metadata
+    inspectorState.cli.meta.renderers[pikkuFuncName] = {
+        name: pikkuFuncName,
+        exportedName: exportedName ?? undefined,
+        services,
+        filePath,
+    };
+    // Add to files map if exported
+    if (exportedName) {
+        inspectorState.cli.files.add(filePath);
+    }
+};

package/dist/add/add-file-extends-core-type.js

@@ -23,11 +23,12 @@ export const addFileExtendsCoreType = (node, checker, methods, expectedTypeName,
                             }
                             const variables = methods.get(fileName) || [];
                             if (!typeName) {
-                                throw new Error('TODO');
+                                throw new Error(`Found anonymous ${ts.isClassDeclaration(node) ? 'class' : 'interface'} extending ${expectedTypeName} in ${fileName}. ` +
+                                    `Classes and interfaces that extend core types must have a name.`);
                             }
                             variables.push({
                                 variable: typeName,
-                                type: typeName || null,
+                                type: typeName,
                                 typePath: extendedTypeDeclarationPath,
                             });
                             methods.set(fileName, variables);

package/dist/add/add-file-with-factory.d.ts

@@ -1,3 +1,3 @@
 import * as ts from 'typescript';
-import { PathToNameAndType } from '../types.js';
-export declare const addFileWithFactory: (node: ts.Node, checker: ts.TypeChecker, methods: PathToNameAndType | undefined, expectedTypeName: string) => void;
+import { PathToNameAndType, InspectorState } from '../types.js';
+export declare const addFileWithFactory: (node: ts.Node, checker: ts.TypeChecker, methods: PathToNameAndType | undefined, expectedTypeName: string, state?: InspectorState) => void;

package/dist/add/add-file-with-factory.js

@@ -1,5 +1,6 @@
 import * as ts from 'typescript';
-export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName) => {
+import { extractServicesFromFunction } from '../utils/extract-services.js';
+export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName, state) => {
     if (ts.isVariableDeclaration(node)) {
         const fileName = node.getSourceFile().fileName;
         const variableTypeNode = node.type;
@@ -23,6 +24,22 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                     typePath: typeDeclarationPath,
                 });
                 methods.set(fileName, variables);
+                // Extract singleton services for CreateSessionServices factories
+                if (expectedTypeName === 'CreateSessionServices' &&
+                    state &&
+                    node.initializer) {
+                    let functionNode;
+                    if (ts.isArrowFunction(node.initializer)) {
+                        functionNode = node.initializer;
+                    }
+                    else if (ts.isFunctionExpression(node.initializer)) {
+                        functionNode = node.initializer;
+                    }
+                    if (functionNode) {
+                        const servicesMeta = extractServicesFromFunction(functionNode);
+                        state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                    }
+                }
             }
             // Handle qualified type names if necessary
             else if (ts.isQualifiedName(typeNameNode)) {
@@ -41,6 +58,22 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         typePath: typeDeclarationPath,
                     });
                     methods.set(fileName, variables);
+                    // Extract singleton services for CreateSessionServices factories
+                    if (expectedTypeName === 'CreateSessionServices' &&
+                        state &&
+                        node.initializer) {
+                        let functionNode;
+                        if (ts.isArrowFunction(node.initializer)) {
+                            functionNode = node.initializer;
+                        }
+                        else if (ts.isFunctionExpression(node.initializer)) {
+                            functionNode = node.initializer;
+                        }
+                        if (functionNode) {
+                            const servicesMeta = extractServicesFromFunction(functionNode);
+                            state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                        }
+                    }
                 }
             }
         }