@pikku/cli 0.9.2 → 0.9.3

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @pikku/cli
 
+## 0.9.3
+
+### Patch Changes
+
+- 9691aba: fix: add-functions should support both functions only and objects
+- 2ab0278: refactor: no longer import ALL functions, only the ones used by rpcs
+- 81005ba: feat: creating a smaller meta file for functions to reduce size
+- b3c2829: fix (using ai): generating custom types broke imports.. this fixes it, but needs more robust training
+- Updated dependencies [9691aba]
+- Updated dependencies [2ab0278]
+- Updated dependencies [81005ba]
+- Updated dependencies [b3c2829]
+  - @pikku/inspector@0.9.3
+  - @pikku/core@0.9.3
+
 ## 0.9.2
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -17,7 +17,10 @@ import chokidar from 'chokidar'
 import { pikkuFunctions } from '../src/wirings/functions/pikku-command-functions.js'
 import { pikkuServices } from '../src/wirings/functions/pikku-command-services.js'
 import { pikkuRPC } from '../src/wirings/rpc/pikku-command-rpc.js'
-import { pikkuRPCMap } from '../src/wirings/rpc/pikku-command-rpc-map.js'
+import {
+  pikkuRPCExposedMap,
+  pikkuRPCInternalMap,
+} from '../src/wirings/rpc/pikku-command-rpc-map.js'
 import { pikkuQueue } from '../src/wirings/queue/pikku-command-queue.js'
 import { pikkuQueueMap } from '../src/wirings/queue/pikku-command-queue-map.js'
 import { pikkuFetch } from '../src/wirings/fetch/index.js'
@@ -39,7 +42,10 @@ const generateBootstrapFile = async (
   schemas?: boolean
 ) => {
   // Common imports that every bootstrap file needs
-  const commonImports = [cliConfig.functionsMetaFile, cliConfig.functionsFile]
+  const commonImports = [
+    cliConfig.functionsMetaMinFile,
+    cliConfig.functionsFile,
+  ]
 
   // Add schema if it exists
   if (schemas) {
@@ -106,7 +112,8 @@ const runAll = async (
   await pikkuServices(logger, cliConfig, visitState)
 
   await pikkuRPC(logger, cliConfig, visitState)
-  await pikkuRPCMap(logger, cliConfig, visitState)
+  await pikkuRPCInternalMap(logger, cliConfig, visitState)
+  await pikkuRPCExposedMap(logger, cliConfig, visitState)
   await pikkuRPCClient(logger, cliConfig)
   allImports.push(cliConfig.rpcWiringMetaFile)
 

package/cli.schema.json

@@ -199,6 +199,9 @@
         "functionsMetaFile": {
           "type": "string"
         },
+        "functionsMetaMinFile": {
+          "type": "string"
+        },
         "httpMapDeclarationFile": {
           "type": "string"
         },
@@ -316,6 +319,7 @@
         "filters",
         "functionsFile",
         "functionsMetaFile",
+        "functionsMetaMinFile",
         "httpMapDeclarationFile",
         "httpWiringMetaFile",
         "httpWiringsFile",

package/dist/bin/pikku-all.js

@@ -11,7 +11,7 @@ import chokidar from 'chokidar';
 import { pikkuFunctions } from '../src/wirings/functions/pikku-command-functions.js';
 import { pikkuServices } from '../src/wirings/functions/pikku-command-services.js';
 import { pikkuRPC } from '../src/wirings/rpc/pikku-command-rpc.js';
-import { pikkuRPCMap } from '../src/wirings/rpc/pikku-command-rpc-map.js';
+import { pikkuRPCExposedMap, pikkuRPCInternalMap, } from '../src/wirings/rpc/pikku-command-rpc-map.js';
 import { pikkuQueue } from '../src/wirings/queue/pikku-command-queue.js';
 import { pikkuQueueMap } from '../src/wirings/queue/pikku-command-queue-map.js';
 import { pikkuFetch } from '../src/wirings/fetch/index.js';
@@ -26,7 +26,10 @@ import { pikkuMCPJSON } from '../src/wirings/mcp/pikku-command-mcp-json.js';
 import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js';
 const generateBootstrapFile = async (logger, cliConfig, bootstrapFile, specificImports, schemas) => {
     // Common imports that every bootstrap file needs
-    const commonImports = [cliConfig.functionsMetaFile, cliConfig.functionsFile];
+    const commonImports = [
+        cliConfig.functionsMetaMinFile,
+        cliConfig.functionsFile,
+    ];
     // Add schema if it exists
     if (schemas) {
         commonImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`);
@@ -61,7 +64,8 @@ const runAll = async (logger, cliConfig, options) => {
     // Generate services map
     await pikkuServices(logger, cliConfig, visitState);
     await pikkuRPC(logger, cliConfig, visitState);
-    await pikkuRPCMap(logger, cliConfig, visitState);
+    await pikkuRPCInternalMap(logger, cliConfig, visitState);
+    await pikkuRPCExposedMap(logger, cliConfig, visitState);
     await pikkuRPCClient(logger, cliConfig);
     allImports.push(cliConfig.rpcWiringMetaFile);
     const schemas = await pikkuSchemas(logger, cliConfig, visitState);

package/dist/src/pikku-cli-config.d.ts

@@ -7,12 +7,15 @@ export interface PikkuCLICoreOutputFiles {
     typesDeclarationFile: string;
     functionsFile: string;
     functionsMetaFile: string;
+    functionsMetaMinFile: string;
     httpWiringsFile: string;
     httpWiringMetaFile: string;
     httpMapDeclarationFile: string;
     channelsWiringFile: string;
     channelsWiringMetaFile: string;
     channelsMapDeclarationFile: string;
+    rpcInternalWiringMetaFile: string;
+    rpcInternalMapDeclarationFile: string;
     rpcWiringMetaFile: string;
     rpcMapDeclarationFile: string;
     schedulersWiringFile: string;

package/dist/src/pikku-cli-config.js

@@ -61,7 +61,8 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, filter
             const functionDir = join(result.outDir, 'function');
             const httpDir = join(result.outDir, 'http');
             const channelDir = join(result.outDir, 'channel');
-            const rpcDir = join(result.outDir, 'rpc');
+            const internalRPCDirectory = join(result.outDir, 'rpc-internal');
+            const externalRPCDirectory = join(result.outDir, 'rpc');
             const schedulerDir = join(result.outDir, 'scheduler');
             const queueDir = join(result.outDir, 'queue');
             const mcpDir = join(result.outDir, 'mcp');
@@ -76,6 +77,9 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, filter
             if (!result.functionsMetaFile) {
                 result.functionsMetaFile = join(functionDir, 'pikku-functions-meta.gen.ts');
             }
+            if (!result.functionsMetaMinFile) {
+                result.functionsMetaMinFile = join(functionDir, 'pikku-functions-meta.min.gen.ts');
+            }
             if (!result.typesDeclarationFile) {
                 result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts');
             }
@@ -99,12 +103,19 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, filter
             if (!result.channelsMapDeclarationFile) {
                 result.channelsMapDeclarationFile = join(channelDir, 'pikku-channels-map.gen.d.ts');
             }
-            // RPC
+            // Internal
+            if (!result.rpcInternalWiringMetaFile) {
+                result.rpcInternalWiringMetaFile = join(internalRPCDirectory, 'pikku-rpc-wirings-meta.internal.gen.ts');
+            }
+            if (!result.rpcInternalMapDeclarationFile) {
+                result.rpcInternalMapDeclarationFile = join(internalRPCDirectory, 'pikku-rpc-wirings-map.internal.gen.d.ts');
+            }
+            // External
             if (!result.rpcWiringMetaFile) {
-                result.rpcWiringMetaFile = join(rpcDir, 'pikku-rpc-wirings-meta.gen.ts');
+                result.rpcWiringMetaFile = join(externalRPCDirectory, 'pikku-rpc-wirings-meta.gen.ts');
             }
             if (!result.rpcMapDeclarationFile) {
-                result.rpcMapDeclarationFile = join(rpcDir, 'pikku-rpc-wirings-map.gen.d.ts');
+                result.rpcMapDeclarationFile = join(externalRPCDirectory, 'pikku-rpc-wirings-map.gen.d.ts');
             }
             // Scheduler
             if (!result.schedulersWiringFile) {

package/dist/src/serialize-import-map.js

@@ -2,7 +2,68 @@ import { getFileImportRelativePath } from './utils.js';
 export const serializeImportMap = (relativeToPath, packageMappings, typesMap, requiredTypes) => {
     const paths = new Map();
     Array.from(requiredTypes).forEach((requiredType) => {
-        const { originalName, uniqueName, path } = typesMap.getTypeMeta(requiredType);
+        let originalName, uniqueName, path;
+        try {
+            const typeMeta = typesMap.getTypeMeta(requiredType);
+            originalName = typeMeta.originalName;
+            uniqueName = typeMeta.uniqueName;
+            path = typeMeta.path;
+        }
+        catch (e) {
+            // Handle missing types by trying to find a suitable import path
+            // Look through all existing types in the map to find a path that might contain this type
+            let foundPath = null;
+            // Get all unique paths from the typesMap
+            const allPaths = new Set();
+            typesMap.customTypes.forEach(({ type, references }) => {
+                references.forEach((ref) => {
+                    try {
+                        const refMeta = typesMap.getTypeMeta(ref);
+                        if (refMeta.path) {
+                            allPaths.add(refMeta.path);
+                        }
+                    }
+                    catch {
+                        // Continue
+                    }
+                });
+            });
+            // Also check direct types in the map
+            try {
+                const mapEntries = typesMap.map?.entries?.() || [];
+                for (const [_, typeMeta] of mapEntries) {
+                    if (typeMeta.path) {
+                        allPaths.add(typeMeta.path);
+                    }
+                }
+            }
+            catch {
+                // Continue
+            }
+            // For PascalCase types, prefer paths that look like type definition files
+            if (/^[A-Z]/.test(requiredType)) {
+                for (const candidatePath of allPaths) {
+                    if (candidatePath.includes('types') ||
+                        candidatePath.includes('.d.')) {
+                        foundPath = candidatePath;
+                        break;
+                    }
+                }
+                // If no types file found, use the first available path
+                if (!foundPath && allPaths.size > 0) {
+                    foundPath = Array.from(allPaths)[0] || null;
+                }
+            }
+            if (foundPath) {
+                originalName = requiredType;
+                uniqueName = requiredType;
+                path = foundPath;
+            }
+            else {
+                // No suitable path found, skip
+                return;
+            }
+        }
         if (!path) {
             // This is a custom type that exists in file, so we don't need to import it
             return;

package/dist/src/serialize-pikku-types.js

@@ -51,7 +51,7 @@ type PikkuFunctionSessionless<
   Out = never, 
   ChannelData = null,  // null means optional channel
   MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Services &
+  RequiredServices extends Services = Omit<Services, 'rpc'> &
     { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null] 
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
@@ -77,7 +77,7 @@ type PikkuFunction<
   Out = never, 
   ChannelData = null,  // null means optional channel
   MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Services &
+  RequiredServices extends Services = Omit<Services, 'rpc'> &
     { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null] 
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel

package/dist/src/utils.js

@@ -206,8 +206,30 @@ export function generateCustomTypes(typesMap, requiredTypes) {
 ${Array.from(typesMap.customTypes.entries())
         .map(([name, { type, references }]) => {
         references.forEach((name) => {
-            const originalName = typesMap.getTypeMeta(name).originalName;
-            requiredTypes.add(originalName);
+            requiredTypes.add(name);
+        });
+        // Extract type names from the type string that might not be in references
+        const typeString = type;
+        // Use regex to extract potential type names (PascalCase identifiers)
+        const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g;
+        const potentialTypes = typeString.match(typeNameRegex) || [];
+        potentialTypes.forEach((typeName) => {
+            // Skip string literals and common keywords
+            if (typeString.includes(`"${typeName}"`) ||
+                ['Pick', 'Omit', 'Partial', 'Required', 'Record', 'Readonly'].includes(typeName)) {
+                return;
+            }
+            // Try to find this type in the typesMap and add it if found
+            try {
+                const typeMeta = typesMap.getTypeMeta(typeName);
+                if (typeMeta.path) {
+                    requiredTypes.add(typeName);
+                }
+            }
+            catch (e) {
+                // Type not found in map, but add it anyway for fallback resolution
+                requiredTypes.add(typeName);
+            }
         });
         return `export type ${name} = ${type}`;
     })

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

@@ -1,13 +1,13 @@
 import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
 import { serializePikkuTypes } from '../../serialize-pikku-types.js';
-export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile }, visitState, options = {}) => {
+export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFile, packageMappings, rpcInternalMapDeclarationFile, }, visitState, options = {}) => {
     return await logCommandInfoAndTime(logger, 'Creating api types', 'Created api types', [false], async () => {
         const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, typesFile, options, {
             userSessionType: true,
             sessionServiceType: true,
             singletonServicesType: true,
         });
-        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`);
+        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcInternalMapDeclarationFile, packageMappings)}'`);
         await writeFileInDir(logger, typesFile, content);
     });
 };

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

@@ -1,6 +1,2 @@
 import { PikkuCommand } from '../../types.js';
-export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
-    path: string;
-    exportedName: string;
-}>, packageMappings?: Record<string, string>) => string;
 export declare const pikkuFunctions: PikkuCommand;

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

@@ -1,35 +1,14 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const serializeFunctionImports = (outputPath, functionsMap, packageMappings = {}) => {
-    const serializedImports = [
-        `/* Import and register RPCs */`,
-        `import { addFunction } from '@pikku/core'`,
-    ];
-    const serializedRegistrations = [];
-    // Sort by function name for consistent output
-    const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
-    for (const [name, { path, exportedName }] of sortedEntries) {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        // For directly exported functions, we can just import and register them
-        if (name === exportedName) {
-            serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
-        }
-        // For renamed functions, we need to import and alias them
-        else {
-            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', ${name})`);
-        }
-    }
-    // Add a blank line between imports and registrations
-    if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
-        serializedImports.push('');
-    }
-    // Combine the imports and registrations
-    return [...serializedImports, ...serializedRegistrations].join('\n');
-};
-export const pikkuFunctions = async (logger, { functionsMetaFile, functionsFile, packageMappings }, { functions }) => {
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+import { generateRuntimeMeta, serializeFunctionImports, } from './serialize-function-imports.js';
+export const pikkuFunctions = async (logger, { functionsMetaFile, functionsMetaMinFile, functionsFile, packageMappings }, { functions, rpc }) => {
     return await logCommandInfoAndTime(logger, 'Serializing Pikku functions', 'Serialized Pikku functions', [false], async () => {
-        await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, functions.files, packageMappings));
+        // 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 runtimeMeta = generateRuntimeMeta(functions.meta);
+        await writeFileInDir(logger, functionsMetaMinFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(runtimeMeta, null, 2)})`);
+        if (rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0) {
+            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, rpc.internalFiles, functions.meta, packageMappings));
+        }
     });
 };

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

@@ -60,7 +60,7 @@ export const serializeServicesMap = (functionsMetaData, middlewareServices = [],
     return code;
 };
 export const pikkuServices = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Generating Pikku services map', 'Generated Pikku services map', [visitState.functions.files.size === 0], async () => {
+    return await logCommandInfoAndTime(logger, 'Generating Pikku services map', 'Generated Pikku services map', [false], async () => {
         const { sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, cliConfig.packageMappings, cliConfig.typesDeclarationFile, {}, {
             sessionServiceType: true,
             singletonServicesType: true,

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

@@ -1,13 +1,13 @@
 import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
 import { serializePikkuTypes } from '../../serialize-pikku-types.js';
-export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile }, visitState, options = {}) => {
+export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFile, packageMappings, rpcInternalMapDeclarationFile, }, visitState, options = {}) => {
     return await logCommandInfoAndTime(logger, 'Creating api types', 'Created api types', [false], async () => {
         const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, typesFile, options, {
             userSessionType: true,
             sessionServiceType: true,
             singletonServicesType: true,
         });
-        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`);
+        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcInternalMapDeclarationFile, packageMappings)}'`);
         await writeFileInDir(logger, typesFile, content);
     });
 };

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

@@ -0,0 +1,6 @@
+import { FunctionsMeta, FunctionsRuntimeMeta } from '@pikku/core';
+export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
+    path: string;
+    exportedName: string;
+}>, functionsMeta: FunctionsMeta, packageMappings?: Record<string, string>) => string;
+export declare const generateRuntimeMeta: (functions: FunctionsMeta) => FunctionsRuntimeMeta;

package/dist/src/wirings/functions/serialize-function-imports.js

@@ -0,0 +1,59 @@
+import { getFileImportRelativePath } from '../../utils.js';
+export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta, packageMappings = {}) => {
+    const serializedImports = [
+        `/* Import and register functions used by RPCs */`,
+        `import { addFunction } from '@pikku/core'`,
+    ];
+    const serializedRegistrations = [];
+    // Sort by function name for consistent output
+    const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [name, { path, exportedName }] of sortedEntries) {
+        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
+        // Find the function metadata to check if it's a direct function
+        // The functionsMeta is keyed by the function name (exported name)
+        const funcMeta = functionsMeta[name];
+        const isDirectFunction = funcMeta?.isDirectFunction ?? false;
+        // For directly exported functions, we can just import and register them
+        if (name === exportedName) {
+            serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
+            if (isDirectFunction) {
+                // Direct function: pikkuFunc(fn) - needs to be wrapped
+                serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
+            }
+            else {
+                // Object format: pikkuFunc({ func: fn }) - can be used directly
+                serializedRegistrations.push(`addFunction('${name}', ${exportedName} as any) // TODO`);
+            }
+        }
+        // For renamed functions, we need to import and alias them
+        else {
+            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
+            if (isDirectFunction) {
+                // Direct function: pikkuFunc(fn) - needs to be wrapped
+                serializedRegistrations.push(`addFunction('${name}', { func: ${name} })`);
+            }
+            else {
+                // Object format: pikkuFunc({ func: fn }) - can be used directly
+                serializedRegistrations.push(`addFunction('${name}', ${name} as any) // TODO`);
+            }
+        }
+    }
+    // Add a blank line between imports and registrations
+    if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
+        serializedImports.push('');
+    }
+    // Combine the imports and registrations
+    return [...serializedImports, ...serializedRegistrations].join('\n');
+};
+export const generateRuntimeMeta = (functions) => {
+    const runtimeMeta = {};
+    for (const [key, { pikkuFuncName, inputSchemaName, outputSchemaName, expose },] of Object.entries(functions)) {
+        runtimeMeta[key] = {
+            pikkuFuncName,
+            inputSchemaName,
+            outputSchemaName,
+            expose,
+        };
+    }
+    return runtimeMeta;
+};

package/dist/src/wirings/rpc/pikku-command-rpc-client.js

@@ -1,7 +1,7 @@
 import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
 import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const pikkuRPCClient = async (logger, { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }) => {
-    return await logCommandInfoAndTime(logger, 'Generating RPC wrapper', 'Generated RPC wrapper', [
+export const pikkuRPCClient = async (logger, { rpcWiringsFile, rpcMapDeclarationFile, rpcInternalMapDeclarationFile, packageMappings, }) => {
+    return await logCommandInfoAndTime(logger, 'Generating RPC wrappers', 'Generated RPC wrappers', [
         rpcWiringsFile === undefined || rpcWiringsFile === null,
         "rpcWiringsFile isn't set in the pikku config",
     ], async () => {

package/dist/src/wirings/rpc/pikku-command-rpc-map.d.ts

@@ -1,2 +1,3 @@
 import { PikkuCommand } from '../../types.js';
-export declare const pikkuRPCMap: PikkuCommand;
+export declare const pikkuRPCInternalMap: PikkuCommand;
+export declare const pikkuRPCExposedMap: PikkuCommand;

package/dist/src/wirings/rpc/pikku-command-rpc-map.js

@@ -1,8 +1,14 @@
 import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
 import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';
-export const pikkuRPCMap = async (logger, { rpcMapDeclarationFile, packageMappings }, { functions, rpc }) => {
-    return await logCommandInfoAndTime(logger, 'Creating RPC map', 'Created RPC map', [false], async () => {
-        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.meta);
+export const pikkuRPCInternalMap = async (logger, { rpcInternalMapDeclarationFile, packageMappings }, { functions, rpc }) => {
+    return await logCommandInfoAndTime(logger, 'Creating RPC internal map', 'Created RPC internal map', [false], async () => {
+        const content = serializeTypedRPCMap(rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.internalMeta);
+        await writeFileInDir(logger, rpcInternalMapDeclarationFile, content);
+    });
+};
+export const pikkuRPCExposedMap = async (logger, { rpcMapDeclarationFile, packageMappings }, { functions, rpc }) => {
+    return await logCommandInfoAndTime(logger, 'Creating RPC external map', 'Created RPC external map', [false], async () => {
+        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.exposedMeta);
         await writeFileInDir(logger, rpcMapDeclarationFile, content);
     });
 };

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

@@ -1,6 +1,11 @@
 import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-export const pikkuRPC = async (logger, { rpcWiringMetaFile }, { rpc }) => {
+export const pikkuRPC = async (logger, { rpcInternalWiringMetaFile, rpcWiringMetaFile }, { rpc }) => {
     return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
-        await writeFileInDir(logger, rpcWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
+        if (rpc.internalFiles.size > 0) {
+            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`);
+        }
+        if (rpc.exposedFiles.size > 0) {
+            await writeFileInDir(logger, rpcWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.exposedFiles, null, 2)})`);
+        }
     });
 };

package/dist/src/wirings/rpc/serialize-typed-rpc-map.d.ts

@@ -1,4 +1,3 @@
-import type { RPCMeta } from '@pikku/core/rpc';
 import { TypesMap } from '@pikku/inspector';
 import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, RPCMeta>) => string;
+export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, string>) => string;

package/dist/src/wirings/rpc/serialize-typed-rpc-map.js

@@ -31,6 +31,7 @@ export type TypedPikkuRPC = {
   depth: number;
   global: boolean;
   invoke: RPCInvoke;
+  invokeExposed: (name: string, data: any) => Promise<any> 
 }
   `;
 };
@@ -38,7 +39,7 @@ function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
     // Initialize an object to collect RPCs
     const rpcsObj = {};
     // Iterate through RPC metadata
-    for (const [funcName, { pikkuFuncName }] of Object.entries(rpcMeta)) {
+    for (const [funcName, pikkuFuncName] of Object.entries(rpcMeta)) {
         const functionMeta = functionsMeta[pikkuFuncName];
         if (!functionMeta) {
             throw new Error(`Function ${funcName} not found in functionsMeta. Please check your configuration.`);

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../bin/pikku-all.ts","../bin/pikku-fetch.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-queue-service.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/pikku-command-schemas.ts","../src/schema-generator.ts","../src/schemas.ts","../src/serialize-import-map.ts","../src/serialize-pikku-types.ts","../src/types.ts","../src/utils.ts","../src/runtimes/nextjs/pikku-command-nextjs.ts","../src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts","../src/wirings/channels/pikku-channels.ts","../src/wirings/channels/pikku-command-channels-map.ts","../src/wirings/channels/pikku-command-channels.ts","../src/wirings/channels/pikku-command-websocket-typed.ts","../src/wirings/channels/serialize-typed-channel-map.ts","../src/wirings/channels/serialize-websocket-wrapper.ts","../src/wirings/fetch/index.ts","../src/wirings/functions/pikku-command-function-types.ts","../src/wirings/functions/pikku-command-functions.ts","../src/wirings/functions/pikku-command-services.ts","../src/wirings/functions/pikku-function-types.ts","../src/wirings/functions/pikku-functions.ts","../src/wirings/http/openapi-spec-generator.ts","../src/wirings/http/pikku-command-http-map.ts","../src/wirings/http/pikku-command-http-routes.ts","../src/wirings/http/pikku-command-openapi.ts","../src/wirings/http/pikku-http-routes.ts","../src/wirings/http/serialize-fetch-wrapper.ts","../src/wirings/http/serialize-typed-http-map.ts","../src/wirings/mcp/pikku-command-mcp-json.ts","../src/wirings/mcp/pikku-command-mcp.ts","../src/wirings/mcp/serialize-mcp-json.ts","../src/wirings/queue/pikku-command-queue-map.ts","../src/wirings/queue/pikku-command-queue-service.ts","../src/wirings/queue/pikku-command-queue.ts","../src/wirings/queue/pikku-queue-map.ts","../src/wirings/queue/pikku-queue.ts","../src/wirings/queue/serialize-queue-map.ts","../src/wirings/queue/serialize-queue-meta.ts","../src/wirings/queue/serialize-queue-wrapper.ts","../src/wirings/rpc/pikku-command-rpc-client.ts","../src/wirings/rpc/pikku-command-rpc-map.ts","../src/wirings/rpc/pikku-command-rpc.ts","../src/wirings/rpc/pikku-rpc.ts","../src/wirings/rpc/serialize-rpc-wrapper.ts","../src/wirings/rpc/serialize-typed-rpc-map.ts","../src/wirings/scheduler/pikku-command-scheduler.ts","../src/wirings/scheduler/serialize-scheduler-meta.ts"],"version":"5.9.2"}
+{"root":["../bin/pikku-all.ts","../bin/pikku-fetch.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-queue-service.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/pikku-command-schemas.ts","../src/schema-generator.ts","../src/schemas.ts","../src/serialize-import-map.ts","../src/serialize-pikku-types.ts","../src/types.ts","../src/utils.ts","../src/runtimes/nextjs/pikku-command-nextjs.ts","../src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts","../src/wirings/channels/pikku-channels.ts","../src/wirings/channels/pikku-command-channels-map.ts","../src/wirings/channels/pikku-command-channels.ts","../src/wirings/channels/pikku-command-websocket-typed.ts","../src/wirings/channels/serialize-typed-channel-map.ts","../src/wirings/channels/serialize-websocket-wrapper.ts","../src/wirings/fetch/index.ts","../src/wirings/functions/pikku-command-function-types.ts","../src/wirings/functions/pikku-command-functions.ts","../src/wirings/functions/pikku-command-services.ts","../src/wirings/functions/pikku-function-types.ts","../src/wirings/functions/serialize-function-imports.ts","../src/wirings/http/openapi-spec-generator.ts","../src/wirings/http/pikku-command-http-map.ts","../src/wirings/http/pikku-command-http-routes.ts","../src/wirings/http/pikku-command-openapi.ts","../src/wirings/http/pikku-http-routes.ts","../src/wirings/http/serialize-fetch-wrapper.ts","../src/wirings/http/serialize-typed-http-map.ts","../src/wirings/mcp/pikku-command-mcp-json.ts","../src/wirings/mcp/pikku-command-mcp.ts","../src/wirings/mcp/serialize-mcp-json.ts","../src/wirings/queue/pikku-command-queue-map.ts","../src/wirings/queue/pikku-command-queue-service.ts","../src/wirings/queue/pikku-command-queue.ts","../src/wirings/queue/pikku-queue-map.ts","../src/wirings/queue/pikku-queue.ts","../src/wirings/queue/serialize-queue-map.ts","../src/wirings/queue/serialize-queue-meta.ts","../src/wirings/queue/serialize-queue-wrapper.ts","../src/wirings/rpc/pikku-command-rpc-client.ts","../src/wirings/rpc/pikku-command-rpc-map.ts","../src/wirings/rpc/pikku-command-rpc.ts","../src/wirings/rpc/serialize-rpc-wrapper.ts","../src/wirings/rpc/serialize-typed-rpc-map.ts","../src/wirings/scheduler/pikku-command-scheduler.ts","../src/wirings/scheduler/serialize-scheduler-meta.ts"],"version":"5.9.2"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.0.2",
-    "@pikku/core": "^0.9.2",
-    "@pikku/inspector": "^0.9.2",
+    "@pikku/core": "^0.9.3",
+    "@pikku/inspector": "^0.9.3",
     "@types/cookie": "^1.0.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.5.0",