@pikku/inspector 0.12.22 → 0.12.23

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.12.23
+
+### Patch Changes
+
+- 807a8d0: Add `refHTTP` / `refChannel` / `refCLI` so a consumer can wire an addon's HTTP routes, channel actions, and CLI commands directly from the addon's published `.pikku` contract metadata — no addon source is imported and nothing is hand-wired. These mirror the existing `ref('namespace:fn')` helper: each reference resolves the addon's already-loaded contract (via `wireAddon`) and proxies every function through `ref()` (RPC) at runtime.
+  - **Inspector:** `wireHTTPRoutes`/`wireChannel`/`wireCLI` now expand `refHTTP('ns:contract')` / `refChannel('ns:contract')` / `refCLI('ns:contract')` call expressions against `state.exportedContracts.addon{Http,Channel,Cli}` (already namespaced and `packageName`-tagged by `loadAddonFunctionsMeta`). An optional second argument overrides the mount basePath, e.g. `refHTTP('ext:helloRoutes', { basePath: '/ext' })`; otherwise the addon contract's own basePath is preserved.
+  - **CLI codegen:** the generated `pikku-function-types.gen.ts` now emits `refHTTP`/`refChannel`/`refCLI` (exported through `#pikku`) backed by const maps built from each wired addon's contract metadata, with every function pre-bound to `ref('ns:fn')`. Type-checking and runtime wiring resolve from the same generated artifact, so a reference can never be an inert marker.
+  - **Addon authoring bans:** when inspecting an addon package (`isAddon`), the inspector now raises a critical error if the addon calls a transport wiring helper (`wireHTTP`/`wireHTTPRoutes`/`wireChannel`/`wireCLI`/`wireScheduler`/`wireQueueWorker`/`wireMCPPrompt`/`wireMCPResource`/`wireTrigger`/`wireTriggerSource`/`wireGateway`/`wireAddon`) — these are the consuming app's responsibility (`PKU920`) — or if a `define*` contract carries `middleware`/`permissions`, which the consuming app applies, not the addon (`PKU921`). Service declarations (`wireSecret`/`wireVariable`/`wireCredential`) and function-level middleware/permissions remain allowed.
+  - **Deploy-bundle fix:** the HTTP/channel/CLI codegen commands now always emit their wiring and meta gen files once they report the category as active (truthy return), including the contracts-only or synthetic-route case where there are no local `wireHTTP`/`addChannel`/`wireCLI` source files. The generated bootstrap imports those files unconditionally, so skipping them left per-unit deploy bundles (e.g. Cloudflare units for scheduled tasks and workflow steps) unable to resolve `pikku-http-wirings.gen.js` and failing to build.
+
 ## 0.12.22
 
 ### Patch Changes

package/dist/add/add-addon-bans.d.ts

@@ -0,0 +1,7 @@
+import type { AddWiring } from '../types.js';
+/**
+ * Enforce addon authoring rules. Only runs when inspecting an addon package
+ * (options.isAddon). Addons cannot wire transports, and their contracts cannot
+ * carry middleware or permissions — those are the consuming app's concern.
+ */
+export declare const checkAddonBans: AddWiring;

package/dist/add/add-addon-bans.js

@@ -0,0 +1,65 @@
+import * as ts from 'typescript';
+import { ErrorCode } from '../error-codes.js';
+/**
+ * Wiring helpers an addon must not call. Addons declare contracts with the
+ * define* helpers and export functions; the consuming app does the wiring via
+ * refHTTP / refChannel / refCLI. Service declarations remain allowed.
+ */
+const BANNED_WIRINGS = new Set([
+    'wireAddon',
+    'wireChannel',
+    'wireCLI',
+    'wireGateway',
+    'wireHTTP',
+    'wireHTTPRoutes',
+    'wireMCPPrompt',
+    'wireMCPResource',
+    'wireQueueWorker',
+    'wireScheduler',
+    'wireTrigger',
+    'wireTriggerSource',
+]);
+const CONTRACT_DEFINERS = new Set([
+    'defineHTTPRoutes',
+    'defineChannelRoutes',
+    'defineCLICommands',
+]);
+const hasHandlerProperty = (node) => {
+    let found = false;
+    const visit = (current) => {
+        if (found)
+            return;
+        if (ts.isPropertyAssignment(current) &&
+            (ts.isIdentifier(current.name) || ts.isStringLiteral(current.name)) &&
+            (current.name.text === 'middleware' ||
+                current.name.text === 'permissions')) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(current, visit);
+    };
+    visit(node);
+    return found;
+};
+/**
+ * Enforce addon authoring rules. Only runs when inspecting an addon package
+ * (options.isAddon). Addons cannot wire transports, and their contracts cannot
+ * carry middleware or permissions — those are the consuming app's concern.
+ */
+export const checkAddonBans = (logger, node, _checker, _state, options) => {
+    if (!options.isAddon)
+        return;
+    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression))
+        return;
+    const name = node.expression.text;
+    if (BANNED_WIRINGS.has(name)) {
+        logger.critical(ErrorCode.ADDON_WIRING_NOT_ALLOWED, `Addons must not call '${name}'. Declare contracts with define* and export functions; the consuming app wires them via refHTTP / refChannel / refCLI.`);
+        return;
+    }
+    if (CONTRACT_DEFINERS.has(name)) {
+        const [arg] = node.arguments;
+        if (arg && hasHandlerProperty(arg)) {
+            logger.critical(ErrorCode.ADDON_CONTRACT_HANDLERS_NOT_ALLOWED, `Addon contract '${name}' must not declare middleware or permissions — these are applied by the consuming app, not the addon.`);
+        }
+    }
+};

package/dist/add/add-channel.js

@@ -10,6 +10,8 @@ import { resolveIdentifier } from '../utils/resolve-identifier.js';
 import { resolveFunctionMeta } from '../utils/resolve-function-meta.js';
 import { resolveAddonName } from '../utils/resolve-addon-package.js';
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js';
+import { getExportedVariableName } from '../utils/get-exported-variable-name.js';
+import { resolveRefContract } from '../utils/resolve-ref-contract.js';
 /**
  * Safely get the "initializer" expression of a property-like AST node:
  * - for `foo: expr`, returns `expr`
@@ -25,6 +27,17 @@ function getInitializerOf(elem) {
     }
     return undefined;
 }
+function getObjectPropertyName(name) {
+    if (!name)
+        return null;
+    if (ts.isIdentifier(name))
+        return name.text;
+    if (ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+        return name.text;
+    if (ts.isComputedPropertyName(name))
+        return null;
+    return name.getText();
+}
 /**
  * Resolve a handler expression (Identifier, CallExpression, or { func })
  * into its underlying function name.
@@ -84,6 +97,14 @@ function getHandlerNameFromExpression(expr, checker, rootDir) {
     }
     return null;
 }
+function extractExportedChannelRoutes(logger, routes, state, checker) {
+    const wrapper = ts.factory.createObjectLiteralExpression([
+        ts.factory.createPropertyAssignment('onMessageWiring', ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment('contract', routes),
+        ])),
+    ]);
+    return addMessagesRoutes(logger, wrapper, state, checker).contract ?? {};
+}
 /**
  * Build out the nested message-routes by looking up each handler
  * in state.functions.meta instead of re-inferring it here.
@@ -108,9 +129,21 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                 chanInit = resolved;
             }
         }
+        const refContract = resolveRefContract(chanInit, 'refChannel', state.exportedContracts.addonChannel);
+        if (refContract) {
+            const refChannelKey = getObjectPropertyName(chanElem.name);
+            if (!refChannelKey)
+                continue;
+            result[refChannelKey] = {
+                ...refContract.contract,
+            };
+            continue;
+        }
         if (!ts.isObjectLiteralExpression(chanInit))
             continue;
-        const channelKey = chanElem.name.getText();
+        const channelKey = getObjectPropertyName(chanElem.name);
+        if (!channelKey)
+            continue;
         result[channelKey] = {};
         for (const routeElem of chanInit.properties) {
             const init = getInitializerOf(routeElem);
@@ -120,11 +153,9 @@ export function addMessagesRoutes(logger, obj, state, checker) {
             const routeName = routeElem.name;
             if (!routeName)
                 continue;
-            let routeKey = routeName.getText();
-            // For string literals like 'greet' or "greet", strip the quotes
-            if (ts.isStringLiteral(routeName)) {
-                routeKey = routeName.text;
-            }
+            const routeKey = getObjectPropertyName(routeName);
+            if (!routeKey)
+                continue;
             // For shorthand properties, we need to resolve the identifier to its declaration
             if (ts.isShorthandPropertyAssignment(routeElem)) {
                 // Get the symbol for the shorthand property
@@ -359,6 +390,16 @@ export function addMessagesRoutes(logger, obj, state, checker) {
 export const addChannel = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node))
         return;
+    if (ts.isIdentifier(node.expression) &&
+        node.expression.text === 'defineChannelRoutes') {
+        const exportName = getExportedVariableName(node, options.sourceFile);
+        const [firstArg] = node.arguments;
+        if (exportName && firstArg && ts.isObjectLiteralExpression(firstArg)) {
+            state.exportedContracts.channel[exportName] =
+                extractExportedChannelRoutes(logger, firstArg, state, checker);
+        }
+        return;
+    }
     const { expression, arguments: args } = node;
     if (!ts.isIdentifier(expression) || expression.text !== 'wireChannel')
         return;

package/dist/add/add-cli.js

@@ -8,6 +8,8 @@ import { resolveIdentifier } from '../utils/resolve-identifier.js';
 import { resolveAddonName } from '../utils/resolve-addon-package.js';
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js';
 import { extractServicesFromFunction } from '../utils/extract-services.js';
+import { getExportedVariableName } from '../utils/get-exported-variable-name.js';
+import { resolveRefContract } from '../utils/resolve-ref-contract.js';
 // Track if we've warned about missing Config type to avoid duplicate warnings
 const configTypeWarningShown = new Set();
 /**
@@ -16,6 +18,15 @@ const configTypeWarningShown = new Set();
 export const addCLI = (logger, node, typeChecker, inspectorState, options) => {
     if (!ts.isCallExpression(node))
         return;
+    if (ts.isIdentifier(node.expression) &&
+        node.expression.text === 'defineCLICommands') {
+        const exportName = getExportedVariableName(node, options.sourceFile);
+        const [firstArg] = node.arguments;
+        if (exportName && firstArg && ts.isObjectLiteralExpression(firstArg)) {
+            inspectorState.exportedContracts.cli[exportName] = processCommands(logger, firstArg, node.getSourceFile(), typeChecker, exportName, inspectorState, options);
+        }
+        return;
+    }
     // Check if this is a wireCLI call
     if (!node || !node.expression) {
         return;
@@ -129,6 +140,12 @@ function processCommands(logger, node, sourceFile, typeChecker, programName, ins
                 const spreadCommands = processCommands(logger, spreadTarget, sourceFile, typeChecker, programName, inspectorState, options, programTags);
                 Object.assign(commands, spreadCommands);
             }
+            else {
+                const refCommands = resolveRefContract(prop.expression, 'refCLI', inspectorState.exportedContracts.addonCli);
+                if (refCommands) {
+                    Object.assign(commands, refCommands.contract);
+                }
+            }
             continue;
         }
         if (!ts.isPropertyAssignment(prop))

package/dist/add/add-http-route.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import type { AddWiring, InspectorState } from '../types.js';
+import type { AddWiring, ExportedHTTPRouteConfigMeta, InspectorState } from '../types.js';
 import type { InspectorLogger } from '../types.js';
 /**
  * Parameters for registering an HTTP route
@@ -14,11 +14,21 @@ export interface RegisterHTTPRouteParams {
     inheritedTags?: string[];
     inheritedAuth?: boolean;
 }
+export interface RegisterHTTPRouteMetaParams {
+    route: ExportedHTTPRouteConfigMeta;
+    state: InspectorState;
+    logger: InspectorLogger;
+    sourceFile: ts.SourceFile;
+    basePath?: string;
+    inheritedTags?: string[];
+    inheritedAuth?: boolean;
+}
 /**
  * Shared function to register an HTTP route in the inspector state.
  * Used by both wireHTTP and wireHTTPRoutes.
  */
 export declare function registerHTTPRoute({ obj, state, checker, logger, sourceFile, basePath, inheritedTags, inheritedAuth, }: RegisterHTTPRouteParams): void;
+export declare function registerHTTPRouteMeta({ route, state, logger, sourceFile, basePath, inheritedTags, inheritedAuth, }: RegisterHTTPRouteMetaParams): void;
 /**
  * Process wireHTTP calls
  */

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

@@ -251,6 +251,43 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
         groupBasePath: basePath || undefined,
     };
 }
+export function registerHTTPRouteMeta({ route, state, logger, sourceFile, basePath = '', inheritedTags = [], inheritedAuth, }) {
+    const method = route.method.toLowerCase();
+    const fullRoute = basePath + route.route;
+    const tags = [...inheritedTags, ...(route.tags || [])];
+    const funcName = route.func.pikkuFuncId;
+    const fnMeta = resolveFunctionMeta(state, funcName);
+    if (!fnMeta) {
+        logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${funcName}'.`);
+        return;
+    }
+    let params = [];
+    try {
+        const keys = pathToRegexp(fullRoute).keys;
+        params = keys.filter((k) => k.type === 'param').map((k) => k.name);
+    }
+    catch (error) {
+        logger.error(`Failed to parse route '${fullRoute}': ${error instanceof Error ? error.message : error}`);
+        return;
+    }
+    if (!route.func.packageName) {
+        computeInputTypes(state.http.metaInputTypes, method, fnMeta.inputs?.[0] || null, [], params);
+    }
+    state.serviceAggregation.usedFunctions.add(funcName);
+    state.http.files.add(sourceFile.fileName);
+    state.http.meta[method][fullRoute] = {
+        pikkuFuncId: funcName,
+        ...(route.func.packageName && { packageName: route.func.packageName }),
+        route: fullRoute,
+        sourceFile: sourceFile.fileName,
+        method: method,
+        params: params.length > 0 ? params : undefined,
+        inputTypes: undefined,
+        tags: tags.length > 0 ? tags : undefined,
+        sse: route.sse ? true : undefined,
+        groupBasePath: basePath || undefined,
+    };
+}
 /**
  * Process wireHTTP calls
  */

package/dist/add/add-http-routes.d.ts

@@ -1,5 +1,2 @@
 import type { AddWiring } from '../types.js';
-/**
- * Process wireHTTPRoutes calls
- */
 export declare const addHTTPRoutes: AddWiring;

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 = {}));