@ajna-inc/workflow 0.5.38 → 0.6.2

package/build/WorkflowModule.js

@@ -1,647 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowModule = exports.WORKFLOW_ROLES = exports.WORKFLOW_PROTOCOL_URI = void 0;
-const core_1 = require("@credo-ts/core");
-const WorkflowModuleConfig_1 = require("./WorkflowModuleConfig");
-const CommandQueue_1 = require("./queue/CommandQueue");
-const PersistentCommandQueue_1 = require("./queue/PersistentCommandQueue");
-const WorkflowApi_1 = require("./api/WorkflowApi");
-const WorkflowCommandRepository_1 = require("./repository/WorkflowCommandRepository");
-const AdvanceHandler_1 = require("./protocol/handlers/AdvanceHandler");
-const CancelHandler_1 = require("./protocol/handlers/CancelHandler");
-const CompleteHandler_1 = require("./protocol/handlers/CompleteHandler");
-const DiscoverHandler_1 = require("./protocol/handlers/DiscoverHandler");
-const FetchTemplateHandler_1 = require("./protocol/handlers/FetchTemplateHandler");
-const TemplateHandler_1 = require("./protocol/handlers/TemplateHandler");
-const PauseHandler_1 = require("./protocol/handlers/PauseHandler");
-const ProblemReportHandler_1 = require("./protocol/handlers/ProblemReportHandler");
-const PublishTemplateHandler_1 = require("./protocol/handlers/PublishTemplateHandler");
-const ResumeHandler_1 = require("./protocol/handlers/ResumeHandler");
-const StartHandler_1 = require("./protocol/handlers/StartHandler");
-const StatusHandler_1 = require("./protocol/handlers/StatusHandler");
-const WorkflowInstanceRepository_1 = require("./repository/WorkflowInstanceRepository");
-const WorkflowTemplateRepository_1 = require("./repository/WorkflowTemplateRepository");
-const WorkflowService_1 = require("./services/WorkflowService");
-const core_2 = require("@credo-ts/core");
-exports.WORKFLOW_PROTOCOL_URI = 'https://didcomm.org/workflow/1.0';
-exports.WORKFLOW_ROLES = ['processor', 'coordinator'];
-class WorkflowModule {
-    constructor(options) {
-        this.api = WorkflowApi_1.WorkflowApi;
-        this.config = new WorkflowModuleConfig_1.WorkflowModuleConfig(options);
-    }
-    register(dependencyManager) {
-        dependencyManager.resolve(core_1.AgentConfig).logger.info('Registering WorkflowModule');
-        dependencyManager.registerInstance(WorkflowModuleConfig_1.WorkflowModuleConfig, this.config);
-        dependencyManager.registerSingleton(WorkflowTemplateRepository_1.WorkflowTemplateRepository);
-        dependencyManager.registerSingleton(WorkflowInstanceRepository_1.WorkflowInstanceRepository);
-        dependencyManager.registerSingleton(WorkflowCommandRepository_1.WorkflowCommandRepository);
-        dependencyManager.registerSingleton(WorkflowService_1.WorkflowService);
-        // IMPORTANT: Do not register WorkflowApi as a singleton here.
-        // The DependencyManager will register `module.api` (WorkflowApi) as context-scoped
-        // via `registerModules`, ensuring a fresh API instance per AgentContext (tenant-safe).
-        dependencyManager.registerSingleton(PublishTemplateHandler_1.PublishTemplateHandler);
-        dependencyManager.registerSingleton(StartHandler_1.StartHandler);
-        dependencyManager.registerSingleton(AdvanceHandler_1.AdvanceHandler);
-        dependencyManager.registerSingleton(StatusHandler_1.StatusHandler);
-        dependencyManager.registerSingleton(ProblemReportHandler_1.ProblemReportHandler);
-        dependencyManager.registerSingleton(PauseHandler_1.PauseHandler);
-        dependencyManager.registerSingleton(ResumeHandler_1.ResumeHandler);
-        dependencyManager.registerSingleton(CancelHandler_1.CancelHandler);
-        dependencyManager.registerSingleton(CompleteHandler_1.CompleteHandler);
-        dependencyManager.registerSingleton(DiscoverHandler_1.DiscoverHandler);
-        dependencyManager.registerSingleton(FetchTemplateHandler_1.FetchTemplateHandler);
-        dependencyManager.registerSingleton(TemplateHandler_1.TemplateHandler);
-    }
-    async initialize(agentContext) {
-        const dm = agentContext.dependencyManager;
-        const logger = dm.resolve(core_1.AgentConfig).logger;
-        const features = dm.resolve(core_1.FeatureRegistry);
-        const handlers = dm.resolve(core_1.MessageHandlerRegistry);
-        logger.info('Initializing WorkflowModule - registering workflow/1.0 protocol');
-        try {
-            features.register(new core_1.Protocol({ id: exports.WORKFLOW_PROTOCOL_URI, roles: [...exports.WORKFLOW_ROLES] }));
-        }
-        catch (_e) {
-            void 0;
-        }
-        handlers.registerMessageHandler(dm.resolve(PublishTemplateHandler_1.PublishTemplateHandler));
-        handlers.registerMessageHandler(dm.resolve(StartHandler_1.StartHandler));
-        handlers.registerMessageHandler(dm.resolve(AdvanceHandler_1.AdvanceHandler));
-        handlers.registerMessageHandler(dm.resolve(StatusHandler_1.StatusHandler));
-        handlers.registerMessageHandler(dm.resolve(ProblemReportHandler_1.ProblemReportHandler));
-        handlers.registerMessageHandler(dm.resolve(PauseHandler_1.PauseHandler));
-        handlers.registerMessageHandler(dm.resolve(ResumeHandler_1.ResumeHandler));
-        handlers.registerMessageHandler(dm.resolve(CancelHandler_1.CancelHandler));
-        handlers.registerMessageHandler(dm.resolve(CompleteHandler_1.CompleteHandler));
-        // discovery/fetch extension
-        handlers.registerMessageHandler(dm.resolve(DiscoverHandler_1.DiscoverHandler));
-        handlers.registerMessageHandler(dm.resolve(FetchTemplateHandler_1.FetchTemplateHandler));
-        handlers.registerMessageHandler(dm.resolve(TemplateHandler_1.TemplateHandler));
-        // Inbound mapping: credentials/proofs → workflow events
-        const events = dm.resolve(core_1.EventEmitter);
-        const service = dm.resolve(WorkflowService_1.WorkflowService);
-        const contextProvider = dm.resolve(core_1.InjectionSymbols.AgentContextProvider);
-        const rootContextId = agentContext.contextCorrelationId;
-        const resolveEventContext = async (metadata) => {
-            const correlationId = metadata?.contextCorrelationId;
-            if (!correlationId || correlationId === rootContextId) {
-                return { context: agentContext, release: async () => { } };
-            }
-            try {
-                const scopedContext = await contextProvider.getAgentContextForContextCorrelationId(correlationId);
-                return {
-                    context: scopedContext,
-                    release: async () => {
-                        try {
-                            await contextProvider.endSessionForAgentContext(scopedContext);
-                        }
-                        catch (error) {
-                            logger.debug('WorkflowModule - failed to end tenant session after event', {
-                                contextCorrelationId: correlationId,
-                                error: error.message,
-                            });
-                        }
-                    },
-                };
-            }
-            catch (error) {
-                logger.debug('WorkflowModule - unable to resolve context for event', {
-                    contextCorrelationId: correlationId,
-                    error: error.message,
-                });
-                return null;
-            }
-        };
-        events.on(core_1.CredentialEventTypes.CredentialStateChanged, async (e) => {
-            const rec = e.payload.credentialRecord;
-            const connId = rec.connectionId;
-            if (!connId)
-                return;
-            const scoped = await resolveEventContext(e.metadata);
-            if (!scoped)
-                return;
-            try {
-                if (rec.state === core_1.CredentialState.ProposalReceived) {
-                    await service.autoAdvanceByConnection(scoped.context, connId, 'proposal_received');
-                }
-                else if (rec.state === core_1.CredentialState.OfferReceived) {
-                    await service.autoAdvanceByConnection(scoped.context, connId, 'offer_received');
-                }
-                else if (rec.state === core_1.CredentialState.RequestReceived) {
-                    await service.autoAdvanceByConnection(scoped.context, connId, 'request_received');
-                }
-                else if (rec.state === core_1.CredentialState.Done) {
-                    await service.autoAdvanceByConnection(scoped.context, connId, 'issued_ack');
-                }
-            }
-            finally {
-                await scoped.release();
-            }
-        });
-        events.on(core_1.ProofEventTypes.ProofStateChanged, async (e) => {
-            const rec = e.payload.proofRecord;
-            const connId = rec.connectionId;
-            if (!connId)
-                return;
-            const scoped = await resolveEventContext(e.metadata);
-            if (!scoped)
-                return;
-            try {
-                if (rec.state === core_1.ProofState.PresentationReceived) {
-                    await service.autoAdvanceByConnection(scoped.context, connId, 'presentation_received');
-                }
-                else if (rec.state === core_1.ProofState.Done) {
-                    await service.autoAdvanceByConnection(scoped.context, connId, 'verified_ack');
-                }
-            }
-            finally {
-                await scoped.release();
-            }
-        });
-        // Optional: register payments v1 actions when payments module is available
-        try {
-            let createPaymentsV1Actions;
-            try {
-                ;
-                ({ createPaymentsV1Actions } = require('@credo-ts/payments'));
-            }
-            catch {
-                /* optional dependency */
-            }
-            if (!createPaymentsV1Actions) {
-                try {
-                    ;
-                    ({ createPaymentsV1Actions } = require('@credo-ts/payments/workflow/PaymentsV1Actions'));
-                }
-                catch {
-                    /* optional dependency */
-                }
-            }
-            if (!createPaymentsV1Actions) {
-                try {
-                    ;
-                    ({ createPaymentsV1Actions } = require('@credo-ts/payments/workflow/PaymentsV1Actions'));
-                }
-                catch {
-                    /* optional dependency */
-                }
-            }
-            // Try @ajna-inc/payments (static require for React Native compatibility)
-            if (!createPaymentsV1Actions) {
-                try {
-                    ;
-                    ({ createPaymentsV1Actions } = require('@ajna-inc/payments'));
-                }
-                catch {
-                    /* optional dependency */
-                }
-            }
-            if (!createPaymentsV1Actions) {
-                try {
-                    ;
-                    ({ createPaymentsV1Actions } = require('@ajna-inc/payments/workflow/PaymentsV1Actions'));
-                }
-                catch {
-                    /* optional dependency */
-                }
-            }
-            if (createPaymentsV1Actions) {
-                const actions = createPaymentsV1Actions();
-                try {
-                    // Prefer explicit API if available
-                    const svcAny = service;
-                    if (typeof svcAny.registerActions === 'function') {
-                        svcAny.registerActions(actions);
-                    }
-                    else if (svcAny.actions && typeof svcAny.actions.register === 'function') {
-                        for (const a of actions)
-                            svcAny.actions.register(a);
-                    }
-                    else {
-                        throw new Error('no action registry available');
-                    }
-                    logger.info('WorkflowModule - registered PaymentsV1 actions');
-                }
-                catch (_e) {
-                    // swallow
-                }
-            }
-        }
-        catch {
-            /* optional dependency */
-        }
-        // Optional: map payments events → workflow events (guarded if payments not installed)
-        if (this.config.enablePaymentsEventMapping)
-            try {
-                let PaymentsEventTypes;
-                try {
-                    ;
-                    ({ PaymentsEventTypes } = require('@credo-ts/payments'));
-                }
-                catch {
-                    /* optional dependency */
-                }
-                if (!PaymentsEventTypes) {
-                    try {
-                        ;
-                        ({ PaymentsEventTypes } = require('@credo-ts/payments/events/PaymentEvents'));
-                    }
-                    catch {
-                        /* optional dependency */
-                    }
-                }
-                if (!PaymentsEventTypes) {
-                    try {
-                        ;
-                        ({ PaymentsEventTypes } = require('@credo-ts/payments/events/PaymentEvents'));
-                    }
-                    catch {
-                        /* optional dependency */
-                    }
-                }
-                if (!PaymentsEventTypes)
-                    return;
-                const adv = async (threadId, event, metadata) => {
-                    const scoped = await resolveEventContext(metadata);
-                    if (!scoped)
-                        return;
-                    try {
-                        await service.advance(scoped.context, {
-                            instance_id: threadId,
-                            event,
-                            idempotency_key: `auto:payments:${event}:${threadId}`,
-                        });
-                    }
-                    catch (e) {
-                        logger.debug(`[Workflow] payments event advance error: ${e.message}`);
-                    }
-                    finally {
-                        await scoped.release();
-                    }
-                };
-                const on = (evt, cb) => events.on?.(evt, cb);
-                if (PaymentsEventTypes.IntroResponded)
-                    on(PaymentsEventTypes.IntroResponded, async (e) => {
-                        const th = e?.payload?.threadId;
-                        if (th)
-                            await adv(th, 'payments.methods_received', e?.metadata);
-                    });
-                if (PaymentsEventTypes.HandshakeAccepted)
-                    on(PaymentsEventTypes.HandshakeAccepted, async (e) => {
-                        const th = e?.payload?.threadId;
-                        if (th)
-                            await adv(th, 'payments.handshake_accepted', e?.metadata);
-                    });
-                if (PaymentsEventTypes.ComplianceRequired)
-                    on(PaymentsEventTypes.ComplianceRequired, async (e) => {
-                        const th = e?.payload?.threadId;
-                        if (th)
-                            await adv(th, 'payments.compliance_required', e?.metadata);
-                    });
-                if (PaymentsEventTypes.ComplianceSatisfied)
-                    on(PaymentsEventTypes.ComplianceSatisfied, async (e) => {
-                        const th = e?.payload?.threadId;
-                        if (th)
-                            await adv(th, 'payments.compliance_satisfied', e?.metadata);
-                    });
-                if (PaymentsEventTypes.ComplianceRejected)
-                    on(PaymentsEventTypes.ComplianceRejected, async (e) => {
-                        const th = e?.payload?.threadId;
-                        if (th)
-                            await adv(th, 'payments.compliance_rejected', e?.metadata);
-                    });
-                if (PaymentsEventTypes.SettlementUpdated)
-                    on(PaymentsEventTypes.SettlementUpdated, async (e) => {
-                        const p = e?.payload;
-                        const th = p?.threadId;
-                        const status = p?.status;
-                        if (!status)
-                            return;
-                        const map = {
-                            received: 'payments.receipt_received',
-                            pending: 'payments.settlement_pending',
-                            settled: 'payments.settled',
-                            failed: 'payments.failed',
-                        };
-                        const ev = map[status];
-                        if (ev && th)
-                            await adv(th, ev, e?.metadata);
-                    });
-                logger.info('WorkflowModule - registered Payments event listeners');
-            }
-            catch {
-                /* optional dependency */
-            }
-        // Optional: register POE v1 actions when POE module is available
-        try {
-            let createPoeV1Actions;
-            try {
-                ;
-                ({ createPoeV1Actions } = require('@ajna-inc/poe'));
-            }
-            catch {
-                /* optional dependency */
-            }
-            if (!createPoeV1Actions) {
-                try {
-                    ;
-                    ({ createPoeV1Actions } = require('@ajna-inc/poe/workflow/PoeV1Actions'));
-                }
-                catch {
-                    /* optional dependency */
-                }
-            }
-            if (createPoeV1Actions) {
-                const actions = createPoeV1Actions();
-                try {
-                    const svcAny = service;
-                    if (typeof svcAny.registerActions === 'function') {
-                        svcAny.registerActions(actions);
-                    }
-                    else if (svcAny.actions && typeof svcAny.actions.register === 'function') {
-                        for (const a of actions)
-                            svcAny.actions.register(a);
-                    }
-                    else {
-                        throw new Error('no action registry available');
-                    }
-                    logger.info('WorkflowModule - registered PoeV1 actions');
-                }
-                catch (_e) {
-                    // swallow
-                }
-            }
-        }
-        catch {
-            /* optional dependency */
-        }
-        // Optional: map POE events → workflow events (guarded if POE not installed)
-        if (this.config.enablePoeEventMapping)
-            try {
-                let PoeEventTypes;
-                let PoeState;
-                try {
-                    ;
-                    ({ PoeEventTypes, PoeState } = require('@ajna-inc/poe'));
-                }
-                catch {
-                    /* optional dependency */
-                }
-                if (!PoeEventTypes || !PoeState)
-                    return;
-                const on = (evt, cb) => events.on?.(evt, cb);
-                if (PoeEventTypes.PoeStateChanged)
-                    on(PoeEventTypes.PoeStateChanged, async (e) => {
-                        const poeRecord = e?.payload?.poeRecord;
-                        const connectionId = poeRecord?.connectionId;
-                        if (!connectionId)
-                            return;
-                        const scoped = await resolveEventContext(e?.metadata);
-                        if (!scoped)
-                            return;
-                        try {
-                            let workflowEvent;
-                            switch (poeRecord.state) {
-                                case PoeState?.RequestReceived:
-                                    workflowEvent = 'poe.request_received';
-                                    break;
-                                case PoeState?.SubmitReceived:
-                                    workflowEvent = poeRecord.verificationResult?.verified
-                                        ? 'poe.verified'
-                                        : 'poe.verification_failed';
-                                    break;
-                                case PoeState?.ProposalReceived:
-                                    workflowEvent = 'poe.proposal_received';
-                                    break;
-                                case PoeState?.Accepted:
-                                    workflowEvent = 'poe.accepted';
-                                    break;
-                                case PoeState?.Declined:
-                                    workflowEvent = 'poe.declined';
-                                    break;
-                                case PoeState?.Complete:
-                                    workflowEvent = 'poe.completed';
-                                    break;
-                                case PoeState?.Problem:
-                                    workflowEvent = 'poe.problem';
-                                    break;
-                                case PoeState?.ChallengeReceived:
-                                    workflowEvent = 'poe.challenge_received';
-                                    break;
-                            }
-                            if (workflowEvent) {
-                                await service.autoAdvanceByConnection(scoped.context, connectionId, workflowEvent);
-                            }
-                        }
-                        catch (err) {
-                            logger.debug(`[Workflow] POE event advance error: ${err.message}`);
-                        }
-                        finally {
-                            await scoped.release();
-                        }
-                    });
-                logger.info('WorkflowModule - registered POE event listeners');
-            }
-            catch {
-                /* optional dependency */
-            }
-        // Initialize persistent command queue (always enabled, no Redis needed)
-        logger.info('WorkflowModule - initializing persistent command queue');
-        const commandRepo = dm.resolve(WorkflowCommandRepository_1.WorkflowCommandRepository);
-        const queue = new PersistentCommandQueue_1.PersistentCommandQueue(commandRepo, contextProvider, agentContext, {
-            pollIntervalMs: this.config.asyncQueue?.pollIntervalMs,
-            concurrency: this.config.asyncQueue?.concurrency,
-            processingTimeoutMs: this.config.asyncQueue?.processingTimeoutMs,
-            staleCheckIntervalMs: this.config.asyncQueue?.staleCheckIntervalMs,
-            cleanupIntervalMs: this.config.asyncQueue?.cleanupIntervalMs,
-            commandRetentionMs: this.config.asyncQueue?.commandRetentionMs,
-            failedRetentionMs: this.config.asyncQueue?.failedRetentionMs,
-            maxAttempts: this.config.asyncQueue?.maxAttempts,
-        });
-        // Test-time helper: register queue instance globally for best-effort shutdown in afterAll
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const g = globalThis;
-            g.__WF_QUEUES = g.__WF_QUEUES || new Set();
-            g.__WF_QUEUES.add(queue);
-        }
-        catch {
-            /* noop */
-        }
-        // In tests or minimal environments, dependencyManager may not expose registerInstance
-        try {
-            const anyDm = dm;
-            anyDm.registerInstance?.(CommandQueue_1.CommandQueueService, queue);
-        }
-        catch {
-            // no-op if DI container doesn't support instance registration in this context
-        }
-        // Start worker: processes commands and sends follow-up status messages
-        await queue.startWorker(async (job) => {
-            // Context resolution handled inside PersistentCommandQueue
-            // Worker receives job with already-resolved context
-            // This worker callback is called from PersistentCommandQueue.processCommand
-            // which already resolves the context, so we need to get it here
-            const metadata = { contextCorrelationId: job.contextCorrelationId };
-            const scoped = await (async () => {
-                const correlationId = metadata.contextCorrelationId;
-                if (!correlationId || correlationId === rootContextId) {
-                    return { context: agentContext, release: async () => { } };
-                }
-                try {
-                    const scopedContext = await contextProvider.getAgentContextForContextCorrelationId(correlationId);
-                    return {
-                        context: scopedContext,
-                        release: async () => {
-                            try {
-                                await contextProvider.endSessionForAgentContext(scopedContext);
-                            }
-                            catch (error) {
-                                logger.debug('WorkflowModule - failed to end tenant session after queue job', {
-                                    contextCorrelationId: correlationId,
-                                    error: error.message,
-                                });
-                            }
-                        },
-                    };
-                }
-                catch (error) {
-                    logger.debug('WorkflowModule - unable to resolve context for queue job', {
-                        error: error.message,
-                    });
-                    return null;
-                }
-            })();
-            if (!scoped)
-                return;
-            try {
-                const ctx = scoped.context;
-                try {
-                    logger.info('[WorkflowWorker] handling job', {
-                        cmd: job.cmd,
-                        thid: job.thid,
-                        connectionId: job.connectionId,
-                        contextCorrelationId: job.contextCorrelationId,
-                    });
-                }
-                catch { }
-                switch (job.cmd) {
-                    case 'start': {
-                        // Ensure template exists before starting. If missing, attempt auto-discover and defer.
-                        try {
-                            const templateRepo = dm.resolve(WorkflowTemplateRepository_1.WorkflowTemplateRepository);
-                            const p = (job.payload || {});
-                            const templateRec = p.template_id
-                                ? await templateRepo.findByTemplateIdAndVersion(ctx, p.template_id, p.template_version)
-                                : null;
-                            if (!templateRec) {
-                                const allowDiscover = p.allow_discover ?? true;
-                                if (allowDiscover && this.config.enableAutoDiscoverOnStart && job.connectionId) {
-                                    try {
-                                        const sender = dm.resolve(core_1.MessageSender);
-                                        const connectionSvc = dm.resolve(core_2.ConnectionService);
-                                        const connection = await connectionSvc.getById(ctx, job.connectionId);
-                                        const { FetchTemplateMessage } = require('./protocol/messages/FetchTemplateMessage');
-                                        const fetch = new FetchTemplateMessage({
-                                            thid: job.thid,
-                                            body: {
-                                                template_id: p.template_id,
-                                                template_version: p.template_version,
-                                                prefer_hash: p.template_hash,
-                                            },
-                                        });
-                                        try {
-                                            fetch.setReturnRouting(core_1.ReturnRouteTypes.thread, job.thid);
-                                        }
-                                        catch { }
-                                        const outbound = new core_1.OutboundMessageContext(fetch, { agentContext: ctx, connection });
-                                        await sender.sendMessage(outbound);
-                                        try {
-                                            logger.info('[WorkflowWorker] fetch-template sent from worker', {
-                                                thid: job.thid,
-                                                template_id: p.template_id,
-                                                template_version: p.template_version,
-                                            });
-                                        }
-                                        catch { }
-                                    }
-                                    catch (e) {
-                                        logger.debug('WorkflowModule - fetch-template send failed in worker', {
-                                            error: e.message,
-                                        });
-                                    }
-                                }
-                                // Defer start by signaling invalid_template so queue will retry later
-                                const err = new Error('template not found for start');
-                                err.code = 'invalid_template';
-                                throw err;
-                            }
-                        }
-                        catch (precheckErr) {
-                            // Rethrow to queue-level handler for unified deferral behavior
-                            throw precheckErr;
-                        }
-                        await service.start(ctx, job.payload);
-                        try {
-                            logger.info('[WorkflowWorker] start completed', { thid: job.thid });
-                        }
-                        catch { }
-                        break;
-                    }
-                    case 'advance':
-                        await service.advance(ctx, job.payload);
-                        try {
-                            logger.info('[WorkflowWorker] advance completed', { thid: job.thid });
-                        }
-                        catch { }
-                        break;
-                    case 'pause':
-                        await service.pause(ctx, job.payload);
-                        try {
-                            logger.info('[WorkflowWorker] pause completed', { thid: job.thid });
-                        }
-                        catch { }
-                        break;
-                    case 'resume':
-                        await service.resume(ctx, job.payload);
-                        try {
-                            logger.info('[WorkflowWorker] resume completed', { thid: job.thid });
-                        }
-                        catch { }
-                        break;
-                    case 'cancel':
-                        await service.cancel(ctx, job.payload);
-                        try {
-                            logger.info('[WorkflowWorker] cancel completed', { thid: job.thid });
-                        }
-                        catch { }
-                        break;
-                    case 'complete':
-                        await service.complete(ctx, job.payload);
-                        try {
-                            logger.info('[WorkflowWorker] complete completed', { thid: job.thid });
-                        }
-                        catch { }
-                        break;
-                }
-                // Note: Per Workflow 1.0 spec §11.6 and §3.4, status is provided on-demand (pull-based).
-                // The spec defines status as a request/response pattern where Coordinators explicitly
-                // request status via StatusRequestMessage, and Processors respond with StatusMessage.
-                //
-                // Unsolicited push notifications are not part of the base protocol and cause issues:
-                // - Tenant context mismatches in multi-tenant deployments
-                // - Receivers interpret unsolicited StatusMessage as a request (same @type)
-                // - HTTP transport timeouts (fire-and-forget over request/response transport)
-                //
-                // For real-time UI updates, use the existing WebSocket event system which emits
-                // WorkflowInstanceStateChanged events to connected clients.
-            }
-            finally {
-                await scoped.release();
-            }
-        });
-    }
-}
-exports.WorkflowModule = WorkflowModule;
-//# sourceMappingURL=WorkflowModule.js.map