cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/route-extractors/laravel.js

@@ -0,0 +1,501 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLaravelRoutes = extractLaravelRoutes;
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const import_decomposer_js_1 = require("../languages/php/import-decomposer.js");
+const qualified_name_js_1 = require("../utils/qualified-name.js");
+const ROUTE_HTTP_METHODS = new Set([
+    'get',
+    'post',
+    'put',
+    'patch',
+    'delete',
+    'options',
+    'any',
+    'match',
+]);
+const ROUTE_RESOURCE_METHODS = new Set(['resource', 'apiResource']);
+const RESOURCE_ACTIONS = ['index', 'create', 'store', 'show', 'edit', 'update', 'destroy'];
+const API_RESOURCE_ACTIONS = ['index', 'store', 'show', 'update', 'destroy'];
+/** Check if node is a scoped_call_expression with object 'Route' */
+function isRouteStaticCall(node) {
+    if (node.type !== 'scoped_call_expression')
+        return false;
+    const obj = node.childForFieldName?.('object') ?? node.children?.[0];
+    return obj?.text === 'Route';
+}
+/** Get the method name from a scoped_call_expression or member_call_expression */
+function getCallMethodName(node) {
+    const nameNode = node.childForFieldName?.('name') ?? node.children?.find((c) => c.type === 'name');
+    return nameNode?.text ?? null;
+}
+/** Get the arguments node from a call expression */
+function getArguments(node) {
+    return node.children?.find((c) => c.type === 'arguments') ?? null;
+}
+/** Find the closure body inside arguments */
+function findClosureBody(argsNode) {
+    if (!argsNode)
+        return null;
+    for (const child of argsNode.children ?? []) {
+        if (child.type === 'argument') {
+            for (const inner of child.children ?? []) {
+                if (inner.type === 'anonymous_function' || inner.type === 'arrow_function') {
+                    return (inner.childForFieldName?.('body') ??
+                        inner.children?.find((c) => c.type === 'compound_statement') ??
+                        null);
+                }
+            }
+        }
+        if (child.type === 'anonymous_function' || child.type === 'arrow_function') {
+            return (child.childForFieldName?.('body') ??
+                child.children?.find((c) => c.type === 'compound_statement') ??
+                null);
+        }
+    }
+    return null;
+}
+/** Extract first string argument from arguments node */
+function extractFirstStringArg(argsNode) {
+    if (!argsNode)
+        return null;
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (!target)
+            continue;
+        if (target.type === 'string' || target.type === 'encapsed_string') {
+            return (0, ast_helpers_js_1.extractStringContent)(target);
+        }
+    }
+    return null;
+}
+/** Extract middleware from arguments — handles string or array */
+function extractMiddlewareArg(argsNode) {
+    if (!argsNode)
+        return [];
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (!target)
+            continue;
+        if (target.type === 'string' || target.type === 'encapsed_string') {
+            const val = (0, ast_helpers_js_1.extractStringContent)(target);
+            return val ? [val] : [];
+        }
+        if (target.type === 'array_creation_expression') {
+            const items = [];
+            for (const el of target.children ?? []) {
+                if (el.type === 'array_element_initializer') {
+                    const str = el.children?.find((c) => c.type === 'string' || c.type === 'encapsed_string');
+                    const val = str ? (0, ast_helpers_js_1.extractStringContent)(str) : null;
+                    if (val)
+                        items.push(val);
+                }
+            }
+            return items;
+        }
+    }
+    return [];
+}
+/** Extract Controller::class from arguments */
+function extractClassArg(argsNode) {
+    if (!argsNode)
+        return null;
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (target?.type === 'class_constant_access_expression') {
+            return target.children?.find((c) => c.type === 'name')?.text ?? null;
+        }
+    }
+    return null;
+}
+function joinRouteName(prefix, name) {
+    if (!name)
+        return null;
+    return prefix ? `${prefix}${name}` : name;
+}
+function routeNameBaseFromPath(routePath) {
+    const base = routePath
+        ?.trim()
+        .replace(/^\/+|\/+$/g, '')
+        .replace(/\//g, '.');
+    return base || null;
+}
+function appendResourceActionName(base, action) {
+    if (!base)
+        return null;
+    return base.endsWith('.') ? `${base}${action}` : `${base}.${action}`;
+}
+/**
+ * Read the controller class reference out of a `class_constant_access_expression`
+ * (the `X::class` node). Returns the simple short name (for short-name fallback)
+ * and, when the reference is itself namespace-qualified (`\App\Admin\X::class`),
+ * its normalized dot-joined fully-qualified name (for direct disambiguation).
+ */
+function readControllerClassRef(classAccess) {
+    const nameChild = classAccess.children?.find((c) => c.type === 'name');
+    const qualifiedChild = classAccess.children?.find((c) => c.type === 'qualified_name');
+    const qualified = qualifiedChild ? (0, qualified_name_js_1.normalizeQualifiedName)(qualifiedChild.text) : null;
+    // When only a qualified_name is present, derive the simple short name from
+    // its last segment so short-name fallback still works.
+    const simple = nameChild?.text ?? (qualified ? (qualified.split('.').pop() ?? null) : null);
+    return { simple, qualified };
+}
+/** Extract controller class name from common Laravel handler argument shapes. */
+function extractControllerTarget(argsNode) {
+    const none = { controller: null, controllerQualified: null, method: null, bareMethod: null };
+    if (!argsNode)
+        return none;
+    const args = [];
+    for (const child of argsNode.children ?? []) {
+        if (child.type === 'argument')
+            args.push(child.children?.[0]);
+        else if (child.type !== '(' && child.type !== ')' && child.type !== ',')
+            args.push(child);
+    }
+    // Second arg is the handler
+    const handlerNode = args[1];
+    if (!handlerNode)
+        return none;
+    // Array syntax: [UserController::class, 'index']
+    if (handlerNode.type === 'array_creation_expression') {
+        let controller = null;
+        let controllerQualified = null;
+        let method = null;
+        const elements = [];
+        for (const el of handlerNode.children ?? []) {
+            if (el.type === 'array_element_initializer')
+                elements.push(el);
+        }
+        if (elements[0]) {
+            const classAccess = (0, ast_helpers_js_1.findDescendant)(elements[0], 'class_constant_access_expression');
+            if (classAccess) {
+                const ref = readControllerClassRef(classAccess);
+                controller = ref.simple;
+                controllerQualified = ref.qualified;
+            }
+        }
+        if (elements[1]) {
+            const str = (0, ast_helpers_js_1.findDescendant)(elements[1], 'string');
+            method = str ? (0, ast_helpers_js_1.extractStringContent)(str) : null;
+        }
+        return { controller, controllerQualified, method, bareMethod: null };
+    }
+    // String syntax: 'UserController@index'. A bare string such as 'index'
+    // becomes a method only when a surrounding Route::controller(...) group
+    // supplies the controller class.
+    if (handlerNode.type === 'string' || handlerNode.type === 'encapsed_string') {
+        const text = (0, ast_helpers_js_1.extractStringContent)(handlerNode);
+        if (text?.includes('@')) {
+            const [controller, method] = text.split('@');
+            return { controller, controllerQualified: null, method, bareMethod: null };
+        }
+        if (text)
+            return { controller: null, controllerQualified: null, method: null, bareMethod: text };
+    }
+    // Class reference: UserController::class (invokable controller)
+    if (handlerNode.type === 'class_constant_access_expression') {
+        const ref = readControllerClassRef(handlerNode);
+        return {
+            controller: ref.simple,
+            controllerQualified: ref.qualified,
+            method: '__invoke',
+            bareMethod: null,
+        };
+    }
+    return { controller: null, controllerQualified: null, method: null, bareMethod: null };
+}
+/**
+ * Unwrap a chained call like Route::middleware('auth')->prefix('api')->group(fn)
+ */
+function unwrapRouteChain(node) {
+    if (node.type !== 'member_call_expression')
+        return null;
+    const terminalMethod = getCallMethodName(node);
+    if (!terminalMethod)
+        return null;
+    const terminalArgs = getArguments(node);
+    const attributes = [];
+    let current = node.children?.[0];
+    while (current) {
+        if (current.type === 'member_call_expression') {
+            const method = getCallMethodName(current);
+            const args = getArguments(current);
+            if (method)
+                attributes.unshift({ method, argsNode: args });
+            current = current.children?.[0];
+        }
+        else if (current.type === 'scoped_call_expression') {
+            const obj = current.childForFieldName?.('object') ?? current.children?.[0];
+            if (obj?.text !== 'Route')
+                return null;
+            const method = getCallMethodName(current);
+            const args = getArguments(current);
+            if (method)
+                attributes.unshift({ method, argsNode: args });
+            return { isRouteFacade: true, terminalMethod, attributes, terminalArgs, node };
+        }
+        else {
+            break;
+        }
+    }
+    return null;
+}
+/** Parse Route::group(['middleware' => ..., 'prefix' => ...], fn) array syntax */
+function parseArrayGroupArgs(argsNode) {
+    const ctx = {
+        middleware: [],
+        prefix: null,
+        namePrefix: null,
+        controller: null,
+    };
+    if (!argsNode)
+        return ctx;
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (target?.type === 'array_creation_expression') {
+            for (const el of target.children ?? []) {
+                if (el.type !== 'array_element_initializer')
+                    continue;
+                const children = el.children ?? [];
+                const arrowIdx = children.findIndex((c) => c.type === '=>');
+                if (arrowIdx === -1)
+                    continue;
+                const key = (0, ast_helpers_js_1.extractStringContent)(children[arrowIdx - 1]);
+                const val = children[arrowIdx + 1];
+                if (key === 'middleware') {
+                    if (val?.type === 'string') {
+                        const s = (0, ast_helpers_js_1.extractStringContent)(val);
+                        if (s)
+                            ctx.middleware.push(s);
+                    }
+                    else if (val?.type === 'array_creation_expression') {
+                        for (const item of val.children ?? []) {
+                            if (item.type === 'array_element_initializer') {
+                                const str = item.children?.find((c) => c.type === 'string');
+                                const s = str ? (0, ast_helpers_js_1.extractStringContent)(str) : null;
+                                if (s)
+                                    ctx.middleware.push(s);
+                            }
+                        }
+                    }
+                }
+                else if (key === 'prefix') {
+                    ctx.prefix = (0, ast_helpers_js_1.extractStringContent)(val) ?? null;
+                }
+                else if (key === 'as' || key === 'name') {
+                    ctx.namePrefix = (0, ast_helpers_js_1.extractStringContent)(val) ?? null;
+                }
+                else if (key === 'controller') {
+                    if (val?.type === 'class_constant_access_expression') {
+                        ctx.controller = val.children?.find((c) => c.type === 'name')?.text ?? null;
+                    }
+                }
+            }
+        }
+    }
+    return ctx;
+}
+/**
+ * Build the routes file's `use`-import alias map: local name (alias, else the
+ * imported short name) → the class's normalized dot-joined fully-qualified name.
+ * Reuses the PHP `use`-declaration decomposer so grouped (`use Foo\{A, B}`) and
+ * aliased (`use Foo\Bar as Baz;`) forms are handled across grammar versions.
+ * `use` statements are file-/namespace-scoped, so a shallow walk over the
+ * routes file's structural nodes finds them all.
+ */
+function buildUseAliasMap(root) {
+    const aliasMap = new Map();
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'namespace_use_declaration') {
+            for (const match of (0, import_decomposer_js_1.splitNamespaceUseDeclaration)(node)) {
+                const source = match['@import.source']?.text;
+                if (source === undefined)
+                    continue;
+                const local = match['@import.alias']?.text ?? match['@import.name']?.text;
+                if (local === undefined || local === '')
+                    continue;
+                aliasMap.set(local, (0, qualified_name_js_1.normalizeQualifiedName)(source));
+            }
+            continue;
+        }
+        // Only descend through file/namespace structure where `use` can appear —
+        // not into function bodies or expressions.
+        if (node.type === 'program' ||
+            node.type === 'namespace_definition' ||
+            node.type === 'declaration_list' ||
+            node.type === 'compound_statement') {
+            for (const child of node.namedChildren ?? [])
+                stack.push(child);
+        }
+    }
+    return aliasMap;
+}
+/**
+ * Resolve a route's controller to its normalized fully-qualified name when the
+ * routes file disambiguates it: an inline qualified `::class` wins, else the
+ * `use`-import alias map for the short/local name, else `null` (the emitter
+ * falls back to short-name resolution).
+ */
+function resolveControllerQualifiedName(inlineQualified, controllerName, aliasMap) {
+    if (inlineQualified)
+        return inlineQualified;
+    if (controllerName)
+        return aliasMap.get(controllerName) ?? null;
+    return null;
+}
+function extractLaravelRoutes(tree, filePath) {
+    const routes = [];
+    const useAliasMap = buildUseAliasMap(tree.rootNode);
+    function resolveStack(stack) {
+        const middleware = [];
+        let prefix = null;
+        let namePrefix = null;
+        let controller = null;
+        for (const ctx of stack) {
+            middleware.push(...ctx.middleware);
+            if (ctx.prefix)
+                prefix = prefix ? `${prefix}/${ctx.prefix}`.replace(/\/+/g, '/') : ctx.prefix;
+            if (ctx.namePrefix)
+                namePrefix = namePrefix ? `${namePrefix}${ctx.namePrefix}` : ctx.namePrefix;
+            if (ctx.controller)
+                controller = ctx.controller;
+        }
+        return { middleware, prefix, namePrefix, controller };
+    }
+    function emitRoute(httpMethod, argsNode, lineNumber, groupStack, chainAttrs) {
+        const effective = resolveStack(groupStack);
+        let routeName = null;
+        for (const attr of chainAttrs) {
+            if (attr.method === 'middleware')
+                effective.middleware.push(...extractMiddlewareArg(attr.argsNode));
+            if (attr.method === 'prefix') {
+                const p = extractFirstStringArg(attr.argsNode);
+                if (p)
+                    effective.prefix = effective.prefix ? `${effective.prefix}/${p}` : p;
+            }
+            if (attr.method === 'controller') {
+                const cls = extractClassArg(attr.argsNode);
+                if (cls)
+                    effective.controller = cls;
+            }
+            if (attr.method === 'name') {
+                routeName = joinRouteName(effective.namePrefix, extractFirstStringArg(attr.argsNode));
+            }
+        }
+        const routePath = extractFirstStringArg(argsNode);
+        if (ROUTE_RESOURCE_METHODS.has(httpMethod)) {
+            const target = extractControllerTarget(argsNode);
+            const actions = httpMethod === 'apiResource' ? API_RESOURCE_ACTIONS : RESOURCE_ACTIONS;
+            const routeNameBase = routeName ?? joinRouteName(effective.namePrefix, routeNameBaseFromPath(routePath));
+            for (const action of actions) {
+                routes.push({
+                    filePath,
+                    httpMethod,
+                    routePath,
+                    routeName: appendResourceActionName(routeNameBase, action),
+                    controllerName: target.controller ?? effective.controller,
+                    controllerQualifiedName: resolveControllerQualifiedName(target.controllerQualified, target.controller ?? effective.controller, useAliasMap),
+                    methodName: action,
+                    middleware: [...effective.middleware],
+                    prefix: effective.prefix,
+                    lineNumber,
+                });
+            }
+        }
+        else {
+            const target = extractControllerTarget(argsNode);
+            routes.push({
+                filePath,
+                httpMethod,
+                routePath,
+                routeName,
+                controllerName: target.controller ?? effective.controller,
+                controllerQualifiedName: resolveControllerQualifiedName(target.controllerQualified, target.controller ?? effective.controller, useAliasMap),
+                methodName: target.method ?? (effective.controller ? target.bareMethod : null),
+                middleware: [...effective.middleware],
+                prefix: effective.prefix,
+                lineNumber,
+            });
+        }
+    }
+    const walkStack = [{ node: tree.rootNode, groupSnapshot: [] }];
+    while (walkStack.length > 0) {
+        const { node, groupSnapshot } = walkStack.pop();
+        // Case 1: Simple Route::get(...), Route::post(...), etc.
+        if (isRouteStaticCall(node)) {
+            const method = getCallMethodName(node);
+            if (method && (ROUTE_HTTP_METHODS.has(method) || ROUTE_RESOURCE_METHODS.has(method))) {
+                emitRoute(method, getArguments(node), node.startPosition.row, groupSnapshot, []);
+                continue;
+            }
+            if (method === 'group') {
+                const argsNode = getArguments(node);
+                const groupCtx = parseArrayGroupArgs(argsNode);
+                const body = findClosureBody(argsNode);
+                if (body) {
+                    const childSnapshot = [...groupSnapshot, groupCtx];
+                    const children = body.children ?? [];
+                    for (let i = children.length - 1; i >= 0; i--) {
+                        walkStack.push({ node: children[i], groupSnapshot: childSnapshot });
+                    }
+                }
+                continue;
+            }
+        }
+        // Case 2: Fluent chain — Route::middleware(...)->group(...) or Route::middleware(...)->get(...)
+        const chain = unwrapRouteChain(node);
+        if (chain) {
+            if (chain.terminalMethod === 'group') {
+                const groupCtx = {
+                    middleware: [],
+                    prefix: null,
+                    namePrefix: null,
+                    controller: null,
+                };
+                for (const attr of chain.attributes) {
+                    if (attr.method === 'middleware')
+                        groupCtx.middleware.push(...extractMiddlewareArg(attr.argsNode));
+                    if (attr.method === 'prefix')
+                        groupCtx.prefix = extractFirstStringArg(attr.argsNode);
+                    if (attr.method === 'name')
+                        groupCtx.namePrefix = extractFirstStringArg(attr.argsNode);
+                    if (attr.method === 'controller')
+                        groupCtx.controller = extractClassArg(attr.argsNode);
+                }
+                const body = findClosureBody(chain.terminalArgs);
+                if (body) {
+                    const childSnapshot = [...groupSnapshot, groupCtx];
+                    const children = body.children ?? [];
+                    for (let i = children.length - 1; i >= 0; i--) {
+                        walkStack.push({ node: children[i], groupSnapshot: childSnapshot });
+                    }
+                }
+                continue;
+            }
+            if (ROUTE_HTTP_METHODS.has(chain.terminalMethod) ||
+                ROUTE_RESOURCE_METHODS.has(chain.terminalMethod)) {
+                emitRoute(chain.terminalMethod, chain.terminalArgs, node.startPosition.row, groupSnapshot, chain.attributes);
+                continue;
+            }
+            const chainedRouteIndex = chain.attributes.findIndex((attr) => ROUTE_HTTP_METHODS.has(attr.method) || ROUTE_RESOURCE_METHODS.has(attr.method));
+            if (chainedRouteIndex >= 0) {
+                const routeAttr = chain.attributes[chainedRouteIndex];
+                const routeAttrs = [
+                    ...chain.attributes.slice(0, chainedRouteIndex),
+                    ...chain.attributes.slice(chainedRouteIndex + 1),
+                    { method: chain.terminalMethod, argsNode: chain.terminalArgs },
+                ];
+                emitRoute(routeAttr.method, routeAttr.argsNode, node.startPosition.row, groupSnapshot, routeAttrs);
+                continue;
+            }
+        }
+        // Default: push children in reverse so leftmost is processed first
+        const children = node.children ?? [];
+        for (let i = children.length - 1; i >= 0; i--) {
+            walkStack.push({ node: children[i], groupSnapshot });
+        }
+    }
+    return routes;
+}

package/dist/core/code/engine/core/ingestion/route-extractors/middleware.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * Middleware chain extraction from route handler file content.
+ * Detects wrapper patterns like: export const POST = withA(withB(withC(handler)))
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIDDLEWARE_STOP_KEYWORDS = void 0;
+exports.extractMiddlewareChain = extractMiddlewareChain;
+exports.extractNextjsMiddlewareConfig = extractNextjsMiddlewareConfig;
+exports.compileMatcher = compileMatcher;
+exports.compiledMatcherMatchesRoute = compiledMatcherMatchesRoute;
+exports.middlewareMatcherMatchesRoute = middlewareMatcherMatchesRoute;
+/** Keywords that terminate middleware chain walking (not wrapper function names) */
+/** Names that are composition wrappers, not middleware functions themselves. */
+const COMPOSER_NAMES = new Set(['middleware', 'default', 'chain', 'compose']);
+/** Keywords that terminate middleware chain walking (not wrapper function names) */
+exports.MIDDLEWARE_STOP_KEYWORDS = new Set([
+    'async',
+    'await',
+    'function',
+    'new',
+    'return',
+    'if',
+    'for',
+    'while',
+    'switch',
+    'class',
+    'const',
+    'let',
+    'var',
+    'req',
+    'res',
+    'request',
+    'response',
+    'event',
+    'ctx',
+    'context',
+    'next',
+]);
+/** Walk nested wrapper calls starting at `pos` in `content`, returning function names. */
+function walkNestedWrappers(content, pos) {
+    const names = [];
+    const nestedRe = /^\s*(\w+)\s*\(/;
+    let remaining = content.slice(pos);
+    let nested;
+    while ((nested = nestedRe.exec(remaining)) !== null) {
+        if (exports.MIDDLEWARE_STOP_KEYWORDS.has(nested[1]))
+            break;
+        names.push(nested[1]);
+        pos += nested[0].length;
+        remaining = content.slice(pos);
+    }
+    return names;
+}
+/**
+ * Extract middleware wrapper chain from a route handler file.
+ * Detects patterns like: export const POST = withA(withB(withC(handler)))
+ * Returns an object with the wrapper function names (outermost-first) and the
+ * HTTP method they were captured from, or undefined if no chain found.
+ */
+function extractMiddlewareChain(content) {
+    const mwPattern = /export\s+(?:const\s+(POST|GET|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*=|default)\s+(\w+)\s*\(/g;
+    let mwMatch;
+    while ((mwMatch = mwPattern.exec(content)) !== null) {
+        const method = mwMatch[1] ?? 'default';
+        const firstWrapper = mwMatch[2];
+        const chain = [firstWrapper];
+        chain.push(...walkNestedWrappers(content, mwMatch.index + mwMatch[0].length));
+        if (chain.length >= 2 || (chain.length === 1 && /^with[A-Z]/.test(chain[0]))) {
+            return { chain, method };
+        }
+    }
+    return undefined;
+}
+/**
+ * Parse a Next.js project-level middleware.ts file and extract:
+ * - config.matcher patterns (string or string[])
+ * - the exported middleware function name
+ * - wrapper composition (e.g. chain([withAuth, withI18n]))
+ */
+function extractNextjsMiddlewareConfig(content) {
+    const matchers = [];
+    const matcherArrayRe = /config\s*=\s*\{[^}]*matcher\s*:\s*\[([^\]]*)\]/s;
+    const matcherStringRe = /config\s*=\s*\{[^}]*matcher\s*:\s*(['"`])([^'"`]+)\1/s;
+    const arrMatch = matcherArrayRe.exec(content);
+    if (arrMatch) {
+        const items = arrMatch[1];
+        const strRe = /(['"`])((?:[^'"`\\\\]|\\\\.)*)\1/g;
+        let m;
+        while ((m = strRe.exec(items)) !== null) {
+            matchers.push(m[2]);
+        }
+    }
+    else {
+        const strMatch = matcherStringRe.exec(content);
+        if (strMatch) {
+            matchers.push(strMatch[2]);
+        }
+    }
+    let exportedName = 'middleware';
+    const isNamedMw = /export\s+(?:async\s+)?function\s+middleware\b/.test(content);
+    const isConstMw = /export\s+const\s+middleware\s*=/.test(content);
+    const defaultFunctionMatch = /export\s+default\s+(?:async\s+)?function(?:\s+(\w+))?/.exec(content);
+    const defaultIdentifierMatch = /export\s+default\s+(?!function\b)(\w+)/.exec(content);
+    if (!isNamedMw && !isConstMw) {
+        if (defaultFunctionMatch) {
+            exportedName = defaultFunctionMatch[1] ?? 'middleware';
+        }
+        else if (defaultIdentifierMatch) {
+            exportedName = defaultIdentifierMatch[1];
+        }
+    }
+    // --- wrapper composition ---
+    const wrappedFunctions = [];
+    // Pattern: chain([fn1, fn2]) or compose(fn1, fn2)
+    const chainRe = /(?:chain|compose)\s*\(\s*\[([^\]]+)\]/;
+    const chainMatch = chainRe.exec(content);
+    if (chainMatch) {
+        const fns = chainMatch[1]
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+        wrappedFunctions.push(...fns);
+    }
+    // Pattern: export default withA(withB(handler))
+    const wrapperRe = /export\s+default\s+(\w+)\s*\(/;
+    const wrapperMatch = wrapperRe.exec(content);
+    if (wrapperMatch && wrappedFunctions.length === 0) {
+        const name = wrapperMatch[1];
+        if (name !== 'function' && name !== 'async') {
+            wrappedFunctions.push(name);
+            wrappedFunctions.push(...walkNestedWrappers(content, wrapperMatch.index + wrapperMatch[0].length));
+        }
+    }
+    if (!COMPOSER_NAMES.has(exportedName) && !wrappedFunctions.includes(exportedName)) {
+        wrappedFunctions.unshift(exportedName);
+    }
+    const hasExport = isNamedMw || isConstMw || !!defaultFunctionMatch || !!defaultIdentifierMatch;
+    if (!hasExport && matchers.length === 0 && wrappedFunctions.length === 0)
+        return undefined;
+    return { matchers, exportedName, wrappedFunctions };
+}
+/**
+ * Compile a Next.js middleware matcher pattern into a reusable matcher.
+ * Call once per pattern, then use compiledMatcherMatchesRoute per route.
+ */
+function compileMatcher(matcher) {
+    const paramWild = matcher.replace(/\/:path\*$/, '');
+    if (paramWild !== matcher)
+        return { type: 'prefix', prefix: paramWild };
+    if (matcher.includes('(')) {
+        try {
+            return { type: 'regex', re: new RegExp('^' + matcher + '$') };
+        }
+        catch {
+            return null;
+        }
+    }
+    return { type: 'exact', value: matcher };
+}
+/** Test a route URL against a pre-compiled matcher. */
+function compiledMatcherMatchesRoute(cm, routeURL) {
+    switch (cm.type) {
+        case 'prefix':
+            return routeURL === cm.prefix || routeURL.startsWith(cm.prefix + '/');
+        case 'regex':
+            return cm.re.test(routeURL);
+        case 'exact':
+            return routeURL === cm.value;
+    }
+}
+function middlewareMatcherMatchesRoute(matcher, routeURL) {
+    const cm = compileMatcher(matcher);
+    return cm ? compiledMatcherMatchesRoute(cm, routeURL) : false;
+}