@pikku/cli 0.11.1 → 0.11.3

package/src/functions/wirings/channels/serialize-typed-channel-map.ts

@@ -17,12 +17,12 @@ export const serializeTypedChannelsMap = (
   )
   typesMap.customTypes.forEach(({ references }) => {
     for (const reference of references) {
-      // Skip __object types (placeholder types for invalid/broken functions)
       if (reference !== '__object' && !reference.startsWith('__object_')) {
         requiredTypes.add(reference)
       }
     }
   })
+
   const imports = serializeImportMap(
     relativeToPath,
     packageMappings,
@@ -30,10 +30,11 @@ export const serializeTypedChannelsMap = (
     requiredTypes
   )
   const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
+
   return `/**
  * This provides the structure needed for TypeScript to be aware of channels
  */
-    
+
 ${imports}
 ${serializedCustomTypes}
 

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

@@ -173,19 +173,19 @@ export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
         checkRequiredTypes(visitState.filesAndMethodsErrors, {
           config: true,
           singletonServicesFactory: true,
-          sessionServicesFactory: true,
+          wireServicesFactory: true,
         })
 
         const {
           pikkuConfigFactory,
           singletonServicesFactory,
-          sessionServicesFactory,
+          wireServicesFactory,
         } = visitState.filesAndMethods
 
         if (
           !pikkuConfigFactory ||
           !singletonServicesFactory ||
-          !sessionServicesFactory
+          !wireServicesFactory
         ) {
           throw new Error('Required types not found')
         }
@@ -197,7 +197,7 @@ export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
           config,
           pikkuConfigFactory,
           singletonServicesFactory,
-          sessionServicesFactory
+          wireServicesFactory
         )
 
         await writeFileInDir(logger, bootstrapFile, bootstrapCode)

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

@@ -19,7 +19,7 @@ export const pikkuCLITypes: any = pikkuSessionlessFunc<void, void>({
     // Check for required types
     checkRequiredTypes(visitState.filesAndMethodsErrors, {
       userSessionType: true,
-      sessionServiceType: true,
+      wireServiceType: true,
       singletonServicesType: true,
     })
 

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

@@ -2,11 +2,22 @@ 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 pikkuCLI: any = pikkuSessionlessFunc<void, boolean | undefined>({
   func: async ({ logger, config, getInspectorState }) => {
     const visitState = await getInspectorState()
-    const { cliWiringsFile, cliWiringMetaFile, packageMappings } = config
+    const {
+      cliWiringsFile,
+      cliWiringMetaFile,
+      cliWiringMetaJsonFile,
+      packageMappings,
+      schema,
+    } = config
     const { cli } = visitState
 
     // Generate CLI wirings file
@@ -21,11 +32,42 @@ export const pikkuCLI: any = pikkuSessionlessFunc<void, boolean | undefined>({
       )
     )
 
-    // Generate CLI metadata file
+    // Write minimal JSON (runtime-only fields)
+    const minimalMeta = stripVerboseFields(cli.meta)
+    await writeFileInDir(
+      logger,
+      cliWiringMetaJsonFile,
+      JSON.stringify(minimalMeta, null, 2)
+    )
+
+    // Write verbose JSON only if it has additional fields
+    if (hasVerboseFields(cli.meta)) {
+      const verbosePath = cliWiringMetaJsonFile.replace(
+        /\.gen\.json$/,
+        '-verbose.gen.json'
+      )
+      await writeFileInDir(
+        logger,
+        verbosePath,
+        JSON.stringify(cli.meta, null, 2)
+      )
+    }
+
+    const jsonImportPath = getFileImportRelativePath(
+      cliWiringMetaFile,
+      cliWiringMetaJsonFile,
+      packageMappings
+    )
+
+    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+    const importStatement = supportsImportAttributes
+      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${jsonImportPath}'`
+
     await writeFileInDir(
       logger,
       cliWiringMetaFile,
-      `import { pikkuState } from '@pikku/core'\npikkuState('cli', 'meta', ${JSON.stringify(cli.meta, null, 2)})`
+      `import { pikkuState } from '@pikku/core'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState(null, 'cli', 'meta', metaData as CLIMeta)`
     )
 
     return true

package/src/functions/wirings/cli/serialize-channel-cli.ts

@@ -89,7 +89,7 @@ import { pikkuMiddleware } from '${functionTypesPath}'
 ${imports}
 
 // Middleware to close the channel after CLI command completes
-const cliCloseOnComplete = pikkuMiddleware(async (services, { channel }, next) => {
+const cliCloseOnComplete = pikkuMiddleware(async (_services, { channel }, next) => {
   const closeChannel = () => {
     setTimeout(async () => {
       try {

package/src/functions/wirings/cli/serialize-cli-types.ts

@@ -56,7 +56,7 @@ export const pikkuCLIRender = <Data, RequiredServices extends SingletonServices
  * CLI command configuration with project-specific types.
  * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.
  */
-type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
+type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out, 'cli' | 'rpc' | 'session'>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
 
 /**
  * Type definition for CLI applications with commands and global options.
@@ -90,7 +90,7 @@ export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any
  * @returns CLI command configuration with inferred types
  */
 export const pikkuCLICommand = <
-  FuncConfig extends PikkuFunctionConfig<any, any>,
+  FuncConfig extends PikkuFunctionConfig<any, any, 'cli' | 'rpc' | 'session'>,
   Params extends string
 >(
   config: CLICommandConfig<FuncConfig, any, any, Params>

package/src/functions/wirings/cli/serialize-local-cli-bootstrap.ts

@@ -11,7 +11,7 @@ export function serializeLocalCLIBootstrap(
   config: Config,
   pikkuConfigFactory: { file: string; variable: string },
   singletonServicesFactory: { file: string; variable: string },
-  sessionServicesFactory: { file: string; variable: string }
+  wireServicesFactory: { file: string; variable: string }
 ): string {
   const capitalizedName =
     programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '')
@@ -27,9 +27,9 @@ export function serializeLocalCLIBootstrap(
     singletonServicesFactory.file,
     config.packageMappings
   )
-  const sessionServicesPath = getFileImportRelativePath(
+  const wireServicesPath = getFileImportRelativePath(
     bootstrapFile,
-    sessionServicesFactory.file,
+    wireServicesFactory.file,
     config.packageMappings
   )
   const cliBootstrapPath = getFileImportRelativePath(
@@ -42,7 +42,7 @@ export function serializeLocalCLIBootstrap(
 import { executeCLI, CLIError } from '@pikku/core/cli'
 import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
 import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
-import { ${sessionServicesFactory.variable} as createSessionServices } from '${sessionServicesPath}'
+import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'
 import '${cliBootstrapPath}'
 
 /**
@@ -56,7 +56,7 @@ export async function ${capitalizedName}CLI(args: string[]): Promise<void> {
       args: args || process.argv.slice(2),
       createConfig,
       createSingletonServices,
-      createSessionServices,
+      createWireServices,
     })
   } catch (error) {
     if (error instanceof CLIError) {

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

@@ -0,0 +1,135 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { ErrorCode } from '@pikku/inspector'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { readFile } from 'fs/promises'
+import { join, isAbsolute } from 'path'
+import {
+  stripVerboseFields,
+  hasVerboseFields,
+} from '../../../utils/strip-verbose-meta.js'
+
+/**
+ * Load and sanitize an SVG icon file.
+ * Returns the SVG content as a string, or undefined if not found.
+ */
+const loadIcon = async (
+  iconPath: string | undefined,
+  rootDir: string,
+  logger: any
+): Promise<string | undefined> => {
+  if (!iconPath) return undefined
+
+  // Resolve the full path to the icon
+  const fullPath = isAbsolute(iconPath) ? iconPath : join(rootDir, iconPath)
+
+  try {
+    const content = await readFile(fullPath, 'utf-8')
+
+    // Basic SVG validation - must start with <svg
+    const trimmed = content.trim()
+    if (!trimmed.startsWith('<svg') && !trimmed.startsWith('<?xml')) {
+      logger.warn(`Icon file is not a valid SVG: ${fullPath}`)
+      return undefined
+    }
+
+    // Return the sanitized SVG (remove XML declaration if present)
+    return trimmed.replace(/<\?xml[^?]*\?>\s*/g, '').trim()
+  } catch (e) {
+    logger.warn(`Could not load icon: ${fullPath}`)
+    return undefined
+  }
+}
+
+export const pikkuForgeNodes: any = pikkuSessionlessFunc<
+  void,
+  boolean | undefined
+>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { forgeNodes, forgeCredentials } = await getInspectorState()
+    const { forgeNodesMetaJsonFile, forge, rootDir } = config
+
+    const hasNodes = Object.keys(forgeNodes.meta).length > 0
+    const hasCredentials = Object.keys(forgeCredentials.meta).length > 0
+
+    // Only generate if there are forge nodes or credentials
+    if (!hasNodes && !hasCredentials) {
+      return undefined
+    }
+
+    // Validate categories if configured
+    const allowedCategories = forge?.node?.categories
+    if (allowedCategories && allowedCategories.length > 0) {
+      for (const [name, meta] of Object.entries(forgeNodes.meta) as [
+        string,
+        any,
+      ][]) {
+        if (!allowedCategories.includes(meta.category)) {
+          logger.critical(
+            ErrorCode.INVALID_VALUE,
+            `Forge node '${name}' has invalid category '${meta.category}'. ` +
+              `Allowed categories: ${allowedCategories.join(', ')}`
+          )
+        }
+      }
+    }
+
+    // Build the output metadata - remove per-node icon field
+    const outputMeta: Record<string, any> = {}
+    for (const [name, meta] of Object.entries(forgeNodes.meta) as [
+      string,
+      any,
+    ][]) {
+      // Remove icon from node meta - only package-level icon is used
+      const { icon: _icon, ...nodeMetaWithoutIcon } = meta
+      outputMeta[name] = nodeMetaWithoutIcon
+    }
+
+    // Load package-level icon
+    const packageIcon = await loadIcon(forge?.node?.icon, rootDir, logger)
+
+    const metaData = {
+      nodes: outputMeta,
+      credentials: forgeCredentials.meta,
+      package: {
+        displayName: forge?.node?.displayName,
+        description: forge?.node?.description,
+        icon: packageIcon,
+        categories: forge?.node?.categories,
+      },
+    }
+
+    if (forgeNodesMetaJsonFile) {
+      // Write minimal JSON (runtime-only fields)
+      const minimalMeta = stripVerboseFields(metaData)
+      await writeFileInDir(
+        logger,
+        forgeNodesMetaJsonFile,
+        JSON.stringify(minimalMeta, null, 2),
+        { ignoreModifyComment: true }
+      )
+
+      // Write verbose JSON only if it has additional fields
+      if (hasVerboseFields(metaData)) {
+        const verbosePath = forgeNodesMetaJsonFile.replace(
+          /\.gen\.json$/,
+          '-verbose.gen.json'
+        )
+        await writeFileInDir(
+          logger,
+          verbosePath,
+          JSON.stringify(metaData, null, 2),
+          { ignoreModifyComment: true }
+        )
+      }
+    }
+
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating Forge nodes metadata',
+      commandEnd: 'Generated Forge nodes metadata',
+    }),
+  ],
+})

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

@@ -0,0 +1,38 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeForgeTypes } from './serialize-forge-types.js'
+
+export const pikkuForgeTypes: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const {
+      forgeTypesFile,
+      rpcInternalMapDeclarationFile,
+      packageMappings,
+      forge,
+    } = config
+
+    // Get the import path for the RPC map declaration file
+    // The declaration file ends in .d.ts, but we need to import from .js
+    // getFileImportRelativePath converts .ts -> .js, so .d.ts -> .d.js
+    // We need to remove the extra .d extension
+    let rpcMapImportPath = getFileImportRelativePath(
+      forgeTypesFile,
+      rpcInternalMapDeclarationFile,
+      packageMappings
+    )
+    // Fix: .d.ts files should be imported as .js (TypeScript resolves types from .d.ts)
+    rpcMapImportPath = rpcMapImportPath.replace('.d.js', '.js')
+
+    const categories = forge?.node?.categories
+    const content = serializeForgeTypes(rpcMapImportPath, categories)
+    await writeFileInDir(logger, forgeTypesFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating Forge types',
+      commandEnd: 'Created Forge types',
+    }),
+  ],
+})

package/src/functions/wirings/forge/serialize-forge-types.ts

@@ -0,0 +1,94 @@
+/**
+ * Generates type definitions for Forge wirings with typed category and RPC validation
+ */
+export const serializeForgeTypes = (
+  rpcMapImportPath: string,
+  categories: string[] | undefined
+) => {
+  // Generate category union type - 'never' if no categories configured
+  const categoryType = categories?.length
+    ? categories.map((c) => `'${c}'`).join(' | ')
+    : 'never'
+
+  return `/**
+ * Forge-specific type definitions for typed wireForgeNode and wireForgeCredential
+ */
+
+import { wireForgeNode as wireForgeNodeCore, wireForgeCredential as wireForgeCredentialCore } from '@pikku/core/forge-node'
+import type { CoreForgeNode, CoreForgeCredential } from '@pikku/core/forge-node'
+import type { FlattenedRPCMap } from '${rpcMapImportPath}'
+
+/**
+ * Valid category values for forge nodes.
+ * ${categories?.length ? `Configured categories: ${categories.join(', ')}` : 'No categories configured - wireForgeNode cannot be used until forge.node.categories is defined in pikku.config.json.'}
+ */
+export type ForgeCategory = ${categoryType}
+
+/**
+ * Valid RPC names that can be used with forge nodes.
+ * These are derived from the FlattenedRPCMap which includes both local and external package RPCs.
+ */
+export type ForgeRPCName = keyof FlattenedRPCMap
+
+/**
+ * Typed forge node configuration.
+ * Validates that category and rpc are valid values.
+ */
+export type TypedForgeNode = Omit<CoreForgeNode, 'category' | 'rpc'> & {
+  /** Grouping category (validated against forge.node.categories in config) */
+  category: ForgeCategory
+  /** RPC name to call when node executes (must be a valid RPC name) */
+  rpc: ForgeRPCName
+}
+
+/**
+ * Registers a Forge node with validated category and RPC.
+ *
+ * @param config - Forge node configuration with typed category and rpc
+ *
+ * @example
+ * \`\`\`typescript
+ * wireForgeNode({
+ *   name: 'send-email',
+ *   displayName: 'Send Email',
+ *   category: 'Communication', // Must be in forge.node.categories
+ *   type: 'action',
+ *   rpc: 'sendEmail', // Must be a valid RPC name
+ *   description: 'Sends an email to a recipient'
+ * })
+ * \`\`\`
+ */
+export const wireForgeNode = (config: TypedForgeNode): void => {
+  wireForgeNodeCore(config as CoreForgeNode)
+}
+
+/**
+ * Registers a Forge credential definition.
+ * Credentials define secrets/API keys required by the package.
+ *
+ * @template T - Zod schema type for the credential structure
+ * @param config - Forge credential configuration
+ *
+ * @example
+ * \`\`\`typescript
+ * import { z } from 'zod'
+ *
+ * const apiCredentials = z.object({
+ *   apiKey: z.string().describe('API key for authentication'),
+ *   apiSecret: z.string().describe('API secret')
+ * })
+ *
+ * wireForgeCredential({
+ *   name: 'example-api',
+ *   displayName: 'Example API Credentials',
+ *   description: 'Credentials for the example external API',
+ *   secretId: 'EXAMPLE_API_CREDENTIALS',
+ *   schema: apiCredentials
+ * })
+ * \`\`\`
+ */
+export const wireForgeCredential = <T>(config: CoreForgeCredential<T>): void => {
+  wireForgeCredentialCore(config)
+}
+`
+}

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

@@ -18,18 +18,18 @@ export const pikkuFunctionTypesSplit: any = pikkuSessionlessFunc<void, void>({
     // Check for required types
     checkRequiredTypes(visitState.filesAndMethodsErrors, {
       userSessionType: true,
-      sessionServiceType: true,
+      wireServiceType: true,
       singletonServicesType: true,
     })
 
     const {
       userSessionType,
-      sessionServicesType,
+      wireServicesType,
       singletonServicesType,
       pikkuConfigType,
     } = visitState.filesAndMethods
 
-    if (!userSessionType || !sessionServicesType || !singletonServicesType) {
+    if (!userSessionType || !wireServicesType || !singletonServicesType) {
       throw new Error('Required types not found')
     }
 
@@ -42,11 +42,12 @@ export const pikkuFunctionTypesSplit: any = pikkuSessionlessFunc<void, void>({
       userSessionType.type,
       `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`,
       singletonServicesType.type,
-      `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, sessionServicesType.typePath, packageMappings)}'`,
-      sessionServicesType.type,
-      `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`,
-      `import type { RequiredSingletonServices, RequiredSessionServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`,
-      configTypeImport
+      `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`,
+      wireServicesType.type,
+      `import type { TypedPikkuRPC, FlattenedRPCMap } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`,
+      `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`,
+      configTypeImport,
+      config.externalPackageName
     )
 
     await writeFileInDir(logger, functionTypesFile, content)

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

@@ -16,20 +16,27 @@ export const pikkuFunctionTypes: any = pikkuSessionlessFunc<void, void>({
       queueTypesFile,
       mcpTypesFile,
       cliTypesFile,
+      forgeTypesFile,
     } = config
 
+    const getImportPath = (file: string) =>
+      config.externalPackage
+        ? null
+        : getFileImportRelativePath(typesFile, file, packageMappings)
+
+    // Forge types are included for external packages (they need wireForgeNode/wireForgeCredential)
+    const getForgeImportPath = (file: string) =>
+      getFileImportRelativePath(typesFile, file, packageMappings)
+
     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)
+      getImportPath(httpTypesFile),
+      getImportPath(channelsTypesFile),
+      getImportPath(schedulersTypesFile),
+      getImportPath(queueTypesFile),
+      getImportPath(mcpTypesFile),
+      getImportPath(cliTypesFile),
+      getForgeImportPath(forgeTypesFile)
     )
 
     await writeFileInDir(logger, typesFile, content)

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

@@ -1,10 +1,12 @@
 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 { serializeFunctionImports } from './serialize-function-imports.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 import {
-  generateRuntimeMeta,
-  serializeFunctionImports,
-} from './serialize-function-imports.js'
+  stripVerboseFields,
+  hasVerboseFields,
+} from '../../../utils/strip-verbose-meta.js'
 
 export const pikkuFunctions: any = pikkuSessionlessFunc<
   void,
@@ -14,41 +16,84 @@ export const pikkuFunctions: any = pikkuSessionlessFunc<
     const { functions, rpc } = await getInspectorState()
     const {
       functionsMetaFile,
-      functionsMetaMinFile,
+      functionsMetaJsonFile,
       functionsFile,
       packageMappings,
+      schema,
     } = config
 
-    // Generate full metadata
+    // 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,
-      `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
+      functionsMetaJsonFile,
+      packageMappings
     )
 
-    // Generate minimal metadata (runtime)
-    const runtimeMeta = generateRuntimeMeta(functions.meta)
+    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+    const importStatement = supportsImportAttributes
+      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${jsonImportPath}'`
+
+    const packageName = config.externalPackageName
+      ? `'${config.externalPackageName}'`
+      : 'null'
+
     await writeFileInDir(
       logger,
-      functionsMetaMinFile,
-      `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(runtimeMeta, null, 2)})`
+      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) {
+    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,
-          rpc.internalFiles,
+          filesToRegister,
           functions.meta,
-          packageMappings
+          packageMappings,
+          config.externalPackageName
         )
       )
     }
 
-    return hasRPCs
+    return shouldGenerateFunctionsFile
   },
   middleware: [
     logCommandInfoAndTime({