@pikku/core 0.11.0 → 0.11.2

package/dist/types/core.types.d.ts

@@ -1,27 +1,21 @@
 import type { Logger, LogLevel } from '../services/logger.js';
 import { VariablesService } from '../services/variables-service.js';
+import { SecretService } from '../services/secret-service.js';
 import { SchemaService } from '../services/schema-service.js';
 import { JWTService } from '../services/jwt-service.js';
 import { PikkuHTTP } from '../wirings/http/http.types.js';
-import { UserSessionService } from '../services/user-session-service.js';
+import { SessionService } from '../services/user-session-service.js';
 import { PikkuChannel } from '../wirings/channel/channel.types.js';
 import { PikkuRPC } from '../wirings/rpc/rpc-types.js';
 import { PikkuMCP } from '../wirings/mcp/mcp.types.js';
 import { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js';
 import { PikkuQueue, QueueService } from '../wirings/queue/queue.types.js';
 import { PikkuCLI } from '../wirings/cli/cli.types.js';
-import { PikkuWorkflowInteraction, WorkflowService, WorkflowServiceConfig, WorkflowStepInteraction } from '../wirings/workflow/workflow.types.js';
+import { PikkuWorkflowWire, WorkflowService, WorkflowServiceConfig, WorkflowStepWire } from '../wirings/workflow/workflow.types.js';
+import type { PikkuGraphWire } from '../wirings/workflow/graph/workflow-graph.types.js';
+import { PikkuTrigger } from '../wirings/trigger/trigger.types.js';
 import { SchedulerService } from '../services/scheduler-service.js';
-export declare enum PikkuWiringTypes {
-    http = "http",
-    scheduler = "scheduler",
-    channel = "channel",
-    rpc = "rpc",
-    queue = "queue",
-    mcp = "mcp",
-    cli = "cli",
-    workflow = "workflow"
-}
+export type PikkuWiringTypes = 'http' | 'scheduler' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow';
 export interface FunctionServicesMeta {
     optimized: boolean;
     services: string[];
@@ -70,14 +64,13 @@ export type FunctionRuntimeMeta = {
 export type FunctionMeta = FunctionRuntimeMeta & Partial<{
     name: string;
     services: FunctionServicesMeta;
+    usedWires: string[];
     inputs: string[] | null;
     outputs: string[] | null;
-    tags: string[];
-    docs: PikkuDocs;
-    isDirectFunction: boolean;
     middleware: MiddlewareMetadata[];
     permissions: PermissionMetadata[];
-}>;
+    isDirectFunction: boolean;
+} & CommonWireMeta>;
 export type FunctionsRuntimeMeta = Record<string, FunctionRuntimeMeta>;
 export type FunctionsMeta = Record<string, FunctionMeta>;
 export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
@@ -134,6 +127,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     logger: Logger;
     /** The variable service to be used */
     variables: VariablesService;
+    /** The secrets service to retrieve secrets */
+    secrets: SecretService;
     /** The workflow orchestrator service */
     workflowService?: WorkflowService;
     /** The queue service */
@@ -142,25 +137,27 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     schedulerService?: SchedulerService;
 }
 /**
- * Represents different forms of interaction within Pikku and the outside world.
+ * Represents different forms of wire within Pikku and the outside world.
  */
-export type PikkuInteraction<In = unknown, Out = unknown> = Partial<{
+export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boolean = false, UserSession extends CoreUserSession = CoreUserSession, TypedRPC extends PikkuRPC = PikkuRPC, IsChannel extends true | null = null, MCPTools extends string | never = never, TypedWorkflow extends PikkuWorkflowWire | never = PikkuWorkflowWire, TriggerOutput = unknown> = Partial<{
     http: PikkuHTTP<In>;
-    mcp: PikkuMCP;
-    rpc: PikkuRPC;
-    channel: PikkuChannel<unknown, Out>;
+    mcp: PikkuMCP<MCPTools>;
+    rpc: TypedRPC;
+    channel: [IsChannel] extends [null] ? PikkuChannel<unknown, Out> : PikkuChannel<unknown, Out> | undefined;
     scheduledTask: PikkuScheduledTask;
     queue: PikkuQueue;
     cli: PikkuCLI;
-    workflow: PikkuWorkflowInteraction;
-    workflowStep: WorkflowStepInteraction;
+    workflow: TypedWorkflow;
+    workflowStep: WorkflowStepWire;
+    graph: PikkuGraphWire;
+    trigger: PikkuTrigger<TriggerOutput>;
+    initialSession: HasInitialSession extends true ? UserSession : UserSession | undefined;
+    session: SessionService<UserSession>;
 }>;
 /**
- * A function that can wrap an interaction and be called before or after
+ * A function that can wrap an wire and be called before or after
  */
-export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
-    userSession: UserSessionService<UserSession>;
-}, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
+export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices, wires: PikkuWire<unknown, unknown, false, UserSession>, next: () => Promise<void>) => Promise<void>;
 /**
  * Configuration object for creating middleware with metadata
  *
@@ -170,8 +167,8 @@ export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices
 export type CorePikkuMiddlewareConfig<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = {
     /** The middleware function */
     func: CorePikkuMiddleware<SingletonServices, UserSession>;
-    /** Optional human-readable name for the middleware */
-    name?: string;
+    /** Optional human-readable title for the middleware */
+    title?: string;
     /** Optional description of what the middleware does */
     description?: string;
 };
@@ -193,7 +190,7 @@ export type CorePikkuMiddlewareGroup<SingletonServices extends CoreSingletonServ
  * ```typescript
  * // Direct function syntax
  * export const logMiddleware = pikkuMiddleware(
- *   async ({ logger }, _interaction, next) => {
+ *   async ({ logger }, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -201,9 +198,9 @@ export type CorePikkuMiddlewareGroup<SingletonServices extends CoreSingletonServ
  *
  * // Configuration object syntax with metadata
  * export const logMiddleware = pikkuMiddleware({
- *   name: 'Request Logger',
+ *   title: 'Request Logger',
  *   description: 'Logs request information',
- *   func: async ({ logger }, _interaction, next) => {
+ *   func: async ({ logger }, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -221,7 +218,7 @@ export declare const pikkuMiddleware: <SingletonServices extends CoreSingletonSe
  *   message,
  *   level = 'info'
  * }) => {
- *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *   return pikkuMiddleware(async ({ logger }, next) => {
  *     logger[level](message)
  *     await next()
  *   })
@@ -230,12 +227,10 @@ export declare const pikkuMiddleware: <SingletonServices extends CoreSingletonSe
  */
 export declare const pikkuMiddlewareFactory: <In = any>(factory: CorePikkuMiddlewareFactory<In>) => CorePikkuMiddlewareFactory<In>;
 /**
- * Represents the core services used by Pikku, including singleton services and the request/response interaction.
+ * Represents the core services used by Pikku, including singleton services.
  */
-export type CoreServices<SingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = SingletonServices & PikkuInteraction & {
-    userSession?: UserSessionService<UserSession>;
-};
-export type SessionServices<SingletonServices extends CoreSingletonServices = CoreSingletonServices, Services = CoreServices<SingletonServices>> = Omit<Services, keyof SingletonServices | keyof PikkuInteraction | 'session'>;
+export type CoreServices<SingletonServices = CoreSingletonServices> = SingletonServices;
+export type WireServices<SingletonServices extends CoreSingletonServices = CoreSingletonServices, Services = CoreServices<SingletonServices>> = Omit<Services, keyof SingletonServices | 'session'>;
 /**
  * Defines a function type for creating singleton services from the given configuration.
  */
@@ -243,7 +238,7 @@ export type CreateSingletonServices<Config extends CoreConfig, SingletonServices
 /**
  * Defines a function type for creating session-specific services.
  */
-export type CreateSessionServices<SingletonServices extends CoreSingletonServices = CoreSingletonServices, Services extends CoreServices<SingletonServices> = CoreServices<SingletonServices>, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices, interaction: PikkuInteraction, session: UserSession | undefined) => Promise<SessionServices<Services, SingletonServices>>;
+export type CreateWireServices<SingletonServices extends CoreSingletonServices = CoreSingletonServices, Services extends CoreServices<SingletonServices> = CoreServices<SingletonServices>, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices, wire: PikkuWire<unknown, unknown, false, UserSession>) => Promise<WireServices<Services, SingletonServices>>;
 /**
  * Defines a function type for creating config.
  */
@@ -251,11 +246,15 @@ export type CreateConfig<Config extends CoreConfig, RemainingArgs extends any[]
 /**
  * Represents the documentation for a route, including summary, description, tags, and errors.
  */
-export type PikkuDocs = {
+export type CommonWireMeta = {
+    pikkuFuncName: string;
+    title?: string;
+    tags?: string[];
     summary?: string;
     description?: string;
-    tags?: string[];
     errors?: string[];
+    middleware?: MiddlewareMetadata[];
+    permissions?: PermissionMetadata[];
 };
 /**
  * Serialized error for storage

package/dist/types/core.types.js

@@ -1,14 +1,3 @@
-export var PikkuWiringTypes;
-(function (PikkuWiringTypes) {
-    PikkuWiringTypes["http"] = "http";
-    PikkuWiringTypes["scheduler"] = "scheduler";
-    PikkuWiringTypes["channel"] = "channel";
-    PikkuWiringTypes["rpc"] = "rpc";
-    PikkuWiringTypes["queue"] = "queue";
-    PikkuWiringTypes["mcp"] = "mcp";
-    PikkuWiringTypes["cli"] = "cli";
-    PikkuWiringTypes["workflow"] = "workflow";
-})(PikkuWiringTypes || (PikkuWiringTypes = {}));
 /**
  * Factory function for creating middleware with tree-shaking support
  * Supports both direct function and configuration object syntax
@@ -17,7 +6,7 @@ export var PikkuWiringTypes;
  * ```typescript
  * // Direct function syntax
  * export const logMiddleware = pikkuMiddleware(
- *   async ({ logger }, _interaction, next) => {
+ *   async ({ logger }, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -25,9 +14,9 @@ export var PikkuWiringTypes;
  *
  * // Configuration object syntax with metadata
  * export const logMiddleware = pikkuMiddleware({
- *   name: 'Request Logger',
+ *   title: 'Request Logger',
  *   description: 'Logs request information',
- *   func: async ({ logger }, _interaction, next) => {
+ *   func: async ({ logger }, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -47,7 +36,7 @@ export const pikkuMiddleware = (middleware) => {
  *   message,
  *   level = 'info'
  * }) => {
- *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *   return pikkuMiddleware(async ({ logger }, next) => {
  *     logger[level](message)
  *     await next()
  *   })

package/dist/types/state.types.d.ts

@@ -0,0 +1,135 @@
+import { PikkuError, ErrorDetails } from '../errors/error-handler.js';
+import { CorePikkuFunctionConfig, CorePermissionGroup, CorePikkuPermission } from '../function/functions.types.js';
+import { CoreChannel, ChannelsMeta } from '../wirings/channel/channel.types.js';
+import { CLIMeta, CLIProgramState } from '../wirings/cli/cli.types.js';
+import { HTTPMethod, CoreHTTPFunctionWiring, HTTPWiringsMeta } from '../wirings/http/http.types.js';
+import { CoreMCPResource, MCPResourceMeta, CoreMCPTool, MCPToolMeta, CoreMCPPrompt, MCPPromptMeta } from '../wirings/mcp/mcp.types.js';
+import { CoreQueueWorker, QueueWorkersMeta } from '../wirings/queue/queue.types.js';
+import { CoreScheduledTask, ScheduledTasksMeta } from '../wirings/scheduler/scheduler.types.js';
+import { CoreWorkflow, WorkflowsRuntimeMeta, WorkflowWires } from '../wirings/workflow/workflow.types.js';
+import type { WorkflowGraphDefinition, GraphNodeConfig } from '../wirings/workflow/graph/workflow-graph.types.js';
+import { CoreTrigger, TriggerMeta } from '../wirings/trigger/trigger.types.js';
+import { FunctionsMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup, FunctionServicesMeta, CreateConfig, CreateSingletonServices, CreateWireServices, CoreConfig, CoreSingletonServices, CoreServices, CoreUserSession } from './core.types.js';
+/**
+ * State structure for an individual package
+ */
+export interface PikkuPackageState {
+    function: {
+        meta: FunctionsMeta;
+        functions: Map<string, CorePikkuFunctionConfig<any, any>>;
+    };
+    rpc: {
+        meta: Record<string, string>;
+        files: Map<string, {
+            exportedName: string;
+            path: string;
+        }>;
+        /** Maps namespace aliases to package names (e.g., 'ext' -> '@pikku/templates-function-external') */
+        externalPackages: Map<string, string>;
+    };
+    http: {
+        middleware: Map<string, CorePikkuMiddleware<any, any>[]>;
+        permissions: Map<string, CorePermissionGroup | CorePikkuPermission[]>;
+        routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionWiring<any, any, any>>>;
+        meta: HTTPWiringsMeta;
+    };
+    channel: {
+        channels: Map<string, CoreChannel<any, any>>;
+        meta: ChannelsMeta;
+    };
+    scheduler: {
+        tasks: Map<string, CoreScheduledTask>;
+        meta: ScheduledTasksMeta;
+    };
+    queue: {
+        registrations: Map<string, CoreQueueWorker>;
+        meta: QueueWorkersMeta;
+    };
+    workflows: {
+        registrations: Map<string, CoreWorkflow>;
+        graphRegistrations: Map<string, WorkflowGraphDefinition<any>>;
+        /** DSL workflow wirings (from wireWorkflow({ func: ... })) */
+        wirings: Map<any, {
+            wires: WorkflowWires;
+            func: any;
+        }>;
+        /** Graph workflow wirings (from wireWorkflow({ graph: ... })) */
+        graphWirings: Map<any, {
+            wires: WorkflowWires;
+            graph: Record<string, GraphNodeConfig<string>>;
+        }>;
+        meta: WorkflowsRuntimeMeta;
+    };
+    trigger: {
+        triggers: Map<string, CoreTrigger>;
+        meta: TriggerMeta;
+    };
+    mcp: {
+        resources: Map<string, CoreMCPResource>;
+        resourcesMeta: MCPResourceMeta;
+        tools: Map<string, CoreMCPTool>;
+        toolsMeta: MCPToolMeta;
+        prompts: Map<string, CoreMCPPrompt>;
+        promptsMeta: MCPPromptMeta;
+    };
+    cli: {
+        meta: CLIMeta | Record<string, any>;
+        programs: Record<string, CLIProgramState>;
+    };
+    middleware: {
+        tagGroup: Record<string, CorePikkuMiddlewareGroup>;
+        httpGroup: Record<string, CorePikkuMiddlewareGroup>;
+        tagGroupMeta: Record<string, {
+            exportName: string | null;
+            sourceFile: string;
+            position: number;
+            services: FunctionServicesMeta;
+            middlewareCount: number;
+            isFactory: boolean;
+        }>;
+        httpGroupMeta: Record<string, {
+            exportName: string | null;
+            sourceFile: string;
+            position: number;
+            services: FunctionServicesMeta;
+            middlewareCount: number;
+            isFactory: boolean;
+        }>;
+    };
+    permissions: {
+        tagGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
+        httpGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
+        tagGroupMeta: Record<string, {
+            exportName: string | null;
+            sourceFile: string;
+            position: number;
+            services: FunctionServicesMeta;
+            permissionCount: number;
+            isFactory: boolean;
+        }>;
+        httpGroupMeta: Record<string, {
+            exportName: string | null;
+            sourceFile: string;
+            position: number;
+            services: FunctionServicesMeta;
+            permissionCount: number;
+            isFactory: boolean;
+        }>;
+    };
+    misc: {
+        errors: Map<PikkuError, ErrorDetails>;
+        schemas: Map<string, any>;
+        middleware: Record<string, CorePikkuMiddleware[]>;
+        permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
+    };
+    package: {
+        /** Service factory functions for external packages */
+        factories: {
+            createConfig?: CreateConfig<CoreConfig>;
+            createSingletonServices?: CreateSingletonServices<CoreConfig, CoreSingletonServices>;
+            createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, CoreUserSession>;
+        } | null;
+        /** Cached singleton services for this package */
+        singletonServices: CoreSingletonServices | null;
+    };
+}

package/dist/types/state.types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -1,5 +1,13 @@
 import { Logger } from './services/logger.js';
-export declare const closeSessionServices: (logger: Logger, sessionServices: Record<string, any>) => Promise<void>;
+import { CoreSingletonServices } from './types/core.types.js';
+export declare const closeWireServices: (logger: Logger, wireServices: Record<string, any>) => Promise<void>;
 export declare const createWeakUID: () => string;
 export declare const isSerializable: (data: any) => boolean;
 export declare const freezeDedupe: <T>(arr?: readonly T[] | T[] | undefined) => readonly T[];
+/**
+ * Stop all singleton services, including external package services.
+ * External package services are stopped first, then the parent services.
+ *
+ * @param singletonServices - The parent singleton services to stop
+ */
+export declare const stopSingletonServices: (singletonServices: CoreSingletonServices) => Promise<void>;

package/dist/utils.js

@@ -1,8 +1,8 @@
-// TODO: SessionServices probably needs it's own type
+// TODO: WireServices probably needs it's own type
 // but is an issue for the future and will be tackled
 // with dependency injection
-export const closeSessionServices = async (logger, sessionServices) => {
-    await Promise.all(Object.values(sessionServices).map(async (service) => {
+export const closeWireServices = async (logger, wireServices) => {
+    await Promise.all(Object.values(wireServices).map(async (service) => {
         if (service?.close) {
             try {
                 await service.close();
@@ -45,3 +45,48 @@ export const freezeDedupe = (arr) => {
     }
     return Object.freeze(out);
 };
+/**
+ * Stop a single service by calling its stop method if it exists
+ */
+const stopService = async (logger, name, service) => {
+    const stop = service?.stop;
+    if (stop) {
+        logger.info(`Stopping singleton service: ${name}`);
+        try {
+            await stop.call(service);
+        }
+        catch (e) {
+            logger.error(`Error stopping service ${name}:`, e);
+        }
+    }
+};
+/**
+ * Stop all singleton services, including external package services.
+ * External package services are stopped first, then the parent services.
+ *
+ * @param singletonServices - The parent singleton services to stop
+ */
+export const stopSingletonServices = async (singletonServices) => {
+    const logger = singletonServices.logger;
+    // First, stop all external package singleton services
+    if (globalThis.pikkuState) {
+        for (const [packageName, packageState] of globalThis.pikkuState) {
+            // Skip main package - we handle it separately
+            if (packageName === '__main__')
+                continue;
+            const packageServices = packageState.package?.singletonServices;
+            if (packageServices) {
+                logger.info(`Stopping singleton services for package: ${packageName}`);
+                for (const [name, service] of Object.entries(packageServices)) {
+                    await stopService(logger, `${packageName}/${name}`, service);
+                }
+                // Clear the cached services
+                packageState.package.singletonServices = null;
+            }
+        }
+    }
+    // Then stop the parent singleton services
+    for (const [name, service] of Object.entries(singletonServices)) {
+        await stopService(logger, name, service);
+    }
+};

package/dist/wirings/channel/channel-common.js

@@ -1,4 +1,3 @@
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 import { runPikkuFuncDirectly } from '../../function/function-runner.js';
 /**
@@ -24,13 +23,13 @@ export const runChannelLifecycleWithMiddleware = async ({ channelConfig, meta, l
         ? lifecycleConfig.middleware || []
         : [];
     // Use combineMiddleware to properly resolve metadata + inline middleware
-    const allMiddleware = combineMiddleware(PikkuWiringTypes.channel, `${channelConfig.name}:${lifecycleType}`, {
+    const allMiddleware = combineMiddleware('channel', `${channelConfig.name}:${lifecycleType}`, {
         wireInheritedMiddleware: meta.middleware,
         wireMiddleware: lifecycleMiddleware,
     });
     // Run the lifecycle function
     const runLifecycle = async () => {
-        return await runPikkuFuncDirectly(meta.pikkuFuncName, { ...services, channel }, data);
+        return await runPikkuFuncDirectly(meta.pikkuFuncName, services, { channel }, data);
     };
     // Run with middleware if any
     if (allMiddleware.length > 0) {

package/dist/wirings/channel/channel-handler.d.ts

@@ -1,3 +1,4 @@
-import { CoreServices } from '../../types/core.types.js';
+import { CoreServices, CoreUserSession } from '../../types/core.types.js';
 import { CoreChannel, PikkuChannelHandler } from './channel.types.js';
-export declare const processMessageHandlers: (services: CoreServices, channelConfig: CoreChannel<any, any>, channelHandler: PikkuChannelHandler) => (rawData: any) => Promise<unknown>;
+import { SessionService } from '../../services/user-session-service.js';
+export declare const processMessageHandlers: (services: CoreServices, channelConfig: CoreChannel<any, any>, channelHandler: PikkuChannelHandler, userSession?: SessionService<CoreUserSession>) => (rawData: any) => Promise<unknown>;

package/dist/wirings/channel/channel-handler.js

@@ -1,8 +1,7 @@
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { pikkuState } from '../../pikku-state.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 const getRouteMeta = (channelName, routingProperty, routerValue) => {
-    const channelMeta = pikkuState('channel', 'meta')[channelName];
+    const channelMeta = pikkuState(null, 'channel', 'meta')[channelName];
     if (!channelMeta) {
         throw new Error(`Channel ${channelName} not found`);
     }
@@ -32,7 +31,7 @@ const validateAuth = (requiresSession, session, onMessage) => {
     }
     return true;
 };
-export const processMessageHandlers = (services, channelConfig, channelHandler) => {
+export const processMessageHandlers = (services, channelConfig, channelHandler, userSession) => {
     const logger = services.logger;
     const requiresSession = channelConfig.auth !== false;
     const processMessage = async (data, onMessage, routingProperty, routerValue) => {
@@ -69,20 +68,18 @@ export const processMessageHandlers = (services, channelConfig, channelHandler)
         const cacheKey = routingProperty
             ? `${channelConfig.name}:${routingProperty}:${routerValue}`
             : `${channelConfig.name}:default`;
-        return await runPikkuFunc(PikkuWiringTypes.channel, cacheKey, pikkuFuncName, {
+        return await runPikkuFunc('channel', cacheKey, pikkuFuncName, {
             singletonServices: services,
-            getAllServices: () => ({
-                ...services,
-                channel: channelHandler.getChannel(),
-            }),
             data: () => data,
-            userSession: services.userSession,
             inheritedMiddleware,
             wireMiddleware,
             inheritedPermissions,
             wirePermissions,
             tags: channelConfig.tags,
-            interaction: { channel: channelHandler.getChannel() },
+            wire: {
+                channel: channelHandler.getChannel(),
+                session: userSession,
+            },
         });
     };
     return async (rawData) => {

package/dist/wirings/channel/channel-runner.d.ts

@@ -1,5 +1,5 @@
 import { CorePikkuPermission } from '../../function/functions.types.js';
-import { UserSessionService } from '../../services/user-session-service.js';
+import { SessionService } from '../../services/user-session-service.js';
 import { CorePikkuMiddleware } from '../../types/core.types.js';
 import { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
 /**
@@ -8,7 +8,7 @@ import { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from '.
  */
 export declare const wireChannel: <In, Channel extends string, PikkuPermission extends CorePikkuPermission<In>, PikkuMiddleware extends CorePikkuMiddleware, ChannelFunction>(channel: CoreChannel<In, Channel, PikkuPermission, PikkuMiddleware, ChannelFunction>) => void;
 export declare const openChannel: ({ route, singletonServices, coerceDataFromSchema, request, }: Pick<CoreChannel<unknown, string>, "route"> & RunChannelParams<unknown> & {
-    userSession: UserSessionService<any>;
+    userSession: SessionService<any>;
 } & RunChannelOptions) => Promise<{
     openingData: unknown;
     channelConfig: CoreChannel<unknown, any>;

package/dist/wirings/channel/channel-runner.js

@@ -9,12 +9,12 @@ import { httpRouter } from '../http/routers/http-router.js';
  */
 export const wireChannel = (channel) => {
     // Get the channel metadata
-    const channelsMeta = pikkuState('channel', 'meta');
+    const channelsMeta = pikkuState(null, 'channel', 'meta');
     const channelMeta = channelsMeta[channel.name];
     if (!channelMeta) {
         throw new Error(`Channel metadata not found for channel: ${channel.name}`);
     }
-    pikkuState('channel', 'channels').set(channel.name, channel);
+    pikkuState(null, 'channel', 'channels').set(channel.name, channel);
     // Register onConnect function if provided
     if (channel.onConnect && channelMeta.connect) {
         addFunction(channelMeta.connect.pikkuFuncName, channel.onConnect);
@@ -50,19 +50,19 @@ export const wireChannel = (channel) => {
         });
     }
     // Store the channel configuration
-    pikkuState('channel', 'channels').set(channel.name, channel);
+    pikkuState(null, 'channel', 'channels').set(channel.name, channel);
 };
 const getMatchingChannelConfig = (path) => {
     const matchedPath = httpRouter.match('get', path);
     if (!matchedPath) {
         return null;
     }
-    const meta = pikkuState('channel', 'meta');
+    const meta = pikkuState(null, 'channel', 'meta');
     const channelMeta = Object.values(meta).find((channelConfig) => channelConfig.route === matchedPath.route);
     if (!channelMeta) {
         return null;
     }
-    const channels = pikkuState('channel', 'channels');
+    const channels = pikkuState(null, 'channel', 'channels');
     const channelConfig = channels.get(channelMeta.name);
     if (!channelConfig) {
         return null;

package/dist/wirings/channel/channel.types.d.ts

@@ -1,6 +1,6 @@
 import { PikkuError } from '../../errors/error-handler.js';
 import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
-import { PikkuDocs, CoreSingletonServices, CreateSessionServices, CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import { CoreSingletonServices, CreateWireServices, CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
 import { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
@@ -14,11 +14,14 @@ export type RunChannelParams<ChannelData> = {
     singletonServices: CoreSingletonServices;
     request?: PikkuHTTPRequest<ChannelData>;
     response?: PikkuHTTPResponse;
-    createSessionServices?: CreateSessionServices;
+    createWireServices?: CreateWireServices;
 };
 export interface ChannelMessageMeta {
     pikkuFuncName: string;
-    docs?: PikkuDocs;
+    summary?: string;
+    description?: string;
+    errors?: string[];
+    tags?: string[];
     middleware?: MiddlewareMetadata[];
     permissions?: PermissionMetadata[];
 }
@@ -33,13 +36,15 @@ export interface ChannelMeta {
     disconnect: ChannelMessageMeta | null;
     message: ChannelMessageMeta | null;
     messageWirings: Record<string, Record<string, ChannelMessageMeta>>;
-    docs?: PikkuDocs;
+    summary?: string;
+    description?: string;
+    errors?: string[];
     tags?: string[];
     middleware?: MiddlewareMetadata[];
     permissions?: PermissionMetadata[];
 }
 export type ChannelsMeta = Record<string, ChannelMeta>;
-export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = CorePikkuFunctionConfig<CorePikkuFunction<void, unknown, ChannelData> | CorePikkuFunctionSessionless<void, unknown, ChannelData>, CorePikkuPermission<void>, CorePikkuMiddleware>, ChannelDisconnect = CorePikkuFunctionConfig<CorePikkuFunction<void, void, ChannelData> | CorePikkuFunctionSessionless<void, void, ChannelData>, CorePikkuPermission<void>, CorePikkuMiddleware>, ChannelFunctionMessage = CorePikkuFunctionConfig<CorePikkuFunction<unknown, unknown, ChannelData> | CorePikkuFunctionSessionless<unknown, unknown, ChannelData>, CorePikkuPermission<unknown>, CorePikkuMiddleware>, PikkuPermission = CorePikkuPermission<ChannelData>, PikkuMiddleware = CorePikkuMiddleware> = {
+export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = CorePikkuFunctionConfig<CorePikkuFunction<void, unknown> | CorePikkuFunctionSessionless<void, unknown>, CorePikkuPermission<void>, CorePikkuMiddleware>, ChannelDisconnect = CorePikkuFunctionConfig<CorePikkuFunction<void, void> | CorePikkuFunctionSessionless<void, void>, CorePikkuPermission<void>, CorePikkuMiddleware>, ChannelFunctionMessage = CorePikkuFunctionConfig<CorePikkuFunction<unknown, unknown> | CorePikkuFunctionSessionless<unknown, unknown>, CorePikkuPermission<unknown>, CorePikkuMiddleware>, PikkuPermission = CorePikkuPermission<ChannelData>, PikkuMiddleware = CorePikkuMiddleware> = {
     name: string;
     route: Channel;
     onConnect?: ChannelConnect | {

package/dist/wirings/channel/local/local-channel-runner.d.ts

@@ -1,3 +1,3 @@
 import { CoreChannel, RunChannelOptions, RunChannelParams } from '../channel.types.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
-export declare const runLocalChannel: ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession, respondWith404, coerceDataFromSchema, logWarningsForStatusCodes, bubbleErrors, }: Partial<Pick<CoreChannel<unknown, any>, "route">> & RunChannelOptions & RunChannelParams<unknown>) => Promise<PikkuLocalChannelHandler | void>;
+export declare const runLocalChannel: ({ singletonServices, channelId, request, response, route, createWireServices, skipUserSession, respondWith404, coerceDataFromSchema, logWarningsForStatusCodes, bubbleErrors, }: Partial<Pick<CoreChannel<unknown, any>, "route">> & RunChannelOptions & RunChannelParams<unknown>) => Promise<PikkuLocalChannelHandler | void>;