@pikku/cli 0.11.1 → 0.11.3

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

@@ -1,16 +1,12 @@
 /**
- * Generate queue workers and RPC functions for workflow steps and orchestrator
+ * Generate queue workers for workflow orchestration
  */
 export const serializeWorkflowWorkers = (pathToPikkuTypes) => {
     return `/**
- * Auto-generated workflow queue workers and RPC functions
- * Do not edit manually - regenerate with 'npx pikku'
+ * Workflow queue workers for orchestration
  */
 import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
 
-/**
- * Worker input types for generated queue workers
- */
 export type WorkflowStepInput = {
   runId: string
   stepName: string
@@ -18,43 +14,34 @@ export type WorkflowStepInput = {
   data: any
 }
 
-export const pikkuWorkflowWorker = pikkuSessionlessFunc<
-  WorkflowStepInput,
-  void
->({
-  func: async ({ workflowService, rpc }, { runId, stepName, rpcName, data }) => {
+export const pikkuWorkflowWorker = pikkuSessionlessFunc<WorkflowStepInput, void>({
+  func: async ({ workflowService }, { runId, stepName, rpcName, data }, { rpc }) => {
     await workflowService!.executeWorkflowStep(runId, stepName, rpcName, data, rpc)
   }
 })
 
-export const pikkuWorkflowOrchestrator = pikkuSessionlessFunc<
-  { runId: string },
-  void
->({
-  func: async ({ workflowService, rpc }, { runId }) => {
+export const pikkuWorkflowOrchestrator = pikkuSessionlessFunc<{ runId: string }, void>({
+  func: async ({ workflowService }, { runId }, { rpc }) => {
     await workflowService!.orchestrateWorkflow(runId, rpc)
   }
 })
 
-export const pikkuWorkflowSleeper = pikkuSessionlessFunc<
-  { runId: string, stepId: string },
-  void
->({
+export const pikkuWorkflowSleeper = pikkuSessionlessFunc<{ runId: string, stepId: string }, void>({
   func: async ({ workflowService }, { runId, stepId }) => {
-    await workflowService!.executeWorkflowSleep(runId, stepId)
+    await workflowService!.executeWorkflowSleepCompleted(runId, stepId)
   },
-  name: 'pikkuWorkflowStepSleeper',
   internal: true,
 })
 
-wireQueueWorker({
-  queueName: 'pikku-workflow-step-worker',
-  func: pikkuWorkflowWorker,
+export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<{ rpcName: string, data?: any }, any>({
+  func: async (_services, { rpcName, data }, { rpc }) => {
+    return await (rpc.invoke as any)(rpcName, data)
+  },
+  internal: true,
 })
 
-wireQueueWorker({
-  queueName: 'pikku-workflow-orchestrator',
-  func: pikkuWorkflowOrchestrator,
-})
+wireQueueWorker({ queueName: 'pikku-workflow-step-worker', func: pikkuWorkflowWorker })
+wireQueueWorker({ queueName: 'pikku-workflow-orchestrator', func: pikkuWorkflowOrchestrator })
+wireQueueWorker({ queueName: 'pikku-remote-internal-rpc', func: pikkuRemoteInternalRPC })
 `;
 };

package/dist/src/middleware/log-command-info-and-time.d.ts

@@ -1,6 +1,6 @@
 import type { Services } from '../../types/application-types.js';
-import type { PikkuInteraction } from '@pikku/core';
-type PikkuMiddleware = (services: Services, interaction: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
+import type { PikkuWire } from '@pikku/core';
+type PikkuMiddleware = (services: Services, wire: PikkuWire, next: () => Promise<void>) => Promise<void>;
 export interface LogCommandInfoOptions {
     commandStart: string;
     commandEnd: string;

package/dist/src/middleware/log-command-info-and-time.js

@@ -3,13 +3,10 @@
  * Uses debug level so it only shows with --verbose flag
  */
 export const logCommandInfoAndTime = ({ commandStart, commandEnd, }) => {
-    return async ({ logger }, _interaction, next) => {
-        // Log start (debug level - only shows with --verbose)
+    return async ({ logger }, _wire, next) => {
         const start = Date.now();
         logger.debug(`• ${commandStart}...`);
-        // Execute the function
         await next();
-        // Log completion (debug level - only shows with --verbose)
         logger.debug({
             type: 'success',
             message: `✓ ${commandEnd} in ${Date.now() - start}ms.`,

package/dist/src/services/cli-logger-forwarder.service.js

@@ -26,7 +26,7 @@ export class CLILoggerForwarder {
             return;
         let message;
         if (messageOrObj instanceof Error) {
-            this.logger.error(messageOrObj);
+            this.logger.error(messageOrObj.toString());
             message = messageOrObj.message;
         }
         else if (typeof messageOrObj === 'object') {

package/dist/src/services.d.ts

@@ -1,20 +1,15 @@
 import type { Config, Services, SingletonServices, UserSession } from '../types/application-types.js';
-import { CreateConfig, CreateSessionServices, CreateSingletonServices } from '@pikku/core';
+import { CreateConfig, CreateWireServices, CreateSingletonServices } from '@pikku/core';
 import { PikkuCLIConfig } from '../types/config.js';
 import { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js';
 /**
  * Default CLI renderer that logs output using the logger
  */
 export declare const defaultCLIRenderer: import("@pikku/core").CorePikkuCLIRender<ForwardedLogMessage, SingletonServices, import("@pikku/core").CoreUserSession>;
-/**
- * Client-safe CLI renderer that outputs to console (no service dependencies)
- * This renderer can be used in CLI-over-channel clients
- */
-export declare const clientCLIRenderer: import("@pikku/core").CorePikkuCLIRender<ForwardedLogMessage, import("@pikku/core").CoreServices, import("@pikku/core").CoreUserSession>;
 export declare const createConfig: CreateConfig<Config, [PikkuCLIConfig]>;
 /**
  * Singleton services factory for the Pikku CLI
  * This function creates the singleton services used by the CLI and is created once on start.
  */
 export declare const createSingletonServices: CreateSingletonServices<Config, SingletonServices>;
-export declare const createSessionServices: CreateSessionServices<SingletonServices, Services, UserSession>;
+export declare const createWireServices: CreateWireServices<SingletonServices, Services, UserSession>;

package/dist/src/services.js

@@ -1,5 +1,5 @@
 import { pikkuCLIRender } from '@pikku/core/cli';
-import { LocalVariablesService, LogLevel } from '@pikku/core/services';
+import { LocalVariablesService, LocalSecretService, LogLevel, } from '@pikku/core/services';
 import { CLILogger } from './services/cli-logger.service.js';
 import { getPikkuCLIConfig } from './utils/pikku-cli-config.js';
 import { inspect, serializeInspectorState, deserializeInspectorState, filterInspectorState, getInitialInspectorState, } from '@pikku/inspector';
@@ -70,15 +70,17 @@ export const defaultCLIRenderer = pikkuCLIRender(({ logger }, data) => {
         logger[data.level]({ message: data.message, type: data.type });
     }
 });
-/**
- * Client-safe CLI renderer that outputs to console (no service dependencies)
- * This renderer can be used in CLI-over-channel clients
- */
-export const clientCLIRenderer = pikkuCLIRender(({ logger }, data) => {
-    if (data) {
-        logger[data.level]?.({ message: data.message, type: data.type });
-    }
-});
+// /**
+//  * Client-safe CLI renderer that outputs to console (no service dependencies)
+//  * This renderer can be used in CLI-over-channel clients
+//  */
+// export const clientCLIRenderer = pikkuCLIRender<ForwardedLogMessage>(
+//   ({ logger }, data) => {
+//     if (data) {
+//       logger[data.level]?.({ message: data.message, type: data.type } as any)
+//     }
+//   }
+// )
 export const createConfig = async (_variablesService, data) => {
     // Determine log level based on CLI flags with precedence:
     // --silent > --loglevel > --verbose > --info > default (warn)
@@ -155,7 +157,7 @@ export const createSingletonServices = async (config) => {
                     type: 'CoreUserSession',
                     typePath: corePackagePath,
                 },
-                sessionServicesType: {
+                wireServicesType: {
                     file: corePackagePath,
                     variable: 'CoreServices',
                     type: 'CoreServices',
@@ -181,14 +183,16 @@ export const createSingletonServices = async (config) => {
             // Run inspector WITHOUT filters to get full state
             const wiringFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`, {
                 ignore: config.ignoreFiles || [],
+                absolute: true,
             })))).flat();
             unfilteredState = inspect(logger, wiringFiles, {
                 setupOnly,
+                rootDir,
                 types: {
                     configFileType: config.configFile,
                     userSessionType: config.userSessionType,
                     singletonServicesFactoryType: config.singletonServicesFactoryType,
-                    sessionServicesFactoryType: config.sessionServicesFactoryType,
+                    wireServicesFactoryType: config.wireServicesFactoryType,
                 },
             });
             // Save unfiltered inspector state to file if stateOutput is provided
@@ -213,10 +217,11 @@ export const createSingletonServices = async (config) => {
         config,
         logger,
         variables,
+        secrets: new LocalSecretService(variables),
         getInspectorState,
     };
 };
-export const createSessionServices = async ({ logger }, { cli, channel }) => {
+export const createWireServices = async ({ logger }, { cli, channel }) => {
     const vChannel = cli ? cli.channel : channel;
     if (!vChannel) {
         throw new Error('No channel provided for CLI services');

package/dist/src/utils/check-required-types.d.ts

@@ -1,10 +1,10 @@
 import { FilesAndMethodsErrors } from '@pikku/inspector';
 export type RequiredTypes = Partial<{
     config: boolean;
-    sessionServiceType: boolean;
+    wireServiceType: boolean;
     singletonServicesType: boolean;
     userSessionType: boolean;
     singletonServicesFactory: boolean;
-    sessionServicesFactory: boolean;
+    wireServicesFactory: boolean;
 }>;
 export declare const checkRequiredTypes: (errors: FilesAndMethodsErrors, requires?: RequiredTypes) => void;

package/dist/src/utils/check-required-types.js

@@ -13,7 +13,7 @@ export const checkRequiredTypes = (errors, requires = {}) => {
         }
         if (requires.config && message.includes('CoreConfig'))
             return true;
-        if (requires.sessionServiceType && message.includes('CoreServices'))
+        if (requires.wireServiceType && message.includes('CoreServices'))
             return true;
         if (requires.singletonServicesType &&
             message.includes('CoreSingletonServices'))
@@ -23,8 +23,7 @@ export const checkRequiredTypes = (errors, requires = {}) => {
         if (requires.singletonServicesFactory &&
             message.includes('CreateSingletonServices'))
             return true;
-        if (requires.sessionServicesFactory &&
-            message.includes('CreateSessionServices'))
+        if (requires.wireServicesFactory && message.includes('CreateWireServices'))
             return true;
         return false;
     });

package/dist/src/utils/command-summary.d.ts

@@ -7,6 +7,8 @@ export interface CommandSummaryStats {
     mcpEndpoints?: number;
     cliCommands?: number;
     workflows?: number;
+    forgeNodes?: number;
+    workflowGraphs?: number;
     [key: string]: number | undefined;
 }
 /**

package/dist/src/utils/command-summary.js

@@ -52,6 +52,8 @@ export class CommandSummary {
             mcpEndpoints: 'MCP endpoint',
             cliCommands: 'CLI command',
             workflows: 'Workflow',
+            forgeNodes: 'Forge node',
+            workflowGraphs: 'Workflow graph',
         };
         for (const [key, label] of Object.entries(statLabels)) {
             const value = this.stats[key];

package/dist/src/utils/custom-types-generator.js

@@ -1,40 +1,38 @@
+// Sanitize a type name to be a valid TypeScript identifier
+function sanitizeTypeName(name) {
+    // Replace hyphens with underscores
+    return name.replace(/-/g, '_');
+}
 export function generateCustomTypes(typesMap, requiredTypes) {
     return `
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
 ${Array.from(typesMap.customTypes.entries())
-        .map(([name, { type, references }]) => {
+        .filter(([_name, { type }]) => {
+        const hasUndefinedGeneric = /\b(Name|In|Out|Key)\b/.test(type) && /\[.*\]/.test(type);
+        return !hasUndefinedGeneric;
+    })
+        .map(([originalName, { type, references }]) => {
+        const name = sanitizeTypeName(originalName);
         references.forEach((refName) => {
-            // Skip __object types (including those with suffixes like __object_abc123)
-            // These are placeholder types created by the inspector for invalid/broken functions
-            // (e.g., functions with type errors or missing return statements). Attempting to
-            // import these would fail since the source files don't actually export __object.
             if (refName !== '__object' && !refName.startsWith('__object_')) {
                 requiredTypes.add(refName);
             }
         });
-        // Extract type names from the type string that might not be in references
         const typeString = type;
-        // Use regex to extract potential type names (PascalCase identifiers)
         const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g;
         const potentialTypes = typeString.match(typeNameRegex) || [];
         potentialTypes.forEach((typeName) => {
-            // Skip string literals and common keywords
             if (typeString.includes(`"${typeName}"`) ||
                 ['Pick', 'Omit', 'Partial', 'Required', 'Record', 'Readonly'].includes(typeName)) {
                 return;
             }
-            // Try to find this type in the typesMap and add it if found
             try {
                 const typeMeta = typesMap.getTypeMeta(typeName);
                 if (typeMeta.path) {
-                    // Add originalName to preserve canonical import name
                     requiredTypes.add(typeMeta.originalName);
                 }
             }
-            catch (e) {
-                // Type not found in map (ambient/builtin type) - ignore it
-                // Do NOT add to requiredTypes to avoid crashes in serializeImportMap
+            catch {
+                // Type not found in map (ambient/builtin type)
             }
         });
         return `export type ${name} = ${type}`;

package/dist/src/utils/generate-bootstrap-file.js

@@ -7,7 +7,7 @@ export const generateBootstrapFile = async (logger, config, bootstrapFile, speci
     if (hasMiddleware) {
         commonImports.push(config.middlewareFile);
     }
-    commonImports.push(config.functionsMetaMinFile, config.functionsFile);
+    commonImports.push(config.functionsMetaFile, config.functionsFile);
     // Add schema if it exists
     if (schemas) {
         commonImports.push(`${config.schemaDirectory}/register.gen.ts`);

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

@@ -38,6 +38,10 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
                     ...extendedConfig.packageMappings,
                     ...config.packageMappings,
                 },
+                externalPackages: {
+                    ...extendedConfig.externalPackages,
+                    ...config.externalPackages,
+                },
                 ignoreFiles: config.ignoreFiles ??
                     extendedConfig.ignoreFiles ?? [
                     '**/*.test.ts',
@@ -47,7 +51,7 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
                 ],
                 schema: {
                     additionalProperties: false,
-                    supportsImportAttributes: false,
+                    supportsImportAttributes: true,
                     ...extendedConfig.schema,
                     ...config.schema,
                 },
@@ -58,6 +62,7 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
                 ...config,
                 configDir,
                 packageMappings: config.packageMappings || {},
+                externalPackages: config.externalPackages || {},
                 rootDir: config.rootDir
                     ? resolve(configDir, config.rootDir)
                     : configDir,
@@ -69,7 +74,7 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
                 ],
                 schema: {
                     additionalProperties: false,
-                    supportsImportAttributes: false,
+                    supportsImportAttributes: true,
                     ...config.schema,
                 },
             };
@@ -96,8 +101,8 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.functionsMetaFile) {
             result.functionsMetaFile = join(functionDir, 'pikku-functions-meta.gen.ts');
         }
-        if (!result.functionsMetaMinFile) {
-            result.functionsMetaMinFile = join(functionDir, 'pikku-functions-meta.min.gen.ts');
+        if (!result.functionsMetaJsonFile) {
+            result.functionsMetaJsonFile = join(functionDir, 'pikku-functions-meta.gen.json');
         }
         if (!result.functionTypesFile) {
             result.functionTypesFile = join(functionDir, 'pikku-function-types.gen.ts');
@@ -112,6 +117,9 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.httpWiringMetaFile) {
             result.httpWiringMetaFile = join(httpDir, 'pikku-http-wirings-meta.gen.ts');
         }
+        if (!result.httpWiringMetaJsonFile) {
+            result.httpWiringMetaJsonFile = join(httpDir, 'pikku-http-wirings-meta.gen.json');
+        }
         if (!result.httpMapDeclarationFile) {
             result.httpMapDeclarationFile = join(httpDir, 'pikku-http-wirings-map.gen.d.ts');
         }
@@ -125,6 +133,9 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.channelsWiringMetaFile) {
             result.channelsWiringMetaFile = join(channelDir, 'pikku-channels-meta.gen.ts');
         }
+        if (!result.channelsWiringMetaJsonFile) {
+            result.channelsWiringMetaJsonFile = join(channelDir, 'pikku-channels-meta.gen.json');
+        }
         if (!result.channelsMapDeclarationFile) {
             result.channelsMapDeclarationFile = join(channelDir, 'pikku-channels-map.gen.d.ts');
         }
@@ -135,6 +146,9 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.rpcInternalWiringMetaFile) {
             result.rpcInternalWiringMetaFile = join(rpcDir, 'pikku-rpc-wirings-meta.internal.gen.ts');
         }
+        if (!result.rpcInternalWiringMetaJsonFile) {
+            result.rpcInternalWiringMetaJsonFile = join(rpcDir, 'pikku-rpc-wirings-meta.internal.gen.json');
+        }
         if (!result.rpcInternalMapDeclarationFile) {
             result.rpcInternalMapDeclarationFile = join(rpcDir, 'pikku-rpc-wirings-map.internal.gen.d.ts');
         }
@@ -155,6 +169,9 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.schedulersWiringMetaFile) {
             result.schedulersWiringMetaFile = join(schedulerDir, 'pikku-schedulers-wirings-meta.gen.ts');
         }
+        if (!result.schedulersWiringMetaJsonFile) {
+            result.schedulersWiringMetaJsonFile = join(schedulerDir, 'pikku-schedulers-wirings-meta.gen.json');
+        }
         if (!result.schedulersTypesFile) {
             result.schedulersTypesFile = join(schedulerDir, 'pikku-scheduler-types.gen.ts');
         }
@@ -165,6 +182,9 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.queueWorkersWiringMetaFile) {
             result.queueWorkersWiringMetaFile = join(queueDir, 'pikku-queue-workers-wirings-meta.gen.ts');
         }
+        if (!result.queueWorkersWiringMetaJsonFile) {
+            result.queueWorkersWiringMetaJsonFile = join(queueDir, 'pikku-queue-workers-wirings-meta.gen.json');
+        }
         if (!result.queueMapDeclarationFile) {
             result.queueMapDeclarationFile = join(queueDir, 'pikku-queue-workers-wirings-map.gen.d.ts');
         }
@@ -187,6 +207,10 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.workflowTypesFile) {
             result.workflowTypesFile = join(workflowDir, 'pikku-workflow-types.gen.ts');
         }
+        // Workflow meta directory (individual JSON files for each workflow)
+        if (!result.workflowMetaDir) {
+            result.workflowMetaDir = join(workflowDir, 'meta');
+        }
         // Services
         if (!result.servicesFile) {
             result.servicesFile = join(result.outDir, 'pikku-services.gen.ts');
@@ -198,6 +222,9 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.middlewareGroupsMetaFile) {
             result.middlewareGroupsMetaFile = join(middlewareDir, 'pikku-middleware-groups-meta.gen.ts');
         }
+        if (!result.middlewareGroupsMetaJsonFile) {
+            result.middlewareGroupsMetaJsonFile = join(middlewareDir, 'pikku-middleware-groups-meta.gen.json');
+        }
         // Permissions
         const permissionsDir = join(result.outDir, 'permissions');
         if (!result.permissionsFile) {
@@ -207,10 +234,17 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.bootstrapFile) {
             result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts');
         }
+        // Package service factories (for external packages)
+        if (!result.packageFile) {
+            result.packageFile = join(result.outDir, 'pikku-package.gen.ts');
+        }
         // MCP
         if (!result.mcpWiringsMetaFile) {
             result.mcpWiringsMetaFile = join(mcpDir, 'pikku-mcp-wirings-meta.gen.ts');
         }
+        if (!result.mcpWiringsMetaJsonFile) {
+            result.mcpWiringsMetaJsonFile = join(mcpDir, 'pikku-mcp-wirings-meta.gen.json');
+        }
         if (!result.mcpWiringsFile) {
             result.mcpWiringsFile = join(mcpDir, 'pikku-mcp-wirings.gen.ts');
         }
@@ -227,12 +261,23 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.cliWiringMetaFile) {
             result.cliWiringMetaFile = join(cliDir, 'pikku-cli-wirings-meta.gen.ts');
         }
+        if (!result.cliWiringMetaJsonFile) {
+            result.cliWiringMetaJsonFile = join(cliDir, 'pikku-cli-wirings-meta.gen.json');
+        }
         if (!result.cliBootstrapFile) {
             result.cliBootstrapFile = join(cliDir, 'pikku-cli-bootstrap.gen.ts');
         }
         if (!result.cliTypesFile) {
             result.cliTypesFile = join(cliDir, 'pikku-cli-types.gen.ts');
         }
+        // Forge
+        const forgeDir = join(result.outDir, 'forge');
+        if (!result.forgeNodesMetaJsonFile) {
+            result.forgeNodesMetaJsonFile = join(forgeDir, 'pikku-forge-nodes-meta.gen.json');
+        }
+        if (!result.forgeTypesFile) {
+            result.forgeTypesFile = join(forgeDir, 'pikku-forge-types.gen.ts');
+        }
         if (requiredFields.length > 0) {
             validateCLIConfig(result, requiredFields);
         }
@@ -252,6 +297,22 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!isAbsolute(result.tsconfig)) {
             result.tsconfig = join(result.rootDir, result.tsconfig);
         }
+        if (result.externalPackage) {
+            const packageJsonPath = join(result.rootDir, 'package.json');
+            try {
+                const packageJsonContent = await readFile(packageJsonPath, 'utf-8');
+                const packageJson = JSON.parse(packageJsonContent);
+                if (!packageJson.name ||
+                    typeof packageJson.name !== 'string' ||
+                    packageJson.name.trim() === '') {
+                    throw new Error(`package.json at ${packageJsonPath} is missing a valid "name" field`);
+                }
+                result.externalPackageName = packageJson.name;
+            }
+            catch (e) {
+                throw new Error(`externalPackage is true but could not read or parse package.json at ${packageJsonPath}: ${e.message}`);
+            }
+        }
         return result;
     }
     catch (e) {

package/dist/src/utils/pikku-files-and-methods.d.ts

@@ -8,11 +8,11 @@ interface Meta {
 }
 export type FilesAndMethods = {
     userSessionType: Meta;
-    sessionServicesType: Meta;
+    wireServicesType: Meta;
     singletonServicesType: Meta;
     pikkuConfigFactory: Meta;
     singletonServicesFactory: Meta;
-    sessionServicesFactory: Meta;
+    wireServicesFactory: Meta;
 };
 /**
  * @deprecated Use state.filesAndMethods from InspectorState instead

package/dist/src/utils/pikku-files-and-methods.js

@@ -45,16 +45,16 @@ const getMetaTypes = (type, map, desiredType) => {
  * @deprecated Use state.filesAndMethods from InspectorState instead
  */
 export const getPikkuFilesAndMethods = async (state, options = {}) => {
-    const { singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, } = state;
-    const { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, } = options;
+    const { singletonServicesTypeImportMap, wireServicesTypeImportMap, userSessionTypeImportMap, wireServicesFactories, singletonServicesFactories, configFactories, } = state;
+    const { configFileType, userSessionType, singletonServicesFactoryType, wireServicesFactoryType, } = options;
     let errors = new Map();
     const result = {
         userSessionType: getMetaTypes('CoreUserSession', userSessionTypeImportMap, userSessionType),
         singletonServicesType: getMetaTypes('CoreSingletonServices', singletonServicesTypeImportMap),
-        sessionServicesType: getMetaTypes('CoreServices', sessionServicesTypeImportMap),
+        wireServicesType: getMetaTypes('CoreServices', wireServicesTypeImportMap),
         pikkuConfigFactory: getMetaTypes('CoreConfig', configFactories, configFileType),
         singletonServicesFactory: getMetaTypes('CreateSingletonServices', singletonServicesFactories, singletonServicesFactoryType),
-        sessionServicesFactory: getMetaTypes('CreateSessionServices', sessionServicesFactories, sessionServicesFactoryType),
+        wireServicesFactory: getMetaTypes('CreateWireServices', wireServicesFactories, wireServicesFactoryType),
     };
     if (errors.size > 0) {
         const result = ['Found errors:'];

package/dist/src/utils/schema-generator.d.ts

@@ -1,6 +1,7 @@
 import { FunctionsMeta, JSONValue } from '@pikku/core';
 import { HTTPWiringsMeta } from '@pikku/core/http';
-import { TypesMap } from '@pikku/inspector';
+import { TypesMap, ZodSchemaRef } from '@pikku/inspector';
 import { CLILogger } from '../services/cli-logger.service.js';
-export declare function generateSchemas(logger: CLILogger, tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpWiringsMeta: HTTPWiringsMeta, additionalTypes?: string[], additionalProperties?: boolean): Promise<Record<string, JSONValue>>;
-export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, additionalTypes?: string[], supportsImportAttributes?: boolean): Promise<void>;
+export declare function generateSchemas(logger: CLILogger, tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpWiringsMeta: HTTPWiringsMeta, additionalTypes?: string[], additionalProperties?: boolean, zodLookup?: Map<string, ZodSchemaRef>): Promise<Record<string, JSONValue>>;
+export declare function generateZodSchemas(logger: CLILogger, zodLookup: Map<string, ZodSchemaRef>, typesMap: TypesMap): Promise<Record<string, JSONValue>>;
+export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean, additionalTypes?: string[], zodLookup?: Map<string, ZodSchemaRef>, packageName?: string | null): Promise<void>;