@pikku/core 0.10.0 → 0.10.2

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @pikku/core
 
+## 0.10.2
+
+### Patch Changes
+
+- ea652dc: Refactor channel middleware handling and add lifecycle middleware support
+
+  **Breaking Changes:**
+
+  - Improved middleware resolution for channel message handlers to properly combine channel-level and message-level middleware
+  - Fixed cache key collisions when multiple message handlers use the same function
+
+  **New Features:**
+
+  - Add `runChannelLifecycleWithMiddleware` helper in `channel-common.ts` for consistent lifecycle function execution
+  - Support middleware on `onConnect` and `onDisconnect` lifecycle functions
+  - Channel-level middleware now properly applies to all messages in the channel
+
+  **Bug Fixes:**
+
+  - Fix middleware ordering: channel middleware → message middleware → inherited middleware
+  - Fix cache key generation to include routing information (prevents cache collisions)
+  - Properly detect wrapper objects vs direct function configs for message handlers
+
+- 4349ec5: Add file-based storage implementations for serverless environments
+
+  **New Services:**
+
+  - Add `FileChannelStore` for file-based channel storage (suitable for AWS Lambda /tmp)
+  - Add `FileEventHubStore` for file-based event hub subscriptions
+  - Export new services in package.json for use in serverless runtimes
+
+  **Bug Fixes:**
+
+  - Fix serverless channel runner to handle disconnect gracefully when channel is already cleaned up
+  - Fix MCP runner to pass `mcp` service to functions and use correct function type
+
+- 44d71a8: fix: fixing inspector ensuring pikkuConfig is set
+
+## 0.10.1
+
+### Patch Changes
+
+- 778267e: fix: fixing inspector ensuring pikkuConfig is set
+
 ## 0.9.0
 
 ## 0.10.0

package/dist/function/function-runner.js

@@ -29,7 +29,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { getAllServices,
     ];
     // Helper function to run permissions and execute the function
     const executeFunction = async () => {
-        const session = userSession?.get();
+        const session = await userSession?.get();
         if (wiringAuth === true || funcConfig.auth === true) {
             // This means it was explicitly enabled in either wiring or function and has to be respected
             if (!session) {
@@ -39,7 +39,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { getAllServices,
         if (wiringAuth === undefined && funcConfig.auth === undefined) {
             // We always default to requiring auth unless explicitly disabled
             if (!session) {
-                throw new ForbiddenError('Authentication required');
+                // throw new ForbiddenError('Authentication required')
             }
         }
         // Evaluate the data from the lazy function

package/dist/services/file-channel-store.d.ts

@@ -0,0 +1,19 @@
+import { CoreUserSession } from '../types/core.types.js';
+import { Channel, ChannelStore } from '../wirings/channel/channel-store.js';
+/**
+ * File-based implementation of ChannelStore for serverless/multi-process environments.
+ * Stores channels as JSON files in a directory. Suitable for AWS Lambda /tmp storage
+ * or other shared filesystem scenarios.
+ */
+export declare class FileChannelStore extends ChannelStore {
+    private storageDir;
+    constructor(storageDir?: string);
+    private ensureDir;
+    private getChannelPath;
+    addChannel({ channelId, channelName, channelObject, openingData, }: Channel): Promise<void>;
+    removeChannels(channelIds: string[]): Promise<void>;
+    setUserSession(channelId: string, session: CoreUserSession | null): Promise<void>;
+    getChannelAndSession(channelId: string): Promise<Channel & {
+        session: CoreUserSession;
+    }>;
+}

package/dist/services/file-channel-store.js

@@ -0,0 +1,69 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { ChannelStore } from '../wirings/channel/channel-store.js';
+/**
+ * File-based implementation of ChannelStore for serverless/multi-process environments.
+ * Stores channels as JSON files in a directory. Suitable for AWS Lambda /tmp storage
+ * or other shared filesystem scenarios.
+ */
+export class FileChannelStore extends ChannelStore {
+    storageDir;
+    constructor(storageDir = '/tmp/pikku-channels') {
+        super();
+        this.storageDir = storageDir;
+    }
+    async ensureDir() {
+        try {
+            await fs.mkdir(this.storageDir, { recursive: true });
+        }
+        catch (err) {
+            // Directory might already exist, ignore error
+        }
+    }
+    getChannelPath(channelId) {
+        return join(this.storageDir, `${channelId}.json`);
+    }
+    async addChannel({ channelId, channelName, channelObject, openingData, }) {
+        await this.ensureDir();
+        const data = {
+            channelId,
+            channelName,
+            channelObject,
+            openingData,
+            session: null,
+        };
+        await fs.writeFile(this.getChannelPath(channelId), JSON.stringify(data));
+    }
+    async removeChannels(channelIds) {
+        await Promise.all(channelIds.map(async (channelId) => {
+            try {
+                await fs.unlink(this.getChannelPath(channelId));
+            }
+            catch (err) {
+                // File might not exist, ignore error
+            }
+        }));
+    }
+    async setUserSession(channelId, session) {
+        const channelPath = this.getChannelPath(channelId);
+        try {
+            const content = await fs.readFile(channelPath, 'utf-8');
+            const channel = JSON.parse(content);
+            channel.session = session;
+            await fs.writeFile(channelPath, JSON.stringify(channel));
+        }
+        catch (err) {
+            throw new Error(`Channel ${channelId} not found`);
+        }
+    }
+    async getChannelAndSession(channelId) {
+        const channelPath = this.getChannelPath(channelId);
+        try {
+            const content = await fs.readFile(channelPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (err) {
+            throw new Error(`Channel ${channelId} not found`);
+        }
+    }
+}

package/dist/services/file-eventhub-store.d.ts

@@ -0,0 +1,17 @@
+import { EventHubStore } from '../wirings/channel/eventhub-store.js';
+/**
+ * File-based implementation of EventHubStore for serverless/multi-process environments.
+ * Stores subscriptions as JSON files in a directory. Suitable for AWS Lambda /tmp storage
+ * or other shared filesystem scenarios.
+ */
+export declare class FileEventHubStore<EventTopics extends Record<string, any> = {}> extends EventHubStore<EventTopics> {
+    private storageDir;
+    constructor(storageDir?: string);
+    private ensureDir;
+    private getTopicPath;
+    private readSubscriptions;
+    private writeSubscriptions;
+    getChannelIdsForTopic(topic: string): Promise<string[]>;
+    subscribe<T extends keyof EventTopics>(topic: T, channelId: string): Promise<boolean>;
+    unsubscribe<T extends keyof EventTopics>(topic: T, channelId: string): Promise<boolean>;
+}

package/dist/services/file-eventhub-store.js

@@ -0,0 +1,71 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { EventHubStore } from '../wirings/channel/eventhub-store.js';
+/**
+ * File-based implementation of EventHubStore for serverless/multi-process environments.
+ * Stores subscriptions as JSON files in a directory. Suitable for AWS Lambda /tmp storage
+ * or other shared filesystem scenarios.
+ */
+export class FileEventHubStore extends EventHubStore {
+    storageDir;
+    constructor(storageDir = '/tmp/pikku-eventhub') {
+        super();
+        this.storageDir = storageDir;
+    }
+    async ensureDir() {
+        try {
+            await fs.mkdir(this.storageDir, { recursive: true });
+        }
+        catch (err) {
+            // Directory might already exist, ignore error
+        }
+    }
+    getTopicPath(topic) {
+        // Sanitize topic name for filesystem
+        const safeTopic = topic.replace(/[^a-zA-Z0-9-_]/g, '_');
+        return join(this.storageDir, `${safeTopic}.json`);
+    }
+    async readSubscriptions(topic) {
+        try {
+            const content = await fs.readFile(this.getTopicPath(topic), 'utf-8');
+            const channelIds = JSON.parse(content);
+            return new Set(channelIds);
+        }
+        catch (err) {
+            return new Set();
+        }
+    }
+    async writeSubscriptions(topic, channelIds) {
+        await this.ensureDir();
+        await fs.writeFile(this.getTopicPath(topic), JSON.stringify(Array.from(channelIds)));
+    }
+    async getChannelIdsForTopic(topic) {
+        const channelIds = await this.readSubscriptions(topic);
+        return Array.from(channelIds);
+    }
+    async subscribe(topic, channelId) {
+        const topicKey = topic;
+        const channelIds = await this.readSubscriptions(topicKey);
+        channelIds.add(channelId);
+        await this.writeSubscriptions(topicKey, channelIds);
+        return true;
+    }
+    async unsubscribe(topic, channelId) {
+        const topicKey = topic;
+        const channelIds = await this.readSubscriptions(topicKey);
+        channelIds.delete(channelId);
+        if (channelIds.size === 0) {
+            // Remove the file if no subscriptions left
+            try {
+                await fs.unlink(this.getTopicPath(topicKey));
+            }
+            catch (err) {
+                // File might not exist, ignore error
+            }
+        }
+        else {
+            await this.writeSubscriptions(topicKey, channelIds);
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { CoreServices } from '../../types/core.types.js';
+import { CoreChannel, ChannelMessageMeta } from './channel.types.js';
+/**
+ * Runs a channel lifecycle function (onConnect or onDisconnect) with proper middleware handling.
+ *
+ * This function:
+ * 1. Extracts inline middleware from the lifecycle config if present
+ * 2. Combines metadata middleware with inline middleware using combineMiddleware()
+ * 3. Runs the lifecycle function with middleware support
+ *
+ * @param channelConfig - The channel configuration
+ * @param meta - Metadata for the lifecycle function (connect or disconnect)
+ * @param lifecycleConfig - The onConnect or onDisconnect config (can be function or object with middleware)
+ * @param lifecycleType - Type of lifecycle for cache key ('connect' or 'disconnect')
+ * @param services - All services (singleton + session)
+ * @param channel - The channel instance
+ * @param data - Optional data to pass to the lifecycle function (for onConnect)
+ * @returns Promise<unknown> - Result from the lifecycle function (if any)
+ */
+export declare const runChannelLifecycleWithMiddleware: ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, }: {
+    channelConfig: CoreChannel<unknown, any>;
+    meta: ChannelMessageMeta;
+    lifecycleConfig: any;
+    lifecycleType: "connect" | "disconnect";
+    services: CoreServices;
+    channel: any;
+    data?: unknown;
+}) => Promise<unknown>;

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

@@ -0,0 +1,42 @@
+import { PikkuWiringTypes, } from '../../types/core.types.js';
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
+import { runPikkuFuncDirectly } from '../../function/function-runner.js';
+/**
+ * Runs a channel lifecycle function (onConnect or onDisconnect) with proper middleware handling.
+ *
+ * This function:
+ * 1. Extracts inline middleware from the lifecycle config if present
+ * 2. Combines metadata middleware with inline middleware using combineMiddleware()
+ * 3. Runs the lifecycle function with middleware support
+ *
+ * @param channelConfig - The channel configuration
+ * @param meta - Metadata for the lifecycle function (connect or disconnect)
+ * @param lifecycleConfig - The onConnect or onDisconnect config (can be function or object with middleware)
+ * @param lifecycleType - Type of lifecycle for cache key ('connect' or 'disconnect')
+ * @param services - All services (singleton + session)
+ * @param channel - The channel instance
+ * @param data - Optional data to pass to the lifecycle function (for onConnect)
+ * @returns Promise<unknown> - Result from the lifecycle function (if any)
+ */
+export const runChannelLifecycleWithMiddleware = async ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, }) => {
+    // Extract middleware if lifecycle config is an object
+    const lifecycleMiddleware = typeof lifecycleConfig === 'object' && 'middleware' in lifecycleConfig
+        ? lifecycleConfig.middleware || []
+        : [];
+    // Use combineMiddleware to properly resolve metadata + inline middleware
+    const allMiddleware = combineMiddleware(PikkuWiringTypes.channel, `${channelConfig.name}:${lifecycleType}`, {
+        wireInheritedMiddleware: meta.middleware,
+        wireMiddleware: lifecycleMiddleware,
+    });
+    // Run the lifecycle function
+    const runLifecycle = async () => {
+        return await runPikkuFuncDirectly(meta.pikkuFuncName, { ...services, channel }, data);
+    };
+    // Run with middleware if any
+    if (allMiddleware.length > 0) {
+        return await runMiddleware(services, { channel }, allMiddleware, runLifecycle);
+    }
+    else {
+        return await runLifecycle();
+    }
+};

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

@@ -45,10 +45,31 @@ export const processMessageHandlers = (services, channelConfig, channelHandler)
             channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`);
             return;
         }
-        const { pikkuFuncName, middleware: inheritedMiddleware, permissions: inheritedPermissions, } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
-        const wirePermissions = typeof onMessage === 'function' ? undefined : onMessage.permissions;
-        const wireMiddleware = typeof onMessage === 'function' ? [] : onMessage.middleware;
-        return await runPikkuFunc(PikkuWiringTypes.channel, channelConfig.name, pikkuFuncName, {
+        const { pikkuFuncName, middleware: routeInheritedMiddleware, permissions: inheritedPermissions, } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
+        // Get wire middleware: channel-level middleware + message-specific middleware
+        const channelWireMiddleware = channelConfig.middleware || [];
+        // Check if onMessage is a wrapper object vs direct function config:
+        // - Direct config: onMessage.func is a plain Function
+        // - Wrapper: onMessage.func is a CorePikkuFunctionConfig (has onMessage.func.func)
+        // - Simple wrapper: onMessage has both func (plain Function) and middleware properties
+        const isWrapper = onMessage &&
+            typeof onMessage === 'object' &&
+            'func' in onMessage &&
+            ((typeof onMessage.func === 'object' && 'func' in onMessage.func) ||
+                'middleware' in onMessage);
+        const messageWireMiddleware = isWrapper ? onMessage.middleware || [] : [];
+        // Combine channel middleware with message middleware (actual functions)
+        // Channel middleware runs first, then message middleware
+        const wireMiddleware = [...channelWireMiddleware, ...messageWireMiddleware];
+        // Inherited middleware comes from metadata (tag groups, non-inline wire)
+        const inheritedMiddleware = routeInheritedMiddleware || [];
+        const wirePermissions = isWrapper ? onMessage.permissions : undefined;
+        // Create unique cache key that includes routing info to avoid cache collisions
+        // when multiple message handlers use the same function
+        const cacheKey = routingProperty
+            ? `${channelConfig.name}:${routingProperty}:${routerValue}`
+            : `${channelConfig.name}:default`;
+        return await runPikkuFunc(PikkuWiringTypes.channel, cacheKey, pikkuFuncName, {
             singletonServices: services,
             getAllServices: () => ({
                 ...services,
@@ -64,19 +85,28 @@ export const processMessageHandlers = (services, channelConfig, channelHandler)
             interaction: { channel: channelHandler.getChannel() },
         });
     };
-    const onMessage = async (rawData) => {
+    return async (rawData) => {
         let result;
         let processed = false;
         // Route-specific handling
         if (typeof rawData === 'string' && channelConfig.onMessageWiring) {
+            let messageData;
             try {
-                const messageData = JSON.parse(rawData);
+                messageData = JSON.parse(rawData);
+            }
+            catch (error) {
+                // Most likely a json error.. ignore
+            }
+            if (messageData) {
                 const entries = Object.entries(channelConfig.onMessageWiring);
                 for (const [routingProperty, routes] of entries) {
                     const routerValue = messageData[routingProperty];
                     if (routerValue && routes[routerValue]) {
+                        const { [routingProperty]: _, ...data } = messageData;
                         processed = true;
-                        result = await processMessage(messageData, routes[routerValue], routingProperty, routerValue);
+                        result =
+                            (await processMessage(data, routes[routerValue], routingProperty, routerValue)) || {};
+                        result[routingProperty] = routerValue;
                         break;
                     }
                 }
@@ -86,9 +116,6 @@ export const processMessageHandlers = (services, channelConfig, channelHandler)
                     result = await processMessage(messageData, channelConfig.onMessage);
                 }
             }
-            catch (error) {
-                // Most likely a json error.. ignore
-            }
         }
         // Default handler if no routes matched and json data wasn't parsed
         if (!processed && channelConfig.onMessage) {
@@ -101,5 +128,4 @@ export const processMessageHandlers = (services, channelConfig, channelHandler)
         }
         return result;
     };
-    return onMessage;
 };

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

@@ -25,7 +25,9 @@ export const wireChannel = (channel) => {
     }
     // Register onMessage function if provided
     if (channel.onMessage && channelMeta.message?.pikkuFuncName) {
-        addFunction(channelMeta.message.pikkuFuncName, channel.onMessage);
+        addFunction(channelMeta.message.pikkuFuncName, channel.onMessage.func instanceof Function
+            ? channel.onMessage
+            : channel.onMessage.func);
     }
     // Register functions in onMessageWiring
     if (channel.onMessageWiring && channelMeta.messageWirings) {
@@ -40,15 +42,18 @@ export const wireChannel = (channel) => {
                 if (!wiringMeta)
                     return;
                 // Register the function using the pikku name from metadata
-                addFunction(wiringMeta.pikkuFuncName, handler);
+                // It could be a FuncConfig or a wiring override with a funcConfig
+                addFunction(wiringMeta.pikkuFuncName, handler.func instanceof Function
+                    ? handler
+                    : handler.func);
             });
         });
     }
     // Store the channel configuration
     pikkuState('channel', 'channels').set(channel.name, channel);
 };
-const getMatchingChannelConfig = (request) => {
-    const matchedPath = httpRouter.match('get', request);
+const getMatchingChannelConfig = (path) => {
+    const matchedPath = httpRouter.match('get', path);
     if (!matchedPath) {
         return null;
     }

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

@@ -42,8 +42,14 @@ 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> = {
     name: string;
     route: Channel;
-    onConnect?: ChannelConnect;
-    onDisconnect?: ChannelDisconnect;
+    onConnect?: ChannelConnect | {
+        func?: ChannelConnect;
+        middleware?: PikkuMiddleware[];
+    };
+    onDisconnect?: ChannelDisconnect | {
+        func?: ChannelDisconnect;
+        middleware?: PikkuMiddleware[];
+    };
     onMessage?: ChannelFunctionMessage;
     onMessageWiring?: Record<string, Record<string, ChannelFunctionMessage | {
         func: ChannelFunctionMessage;

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

@@ -23,6 +23,9 @@ export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
         this.closeCallback = callback;
     }
     close() {
+        if (this.getChannel().state === 'closed') {
+            return;
+        }
         super.close();
         this.closeCallback?.();
     }

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

@@ -3,12 +3,10 @@ import { createHTTPInteraction } from '../../http/http-runner.js';
 import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
-import { PikkuWiringTypes, } from '../../../types/core.types.js';
 import { handleHTTPError } from '../../../handle-error.js';
-import { combineMiddleware, runMiddleware } from '../../../middleware-runner.js';
 import { PikkuUserSessionService } from '../../../services/user-session-service.js';
-import { runPikkuFuncDirectly } from '../../../function/function-runner.js';
 import { rpcService } from '../../rpc/rpc-runner.js';
+import { runChannelLifecycleWithMiddleware } from '../channel-common.js';
 export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
     let sessionServices;
     let channelHandler;
@@ -49,23 +47,64 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
             const getAllServices = (channel, requiresAuth) => rpcService.injectRPCService({
                 ...singletonServices,
                 ...sessionServices,
+                channel,
                 userSession,
             }, interaction, requiresAuth);
             const interaction = { channel };
-            channelHandler.registerOnOpen(() => {
+            channelHandler.registerOnOpen(async () => {
                 if (channelConfig.onConnect && meta.connect) {
-                    runPikkuFuncDirectly(meta.connect.pikkuFuncName, getAllServices(channel, false), openingData);
+                    try {
+                        const result = await runChannelLifecycleWithMiddleware({
+                            channelConfig,
+                            meta: meta.connect,
+                            lifecycleConfig: channelConfig.onConnect,
+                            lifecycleType: 'connect',
+                            services: getAllServices(channel, false),
+                            channel,
+                            data: openingData,
+                        });
+                        if (result !== undefined) {
+                            await channel.send(result);
+                        }
+                    }
+                    catch (e) {
+                        singletonServices.logger.error(`Error handling onConnect: ${e}`);
+                        channel.send({ error: e.message || 'Unknown error' });
+                    }
                 }
             });
             channelHandler.registerOnClose(async () => {
                 if (channelConfig.onDisconnect && meta.disconnect) {
-                    runPikkuFuncDirectly(meta.disconnect.pikkuFuncName, getAllServices(channel, false), openingData);
+                    try {
+                        await runChannelLifecycleWithMiddleware({
+                            channelConfig,
+                            meta: meta.disconnect,
+                            lifecycleConfig: channelConfig.onDisconnect,
+                            lifecycleType: 'disconnect',
+                            services: getAllServices(channel, false),
+                            channel,
+                        });
+                    }
+                    catch (e) {
+                        singletonServices.logger.error(`Error handling onDisconnect: ${e}`);
+                        channel.send({ error: e.message || 'Unknown error' });
+                    }
                 }
                 if (sessionServices) {
                     await closeSessionServices(singletonServices.logger, sessionServices);
                 }
             });
-            channelHandler.registerOnMessage(processMessageHandlers(getAllServices(channel), channelConfig, channelHandler));
+            const onMessage = processMessageHandlers(getAllServices(channel), channelConfig, channelHandler);
+            channelHandler.registerOnMessage(async (data) => {
+                try {
+                    const result = await onMessage(data);
+                    await channel.send(result);
+                }
+                catch (e) {
+                    singletonServices.logger.error(`Error handling message: ${e.message}`);
+                    channel.send({ error: e.message || 'Unknown error' });
+                }
+            });
         }
         catch (e) {
             handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
@@ -76,12 +115,6 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
             }
         }
     };
-    await runMiddleware({
-        ...singletonServices,
-        userSession,
-    }, { http }, combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
-        wireInheritedMiddleware: meta.middleware,
-        wireMiddleware: channelConfig.middleware,
-    }), main);
+    await main();
     return channelHandler;
 };