@pikku/inspector 0.12.103 → 0.12.107

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

@@ -1,13 +1,5 @@
 import type { AddWiring } from '../types.js';
-/**
- * The pikku function id of the single shared auth handler the CLI generates
- * (`export const authHandler = pikkuSessionlessFunc(...)` in auth.gen.ts). An
- * exported top-level const collapses the catch-all `/api/auth/**` route onto one
- * worker, and the export name becomes the function id. Shared with the CLI
- * codegen and the post-process service stamp so all three agree on the same id
- * without the inspector having to import `@pikku/better-auth`.
- */
-export declare const AUTH_HANDLER_FUNC_ID = "authHandler";
+export { AUTH_HANDLER_FUNC_ID } from '../utils/inspector-constants.js';
 /**
  * Detects `pikkuBetterAuth((services) => betterAuth({...}))` calls.
  *

package/dist/add/add-auth.js

@@ -1,15 +1,10 @@
 import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
 import { extractServicesFromFunction } from '../utils/extract-services.js';
-/**
- * The pikku function id of the single shared auth handler the CLI generates
- * (`export const authHandler = pikkuSessionlessFunc(...)` in auth.gen.ts). An
- * exported top-level const collapses the catch-all `/api/auth/**` route onto one
- * worker, and the export name becomes the function id. Shared with the CLI
- * codegen and the post-process service stamp so all three agree on the same id
- * without the inspector having to import `@pikku/better-auth`.
- */
-export const AUTH_HANDLER_FUNC_ID = 'authHandler';
+import { resolveCalleeName } from '../utils/resolve-callee-name.js';
+const isBetterAuth = (name) => name === 'betterAuth';
+const isPikkuBetterAuth = (name) => name === 'pikkuBetterAuth';
+export { AUTH_HANDLER_FUNC_ID } from '../utils/inspector-constants.js';
 /** The default better-auth base path when `basePath` is not configured. */
 const DEFAULT_BASE_PATH = '/api/auth';
 /**
@@ -17,14 +12,12 @@ const DEFAULT_BASE_PATH = '/api/auth';
  * factory body. Supports both `(s) => betterAuth({...})` and
  * `(s) => { ...; return betterAuth({...}) }`.
  */
-const findBetterAuthCall = (node) => {
+const findBetterAuthCall = (node, checker) => {
     let found;
     const visit = (n) => {
         if (found)
             return;
-        if (ts.isCallExpression(n) &&
-            ts.isIdentifier(n.expression) &&
-            n.expression.text === 'betterAuth') {
+        if (ts.isCallExpression(n) && resolveCalleeName(n, checker, isBetterAuth)) {
             found = n;
             return;
         }
@@ -42,6 +35,30 @@ const readStringProp = (obj, name) => {
         return prop.initializer.text;
     return undefined;
 };
+/**
+ * Whether a property is written at all, literal or not — so a value the
+ * inspector cannot read can be told apart from one that was never set.
+ */
+const hasProp = (obj, name) => obj.properties.some((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+    (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
+    p.name.text === name);
+/**
+ * True when a spread comes after the last assignment of `name` in `obj`, so the
+ * value written there may not be the one that applies. A spread before it is
+ * harmless: the property wins.
+ */
+const isOverriddenBySpread = (obj, name) => {
+    let assigned = -1;
+    obj.properties.forEach((p, index) => {
+        if ((ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+            (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
+            p.name.text === name) {
+            assigned = index;
+        }
+    });
+    return (assigned >= 0 &&
+        obj.properties.slice(assigned + 1).some(ts.isSpreadAssignment));
+};
 /** Find an object-literal-valued property off an object literal, if present. */
 const readObjectProp = (obj, name) => {
     const prop = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
@@ -159,11 +176,10 @@ and set password.`;
  * `socialProviders` keys, whether email/password is enabled, and the services
  * the factory touches. Exactly one `pikkuBetterAuth` is allowed per codebase.
  */
-export const addAuth = (logger, node, _checker, state) => {
+export const addAuth = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node))
         return;
-    const expression = node.expression;
-    if (!ts.isIdentifier(expression) || expression.text !== 'pikkuBetterAuth')
+    if (!resolveCalleeName(node, checker, isPikkuBetterAuth))
         return;
     const sourceFile = node.getSourceFile().fileName;
     // Walk up to the `export const <name> = pikkuBetterAuth(...)` binding.
@@ -206,7 +222,21 @@ export const addAuth = (logger, node, _checker, state) => {
     let basePath = DEFAULT_BASE_PATH;
     let hasCredentials = false;
     let cookieCache = false;
-    const betterAuthCall = findBetterAuthCall(factory);
+    let cookiePrefix;
+    let cookieCacheStrategy;
+    let cookieCacheVersion;
+    const unreadCookieOptions = [];
+    const readCookieOption = (block, name, path, enclosingOverridden) => {
+        if (!hasProp(block, name))
+            return undefined;
+        const value = enclosingOverridden || isOverriddenBySpread(block, name)
+            ? undefined
+            : readStringProp(block, name);
+        if (value === undefined)
+            unreadCookieOptions.push(path);
+        return value;
+    };
+    const betterAuthCall = findBetterAuthCall(factory, checker);
     const config = betterAuthCall?.arguments[0];
     if (config && ts.isObjectLiteralExpression(config)) {
         basePath = readStringProp(config, 'basePath') ?? DEFAULT_BASE_PATH;
@@ -221,8 +251,22 @@ export const addAuth = (logger, node, _checker, state) => {
                 cookieCache =
                     !enabledProp ||
                         enabledProp.initializer.kind !== ts.SyntaxKind.FalseKeyword;
+                const sessionOverridden = isOverriddenBySpread(config, 'session') ||
+                    isOverriddenBySpread(session, 'cookieCache');
+                cookieCacheStrategy = readCookieOption(cookieCacheBlock, 'strategy', 'session.cookieCache.strategy', sessionOverridden);
+                cookieCacheVersion = readCookieOption(cookieCacheBlock, 'version', 'session.cookieCache.version', sessionOverridden);
             }
         }
+        // The stateless middleware never builds the auth instance, so it has to be
+        // told how the cookie was written: read the parts that change its name and
+        // its verification, and say so when one is not a literal.
+        const advanced = readObjectProp(config, 'advanced');
+        if (advanced) {
+            cookiePrefix = readCookieOption(advanced, 'cookiePrefix', 'advanced.cookiePrefix', isOverriddenBySpread(config, 'advanced'));
+        }
+        if (cookieCache && unreadCookieOptions.length > 0) {
+            logger.warn(`pikkuBetterAuth in ${sourceFile}: ${unreadCookieOptions.join(', ')} is not a string literal, or a later spread can replace it, so the generated betterAuthStatelessSession cannot read the session cookie the way it is written. Write it as a literal, or register betterAuthStatelessSession({ cookiePrefix, cookieCache: { strategy, version } }) yourself with addGlobalMiddleware — yours runs first and the generated one then does nothing.`);
+        }
         const emailAndPassword = readObjectProp(config, 'emailAndPassword');
         if (emailAndPassword) {
             // `emailAndPassword: { enabled: true }` — treat a present block without an
@@ -272,6 +316,9 @@ export const addAuth = (logger, node, _checker, state) => {
         basePath,
         hasCredentials,
         cookieCache,
+        ...(cookiePrefix !== undefined && { cookiePrefix }),
+        ...(cookieCacheStrategy !== undefined && { cookieCacheStrategy }),
+        ...(cookieCacheVersion !== undefined && { cookieCacheVersion }),
         plugins: [...state.auth.plugins],
         services,
     };

package/dist/add/add-cli.js

@@ -325,15 +325,23 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                 }
                 break;
             case 'subcommands': {
-                let subcommandsNode = prop.initializer;
-                if (ts.isIdentifier(prop.initializer)) {
-                    subcommandsNode = resolveIdentifier(prop.initializer, typeChecker, [
-                        'defineCLICommands',
-                    ]);
-                }
-                if (subcommandsNode && ts.isObjectLiteralExpression(subcommandsNode)) {
-                    meta.subcommands = {};
-                    for (const subProp of subcommandsNode.properties) {
+                const subcommands = {};
+                const collect = (node) => {
+                    const refContract = resolveRefContract(node, 'refCLI', inspectorState.exportedContracts.addonCli);
+                    if (refContract) {
+                        Object.assign(subcommands, refContract.contract);
+                        return;
+                    }
+                    const target = ts.isIdentifier(node)
+                        ? resolveIdentifier(node, typeChecker, ['defineCLICommands'])
+                        : node;
+                    if (!target || !ts.isObjectLiteralExpression(target))
+                        return;
+                    for (const subProp of target.properties) {
+                        if (ts.isSpreadAssignment(subProp)) {
+                            collect(subProp.expression);
+                            continue;
+                        }
                         if (!ts.isPropertyAssignment(subProp))
                             continue;
                         const subName = getPropertyName(subProp);
@@ -341,10 +349,12 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                             continue;
                         const subCommand = processCommand(logger, inspectorState, options, subName, subProp.initializer, sourceFile, typeChecker, programName, fullPath, programTags);
                         if (subCommand) {
-                            meta.subcommands[subName] = subCommand;
+                            subcommands[subName] = subCommand;
                         }
                     }
-                }
+                };
+                collect(prop.initializer);
+                meta.subcommands = subcommands;
                 break;
             }
             case 'isDefault':
@@ -489,6 +499,7 @@ function extractEnumFromPropertyType(type, propertyName, typeChecker) {
     const enumValues = [];
     // Check if it's a union type (e.g., 'debug' | 'info' | 'warn')
     if (propertyType.isUnion()) {
+        let fromEnum = false;
         for (const unionType of propertyType.types) {
             // Check if it's a string literal type
             if (unionType.flags & ts.TypeFlags.StringLiteral) {
@@ -497,6 +508,7 @@ function extractEnumFromPropertyType(type, propertyName, typeChecker) {
             }
             // Check if it's an enum member (could be string or number enum)
             else if (unionType.flags & ts.TypeFlags.EnumLiteral) {
+                fromEnum = true;
                 const enumLiteralType = unionType;
                 // For string enums, use the value directly
                 if (typeof enumLiteralType.value === 'string') {
@@ -511,6 +523,8 @@ function extractEnumFromPropertyType(type, propertyName, typeChecker) {
                 }
             }
         }
+        if (!fromEnum)
+            enumValues.sort();
     }
     // Check if it's an enum type directly
     else if (propertyType.flags & ts.TypeFlags.Enum) {

package/dist/add/add-functions.js

@@ -21,10 +21,15 @@ const SCENARIO_SURFACE_KEYS = [
  * copied into an addon package by a consumer, a called identifier cannot.
  */
 const SCENARIO_STEP_KINDS = new Map([
-    ['pikkuScenarioStep', 'persona'],
+    ['pikkuScenarioStep', 'virtualUser'],
     ['pikkuPlatformScenarioStep', 'platform'],
     ['pikkuAddonScenarioStep', 'addon'],
 ]);
+const PIKKU_FUNC_PATTERN = /pikku.*func/i;
+const isFunctionHelper = (name) => PIKKU_FUNC_PATTERN.test(name) ||
+    name === 'pikkuScenario' ||
+    name === 'pikkuWebhookReceive' ||
+    SCENARIO_STEP_KINDS.has(name);
 import { getPropertyValue, getArrayPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { canonicalJSON, hashString } from '../utils/hash.js';
 import { resolveMiddleware } from '../utils/middleware.js';
@@ -34,6 +39,7 @@ import { ErrorCode } from '../error-codes.js';
 import { findPiiPaths } from '../utils/check-pii-output.js';
 import { findClassifiedSinks } from '../utils/check-classified-sinks.js';
 import { isScenarioInstrumentationFunction } from './scenario-instrumentation.js';
+import { resolveCalleeName } from '../utils/resolve-callee-name.js';
 const isValidVariableName = (name) => {
     const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
     return regex.test(name);
@@ -351,37 +357,27 @@ export const addFunctions = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args, typeArguments } = node;
-    // only handle calls like pikkuFunc(...)
-    if (!ts.isIdentifier(expression)) {
+    // Match helpers whose name contains both "pikku" and "func" (case
+    // insensitive), plus pikkuScenario and the three scenario step wrappers
+    // (workflow wrappers without "func" in their names). The callee is matched
+    // by what it resolves to, so an aliased `pikkuFunc` is still a pikkuFunc —
+    // and still requires a session.
+    const callee = resolveCalleeName(node, checker, isFunctionHelper);
+    if (!callee)
         return;
-    }
-    // Match identifiers that contain both "pikku" and "func" (case insensitive),
-    // plus pikkuScenario and the three scenario step wrappers (workflow wrappers
-    // without "func" in their names)
-    const pikkuFuncPattern = /pikku.*func/i;
-    if (!pikkuFuncPattern.test(expression.text) &&
-        expression.text !== 'pikkuScenario' &&
-        expression.text !== 'pikkuWebhookReceive' &&
-        !SCENARIO_STEP_KINDS.has(expression.text)) {
-        return;
-    }
     // A scenario step is bundled like any invoked function, but is deliberately
     // never RPC-registered: a step may drive a browser, so exposing it over the
     // network would put a test harness on the public API surface.
-    const scenarioStepKind = SCENARIO_STEP_KINDS.get(expression.text);
+    const scenarioStepKind = SCENARIO_STEP_KINDS.get(callee);
     const isScenarioStep = scenarioStepKind !== undefined;
     // A scenario's own body. Marked so the codegen partitions and the deploy
     // analyzer can tell it apart from an application workflow without having to
     // reach into the workflow graph.
-    const isScenario = expression.text === 'pikkuScenario';
+    const isScenario = callee === 'pikkuScenario';
     // A webhook source's `receive`. Only its source's route runs it, with the
     // raw request, so like a scenario step it is bundled but never RPC-registered.
-    const isWebhookReceive = expression.text === 'pikkuWebhookReceive';
+    const isWebhookReceive = callee === 'pikkuWebhookReceive';
     const notRpc = isScenarioStep || isWebhookReceive;
-    // only handle calls like pikkuFunc(...)
-    if (!ts.isIdentifier(expression) || !expression.text.startsWith('pikku')) {
-        return;
-    }
     if (args.length === 0)
         return;
     let { pikkuFuncId, name, explicitName, exportedName } = extractFunctionName(node, checker, state.rootDir);
@@ -424,7 +420,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
     let workflowRetries;
     let workflowTimeout;
     let scenarioStepSurfaces;
-    let scenarioStepRequiresActor;
+    let scenarioStepRequiresVirtualUser;
     let scenarioStepAddon;
     let scenarioStepTemplate;
     let scopes;
@@ -540,7 +536,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
             // take a single `func`, and a binding key here is a coded error rather
             // than a convention nobody reads.
             if (declaredSurfaces.length > 0) {
-                logger.error(`• ${expression.text}('${name}') declares ${declaredSurfaces.join('/')} — a ${scenarioStepKind} step has one implementation, declared as \`func\`. Surfaces are how a person drives the system, and nobody drives this one.`);
+                logger.error(`• ${callee}('${name}') declares ${declaredSurfaces.join('/')} — a ${scenarioStepKind} step has one implementation, declared as \`func\`. Surfaces are how a person drives the system, and nobody drives this one.`);
                 return;
             }
             // The phase rule depends on it: an assertion runs every witness it has and
@@ -560,9 +556,9 @@ export const addFunctions = (logger, node, checker, state, options) => {
                 ? declaredSurfaces
                 : undefined;
             // A browser binding cannot be provisioned without a window to open, so it
-            // requires an actor whether or not the step said so.
-            scenarioStepRequiresActor =
-                getPropertyValue(firstArg, 'actor') === true ||
+            // requires a virtual user whether or not the step said so.
+            scenarioStepRequiresVirtualUser =
+                getPropertyValue(firstArg, 'virtualUser') === true ||
                     declaredSurfaces.includes('browser')
                     ? true
                     : undefined;
@@ -665,7 +661,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
     // A remote channel capability is a contract with no body: the connected
     // client answers it. Everything past this point reads the handler, so it gets
     // its own path rather than a nullable handler threaded through all of it.
-    if (expression.text === 'pikkuRemoteChannelFunc') {
+    if (callee === 'pikkuRemoteChannelFunc') {
         addRemoteChannelFunc({
             state,
             logger,
@@ -679,8 +675,8 @@ export const addFunctions = (logger, node, checker, state, options) => {
         });
         return;
     }
-    const isMCPToolFunc = expression.text === 'pikkuMCPToolFunc';
-    const isListFunc = expression.text === 'pikkuListFunc';
+    const isMCPToolFunc = callee === 'pikkuMCPToolFunc';
+    const isListFunc = callee === 'pikkuListFunc';
     const mcpEnabled = mcp || isMCPToolFunc;
     // Pick the handler: use resolvedFunc when it exists and is a function, otherwise fall back to handlerNode
     const handler = resolvedFunc &&
@@ -777,7 +773,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
     // Every other wrapper reads generic[0] as INPUT, so without this guard the
     // connect handler's output generic is mis-recorded as inputSchemaName and the
     // empty WS handshake fails input validation at connect (1008/403).
-    const isChannelConnectionFunc = /ChannelConnection/i.test(expression.text);
+    const isChannelConnectionFunc = /ChannelConnection/i.test(callee);
     const capitalizedName = funcIdToTypeName(name);
     // --- Input Extraction ---
     let inputNames = [];
@@ -857,7 +853,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         pikkuMCPToolFunc: 'MCPToolResponse',
         pikkuMCPPromptFunc: 'MCPPromptResponse',
     };
-    const mcpOutputType = mcpOutputTypes[expression.text];
+    const mcpOutputType = mcpOutputTypes[callee];
     if (mcpOutputType && outputNames[0] !== mcpOutputType) {
         let resolved = false;
         const rawSymbol = checker.getSymbolAtLocation(expression);
@@ -925,7 +921,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
             }
         }
     }
-    const sessionless = expression.text !== 'pikkuFunc';
+    const sessionless = callee !== 'pikkuFunc';
     // ── Classification brand check ─────────────────────────────────────────────
     // Walk the function body's ACTUAL inferred return type looking for classification
     // brands (__classification__ property on Private<T>, Pii<T>, Secret<T>).
@@ -1017,7 +1013,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         }
     }
     const implementationHash = computeImplementationHash({
-        wrapper: expression.text,
+        wrapper: ts.isIdentifier(expression) ? callee : callee,
         handler,
         objectNode,
         isDirectFunction,
@@ -1051,7 +1047,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
     state.functions.meta[pikkuFuncId] = {
         pikkuFuncId,
         functionType: 'user',
-        funcWrapper: expression.text,
+        funcWrapper: callee,
         sessionless,
         name,
         services,
@@ -1083,10 +1079,10 @@ export const addFunctions = (logger, node, checker, state, options) => {
         workflowTimeout: workflowTimeout ?? undefined,
         compensate: compensateInitializer ? true : undefined,
         scenarioStepSurfaces,
-        scenarioStepRequiresActor,
-        // `persona` is the default reading of an unmarked step, so it is left off
+        scenarioStepRequiresVirtualUser,
+        // `virtualUser` is the default reading of an unmarked step, so it is left off
         // rather than written into every step meta a project already has.
-        scenarioStepKind: scenarioStepKind && scenarioStepKind !== 'persona'
+        scenarioStepKind: scenarioStepKind && scenarioStepKind !== 'virtualUser'
             ? scenarioStepKind
             : undefined,
         scenarioStepAddon,
@@ -1162,7 +1158,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
     }
     // Workflow functions don't get registered as RPC functions,
     // they are their own type handled by add-workflow
-    if (expression.text.includes('Workflow')) {
+    if (callee.includes('Workflow')) {
         return;
     }
     // Trigger and channel connect/disconnect functions are not callable via RPC
@@ -1171,7 +1167,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         /ChannelConnection/i,
         /ChannelDisconnection/i,
     ];
-    if (nonRPCPatterns.some((pattern) => pattern.test(expression.text))) {
+    if (nonRPCPatterns.some((pattern) => pattern.test(callee))) {
         return;
     }
     // Store function file location for wiring generation

package/dist/add/add-keyed-wiring.js

@@ -1,8 +1,9 @@
 import * as ts from 'typescript';
-import { getPropertyValue, getArrayPropertyValue, assertStringLiteralProperty, } from '../utils/get-property-value.js';
+import { getPropertyValue, getArrayPropertyValue, getObjectPropertyLiteral, assertStringLiteralProperty, } from '../utils/get-property-value.js';
 import { ErrorCode } from '../error-codes.js';
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
 import { parseDurationString } from '@pikku/core/utils';
+import { SECRET_GENERATE_MIN_SIZE } from '@pikku/core/secret';
 export const createAddKeyedWiring = (config) => {
     return (logger, node, checker, state, _options) => {
         if (!ts.isCallExpression(node)) {
@@ -79,7 +80,7 @@ export const createAddKeyedWiring = (config) => {
                 logger.critical(ErrorCode.MISSING_NAME, `${config.label} '${nameValue}' is missing the required 'schema' property or schema is not a variable reference.`);
                 return;
             }
-            if (rotationPeriodValue) {
+            if (rotationPeriodValue && rotationPeriodValue !== 'never') {
                 try {
                     parseDurationString(rotationPeriodValue);
                 }
@@ -88,6 +89,24 @@ export const createAddKeyedWiring = (config) => {
                     return;
                 }
             }
+            let generateValue;
+            const generateObj = config.idField === 'secretId'
+                ? getObjectPropertyLiteral(obj, 'generate')
+                : null;
+            if (generateObj) {
+                const sizeValue = getPropertyValue(generateObj, 'size');
+                if (typeof sizeValue !== 'number' ||
+                    !Number.isInteger(sizeValue) ||
+                    sizeValue < SECRET_GENERATE_MIN_SIZE) {
+                    logger.critical(ErrorCode.INVALID_VALUE, `${config.label} '${nameValue}' needs a 'generate' size of at least ${SECRET_GENERATE_MIN_SIZE} bytes.`);
+                    return;
+                }
+                if (!rotationPeriodValue) {
+                    logger.critical(ErrorCode.INVALID_VALUE, `${config.label} '${nameValue}' is generated, so it needs a 'rotationPeriod' such as '30day', or 'never' to generate it once.`);
+                    return;
+                }
+                generateValue = { size: sizeValue };
+            }
             const sourceFile = node.getSourceFile().fileName;
             const wiringState = config.getState(state);
             wiringState.files.add(sourceFile);
@@ -105,6 +124,7 @@ export const createAddKeyedWiring = (config) => {
                 displayName: displayNameValue,
                 description: descriptionValue || undefined,
                 rotationPeriod: rotationPeriodValue || undefined,
+                generate: generateValue,
                 docsUrl: docsUrlValue || undefined,
                 allowedHosts: allowedHostsValue || undefined,
                 [config.idField]: idValue,

package/dist/add/add-middleware.js

@@ -4,6 +4,7 @@ import { extractServicesFromFunction, extractUsedWires, } from '../utils/extract
 import { extractMiddlewareRefs } from '../utils/middleware.js';
 import { getPropertyValue } from '../utils/get-property-value.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { MIDDLEWARE_HELPERS, resolveCalleeName, } from '../utils/resolve-callee-name.js';
 /**
  * Record a middleware group, keeping any registration already stored under the
  * same pattern or tag.
@@ -113,11 +114,11 @@ function renameTempDefinitions(state, definitionIds, groupType, groupKey, storeK
 export const addMiddleware = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node))
         return;
-    const { expression, arguments: args } = node;
-    if (!ts.isIdentifier(expression)) {
+    const { arguments: args } = node;
+    const callee = resolveCalleeName(node, checker, MIDDLEWARE_HELPERS);
+    if (!callee)
         return;
-    }
-    if (expression.text === 'pikkuMiddleware') {
+    if (callee === 'pikkuMiddleware') {
         const arg = args[0];
         if (!arg)
             return;
@@ -174,7 +175,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found middleware with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
         return;
     }
-    if (expression.text === 'pikkuMiddlewareFactory') {
+    if (callee === 'pikkuMiddlewareFactory') {
         const factoryNode = args[0];
         if (!factoryNode)
             return;
@@ -192,8 +193,8 @@ export const addMiddleware = (logger, node, checker, state) => {
         let description;
         const findPikkuMiddlewareCall = (node) => {
             if (ts.isCallExpression(node)) {
-                const expr = node.expression;
-                if (ts.isIdentifier(expr) && expr.text === 'pikkuMiddleware') {
+                if (resolveCalleeName(node, checker, MIDDLEWARE_HELPERS) ===
+                    'pikkuMiddleware') {
                     return node;
                 }
             }
@@ -260,7 +261,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found middleware factory with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
         return;
     }
-    if (expression.text === 'addTagMiddleware') {
+    if (callee === 'addTagMiddleware') {
         const tagArg = args[0];
         const middlewareArrayArg = args[1];
         if (!tagArg || !middlewareArrayArg)
@@ -335,7 +336,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found tag middleware group: ${tag} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
         return;
     }
-    if (expression.text === 'addGlobalMiddleware') {
+    if (callee === 'addGlobalMiddleware') {
         const middlewareArrayArg = args[0];
         if (!middlewareArrayArg ||
             !ts.isArrayLiteralExpression(middlewareArrayArg)) {
@@ -362,7 +363,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found global middleware group with ${refs.length} entries`);
         return;
     }
-    if (expression.text === 'addHTTPMiddleware') {
+    if (callee === 'addHTTPMiddleware') {
         const patternArg = args[0];
         const middlewareArrayArg = args[1];
         if (!patternArg || !middlewareArrayArg)
@@ -438,7 +439,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found HTTP route middleware group: ${pattern} -> [${instanceIds.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
         return;
     }
-    if (expression.text === 'pikkuChannelMiddleware') {
+    if (callee === 'pikkuChannelMiddleware') {
         const arg = args[0];
         if (!arg)
             return;
@@ -476,7 +477,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found channel middleware with services: ${services.services.join(', ')}`);
         return;
     }
-    if (expression.text === 'pikkuChannelMiddlewareFactory') {
+    if (callee === 'pikkuChannelMiddlewareFactory') {
         const factoryNode = args[0];
         if (!factoryNode)
             return;
@@ -488,8 +489,8 @@ export const addMiddleware = (logger, node, checker, state) => {
         let services = { optimized: false, services: [] };
         const findPikkuChannelMiddlewareCall = (n) => {
             if (ts.isCallExpression(n)) {
-                const expr = n.expression;
-                if (ts.isIdentifier(expr) && expr.text === 'pikkuChannelMiddleware') {
+                if (resolveCalleeName(n, checker, MIDDLEWARE_HELPERS) ===
+                    'pikkuChannelMiddleware') {
                     return n;
                 }
             }
@@ -539,7 +540,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found channel middleware factory with services: ${services.services.join(', ')}`);
         return;
     }
-    if (expression.text === 'pikkuAgentMiddleware') {
+    if (callee === 'pikkuAgentMiddleware') {
         const arg = args[0];
         if (!arg)
             return;
@@ -587,7 +588,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         logger.debug(`• Found AI middleware with services: ${services.services.join(', ')}`);
         return;
     }
-    if (expression.text === 'addChannelMiddleware') {
+    if (callee === 'addChannelMiddleware') {
         const tagArg = args[0];
         const middlewareArrayArg = args[1];
         if (!tagArg || !middlewareArrayArg)

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

@@ -1,5 +1,2 @@
 import type { AddWiring } from '../types.js';
-/**
- * Inspect pikkuPermission, pikkuAuth, and pikkuPermissionFactory definitions.
- */
 export declare const addPermission: AddWiring;