@pikku/core 0.10.1 → 0.11.0

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;
 };

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

@@ -1,17 +1,16 @@
-import { PikkuWiringTypes } from '../../../types/core.types.js';
 import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { openChannel } from '../channel-runner.js';
 import { createHTTPInteraction } from '../../http/http-runner.js';
 import { handleHTTPError } from '../../../handle-error.js';
 import { PikkuUserSessionService } from '../../../services/user-session-service.js';
-import { combineMiddleware, runMiddleware } from '../../../middleware-runner.js';
 import { pikkuState } from '../../../pikku-state.js';
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js';
-import { runPikkuFuncDirectly } from '../../../function/function-runner.js';
+import { runChannelLifecycleWithMiddleware } from '../channel-common.js';
+import { rpcService } from '../../rpc/rpc-runner.js';
 const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory, openingData, }) => {
     const channels = pikkuState('channel', 'channels');
-    const channelConfig = channels[channelName];
+    const channelConfig = channels.get(channelName);
     const channelsMeta = pikkuState('channel', 'meta');
     const meta = channelsMeta[channelName];
     if (!channelConfig) {
@@ -44,57 +43,95 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         coerceDataFromSchema,
         userSession,
     });
-    const main = async () => {
-        try {
-            await channelStore.addChannel({
-                channelId,
-                channelName: channelConfig.name,
-                openingData,
-                channelObject,
-            });
-            const { channel } = getVariablesForChannel({
-                channelId,
-                channelHandlerFactory,
-                channelName: channelConfig.name,
-            });
-            if (createSessionServices) {
-                sessionServices = await createSessionServices(singletonServices, { http }, await userSession.get());
-            }
-            if (channelConfig.onConnect && meta.connect) {
-                await runPikkuFuncDirectly(meta.connect.pikkuFuncName, { ...singletonServices, ...sessionServices, channel }, openingData);
-            }
-            http?.response?.status(101);
+    try {
+        await channelStore.addChannel({
+            channelId,
+            channelName: channelConfig.name,
+            openingData,
+            channelObject,
+        });
+        const { channel } = getVariablesForChannel({
+            channelId,
+            channelHandlerFactory,
+            channelName: channelConfig.name,
+        });
+        if (createSessionServices) {
+            sessionServices = await createSessionServices(singletonServices, { http }, await userSession.get());
         }
-        catch (e) {
-            handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        const interaction = { channel };
+        const getAllServices = (requiresAuth) => rpcService.injectRPCService({
+            ...singletonServices,
+            ...sessionServices,
+            channel,
+            userSession,
+        }, interaction, requiresAuth);
+        if (channelConfig.onConnect && meta.connect) {
+            await runChannelLifecycleWithMiddleware({
+                channelConfig,
+                meta: meta.connect,
+                lifecycleConfig: channelConfig.onConnect,
+                lifecycleType: 'connect',
+                services: getAllServices(false),
+                channel,
+                data: openingData,
+            });
         }
-        finally {
-            if (sessionServices) {
-                await closeSessionServices(singletonServices.logger, sessionServices);
-            }
+        http?.response?.status(101);
+    }
+    catch (e) {
+        handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+    }
+    finally {
+        if (sessionServices) {
+            await closeSessionServices(singletonServices.logger, sessionServices);
         }
-    };
-    await runMiddleware({
-        ...singletonServices,
-        userSession,
-    }, { http }, combineMiddleware(PikkuWiringTypes.channel, channelConfig.name, {
-        wireInheritedMiddleware: meta.middleware,
-        wireMiddleware: channelConfig.middleware,
-    }), main);
+    }
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
     let sessionServices;
-    const { openingData, channelName, session } = await params.channelStore.getChannelAndSession(params.channelId);
+    // Try to get channel from store. In serverless environments (especially with
+    // serverless-offline or worker threads), disconnect can be called multiple times
+    // or after the channel has already been cleaned up. If channel doesn't exist,
+    // there's nothing to disconnect, so we can return early.
+    let channelData;
+    try {
+        channelData = await params.channelStore.getChannelAndSession(params.channelId);
+    }
+    catch (error) {
+        singletonServices.logger.info(`Channel ${params.channelId} not found during disconnect - already cleaned up`);
+        return;
+    }
+    const { openingData, channelName, session } = channelData;
     const { channel, channelConfig, meta } = getVariablesForChannel({
         ...params,
         openingData,
         channelName,
     });
+    const userSession = new PikkuUserSessionService(params.channelStore, params.channelId);
     if (!sessionServices && params.createSessionServices) {
         sessionServices = await params.createSessionServices(singletonServices, { channel }, session);
     }
+    const interaction = { channel };
+    const getAllServices = (requiresAuth) => rpcService.injectRPCService({
+        ...singletonServices,
+        ...sessionServices,
+        channel,
+        userSession,
+    }, interaction, requiresAuth);
     if (channelConfig.onDisconnect && meta.disconnect) {
-        await runPikkuFuncDirectly(meta.disconnect.pikkuFuncName, { ...singletonServices, ...sessionServices, channel }, undefined);
+        try {
+            await runChannelLifecycleWithMiddleware({
+                channelConfig,
+                meta: meta.disconnect,
+                lifecycleConfig: channelConfig.onDisconnect,
+                lifecycleType: 'disconnect',
+                services: getAllServices(false),
+                channel,
+            });
+        }
+        catch (e) {
+            singletonServices.logger.error(`Error handling onDisconnect: ${e.message || e}`);
+        }
     }
     await params.channelStore.removeChannels([channel.channelId]);
     if (sessionServices) {
@@ -109,14 +146,26 @@ export const runChannelMessage = async ({ singletonServices, ...params }, data)
         openingData,
         channelName,
     });
+    const userSession = new PikkuUserSessionService(params.channelStore, params.channelId);
     if (params.createSessionServices) {
         sessionServices = await params.createSessionServices(singletonServices, { channel }, session);
     }
+    const interaction = { channel };
+    const getAllServices = () => rpcService.injectRPCService({
+        ...singletonServices,
+        ...sessionServices,
+        channel,
+        userSession,
+    }, interaction);
     let response;
     try {
-        const onMessage = processMessageHandlers({ ...singletonServices, ...sessionServices }, channelConfig, channelHandler);
+        const onMessage = processMessageHandlers(getAllServices(), channelConfig, channelHandler);
         response = await onMessage(data);
     }
+    catch (e) {
+        singletonServices.logger.error(`Error processing message: ${e.message || e}`);
+        return { error: e.message || 'Unknown error' };
+    }
     finally {
         if (sessionServices) {
             await closeSessionServices(singletonServices.logger, sessionServices);

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

@@ -14,7 +14,7 @@ export async function executeCLIViaChannel({ programName, pikkuWS, args = proces
     // Get CLI metadata from state
     const allCLIMeta = pikkuState('cli', 'meta');
     if (!allCLIMeta) {
-        throw new Error('[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/errors/pku342 for more information.');
+        throw new Error('[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/docs/pikku-cli/errors/pku342 for more information.');
     }
     const programMeta = allCLIMeta.programs[programName];
     if (!programMeta) {
@@ -55,6 +55,15 @@ export async function executeCLIViaChannel({ programName, pikkuWS, args = proces
         // Subscribe to responses for this command
         const commandRoute = pikkuWS.getRoute('command');
         const responseHandler = (response) => {
+            // Check if this is a control message
+            if (response?.action === 'cli-control' &&
+                response?.event === 'complete') {
+                // Server signals command is complete, close the connection client-side
+                commandRoute.unsubscribe(commandId, responseHandler);
+                pikkuWS.ws.close();
+                resolve(undefined);
+                return;
+            }
             // Call renderer for any output
             renderer(null, response, undefined);
         };

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

@@ -38,5 +38,5 @@ export declare function executeCLI({ programName, args, createConfig, createSing
     args?: string[];
     createConfig: CreateConfig<any, any>;
     createSingletonServices: CreateSingletonServices<any, any>;
-    createSessionServices?: CreateSessionServices<any, any>;
+    createSessionServices?: CreateSessionServices<any, any, any>;
 }): Promise<void>;

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

@@ -286,7 +286,7 @@ export async function executeCLI({ programName, args, createConfig, createSingle
         // Get CLI metadata from state
         const allCLIMeta = pikkuState('cli', 'meta');
         if (!allCLIMeta) {
-            throw new Error('[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/errors/pku342 for more information.');
+            throw new Error('[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/docs/pikku-cli/errors/pku342 for more information.');
         }
         const programMeta = allCLIMeta.programs[programName];
         if (!programMeta) {

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

@@ -221,7 +221,6 @@ const executeRoute = async (services, matchedRoute, http, options) => {
     }
     const interaction = { http, channel };
     const getAllServices = async (session) => {
-        let channel;
         // Create session-specific services for handling the request
         sessionServices = await createSessionServices({ ...singletonServices, userSession, channel }, { http }, session);
         return rpcService.injectRPCService({

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

@@ -20,7 +20,7 @@ export const wireMCPResource = (mcpResource) => {
     if (!mcpResourceMeta) {
         throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`);
     }
-    addFunction(mcpResourceMeta.pikkuFuncName, mcpResource);
+    addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func);
     const resources = pikkuState('mcp', 'resources');
     if (resources.has(mcpResource.uri)) {
         throw new Error(`MCP resource already exists: ${mcpResource.uri}`);
@@ -85,7 +85,7 @@ export async function runMCPResource(request, params, uri) {
     return await runMCPPikkuFunc({
         ...request,
         params: { ...request.params, ...extractedParams },
-    }, 'resource', uri, endpoint, pikkuFuncName, { ...params, mcp: { uri } });
+    }, 'resource', uri, endpoint, pikkuFuncName, { ...params, mcp: { ...params.mcp, uri } });
 }
 export async function runMCPTool(request, params, name) {
     const endpoint = pikkuState('mcp', 'tools').get(name);
@@ -120,6 +120,7 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { single
             return rpcService.injectRPCService({
                 ...singletonServices,
                 ...sessionServices,
+                mcp: mcpInteraction,
             }, interaction);
         };
         // Get metadata for the MCP endpoint to access pre-resolved middleware

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

@@ -2,6 +2,7 @@ import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { PikkuWiringTypes, } from '../../types/core.types.js';
+import { rpcService } from '../rpc/rpc-runner.js';
 /**
  * Error class for queue processor not found
  */
@@ -102,13 +103,15 @@ export async function runQueueJob({ singletonServices, createSessionServices, jo
     };
     try {
         logger.info(`Processing job ${job.id} in queue ${job.queueName}`);
+        const interaction = { queue };
         // Use provided singleton services
         const getAllServices = async () => {
             const sessionServices = await createSessionServices?.(singletonServices, { queue }, undefined);
-            return {
+            const services = rpcService.injectRPCService({
                 ...singletonServices,
                 ...sessionServices,
-            };
+            }, interaction, false);
+            return services;
         };
         // Execute the pikku function with the job data
         const result = await runPikkuFunc(PikkuWiringTypes.queue, job.queueName, processorMeta.pikkuFuncName, {
@@ -119,7 +122,7 @@ export async function runQueueJob({ singletonServices, createSessionServices, jo
             inheritedMiddleware: processorMeta.middleware,
             wireMiddleware: queueWorker.middleware,
             tags: queueWorker.tags,
-            interaction: { queue },
+            interaction,
         });
         logger.debug(`Successfully processed job ${job.id} in queue ${job.queueName}`);
         return result;

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

@@ -126,13 +126,11 @@ export interface QueueWorkers {
     configMappings: QueueConfigMapping;
     /** Scan state and register all compatible processors */
     registerQueues(): Promise<Record<string, ConfigValidationResult[]>>;
-    /** Close all queues and connections */
-    close(): Promise<void>;
 }
 /**
  * Queue processor metadata
  */
-export type queueWorkersMeta = Record<string, {
+export type QueueWorkersMeta = Record<string, {
     pikkuFuncName: string;
     schemaName?: string;
     queueName: string;

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

@@ -1,2 +1,2 @@
-export { initialize, PikkuRPCService } from './rpc-runner.js';
+export { initialize, PikkuRPCService, rpcService } from './rpc-runner.js';
 export type { PikkuRPC, RPCMeta } from './rpc-types.js';

package/dist/wirings/rpc/index.js

@@ -1 +1 @@
-export { initialize, PikkuRPCService } from './rpc-runner.js';
+export { initialize, PikkuRPCService, rpcService } from './rpc-runner.js';

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

@@ -3,6 +3,21 @@ import { PikkuRPC } from './rpc-types.js';
 type RPCServiceConfig = {
     coerceDataFromSchema: boolean;
 };
+export declare class ContextAwareRPCService {
+    private services;
+    private interaction;
+    private options;
+    constructor(services: CoreServices, interaction: PikkuInteraction, options: {
+        coerceDataFromSchema?: boolean;
+        requiresAuth?: boolean;
+    });
+    rpcExposed(funcName: string, data: any): Promise<any>;
+    rpc<In = any, Out = any>(funcName: string, data: In): Promise<Out>;
+    rpcWithInteraction<In = any, Out = any>(funcName: string, data: In, interaction: PikkuInteraction): Promise<Out>;
+    startWorkflow<In = any>(workflowName: string, input: In): Promise<{
+        runId: string;
+    }>;
+}
 export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = PikkuRPC> {
     private config?;
     initialize(config: RPCServiceConfig): void;

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

@@ -11,7 +11,7 @@ const getPikkuFunctionName = (rpcName) => {
     return rpcMeta;
 };
 // Context-aware RPC client for use within services
-class ContextAwareRPCService {
+export class ContextAwareRPCService {
     services;
     interaction;
     options;
@@ -32,8 +32,7 @@ class ContextAwareRPCService {
     }
     async rpc(funcName, data) {
         const rpcDepth = this.services.rpc?.depth || 0;
-        const pikkuFuncName = getPikkuFunctionName(funcName);
-        return runPikkuFunc(PikkuWiringTypes.rpc, pikkuFuncName, pikkuFuncName, {
+        return runPikkuFunc(PikkuWiringTypes.rpc, funcName, getPikkuFunctionName(funcName), {
             auth: this.options.requiresAuth,
             singletonServices: this.services,
             getAllServices: () => {
@@ -52,6 +51,40 @@ class ContextAwareRPCService {
             interaction: this.interaction,
         });
     }
+    async rpcWithInteraction(funcName, data, interaction) {
+        const rpcDepth = this.services.rpc?.depth || 0;
+        const mergedInteraction = {
+            ...this.interaction,
+            ...interaction,
+        };
+        return runPikkuFunc(PikkuWiringTypes.rpc, funcName, getPikkuFunctionName(funcName), {
+            auth: this.options.requiresAuth,
+            singletonServices: this.services,
+            getAllServices: () => {
+                this.services.rpc = this.services.rpc
+                    ? {
+                        ...this.services.rpc,
+                        depth: rpcDepth + 1,
+                        global: false,
+                    }
+                    : undefined;
+                return {
+                    ...this.services,
+                    ...mergedInteraction,
+                };
+            },
+            data: () => data,
+            userSession: this.services.userSession,
+            coerceDataFromSchema: this.options.coerceDataFromSchema,
+            interaction: mergedInteraction,
+        });
+    }
+    async startWorkflow(workflowName, input) {
+        if (!this.services.workflowService) {
+            throw new Error('WorkflowService service not available');
+        }
+        return this.services.workflowService.startWorkflow(workflowName, input, this);
+    }
 }
 // RPC Service class for the global interface
 export class PikkuRPCService {
@@ -74,6 +107,8 @@ export class PikkuRPCService {
             global: false,
             invoke: serviceRPC.rpc.bind(serviceRPC),
             invokeExposed: serviceRPC.rpc.bind(serviceRPC),
+            startWorkflow: serviceRPC.startWorkflow.bind(serviceRPC),
+            rpcWithInteraction: serviceRPC.rpcWithInteraction.bind(serviceRPC),
         };
         return serviceCopy;
     }

package/dist/wirings/rpc/rpc-types.d.ts

@@ -6,6 +6,7 @@ export type PikkuRPC<invoke extends Function = any> = {
 export type RPCMeta = {
     pikkuFuncName: string;
     expose: boolean;
+    internal?: boolean;
 };
 /**
  * Type for RPC handlers

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

@@ -0,0 +1,6 @@
+/**
+ * Workflow module exports
+ */
+export type { CoreWorkflow, WorkflowStepOptions, WorkflowStepMeta, PikkuWorkflowInteraction, PikkuWorkflow, WorkflowsMeta, WorkflowRun, StepState, WorkflowStatus, StepStatus, } from './workflow.types.js';
+export { PikkuWorkflowService } from './pikku-workflow-service.js';
+export { wireWorkflow } from './workflow-runner.js';

package/dist/wirings/workflow/index.js

@@ -0,0 +1,6 @@
+/**
+ * Workflow module exports
+ */
+export { PikkuWorkflowService } from './pikku-workflow-service.js';
+// Functions
+export { wireWorkflow } from './workflow-runner.js';