@pikku/cli 0.11.1 → 0.11.2

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

@@ -4,6 +4,7 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { readFile } from 'fs/promises';
 import { join } from 'path';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 // Helper function to generate arguments from schema
 const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMap, logger) => {
     if (!inputSchema)
@@ -40,7 +41,7 @@ const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMa
 export const pikkuMCP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { mcpEndpoints, functions } = await getInspectorState();
-        const { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory, } = config;
+        const { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory, schema, } = config;
         await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource or wireMCPTool', mcpWiringsFile, mcpEndpoints.files, packageMappings));
         // Populate arguments for prompts meta before serializing
         const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta };
@@ -51,10 +52,23 @@ export const pikkuMCP = pikkuSessionlessFunc({
                 promptMeta.arguments = await generateArgumentsFromSchema(inputType || null, schemaDirectory || '', functions.typesMap, logger);
             }
         }
+        const metaData = {
+            resourcesMeta: mcpEndpoints.resourcesMeta,
+            toolsMeta: mcpEndpoints.toolsMeta,
+            promptsMeta: promptsMetaWithArguments,
+        };
+        await writeFileInDir(logger, config.mcpWiringsMetaJsonFile, JSON.stringify(metaData, null, 2));
+        const jsonImportPath = getFileImportRelativePath(mcpWiringsMetaFile, config.mcpWiringsMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
         await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core'
-pikkuState('mcp', 'resourcesMeta', ${JSON.stringify(mcpEndpoints.resourcesMeta, null, 2)})
-pikkuState('mcp', 'toolsMeta', ${JSON.stringify(mcpEndpoints.toolsMeta, null, 2)})
-pikkuState('mcp', 'promptsMeta', ${JSON.stringify(promptsMetaWithArguments, null, 2)})`);
+import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
+${importStatement}
+pikkuState('mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)
+pikkuState('mcp', 'toolsMeta', metaData.toolsMeta as MCPToolMeta)
+pikkuState('mcp', 'promptsMeta', metaData.promptsMeta as MCPPromptMeta)`);
         return true;
     },
     middleware: [

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

@@ -27,21 +27,21 @@ import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTy
  * @template In - Input type for the resource request
  * @template URI - URI template string type for compile-time parameter validation
  */
-type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse>> & { uri: URI }
+type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse, 'rpc' | 'session' | 'mcp'>> & { uri: URI }
 
 /**
  * Type definition for MCP tools that AI models can invoke.
  *
  * @template In - Input type for the tool invocation
  */
-type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse>>
+type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse, 'rpc' | 'session' | 'mcp'>>
 
 /**
  * Type definition for MCP prompts that provide templates to AI models.
  *
  * @template In - Input type for the prompt parameters
  */
-type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse>>
+type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse, 'rpc' | 'session' | 'mcp'>>
 
 /**
  * Registers an MCP resource with the Pikku framework.
@@ -93,12 +93,12 @@ export const wireMCPPrompt = <In>(
  */
 export const pikkuMCPPromptFunc = <In>(
   func:
-    | PikkuFunctionSessionless<In, MCPPromptResponse>
+    | PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp'>
     | {
-        func: PikkuFunctionSessionless<In, MCPPromptResponse>
+        func: PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp'>
         name?: string
       }
-): PikkuFunctionConfig<In, MCPPromptResponse> => {
+): PikkuFunctionConfig<In, MCPPromptResponse, 'mcp'> => {
   return typeof func === 'function' ? { func } : func
 }
 
@@ -112,12 +112,12 @@ export const pikkuMCPPromptFunc = <In>(
  */
 export const pikkuMCPToolFunc = <In>(
   func:
-    | PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+    | PikkuFunctionSessionless<In, MCPToolResponse, 'mcp'>
     | {
-      func: PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+      func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp'>
       name?: string
     }
-): PikkuFunctionConfig<In, MCPToolResponse> => {
+): PikkuFunctionConfig<In, MCPToolResponse, 'mcp'> => {
   return typeof func === 'function' ? { func } : func
 }
 
@@ -131,12 +131,12 @@ export const pikkuMCPToolFunc = <In>(
  */
 export const pikkuMCPResourceFunc = <In>(
   func:
-    | PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+    | PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp'>
     | {
-      func: PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+      func: PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp'>
       name?: string
     }
-): PikkuFunctionConfig<In, MCPResourceResponse> => {
+): PikkuFunctionConfig<In, MCPResourceResponse, 'mcp'> => {
   return typeof func === 'function' ? { func } : func
 }
 `;

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

@@ -3,17 +3,41 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeMiddlewareImports } from './serialize-middleware-imports.js';
 import { serializeMiddlewareGroupsMeta } from './serialize-middleware-groups-meta.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuMiddleware = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
         const { middleware } = state;
-        const { middlewareFile, packageMappings } = config;
+        const { middlewareFile, packageMappings, schema } = config;
         let filesGenerated = false;
         // Check if there are any middleware groups
         const hasHTTPGroups = state.http.routeMiddleware.size > 0;
         const hasTagGroups = state.middleware.tagMiddleware.size > 0;
         if (hasHTTPGroups || hasTagGroups) {
-            await writeFileInDir(logger, config.middlewareGroupsMetaFile, serializeMiddlewareGroupsMeta(state));
+            const metaData = serializeMiddlewareGroupsMeta(state);
+            // Write JSON file
+            await writeFileInDir(logger, config.middlewareGroupsMetaJsonFile, JSON.stringify(metaData, null, 2));
+            // Calculate relative path from TS file to JSON file
+            const jsonImportPath = getFileImportRelativePath(config.middlewareGroupsMetaFile, config.middlewareGroupsMetaJsonFile, packageMappings);
+            // Write TypeScript file that imports JSON
+            const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+            const importStatement = supportsImportAttributes
+                ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+                : `import metaData from '${jsonImportPath}'`;
+            const tsContent = `import { pikkuState } from '@pikku/core'
+${importStatement}
+
+// HTTP middleware groups metadata
+if (metaData.httpGroups && Object.keys(metaData.httpGroups).length > 0) {
+  pikkuState('middleware', 'httpGroupMeta', metaData.httpGroups)
+}
+
+// Tag middleware groups metadata
+if (metaData.tagGroups && Object.keys(metaData.tagGroups).length > 0) {
+  pikkuState('middleware', 'tagGroupMeta', metaData.tagGroups)
+}
+`;
+            await writeFileInDir(logger, config.middlewareGroupsMetaFile, tsContent);
             // Always generate middleware imports file when groups exist (even if empty)
             await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings));
             filesGenerated = true;

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

@@ -1,8 +1,11 @@
 import type { InspectorState } from '@pikku/inspector';
 /**
- * Generates the middleware groups metadata file that stores metadata about
+ * Generates the middleware groups metadata that stores metadata about
  * tag-based and HTTP middleware groups for visualization and inspection.
  *
  * This includes services, middleware count, factory status, etc.
  */
-export declare const serializeMiddlewareGroupsMeta: (state: InspectorState) => string;
+export declare const serializeMiddlewareGroupsMeta: (state: InspectorState) => {
+    httpGroups: Record<string, any>;
+    tagGroups: Record<string, any>;
+};

package/dist/src/functions/wirings/middleware/serialize-middleware-groups-meta.js

@@ -1,11 +1,10 @@
 /**
- * Generates the middleware groups metadata file that stores metadata about
+ * Generates the middleware groups metadata that stores metadata about
  * tag-based and HTTP middleware groups for visualization and inspection.
  *
  * This includes services, middleware count, factory status, etc.
  */
 export const serializeMiddlewareGroupsMeta = (state) => {
-    const lines = [`import { pikkuState } from '@pikku/core'`, ``];
     // Serialize HTTP middleware groups metadata
     const httpGroups = {};
     for (const [pattern, meta] of state.http.routeMiddleware.entries()) {
@@ -18,11 +17,6 @@ export const serializeMiddlewareGroupsMeta = (state) => {
             isFactory: meta.isFactory,
         };
     }
-    if (Object.keys(httpGroups).length > 0) {
-        lines.push(`// HTTP middleware groups metadata`);
-        lines.push(`pikkuState('middleware', 'httpGroupMeta', ${JSON.stringify(httpGroups, null, 2)})`);
-        lines.push(``);
-    }
     // Serialize tag middleware groups metadata
     const tagGroups = {};
     for (const [tag, meta] of state.middleware.tagMiddleware.entries()) {
@@ -35,10 +29,8 @@ export const serializeMiddlewareGroupsMeta = (state) => {
             isFactory: meta.isFactory,
         };
     }
-    if (Object.keys(tagGroups).length > 0) {
-        lines.push(`// Tag middleware groups metadata`);
-        lines.push(`pikkuState('middleware', 'tagGroupMeta', ${JSON.stringify(tagGroups, null, 2)})`);
-        lines.push(``);
-    }
-    return lines.join('\n');
+    return {
+        httpGroups,
+        tagGroups,
+    };
 };

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

@@ -2,13 +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;
-        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
+        // 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/pikku-queue.js

@@ -2,11 +2,12 @@ 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 };
@@ -16,7 +17,12 @@ export const pikkuQueue = pikkuSessionlessFunc({
                 queueName: 'pikku-remote-internal-rpc',
             };
         }
-        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueMeta));
+        // 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, 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-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('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.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('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

@@ -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/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, data }) as any
     }
 }
 

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

@@ -2,13 +2,16 @@ 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 = 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));
+        await writeFileInDir(logger, schedulersWiringMetaJsonFile, JSON.stringify(serializeSchedulerMeta(scheduledTasks.meta), 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('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-types.js

@@ -6,6 +6,8 @@ export const pikkuWorkflowTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         const { workflowTypesFile, functionTypesFile, packageMappings } = config;
         const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
-        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath));
+        // Get RPC map import path
+        const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath));
     },
 });

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

@@ -1,18 +1,18 @@
 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';
 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, workflowsWiringMetaJsonFile, 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
@@ -24,13 +24,17 @@ 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));
+        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
         const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
-        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath));
+        // 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)
         await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta));
         if (config.workflows) {

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

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

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

@@ -1,7 +1,17 @@
 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(`pikkuState('workflows', 'meta', ${JSON.stringify(workflowsMeta, null, 2)})`);
+    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("' | '")}'`);

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

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