@pikku/cli 0.12.16 → 0.12.19

package/dist/.pikku/workflow/meta/allWorkflow.gen.json

@@ -0,0 +1,442 @@
+{
+    "name": "allWorkflow",
+    "pikkuFuncId": "allWorkflow",
+    "source": "complex",
+    "nodes": {
+        "Bootstrap inspect": {
+            "nodeId": "Bootstrap inspect",
+            "flow": "inline",
+            "next": "Bootstrap function types"
+        },
+        "Bootstrap function types": {
+            "nodeId": "Bootstrap function types",
+            "rpcName": "pikkuFunctionTypes",
+            "next": "Bootstrap function types split",
+            "stepHash": "c293829b03c7"
+        },
+        "Bootstrap function types split": {
+            "nodeId": "Bootstrap function types split",
+            "rpcName": "pikkuFunctionTypesSplit",
+            "next": "Bootstrap HTTP types",
+            "stepHash": "a59a35fde030"
+        },
+        "Bootstrap HTTP types": {
+            "nodeId": "Bootstrap HTTP types",
+            "rpcName": "pikkuHTTPTypes",
+            "next": "Bootstrap channel types",
+            "stepHash": "ef454ef713da"
+        },
+        "Bootstrap channel types": {
+            "nodeId": "Bootstrap channel types",
+            "rpcName": "pikkuChannelTypes",
+            "next": "Bootstrap scheduler types",
+            "stepHash": "106bc6b98409"
+        },
+        "Bootstrap scheduler types": {
+            "nodeId": "Bootstrap scheduler types",
+            "rpcName": "pikkuSchedulerTypes",
+            "next": "Bootstrap queue types",
+            "stepHash": "23bd821f9ee3"
+        },
+        "Bootstrap queue types": {
+            "nodeId": "Bootstrap queue types",
+            "rpcName": "pikkuQueueTypes",
+            "next": "Bootstrap workflow",
+            "stepHash": "46cd97f1fe31"
+        },
+        "Bootstrap workflow": {
+            "nodeId": "Bootstrap workflow",
+            "rpcName": "pikkuWorkflow",
+            "next": "Bootstrap MCP types",
+            "stepHash": "09f085dde448"
+        },
+        "Bootstrap MCP types": {
+            "nodeId": "Bootstrap MCP types",
+            "rpcName": "pikkuMCPTypes",
+            "next": "Bootstrap AI agent types",
+            "stepHash": "ef01efd74427"
+        },
+        "Bootstrap AI agent types": {
+            "nodeId": "Bootstrap AI agent types",
+            "rpcName": "pikkuAIAgentTypes",
+            "next": "Bootstrap CLI types",
+            "stepHash": "ccd99a28ffd6"
+        },
+        "Bootstrap CLI types": {
+            "nodeId": "Bootstrap CLI types",
+            "rpcName": "pikkuCLITypes",
+            "next": "Bootstrap re-inspect",
+            "stepHash": "bc3a92886cb6"
+        },
+        "Bootstrap re-inspect": {
+            "nodeId": "Bootstrap re-inspect",
+            "flow": "inline",
+            "next": "Generate function types"
+        },
+        "Generate function types": {
+            "nodeId": "Generate function types",
+            "rpcName": "pikkuFunctionTypes",
+            "next": "Re-inspect after types",
+            "stepHash": "3baeae2050fd"
+        },
+        "Re-inspect after types": {
+            "nodeId": "Re-inspect after types",
+            "flow": "inline",
+            "next": "Function types split"
+        },
+        "Function types split": {
+            "nodeId": "Function types split",
+            "rpcName": "pikkuFunctionTypesSplit",
+            "next": "Trigger types",
+            "stepHash": "3ce567580a38"
+        },
+        "Trigger types": {
+            "nodeId": "Trigger types",
+            "rpcName": "pikkuTriggerTypes",
+            "next": "AI agent types",
+            "stepHash": "01f3d641f2cf"
+        },
+        "AI agent types": {
+            "nodeId": "AI agent types",
+            "rpcName": "pikkuAIAgentTypes",
+            "next": "HTTP types",
+            "stepHash": "a0bf0ea14360"
+        },
+        "HTTP types": {
+            "nodeId": "HTTP types",
+            "rpcName": "pikkuHTTPTypes",
+            "next": "Channel types",
+            "stepHash": "f65b70567492"
+        },
+        "Channel types": {
+            "nodeId": "Channel types",
+            "rpcName": "pikkuChannelTypes",
+            "next": "Scheduler types",
+            "stepHash": "61560f2f0c8d"
+        },
+        "Scheduler types": {
+            "nodeId": "Scheduler types",
+            "rpcName": "pikkuSchedulerTypes",
+            "next": "Queue types",
+            "stepHash": "8f484a113d9c"
+        },
+        "Queue types": {
+            "nodeId": "Queue types",
+            "rpcName": "pikkuQueueTypes",
+            "next": "MCP types",
+            "stepHash": "32340a713206"
+        },
+        "MCP types": {
+            "nodeId": "MCP types",
+            "rpcName": "pikkuMCPTypes",
+            "next": "CLI types",
+            "stepHash": "685cbd3c2f83"
+        },
+        "CLI types": {
+            "nodeId": "CLI types",
+            "rpcName": "pikkuCLITypes",
+            "next": "Middleware",
+            "stepHash": "faf88549ab64"
+        },
+        "Middleware": {
+            "nodeId": "Middleware",
+            "rpcName": "pikkuMiddleware",
+            "next": "Permissions",
+            "stepHash": "69ff86ef7ac6"
+        },
+        "Permissions": {
+            "nodeId": "Permissions",
+            "rpcName": "pikkuPermissions",
+            "next": "Services",
+            "stepHash": "517642320b1f"
+        },
+        "Services": {
+            "nodeId": "Services",
+            "rpcName": "pikkuServices",
+            "next": "Package",
+            "stepHash": "c7aaeac0b6e2"
+        },
+        "Package": {
+            "nodeId": "Package",
+            "rpcName": "pikkuPackage",
+            "next": "RPC",
+            "stepHash": "8d10339db08d"
+        },
+        "RPC": {
+            "nodeId": "RPC",
+            "rpcName": "pikkuRPC",
+            "next": "AI agent",
+            "stepHash": "9c7ab6d16eb5"
+        },
+        "AI agent": {
+            "nodeId": "AI agent",
+            "rpcName": "pikkuAIAgent",
+            "next": "Public agent scaffold",
+            "stepHash": "b40cd11dc611"
+        },
+        "Public agent scaffold": {
+            "nodeId": "Public agent scaffold",
+            "rpcName": "pikkuPublicAgent",
+            "next": "Public RPC",
+            "stepHash": "64d807033007"
+        },
+        "Public RPC": {
+            "nodeId": "Public RPC",
+            "rpcName": "pikkuPublicRPC",
+            "next": "Console functions",
+            "stepHash": "4f8cc6772ba9"
+        },
+        "Console functions": {
+            "nodeId": "Console functions",
+            "rpcName": "pikkuConsoleFunctions",
+            "next": "Node types",
+            "stepHash": "45587b4864bf"
+        },
+        "Node types": {
+            "nodeId": "Node types",
+            "rpcName": "pikkuNodeTypes",
+            "next": "Secret definition types",
+            "stepHash": "fa0e98ce519c"
+        },
+        "Secret definition types": {
+            "nodeId": "Secret definition types",
+            "rpcName": "pikkuSecretDefinitionTypes",
+            "next": "Secrets",
+            "stepHash": "fbfdf42a3974"
+        },
+        "Secrets": {
+            "nodeId": "Secrets",
+            "rpcName": "pikkuSecrets",
+            "next": "Credentials",
+            "stepHash": "dc203fbd8f4d"
+        },
+        "Credentials": {
+            "nodeId": "Credentials",
+            "rpcName": "pikkuCredentials",
+            "next": "Variable definition types",
+            "stepHash": "3e4cb364d6f2"
+        },
+        "Variable definition types": {
+            "nodeId": "Variable definition types",
+            "rpcName": "pikkuVariableDefinitionTypes",
+            "next": "Variables",
+            "stepHash": "f0b1834d8da2"
+        },
+        "Variables": {
+            "nodeId": "Variables",
+            "rpcName": "pikkuVariables",
+            "next": "Addon types",
+            "stepHash": "a2bbb318d12b"
+        },
+        "Addon types": {
+            "nodeId": "Addon types",
+            "rpcName": "pikkuAddonTypes",
+            "next": "Re-inspect after agents",
+            "stepHash": "14f255190658"
+        },
+        "Re-inspect after agents": {
+            "nodeId": "Re-inspect after agents",
+            "flow": "inline",
+            "next": "Schemas"
+        },
+        "Schemas": {
+            "nodeId": "Schemas",
+            "rpcName": "pikkuSchemas",
+            "next": "RPC internal map",
+            "stepHash": "1d81976436e8"
+        },
+        "RPC internal map": {
+            "nodeId": "RPC internal map",
+            "rpcName": "pikkuRPCInternalMap",
+            "next": "RPC exposed map",
+            "stepHash": "71c071d4e0af"
+        },
+        "RPC exposed map": {
+            "nodeId": "RPC exposed map",
+            "rpcName": "pikkuRPCExposedMap",
+            "next": "Workflow",
+            "stepHash": "20b6c409e9fb"
+        },
+        "Workflow": {
+            "nodeId": "Workflow",
+            "rpcName": "pikkuWorkflow",
+            "next": "Remote RPC",
+            "stepHash": "21f5ac3be507"
+        },
+        "Remote RPC": {
+            "nodeId": "Remote RPC",
+            "rpcName": "pikkuRemoteRPC",
+            "next": "Workflow routes",
+            "stepHash": "82751ee2ed4b"
+        },
+        "Workflow routes": {
+            "nodeId": "Workflow routes",
+            "rpcName": "pikkuWorkflowRoutes",
+            "next": "Re-inspect after workflows",
+            "stepHash": "41b3fa734593"
+        },
+        "Re-inspect after workflows": {
+            "nodeId": "Re-inspect after workflows",
+            "flow": "inline",
+            "next": "Re-generate schemas"
+        },
+        "Re-generate schemas": {
+            "nodeId": "Re-generate schemas",
+            "rpcName": "pikkuSchemas",
+            "next": "HTTP",
+            "stepHash": "6c1b632628da"
+        },
+        "HTTP": {
+            "nodeId": "HTTP",
+            "rpcName": "pikkuHTTP",
+            "next": "Scheduler",
+            "stepHash": "3a613fe4489a"
+        },
+        "Scheduler": {
+            "nodeId": "Scheduler",
+            "rpcName": "pikkuScheduler",
+            "next": "Trigger",
+            "stepHash": "292dba63a8fa"
+        },
+        "Trigger": {
+            "nodeId": "Trigger",
+            "rpcName": "pikkuTrigger",
+            "next": "HTTP map",
+            "stepHash": "296e642d68de"
+        },
+        "HTTP map": {
+            "nodeId": "HTTP map",
+            "rpcName": "pikkuHTTPMap",
+            "next": "Fetch",
+            "stepHash": "9a365c798484"
+        },
+        "Fetch": {
+            "nodeId": "Fetch",
+            "rpcName": "pikkuFetch",
+            "next": "RPC client",
+            "stepHash": "4102b66eb092"
+        },
+        "RPC client": {
+            "nodeId": "RPC client",
+            "rpcName": "pikkuRPCClient",
+            "next": "Functions",
+            "stepHash": "7f48f64ea306"
+        },
+        "Functions": {
+            "nodeId": "Functions",
+            "rpcName": "pikkuFunctions",
+            "next": "Queue",
+            "stepHash": "90cd834fe20e"
+        },
+        "Queue": {
+            "nodeId": "Queue",
+            "rpcName": "pikkuQueue",
+            "next": "Channels",
+            "stepHash": "6d9159ddfa71"
+        },
+        "Channels": {
+            "nodeId": "Channels",
+            "rpcName": "pikkuChannels",
+            "next": "Gateway",
+            "stepHash": "65df9df381cf"
+        },
+        "Gateway": {
+            "nodeId": "Gateway",
+            "rpcName": "pikkuGateway",
+            "next": "MCP",
+            "stepHash": "4aba6d4affbd"
+        },
+        "MCP": {
+            "nodeId": "MCP",
+            "rpcName": "pikkuMCP",
+            "next": "CLI",
+            "stepHash": "fd4e9c89c777"
+        },
+        "CLI": {
+            "nodeId": "CLI",
+            "rpcName": "pikkuCLI",
+            "next": "Queue map",
+            "stepHash": "8b5a8e81446a"
+        },
+        "Queue map": {
+            "nodeId": "Queue map",
+            "rpcName": "pikkuQueueMap",
+            "next": "Queue service",
+            "stepHash": "ea903f8f068c"
+        },
+        "Queue service": {
+            "nodeId": "Queue service",
+            "rpcName": "pikkuQueueService",
+            "next": "Channels map",
+            "stepHash": "b142dd291e94"
+        },
+        "Channels map": {
+            "nodeId": "Channels map",
+            "rpcName": "pikkuChannelsMap",
+            "next": "WebSocket typed",
+            "stepHash": "7b33a77cf0b4"
+        },
+        "WebSocket typed": {
+            "nodeId": "WebSocket typed",
+            "rpcName": "pikkuWebSocketTyped",
+            "next": "MCP JSON",
+            "stepHash": "388552be75e1"
+        },
+        "MCP JSON": {
+            "nodeId": "MCP JSON",
+            "rpcName": "pikkuMCPJSON",
+            "next": "CLI entry",
+            "stepHash": "cd3ac7d24ff5"
+        },
+        "CLI entry": {
+            "nodeId": "CLI entry",
+            "rpcName": "pikkuCLIEntry",
+            "next": "Nodes meta",
+            "stepHash": "ad1933f9dc1b"
+        },
+        "Nodes meta": {
+            "nodeId": "Nodes meta",
+            "rpcName": "pikkuNodesMeta",
+            "next": "Next.js",
+            "stepHash": "5044787f9c0c"
+        },
+        "Next.js": {
+            "nodeId": "Next.js",
+            "rpcName": "pikkuNext",
+            "next": "OpenAPI re-inspect",
+            "stepHash": "23340e44049b"
+        },
+        "OpenAPI re-inspect": {
+            "nodeId": "OpenAPI re-inspect",
+            "flow": "inline",
+            "next": "OpenAPI"
+        },
+        "OpenAPI": {
+            "nodeId": "OpenAPI",
+            "rpcName": "pikkuOpenAPI",
+            "next": "Versions update",
+            "stepHash": "dde9b4dac1a8"
+        },
+        "Versions update": {
+            "nodeId": "Versions update",
+            "rpcName": "pikkuVersionsUpdate",
+            "next": "Bootstrap",
+            "stepHash": "181615f07c8d"
+        },
+        "Bootstrap": {
+            "nodeId": "Bootstrap",
+            "rpcName": "pikkuBootstrap",
+            "next": "Summary",
+            "stepHash": "3d656d5f2b03"
+        },
+        "Summary": {
+            "nodeId": "Summary",
+            "rpcName": "pikkuSummary",
+            "stepHash": "a6c8f33339e2"
+        }
+    },
+    "entryNodeIds": [
+        "Bootstrap inspect"
+    ],
+    "graphHash": "fd131e164f8a"
+}

package/dist/.pikku/workflow/pikku-workflow-types.gen.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.16
+ * This file was generated by @pikku/cli@0.12.19
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
 import { template } from '@pikku/core/workflow';

package/dist/.pikku/workflow/pikku-workflow-types.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.16
+ * This file was generated by @pikku/cli@0.12.19
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
 import { template } from '@pikku/core/workflow';

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.js

@@ -1,6 +1,9 @@
 /**
- * This file was generated by @pikku/cli@0.12.16
+ * This file was generated by @pikku/cli@0.12.19
  */
 import { pikkuState } from '@pikku/core/internal';
-const workflowsMeta = {};
+import allWorkflowMeta from './meta/allWorkflow.gen.json' with { type: 'json' };
+const workflowsMeta = {
+    'allWorkflow': allWorkflowMeta,
+};
 pikkuState(null, 'workflows', 'meta', workflowsMeta);

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.d.ts

@@ -1,4 +1,2 @@
-export {};
-/**
- * This file was generated by @pikku/cli@0.12.16
- */
+import './pikku-workflow-wirings-meta.gen.js';
+export type WorkflowNames = 'allWorkflow';

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.js

@@ -1,4 +1,7 @@
-export {};
 /**
- * This file was generated by @pikku/cli@0.12.16
+ * This file was generated by @pikku/cli@0.12.19
  */
+import { addWorkflow } from '@pikku/core/workflow';
+import './pikku-workflow-wirings-meta.gen.js';
+import { allWorkflow } from '../../src/functions/workflows/all.workflow.js';
+addWorkflow('allWorkflow', allWorkflow);

package/dist/src/cli.wiring.js

@@ -2,6 +2,7 @@ import { pikkuSchemas } from './functions/wirings/functions/schemas.js';
 import { pikkuFetch } from './functions/runtimes/fetch/index.js';
 import { pikkuWebSocketTyped } from './functions/runtimes/websocket/pikku-command-websocket-typed.js';
 import { pikkuRPCClient } from './functions/wirings/rpc/pikku-command-rpc-client.js';
+import { pikkuReactQuery } from './functions/wirings/rpc/pikku-command-react-query.js';
 import { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js';
 import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js';
 import { pikkuNext } from './functions/runtimes/nextjs/pikku-command-nextjs.js';
@@ -137,6 +138,10 @@ wireCLI({
             func: pikkuRPCClient,
             description: 'Generate RPC client wrappers',
         }),
+        'react-query': pikkuCLICommand({
+            func: pikkuReactQuery,
+            description: 'Generate React Query hooks from RPC map',
+        }),
         'queue-service': pikkuCLICommand({
             func: pikkuQueueService,
             description: 'Generate queue service wrapper',

package/dist/src/deploy/analyzer/analyzer.d.ts

@@ -14,3 +14,4 @@ export interface AnalyzerOptions {
     serverlessIncompatible?: string[];
 }
 export declare function analyzeDeployment(state: InspectorState, options: AnalyzerOptions): DeploymentManifest;
+export declare function toSafeKebab(str: string): string;

package/dist/src/deploy/analyzer/analyzer.js

@@ -71,7 +71,7 @@ export function analyzeDeployment(state, options) {
                 handlers.push({ type: 'queue', queueName: queueMeta.name ?? queueName });
                 queues.push({
                     name: queueMeta.name ?? queueName,
-                    consumerUnit: toKebab(funcId),
+                    consumerUnit: toSafeKebab(funcId),
                     consumerFunctionId: funcId,
                 });
             }
@@ -87,7 +87,7 @@ export function analyzeDeployment(state, options) {
                 scheduledTasks.push({
                     name: schedMeta.name,
                     schedule: schedMeta.schedule,
-                    unitName: toKebab(funcId),
+                    unitName: toSafeKebab(funcId),
                     functionId: funcId,
                 });
             }
@@ -129,7 +129,7 @@ export function analyzeDeployment(state, options) {
             continue;
         }
         units.push({
-            name: toKebab(funcId),
+            name: toSafeKebab(funcId),
             role: 'function',
             target: resolveDeployTarget(funcMeta, serverlessIncompatible),
             functionIds: [funcId],
@@ -143,10 +143,10 @@ export function analyzeDeployment(state, options) {
     for (const [agentName, agentMeta] of entries(state.agents.agentsMeta)) {
         const toolIds = agentMeta.tools ?? [];
         const subAgentNames = agentMeta.agents ?? [];
-        const unitName = `agent-${toKebab(agentName)}`;
+        const unitName = `agent-${toSafeKebab(agentName)}`;
         // Agent gateway depends on its tool function units
-        const toolUnitNames = toolIds.map((id) => toKebab(id));
-        const subAgentUnitNames = subAgentNames.map((sa) => `agent-${toKebab(sa)}`);
+        const toolUnitNames = toolIds.map((id) => toSafeKebab(id));
+        const subAgentUnitNames = subAgentNames.map((sa) => `agent-${toSafeKebab(sa)}`);
         // Agent needs AI services
         const agentServices = [
             { capability: 'ai-model', sourceServiceName: 'aiAgentRunner' },
@@ -209,7 +209,7 @@ export function analyzeDeployment(state, options) {
     const allMcpIds = [...mcpToolIds, ...mcpResourceIds, ...mcpPromptIds];
     if (allMcpIds.length > 0) {
         const unitName = 'mcp-server';
-        const mcpFuncUnitNames = allMcpIds.map((id) => toKebab(id));
+        const mcpFuncUnitNames = allMcpIds.map((id) => toSafeKebab(id));
         units.push({
             name: unitName,
             role: 'mcp',
@@ -232,8 +232,8 @@ export function analyzeDeployment(state, options) {
         const funcIds = collectChannelFunctionIds(channelMeta);
         if (funcIds.length === 0)
             continue;
-        const unitName = `channel-${toKebab(channelName)}`;
-        const funcUnitNames = funcIds.map((id) => toKebab(id));
+        const unitName = `channel-${toSafeKebab(channelName)}`;
+        const funcUnitNames = funcIds.map((id) => toSafeKebab(id));
         units.push({
             name: unitName,
             role: 'channel',
@@ -346,7 +346,7 @@ function buildWorkflows(graphMeta, _functionsMeta, _httpMeta, units, workflows,
                 continue;
             if (!('rpcName' in node))
                 continue;
-            const stepUnitName = toKebab(node.rpcName);
+            const stepUnitName = toSafeKebab(node.rpcName);
             const isAsync = node.options?.async === true;
             const isInline = !isAsync && graph.inline === true;
             steps.push({
@@ -358,7 +358,7 @@ function buildWorkflows(graphMeta, _functionsMeta, _httpMeta, units, workflows,
             stepUnitNames.push(stepUnitName);
         }
         // Build orchestrator unit — no function code, just orchestration
-        const orchUnitName = `wf-${toKebab(graph.name)}`;
+        const orchUnitName = `wf-${toSafeKebab(graph.name)}`;
         const orchServices = [
             { capability: 'workflow-state', sourceServiceName: 'workflowService' },
             { capability: 'queue', sourceServiceName: 'queueService' },
@@ -387,7 +387,7 @@ function buildWorkflows(graphMeta, _functionsMeta, _httpMeta, units, workflows,
             },
         ];
         // Orchestrator queue — the orchestrator consumes from this
-        const orchQueueName = `wf-orchestrator-${toKebab(graph.name)}`;
+        const orchQueueName = `wf-orchestrator-${toSafeKebab(graph.name)}`;
         const orchHandlers = [
             { type: 'fetch', routes: wfRoutes },
             { type: 'queue', queueName: orchQueueName },
@@ -413,10 +413,10 @@ function buildWorkflows(graphMeta, _functionsMeta, _httpMeta, units, workflows,
         for (const step of steps) {
             if (step.inline || !step.functionId)
                 continue;
-            const stepQueueName = `wf-step-${toKebab(step.functionId)}`;
+            const stepQueueName = `wf-step-${toSafeKebab(step.functionId)}`;
             queues.push({
                 name: stepQueueName,
-                consumerUnit: toKebab(step.functionId),
+                consumerUnit: toSafeKebab(step.functionId),
                 consumerFunctionId: `pikkuWorkflowWorker:${step.functionId}`,
             });
         }
@@ -523,10 +523,13 @@ function collectChannelFunctionIds(channelMeta) {
 // ---------------------------------------------------------------------------
 // Naming helpers
 // ---------------------------------------------------------------------------
-function toKebab(str) {
+export function toSafeKebab(str) {
     return str
         .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
         .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .replace(/[:/\\]/g, '-')
+        .replace(/--+/g, '-')
+        .replace(/^-|-$/g, '')
         .toLowerCase();
 }
 function fromKebab(str) {

package/dist/src/deploy/codegen/per-unit-codegen.js

@@ -14,6 +14,7 @@ import { tmpdir } from 'node:os';
 import { randomBytes } from 'node:crypto';
 import { promisify } from 'node:util';
 import { serializeInspectorState } from '@pikku/inspector';
+import { toSafeKebab } from '../analyzer/analyzer.js';
 const execFileAsync = promisify(execFile);
 /**
  * Resolve the pikku CLI binary path.
@@ -122,12 +123,11 @@ function collectFilterNames(unit, manifest, inspectorState) {
                 names.add('http:get:/workflow/:workflowName/status/:runId/stream');
                 names.add('http:post:/workflow/:workflowName/graph/:nodeId');
                 // Queue names for orchestrator and step workers
-                const toKebab = (s) => s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
-                names.add(`wf-orchestrator-${toKebab(wfDef.name)}`);
+                names.add(`wf-orchestrator-${toSafeKebab(wfDef.name)}`);
                 for (const step of wfDef.steps) {
                     if (step.functionId) {
                         names.add(step.functionId);
-                        names.add(`wf-step-${toKebab(step.functionId)}`);
+                        names.add(`wf-step-${toSafeKebab(step.functionId)}`);
                     }
                 }
             }