@pikku/cli 0.11.1 → 0.11.2

package/dist/src/functions/wirings/cli/serialize-channel-cli.js

@@ -50,7 +50,7 @@ import { pikkuMiddleware } from '${functionTypesPath}'
 ${imports}
 
 // Middleware to close the channel after CLI command completes
-const cliCloseOnComplete = pikkuMiddleware(async (services, { channel }, next) => {
+const cliCloseOnComplete = pikkuMiddleware(async (_services, { channel }, next) => {
   const closeChannel = () => {
     setTimeout(async () => {
       try {

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

@@ -50,7 +50,7 @@ export const pikkuCLIRender = <Data, RequiredServices extends SingletonServices
  * CLI command configuration with project-specific types.
  * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.
  */
-type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
+type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out, 'cli' | 'rpc' | 'session'>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
 
 /**
  * Type definition for CLI applications with commands and global options.
@@ -84,7 +84,7 @@ export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any
  * @returns CLI command configuration with inferred types
  */
 export const pikkuCLICommand = <
-  FuncConfig extends PikkuFunctionConfig<any, any>,
+  FuncConfig extends PikkuFunctionConfig<any, any, 'cli' | 'rpc' | 'session'>,
   Params extends string
 >(
   config: CLICommandConfig<FuncConfig, any, any, Params>

package/dist/src/functions/wirings/cli/serialize-local-cli-bootstrap.d.ts

@@ -8,7 +8,7 @@ export declare function serializeLocalCLIBootstrap(programName: string, _program
 }, singletonServicesFactory: {
     file: string;
     variable: string;
-}, sessionServicesFactory: {
+}, wireServicesFactory: {
     file: string;
     variable: string;
 }): string;

package/dist/src/functions/wirings/cli/serialize-local-cli-bootstrap.js

@@ -2,18 +2,18 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 /**
  * Serializes the local (in-program) CLI bootstrap code
  */
-export function serializeLocalCLIBootstrap(programName, _programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory) {
+export function serializeLocalCLIBootstrap(programName, _programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, wireServicesFactory) {
     const capitalizedName = programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '');
     // Get relative import paths
     const pikkuConfigPath = getFileImportRelativePath(bootstrapFile, pikkuConfigFactory.file, config.packageMappings);
     const singletonServicesPath = getFileImportRelativePath(bootstrapFile, singletonServicesFactory.file, config.packageMappings);
-    const sessionServicesPath = getFileImportRelativePath(bootstrapFile, sessionServicesFactory.file, config.packageMappings);
+    const wireServicesPath = getFileImportRelativePath(bootstrapFile, wireServicesFactory.file, config.packageMappings);
     const cliBootstrapPath = getFileImportRelativePath(bootstrapFile, config.bootstrapFile, config.packageMappings);
     return `
 import { executeCLI, CLIError } from '@pikku/core/cli'
 import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
 import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
-import { ${sessionServicesFactory.variable} as createSessionServices } from '${sessionServicesPath}'
+import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'
 import '${cliBootstrapPath}'
 
 /**
@@ -27,7 +27,7 @@ export async function ${capitalizedName}CLI(args: string[]): Promise<void> {
       args: args || process.argv.slice(2),
       createConfig,
       createSingletonServices,
-      createSessionServices,
+      createWireServices,
     })
   } catch (error) {
     if (error instanceof CLIError) {

package/dist/src/functions/wirings/functions/pikku-command-function-types-split.js

@@ -11,17 +11,17 @@ export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
         // Check for required types
         checkRequiredTypes(visitState.filesAndMethodsErrors, {
             userSessionType: true,
-            sessionServiceType: true,
+            wireServiceType: true,
             singletonServicesType: true,
         });
-        const { userSessionType, sessionServicesType, singletonServicesType, pikkuConfigType, } = visitState.filesAndMethods;
-        if (!userSessionType || !sessionServicesType || !singletonServicesType) {
+        const { userSessionType, wireServicesType, singletonServicesType, pikkuConfigType, } = visitState.filesAndMethods;
+        if (!userSessionType || !wireServicesType || !singletonServicesType) {
             throw new Error('Required types not found');
         }
         const configTypeImport = pikkuConfigType
             ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
             : '// Config type not found, will use fallback';
-        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredSessionServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport);
+        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport);
         await writeFileInDir(logger, functionTypesFile, content);
     },
     middleware: [

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

@@ -2,15 +2,25 @@ 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 { generateRuntimeMeta, serializeFunctionImports, } from './serialize-function-imports.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuFunctions = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc } = await getInspectorState();
-        const { functionsMetaFile, functionsMetaMinFile, functionsFile, packageMappings, } = config;
-        // Generate full metadata
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
-        // Generate minimal metadata (runtime)
+        const { functionsMetaFile, functionsMetaJsonFile, functionsMetaMinFile, functionsMetaMinJsonFile, functionsFile, packageMappings, schema, } = config;
+        await writeFileInDir(logger, functionsMetaJsonFile, JSON.stringify(functions.meta, null, 2));
+        const fullJsonImportPath = getFileImportRelativePath(functionsMetaFile, functionsMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const fullImportStatement = supportsImportAttributes
+            ? `import metaData from '${fullJsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${fullJsonImportPath}'`;
+        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState, FunctionsMeta } from '@pikku/core'\n${fullImportStatement}\npikkuState('function', 'meta', metaData as FunctionsMeta)`);
         const runtimeMeta = generateRuntimeMeta(functions.meta);
-        await writeFileInDir(logger, functionsMetaMinFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(runtimeMeta, null, 2)})`);
+        await writeFileInDir(logger, functionsMetaMinJsonFile, JSON.stringify(runtimeMeta, null, 2));
+        const minJsonImportPath = getFileImportRelativePath(functionsMetaMinFile, functionsMetaMinJsonFile, packageMappings);
+        const minImportStatement = supportsImportAttributes
+            ? `import metaData from '${minJsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${minJsonImportPath}'`;
+        await writeFileInDir(logger, functionsMetaMinFile, `import { pikkuState, FunctionsRuntimeMeta } from '@pikku/core'\n${minImportStatement}\npikkuState('function', 'meta', metaData as FunctionsRuntimeMeta)`);
         const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0;
         if (hasRPCs) {
             await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, rpc.internalFiles, functions.meta, packageMappings));

package/dist/src/functions/wirings/functions/pikku-command-services.d.ts

@@ -1,2 +1,2 @@
-export declare const serializeServicesMap: (allSingletonServices: string[], allSessionServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, sessionServicesImport: string) => string;
+export declare const serializeServicesMap: (allSingletonServices: string[], allWireServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, wireServicesImport: string) => string;
 export declare const pikkuServices: any;

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

@@ -3,7 +3,7 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-export const serializeServicesMap = (allSingletonServices, allSessionServices, requiredServices, forceRequiredServices = [], servicesImport, sessionServicesImport) => {
+export const serializeServicesMap = (allSingletonServices, allWireServices, requiredServices, forceRequiredServices = [], servicesImport, wireServicesImport) => {
     // Use pre-aggregated services from inspector state
     // This includes services from:
     // - Wired functions (HTTP, channels, queues, schedulers, MCP, CLI, RPC)
@@ -11,7 +11,7 @@ export const serializeServicesMap = (allSingletonServices, allSessionServices, r
     // - Permissions used by wired functions
     // - Session factories
     const usedServices = new Set(requiredServices);
-    // Internal services that are created internally by the framework (PikkuInteraction)
+    // Internal services that are created internally by the framework (PikkuWire)
     // These should not appear in the services maps
     const internalServices = new Set([
         'rpc',
@@ -37,24 +37,24 @@ export const serializeServicesMap = (allSingletonServices, allSessionServices, r
     allSingletonServices.forEach((service) => {
         singletonServicesMap[service] = usedServices.has(service);
     });
-    // Create session services map: all session services with true/false based on usage
-    // Exclude internal framework services (PikkuInteraction)
-    const sessionServicesMap = {};
-    allSessionServices.forEach((service) => {
+    // Create wire services map: all wire services with true/false based on usage
+    // Exclude internal framework services (PikkuWire)
+    const wireServicesMap = {};
+    allWireServices.forEach((service) => {
         if (!internalServices.has(service)) {
-            sessionServicesMap[service] = usedServices.has(service);
+            wireServicesMap[service] = usedServices.has(service);
         }
     });
     // Get all required service names (those marked as true)
     const requiredSingletonServiceNames = Object.keys(singletonServicesMap)
         .filter((key) => singletonServicesMap[key])
         .sort();
-    const requiredSessionServiceNames = Object.keys(sessionServicesMap)
-        .filter((key) => sessionServicesMap[key])
+    const requiredWireServiceNames = Object.keys(wireServicesMap)
+        .filter((key) => wireServicesMap[key])
         .sort();
     const code = [
         servicesImport,
-        sessionServicesImport,
+        wireServicesImport,
         '',
         '// Singleton services map: true if required, false if available but unused',
         'export const requiredSingletonServices = {',
@@ -63,11 +63,11 @@ export const serializeServicesMap = (allSingletonServices, allSessionServices, r
             .map((service) => `  '${service}': ${singletonServicesMap[service]},`),
         '} as const',
         '',
-        '// Session services map: true if required, false if available but unused',
-        'export const requiredSessionServices = {',
-        ...Object.keys(sessionServicesMap)
+        '// Wire services map: true if required, false if available but unused',
+        'export const requiredWireServices = {',
+        ...Object.keys(wireServicesMap)
             .sort()
-            .map((service) => `  '${service}': ${sessionServicesMap[service]},`),
+            .map((service) => `  '${service}': ${wireServicesMap[service]},`),
         '} as const',
         '',
         '// Type exports',
@@ -75,9 +75,9 @@ export const serializeServicesMap = (allSingletonServices, allSessionServices, r
             ? `export type RequiredSingletonServices = Pick<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
             : 'export type RequiredSingletonServices = Partial<SingletonServices>',
         '',
-        requiredSessionServiceNames.length > 0
-            ? `export type RequiredSessionServices = Pick<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
-            : 'export type RequiredSessionServices = Partial<Services>',
+        requiredWireServiceNames.length > 0
+            ? `export type RequiredWireServices = Pick<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
+            : 'export type RequiredWireServices = Partial<Services>',
         '',
     ].join('\n');
     return code;
@@ -87,16 +87,16 @@ export const pikkuServices = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         // Check for required types
         checkRequiredTypes(visitState.filesAndMethodsErrors, {
-            sessionServiceType: true,
+            wireServiceType: true,
             singletonServicesType: true,
         });
-        const { sessionServicesType, singletonServicesType } = visitState.filesAndMethods;
-        if (!sessionServicesType || !singletonServicesType) {
-            throw new Error('Required types not found: sessionServicesType or singletonServicesType');
+        const { wireServicesType, singletonServicesType } = visitState.filesAndMethods;
+        if (!wireServicesType || !singletonServicesType) {
+            throw new Error('Required types not found: wireServicesType or singletonServicesType');
         }
         const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`;
-        const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`;
-        const servicesCode = serializeServicesMap(visitState.serviceAggregation.allSingletonServices, visitState.serviceAggregation.allSessionServices, visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, sessionServicesImport);
+        const wireServicesImport = `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, wireServicesType.typePath, config.packageMappings)}'`;
+        const servicesCode = serializeServicesMap(visitState.serviceAggregation.allSingletonServices, visitState.serviceAggregation.allWireServices, visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, wireServicesImport);
         await writeFileInDir(logger, config.servicesFile, servicesCode);
     },
     middleware: [

package/dist/src/functions/wirings/functions/schemas.js

@@ -8,7 +8,7 @@ export const pikkuSchemas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes, config.schema?.additionalProperties);
-        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.schemasFromTypes, config.schema?.supportsImportAttributes);
+        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.schema?.supportsImportAttributes || true, config.schemasFromTypes);
         return true;
     },
     middleware: [

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

@@ -1,4 +1,4 @@
 /**
  * Generates core function, middleware, and permission type definitions
  */
-export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, sessionServicesTypeName: string, rpcMapTypeImport: string, requiredServicesTypeImport: string, configTypeImport: string) => string;
+export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, wireServicesTypeImport: string, wireServicesTypeName: string, rpcMapTypeImport: string, requiredServicesTypeImport: string, configTypeImport: string) => string;

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.