@pikku/cli 0.11.3 → 0.12.1

package/dist/src/functions/wirings/http/serialize-typed-http-map.js

@@ -1,17 +1,34 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeTypedHTTPWiringsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, wiringsMeta, metaTypes) => {
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeTypedHTTPWiringsMap = (logger, relativeToPath, packageMappings, typesMap, wiringsMeta, metaTypes, resolvedIOTypes, rpcInternalMapDeclarationFile) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap, requiredTypes);
+    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, resolvedIOTypes, requiredTypes);
+    const needsFlattenedRPCMap = Array.from(requiredTypes).some((t) => t.includes('FlattenedRPCMap'));
+    if (needsFlattenedRPCMap) {
+        for (const t of Array.from(requiredTypes)) {
+            if (t.includes('FlattenedRPCMap')) {
+                requiredTypes.delete(t);
+            }
+        }
+    }
+    const serializedImportMap = serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes);
+    const rpcMapImport = needsFlattenedRPCMap
+        ? `import type { FlattenedRPCMap } from '${getFileImportRelativePath(relativeToPath, rpcInternalMapDeclarationFile, packageMappings)}'`
+        : '';
+    const serializedCustomTypesDeclarationsOnly = serializedCustomTypes
+        .split('\n')
+        .filter((line) => !line.startsWith('import '))
+        .join('\n');
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
  */
 
 ${serializedImportMap}
-${serializedCustomTypes}
+${rpcMapImport}
+${serializedCustomTypesDeclarationsOnly}
 ${serializedMetaTypes}
 
 interface HTTPWiringHandler<I, O> {
@@ -31,52 +48,21 @@ export type HTTPWiringsWithMethod<Method extends string> = {
 }[keyof HTTPWiringsMap];
   `;
 };
-function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect routes
+function generateHTTPWirings(routesMeta, resolvedIOTypes, requiredTypes) {
     const routesObj = {};
     for (const methods of Object.values(routesMeta)) {
         for (const meta of Object.values(methods)) {
-            const { route, method, pikkuFuncName } = meta;
-            // Skip workflow-triggered routes (they don't have a function)
-            if (meta.workflow) {
-                continue;
-            }
-            const functionMeta = functionsMeta[pikkuFuncName];
-            if (!functionMeta) {
-                throw new Error(`Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`);
-            }
-            const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-            const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+            const { route, method, pikkuFuncId } = meta;
             if (!routesObj[route]) {
                 routesObj[route] = {};
             }
-            // For zod-derived schemas, the type might not be in typesMap, so use the schema name directly
-            let inputType = 'null';
-            if (input) {
-                try {
-                    inputType = typesMap.getTypeMeta(input).uniqueName;
-                }
-                catch {
-                    inputType = input;
-                }
-            }
-            let outputType = 'null';
-            if (output) {
-                try {
-                    outputType = typesMap.getTypeMeta(output).uniqueName;
-                }
-                catch {
-                    // Zod-derived schema - use the schema name directly
-                    outputType = output;
-                }
+            const resolved = resolvedIOTypes[pikkuFuncId];
+            if (!resolved) {
+                throw new Error(`Function ${pikkuFuncId} not found in resolvedIOTypes. Please check your configuration.`);
             }
-            requiredTypes.add(inputType);
-            requiredTypes.add(outputType);
-            // Add method entry
-            routesObj[route][method] = {
-                inputType,
-                outputType,
-            };
+            requiredTypes.add(resolved.inputType);
+            requiredTypes.add(resolved.outputType);
+            routesObj[route][method] = resolved;
         }
     }
     // Build the routes object as a string
@@ -91,7 +77,7 @@ function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes)
     routesStr += '};';
     return routesStr;
 }
-const generateMetaTypes = (metaTypes, typesMap) => {
+const generateMetaTypes = (metaTypes, typesMap, requiredTypes) => {
     const nameToTypeMap = Array.from(metaTypes.entries()).reduce((result, [_name, { query, body, params }]) => {
         let uniqueName;
         try {
@@ -101,6 +87,7 @@ const generateMetaTypes = (metaTypes, typesMap) => {
             // Zod-derived schema - use the name directly
             uniqueName = _name;
         }
+        requiredTypes.add(uniqueName);
         const queryType = query && query.length > 0
             ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
             : undefined;

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

@@ -1 +1 @@
-export declare const pikkuMCPJSON: any;
+export declare const pikkuMCPJSON: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,14 +1,13 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { serializeMCPJson } from './serialize-mcp-json.js';
+import { serializeMCPJson } from '@pikku/inspector';
 export const pikkuMCPJSON = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { mcpEndpoints, functions } = await getInspectorState();
-        const { mcpJsonFile, schemaDirectory } = config;
-        // Generate MCP JSON file
+        const state = await getInspectorState();
+        const { mcpJsonFile } = config;
         if (mcpJsonFile) {
-            const mcpJson = await serializeMCPJson(logger, schemaDirectory, functions.meta, functions.typesMap, mcpEndpoints.resourcesMeta, mcpEndpoints.toolsMeta, mcpEndpoints.promptsMeta);
+            const mcpJson = serializeMCPJson(logger, state);
             await writeFileInDir(logger, mcpJsonFile, mcpJson, {
                 ignoreModifyComment: true,
             });

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

@@ -1 +1 @@
-export declare const pikkuMCPTypes: any;
+export declare const pikkuMCPTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 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';

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

@@ -1 +1 @@
-export declare const pikkuMCP: any;
+export declare const pikkuMCP: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 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';
@@ -10,7 +10,16 @@ import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verb
 const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMap, logger) => {
     if (!inputSchema)
         return [];
-    if (['boolean', 'string', 'number', 'null', 'undefined', 'void'].includes(inputSchema)) {
+    if ([
+        'boolean',
+        'string',
+        'number',
+        'null',
+        'undefined',
+        'void',
+        'unknown',
+        'never',
+    ].includes(inputSchema)) {
         return [];
     }
     const uniqueName = typesMap.getUniqueName(inputSchema);
@@ -44,11 +53,11 @@ export const pikkuMCP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { mcpEndpoints, functions } = await getInspectorState();
         const { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory, schema, } = config;
-        await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource or wireMCPTool', mcpWiringsFile, mcpEndpoints.files, packageMappings));
+        await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource', mcpWiringsFile, mcpEndpoints.files, packageMappings));
         // Populate arguments for prompts meta before serializing
         const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta };
         for (const promptMeta of Object.values(promptsMetaWithArguments)) {
-            const functionMeta = functions.meta[promptMeta.pikkuFuncName];
+            const functionMeta = functions.meta[promptMeta.pikkuFuncId];
             if (functionMeta) {
                 const inputType = functionMeta.inputs?.[0];
                 promptMeta.arguments = await generateArgumentsFromSchema(inputType || null, schemaDirectory || '', functions.typesMap, logger);
@@ -72,7 +81,7 @@ export const pikkuMCP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core'
+        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core/internal'
 import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
 ${importStatement}
 pikkuState(null, 'mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)

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

@@ -8,10 +8,8 @@ export const serializeMCPTypes = (functionTypesImportPath) => {
 
 import {
   CoreMCPResource,
-  CoreMCPTool,
   CoreMCPPrompt,
   wireMCPResource as wireMCPResourceCore,
-  wireMCPTool as wireMCPToolCore,
   wireMCPPrompt as wireMCPPromptCore,
   MCPResourceResponse,
   MCPToolResponse,
@@ -19,8 +17,9 @@ import {
   AssertMCPResourceURIParams
 } from '@pikku/core/mcp'
 
-import type { PikkuFunctionConfig, PikkuFunctionSessionless, InferZodOutput } from '${functionTypesImportPath}'
-import type { ZodLike } from '@pikku/core'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuMiddleware, PikkuPermission, InferSchemaOutput } from '${functionTypesImportPath}'
+import type { CorePermissionGroup } from '@pikku/core'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 /**
  * Type definition for MCP resources that provide data to AI models.
@@ -30,13 +29,6 @@ import type { ZodLike } from '@pikku/core'
  */
 type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse, 'rpc' | 'session' | 'mcp'>> & { uri: URI }
 
-/**
- * Type definition for MCP tools that AI models can invoke.
- *
- * @template In - Input type for the tool invocation
- */
-type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse, 'rpc' | 'session' | 'mcp'>>
-
 /**
  * Type definition for MCP prompts that provide templates to AI models.
  *
@@ -58,19 +50,6 @@ export const wireMCPResource = <In, URI extends string>(
   wireMCPResourceCore(mcpResource as any)
 }
 
-/**
- * Registers an MCP tool with the Pikku framework.
- * Tools are functions that AI models can invoke.
- *
- * @template In - Input type for the tool invocation
- * @param mcpTool - MCP tool definition with action function
- */
-export const wireMCPTool = <In>(
-  mcpTool: MCPToolWiring<In>
-) => {
-  wireMCPToolCore(mcpTool as any)
-}
-
 /**
  * Registers an MCP prompt with the Pikku framework.
  * Prompts provide templates that AI models can use.
@@ -87,8 +66,8 @@ export const wireMCPPrompt = <In>(
 /**
  * Configuration for MCP prompt with Zod schema input validation.
  */
-type MCPPromptFuncConfigWithSchema<InputSchema extends ZodLike> = {
-  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+type MCPPromptFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
   name?: string
   input: InputSchema
 }
@@ -105,9 +84,9 @@ type MCPPromptFuncConfigWithSchema<InputSchema extends ZodLike> = {
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export function pikkuMCPPromptFunc<InputSchema extends ZodLike>(
+export function pikkuMCPPromptFunc<InputSchema extends StandardSchemaV1>(
   config: MCPPromptFuncConfigWithSchema<InputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
 export function pikkuMCPPromptFunc<In>(
   func:
     | PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
@@ -123,9 +102,15 @@ export function pikkuMCPPromptFunc(func: any): any {
 /**
  * Configuration for MCP tool with Zod schema input validation.
  */
-type MCPToolFuncConfigWithSchema<InputSchema extends ZodLike> = {
-  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+type MCPToolFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+  description?: string
+  tags?: string[]
+  title?: string
+  summary?: string
   name?: string
+  middleware?: PikkuMiddleware[]
+  permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>
   input: InputSchema
 }
 
@@ -141,15 +126,21 @@ type MCPToolFuncConfigWithSchema<InputSchema extends ZodLike> = {
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export function pikkuMCPToolFunc<InputSchema extends ZodLike>(
+export function pikkuMCPToolFunc<InputSchema extends StandardSchemaV1>(
   config: MCPToolFuncConfigWithSchema<InputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
 export function pikkuMCPToolFunc<In>(
   func:
     | PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
     | {
       func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
+      description?: string
+      tags?: string[]
+      title?: string
+      summary?: string
       name?: string
+      middleware?: PikkuMiddleware[]
+      permissions?: CorePermissionGroup<PikkuPermission<In>>
     }
 ): PikkuFunctionConfig<In, MCPToolResponse, 'mcp' | 'rpc'>
 export function pikkuMCPToolFunc(func: any): any {
@@ -159,8 +150,8 @@ export function pikkuMCPToolFunc(func: any): any {
 /**
  * Configuration for MCP resource with Zod schema input validation.
  */
-type MCPResourceFuncConfigWithSchema<InputSchema extends ZodLike> = {
-  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+type MCPResourceFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
   name?: string
   input: InputSchema
 }
@@ -177,9 +168,9 @@ type MCPResourceFuncConfigWithSchema<InputSchema extends ZodLike> = {
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export function pikkuMCPResourceFunc<InputSchema extends ZodLike>(
+export function pikkuMCPResourceFunc<InputSchema extends StandardSchemaV1>(
   config: MCPResourceFuncConfigWithSchema<InputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
 export function pikkuMCPResourceFunc<In>(
   func:
     | PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>

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

@@ -1 +1 @@
-export declare const pikkuMiddleware: any;
+export declare const pikkuMiddleware: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,48 +1,25 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeMiddlewareImports } from './serialize-middleware-imports.js';
-import { serializeMiddlewareGroupsMeta } from './serialize-middleware-groups-meta.js';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuMiddleware = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
         const { middleware } = state;
-        const { middlewareFile, packageMappings, schema } = config;
+        const { middlewareFile, packageMappings } = config;
         let filesGenerated = false;
-        // Check if there are any middleware groups
         const hasHTTPGroups = state.http.routeMiddleware.size > 0;
         const hasTagGroups = state.middleware.tagMiddleware.size > 0;
-        if (hasHTTPGroups || hasTagGroups) {
-            const metaData = serializeMiddlewareGroupsMeta(state);
-            // Write JSON file
+        const hasDefinitions = Object.keys(state.middleware.definitions).length > 0;
+        const hasChannelMiddleware = state.channelMiddleware.tagMiddleware.size > 0 ||
+            Object.keys(state.channelMiddleware.definitions).length > 0;
+        if (hasHTTPGroups ||
+            hasTagGroups ||
+            hasDefinitions ||
+            hasChannelMiddleware) {
+            const metaData = state.middlewareGroupsMeta;
             await writeFileInDir(logger, config.middlewareGroupsMetaJsonFile, JSON.stringify(metaData, null, 2));
-            // Calculate relative path from TS file to JSON file
-            const jsonImportPath = getFileImportRelativePath(config.middlewareGroupsMetaFile, config.middlewareGroupsMetaJsonFile, packageMappings);
-            // Write TypeScript file that imports JSON
-            const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-            const importStatement = supportsImportAttributes
-                ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-                : `import metaData from '${jsonImportPath}'`;
-            const packageNameValue = config.externalPackageName
-                ? `'${config.externalPackageName}'`
-                : 'null';
-            const tsContent = `import { pikkuState } from '@pikku/core'
-${importStatement}
-
-// HTTP middleware groups metadata
-if (metaData.httpGroups && Object.keys(metaData.httpGroups).length > 0) {
-  pikkuState(${packageNameValue}, 'middleware', 'httpGroupMeta', metaData.httpGroups)
-}
-
-// Tag middleware groups metadata
-if (metaData.tagGroups && Object.keys(metaData.tagGroups).length > 0) {
-  pikkuState(${packageNameValue}, 'middleware', 'tagGroupMeta', metaData.tagGroups)
-}
-`;
-            await writeFileInDir(logger, config.middlewareGroupsMetaFile, tsContent);
-            // Always generate middleware imports file when groups exist (even if empty)
-            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings));
+            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings, state));
             filesGenerated = true;
         }
         return filesGenerated;

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

@@ -1,43 +1,38 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-export const serializeMiddlewareImports = (outputPath, middlewareState, httpState, packageMappings = {}, fullState) => {
-    const serializedImports = [];
-    const serializedFactoryCalls = [];
-    // Collect factory imports and calls for HTTP middleware groups
-    const httpFactories = new Map();
-    for (const [, groupMeta] of httpState.routeMiddleware.entries()) {
-        if (groupMeta.exportName && groupMeta.isFactory) {
-            const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
-            httpFactories.set(groupMeta.exportName, {
-                exportName: groupMeta.exportName,
-                filePath,
-            });
-        }
-    }
-    // Collect factory imports and calls for tag middleware groups
-    const tagFactories = new Map();
-    for (const [, groupMeta] of middlewareState.tagMiddleware.entries()) {
+const collectFactories = (groupMap, outputPath, packageMappings) => {
+    const factories = new Map();
+    for (const [, groupMeta] of groupMap.entries()) {
         if (groupMeta.exportName && groupMeta.isFactory) {
             const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
-            tagFactories.set(groupMeta.exportName, {
+            factories.set(groupMeta.exportName, {
                 exportName: groupMeta.exportName,
                 filePath,
             });
         }
     }
-    // Combine all factories and deduplicate by exportName (same factory might be used in multiple groups)
-    const allFactories = new Map([...httpFactories, ...tagFactories]);
-    // Add factory imports and calls
+    return factories;
+};
+export const serializeMiddlewareImports = (outputPath, middlewareState, httpState, packageMappings = {}, fullState) => {
+    const serializedImports = [];
+    const serializedFactoryCalls = [];
+    const httpFactories = collectFactories(httpState.routeMiddleware, outputPath, packageMappings);
+    const tagFactories = collectFactories(middlewareState.tagMiddleware, outputPath, packageMappings);
+    const channelMiddlewareFactories = fullState
+        ? collectFactories(fullState.channelMiddleware.tagMiddleware, outputPath, packageMappings)
+        : new Map();
+    const allFactories = new Map([
+        ...httpFactories,
+        ...tagFactories,
+        ...channelMiddlewareFactories,
+    ]);
     if (allFactories.size > 0) {
         serializedImports.push('/* Call middleware group factories to register at module evaluation */');
-        // Import factories
         for (const [exportName, { filePath }] of allFactories) {
             serializedImports.push(`import { ${exportName} } from '${filePath}'`);
         }
-        // Call factories
         for (const [exportName] of allFactories) {
             serializedFactoryCalls.push(`${exportName}()`);
         }
     }
-    // Return combined output
     return [...serializedImports, ...serializedFactoryCalls].join('\n');
 };

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

@@ -0,0 +1,2 @@
+export declare const pikkuSecretDefinitionTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuVariableDefinitionTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -0,0 +1,30 @@
+import { pikkuVoidFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeSecretDefinitionTypes, serializeVariableDefinitionTypes, } from './serialize-package-types.js';
+export const pikkuSecretDefinitionTypes = pikkuVoidFunc({
+    func: async ({ logger, config }) => {
+        const { secretTypesFile } = config;
+        const content = serializeSecretDefinitionTypes();
+        await writeFileInDir(logger, secretTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Secret definition types',
+            commandEnd: 'Created Secret definition types',
+        }),
+    ],
+});
+export const pikkuVariableDefinitionTypes = pikkuVoidFunc({
+    func: async ({ logger, config }) => {
+        const { variableTypesFile } = config;
+        const content = serializeVariableDefinitionTypes();
+        await writeFileInDir(logger, variableTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Variable definition types',
+            commandEnd: 'Created Variable definition types',
+        }),
+    ],
+});

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

@@ -1 +1 @@
-export declare const pikkuPackage: any;
+export declare const pikkuPackage: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,20 +1,20 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePackageFactories } from './serialize-package.js';
 export const pikkuPackage = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { externalPackageName, packageMappings, packageFile } = config;
-        // Only generate for external packages
-        if (!externalPackageName) {
-            logger.info({
-                message: 'Skipping package factories - not an external package (externalPackageName not set)',
+        const { addonName, packageMappings, packageFile } = config;
+        // Only generate for addon packages
+        if (!addonName) {
+            logger.debug({
+                message: 'Skipping package factories - not an addon package (addonName not set)',
                 type: 'skip',
             });
             return false;
         }
         if (!packageFile) {
-            logger.info({
+            logger.debug({
                 message: 'Skipping package factories - packageFile not configured',
                 type: 'skip',
             });
@@ -23,7 +23,7 @@ export const pikkuPackage = pikkuSessionlessFunc({
         const state = await getInspectorState();
         const { filesAndMethods } = state;
         const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = filesAndMethods;
-        const content = serializePackageFactories(packageFile, externalPackageName, pikkuConfigFactory
+        const content = serializePackageFactories(packageFile, addonName, pikkuConfigFactory
             ? {
                 file: pikkuConfigFactory.file,
                 variable: pikkuConfigFactory.variable,

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

@@ -0,0 +1,2 @@
+export declare const serializeSecretDefinitionTypes: () => string;
+export declare const serializeVariableDefinitionTypes: () => string;

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

@@ -0,0 +1,10 @@
+export const serializeSecretDefinitionTypes = () => {
+    return `export { wireSecret } from '@pikku/core/secret'
+export type { CoreSecret, SecretDefinitionMeta, SecretDefinitionsMeta } from '@pikku/core/secret'
+`;
+};
+export const serializeVariableDefinitionTypes = () => {
+    return `export { wireVariable } from '@pikku/core/variable'
+export type { CoreVariable, VariableDefinitionMeta, VariableDefinitionsMeta } from '@pikku/core/variable'
+`;
+};

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

@@ -1,7 +1,7 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const serializePackageFactories = (outputPath, packageName, configFactory, singletonServicesFactory, wireServicesFactory, packageMappings = {}) => {
     const imports = [
-        `import { addPackageServiceFactories } from '@pikku/core'`,
+        `import { pikkuState } from '@pikku/core/internal'`,
     ];
     const factoryEntries = [];
     if (configFactory) {
@@ -25,7 +25,7 @@ export const serializePackageFactories = (outputPath, packageName, configFactory
     }
     return `${imports.join('\n')}
 
-addPackageServiceFactories('${packageName}', {
+pikkuState('${packageName}', 'package', 'factories', {
 ${factoryEntries.join('\n')}
 })
 `;

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

@@ -1 +1 @@
-export declare const pikkuPermissions: any;
+export declare const pikkuPermissions: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePermissionsImports } from './serialize-permissions-imports.js';
@@ -8,12 +8,12 @@ export const pikkuPermissions = pikkuSessionlessFunc({
         const { permissions } = state;
         const { permissionsFile, packageMappings } = config;
         let filesGenerated = false;
-        // Check if there are any permission group factories
-        const hasHTTPFactories = Array.from(state.http.routePermissions.values()).some((meta) => meta.exportName && meta.isFactory);
-        const hasTagFactories = Array.from(state.permissions.tagPermissions.values()).some((meta) => meta.exportName && meta.isFactory);
-        const hasFactories = hasHTTPFactories || hasTagFactories;
-        // Generate permissions imports file if there are factories
-        if (hasFactories) {
+        const hasHTTPGroups = state.http.routePermissions.size > 0;
+        const hasTagGroups = state.permissions.tagPermissions.size > 0;
+        const hasIndividual = Object.keys(state.permissions.definitions).length > 0;
+        if (hasHTTPGroups || hasTagGroups || hasIndividual) {
+            const metaData = state.permissionsGroupsMeta;
+            await writeFileInDir(logger, config.permissionsGroupsMetaJsonFile, JSON.stringify(metaData, null, 2));
             await writeFileInDir(logger, permissionsFile, serializePermissionsImports(permissionsFile, permissions, state.http, packageMappings));
             filesGenerated = true;
         }

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

@@ -1 +1 @@
-export declare const pikkuQueueMap: any;
+export declare const pikkuQueueMap: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;