@pikku/inspector 0.11.1 → 0.12.0

package/src/add/add-middleware.ts

@@ -1,28 +1,53 @@
 import * as ts from 'typescript'
-import { AddWiring } from '../types.js'
+import type { AddWiring, InspectorState } from '../types.js'
 import {
   extractFunctionName,
   isNamedExport,
+  makeContextBasedId,
 } from '../utils/extract-function-name.js'
-import { extractServicesFromFunction } from '../utils/extract-services.js'
-import { extractMiddlewarePikkuNames } from '../utils/middleware.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: InspectorState,
+  definitionIds: string[],
+  groupType: string,
+  groupKey: string,
+  storeKey: 'middleware' | 'channelMiddleware' = 'middleware'
+): void {
+  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: AddWiring = (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) return
@@ -31,15 +56,12 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
     let name: string | undefined
     let description: string | undefined
 
-    // 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',
@@ -64,13 +86,34 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
     }
 
     const services = extractServicesFromFunction(actualHandler)
-    const { pikkuFuncName, exportedName } = extractFunctionName(
+    const wires = extractUsedWires(actualHandler, 1)
+    let { pikkuFuncId, exportedName } = extractFunctionName(
       node,
       checker,
       state.rootDir
     )
-    state.middleware.meta[pikkuFuncName] = {
+    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,
@@ -84,7 +127,6 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
     return
   }
 
-  // Handle pikkuMiddlewareFactory(...) - middleware factory function
   if (expression.text === 'pikkuMiddlewareFactory') {
     const factoryNode = args[0]
     if (!factoryNode) return
@@ -97,10 +139,13 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       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: [] as string[] }
+    let wires: ReturnType<typeof extractUsedWires> = {
+      optimized: true,
+      wires: [],
+    }
+    let name: string | undefined
+    let description: string | undefined
 
     const findPikkuMiddlewareCall = (
       node: ts.Node
@@ -116,61 +161,96 @@ export const addMiddleware: AddWiring = (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)
+      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(middlewareHandler)
+        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(
+    let { pikkuFuncId, exportedName } = extractFunctionName(
       node,
       checker,
       state.rootDir
     )
-    state.middleware.meta[pikkuFuncName] = {
+    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(', ')}`
+      `• 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: string | undefined
     if (ts.isStringLiteral(tagArg)) {
       tag = tagArg.text
@@ -181,7 +261,6 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       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`
@@ -189,47 +268,54 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       return
     }
 
-    // Extract middleware pikkuFuncNames from array
-    const middlewareNames = extractMiddlewarePikkuNames(
+    const refs = extractMiddlewareRefs(
       middlewareArrayArg,
       checker,
       state.rootDir
     )
 
-    if (middlewareNames.length === 0) {
+    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: string[] = []
+    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<string>()
-    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: string | null = 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
             }
@@ -238,13 +324,11 @@ export const addMiddleware: AddWiring = (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. ` +
@@ -252,36 +336,31 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       )
     }
 
-    // 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'})`
+      `• 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: string | undefined
     if (ts.isStringLiteral(patternArg)) {
       pattern = patternArg.text
@@ -292,7 +371,6 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       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`
@@ -300,48 +378,56 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       return
     }
 
-    // Extract middleware pikkuFuncNames from array
-    const middlewareNames = extractMiddlewarePikkuNames(
+    const refs = extractMiddlewareRefs(
       middlewareArrayArg,
       checker,
       state.rootDir
     )
 
-    if (middlewareNames.length === 0) {
+    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: string[] = []
+    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<string>()
-    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: string | null = 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
             }
@@ -350,13 +436,11 @@ export const addMiddleware: AddWiring = (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. ` +
@@ -364,21 +448,339 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       )
     }
 
-    // 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: ts.ArrowFunction | ts.FunctionExpression
+
+    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: [] as string[] }
+
+    const findPikkuChannelMiddlewareCall = (
+      n: ts.Node
+    ): ts.CallExpression | undefined => {
+      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<string>()
+    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: string | undefined
+    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: string[] = []
+    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<string>()
+    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: string | null = 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'})`
+      `• Found tag channel middleware group: ${tag} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`
     )
     return
   }