@pikku/cli 0.11.1 → 0.11.3

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 { 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 { 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 { 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 { pikkuPackage } from '../wirings/package/pikku-command-package.js'
+import { pikkuForgeNodes } from '../wirings/forge/pikku-command-forge-nodes.js'
+import { pikkuForgeTypes } from '../wirings/forge/pikku-command-forge-types.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,141 +60,142 @@ 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) {
       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)
+    await pikkuFunctionTypesSplit.func(services, null, wire)
 
-    const hasFunctionRegistrations = await rpc.invoke('pikkuFunctions', null)
+    if (!config.externalPackage) {
+      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 pikkuMCPTypes.func(services, null, wire)
+      await pikkuCLITypes.func(services, null, wire)
+    }
 
-    // Generate and register middleware
-    const middleware = await rpc.invoke('pikkuMiddleware', null)
-    // Middleware must be imported before functions meta to ensure registration happens first
+    const hasFunctionRegistrations = await pikkuFunctions.func(
+      services,
+      wire,
+      null
+    )
+
+    const middleware = await pikkuMiddleware.func(services, null, wire)
     if (middleware) {
       allImports.push(config.middlewareFile)
     }
 
-    // Generate and register permissions
-    const permissions = await rpc.invoke('pikkuPermissions', null)
-    // Permissions must be imported before functions meta to ensure registration happens first
+    const permissions = await pikkuPermissions.func(services, null, wire)
     if (permissions) {
       allImports.push(config.permissionsFile)
     }
 
-    // Always import functions meta (needed for all function metadata)
     allImports.push(config.functionsMetaFile)
 
-    // Only import functionsFile if it was generated (has internal/external RPCs)
     if (hasFunctionRegistrations) {
       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)
+    await pikkuServiceMetadata.func(services, null, wire)
 
-    if (hasInternalRPCs) {
-      allImports.push(config.rpcInternalWiringMetaFile)
+    const hasPackageFactories = await pikkuPackage.func(services, null, wire)
+    if (hasPackageFactories) {
+      allImports.push(config.packageFile)
     }
 
-    const schemas = await rpc.invoke('pikkuSchemas', null)
+    const hasInternalRPCs = await pikkuRPC.func(services, null, wire)
+
+    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)
-    if (http) {
-      await rpc.invoke('pikkuHTTPMap', null)
-      await rpc.invoke('pikkuFetch', null)
-      allImports.push(config.httpWiringMetaFile, config.httpWiringsFile)
+    await pikkuRPCInternalMap.func(services, null, wire)
+    await pikkuRPCExposedMap.func(services, null, wire)
+    await pikkuPublicRPC.func(services, null, wire)
+    await pikkuRPCClient.func(services, null, wire)
+
+    await pikkuForgeTypes.func(services, null, wire)
+
+    if (hasInternalRPCs) {
+      allImports.push(config.rpcInternalWiringMetaFile)
     }
 
-    // Generate Scheduler
-    const scheduler = await rpc.invoke('pikkuScheduler', null)
-    if (scheduler) {
-      allImports.push(
-        config.schedulersWiringMetaFile,
-        config.schedulersWiringFile
-      )
+    if (!config.externalPackage) {
+      const http = await pikkuHTTP.func(services, null, wire)
+      if (http) {
+        await pikkuHTTPMap.func(services, null, wire)
+        await pikkuFetch.func(services, null, wire)
+        allImports.push(config.httpWiringMetaFile, config.httpWiringsFile)
+      }
+
+      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)
+    let remoteRPC = false
+    if (!config.externalPackage) {
+      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)
-      allImports.push(
-        config.workflowsWiringMetaFile,
-        config.workflowsWiringFile
-      )
+      allImports.push(config.workflowsWiringFile)
     }
 
-    if (remoteRPC && config.rpc?.remoteRpcWorkersPath) {
-      // Only add to imports if we actually generated the file
-      allImports.push(config.rpc.remoteRpcWorkersPath)
-    }
+    if (!config.externalPackage) {
+      const queues = await pikkuQueue.func(services, null, wire)
+      if (queues) {
+        await pikkuQueueMap.func(services, null, wire)
+        await pikkuQueueService.func(services, null, wire)
+        allImports.push(
+          config.queueWorkersWiringMetaFile,
+          config.queueWorkersWiringFile
+        )
+      }
 
-    // Generate Queues
-    const queues = await rpc.invoke('pikkuQueue', null)
-    if (queues) {
-      await rpc.invoke('pikkuQueueMap', null)
-      await rpc.invoke('pikkuQueueService', null)
-      allImports.push(
-        config.queueWorkersWiringMetaFile,
-        config.queueWorkersWiringFile
-      )
-    }
+      const channels = await pikkuChannels.func(services, null, wire)
+      if (channels) {
+        await pikkuChannelsMap.func(services, null, wire)
+        await pikkuWebSocketTyped.func(services, null, wire)
+        allImports.push(
+          config.channelsWiringMetaFile,
+          config.channelsWiringFile
+        )
+      }
 
-    // Generate Channels
-    const channels = await rpc.invoke('pikkuChannels', null)
-    if (channels) {
-      await rpc.invoke('pikkuChannelsMap', null)
-      await rpc.invoke('pikkuWebSocketTyped', null)
-      allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile)
-    }
+      const mcp = await pikkuMCP.func(services, null, wire)
+      if (mcp) {
+        await pikkuMCPJSON.func(services, null, wire)
+        allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile)
+      }
 
-    // Generate MCP
-    const mcp = await rpc.invoke('pikkuMCP', null)
-    if (mcp) {
-      await rpc.invoke('pikkuMCPJSON', null)
-      allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile)
+      const cli = await pikkuCLI.func(services, null, wire)
+      if (cli) {
+        await pikkuCLIEntry.func(services, null, wire)
+        allImports.push(config.cliWiringMetaFile, config.cliWiringsFile)
+      }
     }
 
-    // Generate CLI
-    const cli = await rpc.invoke('pikkuCLI', null)
-    if (cli) {
-      await rpc.invoke('pikkuCLIEntry', null)
-      allImports.push(config.cliWiringMetaFile, config.cliWiringsFile)
-    }
+    await pikkuForgeNodes.func(services, null, wire)
 
     if (config.nextBackendFile || config.nextHTTPFile) {
-      await rpc.invoke('pikkuNext', null)
+      await pikkuNext.func(services, null, wire)
     }
 
     if (config.openAPI) {
@@ -156,26 +203,69 @@ 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)
-    await writeFileInDir(
-      logger,
-      config.bootstrapFile,
-      allImports
-        .map(
-          (to) =>
-            `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`
-        )
-        .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
-        .join('\n')
+    const stateBeforeBootstrap = await getInspectorState()
+    const externalPackageBootstraps: string[] = []
+    const usedExternalPackages: Record<string, string> = {}
+    if (
+      config.externalPackages &&
+      stateBeforeBootstrap.rpc?.usedExternalPackages?.size > 0
+    ) {
+      for (const namespace of stateBeforeBootstrap.rpc.usedExternalPackages) {
+        const packageName = config.externalPackages[namespace]
+        if (packageName) {
+          const packageBootstrap = `${packageName}/.pikku/pikku-bootstrap.gen.js`
+          externalPackageBootstraps.push(packageBootstrap)
+          usedExternalPackages[namespace] = packageName
+          logger.debug(
+            `• External package detected: ${namespace} (${packageName})`
+          )
+        }
+      }
+    }
+
+    const localImports = allImports.map(
+      (to) =>
+        `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`
     )
+    const externalImports = externalPackageBootstraps.map(
+      (packagePath) => `import '${packagePath}'`
+    )
+
+    let externalPackagesRegistration = ''
+    if (Object.keys(usedExternalPackages).length > 0) {
+      externalPackagesRegistration = `
+// Register external package mappings
+import { pikkuState } from '@pikku/core'
+const externalPackages = pikkuState(null, 'rpc', 'externalPackages')
+${Object.entries(usedExternalPackages)
+  .map(([ns, pkg]) => `externalPackages.set('${ns}', '${pkg}')`)
+  .join('\n')}
+`
+    }
+
+    const allBootstrapImports =
+      [...localImports, ...externalImports]
+        .sort((a, b) => {
+          const aMeta = a.includes('meta')
+          const bMeta = b.includes('meta')
+          if (aMeta && !bMeta) return -1
+          if (!aMeta && bMeta) return 1
+          return 0
+        })
+        .join('\n') + externalPackagesRegistration
+
+    await writeFileInDir(logger, config.bootstrapFile, allBootstrapImports)
 
-    // Get final inspector state and collect stats for summary
     const state = await getInspectorState()
-    if (state.http?.meta)
-      summary.set('httpRoutes', Object.keys(state.http.meta).length)
+    if (state.http?.meta) {
+      const httpRouteCount = (
+        Object.values(state.http.meta) as Record<string, unknown>[]
+      ).reduce((sum, routes) => sum + Object.keys(routes).length, 0)
+      if (httpRouteCount > 0) summary.set('httpRoutes', httpRouteCount)
+    }
     if (state.channels?.meta)
       summary.set('channels', Object.keys(state.channels.meta).length)
     if (state.scheduledTasks?.meta)
@@ -193,9 +283,8 @@ export const all: any = pikkuVoidFunc({
       if (mcpTotal > 0) summary.set('mcpEndpoints', mcpTotal)
     }
     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)
@@ -203,13 +292,20 @@ export const all: any = pikkuVoidFunc({
     if (state.workflows?.meta) {
       summary.set('workflows', Object.keys(state.workflows.meta).length)
     }
+    if (state.forgeNodes?.meta) {
+      const forgeNodesCount = Object.keys(state.forgeNodes.meta).length
+      if (forgeNodesCount > 0) summary.set('forgeNodes', forgeNodesCount)
+    }
+    if (state.workflows?.graphMeta) {
+      const workflowGraphsCount = Object.keys(state.workflows.graphMeta).length
+      if (workflowGraphsCount > 0)
+        summary.set('workflowGraphs', workflowGraphsCount)
+    }
 
-    // Display summary (unless in silent mode)
     if (!logger.isSilent()) {
       console.log(summary.format())
     }
 
-    // Check for critical errors and exit if any were logged
     if (logger.hasCriticalErrors()) {
       process.exit(1)
     }

package/src/functions/commands/bootstrap.ts

@@ -1,26 +1,33 @@
 import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js'
+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 { pikkuWorkflow } from '../wirings/workflow/pikku-command-workflow.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 }) => {
-    // 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
+  func: async ({ logger, config, getInspectorState }) => {
+    const wire: PikkuWire = {}
+    const services = { logger, config, getInspectorState }
+
     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 pikkuWorkflow.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/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,36 @@ 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 +78,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 +102,12 @@ export const pikkuNext: any = pikkuSessionlessFunc<void, void>({
         packageMappings
       )
 
+      const rpcMapDeclarationPath = getFileImportRelativePath(
+        nextHTTPFile,
+        rpcMapDeclarationFile,
+        packageMappings
+      )
+
       const fetchPath = getFileImportRelativePath(
         nextHTTPFile,
         fetchFile,
@@ -97,6 +116,7 @@ export const pikkuNext: any = pikkuSessionlessFunc<void, void>({
 
       const content = serializeNextHTTPWrapper(
         routesMapDeclarationPath,
+        rpcMapDeclarationPath,
         fetchPath
       )
       await writeFileInDir(logger, nextHTTPFile, content)