@pikku/inspector 0.12.22 → 0.12.24

package/dist/add/add-http-routes.js

@@ -1,31 +1,40 @@
 import * as ts from 'typescript';
 import { getPropertyValue } from '../utils/get-property-value.js';
-import { registerHTTPRoute } from './add-http-route.js';
+import { registerHTTPRoute, registerHTTPRouteMeta } from './add-http-route.js';
 import { resolveIdentifier } from '../utils/resolve-identifier.js';
-/**
- * Process wireHTTPRoutes calls
- */
-export const addHTTPRoutes = (logger, node, checker, state, _options) => {
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { resolveAddonName } from '../utils/resolve-addon-package.js';
+import { resolveRefContract, } from '../utils/resolve-ref-contract.js';
+import { getExportedVariableName } from '../utils/get-exported-variable-name.js';
+export const addHTTPRoutes = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args } = node;
-    if (!ts.isIdentifier(expression) || expression.text !== 'wireHTTPRoutes')
+    if (!ts.isIdentifier(expression))
+        return;
+    if (expression.text === 'defineHTTPRoutes') {
+        const exportName = getExportedVariableName(node, options.sourceFile);
+        const firstArg = args[0];
+        if (exportName && firstArg && ts.isObjectLiteralExpression(firstArg)) {
+            const contract = serializeHTTPRoutesContract(firstArg, checker, state);
+            if (contract) {
+                state.exportedContracts.http[exportName] = contract;
+            }
+        }
+        return;
+    }
+    if (expression.text !== 'wireHTTPRoutes')
         return;
     const firstArg = args[0];
     if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
         return;
-    // Extract group config
     const groupConfig = extractGroupConfig(firstArg);
-    // Get routes property
     const routesProp = getPropertyAssignment(firstArg, 'routes');
     if (!routesProp)
         return;
-    // Process routes recursively
     processRoutes(routesProp.initializer, groupConfig, state, checker, logger, node.getSourceFile());
 };
-/**
- * Get a property assignment from an object literal
- */
 function getPropertyAssignment(obj, propName) {
     for (const prop of obj.properties) {
         if (ts.isPropertyAssignment(prop) &&
@@ -36,9 +45,6 @@ function getPropertyAssignment(obj, propName) {
     }
     return undefined;
 }
-/**
- * Extract group configuration from an object literal
- */
 function extractGroupConfig(obj) {
     const basePath = getPropertyValue(obj, 'basePath') || '';
     const tags = getPropertyValue(obj, 'tags') || [];
@@ -49,9 +55,6 @@ function extractGroupConfig(obj) {
         auth: auth === true ? true : auth === false ? false : undefined,
     };
 }
-/**
- * Merge two group configs following cascading rules
- */
 function mergeConfigs(parent, child) {
     return {
         basePath: parent.basePath + child.basePath,
@@ -59,9 +62,6 @@ function mergeConfigs(parent, child) {
         auth: child.auth ?? parent.auth,
     };
 }
-/**
- * Check if a value is a route config (has method, func, and route)
- */
 function isRouteConfig(obj) {
     let hasMethod = false;
     let hasFunc = false;
@@ -78,9 +78,6 @@ function isRouteConfig(obj) {
     }
     return hasMethod && hasFunc && hasRoute;
 }
-/**
- * Check if a value is a route contract (has routes property but no method/func)
- */
 function isRouteContract(obj) {
     let hasRoutes = false;
     let hasMethod = false;
@@ -97,11 +94,7 @@ function isRouteContract(obj) {
     }
     return hasRoutes && !hasMethod && !hasFunc;
 }
-/**
- * Recursively process routes - handles nested maps, contracts, and identifiers
- */
 function processRoutes(node, parentConfig, state, checker, logger, sourceFile) {
-    // Handle array of routes
     if (ts.isArrayLiteralExpression(node)) {
         for (const element of node.elements) {
             if (ts.isObjectLiteralExpression(element) && isRouteConfig(element)) {
@@ -110,14 +103,11 @@ function processRoutes(node, parentConfig, state, checker, logger, sourceFile) {
         }
         return;
     }
-    // Handle object literal
     if (ts.isObjectLiteralExpression(node)) {
-        // Check if this is a route config
         if (isRouteConfig(node)) {
             processRoute(node, parentConfig, state, checker, logger, sourceFile);
             return;
         }
-        // Check if this is a route contract
         if (isRouteContract(node)) {
             const contractConfig = extractGroupConfig(node);
             const mergedConfig = mergeConfigs(parentConfig, contractConfig);
@@ -127,15 +117,25 @@ function processRoutes(node, parentConfig, state, checker, logger, sourceFile) {
             }
             return;
         }
-        // Otherwise it's a nested map - process each property
         for (const prop of node.properties) {
             if (ts.isPropertyAssignment(prop)) {
+                const ref = resolveRefContract(prop.initializer, 'refHTTP', state.exportedContracts.addonHttp);
+                if (ref) {
+                    processRefHTTPContract(ref, parentConfig, state, logger, sourceFile);
+                    continue;
+                }
                 processRoutes(prop.initializer, parentConfig, state, checker, logger, sourceFile);
             }
         }
         return;
     }
-    // Handle identifier - resolve to its definition
+    if (ts.isCallExpression(node)) {
+        const ref = resolveRefContract(node, 'refHTTP', state.exportedContracts.addonHttp);
+        if (ref) {
+            processRefHTTPContract(ref, parentConfig, state, logger, sourceFile);
+        }
+        return;
+    }
     if (ts.isIdentifier(node)) {
         const resolved = resolveIdentifier(node, checker, ['defineHTTPRoutes']);
         if (resolved) {
@@ -143,9 +143,152 @@ function processRoutes(node, parentConfig, state, checker, logger, sourceFile) {
         }
     }
 }
-/**
- * Register a single route using the shared registerHTTPRoute function
- */
+function processRefHTTPContract(ref, parentConfig, state, logger, sourceFile) {
+    const basePath = ref.basePath !== undefined ? ref.basePath : ref.contract.basePath || '';
+    processExportedRouteMap(ref.contract.routes, mergeConfigs(parentConfig, {
+        basePath,
+        tags: ref.contract.tags || [],
+        auth: ref.contract.auth,
+    }), state, logger, sourceFile);
+}
+function processExportedRouteMap(routes, parentConfig, state, logger, sourceFile) {
+    for (const value of Object.values(routes)) {
+        if (isExportedRouteConfig(value)) {
+            registerHTTPRouteMeta({
+                route: value,
+                state,
+                logger,
+                sourceFile,
+                basePath: parentConfig.basePath,
+                inheritedTags: parentConfig.tags,
+                inheritedAuth: parentConfig.auth,
+            });
+            continue;
+        }
+        if (isExportedRouteContract(value)) {
+            processExportedRouteMap(value.routes, mergeConfigs(parentConfig, {
+                basePath: value.basePath || '',
+                tags: value.tags || [],
+                auth: value.auth,
+            }), state, logger, sourceFile);
+            continue;
+        }
+        processExportedRouteMap(value, parentConfig, state, logger, sourceFile);
+    }
+}
+function isExportedRouteConfig(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'method' in value &&
+        'route' in value &&
+        'func' in value);
+}
+function isExportedRouteContract(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'routes' in value &&
+        !('method' in value));
+}
+function serializeHTTPRoutesContract(node, checker, state) {
+    if (isRouteContract(node)) {
+        const routesProp = getPropertyAssignment(node, 'routes');
+        if (!routesProp || !ts.isObjectLiteralExpression(routesProp.initializer)) {
+            return null;
+        }
+        return {
+            ...extractGroupConfig(node),
+            routes: serializeHTTPRouteMap(routesProp.initializer, checker, state),
+        };
+    }
+    return {
+        routes: serializeHTTPRouteMap(node, checker, state),
+    };
+}
+function serializeHTTPRouteMap(node, checker, state) {
+    const result = {};
+    for (const prop of node.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const key = prop.name.getText().replace(/^['"]|['"]$/g, '');
+        const value = prop.initializer;
+        if (ts.isObjectLiteralExpression(value)) {
+            if (isRouteConfig(value)) {
+                const route = serializeHTTPRouteConfig(value, checker, state);
+                if (route) {
+                    result[key] = route;
+                }
+                continue;
+            }
+            if (isRouteContract(value)) {
+                const routeContract = serializeHTTPRoutesContract(value, checker, state);
+                if (routeContract) {
+                    result[key] = routeContract;
+                }
+                continue;
+            }
+            result[key] = serializeHTTPRouteMap(value, checker, state);
+            continue;
+        }
+        if (ts.isIdentifier(value)) {
+            const resolved = resolveIdentifier(value, checker, ['defineHTTPRoutes']);
+            if (resolved && ts.isObjectLiteralExpression(resolved)) {
+                if (isRouteContract(resolved)) {
+                    const routeContract = serializeHTTPRoutesContract(resolved, checker, state);
+                    if (routeContract) {
+                        result[key] = routeContract;
+                    }
+                }
+                else {
+                    result[key] = serializeHTTPRouteMap(resolved, checker, state);
+                }
+            }
+        }
+    }
+    return result;
+}
+function serializeHTTPRouteConfig(obj, checker, state) {
+    const method = getPropertyValue(obj, 'method');
+    const route = getPropertyValue(obj, 'route');
+    const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+    if (!method || !route || !funcInitializer) {
+        return null;
+    }
+    let pikkuFuncId = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncId;
+    let packageName;
+    if (ts.isCallExpression(funcInitializer) &&
+        ts.isIdentifier(funcInitializer.expression) &&
+        funcInitializer.expression.text === 'ref') {
+        const [firstArg] = funcInitializer.arguments;
+        if (firstArg && ts.isStringLiteral(firstArg)) {
+            pikkuFuncId = firstArg.text;
+            const addonNamespace = pikkuFuncId.includes(':')
+                ? pikkuFuncId.split(':')[0]
+                : null;
+            packageName = addonNamespace
+                ? state.rpc.wireAddonDeclarations.get(addonNamespace)?.package
+                : undefined;
+        }
+    }
+    else if (ts.isIdentifier(funcInitializer)) {
+        packageName =
+            resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations) || undefined;
+    }
+    return {
+        auth: getPropertyValue(obj, 'auth'),
+        contentType: getPropertyValue(obj, 'contentType'),
+        headers: getPropertyValue(obj, 'headers') ||
+            undefined,
+        method,
+        route,
+        sse: getPropertyValue(obj, 'sse'),
+        tags: getPropertyValue(obj, 'tags') || undefined,
+        timeout: getPropertyValue(obj, 'timeout'),
+        func: {
+            pikkuFuncId,
+            ...(packageName && { packageName }),
+        },
+    };
+}
 function processRoute(obj, groupConfig, state, checker, logger, sourceFile) {
     registerHTTPRoute({
         obj,

package/dist/error-codes.d.ts

@@ -57,7 +57,9 @@ export declare enum ErrorCode {
     SERVICES_NOT_DESTRUCTURED = "PKU410",
     WIRES_NOT_DESTRUCTURED = "PKU411",
     WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED = "PKU901",
-    PII_IN_OUTPUT = "PKU910"
+    PII_IN_OUTPUT = "PKU910",
+    ADDON_WIRING_NOT_ALLOWED = "PKU920",
+    ADDON_CONTRACT_HANDLERS_NOT_ALLOWED = "PKU921"
 }
 /**
  * Severity of a tracked, coded diagnostic. `critical` always blocks the build;

package/dist/error-codes.js

@@ -72,4 +72,7 @@ export var ErrorCode;
     ErrorCode["WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED"] = "PKU901";
     // Data classification errors
     ErrorCode["PII_IN_OUTPUT"] = "PKU910";
+    // Addon authoring errors
+    ErrorCode["ADDON_WIRING_NOT_ALLOWED"] = "PKU920";
+    ErrorCode["ADDON_CONTRACT_HANDLERS_NOT_ALLOWED"] = "PKU921";
 })(ErrorCode || (ErrorCode = {}));

package/dist/inspector.js

@@ -1,5 +1,6 @@
 import * as ts from 'typescript';
 import { performance } from 'perf_hooks';
+import { resolve } from 'path';
 import { visitSetup, visitRoutes } from './visit.js';
 import { TypesMap } from './types-map.js';
 import { getFilesAndMethods } from './utils/get-files-and-methods.js';
@@ -185,10 +186,19 @@ export function getInitialInspectorState(rootDir) {
         openAPISpec: null,
         diagnostics: [],
         addonFunctions: {},
+        exportedContracts: {
+            http: {},
+            cli: {},
+            channel: {},
+            addonHttp: {},
+            addonCli: {},
+            addonChannel: {},
+        },
         program: null,
     };
 }
 export const inspect = async (logger, routeFiles, options = {}) => {
+    const normalizedRouteFiles = routeFiles.map((file) => resolve(file));
     const compilerOptions = {
         target: ts.ScriptTarget.ESNext,
         module: ts.ModuleKind.Node16,
@@ -200,14 +210,14 @@ export const inspect = async (logger, routeFiles, options = {}) => {
         checkJs: false,
     };
     const startProgram = performance.now();
-    const program = ts.createProgram(routeFiles, compilerOptions, undefined, // host
+    const program = ts.createProgram(normalizedRouteFiles, compilerOptions, undefined, // host
     options.oldProgram);
-    logger.debug(`Created program in ${(performance.now() - startProgram).toFixed(0)}ms (${routeFiles.length} files${options.oldProgram ? ', incremental' : ''})`);
+    logger.debug(`Created program in ${(performance.now() - startProgram).toFixed(0)}ms (${normalizedRouteFiles.length} files${options.oldProgram ? ', incremental' : ''})`);
     const startChecker = performance.now();
     const checker = program.getTypeChecker();
     logger.debug(`Got type checker in ${(performance.now() - startChecker).toFixed(2)}ms`);
     // Use provided rootDir or infer from source files
-    const rootDir = options.rootDir || findCommonAncestor(routeFiles);
+    const rootDir = options.rootDir || findCommonAncestor(normalizedRouteFiles);
     const startSourceFiles = performance.now();
     // node_modules under rootDir (e.g. a locally-installed addon) is a
     // dependency, not project source — scanning it double-counts the addon's
@@ -221,7 +231,8 @@ export const inspect = async (logger, routeFiles, options = {}) => {
     // First sweep: add all functions
     const startSetup = performance.now();
     for (const sourceFile of sourceFiles) {
-        ts.forEachChild(sourceFile, (child) => visitSetup(logger, checker, child, state, options));
+        const sourceOptions = { ...options, sourceFile };
+        ts.forEachChild(sourceFile, (child) => visitSetup(logger, checker, child, state, sourceOptions));
     }
     logger.debug(`Visit setup phase completed in ${(performance.now() - startSetup).toFixed(0)}ms`);
     // Load addon function metadata so wirings can reference addon functions
@@ -230,7 +241,8 @@ export const inspect = async (logger, routeFiles, options = {}) => {
         // Second sweep: add all transports
         const startRoutes = performance.now();
         for (const sourceFile of sourceFiles) {
-            ts.forEachChild(sourceFile, (child) => visitRoutes(logger, checker, child, state, options));
+            const sourceOptions = { ...options, sourceFile };
+            ts.forEachChild(sourceFile, (child) => visitRoutes(logger, checker, child, state, sourceOptions));
         }
         logger.debug(`Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(0)}ms`);
         resolveLatestVersions(state, logger);

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type * as ts from 'typescript';
-import type { ChannelsMeta } from '@pikku/core/channel';
+import type { ChannelMessageMeta, ChannelsMeta } from '@pikku/core/channel';
 import type { GatewaysMeta } from '@pikku/core/gateway';
 import type { HTTPWiringsMeta } from '@pikku/core/http';
 import type { ScheduledTasksMeta } from '@pikku/core/scheduler';
@@ -9,6 +9,7 @@ import type { WorkflowsMeta } from '@pikku/core/workflow';
 import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
 import type { AIAgentMeta } from '@pikku/core/ai-agent';
 import type { CLIMeta } from '@pikku/core/cli';
+import type { CLICommandMeta } from '@pikku/core/cli';
 import type { NodesMeta } from '@pikku/core/node';
 import type { SecretDefinitions } from '@pikku/core/secret';
 import type { CredentialDefinitions } from '@pikku/core/credential';
@@ -80,6 +81,45 @@ export interface InspectorChannelState {
     meta: ChannelsMeta;
     files: Set<string>;
 }
+export interface ExportedHTTPRouteFunctionMeta {
+    pikkuFuncId: string;
+    packageName?: string;
+}
+export interface ExportedHTTPRouteConfigMeta {
+    method: string;
+    route: string;
+    func: ExportedHTTPRouteFunctionMeta;
+    auth?: boolean;
+    tags?: string[];
+    sse?: boolean;
+    contentType?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+export interface ExportedHTTPRoutesGroupMeta {
+    basePath?: string;
+    tags?: string[];
+    auth?: boolean;
+    routes: ExportedHTTPRouteMapMeta;
+}
+export type ExportedHTTPRouteEntryMeta = ExportedHTTPRouteConfigMeta | ExportedHTTPRoutesGroupMeta | ExportedHTTPRouteMapMeta;
+export interface ExportedHTTPRouteMapMeta {
+    [key: string]: ExportedHTTPRouteEntryMeta;
+}
+export type ExportedHTTPContractsMeta = Record<string, ExportedHTTPRoutesGroupMeta>;
+export interface ExportedChannelRouteMeta extends ChannelMessageMeta {
+    auth?: boolean;
+}
+export type ExportedChannelContractsMeta = Record<string, Record<string, ExportedChannelRouteMeta>>;
+export type ExportedCLIContractsMeta = Record<string, Record<string, CLICommandMeta>>;
+export interface InspectorExportedContractsState {
+    http: ExportedHTTPContractsMeta;
+    cli: ExportedCLIContractsMeta;
+    channel: ExportedChannelContractsMeta;
+    addonHttp: Record<string, ExportedHTTPContractsMeta>;
+    addonCli: Record<string, ExportedCLIContractsMeta>;
+    addonChannel: Record<string, ExportedChannelContractsMeta>;
+}
 export interface InspectorMiddlewareDefinition {
     services: FunctionServicesMeta;
     wires?: FunctionWiresMeta;
@@ -167,6 +207,7 @@ export type InspectorOptions = Partial<{
     setupOnly: boolean;
     rootDir: string;
     isAddon: boolean;
+    sourceFile: ts.SourceFile;
     types: Partial<{
         configFileType: string;
         userSessionType: string;
@@ -390,6 +431,11 @@ export interface InspectorState {
          *  codebase, if any. The CLI generates the `/auth/*` HTTP wiring from it.
          *  More than one `pikkuBetterAuth` is a critical error. */
         definition: AuthDefinition | null;
+        /** True when a user (non-generated) file already registers
+         *  `betterAuthStatelessSession(...)`. The CLI then skips auto-generating its
+         *  own default-map stateless middleware, which would otherwise pre-empt the
+         *  user's custom mapSession (pikkujs/pikku#754). */
+        userStatelessSession?: boolean;
     };
     secrets: {
         definitions: SecretDefinitions;
@@ -444,5 +490,6 @@ export interface InspectorState {
     openAPISpec: Record<string, any> | null;
     diagnostics: InspectorDiagnostic[];
     addonFunctions: Record<string, FunctionsMeta>;
+    exportedContracts: InspectorExportedContractsState;
     program: ts.Program | null;
 }

package/dist/utils/get-exported-variable-name.d.ts

@@ -0,0 +1,2 @@
+import * as ts from 'typescript';
+export declare const getExportedVariableName: (node: ts.Node, sourceFile: ts.SourceFile | undefined) => string | null;

package/dist/utils/get-exported-variable-name.js

@@ -0,0 +1,34 @@
+import * as ts from 'typescript';
+const isExportedVariableStatement = (statement) => ts.isVariableStatement(statement) &&
+    (statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ??
+        false);
+export const getExportedVariableName = (node, sourceFile) => {
+    if (!sourceFile) {
+        return null;
+    }
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+        for (const statement of sourceFile.statements) {
+            if (!isExportedVariableStatement(statement))
+                continue;
+            for (const declaration of statement.declarationList.declarations) {
+                if (declaration === node) {
+                    return node.name.text;
+                }
+            }
+        }
+    }
+    if (!ts.isCallExpression(node)) {
+        return null;
+    }
+    for (const statement of sourceFile.statements) {
+        if (!isExportedVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name) &&
+                declaration.initializer === node) {
+                return declaration.name.text;
+            }
+        }
+    }
+    return null;
+};

package/dist/utils/load-addon-functions-meta.js

@@ -1,6 +1,74 @@
 import { readFile, readdir } from 'fs/promises';
 import { createRequire } from 'module';
 import { join, dirname } from 'path';
+const isHTTPRouteConfig = (value) => typeof value === 'object' &&
+    value !== null &&
+    'method' in value &&
+    'func' in value &&
+    'route' in value;
+const isHTTPRouteGroup = (value) => typeof value === 'object' &&
+    value !== null &&
+    'routes' in value &&
+    !('method' in value);
+const applyPackageToHTTPRouteMap = (routes, packageName, namespace) => {
+    for (const value of Object.values(routes)) {
+        if (!value || typeof value !== 'object')
+            continue;
+        if (isHTTPRouteConfig(value)) {
+            if (!value.func.packageName) {
+                value.func.packageName = packageName;
+            }
+            if (namespace && !value.func.pikkuFuncId.includes(':')) {
+                value.func.pikkuFuncId = `${namespace}:${value.func.pikkuFuncId}`;
+            }
+            continue;
+        }
+        if (isHTTPRouteGroup(value)) {
+            applyPackageToHTTPRouteMap(value.routes, packageName, namespace);
+            continue;
+        }
+        applyPackageToHTTPRouteMap(value, packageName, namespace);
+    }
+};
+const applyPackageToHTTPContracts = (contracts, packageName, namespace) => {
+    for (const contract of Object.values(contracts)) {
+        applyPackageToHTTPRouteMap(contract.routes, packageName, namespace);
+    }
+};
+const applyPackageToCLICommands = (commands, packageName, namespace) => {
+    for (const command of Object.values(commands)) {
+        if (command && typeof command === 'object') {
+            if (!command.packageName && command.pikkuFuncId) {
+                command.packageName = packageName;
+            }
+            if (namespace &&
+                typeof command.pikkuFuncId === 'string' &&
+                !command.pikkuFuncId.includes(':')) {
+                command.pikkuFuncId = `${namespace}:${command.pikkuFuncId}`;
+            }
+            if (command.subcommands) {
+                applyPackageToCLICommands(command.subcommands, packageName, namespace);
+            }
+        }
+    }
+};
+const applyPackageToCLIContracts = (contracts, packageName, namespace) => {
+    for (const commands of Object.values(contracts)) {
+        applyPackageToCLICommands(commands, packageName, namespace);
+    }
+};
+const applyPackageToChannelContracts = (contracts, packageName, namespace) => {
+    for (const routes of Object.values(contracts)) {
+        for (const route of Object.values(routes)) {
+            if (!route.packageName) {
+                route.packageName = packageName;
+            }
+            if (!route.pikkuFuncId.includes(':')) {
+                route.pikkuFuncId = `${namespace}:${route.pikkuFuncId}`;
+            }
+        }
+    }
+};
 /**
  * After the setup sweep discovers wireAddon() declarations, load each addon
  * package's function metadata so that wiring handlers (channels, HTTP routes,
@@ -81,6 +149,36 @@ export async function loadAddonFunctionsMeta(logger, state) {
             catch {
                 // No services gen — addon may not have requiredParentServices
             }
+            try {
+                const httpContractsPath = require.resolve(`${decl.package}/.pikku/http/pikku-http-contracts-meta.gen.json`);
+                const httpContractsRaw = await readFile(httpContractsPath, 'utf-8');
+                const httpContracts = JSON.parse(httpContractsRaw);
+                applyPackageToHTTPContracts(httpContracts, decl.package, namespace);
+                state.exportedContracts.addonHttp[namespace] = httpContracts;
+            }
+            catch {
+                // No addon HTTP contracts metadata
+            }
+            try {
+                const cliContractsPath = require.resolve(`${decl.package}/.pikku/cli/pikku-cli-contracts-meta.gen.json`);
+                const cliContractsRaw = await readFile(cliContractsPath, 'utf-8');
+                const cliContracts = JSON.parse(cliContractsRaw);
+                applyPackageToCLIContracts(cliContracts, decl.package, namespace);
+                state.exportedContracts.addonCli[namespace] = cliContracts;
+            }
+            catch {
+                // No addon CLI contracts metadata
+            }
+            try {
+                const channelContractsPath = require.resolve(`${decl.package}/.pikku/channel/pikku-channel-contracts-meta.gen.json`);
+                const channelContractsRaw = await readFile(channelContractsPath, 'utf-8');
+                const channelContracts = JSON.parse(channelContractsRaw);
+                applyPackageToChannelContracts(channelContracts, decl.package, namespace);
+                state.exportedContracts.addonChannel[namespace] = channelContracts;
+            }
+            catch {
+                // No addon channel contracts metadata
+            }
         }
         catch (error) {
             logger.warn(`Failed to load addon function metadata for '${namespace}' (${decl.package}): ${error.message}`);

package/dist/utils/post-process.js

@@ -245,9 +245,22 @@ export function aggregateRequiredServices(state) {
     if (Object.keys(state.channels.meta).length > 0) {
         requiredServices.add('eventHub');
     }
-    // 7. Services that addons need from the parent project
-    for (const service of state.addonRequiredParentServices ?? []) {
-        requiredServices.add(service);
+    // 7. Services that consumed addons need from the parent project.
+    // These are required ONLY by units that actually deploy an addon function;
+    // a unit that merely calls the addon over RPC (or never touches it) must not
+    // carry them, or every per-unit bundle would over-include the addon's
+    // parent-service dependencies (e.g. aiAgentRunner, deploymentService) and
+    // defeat per-unit tree-shaking.
+    const addonFuncIds = new Set();
+    for (const fns of Object.values(state.addonFunctions ?? {})) {
+        for (const id of Object.keys(fns))
+            addonFuncIds.add(id);
+    }
+    const unitDeploysAddonFn = [...usedFunctions].some((fn) => addonFuncIds.has(fn));
+    if (unitDeploysAddonFn) {
+        for (const service of state.addonRequiredParentServices ?? []) {
+            requiredServices.add(service);
+        }
     }
 }
 export function validateSecretOverrides(logger, state) {

package/dist/utils/resolve-addon-package.js

@@ -61,8 +61,10 @@ export const resolveAddonName = (identifier, checker, wireAddonDeclarations) =>
     // Bare package import path
     if (candidatePackage && !candidatePackage.startsWith('.')) {
         for (const addonDecl of wireAddonDeclarations.values()) {
-            if (addonDecl.package === candidatePackage)
+            if (addonDecl.package === candidatePackage ||
+                candidatePackage.startsWith(`${addonDecl.package}/`)) {
                 return addonDecl.package;
+            }
         }
     }
     // Fall back to package.json lookup based on the declaration's source file.