@pikku/cli 0.11.0 → 0.11.2

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.js

@@ -1,4 +1,4 @@
-export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
+export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, rpcMapPath, configImport, singleServicesFactoryImport, wireServicesImport) => {
     return `'server-only'
 
 /**
@@ -8,12 +8,13 @@ export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, conf
 import { PikkuNextJS } from '@pikku/next'
 import { NextRequest } from 'next/server.js'
 import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
+import type { RPCMap } from '${rpcMapPath}'
 
 type RouteContext = { params: Promise<Record<string, string | string[]>> }
 
 ${configImport}
 ${singleServicesFactoryImport}
-${sessionServicesImport}
+${wireServicesImport}
 
 import '${bootstrapPath}'
 
@@ -34,7 +35,7 @@ export const pikku = (_options?: any) => {
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      createSessionServices
+      createWireServices
     )
   }
 
@@ -174,13 +175,50 @@ export const pikku = (_options?: any) => {
     return staticActionRequest(route, 'GET', data)
   }
 
+  // RPC Requests
+
+  /**
+   * Type definition for RPC invocation with dynamic context.
+   */
+  type RPCInvoke = <Name extends keyof RPCMap>(
+    name: Name,
+    data: RPCMap[Name]['input']
+  ) => Promise<RPCMap[Name]['output']>
+
+  /**
+   * Makes a dynamic RPC request.
+   *
+   * @template Name - The RPC function name from the RPCMap.
+   * @param name - The RPC function identifier.
+   * @param data - The input data for the RPC request.
+   * @returns A promise that resolves to the output of the RPC handler.
+   */
+  const rpc: RPCInvoke = async (name, data) => {
+    return dynamicActionRequest(\`/rpc/\${name}\` as any, 'POST', { data }) as any
+  }
+
+  /**
+   * Makes a static RPC request.
+   * Note: In HTTP wrapper context, both rpc and staticRPC behave the same way.
+   *
+   * @template Name - The RPC function name from the RPCMap.
+   * @param name - The RPC function identifier.
+   * @param data - The input data for the RPC request.
+   * @returns A promise that resolves to the output of the RPC handler.
+   */
+  const staticRPC: RPCInvoke = async (name, data) => {
+    return staticActionRequest(\`/rpc/\${name}\` as any, 'POST', { data }) as any
+  }
+
   return {
+    rpc,
     get: dynamicGet,
     post: dynamicPost,
     patch: dynamicPatch,
     del: dynamicDel,
     staticGet,
     staticPost,
+    staticRPC,
   }
 }
 
@@ -204,7 +242,7 @@ export const pikkuAPIRequest = (
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      createSessionServices
+      createWireServices
     )
   }
   if (_removeAPIPrefix) {

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.d.ts

@@ -1 +1 @@
-export declare const serializeNextJsHTTPWrapper: (routesMapPath: string, pikkuFetchImport: string) => string;
+export declare const serializeNextJsHTTPWrapper: (routesMapPath: string, rpcMapPath: string, pikkuFetchImport: string) => string;

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.js

@@ -1,4 +1,4 @@
-export const serializeNextJsHTTPWrapper = (routesMapPath, pikkuFetchImport) => {
+export const serializeNextJsHTTPWrapper = (routesMapPath, rpcMapPath, pikkuFetchImport) => {
     return `'server-only'
   
 /**
@@ -7,6 +7,7 @@ export const serializeNextJsHTTPWrapper = (routesMapPath, pikkuFetchImport) => {
  */
 import { CorePikkuFetchOptions } from '@pikku/fetch'
 import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
+import type { RPCMap } from '${rpcMapPath}'
 import { PikkuFetch } from '${pikkuFetchImport}'
 
 let _pikku: PikkuFetch | undefined
@@ -146,13 +147,50 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
     return staticActionRequest(route, 'GET', data)
   }
 
+  // RPC Requests
+
+  /**
+   * Type definition for RPC invocation.
+   */
+  type RPCInvoke = <Name extends keyof RPCMap>(
+    name: Name,
+    data: RPCMap[Name]['input']
+  ) => Promise<RPCMap[Name]['output']>
+
+  /**
+   * Makes a dynamic RPC request.
+   *
+   * @template Name - The RPC function name from the RPCMap.
+   * @param name - The RPC function identifier.
+   * @param data - The input data for the RPC request.
+   * @returns A promise that resolves to the output of the RPC handler.
+   */
+  const rpc: RPCInvoke = async (rpcName, data) => {
+    return dynamicActionRequest(\`/rpc/\${rpcName}\` as any, 'POST', { data }) as any
+  }
+
+  /**
+   * Makes a static RPC request.
+   * Note: In HTTP wrapper context, both rpc and rpcStatic behave the same way.
+   *
+   * @template Name - The RPC function name from the RPCMap.
+   * @param name - The RPC function identifier.
+   * @param data - The input data for the RPC request.
+   * @returns A promise that resolves to the output of the RPC handler.
+   */
+  const staticRPC: RPCInvoke = async (rpcName, data) => {
+    return staticActionRequest(\`/rpc/\${rpcName}\` as any, 'POST', { data }) as any
+  }
+
   return {
+    rpc,
     get: dynamicGet,
     post: dynamicPost,
     patch: dynamicPatch,
     del: dynamicDel,
     staticGet,
-    staticPost
+    staticPost,
+    staticRPC
   }
 }
 `;

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

@@ -2,13 +2,20 @@ import { pikkuVoidFunc } 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 pikkuChannels = pikkuVoidFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { channelsWiringFile, channelsWiringMetaFile, packageMappings } = config;
+        const { channelsWiringFile, channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings, schema, } = config;
         const { channels } = visitState;
         await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
-        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+        await writeFileInDir(logger, channelsWiringMetaJsonFile, JSON.stringify(channels.meta, null, 2));
+        const jsonImportPath = getFileImportRelativePath(channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
+        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState('channel', 'meta', metaData as ChannelsMeta)`);
     },
     middleware: [
         logCommandInfoAndTime({

package/dist/src/functions/wirings/channels/serialize-channel-types.js

@@ -8,9 +8,8 @@ export const serializeChannelTypes = (functionTypesImportPath) => {
  */
 
 import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
-import { CorePikkuFunctionConfig } from '@pikku/core'
 import { AssertHTTPWiringParams } from '@pikku/core/http'
-import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
 
 /**
  * Type definition for WebSocket channels with typed data exchange.
@@ -23,9 +22,9 @@ import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMid
 type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
   ChannelData,
   Channel,
-  CorePikkuFunctionConfig<PikkuFunctionSessionless<void, any, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
-  CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
-  CorePikkuFunctionConfig<PikkuFunctionSessionless<any, any, ChannelData> | PikkuFunction<any, any, ChannelData>, PikkuPermission<any>, PikkuMiddleware>,
+  PikkuFunctionConfig<void, any, 'channel' | 'session' | 'rpc'>,
+  PikkuFunctionConfig<void, void, 'channel' | 'session' | 'rpc'>,
+  PikkuFunctionConfig<any, any, 'channel' | 'session' | 'rpc'>,
   PikkuPermission,
   PikkuMiddleware
 >
@@ -40,8 +39,8 @@ type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
  */
 export const pikkuChannelConnectionFunc = <Out = unknown>(
   func:
-    | PikkuFunctionSessionless<void, Out, unknown>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, Out, unknown>, PikkuPermission<void>, PikkuMiddleware>
+    | PikkuFunctionSessionless<void, Out, 'channel' | 'session' | 'rpc'>
+    | PikkuFunctionConfig<void, Out, 'channel' | 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -55,8 +54,8 @@ export const pikkuChannelConnectionFunc = <Out = unknown>(
  */
 export const pikkuChannelDisconnectionFunc = (
   func:
-    | PikkuFunctionSessionless<void, void, unknown>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, unknown>, PikkuPermission<void>, PikkuMiddleware>
+    | PikkuFunctionSessionless<void, void, 'channel'>
+    | PikkuFunctionConfig<void, void, 'channel' | 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -73,8 +72,8 @@ export const pikkuChannelDisconnectionFunc = (
  */
 export const pikkuChannelFunc = <In, Out = unknown>(
   func:
-    | PikkuFunctionSessionless<In, Out, unknown>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out, unknown>, PikkuPermission<In>, PikkuMiddleware>
+    | PikkuFunctionSessionless<In, Out, 'channel' | 'session' | 'rpc'>
+    | PikkuFunctionConfig<In, Out, 'channel' | 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }

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

@@ -100,15 +100,15 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                 checkRequiredTypes(visitState.filesAndMethodsErrors, {
                     config: true,
                     singletonServicesFactory: true,
-                    sessionServicesFactory: true,
+                    wireServicesFactory: true,
                 });
-                const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = visitState.filesAndMethods;
+                const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = visitState.filesAndMethods;
                 if (!pikkuConfigFactory ||
                     !singletonServicesFactory ||
-                    !sessionServicesFactory) {
+                    !wireServicesFactory) {
                     throw new Error('Required types not found');
                 }
-                const bootstrapCode = serializeLocalCLIBootstrap(programName, programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory);
+                const bootstrapCode = serializeLocalCLIBootstrap(programName, programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, wireServicesFactory);
                 await writeFileInDir(logger, bootstrapFile, bootstrapCode);
                 logger.debug(`Serialized CLI bootstrap for ${programName}: ${bootstrapFile}`);
             }

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

@@ -12,7 +12,7 @@ export const pikkuCLITypes = pikkuSessionlessFunc({
         // Check for required types
         checkRequiredTypes(visitState.filesAndMethodsErrors, {
             userSessionType: true,
-            sessionServiceType: true,
+            wireServiceType: true,
             singletonServicesType: true,
         });
         const { userSessionType, singletonServicesType } = visitState.filesAndMethods;

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

@@ -2,15 +2,21 @@ 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 pikkuCLI = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { cliWiringsFile, cliWiringMetaFile, packageMappings } = config;
+        const { cliWiringsFile, cliWiringMetaFile, cliWiringMetaJsonFile, packageMappings, schema, } = config;
         const { cli } = visitState;
         // Generate CLI wirings file
         await writeFileInDir(logger, cliWiringsFile, serializeFileImports('wireCLI', cliWiringsFile, cli.files, packageMappings));
-        // Generate CLI metadata file
-        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('cli', 'meta', ${JSON.stringify(cli.meta, null, 2)})`);
+        await writeFileInDir(logger, cliWiringMetaJsonFile, JSON.stringify(cli.meta, null, 2));
+        const jsonImportPath = getFileImportRelativePath(cliWiringMetaFile, cliWiringMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
+        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState('cli', 'meta', metaData as CLIMeta)`);
         return true;
     },
     middleware: [

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;