@pikku/inspector 0.12.33 → 0.12.35

package/CHANGELOG.md

@@ -1,3 +1,34 @@
+## 0.12.35
+
+### Patch Changes
+
+- 7ebea62: Tree-shake addon registrations in filtered inspector states (per-unit deploy codegen).
+  - `filterInspectorState` drops an addon's `wireAddonDeclarations`/`usedAddons` unless something kept actually references it (kept wiring targeting `namespace:*`, kept agent/MCP tool, or a body-level `rpc.invoke('namespace:*')` from a file that still contains a kept function). The generated per-unit bootstrap no longer imports unused addon package bootstraps — previously every deploy unit registered every addon's entire function surface, which pulled dev-only code (e.g. `@pikku/addon-console`'s static `node:fs` imports) into Cloudflare Worker bundles and failed upload with `No such module "node:fs"`.
+  - Body-level `rpc.invoke()` targets are now tracked per source file (`rpc.invokedFunctionsByFile`) so wiring-level `ref()` targets no longer pin an addon into every unit.
+  - `aggregateRequiredServices` computes addon parent services per used addon function (from the addon's shipped per-function `services` meta) instead of blanket-adding `addonRequiredParentServices` — and matches namespaced ids only, so bare project function names colliding with addon function names no longer force the blanket.
+  - Addon builds keep per-function `services` in the shipped `pikku-functions-meta.gen.json` so parent projects can do the above; addons built before this fall back to the blanket.
+  - HTTP route meta records `refTarget` for `ref('namespace:fn')`-wired routes, so per-unit filtering keeps the addon registration (and only that function's services) when the route deploys.
+
+- Updated dependencies [7ebea62]
+- Updated dependencies [e57dd65]
+  - @pikku/core@0.12.51
+
+## 0.12.34
+
+### Patch Changes
+
+- 92bd643: User flows in the console: workflow graph extraction now captures
+  `workflow.expectEventually` steps and per-step actor names (`{ actor:
+actors.x }`), workflow meta carries `actors`/`title` into the serialized
+  graph, the CLI emits `user-flow-actors.gen.json` for the new
+  `MetaService.getUserFlowActorsMeta()`, and the console Workflows page gains a
+  Workflows / User Flows / Personas toggle. Also fixes complex-workflow graphs
+  being clobbered by a duplicate basic-extraction pass after successful DSL
+  extraction.
+- Updated dependencies [35a9bab]
+- Updated dependencies [92bd643]
+  - @pikku/core@0.12.50
+
 ## 0.12.33
 
 ### Patch Changes

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

@@ -220,8 +220,10 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     const middleware = resolveHTTPMiddlewareFromObject(state, fullRoute, obj, tags, checker);
     // Resolve permissions
     const permissions = resolveHTTPPermissionsFromObject(state, fullRoute, obj, tags, checker);
-    // Track used functions/middleware/permissions for service aggregation
     state.serviceAggregation.usedFunctions.add(funcName);
+    if (refAddonTarget) {
+        state.serviceAggregation.usedFunctions.add(refAddonTarget);
+    }
     extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
     extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
     // Check for SSE
@@ -232,6 +234,7 @@ export function registerHTTPRoute({ obj, state, checker, logger, sourceFile, bas
     state.http.files.add(sourceFile.fileName);
     state.http.meta[method][fullRoute] = {
         pikkuFuncId: funcName,
+        ...(refAddonTarget && { refTarget: refAddonTarget }),
         ...(packageName && { packageName }),
         route: fullRoute,
         sourceFile: sourceFile.fileName,

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

@@ -85,10 +85,17 @@ export function addRPCInvocations(node, state, logger) {
                     const functionRef = firstArg.text;
                     logger.debug(`• Found RPC invocation: ${functionRef}`);
                     state.rpc.invokedFunctions.add(functionRef);
+                    let byFile = state.rpc.invokedFunctionsByFile.get(sourceFileName);
+                    if (!byFile) {
+                        byFile = new Set();
+                        state.rpc.invokedFunctionsByFile.set(sourceFileName, byFile);
+                    }
+                    byFile.add(functionRef);
                     const namespace = extractNamespace(functionRef);
                     if (namespace) {
                         logger.debug(`  → Addon detected: ${namespace}`);
                         state.rpc.usedAddons.add(namespace);
+                        state.serviceAggregation.usedFunctions.add(functionRef);
                     }
                 }
                 // Handle template literals like `function-${name}`

package/dist/add/add-workflow.js

@@ -5,7 +5,7 @@ import { ErrorCode } from '../error-codes.js';
 import { extractStringLiteral, isStringLike, isFunctionLike, extractDescription, extractDuration, } from '../utils/extract-node-value.js';
 import { getCommonWireMetaData, getPropertyValue, } from '../utils/get-property-value.js';
 import { extractDSLWorkflow } from '../utils/workflow/dsl/extract-dsl-workflow.js';
-import { getSourceText } from '../utils/workflow/dsl/patterns.js';
+import { getSourceText, extractActorFromOptions, } from '../utils/workflow/dsl/patterns.js';
 /**
  * Extract a workflow step's display name without letting a non-static name
  * (e.g. a function call) abort the scan. The step name is cosmetic, so a
@@ -86,14 +86,18 @@ export function collectInvokedRPCs(steps, rpcs) {
     }
 }
 /**
- * Scan for workflow.do(), workflow.sleep(), and workflow.cancel() calls to extract workflow steps
+ * Scan for workflow.do(), workflow.expectEventually(), workflow.sleep(), and
+ * workflow.cancel() calls to extract workflow steps
  */
 function getWorkflowInvocations(node, checker, state, workflowName, steps) {
     // Look for property access expressions: workflow.do or workflow.sleep
     if (ts.isPropertyAccessExpression(node)) {
         const { name } = node;
         // Check if this is accessing 'do' or 'sleep' property
-        if (name.text === 'do' || name.text === 'sleep' || name.text === 'cancel') {
+        if (name.text === 'do' ||
+            name.text === 'sleep' ||
+            name.text === 'cancel' ||
+            name.text === 'expectEventually') {
             // Check if the parent is a call expression
             const parent = node.parent;
             if (ts.isCallExpression(parent) && parent.expression === node) {
@@ -113,6 +117,7 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                             type: 'rpc',
                             stepName,
                             rpcName,
+                            actor: extractActorFromOptions(optionsArg),
                         });
                         state.rpc.invokedFunctions.add(rpcName);
                     }
@@ -125,6 +130,21 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                         });
                     }
                 }
+                else if (name.text === 'expectEventually' && args.length >= 4) {
+                    // workflow.expectEventually(stepName, rpcName, data, predicate, options?)
+                    const stepName = extractStepName(args[0], checker);
+                    if (isStringLike(args[1], checker)) {
+                        const rpcName = extractStringLiteral(args[1], checker);
+                        steps.push({
+                            type: 'rpc',
+                            stepName,
+                            rpcName,
+                            expectEventually: true,
+                            actor: extractActorFromOptions(args.length >= 5 ? args[4] : undefined),
+                        });
+                        state.rpc.invokedFunctions.add(rpcName);
+                    }
+                }
                 else if (name.text === 'sleep' && args.length >= 2) {
                     // workflow.sleep(stepName, duration)
                     const stepNameArg = args[0];
@@ -282,9 +302,19 @@ export const addWorkflow = (logger, node, checker, state) => {
     // For pikkuWorkflowComplexFunc, also run basic extraction so RPCs in
     // patterns the DSL extractor doesn't handle (array+push, nested Promise.all
     // with identifier args, etc.) are still registered as invoked functions.
+    // When DSL extraction already produced steps this pass is registration-only:
+    // appending to `steps` would duplicate nodes and clobber the graph.
     if (wrapperType !== 'dsl') {
-        getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
+        const sink = steps.length > 0 ? [] : steps;
+        getWorkflowInvocations(resolvedFunc, checker, state, workflowName, sink);
     }
+    // Actor names the flow's steps run as (user flows) — powers the console
+    // personas view and the User Flow graph badges.
+    const actorNames = [
+        ...new Set(steps
+            .map((s) => ('actor' in s ? s.actor : undefined))
+            .filter((a) => typeof a === 'string')),
+    ];
     state.workflows.meta[workflowName] = {
         pikkuFuncId,
         name: workflowName,
@@ -298,6 +328,7 @@ export const addWorkflow = (logger, node, checker, state) => {
         tags,
         expose,
         userFlow: wrapperType === 'user-flow' ? true : undefined,
+        actors: actorNames.length > 0 ? actorNames : undefined,
     };
     // User flows are pure stories of remote RPCs (same rule as client-side CLI
     // renderers): the func may only destructure logger/config — everything else

package/dist/inspector.js

@@ -93,6 +93,7 @@ export function getInitialInspectorState(rootDir) {
             exposedMeta: {},
             exposedFiles: new Map(),
             invokedFunctions: new Set(),
+            invokedFunctionsByFile: new Map(),
             usedAddons: new Set(),
             wireAddonDeclarations: new Map(),
             wireAddonFiles: new Set(),

package/dist/types.d.ts

@@ -413,6 +413,7 @@ export interface InspectorState {
             exportedName: string;
         }>;
         invokedFunctions: Set<string>;
+        invokedFunctionsByFile: Map<string, Set<string>>;
         usedAddons: Set<string>;
         wireAddonDeclarations: Map<string, {
             package: string;

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

@@ -366,6 +366,9 @@ export function filterInspectorState(state, filters, logger) {
                 // Track used functions/middleware/permissions
                 if (routeMeta.pikkuFuncId) {
                     filteredState.serviceAggregation.usedFunctions.add(routeMeta.pikkuFuncId);
+                    if (routeMeta.refTarget) {
+                        filteredState.serviceAggregation.usedFunctions.add(routeMeta.refTarget);
+                    }
                     // For workflow/agent routes, also add the base name
                     // so the workflow/agent definition survives pruning
                     const colonIdx = routeMeta.pikkuFuncId.indexOf(':');
@@ -796,6 +799,46 @@ export function filterInspectorState(state, filters, logger) {
     if (filteredState.serviceAggregation.requiredServices.has('workflowService')) {
         filteredState.serviceAggregation.requiredServices.add('queueService');
     }
+    if ((filteredState.rpc.wireAddonDeclarations?.size ?? 0) > 0) {
+        const referencedIds = new Set(filteredState.serviceAggregation.usedFunctions);
+        const keptFiles = new Set();
+        for (const funcId of filteredState.serviceAggregation.usedFunctions) {
+            const file = filteredState.functions.files.get(funcId);
+            if (file?.path)
+                keptFiles.add(file.path);
+        }
+        for (const [file, invoked] of state.rpc.invokedFunctionsByFile ??
+            new Map()) {
+            if (!keptFiles.has(file))
+                continue;
+            for (const id of invoked) {
+                referencedIds.add(id);
+                if (id.includes(':')) {
+                    filteredState.serviceAggregation.usedFunctions.add(id);
+                }
+            }
+        }
+        for (const toolMeta of Object.values(filteredState.mcpEndpoints?.toolsMeta ?? {})) {
+            if (toolMeta.pikkuFuncId)
+                referencedIds.add(toolMeta.pikkuFuncId);
+        }
+        for (const agentMeta of Object.values(filteredState.agents?.agentsMeta ?? {})) {
+            for (const tool of agentMeta.tools ?? [])
+                referencedIds.add(tool);
+        }
+        const keptNamespaces = new Set();
+        for (const namespace of filteredState.rpc.wireAddonDeclarations.keys()) {
+            const prefix = `${namespace}:`;
+            for (const id of referencedIds) {
+                if (id.startsWith(prefix)) {
+                    keptNamespaces.add(namespace);
+                    break;
+                }
+            }
+        }
+        filteredState.rpc.wireAddonDeclarations = new Map([...filteredState.rpc.wireAddonDeclarations].filter(([namespace]) => keptNamespaces.has(namespace)));
+        filteredState.rpc.usedAddons = new Set([...filteredState.rpc.usedAddons].filter((namespace) => keptNamespaces.has(namespace)));
+    }
     // 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

@@ -135,6 +135,7 @@ export async function loadAddonFunctionsMeta(logger, state) {
                 // No variables meta — that's fine
             }
             // Load addon serverlessIncompatible service names from pikku-addon-meta.gen.json
+            let loadedParentServices = false;
             try {
                 const addonMetaPath = require.resolve(`${decl.package}/.pikku/console/pikku-addon-meta.gen.json`);
                 const addonMetaRaw = await readFile(addonMetaPath, 'utf-8');
@@ -144,24 +145,29 @@ export async function loadAddonFunctionsMeta(logger, state) {
                     state.addonServerlessIncompatible.set(namespace, addonMeta.serverlessIncompatible);
                     logger.debug(`Addon '${namespace}' marks [${addonMeta.serverlessIncompatible.join(', ')}] as serverless-incompatible`);
                 }
-            }
-            catch {
-                // No addon meta or no serverlessIncompatible declared — 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) {
+                if (Array.isArray(addonMeta.requiredParentServices) &&
+                    addonMeta.requiredParentServices.length > 0) {
+                    for (const service of addonMeta.requiredParentServices) {
                         state.addonRequiredParentServices.push(service);
                     }
-                    logger.debug(`Loaded ${servicesModule.requiredParentServices.length} required parent services for '${namespace}' from ${decl.package}`);
+                    loadedParentServices = true;
+                    logger.debug(`Loaded ${addonMeta.requiredParentServices.length} required parent services for '${namespace}' from addon meta`);
                 }
             }
-            catch {
-                // No services gen — addon may not have requiredParentServices
+            catch { }
+            if (!loadedParentServices) {
+                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 { }
             }
             try {
                 const httpContractsPath = require.resolve(`${decl.package}/.pikku/http/pikku-http-contracts-meta.gen.json`);

package/dist/utils/post-process.js

@@ -253,19 +253,44 @@ export function aggregateRequiredServices(state) {
         requiredServices.add('eventHub');
     }
     // 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 ?? []) {
+    const addonFnServices = new Map();
+    for (const [namespace, fns] of Object.entries(state.addonFunctions ?? {})) {
+        for (const [id, meta] of Object.entries(fns)) {
+            addonFnServices.set(`${namespace}:${id}`, meta?.services?.services);
+        }
+    }
+    const parentDeclared = state.addonRequiredParentServices ?? [];
+    const parentDeclaredSet = new Set(parentDeclared);
+    const defaultServices = new Set([
+        'config',
+        'logger',
+        'variables',
+        'schema',
+        'secrets',
+    ]);
+    let usesAddonFn = false;
+    let addonFactoryNeeded = false;
+    for (const funcId of usedFunctions) {
+        if (!addonFnServices.has(funcId))
+            continue;
+        usesAddonFn = true;
+        const services = addonFnServices.get(funcId);
+        if (!services) {
+            addonFactoryNeeded = true;
+            continue;
+        }
+        for (const service of services) {
+            if (parentDeclaredSet.has(service)) {
+                requiredServices.add(service);
+            }
+            else if (!internalServices.has(service) &&
+                !defaultServices.has(service)) {
+                addonFactoryNeeded = true;
+            }
+        }
+    }
+    if (usesAddonFn && addonFactoryNeeded) {
+        for (const service of parentDeclared) {
             requiredServices.add(service);
         }
     }

package/dist/utils/serialize-inspector-state.d.ts

@@ -178,6 +178,7 @@ export interface SerializableInspectorState {
             exportedName: string;
         }]>;
         invokedFunctions: string[];
+        invokedFunctionsByFile?: Array<[string, string[]]>;
         usedAddons: string[];
         wireAddonDeclarations: Array<[
             string,

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

@@ -78,6 +78,7 @@ export function serializeInspectorState(state) {
             exposedMeta: state.rpc.exposedMeta,
             exposedFiles: Array.from(state.rpc.exposedFiles.entries()),
             invokedFunctions: Array.from(state.rpc.invokedFunctions),
+            invokedFunctionsByFile: Array.from((state.rpc.invokedFunctionsByFile ?? new Map()).entries()).map(([file, fns]) => [file, Array.from(fns)]),
             usedAddons: Array.from(state.rpc.usedAddons),
             wireAddonDeclarations: Array.from(state.rpc.wireAddonDeclarations.entries()),
             wireAddonFiles: Array.from(state.rpc.wireAddonFiles),
@@ -235,6 +236,7 @@ export function deserializeInspectorState(data) {
             exposedMeta: data.rpc.exposedMeta,
             exposedFiles: new Map(data.rpc.exposedFiles),
             invokedFunctions: new Set(data.rpc.invokedFunctions),
+            invokedFunctionsByFile: new Map((data.rpc.invokedFunctionsByFile || []).map(([file, fns]) => [file, new Set(fns)])),
             usedAddons: new Set(data.rpc.usedAddons || []),
             wireAddonDeclarations: new Map(data.rpc.wireAddonDeclarations || []),
             wireAddonFiles: new Set(data.rpc.wireAddonFiles || []),

package/dist/utils/workflow/dsl/extract-dsl-workflow.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { isWorkflowDoCall, isWorkflowSleepCall, isWorkflowSuspendCall, isThrowCancelException, extractCancelReason, isParallelFanout, isParallelGroup, isSequentialFanout, isArrayFilter, isArraySome, isArrayEvery, extractForOfVariable, isArrayType, getSourceText, extractSourcePath, } from './patterns.js';
+import { isWorkflowDoCall, isWorkflowExpectEventuallyCall, extractActorFromOptions, isWorkflowSleepCall, isWorkflowSuspendCall, isThrowCancelException, extractCancelReason, isParallelFanout, isParallelGroup, isSequentialFanout, isArrayFilter, isArraySome, isArrayEvery, extractForOfVariable, isArrayType, getSourceText, extractSourcePath, } from './patterns.js';
 import { validateNoDisallowedPatterns, validateAwaitedCalls, formatValidationErrors, } from './validation.js';
 import { extractStringLiteral, extractNumberLiteral, } from '../../extract-node-value.js';
 /**
@@ -386,9 +386,12 @@ function extractRpcStep(call, context, outputVar) {
         const rpcName = extractStringLiteral(args[1], context.checker);
         // Extract inputs from third argument
         const inputs = args.length >= 3 ? extractInputSources(args[2], context) : undefined;
-        // Extract options from fourth argument
-        const options = args.length >= 4 && ts.isObjectLiteralExpression(args[3])
-            ? extractStepOptions(args[3], context)
+        // do(step, rpc, data, options?) vs expectEventually(step, rpc, data, predicate, options?)
+        const expectEventually = isWorkflowExpectEventuallyCall(call);
+        const optionsIndex = expectEventually ? 4 : 3;
+        const optionsArg = args.length > optionsIndex ? args[optionsIndex] : undefined;
+        const options = optionsArg && ts.isObjectLiteralExpression(optionsArg)
+            ? extractStepOptions(optionsArg, context)
             : undefined;
         return {
             type: 'rpc',
@@ -397,6 +400,8 @@ function extractRpcStep(call, context, outputVar) {
             outputVar,
             inputs,
             options,
+            actor: extractActorFromOptions(optionsArg),
+            expectEventually: expectEventually || undefined,
         };
     }
     catch (error) {

package/dist/utils/workflow/dsl/patterns.d.ts

@@ -3,9 +3,20 @@ import * as ts from 'typescript';
  * Pattern detection helpers for DSL workflow extraction
  */
 /**
- * Check if a call expression is workflow.do()
+ * Check if a call expression is workflow.do() or workflow.expectEventually()
+ * (both are RPC steps; expectEventually is the polling variant used by user flows)
  */
 export declare function isWorkflowDoCall(node: ts.CallExpression, checker: ts.TypeChecker): boolean;
+/**
+ * Check if a call expression is workflow.expectEventually()
+ */
+export declare function isWorkflowExpectEventuallyCall(node: ts.CallExpression): boolean;
+/**
+ * Extract the actor NAME from a step options object literal:
+ * `{ actor: actors.x }` → 'x' (also `actors['x']`). Undefined when absent
+ * or not statically resolvable.
+ */
+export declare function extractActorFromOptions(optionsArg: ts.Expression | undefined): string | undefined;
 /**
  * Check if a call expression is workflow.sleep()
  */

package/dist/utils/workflow/dsl/patterns.js

@@ -3,17 +3,52 @@ import * as ts from 'typescript';
  * Pattern detection helpers for DSL workflow extraction
  */
 /**
- * Check if a call expression is workflow.do()
+ * Check if a call expression is workflow.do() or workflow.expectEventually()
+ * (both are RPC steps; expectEventually is the polling variant used by user flows)
  */
 export function isWorkflowDoCall(node, checker) {
     if (!ts.isPropertyAccessExpression(node.expression)) {
         return false;
     }
     const propAccess = node.expression;
-    return (propAccess.name.text === 'do' &&
+    return ((propAccess.name.text === 'do' ||
+        propAccess.name.text === 'expectEventually') &&
         ts.isIdentifier(propAccess.expression) &&
         propAccess.expression.text === 'workflow');
 }
+/**
+ * Check if a call expression is workflow.expectEventually()
+ */
+export function isWorkflowExpectEventuallyCall(node) {
+    return (ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === 'expectEventually' &&
+        ts.isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === 'workflow');
+}
+/**
+ * Extract the actor NAME from a step options object literal:
+ * `{ actor: actors.x }` → 'x' (also `actors['x']`). Undefined when absent
+ * or not statically resolvable.
+ */
+export function extractActorFromOptions(optionsArg) {
+    if (!optionsArg || !ts.isObjectLiteralExpression(optionsArg))
+        return;
+    for (const prop of optionsArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === 'actor') {
+            const init = prop.initializer;
+            if (ts.isPropertyAccessExpression(init)) {
+                return init.name.text;
+            }
+            if (ts.isElementAccessExpression(init) &&
+                ts.isStringLiteral(init.argumentExpression)) {
+                return init.argumentExpression.text;
+            }
+        }
+    }
+    return;
+}
 /**
  * Check if a call expression is workflow.sleep()
  */

package/dist/utils/workflow/graph/convert-dsl-to-graph.js

@@ -58,6 +58,12 @@ function convertStepToNode(step, index, steps, nodeIdPrefix = 'step') {
                 rpcName: step.rpcName,
                 next: nextNodeId,
             };
+            if (step.actor) {
+                node.actor = step.actor;
+            }
+            if (step.expectEventually) {
+                node.expectEventually = true;
+            }
             if (step.inputs) {
                 if (step.inputs === 'passthrough') {
                     // Entire data is passed through - store as reference to trigger
@@ -304,8 +310,10 @@ export function convertDslToGraph(workflowName, meta) {
         name: workflowName,
         pikkuFuncId: meta.pikkuFuncId,
         source,
+        title: meta.title,
         description: meta.description,
         tags: meta.tags,
+        actors: meta.actors,
         context: meta.context,
         nodes: nodesRecord,
         entryNodeIds,

package/dist/utils/workflow/graph/workflow-graph.types.d.ts

@@ -96,6 +96,10 @@ export interface FunctionNode extends BaseNode {
     outputVar?: string;
     /** Hash of nodeId + RPC input/output schemas for version detection */
     stepHash?: string;
+    /** User-flow actor name this step runs as (workflow.do {actor: actors.x}) */
+    actor?: string;
+    /** True for workflow.expectEventually polling steps (user flows) */
+    expectEventually?: boolean;
 }
 /**
  * Flow node - control flow only, no RPC call
@@ -136,10 +140,14 @@ export interface SerializedWorkflowGraph {
     pikkuFuncId: string;
     /** Source type: 'dsl' for pikkuWorkflowFunc, 'graph' for pikkuWorkflowGraph */
     source: WorkflowSourceType;
+    /** Optional short display name */
+    title?: string;
     /** Optional description */
     description?: string;
     /** Tags for organization */
     tags?: string[];
+    /** Actor names a user flow's steps run as */
+    actors?: string[];
     /** If true, workflow always executes inline without queues */
     inline?: boolean;
     /** Workflow context/state variables (from Zod schema) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.33",
+  "version": "0.12.35",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.49",
+    "@pikku/core": "^0.12.51",
     "openapi-types": "^12.1.3",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "2.9.1-next.16",

package/run-tests.sh

@@ -38,16 +38,16 @@ if [ ${#files[@]} -eq 0 ]; then
 fi
 
 # Construct the node command
-node_cmd="node --import tsx --test"
+node_cmd=(node --import tsx --test)
 
 # Append options based on flags
 if [ "$watch_mode" = true ]; then
-  node_cmd="$node_cmd --watch"
+  node_cmd+=(--watch)
 fi
 
 if [ "$coverage_mode" = true ]; then
-  node_cmd="$node_cmd --test-coverage-include=\"src/**/*.{ts,js}\" --test-coverage-exclude=\"**/dist/**\" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
+  node_cmd+=(--test-coverage-include="src/**/*.{ts,js}" --test-coverage-exclude="**/dist/**" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info)
 fi
 
 # Execute the node command with the expanded list of files
-$node_cmd "${files[@]}"
+"${node_cmd[@]}" "${files[@]}"

package/src/add/add-http-route.ts

@@ -389,8 +389,10 @@ export function registerHTTPRoute({
     checker
   )
 
-  // Track used functions/middleware/permissions for service aggregation
   state.serviceAggregation.usedFunctions.add(funcName)
+  if (refAddonTarget) {
+    state.serviceAggregation.usedFunctions.add(refAddonTarget)
+  }
   extractWireNames(middleware).forEach((name) =>
     state.serviceAggregation.usedMiddleware.add(name)
   )
@@ -415,6 +417,7 @@ export function registerHTTPRoute({
   state.http.files.add(sourceFile.fileName)
   state.http.meta[method][fullRoute] = {
     pikkuFuncId: funcName,
+    ...(refAddonTarget && { refTarget: refAddonTarget }),
     ...(packageName && { packageName }),
     route: fullRoute,
     sourceFile: sourceFile.fileName,