@pikku/cli 0.11.2 → 0.11.3

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

@@ -1,31 +1,46 @@
 import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { generateRuntimeMeta, serializeFunctionImports, } from './serialize-function-imports.js';
+import { serializeFunctionImports } from './serialize-function-imports.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuFunctions = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc } = await getInspectorState();
-        const { functionsMetaFile, functionsMetaJsonFile, functionsMetaMinFile, functionsMetaMinJsonFile, functionsFile, packageMappings, schema, } = config;
-        await writeFileInDir(logger, functionsMetaJsonFile, JSON.stringify(functions.meta, null, 2));
-        const fullJsonImportPath = getFileImportRelativePath(functionsMetaFile, functionsMetaJsonFile, packageMappings);
+        const { functionsMetaFile, functionsMetaJsonFile, functionsFile, packageMappings, schema, } = config;
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(functions.meta);
+        await writeFileInDir(logger, functionsMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(functions.meta)) {
+            const verbosePath = functionsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(functions.meta, null, 2));
+        }
+        const jsonImportPath = getFileImportRelativePath(functionsMetaFile, functionsMetaJsonFile, packageMappings);
         const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const fullImportStatement = supportsImportAttributes
-            ? `import metaData from '${fullJsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${fullJsonImportPath}'`;
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState, FunctionsMeta } from '@pikku/core'\n${fullImportStatement}\npikkuState('function', 'meta', metaData as FunctionsMeta)`);
-        const runtimeMeta = generateRuntimeMeta(functions.meta);
-        await writeFileInDir(logger, functionsMetaMinJsonFile, JSON.stringify(runtimeMeta, null, 2));
-        const minJsonImportPath = getFileImportRelativePath(functionsMetaMinFile, functionsMetaMinJsonFile, packageMappings);
-        const minImportStatement = supportsImportAttributes
-            ? `import metaData from '${minJsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${minJsonImportPath}'`;
-        await writeFileInDir(logger, functionsMetaMinFile, `import { pikkuState, FunctionsRuntimeMeta } from '@pikku/core'\n${minImportStatement}\npikkuState('function', 'meta', metaData as FunctionsRuntimeMeta)`);
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
+        const packageName = config.externalPackageName
+            ? `'${config.externalPackageName}'`
+            : 'null';
+        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState, FunctionsMeta } from '@pikku/core'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`);
+        // For external packages, register ALL functions (they'll be invoked by consumers)
+        // For main packages, only register functions that are invoked via internal RPCs
+        const isExternalPackage = !!config.externalPackageName;
         const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0;
-        if (hasRPCs) {
-            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, rpc.internalFiles, functions.meta, packageMappings));
+        const hasFunctions = functions.files.size > 0;
+        const shouldGenerateFunctionsFile = isExternalPackage
+            ? hasFunctions
+            : hasRPCs;
+        if (shouldGenerateFunctionsFile) {
+            // For external packages, use all function files; for main packages, use internal RPC files
+            const filesToRegister = isExternalPackage
+                ? functions.files
+                : rpc.internalFiles;
+            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, filesToRegister, functions.meta, packageMappings, config.externalPackageName));
         }
-        return hasRPCs;
+        return shouldGenerateFunctionsFile;
     },
     middleware: [
         logCommandInfoAndTime({

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

@@ -30,7 +30,7 @@ export const serializeServicesMap = (allSingletonServices, allWireServices, requ
         }
     });
     // Services that are always required internally by the framework
-    const defaultServices = ['config', 'logger', 'variables', 'schema'];
+    const defaultServices = ['config', 'logger', 'variables', 'schema', 'secrets'];
     defaultServices.forEach((service) => usedServices.add(service));
     // Create singleton services map: all singleton services with true/false based on usage
     const singletonServicesMap = {};

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

@@ -5,8 +5,8 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
 export const pikkuFunctionTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, } = config;
-        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings));
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, forgeTypesFile, } = config;
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings), getFileImportRelativePath(typesFile, forgeTypesFile, packageMappings));
         await writeFileInDir(logger, typesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/functions/schemas.d.ts

@@ -1,4 +1,4 @@
 /**
- * Generate JSON schemas from TypeScript types
+ * Generate JSON schemas from TypeScript types and Zod schemas
  */
 export declare const pikkuSchemas: any;

package/dist/src/functions/wirings/functions/schemas.js

@@ -1,14 +1,15 @@
 import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { saveSchemas, generateSchemas, } from '../../../utils/schema-generator.js';
+import { saveSchemas, generateSchemas, generateZodSchemas, } from '../../../utils/schema-generator.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 /**
- * Generate JSON schemas from TypeScript types
+ * Generate JSON schemas from TypeScript types and Zod schemas
  */
 export const pikkuSchemas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes, config.schema?.additionalProperties);
-        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.schema?.supportsImportAttributes || true, config.schemasFromTypes);
+        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes, config.schema?.additionalProperties, visitState.zodLookup);
+        const zodSchemas = await generateZodSchemas(logger, visitState.zodLookup, visitState.functions.typesMap);
+        await saveSchemas(logger, config.schemaDirectory, { ...schemas, ...zodSchemas }, visitState.functions.typesMap, visitState.functions.meta, config.schema?.supportsImportAttributes || true, config.schemasFromTypes, visitState.zodLookup, config.externalPackageName || null);
         return true;
     },
     middleware: [

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

@@ -2,5 +2,7 @@ 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;
+}>, functionsMeta: FunctionsMeta, packageMappings?: Record<string, string>, 
+/** Package name for external packages (e.g., '@pikku/templates-function-external') */
+externalPackageName?: string) => string;
 export declare const generateRuntimeMeta: (functions: FunctionsMeta) => FunctionsRuntimeMeta;

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

@@ -1,5 +1,7 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta, packageMappings = {}) => {
+export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta, packageMappings = {}, 
+/** Package name for external packages (e.g., '@pikku/templates-function-external') */
+externalPackageName) => {
     const serializedImports = [
         `/* Import and register functions used by RPCs */`,
         `import { addFunction } from '@pikku/core'`,
@@ -7,18 +9,20 @@ export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta
     const serializedRegistrations = [];
     // Sort by function name for consistent output
     const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    // Third argument to addFunction is the package name (null for main package)
+    const packageArg = externalPackageName ? `, '${externalPackageName}'` : '';
     for (const [name, { path, exportedName }] of sortedEntries) {
         const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
         // pikkuFunc/pikkuSessionlessFunc/pikkuVoidFunc always return config objects
         // For directly exported functions, we can just import and register them
         if (name === exportedName) {
             serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', ${exportedName})`);
+            serializedRegistrations.push(`addFunction('${name}', ${exportedName}${packageArg})`);
         }
         // For renamed functions, we need to import and alias them
         else {
             serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', ${name})`);
+            serializedRegistrations.push(`addFunction('${name}', ${name}${packageArg})`);
         }
     }
     // Add a blank line between imports and registrations

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

@@ -1,4 +1,4 @@
 /**
  * Generates core function, middleware, and permission type definitions
  */
-export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, wireServicesTypeImport: string, wireServicesTypeName: string, rpcMapTypeImport: string, requiredServicesTypeImport: string, configTypeImport: string) => string;
+export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, wireServicesTypeImport: string, wireServicesTypeName: string, rpcMapTypeImport: string, requiredServicesTypeImport: string, configTypeImport: string, packageName?: string) => string;

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

@@ -1,12 +1,13 @@
 /**
  * Generates core function, middleware, and permission type definitions
  */
-export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, wireServicesTypeImport, wireServicesTypeName, rpcMapTypeImport, requiredServicesTypeImport, configTypeImport) => {
+export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, wireServicesTypeImport, wireServicesTypeName, rpcMapTypeImport, requiredServicesTypeImport, configTypeImport, packageName) => {
+    const packageNameValue = packageName ? `'${packageName}'` : 'null';
     return `/**
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired, ZodLike, CreateWireServices } from '@pikku/core'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
 
 ${userSessionTypeImport}
@@ -208,6 +209,11 @@ export type PikkuFunction<
     PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any>, RequiredWires>
   >
 
+/**
+ * Helper type to infer the output type from a Zod schema
+ */
+export type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never
+
 /**
  * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
  * This type wraps CorePikkuFunctionConfig with the user's custom types.
@@ -220,64 +226,166 @@ export type PikkuFunctionConfig<
   In = unknown,
   Out = unknown,
   RequiredWires extends keyof PikkuWire = never,
-  PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>
-> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>
+  PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>,
+  InputSchema extends ZodLike | undefined = undefined,
+  OutputSchema extends ZodLike | undefined = undefined
+> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema>
+
+/**
+ * Configuration object for Pikku functions with Zod schema validation.
+ * Use this when you want to define input/output schemas using Zod.
+ * Types are automatically inferred from the schemas.
+ */
+export type PikkuFunctionConfigWithSchema<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined,
+  RequiredWires extends keyof PikkuWire = never
+> = {
+  name?: string
+  tags?: string[]
+  expose?: boolean
+  internal?: boolean
+  func: PikkuFunction<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  > | PikkuFunctionSessionless<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  >
+  auth?: boolean
+  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  middleware?: PikkuMiddleware[]
+  input: InputSchema
+  output?: OutputSchema
+}
 
 /**
  * Creates a Pikku function that can be either session-aware or sessionless.
  * This is the main function wrapper for creating API endpoints.
  *
- * @template In - Input type for the function
- * @template Out - Output type for the function
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuFunc<Input, Output>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuFunc({ input: z.object(...), output: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the function (inferred from schema if provided)
+ * @template Out - Output type for the function (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
  *
  * @example
- * \\\`\\\`\\\`typescript
- * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
- *   func: async ({db, logger}, input, wire) => {
- *     const session = await wire.session.get()
- *     logger.info('Creating user', input.name)
+ * \`\`\`typescript
+ * // Pattern 1: Using generic types
+ * const createUser = pikkuFunc<{name: string, email: string}, {id: number}>({
+ *   func: async ({db}, input) => {
  *     const user = await db.users.create(input)
- *     return {id: user.id, message: \\\`User \\\${input.name} created successfully\\\`}
- *   },
- *   auth: true
+ *     return { id: user.id }
+ *   }
  * })
- * \\\`\\\`\\\`
+ *
+ * // Pattern 2: Using Zod schemas (types inferred automatically)
+ * const createUserInput = z.object({ name: z.string(), email: z.string() })
+ * const createUserOutput = z.object({ id: z.number() })
+ *
+ * const createUser = pikkuFunc({
+ *   input: createUserInput,
+ *   output: createUserOutput,
+ *   func: async ({db}, input) => {
+ *     // input is typed as { name: string, email: string }
+ *     const user = await db.users.create(input)
+ *     return { id: user.id } // must match output schema
+ *   }
+ * })
+ * \`\`\`
  */
-export const pikkuFunc = <In, Out = unknown>(
+export function pikkuFunc<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined
+>(
+  config: PikkuFunctionConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+export function pikkuFunc<In, Out = unknown>(
   func:
     | PikkuFunction<In, Out, 'session' | 'rpc'>
     | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
-) => {
+): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
+export function pikkuFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration object for sessionless Pikku functions with Zod schema validation.
+ */
+export type PikkuFunctionSessionlessConfigWithSchema<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined,
+  RequiredWires extends keyof PikkuWire = never
+> = {
+  name?: string
+  description?: string
+  tags?: string[]
+  expose?: boolean
+  internal?: boolean
+  func: PikkuFunctionSessionless<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  >
+  auth?: boolean
+  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  middleware?: PikkuMiddleware[]
+  input: InputSchema
+  output?: OutputSchema
+}
+
 /**
  * Creates a sessionless Pikku function that doesn't require user authentication.
  * Use this for public endpoints, webhooks, or background tasks.
  *
- * @template In - Input type for the function
- * @template Out - Output type for the function
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuSessionlessFunc<Input, Output>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuSessionlessFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the function (inferred from schema if provided)
+ * @template Out - Output type for the function (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
  *
  * @example
- * \\\`\\\`\\\`typescript
- * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
- *   func: async ({logger}, input) => {
- *     logger.info('Health check requested')
- *     return {status: 'healthy', timestamp: new Date().toISOString()}
- *   },
- *   name: 'healthCheck'
+ * \`\`\`typescript
+ * // Pattern 1: Using generic types
+ * const healthCheck = pikkuSessionlessFunc<void, {status: string}>({
+ *   func: async ({logger}) => {
+ *     return { status: 'healthy' }
+ *   }
+ * })
+ *
+ * // Pattern 2: Using Zod schemas
+ * const greetInput = z.object({ name: z.string() })
+ * const greetOutput = z.object({ message: z.string() })
+ *
+ * const greet = pikkuSessionlessFunc({
+ *   input: greetInput,
+ *   output: greetOutput,
+ *   func: async (_services, { name }) => {
+ *     return { message: \`Hello, \${name}!\` }
+ *   }
  * })
- * \\\`\\\`\\\`
+ * \`\`\`
  */
-export const pikkuSessionlessFunc = <In, Out = unknown>(
+export function pikkuSessionlessFunc<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined
+>(
+  config: PikkuFunctionSessionlessConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+export function pikkuSessionlessFunc<In, Out = unknown>(
   func:
     | PikkuFunctionSessionless<In, Out, 'session' | 'rpc'>
     | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
-) => {
+): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
+export function pikkuSessionlessFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
@@ -289,13 +397,13 @@ export const pikkuSessionlessFunc = <In, Out = unknown>(
  * @returns The normalized configuration object
  *
  * @example
- * \\\`\\\`\\\`typescript
+ * \`\`\`typescript
  * const cleanupTempFiles = pikkuVoidFunc(async ({fileSystem, logger}) => {
  *     logger.info('Starting cleanup of temporary files')
  *     await fileSystem.deleteDirectory('/tmp/uploads')
  *     logger.info('Cleanup completed')
  * })
- * \\\`\\\`\\\`
+ * \`\`\`
  */
 export const pikkuVoidFunc = (
   func:
@@ -305,6 +413,45 @@ export const pikkuVoidFunc = (
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Creates a wrapper function for external package functions that are exposed via RPC.
+ * This allows you to wire external functions to any wiring type (HTTP, queue, etc.)
+ * without type compatibility issues.
+ *
+ * @template Name - The RPC method name (must be a key in FlattenedRPCMap)
+ * @param rpcName - The name of the RPC method to invoke
+ * @returns A Pikku function that proxies calls to the external RPC method
+ *
+ * @example
+ * \`\`\`typescript
+ * // Wire an external function via HTTP
+ * wireHTTP({
+ *   auth: false,
+ *   method: 'get',
+ *   route: '/external/hello',
+ *   func: external('ext:hello'),
+ *   tags: ['external'],
+ * })
+ * \`\`\`
+ */
+export const external = <Name extends keyof FlattenedRPCMap>(
+  rpcName: Name
+): PikkuFunctionConfig<
+  FlattenedRPCMap[Name]['input'],
+  FlattenedRPCMap[Name]['output'],
+  'session' | 'rpc'
+> => {
+  return {
+    func: (async (_services: any, data: any, { rpc }: any) => {
+      return rpc.invoke(rpcName, data)
+    }) as any
+  } as PikkuFunctionConfig<
+    FlattenedRPCMap[Name]['input'],
+    FlattenedRPCMap[Name]['output'],
+    'session' | 'rpc'
+  >
+}
+
 /**
  * Creates a Pikku config factory.
  * Use this to define your application's configuration factory.
@@ -370,7 +517,7 @@ export const pikkuWireServices = (
     services: SingletonServices,
     wire: any
   ) => Promise<RequiredWireServices>
-) => func
+): CreateWireServices => func as unknown as CreateWireServices
 
 /**
  * Adds global middleware for a specific tag.
@@ -396,7 +543,7 @@ export const pikkuWireServices = (
  * \`\`\`
  */
 export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
-  addMiddlewareCore(tag, middleware as any)
+  addMiddlewareCore(tag, middleware as any, ${packageNameValue})
 }
 
 /**
@@ -423,7 +570,7 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
  * \`\`\`
  */
 export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
-  addPermissionCore(tag, permissions as any)
+  addPermissionCore(tag, permissions as any, ${packageNameValue})
 }
 `;
 };

package/dist/src/functions/wirings/functions/serialize-pikku-types-hub.d.ts

@@ -1,4 +1,4 @@
 /**
  * Generates the main pikku-types.gen.ts file as a re-export hub
  */
-export declare const serializePikkuTypesHub: (functionTypesImportPath: string, httpTypesImportPath: string, channelTypesImportPath: string, schedulerTypesImportPath: string, queueTypesImportPath: string, mcpTypesImportPath: string, cliTypesImportPath: string) => string;
+export declare const serializePikkuTypesHub: (functionTypesImportPath: string, httpTypesImportPath: string | null, channelTypesImportPath: string | null, schedulerTypesImportPath: string | null, queueTypesImportPath: string | null, mcpTypesImportPath: string | null, cliTypesImportPath: string | null, forgeTypesImportPath: string | null) => string;

package/dist/src/functions/wirings/functions/serialize-pikku-types-hub.js

@@ -1,30 +1,28 @@
 /**
  * Generates the main pikku-types.gen.ts file as a re-export hub
  */
-export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportPath, channelTypesImportPath, schedulerTypesImportPath, queueTypesImportPath, mcpTypesImportPath, cliTypesImportPath) => {
+export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportPath, channelTypesImportPath, schedulerTypesImportPath, queueTypesImportPath, mcpTypesImportPath, cliTypesImportPath, forgeTypesImportPath) => {
+    const exports = [
+        {
+            comment: 'Core function, middleware, and permission types',
+            path: functionTypesImportPath,
+        },
+        { comment: 'HTTP wiring types', path: httpTypesImportPath },
+        { comment: 'Channel wiring types', path: channelTypesImportPath },
+        { comment: 'Scheduler wiring types', path: schedulerTypesImportPath },
+        { comment: 'Queue wiring types', path: queueTypesImportPath },
+        { comment: 'MCP wiring types', path: mcpTypesImportPath },
+        { comment: 'CLI wiring types', path: cliTypesImportPath },
+        { comment: 'Forge wiring types', path: forgeTypesImportPath },
+    ];
+    const exportStatements = exports
+        .filter((e) => e.path)
+        .map((e) => `// ${e.comment}\nexport * from '${e.path}'`)
+        .join('\n\n');
     return `/**
  * Main type export hub - re-exports all wiring-specific types
  */
 
-// Core function, middleware, and permission types
-export * from '${functionTypesImportPath}'
-
-// HTTP wiring types
-export * from '${httpTypesImportPath}'
-
-// Channel wiring types
-export * from '${channelTypesImportPath}'
-
-// Scheduler wiring types
-export * from '${schedulerTypesImportPath}'
-
-// Queue wiring types
-export * from '${queueTypesImportPath}'
-
-// MCP wiring types
-export * from '${mcpTypesImportPath}'
-
-// CLI wiring types
-export * from '${cliTypesImportPath}'
+${exportStatements}
 `;
 };

package/dist/src/functions/wirings/http/openapi-spec-generator.js

@@ -2,7 +2,7 @@ import { pikkuState } from '@pikku/core';
 import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema';
 const convertSchema = 'default' in _convertSchema ? _convertSchema.default : _convertSchema;
 const getErrorResponseForConstructorName = (constructorName) => {
-    const errors = Array.from(pikkuState('misc', 'errors').entries());
+    const errors = Array.from(pikkuState(null, 'misc', 'errors').entries());
     const foundError = errors.find(([e]) => e.name === constructorName);
     if (foundError) {
         return foundError[1];

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

@@ -2,13 +2,29 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuHTTP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config;
+        const { httpWiringsFile, httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings, schema, } = config;
         const { http } = visitState;
         await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(http.meta);
+        await writeFileInDir(logger, httpWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(http.meta)) {
+            const verbosePath = httpWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(http.meta, null, 2));
+        }
+        // Generate TypeScript file that imports the minimal JSON
+        const jsonImportPath = getFileImportRelativePath(httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [

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

@@ -15,8 +15,8 @@ export const pikkuOpenAPI = pikkuSessionlessFunc({
             });
             return;
         }
-        const { http, functions } = await getInspectorState();
-        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes, config.schema?.additionalProperties);
+        const { http, functions, zodLookup } = await getInspectorState();
+        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes, config.schema?.additionalProperties, zodLookup);
         const openAPISpec = await generateOpenAPISpec(logger, functions.meta, http.meta, schemas, openAPI.additionalInfo);
         if (openAPI.outputFile.endsWith('.json')) {
             await writeFileInDir(logger, openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), { ignoreModifyComment: true });

package/dist/src/functions/wirings/http/pikku-http-routes.js

@@ -15,7 +15,7 @@ export const pikkuHTTP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState, HTTPWiringsMeta } from '@pikku/core'\n${importStatement}\npikkuState('http', 'meta', metaData as HTTPWiringsMeta)`);
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState, HTTPWiringsMeta } from '@pikku/core'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [