@nocobase/plugin-workflow 2.1.0-beta.8 → 2.2.0-alpha.1

package/dist/server/Processor.d.ts

@@ -6,14 +6,29 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+/// <reference types="node" />
 import { Transaction, Transactionable } from '@nocobase/database';
 import { Logger } from '@nocobase/logger';
 import type Plugin from './Plugin';
+import { IJob } from './instructions';
 import type { ExecutionModel, FlowNodeModel, JobModel } from './types';
+export type ProcessorRunOptions = {
+    rerun?: true;
+    signal?: AbortSignal;
+};
+export type ProcessorRerunOptions = {
+    nodeId?: string | number;
+    overwrite?: boolean;
+};
 export interface ProcessorOptions extends Transactionable {
     plugin: Plugin;
     [key: string]: any;
 }
+export type BackgroundAbortHandle = {
+    signal: AbortSignal;
+    dispose: () => void;
+    throwIfAborted: () => void;
+};
 export default class Processor {
     execution: ExecutionModel;
     options: ProcessorOptions;
@@ -31,11 +46,7 @@ export default class Processor {
     /**
      * @experimental
      */
-    transaction: Transaction;
-    /**
-     * @experimental
-     */
-    mainTransaction: Transaction;
+    transaction?: Transaction | null;
     /**
      * @experimental
      */
@@ -47,29 +58,70 @@ export default class Processor {
     private jobsMapByNodeKey;
     private jobResultsMapByNodeKey;
     private jobsToSave;
+    private rerunContext;
     /**
      * @experimental
      */
     lastSavedJob: JobModel | null;
+    abortController: AbortController;
+    timeoutGuard: NodeJS.Timeout | null;
+    private runningRegistered;
+    private abortReason;
+    private aborted;
     constructor(execution: ExecutionModel, options: ProcessorOptions);
+    get abortSignal(): AbortSignal;
+    setTimeoutGuard(ms: number): void;
+    abortExecution(reason?: string): void;
+    isTimeoutAborted(): boolean;
+    /**
+     * Create an independent abort handle for background work that outlives this processor's
+     * run loop (e.g. fire-and-forget instructions that resume the job later). It mirrors the
+     * current abort state and sets its own timer based on the execution's `expiresAt`, so the
+     * timeout still applies after the processor has exited its synchronous run.
+     *
+     * The caller must invoke `dispose()` once the background work settles to release the timer
+     * and the abort listener.
+     */
+    createBackgroundAbortHandle(): BackgroundAbortHandle;
+    /**
+     * Reload a job and return it only when it is still pending, otherwise `null`. Background
+     * work uses this before resuming so it never overwrites a job that another path (timeout
+     * abort, a competing resume) has already settled.
+     */
+    findPendingJob(jobId: number | string): Promise<JobModel | null>;
     private makeNodes;
     private makeJobs;
     prepare(): Promise<void>;
-    start(): Promise<void>;
+    start(): Promise<any>;
     resume(job: JobModel): Promise<void>;
+    resolveRerun(options?: ProcessorRerunOptions): {
+        node: FlowNodeModel;
+        input: JobModel | {
+            result: any;
+        };
+        targetJob: JobModel;
+    };
+    rerun(options?: ProcessorRerunOptions): Promise<any>;
+    private getRerunNode;
+    private getRerunInput;
     private exec;
-    run(node: any, input?: any): any;
-    end(node: any, job: JobModel): Promise<any>;
+    run(node: FlowNodeModel, input?: JobModel | {
+        result: unknown;
+    }, options?: ProcessorRunOptions): Promise<any>;
+    end(node: FlowNodeModel, job: JobModel): Promise<any>;
     private recall;
     exit(s?: number | true): Promise<any>;
     /**
      * @experimental
      */
-    saveJob(payload: JobModel | Record<string, any>): JobModel;
+    saveJob(payload: JobModel | IJob): JobModel;
     /**
      * @experimental
      */
     getBranches(node: FlowNodeModel): FlowNodeModel[];
+    private enterRunningState;
+    private shouldContinueExecution;
+    private leaveRunningState;
     /**
      * @experimental
      * find the first node in current branch
@@ -79,7 +131,7 @@ export default class Processor {
      * @experimental
      * find the node start current branch
      */
-    findBranchParentNode(node: FlowNodeModel): FlowNodeModel | null;
+    findBranchParentNode(node?: FlowNodeModel): FlowNodeModel | null;
     /**
      * @experimental
      */
@@ -102,7 +154,7 @@ export default class Processor {
                 [key: string]: any;
             };
             $system: {};
-            $scopes: {};
+            $scopes: Record<string, any>;
             $env: {};
         };
         $context: any;
@@ -110,7 +162,7 @@ export default class Processor {
             [key: string]: any;
         };
         $system: {};
-        $scopes: {};
+        $scopes: Record<string, any>;
         $env: {};
     };
     /**

package/dist/server/Processor.js

@@ -45,6 +45,7 @@ var import_evaluators = require("@nocobase/evaluators");
 var import_utils = require("@nocobase/utils");
 var import_set = __toESM(require("lodash/set"));
 var import_constants = require("./constants");
+var import_timeout_errors = require("./timeout-errors");
 class Processor {
   constructor(execution, options) {
     this.execution = execution;
@@ -66,11 +67,7 @@ class Processor {
   /**
    * @experimental
    */
-  transaction;
-  /**
-   * @experimental
-   */
-  mainTransaction;
+  transaction = null;
   /**
    * @experimental
    */
@@ -82,10 +79,102 @@ class Processor {
   jobsMapByNodeKey = {};
   jobResultsMapByNodeKey = {};
   jobsToSave = /* @__PURE__ */ new Map();
+  rerunContext = null;
   /**
    * @experimental
    */
   lastSavedJob = null;
+  abortController = new AbortController();
+  timeoutGuard = null;
+  runningRegistered = false;
+  abortReason = null;
+  aborted = false;
+  get abortSignal() {
+    return this.abortController.signal;
+  }
+  setTimeoutGuard(ms) {
+    if (this.timeoutGuard) {
+      clearTimeout(this.timeoutGuard);
+    }
+    this.timeoutGuard = setTimeout(() => {
+      this.abortExecution(import_constants.EXECUTION_REASON.TIMEOUT);
+    }, ms);
+  }
+  abortExecution(reason) {
+    this.aborted = true;
+    this.abortReason = reason ?? null;
+    if (!this.abortController.signal.aborted) {
+      this.abortController.abort(
+        reason === import_constants.EXECUTION_REASON.TIMEOUT ? new import_timeout_errors.WorkflowTimeoutError("Workflow execution has been aborted") : new Error("Workflow execution has been aborted")
+      );
+    }
+  }
+  isTimeoutAborted() {
+    return this.abortSignal.aborted;
+  }
+  /**
+   * Create an independent abort handle for background work that outlives this processor's
+   * run loop (e.g. fire-and-forget instructions that resume the job later). It mirrors the
+   * current abort state and sets its own timer based on the execution's `expiresAt`, so the
+   * timeout still applies after the processor has exited its synchronous run.
+   *
+   * The caller must invoke `dispose()` once the background work settles to release the timer
+   * and the abort listener.
+   */
+  createBackgroundAbortHandle() {
+    const controller = new AbortController();
+    const sourceSignal = this.abortSignal;
+    let timeoutGuard = null;
+    let sourceListener = null;
+    const abort = (reason) => {
+      if (!controller.signal.aborted) {
+        controller.abort((0, import_timeout_errors.isWorkflowTimeoutError)(reason) ? reason : new import_timeout_errors.WorkflowTimeoutError());
+      }
+    };
+    if (sourceSignal.aborted) {
+      abort(sourceSignal.reason);
+    } else {
+      sourceListener = () => abort(sourceSignal.reason);
+      sourceSignal.addEventListener("abort", sourceListener, { once: true });
+    }
+    const remaining = this.execution.expiresAt ? this.execution.expiresAt.getTime() - Date.now() : null;
+    if (remaining != null) {
+      if (remaining <= 0) {
+        abort();
+      } else {
+        timeoutGuard = setTimeout(abort, remaining);
+      }
+    }
+    return {
+      signal: controller.signal,
+      dispose: () => {
+        if (timeoutGuard) {
+          clearTimeout(timeoutGuard);
+          timeoutGuard = null;
+        }
+        if (sourceListener) {
+          sourceSignal.removeEventListener("abort", sourceListener);
+          sourceListener = null;
+        }
+      },
+      throwIfAborted: () => {
+        if (controller.signal.aborted) {
+          throw controller.signal.reason ?? new import_timeout_errors.WorkflowTimeoutError();
+        }
+      }
+    };
+  }
+  /**
+   * Reload a job and return it only when it is still pending, otherwise `null`. Background
+   * work uses this before resuming so it never overwrites a job that another path (timeout
+   * abort, a competing resume) has already settled.
+   */
+  async findPendingJob(jobId) {
+    const job = await this.options.plugin.db.getRepository("jobs").findOne({
+      filterByTk: jobId
+    });
+    return (job == null ? void 0 : job.status) === import_constants.JOB_STATUS.PENDING ? job : null;
+  }
   // make dual linked nodes list then cache
   makeNodes(nodes = []) {
     this.nodes = nodes;
@@ -117,12 +206,13 @@ class Processor {
       execution,
       options: { plugin }
     } = this;
-    this.mainTransaction = plugin.useDataSourceTransaction("main", this.transaction);
-    const transaction = this.mainTransaction;
     if (!execution.workflow) {
-      execution.workflow = plugin.enabledCache.get(execution.workflowId) || await execution.getWorkflow({ transaction });
+      execution.workflow = plugin.enabledCache.get(execution.workflowId) || await execution.getWorkflow();
+    }
+    if (!execution.workflow) {
+      throw new Error(`workflow (#${execution.workflowId}) not found for execution (#${execution.id})`);
     }
-    const nodes = execution.workflow.nodes || await execution.workflow.getNodes({ transaction });
+    const nodes = execution.workflow.nodes || await execution.workflow.getNodes();
     execution.workflow.nodes = nodes;
     this.makeNodes(nodes);
     const JobDBModel = plugin.db.getModel("jobs");
@@ -132,52 +222,130 @@ class Processor {
       where: {
         executionId: execution.id
       },
-      raw: true,
-      transaction
+      raw: true
     });
     const jobs = await execution.getJobs({
       where: {
         id: jobIds.map((item) => item.id)
       },
-      order: [["id", "ASC"]],
-      transaction
+      order: [["id", "ASC"]]
     });
     execution.jobs = jobs;
     this.makeJobs(jobs);
   }
   async start() {
     const { execution } = this;
-    if (execution.status) {
+    if (!await this.shouldContinueExecution()) {
       this.logger.warn(`execution was ended with status ${execution.status} before, could not be started again`, {
         workflowId: execution.workflowId
       });
       return;
     }
-    await this.prepare();
-    if (this.nodes.length) {
-      const head = this.nodes.find((item) => !item.upstream);
-      await this.run(head, { result: execution.context });
-    } else {
-      await this.exit(import_constants.JOB_STATUS.RESOLVED);
+    this.enterRunningState();
+    try {
+      await this.prepare();
+      if (this.nodes.length) {
+        const head = this.nodes.find((item) => !item.upstream);
+        if (!head) {
+          this.logger.warn(`head node not found for workflow (${execution.workflowId}), could not be started`, {
+            workflowId: execution.workflowId
+          });
+          return this.exit(import_constants.JOB_STATUS.ERROR);
+        }
+        await this.run(head);
+      } else {
+        await this.exit(import_constants.JOB_STATUS.RESOLVED);
+      }
+    } finally {
+      this.leaveRunningState();
     }
   }
   async resume(job) {
     const { execution } = this;
-    if (execution.status) {
+    if (!await this.shouldContinueExecution()) {
       this.logger.warn(`execution was ended with status ${execution.status} before, could not be resumed`, {
         workflowId: execution.workflowId
       });
       return;
     }
-    await this.prepare();
-    const node = this.nodesMap.get(job.nodeId);
-    await this.recall(node, job);
+    this.enterRunningState();
+    try {
+      await this.prepare();
+      const node = this.nodesMap.get(job.nodeId);
+      await this.recall(node, job);
+    } finally {
+      this.leaveRunningState();
+    }
+  }
+  resolveRerun(options = {}) {
+    const node = this.getRerunNode(options.nodeId);
+    const targetJob = this.jobsMapByNodeKey[node.key];
+    if (options.nodeId != null && !targetJob) {
+      throw new Error(`job of node (#${node.id}) not found in execution (#${this.execution.id})`);
+    }
+    if (options.nodeId == null && options.overwrite && !targetJob) {
+      throw new Error(`job of head node (#${node.id}) not found in execution (#${this.execution.id})`);
+    }
+    const input = this.getRerunInput(node);
+    return { node, input, targetJob };
+  }
+  async rerun(options = {}) {
+    const { execution } = this;
+    if (execution.status !== import_constants.EXECUTION_STATUS.STARTED) {
+      throw new Error(`execution (#${execution.id}) is not started`);
+    }
+    if (!await this.shouldContinueExecution()) {
+      this.logger.warn(`execution was ended with status ${execution.status} before, could not be rerun`, {
+        workflowId: execution.workflowId
+      });
+      return;
+    }
+    this.enterRunningState();
+    try {
+      await this.prepare();
+      const { node, input, targetJob } = this.resolveRerun(options);
+      this.rerunContext = {
+        overwrite: options.overwrite === true,
+        targetJob
+      };
+      return await this.run(node, input, { rerun: true });
+    } finally {
+      this.rerunContext = null;
+      this.leaveRunningState();
+    }
   }
-  async exec(instruction, node, prevJob) {
+  getRerunNode(nodeId) {
+    if (nodeId != null) {
+      const node = this.nodesMap.get(nodeId) || this.nodes.find((item) => String(item.id) === String(nodeId));
+      if (!node) {
+        throw new Error(`node (#${nodeId}) not found in workflow (#${this.execution.workflowId})`);
+      }
+      return node;
+    }
+    const head = this.nodes.find((item) => !item.upstream);
+    if (!head) {
+      throw new Error(`head node not found in workflow (#${this.execution.workflowId})`);
+    }
+    return head;
+  }
+  getRerunInput(node) {
+    if (!node.upstream) {
+      return { result: this.execution.context };
+    }
+    const upstreamJob = this.jobsMapByNodeKey[node.upstream.key];
+    if (!upstreamJob) {
+      throw new Error(`upstream job of node (#${node.id}) not found in execution (#${this.execution.id})`);
+    }
+    return upstreamJob;
+  }
+  async exec(instruction, node, prevJob, options = {}) {
     let job;
+    if (!await this.shouldContinueExecution()) {
+      return this.exit();
+    }
     try {
       this.logger.debug(`config of node`, { data: node.config, workflowId: node.workflowId });
-      job = await instruction(node, prevJob, this);
+      job = await instruction(node, prevJob, this, { ...options, signal: this.abortSignal });
       if (job === null) {
         return this.exit();
       }
@@ -185,18 +353,27 @@ class Processor {
         return this.exit(true);
       }
     } catch (err) {
-      this.logger.error(
-        `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) failed: `,
-        { error: err, workflowId: node.workflowId }
-      );
-      job = {
-        result: err instanceof Error ? {
-          message: err.message,
-          ...err
-        } : err,
-        status: import_constants.JOB_STATUS.ERROR
-      };
-      if (prevJob && prevJob.nodeId === node.id) {
+      if ((0, import_timeout_errors.isWorkflowTimeoutError)(err) || this.abortSignal.aborted && this.aborted) {
+        job = {
+          result: {
+            message: err.message
+          },
+          status: import_constants.JOB_STATUS.ABORTED
+        };
+      } else {
+        this.logger.error(
+          `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) failed: `,
+          { error: err, workflowId: node.workflowId }
+        );
+        job = {
+          result: err instanceof Error ? {
+            ...err,
+            message: err.message
+          } : err,
+          status: import_constants.JOB_STATUS.ERROR
+        };
+      }
+      if (prevJob instanceof import_database.Model && prevJob.nodeId === node.id) {
         prevJob.set(job);
         job = prevJob;
       }
@@ -213,13 +390,16 @@ class Processor {
       }
     );
     this.logger.debug(`result of node`, { data: savedJob.result });
+    if (this.execution.status === import_constants.EXECUTION_STATUS.ABORTED || this.isTimeoutAborted()) {
+      return this.exit(import_constants.JOB_STATUS.ABORTED);
+    }
     if (savedJob.status === import_constants.JOB_STATUS.RESOLVED && node.downstream) {
       this.logger.debug(`run next node (${node.downstreamId})`);
       return this.run(node.downstream, savedJob);
     }
     return this.end(node, savedJob);
   }
-  async run(node, input) {
+  async run(node, input, options) {
     const { instructions } = this.options.plugin;
     const instruction = instructions.get(node.type);
     if (!instruction) {
@@ -231,7 +411,7 @@ class Processor {
     this.logger.info(`execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id})`, {
       workflowId: node.workflowId
     });
-    return this.exec(instruction.run.bind(instruction), node, input);
+    return this.exec(instruction.run.bind(instruction), node, input, options);
   }
   // parent node should take over the control
   async end(node, job) {
@@ -263,6 +443,7 @@ class Processor {
     return this.exec(instruction.resume.bind(instruction), node, job);
   }
   async exit(s) {
+    this.leaveRunningState();
     if (s === true) {
       return;
     }
@@ -289,7 +470,7 @@ class Processor {
           if (changes.length) {
             await this.options.plugin.db.sequelize.query(
               `UPDATE ${JobCollection.quotedTableName()} SET ${changes.map(([key]) => `${key} = ?`)} WHERE id='${job.id}'`,
-              { replacements: changes.map(([, value]) => value), transaction: this.mainTransaction }
+              { replacements: changes.map(([, value]) => value) }
             );
           }
         }
@@ -299,7 +480,6 @@ class Processor {
         await JobsModel.bulkCreate(
           newJobs.map((job) => job.toJSON()),
           {
-            transaction: this.mainTransaction,
             returning: false
           }
         );
@@ -311,10 +491,29 @@ class Processor {
     }
     if (typeof s === "number") {
       const status = this.constructor.StatusMap[s] ?? Math.sign(s);
-      await this.execution.update({ status }, { transaction: this.mainTransaction });
+      const values = { status };
+      if (status === import_constants.EXECUTION_STATUS.ABORTED && this.abortReason) {
+        values.reason = this.abortReason;
+      }
+      const ExecutionModelClass = this.options.plugin.db.getModel("executions");
+      const [affected] = await ExecutionModelClass.update(values, {
+        where: {
+          id: this.execution.id,
+          status: import_constants.EXECUTION_STATUS.STARTED
+        },
+        individualHooks: true
+      });
+      if (affected) {
+        this.execution.set(values);
+      } else {
+        await this.execution.reload();
+      }
     }
-    if (this.mainTransaction && this.mainTransaction !== this.transaction) {
-      await this.mainTransaction.commit();
+    if (this.execution.status === import_constants.EXECUTION_STATUS.STARTED) {
+      this.options.plugin.timeoutManager.scheduleExecutionTimeout(this.execution);
+    } else {
+      this.options.plugin.timeoutManager.clear(this.execution.id);
+      this.options.plugin.timeoutManager.invalidateNextExpiresAtIfMatches(this.execution.expiresAt);
     }
     this.logger.info(`execution (${this.execution.id}) exiting with status ${this.execution.status}`, {
       workflowId: this.execution.workflowId
@@ -325,12 +524,21 @@ class Processor {
    * @experimental
    */
   saveJob(payload) {
+    var _a;
     const { database } = this.execution.constructor;
-    const { model } = database.getCollection("jobs");
+    const model = database.getModel("jobs");
     let job;
     if (payload instanceof model) {
       job = payload;
       job.set("updatedAt", /* @__PURE__ */ new Date());
+    } else if (((_a = this.rerunContext) == null ? void 0 : _a.overwrite) && this.rerunContext.targetJob && this.rerunContext.targetJob.nodeId === payload.nodeId) {
+      job = this.rerunContext.targetJob;
+      job.set({
+        status: payload.status,
+        result: Object.prototype.hasOwnProperty.call(payload, "result") ? payload.result : null,
+        meta: Object.prototype.hasOwnProperty.call(payload, "meta") ? payload.meta : null,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
     } else {
       job = model.build(
         {
@@ -345,7 +553,7 @@ class Processor {
         }
       );
     }
-    this.jobsToSave.set(job.id, job);
+    this.jobsToSave.set(job.id.toString(), job);
     this.lastSavedJob = job;
     this.jobsMapByNodeKey[job.nodeKey] = job;
     this.jobResultsMapByNodeKey[job.nodeKey] = job.result;
@@ -360,6 +568,36 @@ class Processor {
   getBranches(node) {
     return this.nodes.filter((item) => item.upstream === node && item.branchIndex !== null).sort((a, b) => Number(a.branchIndex) - Number(b.branchIndex));
   }
+  enterRunningState() {
+    this.options.plugin.timeoutManager.clear(this.execution.id);
+    this.abortReason = null;
+    this.aborted = false;
+    this.options.plugin.registerRunningExecution(this.execution.id, (reason) => this.abortExecution(reason));
+    this.runningRegistered = true;
+    const remaining = this.execution.expiresAt ? this.execution.expiresAt.getTime() - Date.now() : null;
+    if (remaining == null) {
+      return;
+    }
+    if (remaining <= 0) {
+      this.abortExecution(import_constants.EXECUTION_REASON.TIMEOUT);
+      return;
+    }
+    this.setTimeoutGuard(remaining);
+  }
+  async shouldContinueExecution() {
+    return this.options.plugin.timeoutManager.shouldContinue(this.execution);
+  }
+  leaveRunningState() {
+    if (this.timeoutGuard) {
+      clearTimeout(this.timeoutGuard);
+      this.timeoutGuard = null;
+    }
+    if (!this.runningRegistered) {
+      return;
+    }
+    this.options.plugin.unregisterRunningExecution(this.execution.id);
+    this.runningRegistered = false;
+  }
   /**
    * @experimental
    * find the first node in current branch
@@ -423,7 +661,7 @@ class Processor {
    * @experimental
    */
   getScope(sourceNodeId, includeSelfScope = false) {
-    const node = this.nodesMap.get(sourceNodeId);
+    const node = sourceNodeId ? this.nodesMap.get(sourceNodeId) : void 0;
     const systemFns = {};
     const scope = {
       execution: this.execution,

package/dist/server/RunningExecutionRegistry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+type AbortHandler = {
+    abort(reason?: string): void;
+};
+export default class RunningExecutionRegistry {
+    private readonly executions;
+    register(executionId: number | string, handler: AbortHandler): void;
+    unregister(executionId: number | string): void;
+    abort(executionId: number | string, reason?: string): boolean;
+}
+export {};

package/dist/server/RunningExecutionRegistry.js

@@ -0,0 +1,48 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RunningExecutionRegistry_exports = {};
+__export(RunningExecutionRegistry_exports, {
+  default: () => RunningExecutionRegistry
+});
+module.exports = __toCommonJS(RunningExecutionRegistry_exports);
+class RunningExecutionRegistry {
+  executions = /* @__PURE__ */ new Map();
+  register(executionId, handler) {
+    this.executions.set(String(executionId), handler);
+  }
+  unregister(executionId) {
+    this.executions.delete(String(executionId));
+  }
+  abort(executionId, reason) {
+    const handler = this.executions.get(String(executionId));
+    if (!handler) {
+      return false;
+    }
+    handler.abort(reason);
+    return true;
+  }
+}