@pikku/cli 0.11.0 → 0.11.2

package/src/functions/commands/all.ts

@@ -4,8 +4,54 @@ 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'
+import { PikkuWire } from '@pikku/core'
+
 export const all: any = pikkuVoidFunc({
-  func: async ({ logger, config, rpc, getInspectorState }) => {
+  func: async ({ logger, config, getInspectorState }) => {
+    const wire: PikkuWire = {}
+    const services = { logger, config, getInspectorState }
     const summary = new CommandSummary('all')
     const allImports: string[] = []
     let typesDeclarationFileExists = true
@@ -14,7 +60,7 @@ export const all: any = pikkuVoidFunc({
       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) {
@@ -23,26 +69,30 @@ export const all: any = pikkuVoidFunc({
     }
 
     // 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)
+    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 rpc.invoke('pikkuFunctions', null)
+    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)
@@ -57,32 +107,36 @@ export const all: any = pikkuVoidFunc({
     }
 
     // Generate services map
-    await rpc.invoke('pikkuServices', null)
+    await pikkuServices.func(services, null, wire)
+
+    // Generate service metadata JSON files for AI consumption
+    await pikkuServiceMetadata.func(services, null, wire)
 
-    const hasInternalRPCs = await rpc.invoke('pikkuRPC', null)
-    await rpc.invoke('pikkuRPCInternalMap', null)
-    await rpc.invoke('pikkuRPCExposedMap', null)
-    await rpc.invoke('pikkuRPCClient', null)
+    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,
@@ -91,10 +145,10 @@ export const all: any = pikkuVoidFunc({
     }
 
     // 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) {
@@ -102,23 +156,18 @@ export const all: any = pikkuVoidFunc({
     }
 
     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
@@ -126,29 +175,29 @@ export const all: any = pikkuVoidFunc({
     }
 
     // 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) {
@@ -156,7 +205,7 @@ export const all: any = pikkuVoidFunc({
         `• 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)
@@ -194,8 +243,8 @@ export const all: any = pikkuVoidFunc({
     }
     if (state.cli?.meta) {
       // Count total CLI commands across all programs
-      const totalCommands = Object.values(state.cli.meta).reduce(
-        (sum, program) => sum + (program.commands?.length || 0),
+      const totalCommands: number = Object.values(state.cli.meta).reduce(
+        (sum: number, program: any) => sum + (program.commands?.length || 0),
         0
       )
       if (totalCommands > 0) summary.set('cliCommands', totalCommands)

package/src/functions/commands/bootstrap.ts

@@ -1,24 +1,39 @@
 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'
+import { PikkuWire } from '@pikku/core'
+
 export const bootstrap: any = pikkuVoidFunc({
-  func: async ({ logger, config, rpc, getInspectorState }) => {
+  func: async ({ logger, config, getInspectorState }) => {
+    const wire: PikkuWire = {}
+    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()) {

package/src/functions/commands/watch.ts

@@ -1,8 +1,10 @@
 import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js'
 import chokidar from 'chokidar'
+import { all } from './all.js'
 
 export const watch: any = 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?/,
@@ -25,13 +27,14 @@ export const watch: any = 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')
           }
         }
 

package/src/functions/runtimes/nextjs/pikku-command-nextjs.ts

@@ -12,6 +12,7 @@ export const pikkuNext: any = pikkuSessionlessFunc<void, void>({
       nextBackendFile,
       nextHTTPFile,
       httpMapDeclarationFile,
+      rpcMapDeclarationFile,
       packageMappings,
       fetchFile,
     } = config
@@ -34,31 +35,37 @@ export const pikkuNext: any = pikkuSessionlessFunc<void, void>({
       )
     }
 
+    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,
+        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,
@@ -72,12 +79,19 @@ export const pikkuNext: any = pikkuSessionlessFunc<void, void>({
         packageMappings
       )
 
+      const rpcMapDeclarationPath = getFileImportRelativePath(
+        nextBackendFile,
+        rpcMapDeclarationFile,
+        packageMappings
+      )
+
       const content = serializeNextBackendWrapper(
         bootstrapPath,
         routesMapDeclarationPath,
+        rpcMapDeclarationPath,
         pikkuConfigImport,
         singletonServicesImport,
-        sessionServicesImport
+        wireServicesImport
       )
       await writeFileInDir(logger, nextBackendFile, content)
     }
@@ -89,6 +103,12 @@ export const pikkuNext: any = pikkuSessionlessFunc<void, void>({
         packageMappings
       )
 
+      const rpcMapDeclarationPath = getFileImportRelativePath(
+        nextHTTPFile,
+        rpcMapDeclarationFile,
+        packageMappings
+      )
+
       const fetchPath = getFileImportRelativePath(
         nextHTTPFile,
         fetchFile,
@@ -97,6 +117,7 @@ export const pikkuNext: any = pikkuSessionlessFunc<void, void>({
 
       const content = serializeNextHTTPWrapper(
         routesMapDeclarationPath,
+        rpcMapDeclarationPath,
         fetchPath
       )
       await writeFileInDir(logger, nextHTTPFile, content)

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

@@ -1,9 +1,10 @@
 export const serializeNextJsBackendWrapper = (
   bootstrapPath: string,
   routesMapPath: string,
+  rpcMapPath: string,
   configImport: string,
   singleServicesFactoryImport: string,
-  sessionServicesImport: string
+  wireServicesImport: string
 ) => {
   return `'server-only'
 
@@ -14,12 +15,13 @@ export const serializeNextJsBackendWrapper = (
 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}'
 
@@ -40,7 +42,7 @@ export const pikku = (_options?: any) => {
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      createSessionServices
+      createWireServices
     )
   }
 
@@ -180,13 +182,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,
   }
 }
 
@@ -210,7 +249,7 @@ export const pikkuAPIRequest = (
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      createSessionServices
+      createWireServices
     )
   }
   if (_removeAPIPrefix) {

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

@@ -1,5 +1,6 @@
 export const serializeNextJsHTTPWrapper = (
   routesMapPath: string,
+  rpcMapPath: string,
   pikkuFetchImport: string
 ) => {
   return `'server-only'
@@ -10,6 +11,7 @@ export const serializeNextJsHTTPWrapper = (
  */
 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
@@ -149,13 +151,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/src/functions/wirings/channels/pikku-channels.ts

@@ -2,12 +2,18 @@ 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: any = 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(
@@ -20,10 +26,28 @@ export const pikkuChannels: any = pikkuVoidFunc({
         packageMappings
       )
     )
+
+    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'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
+      `import { pikkuState } from '@pikku/core'\nimport { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState('channel', 'meta', metaData as ChannelsMeta)`
     )
   },
   middleware: [