@pikku/inspector 0.12.7 → 0.12.8

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 ## 0.12.0
 
+## 0.12.8
+
+### Patch Changes
+
+- 624097e: Add deploy pipeline with provider-agnostic architecture
+
+  - Add MetaService with explicit typed API, absorb WiringService reads
+  - Add deployment service, traceId propagation, scoped logger
+  - Rewrite analyzer: one function = one worker, gateways dispatch via RPC
+  - Add Cloudflare deploy provider with plan/apply commands
+  - Add per-unit filtered codegen for deploy pipeline
+  - Skip missing metadata in wiring registration for deploy units
+  - Fix schema coercion crash when schema has no properties
+  - Fix E2E codegen: double-pass resolves cross-package Zod type imports
+
+- Updated dependencies [9e8605f]
+- Updated dependencies [624097e]
+- Updated dependencies [7ab3243]
+  - @pikku/core@0.12.15
+
 ## 0.12.7
 
 ### Patch Changes

package/dist/add/add-ai-agent.js

@@ -33,7 +33,7 @@ function resolveToolReferences(obj, checker, agentName, logger) {
                     continue;
                 }
             }
-            if (calleeName === 'addon') {
+            if (calleeName === 'ref') {
                 const [firstArg] = element.arguments;
                 if (firstArg && ts.isStringLiteral(firstArg)) {
                     resolved.push(firstArg.text);
@@ -163,11 +163,12 @@ export const addAIAgent = (logger, node, checker, state, options) => {
         if (disabled)
             return;
         const modelValue = getPropertyValue(obj, 'model');
-        const instructionsValue = getPropertyValue(obj, 'instructions');
+        const roleValue = getPropertyValue(obj, 'role');
+        const personalityValue = getPropertyValue(obj, 'personality');
+        const goalValue = getPropertyValue(obj, 'goal');
         const maxStepsValue = getPropertyValue(obj, 'maxSteps');
         const temperatureValue = getPropertyValue(obj, 'temperature');
         const toolChoiceValue = getPropertyValue(obj, 'toolChoice');
-        const dynamicWorkflowsValue = getPropertyValue(obj, 'dynamicWorkflows');
         const toolsValue = resolveToolReferences(obj, checker, nameValue || '', logger);
         if (toolsValue) {
             for (const toolName of toolsValue) {
@@ -291,10 +292,14 @@ export const addAIAgent = (logger, node, checker, state, options) => {
         state.agents.agentsMeta[agentKey] = {
             name: nameValue,
             description,
-            instructions: instructionsValue || '',
+            role: roleValue || undefined,
+            personality: personalityValue || undefined,
+            goal: goalValue || '',
             model: modelValue || '',
             summary,
             errors,
+            sourceFile: node.getSourceFile().fileName,
+            exportedName: exportedName || undefined,
             ...(maxStepsValue !== null && { maxSteps: maxStepsValue }),
             ...(temperatureValue !== null && { temperature: temperatureValue }),
             ...(toolChoiceValue !== null && {
@@ -302,9 +307,6 @@ export const addAIAgent = (logger, node, checker, state, options) => {
             }),
             ...(toolsValue !== null && { tools: toolsValue }),
             ...(agentsValue !== null && { agents: agentsValue }),
-            ...(dynamicWorkflowsValue !== null && {
-                dynamicWorkflows: dynamicWorkflowsValue,
-            }),
             tags,
             inputSchema,
             outputSchema,
@@ -314,5 +316,20 @@ export const addAIAgent = (logger, node, checker, state, options) => {
             aiMiddleware,
             permissions,
         };
+        // AI agent functions require platform services that aren't visible
+        // through parameter destructuring
+        const funcMeta = state.functions.meta[agentKey];
+        if (funcMeta?.services) {
+            for (const svc of [
+                'aiStorage',
+                'aiRunState',
+                'agentRunService',
+                'aiAgentRunner',
+            ]) {
+                if (!funcMeta.services.services.includes(svc)) {
+                    funcMeta.services.services.push(svc);
+                }
+            }
+        }
     }
 };

package/dist/add/add-channel.js

@@ -65,8 +65,8 @@ function getHandlerNameFromExpression(expr, checker, rootDir) {
     }
     // Handle call expressions
     if (ts.isCallExpression(expr)) {
-        // Handle addon('namespace:funcName') calls
-        if (ts.isIdentifier(expr.expression) && expr.expression.text === 'addon') {
+        // Handle ref('name') calls
+        if (ts.isIdentifier(expr.expression) && expr.expression.text === 'ref') {
             const [firstArg] = expr.arguments;
             if (firstArg && ts.isStringLiteral(firstArg)) {
                 return firstArg.text;

package/dist/add/add-cli.js

@@ -206,22 +206,25 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
         if (propName === 'func') {
             if (ts.isCallExpression(prop.initializer) &&
                 ts.isIdentifier(prop.initializer.expression) &&
-                prop.initializer.expression.text === 'addon') {
+                prop.initializer.expression.text === 'ref') {
                 const [firstArg] = prop.initializer.arguments;
                 if (!firstArg || !ts.isStringLiteral(firstArg)) {
-                    throw new Error(`addon() call requires a string literal argument in the form "namespace:funcName"`);
+                    throw new Error(`ref() call requires a string literal argument`);
                 }
                 pikkuFuncId = firstArg.text;
-                const addonNamespace = pikkuFuncId.split(':')[0];
-                if (!addonNamespace || !pikkuFuncId.includes(':')) {
-                    throw new Error(`Malformed addon function ID "${pikkuFuncId}": expected "namespace:funcName" format`);
-                }
-                if (!inspectorState.rpc.wireAddonDeclarations.has(addonNamespace)) {
-                    throw new Error(`Unknown addon namespace "${addonNamespace}" in "${pikkuFuncId}": no matching wireAddonDeclarations entry found`);
+                const addonNamespace = pikkuFuncId.includes(':')
+                    ? pikkuFuncId.split(':')[0]
+                    : null;
+                if (addonNamespace) {
+                    if (!inspectorState.rpc.wireAddonDeclarations.has(addonNamespace)) {
+                        throw new Error(`Unknown addon namespace "${addonNamespace}" in "${pikkuFuncId}": no matching wireAddonDeclarations entry found`);
+                    }
                 }
                 meta.pikkuFuncId = pikkuFuncId;
-                meta.packageName =
-                    inspectorState.rpc.wireAddonDeclarations.get(addonNamespace).package;
+                if (addonNamespace) {
+                    meta.packageName =
+                        inspectorState.rpc.wireAddonDeclarations.get(addonNamespace).package;
+                }
             }
             else {
                 pikkuFuncId = extractFunctionName(prop.initializer, typeChecker, inspectorState.rootDir).pikkuFuncId;

package/dist/add/add-file-with-factory.js

@@ -40,10 +40,7 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         typePath: typeDeclarationPath,
                     });
                     methods.set(fileName, variables);
-                    // Extract singleton services for CreateWireServices factories
-                    if (expectedTypeName === 'CreateWireServices' &&
-                        state &&
-                        callExpression.arguments.length > 0) {
+                    if (state && callExpression.arguments.length > 0) {
                         const firstArg = callExpression.arguments[0];
                         let functionNode;
                         if (ts.isArrowFunction(firstArg)) {
@@ -52,10 +49,30 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         else if (ts.isFunctionExpression(firstArg)) {
                             functionNode = firstArg;
                         }
-                        if (functionNode) {
+                        // Extract singleton services for CreateWireServices factories
+                        if (expectedTypeName === 'CreateWireServices' && functionNode) {
                             const servicesMeta = extractServicesFromFunction(functionNode);
                             state.wireServicesMeta.set(variableName, servicesMeta.services);
                         }
+                        // Extract existing services an addon needs from the parent
+                        // (second parameter of pikkuAddonServices callback)
+                        if (wrapperFunctionName === 'pikkuAddonServices' &&
+                            functionNode &&
+                            functionNode.parameters.length >= 2) {
+                            const secondParam = functionNode.parameters[1];
+                            if (secondParam && ts.isObjectBindingPattern(secondParam.name)) {
+                                for (const elem of secondParam.name.elements) {
+                                    const name = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                                        ? elem.propertyName.text
+                                        : ts.isIdentifier(elem.name)
+                                            ? elem.name.text
+                                            : undefined;
+                                    if (name) {
+                                        state.addonRequiredParentServices.push(name);
+                                    }
+                                }
+                            }
+                        }
                     }
                     return; // Early return since we found a match
                 }

package/dist/add/add-functions.js

@@ -594,6 +594,8 @@ export const addFunctions = (logger, node, checker, state, options) => {
         middleware,
         permissions,
         isDirectFunction,
+        sourceFile: node.getSourceFile().fileName,
+        exportedName: exportedName || undefined,
     };
     // Populate node metadata if node config is present
     if (nodeDisplayName && nodeCategory && nodeType) {

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

@@ -174,6 +174,7 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
         pikkuFuncId: funcName,
         ...(packageName && { packageName }),
         route: fullRoute,
+        sourceFile: sourceFile.fileName,
         method: method,
         params: params.length > 0 ? params : undefined,
         query: query.length > 0 ? query : undefined,

package/dist/add/add-rpc-invocations.js

@@ -19,8 +19,8 @@ export function addRPCInvocations(node, state, logger) {
     // Look for call expressions: addon('ext:hello') or rpc.invoke('...')
     if (ts.isCallExpression(node)) {
         const { expression, arguments: args } = node;
-        // Check for addon('namespace:function') calls
-        if (ts.isIdentifier(expression) && expression.text === 'addon') {
+        // Check for ref('name') calls
+        if (ts.isIdentifier(expression) && expression.text === 'ref') {
             const [firstArg] = args;
             if (firstArg && ts.isStringLiteral(firstArg)) {
                 const functionRef = firstArg.text;

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

@@ -1,4 +1,9 @@
 import type { AddWiring } from '../types.js';
+import type { WorkflowStepMeta } from '@pikku/core/workflow';
+/**
+ * Recursively collect all RPC names from workflow steps
+ */
+export declare function collectInvokedRPCs(steps: WorkflowStepMeta[], rpcs: Set<string>): void;
 /**
  * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
  * Detects workflow registration and extracts metadata

package/dist/add/add-workflow.js

@@ -43,7 +43,7 @@ function hasInlineSteps(steps) {
 /**
  * Recursively collect all RPC names from workflow steps
  */
-function collectInvokedRPCs(steps, rpcs) {
+export function collectInvokedRPCs(steps, rpcs) {
     for (const step of steps) {
         if (step.type === 'rpc' && step.rpcName) {
             rpcs.add(step.rpcName);
@@ -183,6 +183,7 @@ export const addWorkflow = (logger, node, checker, state) => {
     let description;
     let errors;
     let inline;
+    let expose;
     if (ts.isObjectLiteralExpression(firstArg)) {
         const metadata = getCommonWireMetaData(firstArg, 'Workflow', workflowName, logger);
         if (metadata.disabled)
@@ -195,6 +196,7 @@ export const addWorkflow = (logger, node, checker, state) => {
         if (inlineProp === true) {
             inline = true;
         }
+        expose = getPropertyValue(firstArg, 'expose');
     }
     // Validate that we got a valid function
     if (ts.isObjectLiteralExpression(firstArg) &&
@@ -278,5 +280,21 @@ export const addWorkflow = (logger, node, checker, state) => {
         errors,
         tags,
         inline,
+        expose,
     };
+    // Workflow functions require platform services that aren't visible
+    // through parameter destructuring (they're accessed via workflow.do/sleep)
+    const funcMeta = state.functions.meta[pikkuFuncId];
+    if (funcMeta?.services) {
+        for (const svc of [
+            'workflowService',
+            'workflowRunService',
+            'schedulerService',
+            'queueService',
+        ]) {
+            if (!funcMeta.services.services.includes(svc)) {
+                funcMeta.services.services.push(svc);
+            }
+        }
+    }
 };

package/dist/inspector.js

@@ -28,6 +28,7 @@ export function getInitialInspectorState(rootDir) {
         singletonServicesFactories: new Map(),
         wireServicesFactories: new Map(),
         wireServicesMeta: new Map(),
+        addonRequiredParentServices: [],
         configFactories: new Map(),
         filesAndMethods: {},
         filesAndMethodsErrors: new Map(),

package/dist/types.d.ts

@@ -264,6 +264,7 @@ export interface InspectorState {
     singletonServicesFactories: PathToNameAndType;
     wireServicesFactories: PathToNameAndType;
     wireServicesMeta: Map<string, string[]>;
+    addonRequiredParentServices: string[];
     configFactories: PathToNameAndType;
     filesAndMethods: InspectorFilesAndMethods;
     filesAndMethodsErrors: Map<string, PathToNameAndType>;

package/dist/utils/filter-inspector-state.js

@@ -139,6 +139,10 @@ export function filterInspectorState(state, filters, logger) {
             (!filters.httpMethods || filters.httpMethods.length === 0))) {
         return state;
     }
+    // Snapshot the original workflow graph meta before filtering prunes it
+    const originalGraphMeta = {
+        ...(state.workflows?.graphMeta ?? {}),
+    };
     // Create a shallow copy with new Maps/Sets to avoid mutating the original
     const filteredState = {
         ...state,
@@ -149,11 +153,21 @@ export function filterInspectorState(state, filters, logger) {
             usedMiddleware: new Set(),
             usedPermissions: new Set(),
         },
+        functions: {
+            ...state.functions,
+            meta: JSON.parse(JSON.stringify(state.functions.meta)), // Deep clone to avoid mutating original
+            files: new Map(state.functions.files),
+        },
         http: {
             ...state.http,
             meta: JSON.parse(JSON.stringify(state.http.meta)), // Deep clone metadata
             files: new Set(), // Will be repopulated with filtered files
         },
+        workflows: {
+            ...state.workflows,
+            graphMeta: JSON.parse(JSON.stringify(state.workflows?.graphMeta ?? {})),
+            meta: JSON.parse(JSON.stringify(state.workflows?.meta ?? {})),
+        },
         channels: {
             ...state.channels,
             meta: JSON.parse(JSON.stringify(state.channels.meta)),
@@ -186,6 +200,14 @@ export function filterInspectorState(state, filters, logger) {
             agentsMeta: JSON.parse(JSON.stringify(state.agents?.agentsMeta ?? {})),
             files: new Map(),
         },
+        rpc: {
+            ...state.rpc,
+            internalMeta: { ...state.rpc.internalMeta }, // Clone to avoid mutating original
+            internalFiles: new Map(state.rpc.internalFiles),
+            exposedMeta: { ...state.rpc.exposedMeta },
+            exposedFiles: new Map(state.rpc.exposedFiles),
+            invokedFunctions: new Set(state.rpc.invokedFunctions),
+        },
         cli: {
             ...state.cli,
             meta: JSON.parse(JSON.stringify(state.cli.meta)),
@@ -216,16 +238,33 @@ export function filterInspectorState(state, filters, logger) {
                 // Track used functions/middleware/permissions
                 if (routeMeta.pikkuFuncId) {
                     filteredState.serviceAggregation.usedFunctions.add(routeMeta.pikkuFuncId);
+                    // For workflow/agent routes, also add the base name
+                    // so the workflow/agent definition survives pruning
+                    const colonIdx = routeMeta.pikkuFuncId.indexOf(':');
+                    if (colonIdx !== -1) {
+                        filteredState.serviceAggregation.usedFunctions.add(routeMeta.pikkuFuncId.slice(colonIdx + 1));
+                    }
                 }
                 extractWireNames(routeMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
                 extractWireNames(routeMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
             }
         }
     }
-    // Repopulate http.files if any routes remain
-    const hasHttpRoutes = Object.values(filteredState.http.meta).some((routes) => Object.keys(routes).length > 0);
-    if (hasHttpRoutes) {
-        filteredState.http.files = new Set(state.http.files);
+    // Repopulate http.files with only files that have surviving routes
+    for (const method of Object.keys(filteredState.http.meta)) {
+        const routes = filteredState.http.meta[method];
+        for (const routeMeta of Object.values(routes)) {
+            if (routeMeta.sourceFile) {
+                filteredState.http.files.add(routeMeta.sourceFile);
+            }
+        }
+    }
+    // Fallback: if no sourceFile info available but routes exist, include all files
+    if (filteredState.http.files.size === 0) {
+        const hasHttpRoutes = Object.values(filteredState.http.meta).some((routes) => Object.keys(routes).length > 0);
+        if (hasHttpRoutes) {
+            filteredState.http.files = new Set(state.http.files);
+        }
     }
     // Filter channels
     for (const name of Object.keys(filteredState.channels.meta)) {
@@ -239,9 +278,30 @@ export function filterInspectorState(state, filters, logger) {
             delete filteredState.channels.meta[name];
         }
         else {
-            if (channelMeta.pikkuFuncId) {
+            // Add all functions referenced by this channel
+            if ('pikkuFuncId' in channelMeta && channelMeta.pikkuFuncId) {
                 filteredState.serviceAggregation.usedFunctions.add(channelMeta.pikkuFuncId);
             }
+            if (channelMeta.connect?.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(channelMeta.connect.pikkuFuncId);
+            }
+            if (channelMeta.disconnect?.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(channelMeta.disconnect.pikkuFuncId);
+            }
+            if (channelMeta.message?.pikkuFuncId) {
+                filteredState.serviceAggregation.usedFunctions.add(channelMeta.message.pikkuFuncId);
+            }
+            if (channelMeta.messageWirings) {
+                for (const groupKey of Object.keys(channelMeta.messageWirings)) {
+                    const commands = channelMeta.messageWirings[groupKey];
+                    for (const cmdKey of Object.keys(commands)) {
+                        const wiring = commands[cmdKey];
+                        if (wiring.pikkuFuncId) {
+                            filteredState.serviceAggregation.usedFunctions.add(wiring.pikkuFuncId);
+                        }
+                    }
+                }
+            }
             extractWireNames(channelMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
             extractWireNames(channelMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
         }
@@ -307,6 +367,10 @@ export function filterInspectorState(state, filters, logger) {
         else {
             if (workerMeta.pikkuFuncId) {
                 filteredState.serviceAggregation.usedFunctions.add(workerMeta.pikkuFuncId);
+                const colonIdx = workerMeta.pikkuFuncId.indexOf(':');
+                if (colonIdx !== -1) {
+                    filteredState.serviceAggregation.usedFunctions.add(workerMeta.pikkuFuncId.slice(colonIdx + 1));
+                }
             }
             extractWireNames(workerMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
         }
@@ -444,6 +508,30 @@ export function filterInspectorState(state, filters, logger) {
     if (hasCliPrograms || hasCliRenderers) {
         filteredState.cli.files = new Set(state.cli.files);
     }
+    // Direct function filtering: functions that match the names/tags/directories
+    // filters should be included even if no wiring (HTTP, scheduler, etc.) references them.
+    // This ensures standalone RPC-callable functions survive filtering.
+    // Only run when function-level filters are active — httpRoutes/httpMethods work
+    // through the HTTP wiring pass which already adds the right functions.
+    const hasFunctionLevelFilters = (filters.names && filters.names.length > 0) ||
+        (filters.tags && filters.tags.length > 0) ||
+        (filters.directories && filters.directories.length > 0);
+    for (const funcId of Object.keys(filteredState.functions.meta)) {
+        if (!hasFunctionLevelFilters)
+            break;
+        const funcMeta = filteredState.functions.meta[funcId];
+        const funcFile = filteredState.functions.files.get(funcId);
+        const filePath = funcFile?.path;
+        const matches = matchesFilters(filters, {
+            type: 'rpc',
+            name: funcId,
+            tags: funcMeta.tags,
+            filePath,
+        }, logger);
+        if (matches) {
+            filteredState.serviceAggregation.usedFunctions.add(funcId);
+        }
+    }
     // Post-filter version expansion: include all versions of matched functions
     const includedBaseNames = new Set();
     for (const funcId of filteredState.serviceAggregation.usedFunctions) {
@@ -458,6 +546,117 @@ export function filterInspectorState(state, filters, logger) {
             }
         }
     }
+    // Prune functions.meta and functions.files to only include used functions
+    if (filteredState.serviceAggregation.usedFunctions.size > 0) {
+        for (const funcId of Object.keys(filteredState.functions.meta)) {
+            if (!filteredState.serviceAggregation.usedFunctions.has(funcId)) {
+                delete filteredState.functions.meta[funcId];
+                filteredState.functions.files.delete(funcId);
+            }
+        }
+        // Prune channels whose functions were filtered out
+        for (const name of Object.keys(filteredState.channels.meta)) {
+            const channelMeta = filteredState.channels.meta[name];
+            // Check if any of the channel's functions are in the used set
+            const channelFuncIds = [];
+            if (channelMeta.connect?.pikkuFuncId)
+                channelFuncIds.push(channelMeta.connect.pikkuFuncId);
+            if (channelMeta.disconnect?.pikkuFuncId)
+                channelFuncIds.push(channelMeta.disconnect.pikkuFuncId);
+            if (channelMeta.message?.pikkuFuncId)
+                channelFuncIds.push(channelMeta.message.pikkuFuncId);
+            if (channelMeta.messageWirings) {
+                for (const groupKey of Object.keys(channelMeta.messageWirings)) {
+                    const commands = channelMeta.messageWirings[groupKey];
+                    for (const cmdKey of Object.keys(commands)) {
+                        const wiring = commands[cmdKey];
+                        if (wiring.pikkuFuncId)
+                            channelFuncIds.push(wiring.pikkuFuncId);
+                    }
+                }
+            }
+            const hasUsedFunc = channelFuncIds.some((id) => filteredState.serviceAggregation.usedFunctions.has(id));
+            if (channelFuncIds.length > 0 && !hasUsedFunc) {
+                delete filteredState.channels.meta[name];
+            }
+        }
+        // Prune workflow graphs whose function was filtered out
+        const workflowKeys = new Set([
+            ...Object.keys(filteredState.workflows.graphMeta),
+            ...Object.keys(filteredState.workflows.meta),
+        ]);
+        for (const name of workflowKeys) {
+            const graphMeta = filteredState.workflows.graphMeta[name];
+            const workflowMeta = filteredState.workflows.meta[name];
+            // Check both graphMeta.pikkuFuncId and meta.pikkuFuncId
+            const pikkuFuncId = graphMeta?.pikkuFuncId ?? workflowMeta?.pikkuFuncId;
+            if (pikkuFuncId &&
+                !filteredState.serviceAggregation.usedFunctions.has(pikkuFuncId)) {
+                delete filteredState.workflows.graphMeta[name];
+                delete filteredState.workflows.meta[name];
+            }
+            else if (!pikkuFuncId) {
+                // No function ID found — prune it
+                delete filteredState.workflows.graphMeta[name];
+                delete filteredState.workflows.meta[name];
+            }
+        }
+        // Prune RPC meta to only include entries whose target function survived
+        const survivingFuncIds = new Set(Object.keys(filteredState.functions.meta));
+        for (const key of Object.keys(filteredState.rpc.internalMeta)) {
+            const targetFuncId = filteredState.rpc.internalMeta[key];
+            if (!survivingFuncIds.has(targetFuncId) && !survivingFuncIds.has(key)) {
+                delete filteredState.rpc.internalMeta[key];
+                filteredState.rpc.internalFiles.delete(key);
+            }
+        }
+        for (const key of Object.keys(filteredState.rpc.exposedMeta)) {
+            const targetFuncId = filteredState.rpc.exposedMeta[key];
+            if (!survivingFuncIds.has(targetFuncId) && !survivingFuncIds.has(key)) {
+                delete filteredState.rpc.exposedMeta[key];
+                filteredState.rpc.exposedFiles.delete(key);
+            }
+        }
+        // Prune invokedFunctions to match surviving functions
+        for (const funcId of filteredState.rpc.invokedFunctions) {
+            if (!survivingFuncIds.has(funcId)) {
+                filteredState.rpc.invokedFunctions.delete(funcId);
+            }
+        }
+    }
+    // Recompute requiredSchemas based on pruned functions.meta
+    if (filteredState.serviceAggregation.usedFunctions.size > 0) {
+        const prunedSchemas = new Set();
+        for (const funcMeta of Object.values(filteredState.functions.meta)) {
+            if (funcMeta.inputs?.[0])
+                prunedSchemas.add(funcMeta.inputs[0]);
+            if (funcMeta.outputs?.[0])
+                prunedSchemas.add(funcMeta.outputs[0]);
+        }
+        filteredState.requiredSchemas = prunedSchemas;
+    }
+    // If any surviving function is a non-inline workflow step, the unit needs
+    // workflowService + queueService even though the function doesn't use them.
+    // Check the ORIGINAL graph meta (before filtering pruned it).
+    const survivingFuncIds = new Set(Object.keys(filteredState.functions.meta));
+    // Use the snapshot taken before filtering
+    for (const graph of Object.values(originalGraphMeta)) {
+        if (!graph.nodes)
+            continue;
+        for (const node of Object.values(graph.nodes)) {
+            if (!('rpcName' in node) || !node.rpcName)
+                continue;
+            const rpcName = node.rpcName;
+            if (!survivingFuncIds.has(rpcName))
+                continue;
+            const isInline = node.options?.async !== true &&
+                graph.inline === true;
+            if (!isInline) {
+                filteredState.serviceAggregation.requiredServices.add('workflowService');
+                filteredState.serviceAggregation.requiredServices.add('queueService');
+            }
+        }
+    }
     // Recalculate requiredServices based on filtered functions/middleware/permissions
     // Need to cast to InspectorState temporarily for aggregateRequiredServices
     const stateForAggregation = filteredState;

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

@@ -34,6 +34,53 @@ export async function loadAddonFunctionsMeta(logger, state) {
                     }
                 }
             }
+            // Load addon secrets meta
+            try {
+                const secretsMetaPath = require.resolve(`${decl.package}/.pikku/secrets/pikku-secrets-meta.gen.json`);
+                const secretsRaw = await readFile(secretsMetaPath, 'utf-8');
+                const secretsMeta = JSON.parse(secretsRaw);
+                for (const [key, def] of Object.entries(secretsMeta)) {
+                    const existing = state.secrets.definitions.find((d) => d.name === key);
+                    if (!existing) {
+                        state.secrets.definitions.push(def);
+                        logger.debug(`Loaded addon secret '${key}' from ${decl.package}`);
+                    }
+                }
+            }
+            catch {
+                // No secrets meta — that's fine
+            }
+            // Load addon variables meta
+            try {
+                const variablesMetaPath = require.resolve(`${decl.package}/.pikku/variables/pikku-variables-meta.gen.json`);
+                const variablesRaw = await readFile(variablesMetaPath, 'utf-8');
+                const variablesMeta = JSON.parse(variablesRaw);
+                for (const [key, def] of Object.entries(variablesMeta)) {
+                    const existing = state.variables.definitions.find((d) => d.name === key);
+                    if (!existing) {
+                        state.variables.definitions.push(def);
+                        logger.debug(`Loaded addon variable '${key}' from ${decl.package}`);
+                    }
+                }
+            }
+            catch {
+                // No variables meta — that's fine
+            }
+            // Load addon required parent services from pikku-services.gen
+            try {
+                const servicesGenPath = require.resolve(`${decl.package}/.pikku/pikku-services.gen.js`);
+                const servicesModule = await import(servicesGenPath);
+                if (servicesModule.requiredParentServices &&
+                    Array.isArray(servicesModule.requiredParentServices)) {
+                    for (const service of servicesModule.requiredParentServices) {
+                        state.addonRequiredParentServices.push(service);
+                    }
+                    logger.debug(`Loaded ${servicesModule.requiredParentServices.length} required parent services for '${namespace}' from ${decl.package}`);
+                }
+            }
+            catch {
+                // No services gen — addon may not have requiredParentServices
+            }
         }
         catch (error) {
             logger.warn(`Failed to load addon function metadata for '${namespace}' (${decl.package}): ${error.message}`);