@pikku/cli 0.9.2 → 0.9.4

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-rpc.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.4",
   "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.4",
+    "@pikku/inspector": "^0.9.3",
     "@types/cookie": "^1.0.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.5.0",

package/src/pikku-cli-config.ts

@@ -15,6 +15,7 @@ export interface PikkuCLICoreOutputFiles {
   // Function definitions
   functionsFile: string
   functionsMetaFile: string
+  functionsMetaMinFile: string
 
   // HTTP
   httpWiringsFile: string
@@ -26,7 +27,11 @@ export interface PikkuCLICoreOutputFiles {
   channelsWiringMetaFile: string
   channelsMapDeclarationFile: string
 
-  // RPC
+  // RPC Internal
+  rpcInternalWiringMetaFile: string
+  rpcInternalMapDeclarationFile: string
+
+  // RPC Exposed
   rpcWiringMetaFile: string
   rpcMapDeclarationFile: string
 
@@ -166,7 +171,8 @@ const _getPikkuCLIConfig = async (
       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')
@@ -187,6 +193,12 @@ const _getPikkuCLIConfig = async (
           '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')
       }
@@ -225,13 +237,31 @@ const _getPikkuCLIConfig = async (
         )
       }
 
-      // 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,
+          externalRPCDirectory,
           'pikku-rpc-wirings-map.gen.d.ts'
         )
       }

package/src/serialize-import-map.ts

@@ -9,8 +9,73 @@ export const serializeImportMap = (
 ) => {
   const paths = new Map<string, string[]>()
   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: string | null = null
+
+      // Get all unique paths from the typesMap
+      const allPaths = new Set<string>()
+      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 as any).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/src/serialize-pikku-types.ts

@@ -13,7 +13,7 @@ export const serializePikkuTypes = (
 * This is used to provide the application types in the typescript project
 */
   
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, addHTTPMiddleware } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, addHTTPMiddleware, addMiddleware, addMiddlewareForTags, addPermission } from '@pikku/core'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
 import { CoreHTTPFunctionWiring, AssertHTTPWiringParams, wireHTTP as wireHTTPCore } from '@pikku/core/http'
 import { CoreScheduledTask, wireScheduler as wireSchedulerCore } from '@pikku/core/scheduler'
@@ -58,7 +58,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
@@ -84,7 +84,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
@@ -118,7 +118,7 @@ type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<ChannelDat
  * Type definition for scheduled tasks that run at specified intervals.
  * These are sessionless functions that execute based on cron expressions.
  */
-type SchedulerWiring = CoreScheduledTask<PikkuFunctionSessionless<void, void>>
+type SchedulerWiring = CoreScheduledTask<PikkuFunctionSessionless<void, void>, PikkuMiddleware>
 
 /**
  * Type definition for queue workers that process background jobs.
@@ -201,7 +201,7 @@ export const pikkuFunc = <In, Out = unknown>(
 export const pikkuSessionlessFunc = <In, Out = unknown>(
   func:
     | PikkuFunctionSessionless<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out>, PikkuPermission<In>>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
 ) => {
   return typeof func === 'function' ? func : func.func
 }
@@ -351,6 +351,78 @@ export const wireChannel = <ChannelData, Channel extends string>(
  */
 export { addHTTPMiddleware }
 
+/**
+ * Adds global middleware for a specific tag.
+ * 
+ * This function allows you to register middleware that will be applied to 
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ * 
+ * @param tag - The tag that the middleware should apply to.
+ * @param middleware - The middleware array to apply for the specified tag.
+ * 
+ * @throws Error if middleware for the tag already exists.
+ * 
+ * @example
+ * \`\`\`typescript
+ * // Add admin middleware for admin endpoints
+ * addMiddleware('admin', [adminMiddleware])
+ * 
+ * // Add authentication middleware for auth endpoints
+ * addMiddleware('auth', [authMiddleware])
+ * 
+ * // Add logging middleware for all API endpoints  
+ * addMiddleware('api', [loggingMiddleware])
+ * \`\`\`
+ */
+export { addMiddleware }
+
+/**
+ * Combines tag-based middleware with wiring-specific middleware.
+ * 
+ * This helper function gets middleware for tags and combines it with any
+ * wiring-specific middleware, avoiding the need for manual spreading.
+ * 
+ * @param wiringMiddleware - Wiring-specific middleware.
+ * @param tags - Array of tags to look up middleware for.
+ * @returns Combined array of tag-based and wiring-specific middleware.
+ * 
+ * @example
+ * \`\`\`typescript
+ * // Instead of:
+ * const taggedMiddleware = getMiddlewareForTags(tags)
+ * const combined = [...taggedMiddleware, ...(middleware || [])]
+ * 
+ * // Use:
+ * const combined = addMiddlewareForTags(middleware, tags)
+ * \`\`\`
+ */
+export { addMiddlewareForTags }
+
+/**
+ * Adds global permissions for a specific tag.
+ * 
+ * This function allows you to register permissions that will be applied to 
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ * 
+ * @param tag - The tag that the permissions should apply to.
+ * @param permissions - The permissions array to apply for the specified tag.
+ * 
+ * @throws Error if permissions for the tag already exist.
+ * 
+ * @example
+ * \`\`\`typescript
+ * // Add admin permissions for admin endpoints
+ * addPermission('admin', [adminPermission])
+ * 
+ * // Add authentication permissions for auth endpoints
+ * addPermission('auth', [authPermission])
+ * 
+ * // Add read permissions for all API endpoints
+ * addPermission('api', [readPermission])
+ * \`\`\`
+ */
+export { addPermission }
+
 /**
  * Registers an HTTP wiring with the Pikku framework.
  * 

package/src/utils.ts

@@ -371,9 +371,38 @@ export function generateCustomTypes(
 ${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}`
   })
   .join('\n')}`

package/src/wirings/functions/pikku-command-function-types.ts

@@ -9,7 +9,11 @@ import { PikkuCommand } from '../../types.js'
 
 export const pikkuFunctionTypes: PikkuCommand = async (
   logger,
-  { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile },
+  {
+    typesDeclarationFile: typesFile,
+    packageMappings,
+    rpcInternalMapDeclarationFile,
+  },
   visitState,
   options = {}
 ) => {
@@ -39,7 +43,7 @@ export const pikkuFunctionTypes: PikkuCommand = async (
         `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)}'`
+        `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcInternalMapDeclarationFile, packageMappings)}'`
       )
 
       await writeFileInDir(logger, typesFile, content)

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

@@ -1,63 +1,14 @@
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  writeFileInDir,
-} from '../../utils.js'
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
 import { PikkuCommand } from '../../types.js'
-
-export const serializeFunctionImports = (
-  outputPath: string,
-  functionsMap: Map<string, { path: string; exportedName: string }>,
-  packageMappings: Record<string, string> = {}
-) => {
-  const serializedImports: string[] = [
-    `/* Import and register RPCs */`,
-    `import { addFunction } from '@pikku/core'`,
-  ]
-
-  const serializedRegistrations: string[] = []
-
-  // 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')
-}
+import {
+  generateRuntimeMeta,
+  serializeFunctionImports,
+} from './serialize-function-imports.js'
 
 export const pikkuFunctions: PikkuCommand = async (
   logger,
-  { functionsMetaFile, functionsFile, packageMappings },
-  { functions }
+  { functionsMetaFile, functionsMetaMinFile, functionsFile, packageMappings },
+  { functions, rpc }
 ) => {
   return await logCommandInfoAndTime(
     logger,
@@ -65,20 +16,33 @@ export const pikkuFunctions: PikkuCommand = async (
     'Serialized Pikku functions',
     [false],
     async () => {
+      // Generate full metadata
       await writeFileInDir(
         logger,
-        functionsFile,
-        serializeFunctionImports(
-          functionsFile,
-          functions.files,
-          packageMappings
-        )
+        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,
-        functionsMetaFile,
-        `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
+        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/src/wirings/functions/pikku-command-services.ts

@@ -95,7 +95,7 @@ export const pikkuServices: PikkuCommand = async (
     logger,
     'Generating Pikku services map',
     'Generated Pikku services map',
-    [visitState.functions.files.size === 0],
+    [false],
     async () => {
       const { sessionServicesType, singletonServicesType } =
         await getPikkuFilesAndMethods(

package/src/wirings/functions/pikku-function-types.ts

@@ -9,7 +9,11 @@ import { PikkuCommand } from '../../types.js'
 
 export const pikkuFunctionTypes: PikkuCommand = async (
   logger,
-  { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile },
+  {
+    typesDeclarationFile: typesFile,
+    packageMappings,
+    rpcInternalMapDeclarationFile,
+  },
   visitState,
   options = {}
 ) => {
@@ -39,7 +43,7 @@ export const pikkuFunctionTypes: PikkuCommand = async (
         `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)}'`
+        `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcInternalMapDeclarationFile, packageMappings)}'`
       )
       await writeFileInDir(logger, typesFile, content)
     }