@pikku/cli 0.11.0 → 0.11.2

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

@@ -1,25 +1,23 @@
 /**
  * Generates core function, middleware, and permission type definitions
  */
-export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, sessionServicesTypeName, rpcMapTypeImport, requiredServicesTypeImport, configTypeImport) => {
+export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, wireServicesTypeImport, wireServicesTypeName, rpcMapTypeImport, requiredServicesTypeImport, configTypeImport) => {
     return `/**
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired } from '@pikku/core'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
-import { PikkuChannel } from '@pikku/core/channel'
-import { PikkuMCP } from '@pikku/core/mcp'
 
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
-${sessionServicesTypeImport}
+${wireServicesTypeImport}
 ${configTypeImport}
 ${rpcMapTypeImport}
 ${requiredServicesTypeImport}
 
 ${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
-${sessionServicesTypeName !== 'Services' ? `type Services = ${sessionServicesTypeName}` : ''}
+${wireServicesTypeName !== 'Services' ? `type Services = ${wireServicesTypeName}` : ''}
 ${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
 ${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
 
@@ -30,7 +28,7 @@ ${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
  * @template In - The input type that the permission check will receive
  * @template RequiredServices - The services required for this permission check
  */
-export type PikkuPermission<In = unknown, RequiredServices extends Services = Services> = CorePikkuPermission<In, RequiredServices, Session>
+export type PikkuPermission<In = unknown, RequiredServices extends Services = Services> = CorePikkuPermission<In, RequiredServices, PikkuWire<In, never, false, Session>>
 
 /**
  * Type-safe middleware definition that can access your application's services and session.
@@ -38,7 +36,7 @@ export type PikkuPermission<In = unknown, RequiredServices extends Services = Se
  *
  * @template RequiredServices - The services required for this middleware
  */
-export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices, Session>
+export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices>
 
 /**
  * Configuration object for creating a permission with metadata
@@ -59,7 +57,8 @@ export type PikkuPermissionConfig<In = unknown, RequiredServices extends Service
  * @example
  * \`\`\`typescript
  * // Direct function syntax
- * const permission = pikkuPermission(({ logger }, data, session) => {
+ * const permission = pikkuPermission(async ({ logger }, data, { session }) => {
+ *   const session = await session?.get()
  *   return session?.role === 'admin'
  * })
  *
@@ -67,7 +66,8 @@ export type PikkuPermissionConfig<In = unknown, RequiredServices extends Service
  * const adminPermission = pikkuPermission({
  *   name: 'Admin Permission',
  *   description: 'Checks if user has admin role',
- *   func: async ({ logger }, data, session) => {
+ *   func: async ({ logger }, data, { session }) => {
+ *     const session = await session?.get()
  *     return session?.role === 'admin'
  *   }
  * })
@@ -98,7 +98,7 @@ export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = S
  * @example
  * \`\`\`typescript
  * // Direct function syntax
- * const middleware = pikkuMiddleware(({ logger }, interactions, next) => {
+ * const middleware = pikkuMiddleware(({ logger }, wires, next) => {
  *   logger.info('Middleware executed')
  *   await next()
  * })
@@ -107,7 +107,7 @@ export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = S
  * const logMiddleware = pikkuMiddleware({
  *   name: 'Request Logger',
  *   description: 'Logs all incoming requests',
- *   func: async ({ logger }, interactions, next) => {
+ *   func: async ({ logger }, wires, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -130,7 +130,7 @@ export const pikkuMiddleware = <RequiredServices extends SingletonServices = Sin
  *   message,
  *   level = 'info'
  * }) => {
- *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *   return pikkuMiddleware(async ({ logger }, next) => {
  *     logger[level](message)
  *     await next()
  *   })
@@ -152,8 +152,8 @@ export const pikkuMiddlewareFactory = <In = any>(
  * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
  *   role
  * }) => {
- *   return pikkuPermission(async ({ logger }, data, session) => {
- *     if (!session || session.role !== role) {
+ *   return pikkuPermission(async ({ logger }, data, { initialSession }) => {
+ *     if (!initialSession || initialSession.role !== role) {
  *       logger.warn(\`Permission denied: required role '\${role}'\`)
  *       return false
  *     }
@@ -174,25 +174,19 @@ export const pikkuPermissionFactory = <In = any>(
  *
  * @template In - The input type
  * @template Out - The output type that the function returns
- * @template ChannelData - Channel data type (null = optional channel)
- * @template MCPData - MCP data type (null = optional MCP)
  * @template RequiredServices - Services required by this function
  */
 export type PikkuFunctionSessionless<
   In = unknown,
   Out = never,
-  ChannelData = null,  // null means optional channel
-  MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> &
-    { rpc: TypedPikkuRPC } & (
-    [ChannelData] extends [null]
-      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
-      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
-  ) & ([MCPData] extends [null]
-    ? { mcp?: PikkuMCP }  // Optional MCP
-    : { mcp: PikkuMCP }  // Required MCP
-  )
-> = CorePikkuFunctionSessionless<In, Out, ChannelData, RequiredServices, Session>
+  RequiredWires extends keyof PikkuWire = never,
+  RequiredServices extends Services = Services
+> = CorePikkuFunctionSessionless<
+    In,
+    Out,
+    RequiredServices,
+    PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any>, RequiredWires>
+  >
 
 /**
  * A session-aware API function that requires user authentication.
@@ -200,25 +194,19 @@ export type PikkuFunctionSessionless<
  *
  * @template In - The input type
  * @template Out - The output type that the function returns
- * @template ChannelData - Channel data type (null = optional channel)
- * @template MCPData - MCP data type (null = optional MCP)
  * @template RequiredServices - Services required by this function
  */
 export type PikkuFunction<
   In = unknown,
   Out = never,
-  ChannelData = null,  // null means optional channel
-  MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> &
-    { rpc: TypedPikkuRPC } & (
-    [ChannelData] extends [null]
-      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
-      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
-  ) & ([MCPData] extends [null]
-    ? { mcp?: PikkuMCP }  // Optional MCP
-    : { mcp: PikkuMCP }  // Required MCP
-  )
-> = CorePikkuFunction<In, Out, ChannelData, RequiredServices, Session>
+  RequiredWires extends keyof PikkuWire = 'session',
+  RequiredServices extends Services = Services
+> = CorePikkuFunction<
+    In,
+    Out,
+    RequiredServices,
+    PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any>, RequiredWires>
+  >
 
 /**
  * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
@@ -226,16 +214,13 @@ export type PikkuFunction<
  *
  * @template In - The input type
  * @template Out - The output type
- * @template ChannelData - Channel data type
- * @template MCPData - MCP data type
  * @template PikkuFunc - The function type (can be narrowed to PikkuFunction or PikkuFunctionSessionless)
  */
 export type PikkuFunctionConfig<
   In = unknown,
   Out = unknown,
-  ChannelData = unknown,
-  MCPData = unknown,
-  PikkuFunc extends PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData> = PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData>
+  RequiredWires extends keyof PikkuWire = never,
+  PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>
 > = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>
 
 /**
@@ -250,7 +235,8 @@ export type PikkuFunctionConfig<
  * @example
  * \\\`\\\`\\\`typescript
  * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
- *   func: async ({db, logger}, input) => {
+ *   func: async ({db, logger}, input, wire) => {
+ *     const session = await wire.session.get()
  *     logger.info('Creating user', input.name)
  *     const user = await db.users.create(input)
  *     return {id: user.id, message: \\\`User \\\${input.name} created successfully\\\`}
@@ -261,8 +247,8 @@ export type PikkuFunctionConfig<
  */
 export const pikkuFunc = <In, Out = unknown>(
   func:
-    | PikkuFunction<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+    | PikkuFunction<In, Out, 'session' | 'rpc'>
+    | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -279,7 +265,7 @@ export const pikkuFunc = <In, Out = unknown>(
  * @example
  * \\\`\\\`\\\`typescript
  * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
- *   func: async ({logger}) => {
+ *   func: async ({logger}, input) => {
  *     logger.info('Health check requested')
  *     return {status: 'healthy', timestamp: new Date().toISOString()}
  *   },
@@ -289,8 +275,8 @@ export const pikkuFunc = <In, Out = unknown>(
  */
 export const pikkuSessionlessFunc = <In, Out = unknown>(
   func:
-    | PikkuFunctionSessionless<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+    | PikkuFunctionSessionless<In, Out, 'session' | 'rpc'>
+    | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -313,8 +299,8 @@ export const pikkuSessionlessFunc = <In, Out = unknown>(
  */
 export const pikkuVoidFunc = (
   func:
-    | PikkuFunctionSessionless<void, void>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>
+    | PikkuFunctionSessionless<void, void, 'session' | 'rpc'>
+    | PikkuFunctionConfig<void, void, 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -363,27 +349,27 @@ export const pikkuServices = (
 ) => func
 
 /**
- * Creates a Pikku session services factory.
+ * Creates a Pikku wire services factory.
  * Use this to define services that are created per-request/session.
  *
- * @param func - Session services factory function
- * @returns The session services factory function
+ * @param func - Wire services factory function
+ * @returns The wire services factory function
  *
  * @example
  * \`\`\`typescript
- * export const createSessionServices = pikkuSessionServices(async (services, interaction, session) => {
+ * export const createWireServices = pikkuWireServices(async (services, wire) => {
+ *   const session = await wire.session?.get()
  *   return {
  *     userCache: new UserCache(session?.userId)
  *   }
  * })
  * \`\`\`
  */
-export const pikkuSessionServices = (
+export const pikkuWireServices = (
   func: (
     services: SingletonServices,
-    interaction: any,
-    session: Session | undefined
-  ) => Promise<RequiredSessionServices>
+    wire: any
+  ) => Promise<RequiredWireServices>
 ) => func
 
 /**

package/dist/src/functions/wirings/http/openapi-spec-generator.js

@@ -38,7 +38,7 @@ export async function generateOpenAPISpec(logger, functionsMeta, httpMeta, schem
     const paths = {};
     for (const routeMeta of Object.values(httpMeta)) {
         for (const meta of Object.values(routeMeta)) {
-            const { route, method, inputTypes, pikkuFuncName, params, query, docs } = meta;
+            const { route, method, inputTypes, pikkuFuncName, params, query, errors, description, tags, } = meta;
             const functionMeta = functionsMeta[pikkuFuncName];
             if (!functionMeta) {
                 logger.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
@@ -50,7 +50,7 @@ export async function generateOpenAPISpec(logger, functionsMeta, httpMeta, schem
                 paths[path] = {};
             }
             const responses = {};
-            docs?.errors?.forEach((error) => {
+            errors?.forEach((error) => {
                 const errorResponse = getErrorResponseForConstructorName(error);
                 if (errorResponse) {
                     responses[errorResponse.status] = {
@@ -59,9 +59,9 @@ export async function generateOpenAPISpec(logger, functionsMeta, httpMeta, schem
                 }
             });
             const operation = {
-                description: docs?.description ||
+                description: description ||
                     `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
-                tags: docs?.tags || [route.split('/')[1] || 'default'],
+                tags: tags || [route.split('/')[1] || 'default'],
                 parameters: [],
                 responses: {
                     ...responses,

package/dist/src/functions/wirings/http/pikku-http-routes.js

@@ -2,13 +2,20 @@ 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 { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuHTTP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config;
+        const { httpWiringsFile, httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings, schema, } = config;
         const { http } = visitState;
         await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+        await writeFileInDir(logger, httpWiringMetaJsonFile, JSON.stringify(http.meta, null, 2));
+        const jsonImportPath = getFileImportRelativePath(httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState, HTTPWiringsMeta } from '@pikku/core'\n${importStatement}\npikkuState('http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [

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

@@ -18,7 +18,7 @@ import type { CoreHTTPFunctionWiring } from '@pikku/core/http'
  * @template Out - Output type for the HTTP wiring
  * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
  */
-type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out>, PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out, 'rpc' | 'session'>, PikkuFunctionSessionless<In, Out, 'rpc' | 'session'>, PikkuPermission<In>, PikkuMiddleware>
 
 /**
  * Registers an HTTP wiring with the Pikku framework.

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');
 };