@pikku/cli 0.11.1 → 0.11.2

package/dist/src/functions/commands/all.js

@@ -3,38 +3,79 @@ import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
 import { getFileImportRelativePath } from '../../utils/file-import-path.js';
 import { writeFileInDir } from '../../utils/file-writer.js';
 import { CommandSummary } from '../../utils/command-summary.js';
+// Import all command functions directly
+import { pikkuFunctionTypes } from '../wirings/functions/pikku-command-function-types.js';
+import { pikkuFunctionTypesSplit } from '../wirings/functions/pikku-command-function-types-split.js';
+import { pikkuHTTPTypes } from '../wirings/http/pikku-command-http-types.js';
+import { pikkuChannelTypes } from '../wirings/channels/pikku-command-channel-types.js';
+import { pikkuSchedulerTypes } from '../wirings/scheduler/pikku-command-scheduler-types.js';
+import { pikkuQueueTypes } from '../wirings/queue/pikku-command-queue-types.js';
+import { pikkuWorkflowTypes } from '../wirings/workflow/pikku-command-workflow-types.js';
+import { pikkuMCPTypes } from '../wirings/mcp/pikku-command-mcp-types.js';
+import { pikkuCLITypes } from '../wirings/cli/pikku-command-cli-types.js';
+import { pikkuFunctions } from '../wirings/functions/pikku-command-functions.js';
+import { pikkuMiddleware } from '../wirings/middleware/pikku-command-middleware.js';
+import { pikkuPermissions } from '../wirings/permissions/pikku-command-permissions.js';
+import { pikkuServices } from '../wirings/functions/pikku-command-services.js';
+import { pikkuServiceMetadata } from '../wirings/services/pikku-command-service-metadata.js';
+import { pikkuRPC } from '../wirings/rpc/pikku-command-rpc.js';
+import { pikkuRPCExposedMap, pikkuRPCInternalMap, } from '../wirings/rpc/pikku-command-rpc-map.js';
+import { pikkuPublicRPC } from '../wirings/rpc/pikku-command-public-rpc.js';
+import { pikkuRPCClient } from '../wirings/rpc/pikku-command-rpc-client.js';
+import { pikkuSchemas } from '../wirings/functions/schemas.js';
+import { pikkuHTTP } from '../wirings/http/pikku-command-http-routes.js';
+import { pikkuHTTPMap } from '../wirings/http/pikku-command-http-map.js';
+import { pikkuFetch } from '../wirings/fetch/index.js';
+import { pikkuScheduler } from '../wirings/scheduler/pikku-command-scheduler.js';
+import { pikkuWorkflow } from '../wirings/workflow/pikku-command-workflow.js';
+import { pikkuRemoteRPC } from '../wirings/rpc/pikku-command-remote-rpc.js';
+import { pikkuWorkflowMap } from '../wirings/workflow/pikku-command-workflow-map.js';
+import { pikkuQueue } from '../wirings/queue/pikku-command-queue.js';
+import { pikkuQueueMap } from '../wirings/queue/pikku-command-queue-map.js';
+import { pikkuQueueService } from '../wirings/queue/pikku-command-queue-service.js';
+import { pikkuChannels } from '../wirings/channels/pikku-command-channels.js';
+import { pikkuChannelsMap } from '../wirings/channels/pikku-command-channels-map.js';
+import { pikkuWebSocketTyped } from '../wirings/channels/pikku-command-websocket-typed.js';
+import { pikkuMCP } from '../wirings/mcp/pikku-command-mcp.js';
+import { pikkuMCPJSON } from '../wirings/mcp/pikku-command-mcp-json.js';
+import { pikkuCLI } from '../wirings/cli/pikku-command-cli.js';
+import { pikkuCLIEntry } from '../wirings/cli/pikku-command-cli-entry.js';
+import { pikkuNext } from '../runtimes/nextjs/pikku-command-nextjs.js';
+import { pikkuOpenAPI } from '../wirings/http/pikku-command-openapi.js';
 export const all = pikkuVoidFunc({
-    func: async ({ logger, config, rpc, getInspectorState }) => {
+    func: async ({ logger, config, getInspectorState }) => {
+        const wire = {};
+        const services = { logger, config, getInspectorState };
         const summary = new CommandSummary('all');
         const allImports = [];
         let typesDeclarationFileExists = true;
         if (!existsSync(config.typesDeclarationFile)) {
             typesDeclarationFileExists = false;
         }
-        await rpc.invoke('pikkuFunctionTypes', null);
+        await pikkuFunctionTypes.func(services, null, wire);
         // This is needed since the wireHTTP function will add the routes to the visitState
         if (!typesDeclarationFileExists) {
             logger.debug(`• Type file first created, inspecting again...`);
             await getInspectorState(true);
         }
         // Generate wiring-specific type files for tree-shaking
-        await rpc.invoke('pikkuFunctionTypesSplit', null);
-        await rpc.invoke('pikkuHTTPTypes', null);
-        await rpc.invoke('pikkuChannelTypes', null);
-        await rpc.invoke('pikkuSchedulerTypes', null);
-        await rpc.invoke('pikkuQueueTypes', null);
-        await rpc.invoke('pikkuWorkflowTypes', null);
-        await rpc.invoke('pikkuMCPTypes', null);
-        await rpc.invoke('pikkuCLITypes', null);
-        const hasFunctionRegistrations = await rpc.invoke('pikkuFunctions', null);
+        await pikkuFunctionTypesSplit.func(services, null, wire);
+        await pikkuHTTPTypes.func(services, null, wire);
+        await pikkuChannelTypes.func(services, null, wire);
+        await pikkuSchedulerTypes.func(services, null, wire);
+        await pikkuQueueTypes.func(services, null, wire);
+        await pikkuWorkflowTypes.func(services, null, wire);
+        await pikkuMCPTypes.func(services, null, wire);
+        await pikkuCLITypes.func(services, null, wire);
+        const hasFunctionRegistrations = await pikkuFunctions.func(services, wire, null);
         // Generate and register middleware
-        const middleware = await rpc.invoke('pikkuMiddleware', null);
+        const middleware = await pikkuMiddleware.func(services, null, wire);
         // Middleware must be imported before functions meta to ensure registration happens first
         if (middleware) {
             allImports.push(config.middlewareFile);
         }
         // Generate and register permissions
-        const permissions = await rpc.invoke('pikkuPermissions', null);
+        const permissions = await pikkuPermissions.func(services, null, wire);
         // Permissions must be imported before functions meta to ensure registration happens first
         if (permissions) {
             allImports.push(config.permissionsFile);
@@ -46,79 +87,78 @@ export const all = pikkuVoidFunc({
             allImports.push(config.functionsFile);
         }
         // Generate services map
-        await rpc.invoke('pikkuServices', null);
-        const hasInternalRPCs = await rpc.invoke('pikkuRPC', null);
-        await rpc.invoke('pikkuRPCInternalMap', null);
-        await rpc.invoke('pikkuRPCExposedMap', null);
-        await rpc.invoke('pikkuRPCClient', null);
+        await pikkuServices.func(services, null, wire);
+        // Generate service metadata JSON files for AI consumption
+        await pikkuServiceMetadata.func(services, null, wire);
+        const hasInternalRPCs = await pikkuRPC.func(services, null, wire);
+        await pikkuRPCInternalMap.func(services, null, wire);
+        await pikkuRPCExposedMap.func(services, null, wire);
+        await pikkuPublicRPC.func(services, null, wire);
+        await pikkuRPCClient.func(services, null, wire);
         if (hasInternalRPCs) {
             allImports.push(config.rpcInternalWiringMetaFile);
         }
-        const schemas = await rpc.invoke('pikkuSchemas', null);
+        const schemas = await pikkuSchemas.func(services, null, wire);
         if (schemas) {
             allImports.push(`${config.schemaDirectory}/register.gen.ts`);
         }
         // Generate HTTP
-        const http = await rpc.invoke('pikkuHTTP', null);
+        const http = await pikkuHTTP.func(services, null, wire);
         if (http) {
-            await rpc.invoke('pikkuHTTPMap', null);
-            await rpc.invoke('pikkuFetch', null);
+            await pikkuHTTPMap.func(services, null, wire);
+            await pikkuFetch.func(services, null, wire);
             allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
         }
         // Generate Scheduler
-        const scheduler = await rpc.invoke('pikkuScheduler', null);
+        const scheduler = await pikkuScheduler.func(services, null, wire);
         if (scheduler) {
             allImports.push(config.schedulersWiringMetaFile, config.schedulersWiringFile);
         }
         // Generate Workflows
-        const workflows = await rpc.invoke('pikkuWorkflow', null);
+        const workflows = await pikkuWorkflow.func(services, null, wire);
         // Generate Remote RPC Workers (must be before queue discovery so wireQueueWorker calls are picked up)
-        const remoteRPC = await rpc.invoke('pikkuRemoteRPC', null);
+        const remoteRPC = await pikkuRemoteRPC.func(services, null, wire);
         // Reinspect to pick up generated workflow workers and remote RPC workers BEFORE generating maps
         if (workflows || remoteRPC) {
             await getInspectorState(true);
         }
         if (workflows) {
-            await rpc.invoke('pikkuWorkflowMap', null);
+            await pikkuWorkflowMap.func(services, null, wire);
             allImports.push(config.workflowsWiringMetaFile, config.workflowsWiringFile);
         }
-        if (remoteRPC && config.rpc?.remoteRpcWorkersPath) {
-            // Only add to imports if we actually generated the file
-            allImports.push(config.rpc.remoteRpcWorkersPath);
-        }
         // Generate Queues
-        const queues = await rpc.invoke('pikkuQueue', null);
+        const queues = await pikkuQueue.func(services, null, wire);
         if (queues) {
-            await rpc.invoke('pikkuQueueMap', null);
-            await rpc.invoke('pikkuQueueService', null);
+            await pikkuQueueMap.func(services, null, wire);
+            await pikkuQueueService.func(services, null, wire);
             allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
         }
         // Generate Channels
-        const channels = await rpc.invoke('pikkuChannels', null);
+        const channels = await pikkuChannels.func(services, null, wire);
         if (channels) {
-            await rpc.invoke('pikkuChannelsMap', null);
-            await rpc.invoke('pikkuWebSocketTyped', null);
+            await pikkuChannelsMap.func(services, null, wire);
+            await pikkuWebSocketTyped.func(services, null, wire);
             allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
         }
         // Generate MCP
-        const mcp = await rpc.invoke('pikkuMCP', null);
+        const mcp = await pikkuMCP.func(services, null, wire);
         if (mcp) {
-            await rpc.invoke('pikkuMCPJSON', null);
+            await pikkuMCPJSON.func(services, null, wire);
             allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
         }
         // Generate CLI
-        const cli = await rpc.invoke('pikkuCLI', null);
+        const cli = await pikkuCLI.func(services, null, wire);
         if (cli) {
-            await rpc.invoke('pikkuCLIEntry', null);
+            await pikkuCLIEntry.func(services, null, wire);
             allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
         }
         if (config.nextBackendFile || config.nextHTTPFile) {
-            await rpc.invoke('pikkuNext', null);
+            await pikkuNext.func(services, null, wire);
         }
         if (config.openAPI) {
             logger.debug(`• OpenAPI requires a reinspection to pickup new generated types..`);
             await getInspectorState(true);
-            await rpc.invoke('pikkuOpenAPI', null);
+            await pikkuOpenAPI.func(services, null, wire);
         }
         // Generate main bootstrap file (pass all imports directly since this is the main file)
         await writeFileInDir(logger, config.bootstrapFile, allImports

package/dist/src/functions/commands/bootstrap.js

@@ -1,21 +1,33 @@
 import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
+// Import command functions directly
+import { pikkuFunctionTypes } from '../wirings/functions/pikku-command-function-types.js';
+import { pikkuFunctionTypesSplit } from '../wirings/functions/pikku-command-function-types-split.js';
+import { pikkuHTTPTypes } from '../wirings/http/pikku-command-http-types.js';
+import { pikkuChannelTypes } from '../wirings/channels/pikku-command-channel-types.js';
+import { pikkuSchedulerTypes } from '../wirings/scheduler/pikku-command-scheduler-types.js';
+import { pikkuQueueTypes } from '../wirings/queue/pikku-command-queue-types.js';
+import { pikkuWorkflowTypes } from '../wirings/workflow/pikku-command-workflow-types.js';
+import { pikkuMCPTypes } from '../wirings/mcp/pikku-command-mcp-types.js';
+import { pikkuCLITypes } from '../wirings/cli/pikku-command-cli-types.js';
 export const bootstrap = pikkuVoidFunc({
-    func: async ({ logger, config, rpc, getInspectorState }) => {
+    func: async ({ logger, config, getInspectorState }) => {
+        const wire = {};
+        const services = { logger, config, getInspectorState };
         // Initialize inspector state in bootstrap mode with core types only
         // This allows bootstrap to run immediately without inspecting the codebase
         // All subsequent RPC commands will use this cached state
         await getInspectorState(false, false, true);
-        await rpc.invoke('pikkuFunctionTypes', null);
+        await pikkuFunctionTypes.func(services, null, wire);
         // Generate wiring-specific type files for tree-shaking
         // These use the bootstrap mode state with core types
-        await rpc.invoke('pikkuFunctionTypesSplit', null);
-        await rpc.invoke('pikkuHTTPTypes', null);
-        await rpc.invoke('pikkuChannelTypes', null);
-        await rpc.invoke('pikkuSchedulerTypes', null);
-        await rpc.invoke('pikkuQueueTypes', null);
-        await rpc.invoke('pikkuWorkflowTypes', null);
-        await rpc.invoke('pikkuMCPTypes', null);
-        await rpc.invoke('pikkuCLITypes', null);
+        await pikkuFunctionTypesSplit.func(services, null, wire);
+        await pikkuHTTPTypes.func(services, null, wire);
+        await pikkuChannelTypes.func(services, null, wire);
+        await pikkuSchedulerTypes.func(services, null, wire);
+        await pikkuQueueTypes.func(services, null, wire);
+        await pikkuWorkflowTypes.func(services, null, wire);
+        await pikkuMCPTypes.func(services, null, wire);
+        await pikkuCLITypes.func(services, null, wire);
         // Check for critical errors and exit if any were logged
         if (logger.hasCriticalErrors()) {
             process.exit(1);

package/dist/src/functions/commands/watch.js

@@ -1,7 +1,9 @@
 import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
 import chokidar from 'chokidar';
+import { all } from './all.js';
 export const watch = pikkuVoidFunc({
-    func: async ({ logger, config, rpc }) => {
+    func: async ({ logger, config, getInspectorState }) => {
+        const services = { logger, config, getInspectorState };
         const configWatcher = chokidar.watch(config.srcDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.tsx?/,
@@ -18,14 +20,15 @@ export const watch = pikkuVoidFunc({
                 const handle = async () => {
                     try {
                         const start = Date.now();
-                        await rpc.invoke('all', null);
+                        await all.func(services, null, {});
                         logger.info({
                             message: `✓ Generated in ${Date.now() - start}ms`,
                             type: 'timing',
                         });
                     }
                     catch (err) {
-                        logger.error(err);
+                        console.error(err);
+                        logger.error('Error running watch');
                     }
                 };
                 await handle();

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.js

@@ -7,7 +7,7 @@ import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './
 import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js';
 export const pikkuNext = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { nextBackendFile, nextHTTPFile, httpMapDeclarationFile, packageMappings, fetchFile, } = config;
+        const { nextBackendFile, nextHTTPFile, httpMapDeclarationFile, rpcMapDeclarationFile, packageMappings, fetchFile, } = config;
         // If both files are undefined, clean up any existing files and return
         if (!nextBackendFile && !nextHTTPFile) {
             logger.info({
@@ -20,31 +20,36 @@ export const pikkuNext = pikkuSessionlessFunc({
         if (nextHTTPFile && !fetchFile) {
             throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
         }
+        if ((nextBackendFile || nextHTTPFile) && !rpcMapDeclarationFile) {
+            throw new Error('rpcMapDeclarationFile is required in pikku config in order for nextJS wrapper to work');
+        }
         if (nextBackendFile) {
             // Check for required types
             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 pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
             const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
-            const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`;
+            const wireServicesImport = `import { ${wireServicesFactory.variable} as createWireServices } from '${getFileImportRelativePath(nextBackendFile, wireServicesFactory.file, packageMappings)}'`;
             const bootstrapPath = getFileImportRelativePath(nextBackendFile, config.bootstrapFile, packageMappings);
             const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
-            const content = serializeNextBackendWrapper(bootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
+            const rpcMapDeclarationPath = getFileImportRelativePath(nextBackendFile, rpcMapDeclarationFile, packageMappings);
+            const content = serializeNextBackendWrapper(bootstrapPath, routesMapDeclarationPath, rpcMapDeclarationPath, pikkuConfigImport, singletonServicesImport, wireServicesImport);
             await writeFileInDir(logger, nextBackendFile, content);
         }
         if (nextHTTPFile && fetchFile) {
             const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpMapDeclarationFile, packageMappings);
+            const rpcMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, rpcMapDeclarationFile, packageMappings);
             const fetchPath = getFileImportRelativePath(nextHTTPFile, fetchFile, packageMappings);
-            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, fetchPath);
+            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, rpcMapDeclarationPath, fetchPath);
             await writeFileInDir(logger, nextHTTPFile, content);
         }
     },

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

@@ -1 +1 @@
-export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, configImport: string, singleServicesFactoryImport: string, sessionServicesImport: string) => string;
+export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, rpcMapPath: string, configImport: string, singleServicesFactoryImport: string, wireServicesImport: string) => string;

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: [