@pikku/cli 0.10.2 → 0.11.0

package/dist/src/functions/commands/all.js

@@ -23,6 +23,7 @@ export const all = pikkuVoidFunc({
         await rpc.invoke('pikkuChannelTypes', null);
         await rpc.invoke('pikkuSchedulerTypes', null);
         await rpc.invoke('pikkuQueueTypes', null);
+        await rpc.invoke('pikkuWorkflowTypes', null);
         await rpc.invoke('pikkuMCPTypes', null);
         await rpc.invoke('pikkuCLITypes', null);
         const hasFunctionRegistrations = await rpc.invoke('pikkuFunctions', null);
@@ -69,6 +70,22 @@ export const all = pikkuVoidFunc({
         if (scheduler) {
             allImports.push(config.schedulersWiringMetaFile, config.schedulersWiringFile);
         }
+        // Generate Workflows
+        const workflows = await rpc.invoke('pikkuWorkflow', null);
+        // Generate Remote RPC Workers (must be before queue discovery so wireQueueWorker calls are picked up)
+        const remoteRPC = await rpc.invoke('pikkuRemoteRPC', null);
+        // Reinspect to pick up generated workflow workers and remote RPC workers BEFORE generating maps
+        if (workflows || remoteRPC) {
+            await getInspectorState(true);
+        }
+        if (workflows) {
+            await rpc.invoke('pikkuWorkflowMap', null);
+            allImports.push(config.workflowsWiringMetaFile, config.workflowsWiringFile);
+        }
+        if (remoteRPC && config.rpc?.remoteRpcWorkersPath) {
+            // Only add to imports if we actually generated the file
+            allImports.push(config.rpc.remoteRpcWorkersPath);
+        }
         // Generate Queues
         const queues = await rpc.invoke('pikkuQueue', null);
         if (queues) {
@@ -131,6 +148,9 @@ export const all = pikkuVoidFunc({
             if (totalCommands > 0)
                 summary.set('cliCommands', totalCommands);
         }
+        if (state.workflows?.meta) {
+            summary.set('workflows', Object.keys(state.workflows.meta).length);
+        }
         // Display summary (unless in silent mode)
         if (!logger.isSilent()) {
             console.log(summary.format());

package/dist/src/functions/commands/bootstrap.js

@@ -13,6 +13,7 @@ export const bootstrap = pikkuVoidFunc({
         await rpc.invoke('pikkuChannelTypes', null);
         await rpc.invoke('pikkuSchedulerTypes', null);
         await rpc.invoke('pikkuQueueTypes', null);
+        await rpc.invoke('pikkuWorkflowTypes', null);
         await rpc.invoke('pikkuMCPTypes', null);
         await rpc.invoke('pikkuCLITypes', null);
         // Check for critical errors and exit if any were logged

package/dist/src/functions/wirings/cli/serialize-channel-cli-client.js

@@ -99,29 +99,10 @@ ${rendererImports}
  * Executes CLI commands over a WebSocket connection
  */
 export async function ${capitalizedName}CLIClient(
-  url: string,
+  ws: WebSocket,
   args?: string[]
 ): Promise<void> {
-  // Get WebSocket implementation (browser or Node.js)
-  let WebSocketImpl: any
-  if (typeof WebSocket !== 'undefined') {
-    WebSocketImpl = WebSocket
-  } else {
-    // Node.js environment - dynamically import 'ws'
-    try {
-      const wsModule = await import('ws')
-      WebSocketImpl = wsModule.default
-    } catch (e) {
-      throw new Error(
-        'No WebSocket implementation found. In Node.js environments, you need to:\\n' +
-        '1. Install the "ws" package: npm install ws\\n' +
-        'Learn more: https://www.npmjs.com/package/ws'
-      )
-    }
-  }
-
-  // Create WebSocket connection
-  const ws = new WebSocketImpl(url) as WebSocket
+  // Create Pikku WebSocket wrapper
   const pikkuWS = new CorePikkuWebsocket(ws)
 
   // Register renderers for CLI commands
@@ -141,7 +122,19 @@ export default ${capitalizedName}CLIClient
 // For direct execution (if this file is run directly)
 if (import.meta.url === \`file://\${process.argv[1]}\`) {
   const url = process.env.PIKKU_WS_URL || 'ws://localhost:4002${finalChannelRoute}'
-  ${capitalizedName}CLIClient(url, process.argv.slice(2)).catch(error => {
+
+  // Create WebSocket instance
+  let WebSocketImpl: any
+  if (typeof WebSocket !== 'undefined') {
+    WebSocketImpl = WebSocket
+  } else {
+    // Node.js environment - dynamically import 'ws'
+    const wsModule = await import('ws')
+    WebSocketImpl = wsModule.default
+  }
+
+  const ws = new WebSocketImpl(url) as WebSocket
+  ${capitalizedName}CLIClient(ws, process.argv.slice(2)).catch(error => {
     console.error('Fatal channel CLI error:', error)
     // TODO: We get an error code even when it exists cleanly, investigate
     // process.exit(1)

package/dist/src/functions/wirings/queue/pikku-queue.js

@@ -8,7 +8,15 @@ export const pikkuQueue = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { queueWorkersWiringFile, queueWorkersWiringMetaFile, packageMappings, } = config;
         const { queueWorkers } = visitState;
-        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
+        // Add remote RPC worker to queue metadata if it exists
+        const queueMeta = { ...queueWorkers.meta };
+        if (config.rpc?.remoteRpcWorkersPath) {
+            queueMeta['pikku-remote-internal-rpc'] = {
+                pikkuFuncName: 'pikkuRemoteInternalRPC',
+                queueName: 'pikku-remote-internal-rpc',
+            };
+        }
+        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueMeta));
         await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
         return true;
     },

package/dist/src/functions/wirings/queue/serialize-queue-map.d.ts

@@ -1,4 +1,4 @@
-import type { queueWorkersMeta } from '@pikku/core/queue';
+import type { QueueWorkersMeta } from '@pikku/core/queue';
 import { TypesMap } from '@pikku/inspector';
 import { FunctionsMeta } from '@pikku/core';
-export declare const serializeQueueMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, queueWorkersMeta: queueWorkersMeta) => string;
+export declare const serializeQueueMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, queueWorkersMeta: QueueWorkersMeta) => string;

package/dist/src/functions/wirings/queue/serialize-queue-meta.d.ts

@@ -1,2 +1,2 @@
-import { queueWorkersMeta } from '@pikku/core/queue';
-export declare const serializeQueueMeta: (queueWorkersMeta: queueWorkersMeta) => string;
+import { QueueWorkersMeta } from '@pikku/core/queue';
+export declare const serializeQueueMeta: (queueWorkersMeta: QueueWorkersMeta) => string;

package/dist/src/functions/wirings/rpc/pikku-command-public-rpc.d.ts

@@ -0,0 +1 @@
+export declare const pikkuPublicRPC: any;

package/dist/src/functions/wirings/rpc/pikku-command-public-rpc.js

@@ -0,0 +1,23 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializePublicRPC } from './serialize-public-rpc.js';
+import { join } from 'path';
+export const pikkuPublicRPC = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        if (config.rpc?.publicRpcPath) {
+            const publicRpcPath = join(config.rootDir, config.rpc.publicRpcPath);
+            const pathToPikkuTypes = getFileImportRelativePath(publicRpcPath, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, publicRpcPath, serializePublicRPC(pathToPikkuTypes));
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Public RPC Endpoint',
+            commandEnd: 'Generated Public RPC Endpoint',
+        }),
+    ],
+});

package/dist/src/functions/wirings/rpc/pikku-command-remote-rpc.d.ts

@@ -0,0 +1 @@
+export declare const pikkuRemoteRPC: any;

package/dist/src/functions/wirings/rpc/pikku-command-remote-rpc.js

@@ -0,0 +1,23 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeRemoteRPC } from './serialize-remote-rpc.js';
+import { join } from 'path';
+export const pikkuRemoteRPC = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        if (config.rpc?.remoteRpcWorkersPath) {
+            const remoteRpcPath = join(config.rootDir, config.rpc.remoteRpcWorkersPath);
+            const pathToPikkuTypes = getFileImportRelativePath(remoteRpcPath, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, remoteRpcPath, serializeRemoteRPC(pathToPikkuTypes));
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Remote RPC Workers',
+            commandEnd: 'Generated Remote RPC Workers',
+        }),
+    ],
+});

package/dist/src/functions/wirings/rpc/serialize-public-rpc.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate public RPC HTTP endpoint
+ */
+export declare const serializePublicRPC: (pathToPikkuTypes: string) => string;

package/dist/src/functions/wirings/rpc/serialize-public-rpc.js

@@ -0,0 +1,30 @@
+/**
+ * Generate public RPC HTTP endpoint
+ */
+export const serializePublicRPC = (pathToPikkuTypes) => {
+    return `/**
+ * Auto-generated public RPC HTTP endpoint
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
+
+/**
+ * Public RPC endpoint that invokes any exposed RPC by name
+ * This is used for public HTTP access to exposed server functions
+ */
+export const rpcCaller = pikkuSessionlessFunc<
+  { name: string, data?: any },
+  any
+>({
+  func: async ({ rpc }, { name, data }) => {
+    return await (rpc.invokeExposed as any)(name, data)
+  },
+})
+
+wireHTTP({
+  route: '/rpc',
+  method: 'post',
+  func: rpcCaller,
+})
+`;
+};

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate remote internal RPC queue worker and HTTP endpoint
+ */
+export declare const serializeRemoteRPC: (pathToPikkuTypes: string) => string;

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.js

@@ -0,0 +1,30 @@
+/**
+ * Generate remote internal RPC queue worker and HTTP endpoint
+ */
+export const serializeRemoteRPC = (pathToPikkuTypes) => {
+    return `/**
+ * Auto-generated remote internal RPC queue worker and HTTP endpoint
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
+
+/**
+ * Generic remote RPC worker that invokes any internal RPC by name
+ * This is used for executing internal RPCs via a queue or HTTP (e.g., scheduled tasks, background jobs, internal services)
+ */
+export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
+  { rpcName: string, data?: any },
+  any
+>({
+  func: async ({ rpc }, { rpcName, data }) => {
+    return await (rpc.invoke as any)(rpcName, data)
+  },
+  internal: true,
+})
+
+wireQueueWorker({
+  queueName: 'pikku-remote-internal-rpc',
+  func: pikkuRemoteInternalRPC,
+})
+`;
+};

package/dist/src/functions/wirings/rpc/serialize-rpc-wrapper.js

@@ -53,13 +53,13 @@ export class PikkuRPC {
      * Invokes a remote procedure call on the server.
      * This is a generic method that routes to the appropriate server function
      * based on the function name and passes the provided data.
-     * 
+     *
      * @param name - The name of the server function to invoke
      * @param data - The data to pass to the server function
      * @returns A promise that resolves with the function's return value
      */
     invoke: RPCInvoke = async (name, data) => {
-       return await this.pikkuFetch.post('/rpc', { name, data })
+       return await this.pikkuFetch.post('/rpc' as any, { name, data }) as any
     }
 }
 

package/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.js

@@ -27,11 +27,18 @@ export type RPCInvoke = <Name extends keyof RPCMap>(
   }
 ) => Promise<RPCMap[Name]['output']>
 
+// Import WorkflowMap for workflow typing
+import type { WorkflowMap } from '../workflow/pikku-workflow-map.gen.js'
+
 export type TypedPikkuRPC = {
   depth: number;
   global: boolean;
   invoke: RPCInvoke;
-  invokeExposed: (name: string, data: any) => Promise<any> 
+  invokeExposed: (name: string, data: any) => Promise<any>;
+  startWorkflow: <Name extends keyof WorkflowMap>(
+    name: Name,
+    input: WorkflowMap[Name]['input']
+  ) => Promise<{ runId: string }>;
 }
   `;
 };
@@ -47,8 +54,25 @@ function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
         const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
         const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
         // Store the input and output types for RPCHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
+        // Use 'any' for types not in typesMap (e.g., inline types in generated workflow workers)
+        let inputType = 'null';
+        if (input) {
+            try {
+                inputType = typesMap.getTypeMeta(input).uniqueName;
+            }
+            catch {
+                inputType = 'any';
+            }
+        }
+        let outputType = 'null';
+        if (output) {
+            try {
+                outputType = typesMap.getTypeMeta(output).uniqueName;
+            }
+            catch {
+                outputType = 'any';
+            }
+        }
         requiredTypes.add(inputType);
         requiredTypes.add(outputType);
         // Add RPC entry

package/dist/src/functions/wirings/workflow/pikku-command-workflow-map.d.ts

@@ -0,0 +1 @@
+export declare const pikkuWorkflowMap: any;

package/dist/src/functions/wirings/workflow/pikku-command-workflow-map.js

@@ -0,0 +1,12 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { serializeWorkflowMap } from './serialize-workflow-map.js';
+export const pikkuWorkflowMap = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { workflowMapDeclarationFile, packageMappings } = config;
+        const { workflows, functions: functionState } = visitState;
+        const { typesMap } = functionState;
+        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta));
+    },
+});

package/dist/src/functions/wirings/workflow/pikku-command-workflow-types.d.ts

@@ -0,0 +1 @@
+export declare const pikkuWorkflowTypes: any;

package/dist/src/functions/wirings/workflow/pikku-command-workflow-types.js

@@ -0,0 +1,11 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { serializeWorkflowTypes } from './serialize-workflow-types.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const pikkuWorkflowTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { workflowTypesFile, functionTypesFile, packageMappings } = config;
+        const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath));
+    },
+});

package/dist/src/functions/wirings/workflow/pikku-command-workflow.d.ts

@@ -0,0 +1 @@
+export declare const pikkuWorkflow: any;

package/dist/src/functions/wirings/workflow/pikku-command-workflow.js

@@ -0,0 +1,55 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { ErrorCode } from '@pikku/inspector';
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeWorkflowMeta } from './serialize-workflow-meta.js';
+import { serializeWorkflowTypes } from './serialize-workflow-types.js';
+import { serializeWorkflowMap } from './serialize-workflow-map.js';
+import { serializeWorkflowWorkers } from './serialize-workflow-workers.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { join } from 'path';
+export const pikkuWorkflow = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { workflowsWiringFile, workflowsWiringMetaFile, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, typesDeclarationFile, packageMappings, } = config;
+        const { workflows, functions: functionState } = visitState;
+        const { typesMap } = functionState;
+        // Validate that workflowService service is configured if workflows are defined
+        const hasWorkflows = Object.keys(workflows.meta).length > 0;
+        if (hasWorkflows) {
+            const hasWorkflowState = visitState.serviceAggregation.allSingletonServices.includes('workflowService');
+            if (!hasWorkflowState) {
+                logger.critical(ErrorCode.WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED, 'Workflows detected but workflowService service not configured. Please add workflowService to your singleton services');
+                throw new Error('WorkflowState service not configured but workflows are defined');
+            }
+        }
+        // Write workflow metadata
+        await writeFileInDir(logger, workflowsWiringMetaFile, serializeWorkflowMeta(workflows.meta));
+        // Write workflow wirings (imports)
+        await writeFileInDir(logger, workflowsWiringFile, serializeFileImports('wireWorkflow', workflowsWiringFile, workflows.files, packageMappings));
+        // Write workflow types
+        const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath));
+        // Write workflow map (type-safe client API)
+        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta));
+        if (config.workflows) {
+            if (config.workflows.singleQueue) {
+                const workflowPath = join(config.rootDir, config.workflows.path);
+                const pathToPikkuTypes = getFileImportRelativePath(workflowPath, typesDeclarationFile, packageMappings);
+                await writeFileInDir(logger, workflowPath, serializeWorkflowWorkers(pathToPikkuTypes));
+            }
+            else if (workflows.files.size > 0) {
+                logger.critical(ErrorCode.WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED, 'Multi-queue workflows are not supported when workflows.singleQueue is false. Please enable singleQueue in your configuration.');
+                return false;
+            }
+        }
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding Workflows',
+            commandEnd: 'Found Workflows',
+        }),
+    ],
+});

package/dist/src/functions/wirings/workflow/serialize-workflow-map.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowsMeta } from '@pikku/core/workflow';
+import { TypesMap } from '@pikku/inspector';
+import { FunctionsMeta } from '@pikku/core';
+export declare const serializeWorkflowMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, workflowsMeta: WorkflowsMeta) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-map.js

@@ -0,0 +1,79 @@
+import { serializeImportMap } from '../../../utils/serialize-import-map.js';
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
+export const serializeWorkflowMap = (relativeToPath, packageMappings, typesMap, functionsMeta, workflowsMeta) => {
+    const requiredTypes = new Set();
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
+    const serializedWorkflows = generateWorkflows(workflowsMeta, functionsMeta, typesMap, requiredTypes);
+    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for TypeScript to be aware of workflows and their input/output types
+ */
+
+${serializedImportMap}
+${serializedCustomTypes}
+
+interface WorkflowHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedWorkflows}
+
+/**
+ * Type-safe workflow client API
+ */
+export type WorkflowClient<Name extends keyof WorkflowMap> = {
+  /**
+   * Start a new workflow run
+   */
+  start: (input: WorkflowMap[Name]['input']) => Promise<{ runId: string }>;
+
+  /**
+   * Get a workflow run by ID
+   */
+  getRun: <output extends keyof WorkflowMap[Name]>(runId: string) => Promise<WorkflowMap[Name][output]>;
+
+  /**
+   * Cancel a running workflow
+   */
+  cancelRun: (runId: string) => Promise<boolean>;
+}
+
+/**
+ * Map of all registered workflows with type-safe client APIs
+ */
+export type TypedWorkflowClients = {
+  [Name in keyof WorkflowMap]: WorkflowClient<Name>;
+}
+  `;
+};
+function generateWorkflows(workflowsMeta, functionsMeta, typesMap, requiredTypes) {
+    // Initialize an object to collect workflows
+    const workflowsObj = {};
+    // Iterate through workflow metadata
+    for (const [workflowName, { pikkuFuncName }] of Object.entries(workflowsMeta)) {
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            throw new Error(`Function ${workflowName} not found in functionsMeta. Please check your configuration.`);
+        }
+        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+        // Store the input and output types for WorkflowHandler
+        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'void';
+        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'void';
+        requiredTypes.add(inputType);
+        requiredTypes.add(outputType);
+        // Add workflow entry
+        workflowsObj[workflowName] = {
+            inputType,
+            outputType,
+        };
+    }
+    // Build the Workflows object as a string
+    let workflowsStr = 'export type WorkflowMap = {\n';
+    for (const [workflowName, handler] of Object.entries(workflowsObj)) {
+        workflowsStr += `  readonly '${workflowName}': WorkflowHandler<${handler.inputType}, ${handler.outputType}>,\n`;
+    }
+    workflowsStr += '};\n';
+    return workflowsStr;
+}

package/dist/src/functions/wirings/workflow/serialize-workflow-meta.d.ts

@@ -0,0 +1,2 @@
+import { WorkflowsMeta } from '@pikku/core/workflow';
+export declare const serializeWorkflowMeta: (workflowsMeta: WorkflowsMeta) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-meta.js

@@ -0,0 +1,10 @@
+export const serializeWorkflowMeta = (workflowsMeta) => {
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push(`pikkuState('workflows', 'meta', ${JSON.stringify(workflowsMeta, null, 2)})`);
+    const workflowsMetaValues = Object.values(workflowsMeta);
+    if (workflowsMetaValues.length > 0) {
+        serializedOutput.push(`export type WorkflowNames = '${workflowsMetaValues.map((w) => w.workflowName).join("' | '")}'`);
+    }
+    return serializedOutput.join('\n');
+};

package/dist/src/functions/wirings/workflow/serialize-workflow-types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generates type definitions for workflow wirings
+ */
+export declare const serializeWorkflowTypes: (functionTypesImportPath: string) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-types.js

@@ -0,0 +1,95 @@
+/**
+ * Generates type definitions for workflow wirings
+ */
+export const serializeWorkflowTypes = (functionTypesImportPath) => {
+    return `/**
+ * Workflow-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreWorkflow, wireWorkflow as wireWorkflowCore, PikkuWorkflowInteraction, WorkflowStepOptions } from '@pikku/core/workflow'
+import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '@pikku/core'
+import type { PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { UserSession, SingletonServices } from '../../types/application-types.d.js'
+import type { TypedPikkuRPC, RPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js'
+
+/**
+ * Type definition for workflows that orchestrate multi-step processes.
+ * Workflows support both inline and remote execution modes with step caching.
+ */
+type WorkflowWiring = CoreWorkflow<
+  CorePikkuFunctionConfig<PikkuFunctionWorkflow<any, any>, PikkuPermission<any>, PikkuMiddleware>
+>
+
+/**
+ * Typed workflow interaction with RPC awareness
+ * Provides type-safe workflow.do() for RPC steps
+ */
+export interface TypedWorkflow extends PikkuWorkflowInteraction {
+  /**
+   * Execute a workflow step with RPC invocation (typed based on available RPCs)
+   * @template K - RPC name from the RPC map
+   */
+  do<K extends keyof RPCMap>(
+    stepName: string,
+    rpcName: K,
+    data: RPCMap[K]['input'],
+    options?: WorkflowStepOptions
+  ): Promise<RPCMap[K]['output']>
+
+  /**
+   * Execute a workflow step with inline function
+   * @template T - Return type of the inline function
+   */
+  do<T>(
+    stepName: string,
+    fn: () => T | Promise<T>,
+    options?: WorkflowStepOptions
+  ): Promise<T>
+}
+
+/**
+ * Workflow function type with typed workflow service
+ * Includes the workflow interaction object with typed RPC methods
+ */
+export type PikkuFunctionWorkflow<
+  In = unknown,
+  Out = never
+> = CorePikkuFunctionSessionless<
+  In,
+  Out,
+  null,
+  SingletonServices & {
+    rpc: TypedPikkuRPC
+    workflow: TypedWorkflow
+  },
+  UserSession
+>
+
+/**
+ * Creates a workflow function with typed input and output.
+ * Workflow functions have access to the workflow interaction object for step execution.
+ *
+ * @template In - Input type for the workflow
+ * @template Out - Output type for the workflow
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ */
+export const pikkuWorkflowFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionWorkflow<In, Out>
+    | CorePikkuFunctionConfig<PikkuFunctionWorkflow<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Registers a workflow with the Pikku framework.
+ * Workflows can run in 'inline' (synchronous) or 'remote' (queue-based) execution modes.
+ *
+ * @param workflow - Workflow definition with name, execution mode, and handler function
+ */
+export const wireWorkflow = (workflow: WorkflowWiring) => {
+  wireWorkflowCore(workflow as any)
+}
+`;
+};

package/dist/src/functions/wirings/workflow/serialize-workflow-workers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate queue workers and RPC functions for workflow steps and orchestrator
+ */
+export declare const serializeWorkflowWorkers: (pathToPikkuTypes: string) => string;