@pikku/cli 0.11.1 → 0.11.2

package/src/functions/wirings/queue/pikku-command-queue.ts

@@ -2,7 +2,11 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 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 { serializeQueueMeta } from './serialize-queue-meta.js'
+import {
+  serializeQueueMeta,
+  serializeQueueMetaTS,
+} from './serialize-queue-meta.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean | undefined>({
   func: async ({ logger, config, getInspectorState }) => {
@@ -10,15 +14,36 @@ export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean | undefined>({
     const {
       queueWorkersWiringFile,
       queueWorkersWiringMetaFile,
+      queueWorkersWiringMetaJsonFile,
       packageMappings,
+      schema,
     } = config
     const { queueWorkers } = visitState
 
+    // Write JSON file
     await writeFileInDir(
       logger,
+      queueWorkersWiringMetaJsonFile,
+      JSON.stringify(serializeQueueMeta(queueWorkers.meta), null, 2)
+    )
+
+    // Calculate relative path from TS file to JSON file
+    const jsonImportPath = getFileImportRelativePath(
       queueWorkersWiringMetaFile,
-      serializeQueueMeta(queueWorkers.meta)
+      queueWorkersWiringMetaJsonFile,
+      packageMappings
     )
+
+    // Write TypeScript file that imports JSON
+    await writeFileInDir(
+      logger,
+      queueWorkersWiringMetaFile,
+      serializeQueueMetaTS(
+        jsonImportPath,
+        schema?.supportsImportAttributes ?? false
+      )
+    )
+
     await writeFileInDir(
       logger,
       queueWorkersWiringFile,

package/src/functions/wirings/queue/pikku-queue.ts

@@ -2,7 +2,11 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 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 { serializeQueueMeta } from './serialize-queue-meta.js'
+import {
+  serializeQueueMeta,
+  serializeQueueMetaTS,
+} from './serialize-queue-meta.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean>({
   func: async ({ logger, config, getInspectorState }) => {
@@ -10,7 +14,9 @@ export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean>({
     const {
       queueWorkersWiringFile,
       queueWorkersWiringMetaFile,
+      queueWorkersWiringMetaJsonFile,
       packageMappings,
+      schema,
     } = config
     const { queueWorkers } = visitState
 
@@ -23,11 +29,30 @@ export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean>({
       }
     }
 
+    // Write JSON file
     await writeFileInDir(
       logger,
+      queueWorkersWiringMetaJsonFile,
+      JSON.stringify(serializeQueueMeta(queueMeta), null, 2)
+    )
+
+    // Calculate relative path from TS file to JSON file
+    const jsonImportPath = getFileImportRelativePath(
       queueWorkersWiringMetaFile,
-      serializeQueueMeta(queueMeta)
+      queueWorkersWiringMetaJsonFile,
+      packageMappings
     )
+
+    // Write TypeScript file that imports JSON
+    await writeFileInDir(
+      logger,
+      queueWorkersWiringMetaFile,
+      serializeQueueMetaTS(
+        jsonImportPath,
+        schema?.supportsImportAttributes ?? false
+      )
+    )
+
     await writeFileInDir(
       logger,
       queueWorkersWiringFile,

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

@@ -1,10 +1,24 @@
 import { QueueWorkersMeta } from '@pikku/core/queue'
 
 export const serializeQueueMeta = (queueWorkersMeta: QueueWorkersMeta) => {
+  return queueWorkersMeta
+}
+
+export const serializeQueueMetaTS = (
+  jsonImportPath: string,
+  supportsImportAttributes: boolean
+) => {
+  const importStatement = supportsImportAttributes
+    ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+    : `import metaData from '${jsonImportPath}'`
+
   const serializedOutput: string[] = []
   serializedOutput.push("import { pikkuState } from '@pikku/core'")
+  serializedOutput.push("import { QueueWorkersMeta } from '@pikku/core/queue'")
+  serializedOutput.push(importStatement)
+  serializedOutput.push('')
   serializedOutput.push(
-    `pikkuState('queue', 'meta', ${JSON.stringify(queueWorkersMeta, null, 2)})`
+    "pikkuState('queue', 'meta', metaData as QueueWorkersMeta)"
   )
   return serializedOutput.join('\n')
 }

package/src/functions/wirings/queue/serialize-queue-types.ts

@@ -15,7 +15,7 @@ import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
  * @template In - Input type for the queue job
  * @template Out - Output type for the queue job
  */
-type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out>>
+type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out, 'session' | 'rpc'>>
 
 /**
  * Registers a queue worker with the Pikku framework.

package/src/functions/wirings/rpc/pikku-command-rpc.ts

@@ -1,17 +1,40 @@
 import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuRPC: any = pikkuSessionlessFunc<void, boolean>({
   func: async ({ logger, config, getInspectorState }) => {
     const { rpc } = await getInspectorState()
-    const { rpcInternalWiringMetaFile } = config
+    const {
+      rpcInternalWiringMetaFile,
+      rpcInternalWiringMetaJsonFile,
+      packageMappings,
+      schema,
+    } = config
 
     if (rpc.internalFiles.size > 0) {
+      await writeFileInDir(
+        logger,
+        rpcInternalWiringMetaJsonFile,
+        JSON.stringify(rpc.internalMeta, null, 2)
+      )
+
+      const jsonImportPath = getFileImportRelativePath(
+        rpcInternalWiringMetaFile,
+        rpcInternalWiringMetaJsonFile,
+        packageMappings
+      )
+
+      const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+      const importStatement = supportsImportAttributes
+        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+        : `import metaData from '${jsonImportPath}'`
+
       await writeFileInDir(
         logger,
         rpcInternalWiringMetaFile,
-        `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`
+        `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState('rpc', 'meta', metaData as Record<string, string>)`
       )
       return true
     }

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

@@ -13,16 +13,23 @@ import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
  * This is used for public HTTP access to exposed server functions
  */
 export const rpcCaller = pikkuSessionlessFunc<
-  { name: string, data?: any },
+  { rpcName: string, data?: any },
   any
 >({
-  func: async ({ rpc }, { name, data }) => {
-    return await (rpc.invokeExposed as any)(name, data)
+  func: async (services, { rpcName, data }, { rpc }) => {
+    return await (rpc.invokeExposed as any)(rpcName, data)
   },
 })
 
 wireHTTP({
-  route: '/rpc',
+  route: "/rpc/:rpcName",
+  method: "options",
+  auth: false,
+  func: pikkuSessionlessFunc<{ rpcName: string }>(async () => void 0),
+});
+
+wireHTTP({
+  route: '/rpc/:rpcName',
   method: 'post',
   func: rpcCaller,
 })

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

@@ -16,7 +16,7 @@ export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
   { rpcName: string, data?: any },
   any
 >({
-  func: async ({ rpc }, { rpcName, data }) => {
+  func: async (_services, { rpcName, data }, { rpc }) => {
     return await (rpc.invoke as any)(rpcName, data)
   },
   internal: true,

package/src/functions/wirings/rpc/serialize-rpc-wrapper.ts

@@ -54,12 +54,12 @@ export class PikkuRPC {
      * 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 rpcName - 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' as any, { name, data }) as any
+    invoke: RPCInvoke = async (rpcName, data) => {
+       return await this.pikkuFetch.post(\`/rpc/\${rpcName}\` as any, { rpcName, data }) as any
     }
 }
 

package/src/functions/wirings/scheduler/pikku-command-scheduler.ts

@@ -2,7 +2,11 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 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 { serializeSchedulerMeta } from './serialize-scheduler-meta.js'
+import {
+  serializeSchedulerMeta,
+  serializeSchedulerMetaTS,
+} from './serialize-scheduler-meta.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuScheduler: any = pikkuSessionlessFunc<
   void,
@@ -10,15 +14,37 @@ export const pikkuScheduler: any = pikkuSessionlessFunc<
 >({
   func: async ({ logger, config, getInspectorState }) => {
     const visitState = await getInspectorState()
-    const { schedulersWiringFile, schedulersWiringMetaFile, packageMappings } =
-      config
+    const {
+      schedulersWiringFile,
+      schedulersWiringMetaFile,
+      schedulersWiringMetaJsonFile,
+      packageMappings,
+      schema,
+    } = config
     const { scheduledTasks } = visitState
 
     await writeFileInDir(
       logger,
+      schedulersWiringMetaJsonFile,
+      JSON.stringify(serializeSchedulerMeta(scheduledTasks.meta), null, 2)
+    )
+
+    const jsonImportPath = getFileImportRelativePath(
       schedulersWiringMetaFile,
-      serializeSchedulerMeta(scheduledTasks.meta)
+      schedulersWiringMetaJsonFile,
+      packageMappings
     )
+
+    await writeFileInDir(
+      logger,
+      schedulersWiringMetaFile,
+      serializeSchedulerMetaTS(
+        scheduledTasks.meta,
+        jsonImportPath,
+        schema?.supportsImportAttributes ?? false
+      )
+    )
+
     await writeFileInDir(
       logger,
       schedulersWiringFile,

package/src/functions/wirings/scheduler/serialize-scheduler-meta.ts

@@ -3,11 +3,30 @@ import { ScheduledTasksMeta } from '@pikku/core/scheduler'
 export const serializeSchedulerMeta = (
   scheduledTasksMeta: ScheduledTasksMeta
 ) => {
+  return scheduledTasksMeta
+}
+
+export const serializeSchedulerMetaTS = (
+  scheduledTasksMeta: ScheduledTasksMeta,
+  jsonImportPath: string,
+  supportsImportAttributes
+) => {
+  const importStatement = supportsImportAttributes
+    ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+    : `import metaData from '${jsonImportPath}'`
+
   const serializedOutput: string[] = []
   serializedOutput.push("import { pikkuState } from '@pikku/core'")
   serializedOutput.push(
-    `pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`
+    "import { ScheduledTasksMeta } from '@pikku/core/scheduler'"
   )
+  serializedOutput.push(importStatement)
+  serializedOutput.push('')
+  serializedOutput.push(
+    "pikkuState('scheduler', 'meta', metaData as ScheduledTasksMeta)"
+  )
+  serializedOutput.push('')
+
   const scheduledTasksMetaValues = Object.values(scheduledTasksMeta)
   if (scheduledTasksMetaValues.length > 0) {
     serializedOutput.push(

package/src/functions/wirings/scheduler/serialize-scheduler-types.ts

@@ -13,7 +13,7 @@ import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImport
  * Type definition for scheduled tasks that run at specified intervals.
  * These are sessionless functions that execute based on cron expressions.
  */
-type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void>, PikkuMiddleware>
+type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void, 'session' | 'rpc'>, PikkuMiddleware>
 
 /**
  * Registers a scheduled task with the Pikku framework.

package/src/functions/wirings/services/pikku-command-service-metadata.ts

@@ -0,0 +1,25 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { writeAllServiceMetadata } from '@pikku/inspector'
+
+export const pikkuServiceMetadata: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const state = await getInspectorState()
+
+    // Only write service metadata if there are services to document
+    if (state.serviceMetadata && state.serviceMetadata.length > 0) {
+      writeAllServiceMetadata(state.serviceMetadata, config.outDir)
+      logger.debug(
+        `• Wrote ${state.serviceMetadata.length} service metadata files`
+      )
+    } else {
+      logger.debug('• No service metadata to write')
+    }
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating service metadata',
+      commandEnd: 'Generated service metadata',
+    }),
+  ],
+})

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

@@ -13,10 +13,17 @@ export const pikkuWorkflowTypes: any = pikkuSessionlessFunc<void, void>({
       packageMappings
     )
 
+    // Get RPC map import path
+    const rpcMapImportPath = getFileImportRelativePath(
+      workflowTypesFile,
+      config.rpcInternalMapDeclarationFile,
+      packageMappings
+    )
+
     await writeFileInDir(
       logger,
       workflowTypesFile,
-      serializeWorkflowTypes(functionTypesImportPath)
+      serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath)
     )
   },
 })

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

@@ -1,12 +1,15 @@
 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 {
+  serializeWorkflowMeta,
+  serializeWorkflowMetaTS,
+} 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 { serializeWorkflowWirings } from './serialize-workflow-wirings.js'
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 import { join } from 'path'
 
@@ -19,11 +22,13 @@ export const pikkuWorkflow: any = pikkuSessionlessFunc<
     const {
       workflowsWiringFile,
       workflowsWiringMetaFile,
+      workflowsWiringMetaJsonFile,
       workflowMapDeclarationFile,
       workflowTypesFile,
       functionTypesFile,
       typesDeclarationFile,
       packageMappings,
+      schema,
     } = config
     const { workflows, functions: functionState } = visitState
     const { typesMap } = functionState
@@ -46,19 +51,34 @@ export const pikkuWorkflow: any = pikkuSessionlessFunc<
       }
     }
 
-    // Write workflow metadata
+    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,
-      serializeWorkflowMeta(workflows.meta)
+      serializeWorkflowMetaTS(
+        workflows.meta,
+        jsonImportPath,
+        schema?.supportsImportAttributes ?? false
+      )
     )
 
-    // Write workflow wirings (imports)
+    // Write workflow wirings (imports and addWorkflow calls)
     await writeFileInDir(
       logger,
       workflowsWiringFile,
-      serializeFileImports(
-        'wireWorkflow',
+      serializeWorkflowWirings(
         workflowsWiringFile,
         workflows.files,
         packageMappings
@@ -71,10 +91,18 @@ export const pikkuWorkflow: any = pikkuSessionlessFunc<
       functionTypesFile,
       packageMappings
     )
+
+    // Get RPC map import path
+    const rpcMapImportPath = getFileImportRelativePath(
+      workflowTypesFile,
+      config.rpcInternalMapDeclarationFile,
+      packageMappings
+    )
+
     await writeFileInDir(
       logger,
       workflowTypesFile,
-      serializeWorkflowTypes(functionTypesImportPath)
+      serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath)
     )
 
     // Write workflow map (type-safe client API)

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

@@ -1,11 +1,28 @@
 import { WorkflowsMeta } from '@pikku/core/workflow'
 
 export const serializeWorkflowMeta = (workflowsMeta: WorkflowsMeta) => {
+  return workflowsMeta
+}
+
+export const serializeWorkflowMetaTS = (
+  workflowsMeta: WorkflowsMeta,
+  jsonImportPath: string,
+  supportsImportAttributes: boolean
+) => {
+  const importStatement = supportsImportAttributes
+    ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+    : `import metaData from '${jsonImportPath}'`
+
   const serializedOutput: string[] = []
   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', ${JSON.stringify(workflowsMeta, null, 2)})`
+    "pikkuState('workflows', 'meta', metaData as WorkflowsMeta)"
   )
+  serializedOutput.push('')
+
   const workflowsMetaValues = Object.values(workflowsMeta)
   if (workflowsMetaValues.length > 0) {
     serializedOutput.push(

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

@@ -1,30 +1,23 @@
 /**
  * Generates type definitions for workflow wirings
  */
-export const serializeWorkflowTypes = (functionTypesImportPath: string) => {
+export const serializeWorkflowTypes = (
+  functionTypesImportPath: string,
+  rpcMapImportPath: string
+) => {
   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>
->
+import { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow'
+import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '${functionTypesImportPath}'
+import type { RPCMap } from '${rpcMapImportPath}'
 
 /**
- * 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 {
+export interface TypedWorkflow extends PikkuWorkflowWire {
   /**
    * Execute a workflow step with RPC invocation (typed based on available RPCs)
    * @template K - RPC name from the RPC map
@@ -49,25 +42,23 @@ export interface TypedWorkflow extends PikkuWorkflowInteraction {
 
 /**
  * Workflow function type with typed workflow service
- * Includes the workflow interaction object with typed RPC methods
+ * Includes the workflow wire object with typed RPC methods
  */
 export type PikkuFunctionWorkflow<
   In = unknown,
   Out = never
-> = CorePikkuFunctionSessionless<
+> = PikkuFunctionSessionless<
   In,
   Out,
-  null,
-  SingletonServices & {
-    rpc: TypedPikkuRPC
-    workflow: TypedWorkflow
-  },
-  UserSession
+  'workflow'
 >
 
 /**
  * Creates a workflow function with typed input and output.
- * Workflow functions have access to the workflow interaction object for step execution.
+ * Workflow functions have access to the workflow wire object for step execution.
+ *
+ * This is the permissive mode - workflows that don't conform to simple DSL will fall back
+ * to basic extraction with a warning.
  *
  * @template In - Input type for the workflow
  * @template Out - Output type for the workflow
@@ -77,19 +68,36 @@ export type PikkuFunctionWorkflow<
 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
 }
 
 /**
- * Registers a workflow with the Pikku framework.
- * Workflows can run in 'inline' (synchronous) or 'remote' (queue-based) execution modes.
+ * Creates a simple workflow function with typed input and output.
+ * Simple workflows must conform to the restricted DSL for static analysis.
+ *
+ * This is the strict mode - workflows that don't conform to simple DSL will cause
+ * a critical error during inspection.
  *
- * @param workflow - Workflow definition with name, execution mode, and handler function
+ * Constraints:
+ * - Must use only workflow.do() with RPC form (no inline functions)
+ * - Only if/else, for..of, and Promise.all(array.map()) control flow allowed
+ * - Step names must be unique (except across mutually exclusive branches)
+ * - All workflow calls must be awaited
+ *
+ * @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 wireWorkflow = (workflow: WorkflowWiring) => {
-  wireWorkflowCore(workflow as any)
+export const pikkuSimpleWorkflowFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionWorkflow<In, Out>
+    | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
+) => {
+  return typeof func === 'function' ? { func } : func
 }
+
 `
 }

package/src/functions/wirings/workflow/serialize-workflow-wirings.ts

@@ -0,0 +1,47 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+
+/**
+ * Generate workflow registration wirings
+ * Imports all workflow functions and calls addWorkflow for each
+ */
+export const serializeWorkflowWirings = (
+  outputPath: string,
+  workflowFiles: Map<string, { path: string; exportedName: string }>,
+  packageMappings: Record<string, string> = {}
+) => {
+  const imports: string[] = []
+  const registrations: string[] = []
+
+  // Sort by pikkuFuncName for consistent output
+  const sortedWorkflows = Array.from(workflowFiles.entries()).sort((a, b) =>
+    a[0].localeCompare(b[0])
+  )
+
+  // Generate imports
+  for (const [, { path, exportedName }] of sortedWorkflows) {
+    const importPath = getFileImportRelativePath(
+      outputPath,
+      path,
+      packageMappings
+    )
+    imports.push(`import { ${exportedName} } from '${importPath}'`)
+  }
+
+  // Generate addWorkflow calls
+  for (const [pikkuFuncName, { exportedName }] of sortedWorkflows) {
+    registrations.push(`addWorkflow('${pikkuFuncName}', ${exportedName})`)
+  }
+
+  // Only import addWorkflow if there are workflows to register
+  const addWorkflowImport =
+    sortedWorkflows.length > 0
+      ? `import { addWorkflow } from '@pikku/core/workflow'\n\n`
+      : ''
+
+  return `/**
+ * Auto-generated workflow registrations
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+${addWorkflowImport}${imports.join('\n')}${imports.length > 0 ? '\n\n' : ''}${registrations.join('\n')}
+`
+}