@pikku/cli 0.11.1 → 0.11.3

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

@@ -2,13 +2,27 @@ 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';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuQueue = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { queueWorkersWiringFile, queueWorkersWiringMetaFile, packageMappings, } = config;
+        const { queueWorkersWiringFile, queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { queueWorkers } = visitState;
-        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
+        const fullMeta = serializeQueueMeta(queueWorkers.meta);
+        // Write minimal JSON file (runtime-only fields)
+        const minimalMeta = stripVerboseFields(fullMeta);
+        await writeFileInDir(logger, queueWorkersWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(fullMeta)) {
+            const verbosePath = queueWorkersWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
+        }
+        // Calculate relative path from TS file to JSON file
+        const jsonImportPath = getFileImportRelativePath(queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings);
+        // Write TypeScript file that imports JSON
+        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMetaTS(jsonImportPath, schema?.supportsImportAttributes ?? false));
         await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
         return true;
     },

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

@@ -2,21 +2,19 @@ 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 = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { queueWorkersWiringFile, queueWorkersWiringMetaFile, packageMappings, } = config;
+        const { queueWorkersWiringFile, queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { queueWorkers } = visitState;
-        // 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));
+        // 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, queueWorkersWiringMetaJsonFile, packageMappings);
+        // Write TypeScript file that imports JSON
+        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMetaTS(jsonImportPath, schema?.supportsImportAttributes ?? false));
         await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
         return true;
     },

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

@@ -8,7 +8,7 @@ export const serializeQueueMap = (relativeToPath, packageMappings, typesMap, fun
     return `/**
  * This provides the structure needed for typescript to be aware of Queue workers and their input/output types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 
@@ -57,8 +57,25 @@ function generateQueues(queueWorkersMeta, 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 QueueHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
+        // 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 = input;
+            }
+        }
+        let outputType = 'null';
+        if (output) {
+            try {
+                outputType = typesMap.getTypeMeta(output).uniqueName;
+            }
+            catch {
+                outputType = output;
+            }
+        }
         requiredTypes.add(inputType);
         requiredTypes.add(outputType);
         // Add Queue entry

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

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

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

@@ -1,6 +1,15 @@
 export const serializeQueueMeta = (queueWorkersMeta) => {
+    return queueWorkersMeta;
+};
+export const serializeQueueMetaTS = (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(`pikkuState('queue', 'meta', ${JSON.stringify(queueWorkersMeta, null, 2)})`);
+    serializedOutput.push("import { QueueWorkersMeta } from '@pikku/core/queue'");
+    serializedOutput.push(importStatement);
+    serializedOutput.push('');
+    serializedOutput.push("pikkuState(null, 'queue', 'meta', metaData as QueueWorkersMeta)");
     return serializedOutput.join('\n');
 };

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

@@ -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/dist/src/functions/wirings/rpc/pikku-command-rpc-map.js

@@ -5,8 +5,8 @@ import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';
 export const pikkuRPCInternalMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc } = await getInspectorState();
-        const { rpcInternalMapDeclarationFile, packageMappings } = config;
-        const content = serializeTypedRPCMap(rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.internalMeta);
+        const { rpcInternalMapDeclarationFile, packageMappings, externalPackages } = config;
+        const content = serializeTypedRPCMap(rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.internalMeta, externalPackages);
         await writeFileInDir(logger, rpcInternalMapDeclarationFile, content);
     },
     middleware: [
@@ -19,8 +19,8 @@ export const pikkuRPCInternalMap = pikkuSessionlessFunc({
 export const pikkuRPCExposedMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc } = await getInspectorState();
-        const { rpcMapDeclarationFile, packageMappings } = config;
-        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.exposedMeta);
+        const { rpcMapDeclarationFile, packageMappings, externalPackages } = config;
+        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.exposedMeta, externalPackages);
         await writeFileInDir(logger, rpcMapDeclarationFile, content);
     },
     middleware: [

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

@@ -1,12 +1,19 @@
 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 = pikkuSessionlessFunc({
     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, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`);
+            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'\n${importStatement}\npikkuState(null, 'rpc', 'meta', metaData as Record<string, string>)`);
             return true;
         }
         return false;

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

@@ -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/dist/src/functions/wirings/rpc/serialize-remote-rpc.js

@@ -11,12 +11,15 @@ 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)
+ *
+ * TODO: Security risk - this allows any RPC to be invoked by name. Should validate
+ * that rpcName is in an allowlist of permitted internal RPCs to prevent unauthorized access.
  */
 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/dist/src/functions/wirings/rpc/serialize-rpc-wrapper.js

@@ -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: String(rpcName), data }) as any
     }
 }
 

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

@@ -1,3 +1,3 @@
 import { TypesMap } from '@pikku/inspector';
 import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, string>) => string;
+export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, string>, externalPackages?: Record<string, string>) => string;

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

@@ -2,13 +2,25 @@ 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';
+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, packageMappings } = config;
+        const { schedulersWiringFile, schedulersWiringMetaFile, schedulersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { scheduledTasks } = visitState;
-        await writeFileInDir(logger, schedulersWiringMetaFile, serializeSchedulerMeta(scheduledTasks.meta));
+        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));
         return true;
     },

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

@@ -1,2 +1,3 @@
 import { ScheduledTasksMeta } from '@pikku/core/scheduler';
-export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => string;
+export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => ScheduledTasksMeta;
+export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: any) => string;

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

@@ -1,7 +1,17 @@
 export const serializeSchedulerMeta = (scheduledTasksMeta) => {
+    return scheduledTasksMeta;
+};
+export const serializeSchedulerMetaTS = (scheduledTasksMeta, 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(`pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`);
+    serializedOutput.push("import { ScheduledTasksMeta } from '@pikku/core/scheduler'");
+    serializedOutput.push(importStatement);
+    serializedOutput.push('');
+    serializedOutput.push("pikkuState(null, 'scheduler', 'meta', metaData as ScheduledTasksMeta)");
+    serializedOutput.push('');
     const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
     if (scheduledTasksMetaValues.length > 0) {
         serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);

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

@@ -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/dist/src/functions/wirings/services/pikku-command-service-metadata.d.ts

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

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

@@ -0,0 +1,22 @@
+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 = pikkuSessionlessFunc({
+    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/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 { serializeFileImports } from '../../../utils/file-imports-serializer.js';
+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 } 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 { 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, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, typesDeclarationFile, packageMappings, } = 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,15 +31,50 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
                 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
+        // 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);
-        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath));
-        // Write workflow map (type-safe client API)
+        const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath));
+        // 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);
@@ -44,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';