@pikku/cli 0.11.1 → 0.11.3

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,2 +1 @@
-import { WorkflowsMeta } from '@pikku/core/workflow';
-export declare const serializeWorkflowMeta: (workflowsMeta: WorkflowsMeta) => 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,10 +1,45 @@
-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("' | '")}'`);
+/**
+ * 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');
     }
-    return serializedOutput.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,`);
+    }
+    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) => string;
+export declare const serializeWorkflowTypes: (functionTypesImportPath: string, rpcMapImportPath: string) => string;

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

@@ -1,34 +1,32 @@
 /**
- * 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 const serializeWorkflowTypes = (functionTypesImportPath) => {
+export const serializeWorkflowTypes = (functionTypesImportPath, rpcMapImportPath) => {
     return `/**
- * Workflow-specific type definitions for tree-shaking optimization
+ * Workflow type definitions and helpers
+ * Used for authoring both DSL and graph-based workflows
  */
 
-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'
+import { PikkuWorkflowWire, WorkflowStepOptions, WorkflowCancelledException } from '@pikku/core/workflow'
 
-/**
- * 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>
->
+// Re-export WorkflowCancelledException for use in workflow functions
+export { WorkflowCancelledException }
+import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '${functionTypesImportPath}'
+import type { RPCMap, FlattenedRPCMap } from '${rpcMapImportPath}'
+import type { GraphNodeConfig, HTTPMethod } from '@pikku/core'
+import { createGraph, wireWorkflow as coreWireWorkflow } from '@pikku/core'
+
+// ============================================================================
+// DSL Workflow Types (pikkuWorkflowFunc, pikkuWorkflowComplexFunc)
+// ============================================================================
 
 /**
- * Typed workflow interaction with RPC awareness
+ * Typed workflow wire 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
-   */
+export interface TypedWorkflow extends PikkuWorkflowWire {
   do<K extends keyof RPCMap>(
     stepName: string,
     rpcName: K,
@@ -36,10 +34,6 @@ export interface TypedWorkflow extends PikkuWorkflowInteraction {
     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>,
@@ -49,47 +43,312 @@ export interface TypedWorkflow extends PikkuWorkflowInteraction {
 
 /**
  * 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
->
+> = PikkuFunctionSessionless<In, Out, 'workflow'>
 
 /**
- * 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
+ * Creates a DSL-compatible workflow function (serializable, shows in Forge UI)
  */
 export const pikkuWorkflowFunc = <In, Out = unknown>(
   func:
     | PikkuFunctionWorkflow<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunctionWorkflow<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+    | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a complex workflow function (arbitrary code, hidden from Forge UI)
+ */
+export const pikkuWorkflowComplexFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionWorkflow<In, Out>
+    | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
 
+// ============================================================================
+// Graph Workflow Types (pikkuWorkflowGraph)
+// ============================================================================
+
+/**
+ * Type-safe graph builder with full RPC autocomplete
+ */
+const graphBuilder = createGraph<FlattenedRPCMap>()
+
+/** HTTP wire configuration for graph workflows */
+interface GraphHttpWire<NodeIds extends string> {
+  route: string
+  method: HTTPMethod
+  startNode: NodeIds
+}
+
+/** Channel wire configuration for graph workflows */
+interface GraphChannelWire<NodeIds extends string> {
+  name: string
+  onConnect?: NodeIds
+  onDisconnect?: NodeIds
+  onMessage?: NodeIds
+}
+
+/** Queue wire configuration for graph workflows */
+interface GraphQueueWire<NodeIds extends string> {
+  name: string
+  startNode: NodeIds
+}
+
+/** CLI wire configuration for graph workflows */
+interface GraphCliWire<NodeIds extends string> {
+  command: string
+  startNode: NodeIds
+}
+
+/** MCP wire configurations for graph workflows */
+interface GraphMcpWires<NodeIds extends string> {
+  tool?: Array<{ name: string; startNode: NodeIds }>
+  prompt?: Array<{ name: string; startNode: NodeIds }>
+  resource?: Array<{ uri: string; startNode: NodeIds }>
+}
+
+/** Schedule wire configuration for graph workflows */
+interface GraphScheduleWire<NodeIds extends string> {
+  cron?: string
+  interval?: string
+  startNode: NodeIds
+}
+
+/** Trigger wire configuration for graph workflows */
+interface GraphTriggerWire<NodeIds extends string> {
+  name: string  // RPC name of the trigger function
+  startNode: NodeIds
+}
+
+/** All wire configurations for graph workflows */
+interface GraphWiresConfig<NodeIds extends string> {
+  http?: Array<GraphHttpWire<NodeIds>>
+  channel?: Array<GraphChannelWire<NodeIds>>
+  queue?: Array<GraphQueueWire<NodeIds>>
+  cli?: Array<GraphCliWire<NodeIds>>
+  mcp?: GraphMcpWires<NodeIds>
+  schedule?: Array<GraphScheduleWire<NodeIds>>
+  trigger?: Array<GraphTriggerWire<NodeIds>>
+}
+
+/** Configuration for graph-based workflow */
+export interface PikkuWorkflowGraphConfig<
+  FuncMap extends Record<string, keyof FlattenedRPCMap & string>,
+  T
+> {
+  /** Workflow name (optional - defaults to exported variable name) */
+  name?: string
+  /** Optional description */
+  description?: string
+  /** Optional tags for organization */
+  tags?: string[]
+  /** Node to RPC function mapping */
+  nodes: FuncMap
+  /** Wire configurations - how this workflow can be triggered */
+  wires?: GraphWiresConfig<Extract<keyof FuncMap, string>>
+  /** Node configurations (next, input, onError) */
+  config?: T
+}
+
+/** Result of pikkuWorkflowGraph - includes metadata for wiring */
+export interface PikkuWorkflowGraphResult<T, NodeIds extends string = string> {
+  __type: 'pikkuWorkflowGraph'
+  name?: string
+  description?: string
+  tags?: string[]
+  wires?: GraphWiresConfig<NodeIds>
+  graph: T
+}
+
 /**
- * Registers a workflow with the Pikku framework.
- * Workflows can run in 'inline' (synchronous) or 'remote' (queue-based) execution modes.
+ * Creates a graph-based workflow definition with metadata
+ * Name defaults to the exported variable name if not provided.
+ *
+ * @example
+ * // Name inferred from exported variable name
+ * export const myWorkflow = pikkuWorkflowGraph({
+ *   description: 'Handles user onboarding',
+ *   tags: ['onboarding'],
+ *   nodes: {
+ *     entry: 'createUser',
+ *     sendEmail: 'sendWelcomeEmail',
+ *   },
+ *   config: {
+ *     entry: { next: 'sendEmail' },
+ *     sendEmail: { input: (ref) => ({ to: ref('entry', 'email') }) },
+ *   },
+ * })
+ */
+export function pikkuWorkflowGraph<
+  const FuncMap extends Record<string, keyof FlattenedRPCMap & string>
+>(
+  config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>
+): PikkuWorkflowGraphResult<Record<Extract<keyof FuncMap, string>, GraphNodeConfig<Extract<keyof FuncMap, string>>>, Extract<keyof FuncMap, string>> {
+  return {
+    __type: 'pikkuWorkflowGraph',
+    name: config.name,
+    description: config.description,
+    tags: config.tags,
+    wires: config.wires,
+    graph: graphBuilder(config.nodes, config.config as any),
+  }
+}
+
+/** Typed ref value */
+type TypedRef<T> = { $ref: string; path?: string } & { __phantomType?: T }
+
+/** Template string type - assignable to string fields */
+type TemplateString = {
+  $template: {
+    parts: string[]
+    expressions: Array<{ $ref: string; path?: string }>
+  }
+} & { __brand: 'TemplateString' }
+
+/**
+ * Creates a template string with variable interpolation
+ * Uses indexed placeholders $0, $1, etc. with refs array
+ *
+ * @example
+ * template('Hello $0, your order $1 is ready', [ref('trigger', 'name'), ref('step_0', 'orderId')])
+ */
+export function template(templateStr: string, refs: TypedRef<unknown>[]): TemplateString {
+  const parts: string[] = []
+  const expressions: Array<{ $ref: string; path?: string }> = []
+
+  // Parse template string: "Hello $0" -> parts: ["Hello ", ""], use refs[0] for expression
+  const regex = /\$(\d+)/g
+  let lastIndex = 0
+  let match
+
+  while ((match = regex.exec(templateStr)) !== null) {
+    // Add the part before this match
+    parts.push(templateStr.slice(lastIndex, match.index))
+
+    // Get the ref by index
+    const refIndex = parseInt(match[1]!, 10)
+    const refValue = refs[refIndex]
+    if (refValue) {
+      const expr: { $ref: string; path?: string } = { $ref: refValue.$ref }
+      if (refValue.path) {
+        expr.path = refValue.path
+      }
+      expressions.push(expr)
+    } else {
+      expressions.push({ $ref: 'unknown' })
+    }
+
+    lastIndex = regex.lastIndex
+  }
+
+  // Add the remaining part
+  parts.push(templateStr.slice(lastIndex))
+
+  return {
+    $template: { parts, expressions }
+  } as TemplateString
+}
+
+/** Map input type fields to allow TypedRef or TemplateString for any field */
+type InputWithRefs<T> = {
+  [K in keyof T]?: T[K] | TypedRef<T[K]> | TypedRef<unknown> | TemplateString
+}
+
+/** Get the input type for a node based on its RPC mapping */
+type NodeInputType<FuncMap extends Record<string, string>, K extends keyof FuncMap> =
+  FuncMap[K] extends keyof FlattenedRPCMap
+    ? InputWithRefs<FlattenedRPCMap[FuncMap[K]]['input']>
+    : Record<string, unknown>
+
+/** Get the output type keys for a node based on its RPC mapping */
+type NodeOutputKeys<FuncMap extends Record<string, string>, N extends string> =
+  N extends keyof FuncMap
+    ? FuncMap[N] extends keyof FlattenedRPCMap
+      ? keyof FlattenedRPCMap[FuncMap[N]]['output'] & string
+      : string
+    : string
+
+/** Ref function type with path validation */
+type RefFunction<FuncMap extends Record<string, string>> = {
+  <N extends Extract<keyof FuncMap, string>>(
+    nodeId: N,
+    path: NodeOutputKeys<FuncMap, N>
+  ): TypedRef<unknown>
+  (nodeId: 'trigger' | '$item', path?: string): TypedRef<unknown>
+}
+
+/** Template function type */
+type TemplateFunction = (templateStr: string, refs: TypedRef<unknown>[]) => TemplateString
+
+/** Type helper for node configuration */
+type GraphNodeConfigMap<FuncMap extends Record<string, string>> = {
+  [K in Extract<keyof FuncMap, string>]?: {
+    next?: NextConfig<Extract<keyof FuncMap, string>>
+    input?:
+      | NodeInputType<FuncMap, K>
+      | (() => NodeInputType<FuncMap, K>)
+      | ((ref: RefFunction<FuncMap>, template: TemplateFunction) => NodeInputType<FuncMap, K>)
+    onError?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[]
+  }
+}
+
+type NextConfig<NodeIds extends string> = NodeIds | NodeIds[] | { if: string; then: NodeIds; else?: NodeIds }
+
+// ============================================================================
+// Unified wireWorkflow
+// ============================================================================
+
+/** Workflow definition with DSL function */
+interface WorkflowDefinitionFunc {
+  /** Whether this workflow wiring is enabled (default: true) */
+  enabled?: boolean
+  /** Wire configurations for the workflow */
+  wires: {
+    http?: { route: string; method: HTTPMethod }
+    channel?: string
+    queue?: string
+  }
+  /** DSL workflow function */
+  func: PikkuFunctionConfig<any, any, 'workflow', PikkuFunctionWorkflow<any, any>>
+}
+
+/** Workflow definition with graph */
+interface WorkflowDefinitionGraph<T, NodeIds extends string = string> {
+  /** Whether this workflow wiring is enabled (default: true) */
+  enabled?: boolean
+  /** Graph workflow definition - wires are defined in the graph itself */
+  graph: PikkuWorkflowGraphResult<T, NodeIds>
+}
+
+/**
+ * Wire a workflow with wires
+ * Accepts either a DSL function (func) or a graph definition (graph)
+ *
+ * @example
+ * // DSL workflow
+ * wireWorkflow({
+ *   wires: { http: { route: '/start', method: 'post' } },
+ *   func: myWorkflowFunc,
+ * })
  *
- * @param workflow - Workflow definition with name, execution mode, and handler function
+ * @example
+ * // Graph workflow - wires are defined in the graph itself
+ * wireWorkflow({
+ *   enabled: true,  // default: true
+ *   graph: myGraphWorkflow,
+ * })
  */
-export const wireWorkflow = (workflow: WorkflowWiring) => {
-  wireWorkflowCore(workflow as any)
+export function wireWorkflow<T extends Record<string, GraphNodeConfig<Extract<keyof T, string>>>, NodeIds extends string = string>(
+  definition: WorkflowDefinitionFunc | WorkflowDefinitionGraph<T, NodeIds>
+): void {
+  coreWireWorkflow(definition as any)
 }
 `;
 };

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

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