@pikku/inspector 0.11.1 → 0.12.0

package/dist/add/add-middleware.js

@@ -1,21 +1,33 @@
 import * as ts from 'typescript';
-import { extractFunctionName, isNamedExport, } from '../utils/extract-function-name.js';
-import { extractServicesFromFunction } from '../utils/extract-services.js';
-import { extractMiddlewarePikkuNames } from '../utils/middleware.js';
+import { extractFunctionName, isNamedExport, makeContextBasedId, } from '../utils/extract-function-name.js';
+import { extractServicesFromFunction, extractUsedWires, } from '../utils/extract-services.js';
+import { extractMiddlewareRefs } from '../utils/middleware.js';
 import { getPropertyValue } from '../utils/get-property-value.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-/**
- * Inspect pikkuMiddleware calls, addMiddleware calls, and addHTTPMiddleware calls
- */
+function renameTempDefinitions(state, definitionIds, groupType, groupKey, storeKey = 'middleware') {
+    const tempIndices = definitionIds
+        .map((name, i) => (name.startsWith('__temp_') ? i : -1))
+        .filter((i) => i >= 0);
+    for (const idx of tempIndices) {
+        const oldId = definitionIds[idx];
+        const newId = tempIndices.length === 1
+            ? makeContextBasedId(groupType, groupKey)
+            : makeContextBasedId(groupType, groupKey, String(idx));
+        const existing = state[storeKey].definitions[oldId];
+        if (existing) {
+            delete state[storeKey].definitions[oldId];
+            state[storeKey].definitions[newId] = existing;
+        }
+        definitionIds[idx] = newId;
+    }
+}
 export const addMiddleware = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args } = node;
-    // only handle specific function calls
     if (!ts.isIdentifier(expression)) {
         return;
     }
-    // Handle pikkuMiddleware(...) - individual middleware function definition
     if (expression.text === 'pikkuMiddleware') {
         const arg = args[0];
         if (!arg)
@@ -23,14 +35,11 @@ export const addMiddleware = (logger, node, checker, state) => {
         let actualHandler;
         let name;
         let description;
-        // Check if using object syntax: pikkuMiddleware({ func: ..., name: '...', description: '...' })
         if (ts.isObjectLiteralExpression(arg)) {
-            // Extract name and description metadata
             const nameValue = getPropertyValue(arg, 'name');
             const descValue = getPropertyValue(arg, 'description');
             name = typeof nameValue === 'string' ? nameValue : undefined;
             description = typeof descValue === 'string' ? descValue : undefined;
-            // Extract the func property
             const fnProp = getPropertyAssignmentInitializer(arg, 'func', true, checker);
             if (!fnProp ||
                 (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
@@ -47,9 +56,26 @@ export const addMiddleware = (logger, node, checker, state) => {
             return;
         }
         const services = extractServicesFromFunction(actualHandler);
-        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
-        state.middleware.meta[pikkuFuncName] = {
+        const wires = extractUsedWires(actualHandler, 1);
+        let { pikkuFuncId, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        if (pikkuFuncId.startsWith('__temp_')) {
+            if (ts.isVariableDeclaration(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else if (ts.isPropertyAssignment(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else {
+                logger.error(`• pikkuMiddleware() must be assigned to a variable or object property. ` +
+                    `Extract it to a const: const myMiddleware = pikkuMiddleware(...)`);
+                return;
+            }
+        }
+        state.middleware.definitions[pikkuFuncId] = {
             services,
+            wires: wires.wires.length > 0 || !wires.optimized ? wires : undefined,
             sourceFile: node.getSourceFile().fileName,
             position: node.getStart(),
             exportedName,
@@ -59,7 +85,6 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found middleware with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
         return;
     }
-    // Handle pikkuMiddlewareFactory(...) - middleware factory function
     if (expression.text === 'pikkuMiddlewareFactory') {
         const factoryNode = args[0];
         if (!factoryNode)
@@ -69,10 +94,13 @@ export const addMiddleware = (logger, node, checker, state) => {
             logger.error(`• Handler for pikkuMiddlewareFactory is not a function.`);
             return;
         }
-        // Extract services by looking inside the factory function body
-        // The factory should return pikkuMiddleware(...), so we need to find that call
-        // If no wrapper is found, extract from the factory's returned function directly
         let services = { optimized: false, services: [] };
+        let wires = {
+            optimized: true,
+            wires: [],
+        };
+        let name;
+        let description;
         const findPikkuMiddlewareCall = (node) => {
             if (ts.isCallExpression(node)) {
                 const expr = node.expression;
@@ -84,46 +112,70 @@ export const addMiddleware = (logger, node, checker, state) => {
         };
         const pikkuMiddlewareCall = findPikkuMiddlewareCall(factoryNode);
         if (pikkuMiddlewareCall && pikkuMiddlewareCall.arguments[0]) {
-            const middlewareHandler = pikkuMiddlewareCall.arguments[0];
-            if (ts.isArrowFunction(middlewareHandler) ||
-                ts.isFunctionExpression(middlewareHandler)) {
-                services = extractServicesFromFunction(middlewareHandler);
+            const middlewareArg = pikkuMiddlewareCall.arguments[0];
+            if (ts.isObjectLiteralExpression(middlewareArg)) {
+                const nameValue = getPropertyValue(middlewareArg, 'name');
+                const descValue = getPropertyValue(middlewareArg, 'description');
+                name = typeof nameValue === 'string' ? nameValue : undefined;
+                description = typeof descValue === 'string' ? descValue : undefined;
+                const fnProp = getPropertyAssignmentInitializer(middlewareArg, 'func', true, checker);
+                if (fnProp &&
+                    (ts.isArrowFunction(fnProp) || ts.isFunctionExpression(fnProp))) {
+                    services = extractServicesFromFunction(fnProp);
+                    wires = extractUsedWires(fnProp, 1);
+                }
+            }
+            else if (ts.isArrowFunction(middlewareArg) ||
+                ts.isFunctionExpression(middlewareArg)) {
+                services = extractServicesFromFunction(middlewareArg);
+                wires = extractUsedWires(middlewareArg, 1);
             }
         }
         else {
-            // No pikkuMiddleware wrapper found - extract from factory's return value directly
-            // Factory pattern: (config) => (services, wire, next) => { ... }
             if (ts.isArrowFunction(factoryNode) ||
                 ts.isFunctionExpression(factoryNode)) {
                 const factoryBody = factoryNode.body;
-                // Check if the body is an arrow function (direct return)
                 if (ts.isArrowFunction(factoryBody) ||
                     ts.isFunctionExpression(factoryBody)) {
                     services = extractServicesFromFunction(factoryBody);
+                    wires = extractUsedWires(factoryBody, 1);
                 }
             }
         }
-        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
-        state.middleware.meta[pikkuFuncName] = {
+        let { pikkuFuncId, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        if (pikkuFuncId.startsWith('__temp_')) {
+            if (ts.isVariableDeclaration(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else if (ts.isPropertyAssignment(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else {
+                logger.error(`• pikkuMiddlewareFactory() must be assigned to a variable or object property. ` +
+                    `Extract it to a const: const myMiddleware = pikkuMiddlewareFactory(...)`);
+                return;
+            }
+        }
+        state.middleware.definitions[pikkuFuncId] = {
             services,
+            wires: wires.wires.length > 0 || !wires.optimized ? wires : undefined,
             sourceFile: node.getSourceFile().fileName,
             position: node.getStart(),
             exportedName,
             factory: true,
+            name,
+            description,
         };
-        logger.debug(`• Found middleware factory with services: ${services.services.join(', ')}`);
+        logger.debug(`• Found middleware factory with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
         return;
     }
-    // Handle addMiddleware('tag', [middleware1, middleware2])
-    // Supports two patterns:
-    // 1. export const x = () => addMiddleware('tag', [...])  (factory - tree-shakeable)
-    // 2. export const x = addMiddleware('tag', [...])  (direct - no tree-shaking)
     if (expression.text === 'addMiddleware') {
         const tagArg = args[0];
         const middlewareArrayArg = args[1];
         if (!tagArg || !middlewareArrayArg)
             return;
-        // Extract tag name
         let tag;
         if (ts.isStringLiteral(tagArg)) {
             tag = tagArg.text;
@@ -132,43 +184,47 @@ export const addMiddleware = (logger, node, checker, state) => {
             logger.warn(`• addMiddleware call without valid tag string`);
             return;
         }
-        // Check if middleware array is a literal array
         if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
             logger.error(`• addMiddleware('${tag}', ...) must have a literal array as second argument`);
             return;
         }
-        // Extract middleware pikkuFuncNames from array
-        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker, state.rootDir);
-        if (middlewareNames.length === 0) {
+        const refs = extractMiddlewareRefs(middlewareArrayArg, checker, state.rootDir);
+        if (refs.length === 0) {
             logger.warn(`• addMiddleware('${tag}', ...) has empty middleware array`);
             return;
         }
-        // Collect services from all middleware in the group
+        const definitionIds = refs.map((r) => r.definitionId);
+        renameTempDefinitions(state, definitionIds, 'tag', tag);
+        const sourceFile = node.getSourceFile().fileName;
+        const instanceIds = [];
+        for (let i = 0; i < refs.length; i++) {
+            const instanceId = makeContextBasedId('tag', tag, String(i));
+            state.middleware.instances[instanceId] = {
+                definitionId: definitionIds[i],
+                sourceFile,
+                position: node.getStart(),
+                isFactoryCall: refs[i].isFactoryCall,
+            };
+            instanceIds.push(instanceId);
+        }
         const allServices = new Set();
-        for (const middlewareName of middlewareNames) {
-            const middlewareMeta = state.middleware.meta[middlewareName];
-            if (middlewareMeta && middlewareMeta.services) {
-                for (const service of middlewareMeta.services.services) {
+        for (const defId of definitionIds) {
+            const def = state.middleware.definitions[defId];
+            if (def?.services) {
+                for (const service of def.services.services) {
                     allServices.add(service);
                 }
             }
         }
-        // Check if this call is wrapped in a factory function
-        // We need to walk up the tree to see if the parent is: const x = () => addMiddleware(...)
         let isFactory = false;
         let exportedName = null;
         let parent = node.parent;
-        // Check if parent is arrow function: () => addMiddleware(...)
         if (parent && ts.isArrowFunction(parent)) {
-            // Check if arrow function has no parameters
             if (parent.parameters.length === 0) {
                 isFactory = true;
-                // For factories, we need to check the arrow function's parent for the export name
-                // const apiTagMiddleware = () => addMiddleware(...)
                 const arrowParent = parent.parent;
                 if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
                     if (ts.isIdentifier(arrowParent.name)) {
-                        // Check if it's exported
                         if (isNamedExport(arrowParent)) {
                             exportedName = arrowParent.name.text;
                         }
@@ -176,41 +232,34 @@ export const addMiddleware = (logger, node, checker, state) => {
                 }
             }
         }
-        // If not a factory, get export name from the call expression itself
         if (!isFactory) {
             const extracted = extractFunctionName(node, checker, state.rootDir);
             exportedName = extracted.exportedName;
         }
-        // Log warning if not using factory pattern
         if (!isFactory && exportedName) {
             logger.warn(`• Middleware group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
                 `For tree-shaking, use: export const ${exportedName} = () => addMiddleware('${tag}', [...])`);
         }
-        // Store group metadata
         state.middleware.tagMiddleware.set(tag, {
             exportName: exportedName,
-            sourceFile: node.getSourceFile().fileName,
+            sourceFile,
             position: node.getStart(),
             services: {
                 optimized: false,
                 services: Array.from(allServices),
             },
-            middlewareCount: middlewareNames.length,
+            count: refs.length,
+            instanceIds,
             isFactory,
         });
-        logger.debug(`• Found tag middleware group: ${tag} -> [${middlewareNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
+        logger.debug(`• Found tag middleware group: ${tag} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
         return;
     }
-    // Handle addHTTPMiddleware(pattern, [middleware1, middleware2])
-    // Supports two patterns:
-    // 1. export const x = () => addHTTPMiddleware('*', [...])  (factory - tree-shakeable)
-    // 2. export const x = addHTTPMiddleware('*', [...])  (direct - no tree-shaking)
     if (expression.text === 'addHTTPMiddleware') {
         const patternArg = args[0];
         const middlewareArrayArg = args[1];
         if (!patternArg || !middlewareArrayArg)
             return;
-        // Extract route pattern
         let pattern;
         if (ts.isStringLiteral(patternArg)) {
             pattern = patternArg.text;
@@ -219,42 +268,47 @@ export const addMiddleware = (logger, node, checker, state) => {
             logger.warn(`• addHTTPMiddleware call without valid pattern string`);
             return;
         }
-        // Check if middleware array is a literal array
         if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
             logger.error(`• addHTTPMiddleware('${pattern}', ...) must have a literal array as second argument`);
             return;
         }
-        // Extract middleware pikkuFuncNames from array
-        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker, state.rootDir);
-        if (middlewareNames.length === 0) {
+        const refs = extractMiddlewareRefs(middlewareArrayArg, checker, state.rootDir);
+        if (refs.length === 0) {
             logger.warn(`• addHTTPMiddleware('${pattern}', ...) has empty middleware array`);
             return;
         }
-        // Collect services from all middleware in the group
+        const definitionIds = refs.map((r) => r.definitionId);
+        renameTempDefinitions(state, definitionIds, 'http', pattern);
+        const sourceFile = node.getSourceFile().fileName;
+        const instanceIds = [];
+        for (let i = 0; i < refs.length; i++) {
+            const instanceId = makeContextBasedId('http', pattern, String(i));
+            state.middleware.instances[instanceId] = {
+                definitionId: definitionIds[i],
+                sourceFile,
+                position: node.getStart(),
+                isFactoryCall: refs[i].isFactoryCall,
+            };
+            instanceIds.push(instanceId);
+        }
         const allServices = new Set();
-        for (const middlewareName of middlewareNames) {
-            const middlewareMeta = state.middleware.meta[middlewareName];
-            if (middlewareMeta && middlewareMeta.services) {
-                for (const service of middlewareMeta.services.services) {
+        for (const defId of definitionIds) {
+            const def = state.middleware.definitions[defId];
+            if (def?.services) {
+                for (const service of def.services.services) {
                     allServices.add(service);
                 }
             }
         }
-        // Check if this call is wrapped in a factory function
         let isFactory = false;
         let exportedName = null;
         let parent = node.parent;
-        // Check if parent is arrow function: () => addHTTPMiddleware(...)
         if (parent && ts.isArrowFunction(parent)) {
-            // Check if arrow function has no parameters
             if (parent.parameters.length === 0) {
                 isFactory = true;
-                // For factories, we need to check the arrow function's parent for the export name
-                // const apiRouteMiddleware = () => addHTTPMiddleware(...)
                 const arrowParent = parent.parent;
                 if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
                     if (ts.isIdentifier(arrowParent.name)) {
-                        // Check if it's exported
                         if (isNamedExport(arrowParent)) {
                             exportedName = arrowParent.name.text;
                         }
@@ -262,29 +316,260 @@ export const addMiddleware = (logger, node, checker, state) => {
                 }
             }
         }
-        // If not a factory, get export name from the call expression itself
         if (!isFactory) {
             const extracted = extractFunctionName(node, checker, state.rootDir);
             exportedName = extracted.exportedName;
         }
-        // Log warning if not using factory pattern
         if (!isFactory && exportedName) {
             logger.warn(`• HTTP middleware group '${exportedName}' for pattern '${pattern}' is not wrapped in a factory function. ` +
                 `For tree-shaking, use: export const ${exportedName} = () => addHTTPMiddleware('${pattern}', [...])`);
         }
-        // Store group metadata
         state.http.routeMiddleware.set(pattern, {
             exportName: exportedName,
+            sourceFile,
+            position: node.getStart(),
+            services: {
+                optimized: false,
+                services: Array.from(allServices),
+            },
+            count: refs.length,
+            instanceIds,
+            isFactory,
+        });
+        logger.debug(`• Found HTTP route middleware group: ${pattern} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
+        return;
+    }
+    if (expression.text === 'pikkuChannelMiddleware') {
+        const arg = args[0];
+        if (!arg)
+            return;
+        let actualHandler;
+        if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+            actualHandler = arg;
+        }
+        else {
+            logger.error(`• Handler for pikkuChannelMiddleware is not a function.`);
+            return;
+        }
+        const services = extractServicesFromFunction(actualHandler);
+        let { pikkuFuncId, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        if (pikkuFuncId.startsWith('__temp_')) {
+            if (ts.isVariableDeclaration(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else if (ts.isPropertyAssignment(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else {
+                logger.error(`• pikkuChannelMiddleware() must be assigned to a variable or object property. ` +
+                    `Extract it to a const: const myMiddleware = pikkuChannelMiddleware(...)`);
+                return;
+            }
+        }
+        state.channelMiddleware.definitions[pikkuFuncId] = {
+            services,
             sourceFile: node.getSourceFile().fileName,
             position: node.getStart(),
+            exportedName,
+        };
+        logger.debug(`• Found channel middleware with services: ${services.services.join(', ')}`);
+        return;
+    }
+    if (expression.text === 'pikkuChannelMiddlewareFactory') {
+        const factoryNode = args[0];
+        if (!factoryNode)
+            return;
+        if (!ts.isArrowFunction(factoryNode) &&
+            !ts.isFunctionExpression(factoryNode)) {
+            logger.error(`• Handler for pikkuChannelMiddlewareFactory is not a function.`);
+            return;
+        }
+        let services = { optimized: false, services: [] };
+        const findPikkuChannelMiddlewareCall = (n) => {
+            if (ts.isCallExpression(n)) {
+                const expr = n.expression;
+                if (ts.isIdentifier(expr) && expr.text === 'pikkuChannelMiddleware') {
+                    return n;
+                }
+            }
+            return ts.forEachChild(n, findPikkuChannelMiddlewareCall);
+        };
+        const channelMiddlewareCall = findPikkuChannelMiddlewareCall(factoryNode);
+        if (channelMiddlewareCall && channelMiddlewareCall.arguments[0]) {
+            const middlewareHandler = channelMiddlewareCall.arguments[0];
+            if (ts.isArrowFunction(middlewareHandler) ||
+                ts.isFunctionExpression(middlewareHandler)) {
+                services = extractServicesFromFunction(middlewareHandler);
+            }
+        }
+        else {
+            if (ts.isArrowFunction(factoryNode) ||
+                ts.isFunctionExpression(factoryNode)) {
+                const factoryBody = factoryNode.body;
+                if (ts.isArrowFunction(factoryBody) ||
+                    ts.isFunctionExpression(factoryBody)) {
+                    services = extractServicesFromFunction(factoryBody);
+                }
+            }
+        }
+        let { pikkuFuncId, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        if (pikkuFuncId.startsWith('__temp_')) {
+            if (ts.isVariableDeclaration(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else if (ts.isPropertyAssignment(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else {
+                logger.error(`• pikkuChannelMiddlewareFactory() must be assigned to a variable or object property. ` +
+                    `Extract it to a const: const myMiddleware = pikkuChannelMiddlewareFactory(...)`);
+                return;
+            }
+        }
+        state.channelMiddleware.definitions[pikkuFuncId] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+            factory: true,
+        };
+        logger.debug(`• Found channel middleware factory with services: ${services.services.join(', ')}`);
+        return;
+    }
+    if (expression.text === 'pikkuAIMiddleware') {
+        const arg = args[0];
+        if (!arg)
+            return;
+        if (!ts.isObjectLiteralExpression(arg)) {
+            logger.error(`• pikkuAIMiddleware() requires an object literal argument.`);
+            return;
+        }
+        const allServices = new Set();
+        for (const prop of arg.properties) {
+            if (ts.isPropertyAssignment(prop) &&
+                (ts.isArrowFunction(prop.initializer) ||
+                    ts.isFunctionExpression(prop.initializer))) {
+                const hookServices = extractServicesFromFunction(prop.initializer);
+                for (const s of hookServices.services) {
+                    allServices.add(s);
+                }
+            }
+        }
+        const services = {
+            optimized: allServices.size > 0,
+            services: Array.from(allServices),
+        };
+        let { pikkuFuncId, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        if (pikkuFuncId.startsWith('__temp_')) {
+            if (ts.isVariableDeclaration(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else if (ts.isPropertyAssignment(node.parent) &&
+                ts.isIdentifier(node.parent.name)) {
+                pikkuFuncId = node.parent.name.text;
+            }
+            else {
+                logger.error(`• pikkuAIMiddleware() must be assigned to a variable or object property. ` +
+                    `Extract it to a const: const myMiddleware = pikkuAIMiddleware(...)`);
+                return;
+            }
+        }
+        state.aiMiddleware.definitions[pikkuFuncId] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+        };
+        logger.debug(`• Found AI middleware with services: ${services.services.join(', ')}`);
+        return;
+    }
+    if (expression.text === 'addChannelMiddleware') {
+        const tagArg = args[0];
+        const middlewareArrayArg = args[1];
+        if (!tagArg || !middlewareArrayArg)
+            return;
+        let tag;
+        if (ts.isStringLiteral(tagArg)) {
+            tag = tagArg.text;
+        }
+        if (!tag) {
+            logger.warn(`• addChannelMiddleware call without valid tag string`);
+            return;
+        }
+        if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
+            logger.error(`• addChannelMiddleware('${tag}', ...) must have a literal array as second argument`);
+            return;
+        }
+        const refs = extractMiddlewareRefs(middlewareArrayArg, checker, state.rootDir);
+        if (refs.length === 0) {
+            logger.warn(`• addChannelMiddleware('${tag}', ...) has empty middleware array`);
+            return;
+        }
+        const definitionIds = refs.map((r) => r.definitionId);
+        renameTempDefinitions(state, definitionIds, 'tag', tag, 'channelMiddleware');
+        const sourceFile = node.getSourceFile().fileName;
+        const instanceIds = [];
+        for (let i = 0; i < refs.length; i++) {
+            const instanceId = makeContextBasedId('tag', tag, String(i));
+            state.channelMiddleware.instances[instanceId] = {
+                definitionId: definitionIds[i],
+                sourceFile,
+                position: node.getStart(),
+                isFactoryCall: refs[i].isFactoryCall,
+            };
+            instanceIds.push(instanceId);
+        }
+        const allServices = new Set();
+        for (const defId of definitionIds) {
+            const def = state.channelMiddleware.definitions[defId];
+            if (def?.services) {
+                for (const service of def.services.services) {
+                    allServices.add(service);
+                }
+            }
+        }
+        let isFactory = false;
+        let exportedName = null;
+        let parent = node.parent;
+        if (parent && ts.isArrowFunction(parent)) {
+            if (parent.parameters.length === 0) {
+                isFactory = true;
+                const arrowParent = parent.parent;
+                if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
+                    if (ts.isIdentifier(arrowParent.name)) {
+                        if (isNamedExport(arrowParent)) {
+                            exportedName = arrowParent.name.text;
+                        }
+                    }
+                }
+            }
+        }
+        if (!isFactory) {
+            const extracted = extractFunctionName(node, checker, state.rootDir);
+            exportedName = extracted.exportedName;
+        }
+        if (!isFactory && exportedName) {
+            logger.warn(`• Channel middleware group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
+                `For tree-shaking, use: export const ${exportedName} = () => addChannelMiddleware('${tag}', [...])`);
+        }
+        state.channelMiddleware.tagMiddleware.set(tag, {
+            exportName: exportedName,
+            sourceFile,
+            position: node.getStart(),
             services: {
                 optimized: false,
                 services: Array.from(allServices),
             },
-            middlewareCount: middlewareNames.length,
+            count: refs.length,
+            instanceIds,
             isFactory,
         });
-        logger.debug(`• Found HTTP route middleware group: ${pattern} -> [${middlewareNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
+        logger.debug(`• Found tag channel middleware group: ${tag} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
         return;
     }
 };

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

@@ -1,4 +1,4 @@
-import { AddWiring } from '../types.js';
+import type { AddWiring } from '../types.js';
 /**
  * Inspect pikkuPermission calls, addPermission calls, and addHTTPPermission calls
  */