@pikku/cli 0.11.2 → 0.11.3

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

@@ -1,14 +1,16 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
 import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeTypedRPCMap = (relativeToPath, packageMappings, typesMap, functionsMeta, rpcMeta) => {
+export const serializeTypedRPCMap = (relativeToPath, packageMappings, typesMap, functionsMeta, rpcMeta, externalPackages) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedRPCs = generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes);
     const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const externalPackageImports = generateExternalPackageImports(externalPackages, relativeToPath);
+    const mergedRPCMap = generateMergedRPCMap(externalPackages);
     return `/**
  * This provides the structure needed for typescript to be aware of RPCs and their return types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 
@@ -18,14 +20,16 @@ interface RPCHandler<I, O> {
 }
 
 ${serializedRPCs}
+${externalPackageImports}
+${mergedRPCMap}
 
-export type RPCInvoke = <Name extends keyof RPCMap>(
+export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
   name: Name,
-  data: RPCMap[Name]['input'],
+  data: FlattenedRPCMap[Name]['input'],
   options?: {
     location?: 'local' | 'remote' | 'auto'
   }
-) => Promise<RPCMap[Name]['output']>
+) => Promise<FlattenedRPCMap[Name]['output']>
 
 // Import WorkflowMap for workflow typing
 import type { WorkflowMap } from '../workflow/pikku-workflow-map.gen.js'
@@ -42,6 +46,46 @@ export type TypedPikkuRPC = {
 }
   `;
 };
+function generateExternalPackageImports(externalPackages, relativeToPath) {
+    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+        return '';
+    }
+    let imports = '\n// External package RPC maps\n';
+    for (const [namespace, packageName] of Object.entries(externalPackages)) {
+        // Import the RPCMap from each external package's internal RPC map
+        // Use .js extension - package.json exports will resolve to .d.ts for types
+        imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${packageName}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`;
+    }
+    return imports;
+}
+function generateMergedRPCMap(externalPackages) {
+    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+        return `
+// No external packages, use RPCMap directly
+export type FlattenedRPCMap = RPCMap
+`;
+    }
+    // TypeScript utility to flatten namespaced RPC maps
+    const utilityTypes = `
+// Utility type to prefix keys with namespace
+type PrefixKeys<T, Prefix extends string> = {
+  [K in keyof T as \`\${Prefix}:\${string & K}\`]: T[K]
+}
+
+// Merge all RPC maps with namespace prefixes
+export type FlattenedRPCMap =
+  RPCMap${Object.keys(externalPackages)
+        .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}RPCMap, '${namespace}'>`)
+        .join('')}
+`;
+    return utilityTypes;
+}
+function toPascalCase(str) {
+    return str
+        .split(/[-_]/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
 function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
     // Initialize an object to collect RPCs
     const rpcsObj = {};
@@ -54,14 +98,15 @@ 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
-        // Use 'any' for types not in typesMap (e.g., inline types in generated workflow workers)
+        // For zod-derived schemas, the type might not be in typesMap, so use the schema name directly
         let inputType = 'null';
         if (input) {
             try {
                 inputType = typesMap.getTypeMeta(input).uniqueName;
             }
             catch {
-                inputType = 'any';
+                // Type not in typesMap - use the name directly (e.g., zod-derived types)
+                inputType = input;
             }
         }
         let outputType = 'null';
@@ -70,7 +115,8 @@ function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
                 outputType = typesMap.getTypeMeta(output).uniqueName;
             }
             catch {
-                outputType = 'any';
+                // Type not in typesMap - use the name directly (e.g., zod-derived types)
+                outputType = output;
             }
         }
         requiredTypes.add(inputType);

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

@@ -4,12 +4,21 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeSchedulerMeta, serializeSchedulerMetaTS, } from './serialize-scheduler-meta.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuScheduler = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const { schedulersWiringFile, schedulersWiringMetaFile, schedulersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { scheduledTasks } = visitState;
-        await writeFileInDir(logger, schedulersWiringMetaJsonFile, JSON.stringify(serializeSchedulerMeta(scheduledTasks.meta), null, 2));
+        const fullMeta = serializeSchedulerMeta(scheduledTasks.meta);
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(fullMeta);
+        await writeFileInDir(logger, schedulersWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(fullMeta)) {
+            const verbosePath = schedulersWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
+        }
         const jsonImportPath = getFileImportRelativePath(schedulersWiringMetaFile, schedulersWiringMetaJsonFile, packageMappings);
         await writeFileInDir(logger, schedulersWiringMetaFile, serializeSchedulerMetaTS(scheduledTasks.meta, jsonImportPath, schema?.supportsImportAttributes ?? false));
         await writeFileInDir(logger, schedulersWiringFile, serializeFileImports('addScheduledTasks', schedulersWiringFile, scheduledTasks.files, packageMappings));

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

@@ -10,7 +10,7 @@ export const serializeSchedulerMetaTS = (scheduledTasksMeta, jsonImportPath, sup
     serializedOutput.push("import { ScheduledTasksMeta } from '@pikku/core/scheduler'");
     serializedOutput.push(importStatement);
     serializedOutput.push('');
-    serializedOutput.push("pikkuState('scheduler', 'meta', metaData as ScheduledTasksMeta)");
+    serializedOutput.push("pikkuState(null, 'scheduler', 'meta', metaData as ScheduledTasksMeta)");
     serializedOutput.push('');
     const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
     if (scheduledTasksMetaValues.length > 0) {

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

@@ -1,22 +1,29 @@
 import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { ErrorCode } from '@pikku/inspector';
+import { convertDslToGraph, ErrorCode } from '@pikku/inspector';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { serializeWorkflowMeta, serializeWorkflowMetaTS, } from './serialize-workflow-meta.js';
 import { serializeWorkflowTypes } from './serialize-workflow-types.js';
+import { serializeWorkflowRegistration } from './serialize-workflow-registration.js';
 import { serializeWorkflowMap } from './serialize-workflow-map.js';
+import { serializeWorkflowMeta } from './serialize-workflow-meta.js';
 import { serializeWorkflowWorkers } from './serialize-workflow-workers.js';
-import { serializeWorkflowWirings } from './serialize-workflow-wirings.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 import { join } from 'path';
 export const pikkuWorkflow = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { workflowsWiringFile, workflowsWiringMetaFile, workflowsWiringMetaJsonFile, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, typesDeclarationFile, packageMappings, schema, } = config;
+        const { workflowsWiringFile, workflowsWiringMetaFile, workflowMetaDir, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, typesDeclarationFile, packageMappings, schema, } = 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;
+        // Get all workflow names (both DSL and graph-based)
+        const dslWorkflowNames = Object.keys(workflows.meta);
+        const graphWorkflowNames = Object.keys(workflows.graphMeta);
+        const allWorkflowNames = [
+            ...new Set([...dslWorkflowNames, ...graphWorkflowNames]),
+        ];
+        const hasWorkflows = allWorkflowNames.length > 0;
+        // Validate that workflowService is configured if workflows are defined
         if (hasWorkflows) {
             const hasWorkflowState = visitState.serviceAggregation.allSingletonServices.includes('workflowService');
             if (!hasWorkflowState) {
@@ -24,19 +31,50 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
                 throw new Error('WorkflowState service not configured but workflows are defined');
             }
         }
-        await writeFileInDir(logger, workflowsWiringMetaJsonFile, JSON.stringify(serializeWorkflowMeta(workflows.meta), null, 2));
-        const jsonImportPath = getFileImportRelativePath(workflowsWiringMetaFile, workflowsWiringMetaJsonFile, packageMappings);
-        // Write workflow metadata TypeScript file that imports JSON
-        await writeFileInDir(logger, workflowsWiringMetaFile, serializeWorkflowMetaTS(workflows.meta, jsonImportPath, schema?.supportsImportAttributes ?? false));
-        // Write workflow wirings (imports and addWorkflow calls)
-        await writeFileInDir(logger, workflowsWiringFile, serializeWorkflowWirings(workflowsWiringFile, workflows.files, packageMappings));
-        // Write workflow types
+        // Generate individual JSON files for each workflow (convert DSL to graph format)
+        if (hasWorkflows && workflowMetaDir) {
+            // Write individual JSON files for DSL workflows
+            const dslMeta = workflows.meta;
+            for (const [name, meta] of Object.entries(dslMeta)) {
+                const graphMeta = convertDslToGraph(name, meta);
+                // Write minimal version (runtime-only fields)
+                const minimalMeta = stripVerboseFields(graphMeta);
+                const minimalPath = join(workflowMetaDir, `${name}.gen.json`);
+                await writeFileInDir(logger, minimalPath, JSON.stringify(minimalMeta, null, 2), { ignoreModifyComment: true });
+                // Write verbose version only if it has additional fields
+                if (hasVerboseFields(graphMeta)) {
+                    const verbosePath = join(workflowMetaDir, `${name}-verbose.gen.json`);
+                    await writeFileInDir(logger, verbosePath, JSON.stringify(graphMeta, null, 2), { ignoreModifyComment: true });
+                }
+            }
+            // Write individual JSON files for graph workflows
+            for (const [name, graphMeta] of Object.entries(workflows.graphMeta)) {
+                // Write minimal version (runtime-only fields)
+                const minimalMeta = stripVerboseFields(graphMeta);
+                const minimalPath = join(workflowMetaDir, `${name}.gen.json`);
+                await writeFileInDir(logger, minimalPath, JSON.stringify(minimalMeta, null, 2), { ignoreModifyComment: true });
+                // Write verbose version only if it has additional fields
+                if (hasVerboseFields(graphMeta)) {
+                    const verbosePath = join(workflowMetaDir, `${name}-verbose.gen.json`);
+                    await writeFileInDir(logger, verbosePath, JSON.stringify(graphMeta, null, 2), { ignoreModifyComment: true });
+                }
+            }
+        }
+        // Generate workflow meta aggregation file
+        if (workflowsWiringMetaFile && workflowMetaDir) {
+            await writeFileInDir(logger, workflowsWiringMetaFile, serializeWorkflowMeta(workflowsWiringMetaFile, workflowMetaDir, allWorkflowNames, packageMappings, schema?.supportsImportAttributes ?? false, config.externalPackageName));
+        }
+        // Generate workflow registration (meta + DSL workflow registrations)
+        const metaImportPath = getFileImportRelativePath(workflowsWiringFile, workflowsWiringMetaFile, packageMappings);
+        await writeFileInDir(logger, workflowsWiringFile, serializeWorkflowRegistration(workflowsWiringFile, metaImportPath, allWorkflowNames, workflows.files, workflows.graphFiles, packageMappings, config.externalPackageName));
+        // Generate workflow types (DSL + graph helpers in one file)
         const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
-        // Get RPC map import path
         const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
         await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath));
-        // Write workflow map (type-safe client API)
+        // Generate workflow map (I/O types for type-safe client)
+        // Always generate even if empty - RPC map imports WorkflowMap
         await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta));
+        // Generate workflow workers if configured
         if (config.workflows) {
             if (config.workflows.singleQueue) {
                 const workflowPath = join(config.rootDir, config.workflows.path);
@@ -48,12 +86,12 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
                 return false;
             }
         }
-        return true;
+        return hasWorkflows;
     },
     middleware: [
         logCommandInfoAndTime({
-            commandStart: 'Finding Workflows',
-            commandEnd: 'Found Workflows',
+            commandStart: 'Generating Workflows',
+            commandEnd: 'Generated Workflows',
         }),
     ],
 });

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

@@ -1,3 +1,6 @@
+/**
+ * Generate workflow map type definitions for type-safe client API
+ */
 import type { WorkflowsMeta } from '@pikku/core/workflow';
 import { TypesMap } from '@pikku/inspector';
 import { FunctionsMeta } from '@pikku/core';

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

@@ -2,11 +2,18 @@ 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);
+    // First generate workflows to collect required types
     const serializedWorkflows = generateWorkflows(workflowsMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    // Only generate custom types if we have workflows with types
+    const hasWorkflows = Object.keys(workflowsMeta).length > 0;
+    const serializedCustomTypes = hasWorkflows
+        ? generateCustomTypes(typesMap, requiredTypes)
+        : '';
+    const serializedImportMap = hasWorkflows
+        ? serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes)
+        : '';
     return `/**
- * This provides the structure needed for TypeScript to be aware of workflows and their input/output types
+ * Workflow type map with input/output types for each workflow
  */
 
 ${serializedImportMap}
@@ -19,38 +26,19 @@ interface WorkflowHandler<I, 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) {
@@ -58,18 +46,28 @@ function generateWorkflows(workflowsMeta, 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 WorkflowHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'void';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'void';
+        let inputType = 'void';
+        if (input) {
+            try {
+                inputType = typesMap.getTypeMeta(input).uniqueName;
+            }
+            catch {
+                inputType = input;
+            }
+        }
+        let outputType = 'void';
+        if (output) {
+            try {
+                outputType = typesMap.getTypeMeta(output).uniqueName;
+            }
+            catch {
+                outputType = output;
+            }
+        }
         requiredTypes.add(inputType);
         requiredTypes.add(outputType);
-        // Add workflow entry
-        workflowsObj[workflowName] = {
-            inputType,
-            outputType,
-        };
+        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`;

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

@@ -1,3 +1 @@
-import { WorkflowsMeta } from '@pikku/core/workflow';
-export declare const serializeWorkflowMeta: (workflowsMeta: WorkflowsMeta) => WorkflowsMeta;
-export declare const serializeWorkflowMetaTS: (workflowsMeta: WorkflowsMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;
+export declare const serializeWorkflowMeta: (outputPath: string, metaDir: string, workflowNames: string[], packageMappings: Record<string, string>, supportsImportAttributes: boolean, packageName?: string) => string;

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

@@ -1,20 +1,45 @@
-export const serializeWorkflowMeta = (workflowsMeta) => {
-    return workflowsMeta;
-};
-export const serializeWorkflowMetaTS = (workflowsMeta, jsonImportPath, supportsImportAttributes) => {
-    const importStatement = supportsImportAttributes
-        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-        : `import metaData from '${jsonImportPath}'`;
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push("import { WorkflowsMeta } from '@pikku/core/workflow'");
-    serializedOutput.push(importStatement);
-    serializedOutput.push('');
-    serializedOutput.push("pikkuState('workflows', 'meta', metaData as WorkflowsMeta)");
-    serializedOutput.push('');
-    const workflowsMetaValues = Object.values(workflowsMeta);
-    if (workflowsMetaValues.length > 0) {
-        serializedOutput.push(`export type WorkflowNames = '${workflowsMetaValues.map((w) => w.workflowName).join("' | '")}'`);
+/**
+ * Generate workflow meta aggregation file that imports individual workflow JSON files
+ * and registers them with pikkuState
+ */
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const serializeWorkflowMeta = (outputPath, metaDir, workflowNames, packageMappings, supportsImportAttributes, packageName) => {
+    const lines = [];
+    if (workflowNames.length === 0) {
+        // Empty meta file - still need to register empty meta
+        lines.push("import { pikkuState } from '@pikku/core'");
+        lines.push("import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph'");
+        lines.push('');
+        lines.push('const workflowsMeta: SerializedWorkflowGraphs = {}');
+        lines.push('');
+        const packageNameValue = packageName ? `'${packageName}'` : 'null';
+        lines.push(`pikkuState(${packageNameValue}, 'workflows', 'meta', workflowsMeta)`);
+        return lines.join('\n');
+    }
+    // Imports
+    lines.push("import { pikkuState } from '@pikku/core'");
+    lines.push("import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph'");
+    lines.push('');
+    // Import each workflow meta JSON
+    const sortedNames = [...workflowNames].sort();
+    for (const name of sortedNames) {
+        const jsonPath = `${metaDir}/${name}.gen.json`;
+        const importPath = getFileImportRelativePath(outputPath, jsonPath, packageMappings);
+        const importStatement = supportsImportAttributes
+            ? `import ${name}Meta from '${importPath}' with { type: 'json' }`
+            : `import ${name}Meta from '${importPath}'`;
+        lines.push(importStatement);
+    }
+    lines.push('');
+    // Create aggregated meta object (cast JSON imports to proper types)
+    lines.push('const workflowsMeta = {');
+    for (const name of sortedNames) {
+        lines.push(`  '${name}': ${name}Meta,`);
     }
-    return serializedOutput.join('\n');
+    lines.push('} as SerializedWorkflowGraphs');
+    lines.push('');
+    // Register meta with pikkuState
+    const packageNameValue = packageName ? `'${packageName}'` : 'null';
+    lines.push(`pikkuState(${packageNameValue}, 'workflows', 'meta', workflowsMeta)`);
+    return lines.join('\n');
 };

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

@@ -0,0 +1,7 @@
+export declare const serializeWorkflowRegistration: (outputPath: string, metaImportPath: string, workflowNames: string[], workflowFiles: Map<string, {
+    path: string;
+    exportedName: string;
+}>, graphFiles: Map<string, {
+    path: string;
+    exportedName: string;
+}>, packageMappings: Record<string, string>, _packageName?: string) => string;

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

@@ -0,0 +1,53 @@
+/**
+ * Generate workflow runtime registration
+ * Imports meta (which registers with pikkuState) and registers DSL workflows (addWorkflow) and graph workflows (addWorkflowGraph)
+ */
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const serializeWorkflowRegistration = (outputPath, metaImportPath, workflowNames, workflowFiles, graphFiles, packageMappings, _packageName) => {
+    const lines = [];
+    const hasWorkflows = workflowNames.length > 0;
+    const hasDslWorkflows = workflowFiles.size > 0;
+    const hasGraphWorkflows = graphFiles.size > 0;
+    // Imports
+    const imports = [];
+    if (hasDslWorkflows) {
+        imports.push('addWorkflow');
+    }
+    if (hasGraphWorkflows) {
+        imports.push('addWorkflowGraph');
+    }
+    if (imports.length > 0) {
+        lines.push(`import { ${imports.join(', ')} } from '@pikku/core/workflow'`);
+    }
+    // Import meta file (which registers meta with pikkuState)
+    if (hasWorkflows) {
+        lines.push(`import '${metaImportPath}'`);
+    }
+    // Import DSL workflow functions
+    const sortedWorkflows = Array.from(workflowFiles.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [, { path, exportedName }] of sortedWorkflows) {
+        const importPath = getFileImportRelativePath(outputPath, path, packageMappings);
+        lines.push(`import { ${exportedName} } from '${importPath}'`);
+    }
+    // Import graph workflow definitions
+    const sortedGraphWorkflows = Array.from(graphFiles.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [, { path, exportedName }] of sortedGraphWorkflows) {
+        const importPath = getFileImportRelativePath(outputPath, path, packageMappings);
+        lines.push(`import { ${exportedName} } from '${importPath}'`);
+    }
+    lines.push('');
+    // Register DSL workflows
+    for (const [pikkuFuncName, { exportedName }] of sortedWorkflows) {
+        lines.push(`addWorkflow('${pikkuFuncName}', ${exportedName})`);
+    }
+    // Register graph workflows
+    for (const [workflowName, { exportedName }] of sortedGraphWorkflows) {
+        lines.push(`addWorkflowGraph('${workflowName}', ${exportedName})`);
+    }
+    // Export workflow names type
+    if (hasWorkflows) {
+        lines.push('');
+        lines.push(`export type WorkflowNames = '${workflowNames.join("' | '")}'`);
+    }
+    return lines.join('\n');
+};

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

@@ -1,4 +1,6 @@
 /**
- * Generates type definitions for workflow wirings
+ * Generate all workflow type helpers for authoring workflows
+ * Combines DSL helpers (pikkuWorkflowFunc, pikkuWorkflowComplexFunc) and
+ * graph helpers (pikkuWorkflowGraph) with unified wireWorkflow
  */
 export declare const serializeWorkflowTypes: (functionTypesImportPath: string, rpcMapImportPath: string) => string;