@pikku/core 0.12.0 → 0.12.2

package/dist/wirings/ai-agent/index.js

@@ -1,4 +1,6 @@
+export { agent, agentStream, agentResume, agentApprove, } from './ai-agent-helpers.js';
 export { runAIAgent } from './ai-agent-runner.js';
 export { streamAIAgent, resumeAIAgent } from './ai-agent-stream.js';
+export { createAssistantUIChannel, parseAssistantUIInput, } from './ai-agent-assistant-ui.js';
 export { ToolApprovalRequired, } from './ai-agent-prepare.js';
 export { addAIAgent, approveAIAgent, getAIAgents, getAIAgentsMeta, } from './ai-agent-registry.js';

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

@@ -1,5 +1,5 @@
-import { CoreSingletonServices, MiddlewareMetadata } from '../../types/core.types.js';
-import { CoreChannel, ChannelMessageMeta } from './channel.types.js';
+import type { CoreSingletonServices, MiddlewareMetadata } from '../../types/core.types.js';
+import type { CoreChannel, ChannelMessageMeta } from './channel.types.js';
 /**
  * Runs a channel lifecycle function (onConnect or onDisconnect) with proper middleware handling.
  *

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

@@ -1,4 +1,7 @@
-import { CoreServices, CoreUserSession } from '../../types/core.types.js';
-import { CoreChannel, PikkuChannelHandler } from './channel.types.js';
-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>;
+import type { CoreServices, CoreUserSession } from '../../types/core.types.js';
+import type { BinaryData, CoreChannel, PikkuChannelHandler } from './channel.types.js';
+import type { SessionService } from '../../services/user-session-service.js';
+export declare const processMessageHandlers: (services: CoreServices, channelConfig: CoreChannel<any, any>, channelHandler: PikkuChannelHandler, userSession?: SessionService<CoreUserSession>) => {
+    onMessage: (rawData: unknown) => Promise<unknown>;
+    onBinaryMessage: ((data: BinaryData) => Promise<BinaryData | void>) | undefined;
+};

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

@@ -1,6 +1,6 @@
 import { pikkuState } from '../../pikku-state.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
-import { createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
+import { createMiddlewareSessionWireProps } from '../../services/user-session-service.js';
 const getChannelMeta = (channelName) => {
     return pikkuState(null, 'channel', 'meta')[channelName];
 };
@@ -39,7 +39,7 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
     const logger = services.logger;
     const requiresSession = channelConfig.auth !== false;
     const processMessage = async (data, onMessage, routingProperty, routerValue) => {
-        if (!validateAuth(requiresSession, channelHandler, onMessage)) {
+        if (!validateAuth(requiresSession, userSession?.get(), onMessage)) {
             const routeMessage = routingProperty
                 ? `route '${routingProperty}:${routerValue}'`
                 : 'the default message route';
@@ -91,7 +91,7 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
             },
         });
     };
-    return async (rawData) => {
+    const onMessage = async (rawData) => {
         let result;
         let processed = false;
         // Route-specific handling
@@ -100,7 +100,7 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
             try {
                 messageData = JSON.parse(rawData);
             }
-            catch (error) {
+            catch {
                 // Most likely a json error.. ignore
             }
             if (messageData) {
@@ -130,8 +130,18 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
         }
         if (!processed) {
             logger.error(`No handler found for message in channel ${channelConfig.name} for ${JSON.stringify(rawData)}`);
-            logger.error(`Channel ${JSON.stringify(channelConfig)}`);
+            logger.error(`Channel config name: ${channelConfig.name}`);
         }
         return result;
     };
+    const onBinaryMessage = channelConfig.onBinaryMessage
+        ? async (data) => {
+            if (!validateAuth(requiresSession, userSession?.get(), channelConfig)) {
+                logger.error(`Channel ${channelConfig.name} with id ${channelHandler.getChannel().channelId} requires a session for binary message`);
+                return;
+            }
+            return channelConfig.onBinaryMessage(services, data, channelHandler.getChannel());
+        }
+        : undefined;
+    return { onMessage, onBinaryMessage };
 };

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

@@ -68,6 +68,7 @@ export function wrapChannelWithMiddleware(wire, services, middlewares) {
         channel: {
             ...channel,
             send: ((data) => dispatch(0, data)),
+            sendBinary: channel.sendBinary,
         },
     };
 }

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

@@ -1,13 +1,13 @@
-import { CorePikkuPermission } from '../../function/functions.types.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';
+import type { CorePikkuPermission } from '../../function/functions.types.js';
+import type { SessionService } from '../../services/user-session-service.js';
+import type { CorePikkuMiddleware } from '../../types/core.types.js';
+import type { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
 /**
  * Adds a channel and registers all functions referenced in it using the
  * function names already stored in the channel metadata
  */
 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> & {
+export declare const openChannel: ({ route, coerceDataFromSchema, request, }: Pick<CoreChannel<unknown, string>, "route"> & RunChannelParams<unknown> & {
     userSession: SessionService<any>;
 } & RunChannelOptions) => Promise<{
     openingData: unknown;

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

@@ -1,6 +1,6 @@
 import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
 import { addFunction } from '../../function/function-runner.js';
-import { pikkuState } from '../../pikku-state.js';
+import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js';
 import { httpRouter } from '../http/routers/http-router.js';
 /**
@@ -75,7 +75,8 @@ const getMatchingChannelConfig = (path) => {
         meta: channelMeta,
     };
 };
-export const openChannel = async ({ route, singletonServices, coerceDataFromSchema = true, request, }) => {
+export const openChannel = async ({ route, coerceDataFromSchema = true, request, }) => {
+    const singletonServices = getSingletonServices();
     const matchingChannel = getMatchingChannelConfig(route);
     if (!matchingChannel) {
         singletonServices.logger.info(`Channel not found: ${route}`);

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

@@ -1,4 +1,4 @@
-import { CoreUserSession } from '../../types/core.types.js';
+import type { CoreUserSession } from '../../types/core.types.js';
 export type Channel<ChannelType = unknown, OpeningData = unknown> = {
     channelId: string;
     channelName: string;

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

@@ -1,9 +1,10 @@
-import { PikkuError } from '../../errors/error-handler.js';
-import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
-import { CoreSingletonServices, CreateWireServices, CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import type { PikkuError } from '../../errors/error-handler.js';
+import type { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
+import type { CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+export type BinaryData = ArrayBuffer | Uint8Array;
 export type CorePikkuChannelMiddleware<Services = any, Event = unknown> = (services: Services, event: Event, next: (event: Event | Event[] | null) => Promise<void> | void) => Promise<void> | void;
 export type CorePikkuChannelMiddlewareFactory<In = any, Services = any, Event = unknown> = (input: In) => CorePikkuChannelMiddleware<Services, Event>;
-import { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
+import type { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
     respondWith404: boolean;
@@ -13,10 +14,8 @@ export type RunChannelOptions = Partial<{
 }>;
 export type RunChannelParams<ChannelData> = {
     channelId: string;
-    singletonServices: CoreSingletonServices;
     request?: PikkuHTTPRequest<ChannelData>;
     response?: PikkuHTTPResponse;
-    createWireServices?: CreateWireServices;
 };
 export interface ChannelMessageMeta {
     pikkuFuncId: string;
@@ -38,6 +37,7 @@ export interface ChannelMeta {
     disconnect: ChannelMessageMeta | null;
     message: ChannelMessageMeta | null;
     messageWirings: Record<string, Record<string, ChannelMessageMeta>>;
+    binary?: boolean | null;
     summary?: string;
     description?: string;
     errors?: string[];
@@ -69,6 +69,8 @@ export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = Co
     channelMiddleware?: Array<CorePikkuChannelMiddleware | CorePikkuChannelMiddlewareFactory>;
     permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: boolean;
+    binary?: boolean | null;
+    onBinaryMessage?: (services: any, data: BinaryData, channel: PikkuChannel<ChannelData, any>) => Promise<BinaryData | void> | BinaryData | void;
     docs?: Partial<{
         description: string;
         response: string;
@@ -81,11 +83,13 @@ export interface PikkuChannel<OpeningData, out Out> {
     channelId: string;
     openingData: OpeningData;
     send(data: Out, isBinary?: boolean): Promise<void> | void;
+    sendBinary(data: BinaryData): Promise<void> | void;
     close(): Promise<void> | void;
     state: 'initial' | 'open' | 'closed';
 }
 export interface PikkuChannelHandler<OpeningData = unknown, Out = unknown> {
     send(message: Out, isBinary?: boolean): Promise<void> | void;
+    sendBinary(data: BinaryData): Promise<void> | void;
     getChannel(): PikkuChannel<OpeningData, Out>;
 }
 export type PikkuChannelHandlerFactory<OpeningData = unknown, Out = unknown> = (channelId: string, channelName: string, openingData: OpeningData) => PikkuChannelHandler<OpeningData, Out>;

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

@@ -6,5 +6,5 @@ export type { EventHubService } from './eventhub-service.js';
 export { ChannelStore } from './channel-store.js';
 export type { Channel } from './channel-store.js';
 export { EventHubStore } from './eventhub-store.js';
-export type { ChannelsMeta, CoreChannel, CorePikkuChannelMiddleware, CorePikkuChannelMiddlewareFactory, ChannelMessageMeta, ChannelMeta, PikkuChannel, PikkuChannelHandlerFactory, } from './channel.types.js';
+export type { BinaryData, ChannelsMeta, CoreChannel, CorePikkuChannelMiddleware, CorePikkuChannelMiddlewareFactory, ChannelMessageMeta, ChannelMeta, PikkuChannel, PikkuChannelHandlerFactory, } from './channel.types.js';
 export { defineChannelRoutes } from './define-channel-routes.js';

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

@@ -1,15 +1,22 @@
+import type { BinaryData } from '../channel.types.js';
 import { PikkuAbstractChannelHandler } from '../pikku-abstract-channel-handler.js';
 export declare class PikkuLocalChannelHandler<OpeningData = unknown, Out = unknown> extends PikkuAbstractChannelHandler<OpeningData, Out> {
     private onMessageCallback?;
+    private onBinaryMessageCallback?;
     private openCallBack?;
     private closeCallback?;
     private sendCallback?;
+    private sendBinaryCallback?;
     registerOnOpen(callback: () => void): void;
     open(): void;
     registerOnMessage(callback: (data: any) => Promise<unknown>): void;
     message(data: unknown): Promise<unknown>;
+    registerOnBinaryMessage(callback: (data: BinaryData) => Promise<BinaryData | void> | BinaryData | void): void;
+    binaryMessage(data: BinaryData): Promise<BinaryData | void>;
     registerOnClose(callback: () => void): void;
     close(): void;
     registerOnSend(send: (message: Out) => void): void;
     send(message: Out, isBinary?: boolean): void;
+    registerOnSendBinary(send: (data: BinaryData) => void): void;
+    sendBinary(data: BinaryData): void;
 }

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

@@ -1,9 +1,11 @@
 import { PikkuAbstractChannelHandler } from '../pikku-abstract-channel-handler.js';
 export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
     onMessageCallback;
+    onBinaryMessageCallback;
     openCallBack;
     closeCallback;
     sendCallback;
+    sendBinaryCallback;
     registerOnOpen(callback) {
         this.openCallBack = callback;
     }
@@ -19,6 +21,12 @@ export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
     async message(data) {
         return this.onMessageCallback?.(data);
     }
+    registerOnBinaryMessage(callback) {
+        this.onBinaryMessageCallback = callback;
+    }
+    async binaryMessage(data) {
+        return this.onBinaryMessageCallback?.(data);
+    }
     registerOnClose(callback) {
         this.closeCallback = callback;
     }
@@ -38,4 +46,13 @@ export class PikkuLocalChannelHandler extends PikkuAbstractChannelHandler {
         }
         return this.sendCallback?.(message, isBinary);
     }
+    registerOnSendBinary(send) {
+        this.sendBinaryCallback = send;
+    }
+    sendBinary(data) {
+        if (!this.sendBinaryCallback) {
+            throw new Error('No sendBinary callback registered');
+        }
+        this.sendBinaryCallback(data);
+    }
 }

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

@@ -1,3 +1,8 @@
-import { CoreChannel, RunChannelOptions, RunChannelParams } from '../channel.types.js';
+import type { CoreChannel, RunChannelOptions } from '../channel.types.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
-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>;
+import type { PikkuHTTPRequest, PikkuHTTPResponse } from '../../http/http.types.js';
+export declare const runLocalChannel: ({ channelId, request, response, route, skipUserSession, respondWith404, coerceDataFromSchema, logWarningsForStatusCodes, bubbleErrors, }: Partial<Pick<CoreChannel<unknown, any>, "route">> & RunChannelOptions & {
+    channelId: string;
+    request?: PikkuHTTPRequest;
+    response?: PikkuHTTPResponse;
+}) => Promise<PikkuLocalChannelHandler | void>;

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

@@ -6,7 +6,10 @@ import { PikkuLocalChannelHandler } from './local-channel-handler.js';
 import { handleHTTPError } from '../../../handle-error.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../../services/user-session-service.js';
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js';
-export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createWireServices, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
+import { getSingletonServices, getCreateWireServices, } from '../../../pikku-state.js';
+export const runLocalChannel = async ({ channelId, request, response, route, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
     let closedWireServices = false;
     let channelHandler;
@@ -21,12 +24,10 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         ;
         ({ openingData, channelConfig, meta } = await openChannel({
             channelId,
-            createWireServices,
             respondWith404,
             request,
             response,
             route,
-            singletonServices,
             skipUserSession,
             coerceDataFromSchema,
             userSession,
@@ -98,7 +99,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                 }
                 await closeServices();
             });
-            const onMessage = processMessageHandlers(services, channelConfig, channelHandler, userSession);
+            const { onMessage, onBinaryMessage } = processMessageHandlers(services, channelConfig, channelHandler, userSession);
             channelHandler.registerOnMessage(async (data) => {
                 try {
                     const result = await onMessage(data);
@@ -109,6 +110,19 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                     channel.send({ error: e.message || 'Unknown error' });
                 }
             });
+            if (onBinaryMessage) {
+                channelHandler.registerOnBinaryMessage(async (data) => {
+                    try {
+                        const result = await onBinaryMessage(data);
+                        if (result) {
+                            await channel.sendBinary(result);
+                        }
+                    }
+                    catch (e) {
+                        singletonServices.logger.error(`Error handling binary message: ${e.message}`);
+                    }
+                });
+            }
         }
         catch (e) {
             handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);

package/dist/wirings/channel/local/local-eventhub-service.d.ts

@@ -1,5 +1,5 @@
-import { PikkuChannelHandler } from '../channel.types.js';
-import { EventHubService } from '../eventhub-service.js';
+import type { PikkuChannelHandler } from '../channel.types.js';
+import type { EventHubService } from '../eventhub-service.js';
 /**
  * Implementation of the SubscriptionService interface.
  * Manages subscriptions and publishes messages to subscribers.

package/dist/wirings/channel/log-channels.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../../services/index.js';
+import type { Logger } from '../../services/index.js';
 /**
  * Logs all the loaded channels.
  * @param logger - A logger for logging information.

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

@@ -1,4 +1,4 @@
-import { PikkuChannel, PikkuChannelHandler } from './channel.types.js';
+import type { BinaryData, PikkuChannel, PikkuChannelHandler } from './channel.types.js';
 export declare abstract class PikkuAbstractChannelHandler<OpeningData = unknown, Out = unknown> implements PikkuChannelHandler<OpeningData, Out> {
     channelId: string;
     channelName: string;
@@ -6,6 +6,7 @@ export declare abstract class PikkuAbstractChannelHandler<OpeningData = unknown,
     protected channel?: PikkuChannel<OpeningData, Out>;
     constructor(channelId: string, channelName: string, openingData: OpeningData);
     abstract send(message: Out, isBinary?: boolean): Promise<void> | void;
+    abstract sendBinary(data: BinaryData): Promise<void> | void;
     getChannel(): PikkuChannel<OpeningData, Out>;
     open(): void;
     close(): Promise<void> | void;

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

@@ -14,6 +14,7 @@ export class PikkuAbstractChannelHandler {
                 channelId: this.channelId,
                 openingData: this.openingData,
                 send: this.send.bind(this),
+                sendBinary: this.sendBinary.bind(this),
                 close: this.close.bind(this),
                 state: 'initial',
             };

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

@@ -1,10 +1,10 @@
 import type { CoreChannel, RunChannelOptions, RunChannelParams, PikkuChannelHandlerFactory } from '../channel.types.js';
-import { ChannelStore } from '../channel-store.js';
+import type { ChannelStore } from '../channel-store.js';
 export interface RunServerlessChannelParams<ChannelData> extends RunChannelParams<ChannelData> {
     channelStore: ChannelStore;
     channelHandlerFactory: PikkuChannelHandlerFactory;
     channelObject?: unknown;
 }
-export declare const runChannelConnect: ({ singletonServices, channelId, channelObject, request, response, route, createWireServices, channelStore, channelHandlerFactory, coerceDataFromSchema, logWarningsForStatusCodes, respondWith404, bubbleErrors, }: Pick<CoreChannel<unknown, any>, "route"> & RunChannelOptions & RunServerlessChannelParams<unknown>) => Promise<void>;
-export declare const runChannelDisconnect: ({ singletonServices, ...params }: RunServerlessChannelParams<unknown>) => Promise<void>;
-export declare const runChannelMessage: ({ singletonServices, ...params }: RunServerlessChannelParams<unknown>, data: unknown) => Promise<unknown>;
+export declare const runChannelConnect: ({ channelId, channelObject, request, response, route, channelStore, channelHandlerFactory, coerceDataFromSchema, logWarningsForStatusCodes, respondWith404, bubbleErrors, }: Pick<CoreChannel<unknown, any>, "route"> & RunChannelOptions & RunServerlessChannelParams<unknown>) => Promise<void>;
+export declare const runChannelDisconnect: ({ channelId, channelStore, channelHandlerFactory, }: RunServerlessChannelParams<unknown>) => Promise<void>;
+export declare const runChannelMessage: ({ channelId, channelStore, channelHandlerFactory, }: RunServerlessChannelParams<unknown>, data: unknown) => Promise<unknown>;

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

@@ -4,7 +4,7 @@ import { openChannel } from '../channel-runner.js';
 import { createHTTPWire } from '../../http/http-runner.js';
 import { handleHTTPError } from '../../../handle-error.js';
 import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../../services/user-session-service.js';
-import { pikkuState } from '../../../pikku-state.js';
+import { getSingletonServices, getCreateWireServices, pikkuState, } from '../../../pikku-state.js';
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js';
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js';
 const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory, openingData, }) => {
@@ -26,7 +26,9 @@ const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory,
         meta,
     };
 };
-export const runChannelConnect = async ({ singletonServices, channelId, channelObject, request, response, route, createWireServices, channelStore, channelHandlerFactory, coerceDataFromSchema = true, logWarningsForStatusCodes = [], respondWith404 = true, bubbleErrors = false, }) => {
+export const runChannelConnect = async ({ channelId, channelObject, request, response, route, channelStore, channelHandlerFactory, coerceDataFromSchema = true, logWarningsForStatusCodes = [], respondWith404 = true, bubbleErrors = false, }) => {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
     let http;
     if (request instanceof Request) {
@@ -35,10 +37,8 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
     const userSession = new PikkuSessionService(channelStore, channelId);
     const { channelConfig, openingData, meta } = await openChannel({
         channelId,
-        createWireServices,
         request,
         route,
-        singletonServices,
         coerceDataFromSchema,
         userSession,
     });
@@ -88,7 +88,9 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         }
     }
 };
-export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
+export const runChannelDisconnect = async ({ channelId, channelStore, channelHandlerFactory, }) => {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
     // Try to get channel from store. In serverless environments (especially with
     // serverless-offline or worker threads), disconnect can be called multiple times
@@ -96,26 +98,27 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
     // there's nothing to disconnect, so we can return early.
     let channelData;
     try {
-        channelData = await params.channelStore.getChannelAndSession(params.channelId);
+        channelData = await channelStore.getChannelAndSession(channelId);
     }
-    catch (error) {
-        singletonServices.logger.info(`Channel ${params.channelId} not found during disconnect - already cleaned up`);
+    catch {
+        singletonServices.logger.info(`Channel ${channelId} not found during disconnect - already cleaned up`);
         return;
     }
     const { openingData, channelName, session } = channelData;
     const { channel, channelConfig, meta } = getVariablesForChannel({
-        ...params,
+        channelId,
+        channelHandlerFactory,
         openingData,
         channelName,
     });
-    const userSession = new PikkuSessionService(params.channelStore, params.channelId);
+    const userSession = new PikkuSessionService(channelStore, channelId);
     userSession.setInitial(session);
     const wire = {
         channel,
         ...createMiddlewareSessionWireProps(userSession),
     };
-    if (!wireServices && params.createWireServices) {
-        wireServices = await params.createWireServices(singletonServices, wire);
+    if (createWireServices) {
+        wireServices = await createWireServices(singletonServices, wire);
     }
     const services = {
         ...singletonServices,
@@ -137,27 +140,30 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
             singletonServices.logger.error(`Error handling onDisconnect: ${e.message || e}`);
         }
     }
-    await params.channelStore.removeChannels([channel.channelId]);
+    await channelStore.removeChannels([channel.channelId]);
     if (wireServices) {
         await closeWireServices(singletonServices.logger, wireServices);
     }
 };
-export const runChannelMessage = async ({ singletonServices, ...params }, data) => {
+export const runChannelMessage = async ({ channelId, channelStore, channelHandlerFactory, }, data) => {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
-    const { openingData, channelName, session } = await params.channelStore.getChannelAndSession(params.channelId);
+    const { openingData, channelName, session } = await channelStore.getChannelAndSession(channelId);
     const { channel, channelHandler, channelConfig } = getVariablesForChannel({
-        ...params,
+        channelId,
+        channelHandlerFactory,
         openingData,
         channelName,
     });
-    const userSession = new PikkuSessionService(params.channelStore, params.channelId);
+    const userSession = new PikkuSessionService(channelStore, channelId);
     userSession.setInitial(session);
     const wire = {
         channel,
         ...createMiddlewareSessionWireProps(userSession),
     };
-    if (params.createWireServices) {
-        wireServices = await params.createWireServices(singletonServices, wire);
+    if (createWireServices) {
+        wireServices = await createWireServices(singletonServices, wire);
     }
     const services = {
         ...singletonServices,
@@ -165,7 +171,7 @@ export const runChannelMessage = async ({ singletonServices, ...params }, data)
     };
     let response;
     try {
-        const onMessage = processMessageHandlers(services, channelConfig, channelHandler, userSession);
+        const { onMessage } = processMessageHandlers(services, channelConfig, channelHandler, userSession);
         response = await onMessage(data);
     }
     catch (e) {

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

@@ -1,4 +1,4 @@
-import { CorePikkuCLIRender } from '../cli.types.js';
+import type { CorePikkuCLIRender } from '../cli.types.js';
 /**
  * Execute a CLI program via WebSocket channel
  * This is the main entry point for CLI-over-Channel clients

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

@@ -1,5 +1,5 @@
-import { CorePikkuMiddleware, CoreUserSession } from '../../types/core.types.js';
-import { CoreCLI, CorePikkuCLIRender, CoreCLICommandConfig } from './cli.types.js';
+import type { CorePikkuMiddleware, CoreUserSession } from '../../types/core.types.js';
+import type { CoreCLI, CorePikkuCLIRender, CoreCLICommandConfig } from './cli.types.js';
 import type { CoreSingletonServices, CoreServices, CreateWireServices, CreateConfig, CreateSingletonServices } from '../../types/core.types.js';
 /**
  * CLI command execution error - thrown when CLI execution fails

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

@@ -207,6 +207,9 @@ export async function runCLICommand({ program, commandPath, data, singletonServi
                 await Promise.resolve(renderer(singletonServices, data, undefined));
             }
         },
+        sendBinary: () => {
+            throw new Error('Binary data is not supported on CLI channels');
+        },
         close: () => {
             if (channel) {
                 channel.state = 'closed';

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

@@ -1,6 +1,6 @@
-import { CorePikkuMiddleware, CoreSingletonServices, CoreUserSession, CoreServices, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuFunction, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
-import { PikkuChannel } from '../channel/channel.types.js';
+import type { CorePikkuMiddleware, CoreSingletonServices, CoreUserSession, CoreServices, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import type { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuFunction, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
+import type { PikkuChannel } from '../channel/channel.types.js';
 /**
  * CLI option definition
  */

package/dist/wirings/cli/command-parser.d.ts

@@ -1,4 +1,4 @@
-import { CLIMeta } from './cli.types.js';
+import type { CLIMeta } from './cli.types.js';
 /**
  * Result of parsing CLI arguments
  */

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

@@ -0,0 +1,24 @@
+import type { CoreGateway } from './gateway.types.js';
+import type { CoreSingletonServices } from '../../types/core.types.js';
+/**
+ * Register a messaging gateway.
+ *
+ * `wireGateway` is a meta-wiring that composes existing primitives
+ * (`wireHTTP`, `wireChannel`) under the hood.  It does not replace them;
+ * it layers on top.
+ *
+ * @param config - Gateway configuration (name, type, adapter, func, middleware, etc.)
+ */
+export declare const wireGateway: (config: CoreGateway) => void;
+/**
+ * Create the message handler callback for a listener gateway.
+ *
+ * Returns a function `(rawData: unknown) => Promise<void>` that can be
+ * passed to `adapter.init()`.  Used by `LocalGatewayService` (and any
+ * other GatewayService implementation) to wire up listener gateways.
+ *
+ * @param name   - Gateway name (for wire.gateway metadata)
+ * @param config - The gateway configuration (adapter, func, middleware)
+ * @param singletonServices - Singleton services to pass to handler/middleware
+ */
+export declare const createListenerMessageHandler: (name: string, config: CoreGateway, singletonServices: CoreSingletonServices) => ((rawData: unknown) => Promise<void>);