@pikku/inspector 0.12.75 → 0.12.81

package/src/add/add-middleware.ts

@@ -1,879 +0,0 @@
-import * as ts from 'typescript'
-import type {
-  AddWiring,
-  InspectorState,
-  MiddlewareGroupMeta,
-} from '../types.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'
-
-/**
- * Record a middleware group, keeping any registration already stored under the
- * same pattern or tag.
- *
- * Several files may add middleware for one pattern — an app's own `'*'` group
- * alongside the generated better-auth session bridge, say — and the runtime
- * composes them. A plain `set` kept only the last, and codegen emits imports
- * from what is stored, so the other file was never imported and its middleware
- * silently stopped running. Merging is the only shape that cannot lose a gate;
- * the first registration stays primary so single-registration groups serialize
- * exactly as before.
- */
-function recordMiddlewareGroup(
-  groups: Map<string, MiddlewareGroupMeta>,
-  key: string,
-  group: MiddlewareGroupMeta
-): void {
-  const existing = groups.get(key)
-  if (!existing) {
-    groups.set(key, group)
-    return
-  }
-
-  // The same call seen twice — the inspector may revisit a file — is not a
-  // second registration, and appending it would emit a duplicate import.
-  const alreadyRecorded = [
-    existing,
-    ...(existing.additionalRegistrations ?? []),
-  ]
-  if (
-    alreadyRecorded.some(
-      (r) => r.sourceFile === group.sourceFile && r.position === group.position
-    )
-  ) {
-    return
-  }
-
-  existing.additionalRegistrations = [
-    ...(existing.additionalRegistrations ?? []),
-    {
-      exportName: group.exportName,
-      sourceFile: group.sourceFile,
-      position: group.position,
-      isFactory: group.isFactory,
-    },
-  ]
-  existing.count += group.count
-  existing.instanceIds = [...existing.instanceIds, ...group.instanceIds]
-  existing.services = {
-    optimized: false,
-    services: Array.from(
-      new Set([...existing.services.services, ...group.services.services])
-    ),
-  }
-}
-
-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
-
-  if (!ts.isIdentifier(expression)) {
-    return
-  }
-
-  if (expression.text === 'pikkuMiddleware') {
-    const arg = args[0]
-    if (!arg) return
-
-    let actualHandler: ts.ArrowFunction | ts.FunctionExpression
-    let name: string | undefined
-    let description: string | undefined
-
-    if (ts.isObjectLiteralExpression(arg)) {
-      const nameValue = getPropertyValue(arg, 'name')
-      const descValue = getPropertyValue(arg, 'description')
-      name = typeof nameValue === 'string' ? nameValue : undefined
-      description = typeof descValue === 'string' ? descValue : undefined
-
-      const fnProp = getPropertyAssignmentInitializer(
-        arg,
-        'func',
-        true,
-        checker
-      )
-      if (
-        !fnProp ||
-        (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))
-      ) {
-        logger.error(
-          `• pikkuMiddleware object missing required 'func' property.`
-        )
-        return
-      }
-      actualHandler = fnProp
-    } else if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
-      actualHandler = arg
-    } else {
-      logger.error(`• Handler for pikkuMiddleware is not a function.`)
-      return
-    }
-
-    const services = extractServicesFromFunction(actualHandler)
-    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,
-      name,
-      description,
-    }
-
-    logger.debug(
-      `• Found middleware with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`
-    )
-    return
-  }
-
-  if (expression.text === 'pikkuMiddlewareFactory') {
-    const factoryNode = args[0]
-    if (!factoryNode) return
-
-    if (
-      !ts.isArrowFunction(factoryNode) &&
-      !ts.isFunctionExpression(factoryNode)
-    ) {
-      logger.error(`• Handler for pikkuMiddlewareFactory is not a function.`)
-      return
-    }
-
-    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
-    ): ts.CallExpression | undefined => {
-      if (ts.isCallExpression(node)) {
-        const expr = node.expression
-        if (ts.isIdentifier(expr) && expr.text === 'pikkuMiddleware') {
-          return node
-        }
-      }
-      return ts.forEachChild(node, findPikkuMiddlewareCall)
-    }
-
-    const pikkuMiddlewareCall = findPikkuMiddlewareCall(factoryNode)
-    if (pikkuMiddlewareCall && pikkuMiddlewareCall.arguments[0]) {
-      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 {
-      if (
-        ts.isArrowFunction(factoryNode) ||
-        ts.isFunctionExpression(factoryNode)
-      ) {
-        const factoryBody = factoryNode.body
-        if (
-          ts.isArrowFunction(factoryBody) ||
-          ts.isFunctionExpression(factoryBody)
-        ) {
-          services = extractServicesFromFunction(factoryBody)
-          wires = extractUsedWires(factoryBody, 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(
-          `• 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(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`
-    )
-    return
-  }
-
-  if (expression.text === 'addTagMiddleware') {
-    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(`• addTagMiddleware call without valid tag string`)
-      return
-    }
-
-    if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
-      logger.error(
-        `• addTagMiddleware('${tag}', ...) must have a literal array as second argument`
-      )
-      return
-    }
-
-    const refs = extractMiddlewareRefs(
-      middlewareArrayArg,
-      checker,
-      state.rootDir
-    )
-
-    const definitionIds = refs.map((r) => r.definitionId)
-    if (definitionIds.length > 0) {
-      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 defId of definitionIds) {
-      const def = state.middleware.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(
-        `• Middleware group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
-          `For tree-shaking, use: export const ${exportedName} = () => addTagMiddleware('${tag}', [...])`
-      )
-    }
-
-    recordMiddlewareGroup(state.middleware.tagMiddleware, tag, {
-      exportName: exportedName,
-      sourceFile,
-      position: node.getStart(),
-      services: {
-        optimized: false,
-        services: Array.from(allServices),
-      },
-      count: refs.length,
-      instanceIds,
-      isFactory,
-    })
-
-    logger.debug(
-      `• Found tag middleware group: ${tag} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`
-    )
-    return
-  }
-
-  if (expression.text === 'addGlobalMiddleware') {
-    const middlewareArrayArg = args[0]
-    if (
-      !middlewareArrayArg ||
-      !ts.isArrayLiteralExpression(middlewareArrayArg)
-    ) {
-      logger.error(
-        `• addGlobalMiddleware(...) must have a literal array as its only argument`
-      )
-      return
-    }
-    const refs = extractMiddlewareRefs(
-      middlewareArrayArg,
-      checker,
-      state.rootDir
-    )
-    const definitionIds = refs.map((r) => r.definitionId)
-    if (definitionIds.length > 0) {
-      renameTempDefinitions(state, definitionIds, 'global', 'middleware')
-    }
-    const sourceFile = node.getSourceFile().fileName
-    for (let i = 0; i < refs.length; i++) {
-      const instanceId = makeContextBasedId('global', 'middleware', String(i))
-      state.middleware.instances[instanceId] = {
-        definitionId: definitionIds[i],
-        sourceFile,
-        position: node.getStart(),
-        isFactoryCall: refs[i].isFactoryCall,
-      }
-    }
-    // Without this, bootstrap codegen's "import every file with a wire-call"
-    // pass skips middleware-only files and the registration never runs.
-    state.http.files.add(sourceFile)
-    logger.debug(`• Found global middleware group with ${refs.length} entries`)
-    return
-  }
-
-  if (expression.text === 'addHTTPMiddleware') {
-    const patternArg = args[0]
-    const middlewareArrayArg = args[1]
-
-    if (!patternArg || !middlewareArrayArg) return
-
-    let pattern: string | undefined
-    if (ts.isStringLiteral(patternArg)) {
-      pattern = patternArg.text
-    }
-
-    if (!pattern) {
-      logger.warn(`• addHTTPMiddleware call without valid pattern string`)
-      return
-    }
-
-    if (!ts.isArrayLiteralExpression(middlewareArrayArg)) {
-      logger.error(
-        `• addHTTPMiddleware('${pattern}', ...) must have a literal array as second argument`
-      )
-      return
-    }
-
-    const refs = extractMiddlewareRefs(
-      middlewareArrayArg,
-      checker,
-      state.rootDir
-    )
-
-    const definitionIds = refs.map((r) => r.definitionId)
-    if (definitionIds.length > 0) {
-      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 defId of definitionIds) {
-      const def = state.middleware.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(
-        `• HTTP middleware group '${exportedName}' for pattern '${pattern}' is not wrapped in a factory function. ` +
-          `For tree-shaking, use: export const ${exportedName} = () => addHTTPMiddleware('${pattern}', [...])`
-      )
-    }
-
-    recordMiddlewareGroup(state.http.routeMiddleware, pattern, {
-      exportName: exportedName,
-      sourceFile,
-      position: node.getStart(),
-      services: {
-        optimized: false,
-        services: Array.from(allServices),
-      },
-      count: refs.length,
-      instanceIds,
-      isFactory,
-    })
-    state.http.files.add(sourceFile)
-
-    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 === 'pikkuAgentMiddleware') {
-    const arg = args[0]
-    if (!arg) return
-
-    if (!ts.isObjectLiteralExpression(arg)) {
-      logger.error(
-        `• pikkuAgentMiddleware() 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(
-          `• pikkuAgentMiddleware() must be assigned to a variable or object property. ` +
-            `Extract it to a const: const myMiddleware = pikkuAgentMiddleware(...)`
-        )
-        return
-      }
-    }
-    state.agentMiddleware.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}', [...])`
-      )
-    }
-
-    recordMiddlewareGroup(state.channelMiddleware.tagMiddleware, tag, {
-      exportName: exportedName,
-      sourceFile,
-      position: node.getStart(),
-      services: {
-        optimized: false,
-        services: Array.from(allServices),
-      },
-      count: refs.length,
-      instanceIds,
-      isFactory,
-    })
-
-    logger.debug(
-      `• Found tag channel middleware group: ${tag} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`
-    )
-    return
-  }
-}