@0dep/bpmn-extensions 0.0.2 → 0.0.4

package/README.md

@@ -21,6 +21,12 @@ npm install @0dep/bpmn-extensions bpmn-elements
 
 - **FEEL expressions** — a `FeelExpressions()` adapter resolves FEEL (`= order.total > 100`)
   everywhere bpmn-elements resolves an expression, including sequence flow conditions.
+- **Environment services in FEEL scope** — every FEEL expression can call the environment services
+  as functions, namespaced under `services` (e.g. a condition `= services.isEligible(order)`).
+  This strays from strict Camunda 8 conformance on purpose: unlike functions smuggled through
+  variables, services survive `getState()`/`recover()` — state is JSON-serialized (functions are
+  dropped), while services are re-supplied by the host at recover time — so service-backed
+  conditions are resume-safe. A variable named `services` shadows the overlay.
 - **`zeebe:script`** — a `FeelScripts()` adapter runs a script task's FEEL `expression` and assigns
   the result to its `resultVariable`.
 - **`zeebe:taskDefinition`** — maps a service task's job `type` to an environment service (job worker).
@@ -40,6 +46,10 @@ npm install @0dep/bpmn-extensions bpmn-elements
 - **`zeebe:calledElement`** — call activity target process id.
 - **`zeebe:loopCharacteristics`** — collection-based multi-instance (`inputCollection` / `inputElement`),
   sequential or parallel, with `outputElement` aggregated into the `outputCollection` array in input order.
+- **`zeebe:subscription`** — the referenced message's `correlationKey` is resolved when the catching
+  element (receive task, message event) starts waiting, and exposed on its content as
+  `subscription: { message, correlationKey }` — route an incoming message by matching it against the
+  waiting elements (`getPostponed()`) and signalling the right one.
 
 ## API
 
@@ -48,7 +58,8 @@ npm install @0dep/bpmn-extensions bpmn-elements
   bpmn-elements expects on the behaviour: call activity process id and multi-instance collection).
 - `FeelExpressions()` — a bpmn-elements `IExpressions` implementation backed by FEEL.
 - `FeelScripts()` — a bpmn-elements `scripts` implementation that runs `zeebe:script` FEEL expressions.
-- FEEL helpers: `isFeelExpression`, `stripFeel`, `evaluateFeel`, `evaluateFeelUnaryTest`, `resolveValue`.
+- FEEL helpers: `isFeelExpression`, `stripFeel`, `evaluateFeel`, `evaluateFeelUnaryTest`, `resolveValue`,
+  `getFeelScope` (the scope every expression is evaluated in: `services` + environment variables + local overlay).
 - `JobService`, `ServiceError`, `FormatError`.
 
 ## Usage
@@ -128,8 +139,12 @@ in `test/helpers/factory.js`, then run on a real bpmn-elements `Definition`. The
 the engine's `Logger` to the [`debug`](https://www.npmjs.com/package/debug) package, so
 `DEBUG=bpmn-extensions:* npm test` traces the engine and extensions (`:error:*` for errors only).
 
-See the `camunda8-bpmn-schemas` skill (`.claude/skills/`) for a reference of the `zeebe:*`
-extension elements and FEEL.
+# Ecosystem
+
+- [bpmn-engine](https://github.com/paed01/bpmn-engine) — BPMN 2.0 execution engine wrapping `bpmn-elements`; the batteries-included way to run, stop, resume, and recover flows.
+- [bpmn-middleware](https://github.com/zerodep/bpmn-middleware) — Express middleware exposing the engine over HTTP, with pluggable state storage.
+- [@onify/flow-extensions](https://github.com/onify/flow-extensions) — Onify Flow extensions for `bpmn-elements`.
+- [dmn-elements](https://github.com/zerodep/dmn-elements) — Executable DMN 1.3 decision elements; back a Business Rule Task with it (see [Conformance](/docs/Conformance.md#business-rule-task-and-dmn)).
 
 ## License
 

package/dist/index.js

@@ -16203,11 +16203,11 @@ function evaluateFeel(expression, context) {
  * @param {string} expression FEEL unary test
  * @param {any} input The value being tested, available as `?` in the test
  * @param {Record<string, any>} [context] Additional variables in scope
- * @returns {boolean}
+ * @returns {boolean} true only when the test is satisfied — an undecidable (null) test is false
  */
 function evaluateFeelUnaryTest(expression, input, context) {
-  const { value } = unaryTest(stripFeel(expression), { ...(context || {}), '?': input });
-  return value;
+  const { value } = unaryTest(stripFeel(expression), { ...context, '?': input });
+  return value === true;
 }
 
 /**
@@ -16222,17 +16222,39 @@ function resolveValue(value, context) {
   return value;
 }
 
+/**
+ * Build the FEEL evaluation scope for an environment. The environment services are exposed
+ * under `services`, callable as FEEL functions (e.g. `services.isEligible(order)`) — resume-safe,
+ * since the host re-supplies services at recover time, unlike functions smuggled through
+ * variables, which JSON state serialization drops. The environment variables form the base
+ * scope, overlaid with any local variables (a job result, element-local variables such as a
+ * multi-instance item); a variable named `services` shadows the overlay.
+ * @param {import('bpmn-elements').Environment} [environment]
+ * @param {Record<string, any>} [localVariables] scope-local overlay
+ * @returns {Record<string, any>}
+ */
+function getFeelScope(environment, localVariables) {
+  return { services: environment?.services, ...environment?.variables, ...localVariables };
+}
+
 /**
  * Format an activity on enter from its behaviour and extensions: documentation and,
  * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups).
  */
 class FormatActivity {
+  /**
+   * @param {import('bpmn-elements').Activity} activity
+   * @param {any} assignmentDefinition
+   */
   constructor(activity, assignmentDefinition) {
     this.activity = activity;
     this.assignmentDefinition = assignmentDefinition;
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   resolve(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const result = {};
 
     const documentation = this.activity.behaviour.documentation;
@@ -16259,15 +16281,21 @@ class FormatActivity {
  * Format a process on enter: documentation.
  */
 class FormatProcess {
+  /**
+   * @param {import('bpmn-elements').Process} bp
+   */
   constructor(bp) {
     this.process = bp;
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Process>} elementApi
+   */
   resolve(elementApi) {
     const result = {};
     const documentation = this.process.behaviour.documentation;
     if (documentation && !elementApi.content.description) {
       const text = documentation[0]?.text;
-      if (text) result.description = resolveValue(text, elementApi.environment.variables);
+      if (text) result.description = resolveValue(text, getFeelScope(elementApi.environment));
     }
     return result;
   }
@@ -16280,7 +16308,7 @@ class FormatProcess {
 function resolveList(value, scope) {
   if (!value) return undefined;
   const resolved = resolveValue(value, scope);
-  if (Array.isArray(resolved)) return resolved.filter((v) => v !== null && v !== undefined);
+  if (Array.isArray(resolved)) return resolved.filter(Boolean);
   if (typeof resolved !== 'string') return undefined;
   return resolved
     .split(',')
@@ -16316,7 +16344,7 @@ class IoMapping {
    * @param {import('bpmn-elements').IApi<any>} elementApi
    */
   getInput(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const result = {};
     for (const { source, target } of this.inputParameters) {
       if (!target) continue;
@@ -16330,7 +16358,7 @@ class IoMapping {
    * @param {Record<string, any>} [jobResult] Variables produced by the job
    */
   getOutput(elementApi, jobResult) {
-    const scope = { ...elementApi.environment.variables, ...jobResult };
+    const scope = getFeelScope(elementApi.environment, jobResult);
     const result = {};
     for (const { source, target } of this.outputParameters) {
       if (!target) continue;
@@ -16386,7 +16414,7 @@ class Properties {
     this.properties = properties.properties || [];
   }
   resolve(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const result = {};
     for (const { name, value } of this.properties) {
       if (name === undefined) continue;
@@ -16482,7 +16510,7 @@ class Form {
     this.formDefinition = formDefinition;
   }
   resolve(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const { formId, formKey, externalReference, bindingType, versionTag } = this.formDefinition;
     return {
       ...(formId !== undefined && { formId: resolveValue(formId, scope) }),
@@ -16515,7 +16543,7 @@ class LoopCharacteristics {
   }
   /**
    * @param {Record<string, any>|undefined} indexedOutput bpmn-elements index-keyed instance outputs
-   * @param {Record<string, any>} baseScope process variables in scope for `outputElement`
+   * @param {Record<string, any>} baseScope base scope for `outputElement` (services + process variables)
    * @returns {any[]}
    */
   aggregate(indexedOutput, baseScope) {
@@ -16558,13 +16586,19 @@ function JobService(taskType, activity) {
   this.activity = activity;
 }
 
+/**
+ * Execute
+ * @param {import('bpmn-elements').ElementBrokerMessage} executionMessage
+ * @param {CallableFunction} callback
+ * @returns {any}
+ */
 JobService.prototype.execute = function execute(executionMessage, callback) {
   const activity = this.activity;
   const environment = activity.environment;
 
   let jobType;
   try {
-    jobType = resolveValue(this.taskType, environment.variables);
+    jobType = resolveValue(this.taskType, getFeelScope(environment));
   } catch (err) {
     return callback(err);
   }
@@ -16575,23 +16609,58 @@ JobService.prototype.execute = function execute(executionMessage, callback) {
   return serviceFn.call(activity, executionMessage, (err, result) => callback(err, result));
 };
 
+/**
+ * `zeebe:subscription` — rides on the referenced `bpmn:Message`, not on the catching element.
+ *
+ * Resolves the correlation key in the activity's variable scope on enter and exposes it on the
+ * element content as `subscription`. Correlation itself is the embedding application's job:
+ * read the resolved key off the waiting activity (`getPostponed()` → `content.subscription`)
+ * and signal the matching one (`api.signal(...)`).
+ */
+class Subscription {
+  /**
+   * @param {{ id: string, name?: string }} messageRef The serialized message reference
+   * @param {{ correlationKey: string }} subscription The `zeebe:Subscription` behaviour
+   */
+  constructor(messageRef, subscription) {
+    this.message = { id: messageRef.id, name: messageRef.name };
+    this.correlationKey = subscription.correlationKey;
+  }
+  /**
+   * @param {import('bpmn-elements').IApi<any>} elementApi
+   * @returns {{ message: { id: string, name?: string }, correlationKey: any }}
+   */
+  resolve(elementApi) {
+    return {
+      message: this.message,
+      correlationKey: resolveValue(this.correlationKey, getFeelScope(elementApi.environment)),
+    };
+  }
+}
+
+/**
+ * The extension handlers assembled for one element.
+ * @typedef {object} ExtensionHandlers
+ * @property {FormatActivity | FormatProcess} format
+ * @property {IoMapping} [io]
+ * @property {TaskHeaders} [headers]
+ * @property {Properties} [properties]
+ * @property {ExecutionListeners} [listeners]
+ * @property {Form} [form]
+ * @property {LoopCharacteristics} [loop]
+ * @property {any} [script]
+ * @property {any} [calledDecision]
+ * @property {Function} [Service]
+ * @property {Subscription} [subscription]
+ */
+
 /**
  * Inspect an element's extension elements and assemble the extension handlers it needs.
  * @param {import('bpmn-elements').Activity | import('bpmn-elements').Process} element
- * @returns {{
- *   format: FormatActivity | FormatProcess,
- *   io?: IoMapping,
- *   headers?: TaskHeaders,
- *   properties?: Properties,
- *   listeners?: ExecutionListeners,
- *   form?: Form,
- *   loop?: LoopCharacteristics,
- *   script?: any,
- *   calledDecision?: any,
- *   Service?: Function,
- * }}
+ * @param {import('bpmn-elements').ContextInstance} [context]
+ * @returns {ExtensionHandlers}
  */
-function getExtensions(element) {
+function getExtensions(element, context) {
   const result = {};
   const isProcess = element.type === 'bpmn:Process';
 
@@ -16635,6 +16704,18 @@ function getExtensions(element) {
     }
   }
 
+  // A message catch (receive task / message event) may reference a bpmn:Message carrying a
+  // zeebe:subscription with the correlation key. The subscription lives on the message element,
+  // which the instantiated bpmn-elements Message strips — read it off the serialized context.
+  const messageRef =
+    element.behaviour.messageRef ?? element.behaviour.eventDefinitions?.find((ed) => ed.behaviour?.messageRef)?.behaviour.messageRef;
+  if (messageRef?.id && context) {
+    const subscription = context.definitionContext
+      .getActivityById(messageRef.id)
+      ?.behaviour.extensionElements?.values?.find((v) => v.$type === 'zeebe:Subscription');
+    if (subscription?.correlationKey) result.subscription = new Subscription(messageRef, subscription);
+  }
+
   // Output side of a multi-instance `zeebe:loopCharacteristics` (the input side is lifted by extendFn).
   const loopExtension = element.behaviour.loopCharacteristics?.behaviour?.extensionElements?.values?.find(
     (v) => v.$type === 'zeebe:LoopCharacteristics'
@@ -16648,6 +16729,13 @@ function getExtensions(element) {
 
 const SUBPROCESS_TYPES = new Set(['bpmn:SubProcess', 'bpmn:AdHocSubProcess', 'bpmn:Transaction']);
 
+// Consumer tags shared between activate (here and in the SubProcessExtensions override) and
+// deactivate — deactivate cancels by tag, so both must subscribe with these exact tags.
+const ON_ENTER_TAG = '0dep-bpmn-extensions:on-enter';
+const ON_EXECUTED_TAG = '0dep-bpmn-extensions:on-executed';
+const ON_START_TAG = '0dep-bpmn-extensions:on-start';
+const ON_END_TAG = '0dep-bpmn-extensions:on-end';
+
 /**
  * Activity-level extensions.
  *
@@ -16656,43 +16744,55 @@ const SUBPROCESS_TYPES = new Set(['bpmn:SubProcess', 'bpmn:AdHocSubProcess', 'bp
  * proceeding — the same mechanism bpmn-elements uses for extension formatting.
  */
 class ElementExtensions {
-  constructor(activity) {
+  /**
+   * @param {import('bpmn-elements').Activity} activity
+   * @param {import('bpmn-elements').ContextInstance} context
+   */
+  constructor(activity, context) {
     this.activity = activity;
     this.formatQ = activity.broker.getQueue('format-run-q');
 
-    this.extensions = getExtensions(activity);
+    /** @type {import('./getExtensions.js').ExtensionHandlers} */
+    this.extensions = getExtensions(activity, context);
     const Service = this.extensions.Service;
     if (Service) activity.behaviour.Service = Service;
   }
+  /**
+   * Activate extensions
+   * @param {import('bpmn-elements').ElementBrokerMessage} message
+   */
   activate(message) {
     const activity = this.activity;
     const listeners = this.extensions.listeners;
 
     if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
-      activity.on('start', (api) => this._onEnter(api), { consumerTag: '0dep-bpmn-extensions:on-enter' });
+      activity.on('start', (api) => this._onEnter(api), { consumerTag: ON_ENTER_TAG });
     } else {
-      activity.on('enter', (api) => this._onEnter(api), { consumerTag: '0dep-bpmn-extensions:on-enter' });
+      activity.on('enter', (api) => this._onEnter(api), { consumerTag: ON_ENTER_TAG });
     }
 
     activity.on('activity.execution.completed', (api) => this._onExecuted(api), {
-      consumerTag: '0dep-bpmn-extensions:on-executed',
+      consumerTag: ON_EXECUTED_TAG,
     });
 
     if (listeners?.onStart) {
-      activity.on('start', (api) => this._onListener('start', api), { consumerTag: '0dep-bpmn-extensions:on-start' });
+      activity.on('start', (api) => this._onListener('start', api), { consumerTag: ON_START_TAG });
     }
     if (listeners?.onEnd) {
-      activity.on('end', (api) => this._onListener('end', api), { consumerTag: '0dep-bpmn-extensions:on-end' });
+      activity.on('end', (api) => this._onListener('end', api), { consumerTag: ON_END_TAG });
     }
   }
   deactivate() {
     const broker = this.activity.broker;
-    broker.cancel('0dep-bpmn-extensions:on-enter');
-    broker.cancel('0dep-bpmn-extensions:on-executed');
-    broker.cancel('0dep-bpmn-extensions:on-start');
-    broker.cancel('0dep-bpmn-extensions:on-end');
+    broker.cancel(ON_ENTER_TAG);
+    broker.cancel(ON_EXECUTED_TAG);
+    broker.cancel(ON_START_TAG);
+    broker.cancel(ON_END_TAG);
   }
-  /** @internal Shared with SubProcessExtensions. */
+  /**
+   * @internal Shared with SubProcessExtensions.
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   async _onEnter(elementApi) {
     this.formatQ.queueMessage({ routingKey: 'run.enter.format' }, { endRoutingKey: 'run.enter.complete' }, { persistent: false });
     try {
@@ -16702,7 +16802,10 @@ class ElementExtensions {
       elementApi.broker.publish('format', 'run.enter.error', { error: err }, { persistent: false });
     }
   }
-  /** @internal Shared with SubProcessExtensions. */
+  /**
+   * @internal Shared with SubProcessExtensions.
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   async _onExecuted(elementApi) {
     this.formatQ.queueMessage({ routingKey: 'run.end.format' }, { endRoutingKey: 'run.end.complete' }, { persistent: false });
     try {
@@ -16712,7 +16815,10 @@ class ElementExtensions {
       elementApi.broker.publish('format', 'run.end.error', { error: err }, { persistent: false });
     }
   }
-  /** @internal Shared with SubProcessExtensions. */
+  /**
+   * @internal Shared with SubProcessExtensions.
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   async _onListener(eventType, elementApi) {
     const routingKey = `run.listener.${eventType}`;
     this.formatQ.queueMessage({ routingKey }, { endRoutingKey: `${routingKey}.complete` }, { persistent: false });
@@ -16724,13 +16830,17 @@ class ElementExtensions {
       elementApi.broker.publish('format', `${routingKey}.error`, { error: err }, { persistent: false });
     }
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   #formatOnEnter(elementApi) {
-    const { format, io, headers, properties, form } = this.extensions;
+    const { format, io, headers, properties, form, subscription } = this.extensions;
     const result = { ...format.resolve(elementApi) };
 
     if (headers) result.headers = headers.resolve();
     if (properties) result.properties = properties.resolve(elementApi);
     if (form) result.form = form.resolve(elementApi);
+    if (subscription) result.subscription = subscription.resolve(elementApi);
     if (io?.hasInput) {
       result.input = io.getInput(elementApi);
       // A (sub) process input mapping creates local variables visible to its children; a job
@@ -16742,13 +16852,16 @@ class ElementExtensions {
     Object.assign(elementApi.content, result);
     return result;
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   #formatOnExecuted(elementApi) {
     const { io, script, calledDecision, loop } = this.extensions;
     let jobResult = elementApi.content.output;
 
     // Multi-instance: aggregate the per-instance outputs into the `outputCollection` array.
     if (loop?.hasOutputCollection) {
-      const output = { [loop.outputCollection]: loop.aggregate(jobResult, elementApi.environment.variables) };
+      const output = { [loop.outputCollection]: loop.aggregate(jobResult, getFeelScope(elementApi.environment)) };
       this.#assignOutput(elementApi, output);
       return { output };
     }
@@ -16778,6 +16891,10 @@ class ElementExtensions {
     }
     return {};
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   * @param {any} output
+   */
   #assignOutput(elementApi, output) {
     const environment = this.activity.environment;
     // Visible to downstream FEEL within the process, and surfaced as process output
@@ -16793,8 +16910,12 @@ class ElementExtensions {
  * the result to the process variables.
  */
 class ProcessExtensions {
+  /**
+   * @param {import('bpmn-elements').Process} bp
+   */
   constructor(bp) {
     this.process = bp;
+    /** @type {import('./getExtensions.js').ExtensionHandlers} */
     this.extensions = getExtensions(bp);
   }
   activate() {
@@ -16808,6 +16929,9 @@ class ProcessExtensions {
   deactivate() {
     this.process.broker.cancel('0dep-bpmn-extensions:on-enter');
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Process>} elementApi
+   */
   #onEnter(elementApi) {
     try {
       // bpmn-elements (>=18.0.4) forwards a call activity's formatted input — its io mapping plus,
@@ -16849,14 +16973,14 @@ class SubProcessExtensions extends ElementExtensions {
     const listeners = this.extensions.listeners;
     const enterKey = message.fields.redelivered && message.fields.routingKey === 'run.start' ? 'activity.start' : 'activity.enter';
 
-    this.#subscribe(enterKey, (api) => this._onEnter(api), '0dep-bpmn-extensions:on-enter');
-    this.#subscribe('activity.execution.completed', (api) => this._onExecuted(api), '0dep-bpmn-extensions:on-executed');
+    this.#subscribe(enterKey, (api) => this._onEnter(api), ON_ENTER_TAG);
+    this.#subscribe('activity.execution.completed', (api) => this._onExecuted(api), ON_EXECUTED_TAG);
 
     if (listeners?.onStart) {
-      this.#subscribe('activity.start', (api) => this._onListener('start', api), '0dep-bpmn-extensions:on-start');
+      this.#subscribe('activity.start', (api) => this._onListener('start', api), ON_START_TAG);
     }
     if (listeners?.onEnd) {
-      this.#subscribe('activity.end', (api) => this._onListener('end', api), '0dep-bpmn-extensions:on-end');
+      this.#subscribe('activity.end', (api) => this._onListener('end', api), ON_END_TAG);
     }
   }
   #subscribe(routingKey, callback, consumerTag) {
@@ -16880,7 +17004,7 @@ class SubProcessExtensions extends ElementExtensions {
  * definition resolves FEEL expressions (`= ...`) instead of the default
  * `${...}` template expressions.
  *
- * @returns {import('bpmn-elements').IExpressions}
+ * @returns {import('bpmn-elements').IExpressions & {isExpression: (text:string) => boolean, hasExpression: (text:string) => boolean}}
  */
 function FeelExpressions() {
   return {
@@ -16900,25 +17024,14 @@ function hasExpression(text) {
 
 /**
  * Resolve a templated string. Static literals are returned as-is; FEEL expressions are
- * evaluated against the environment variables (overlaid with any element-local variables).
+ * evaluated in the environment scope (see `getFeelScope`), overlaid with any element-local
+ * variables carried on the message content (e.g. a multi-instance item).
  * @param {string} templatedString
  * @param {{ environment?: import('bpmn-elements').Environment, content?: any }} [context]
  */
 function resolveExpression(templatedString, context) {
   if (!isFeelExpression(templatedString)) return templatedString;
-  return evaluateFeel(templatedString, getScope(context));
-}
-
-/**
- * Build the FEEL variable scope from a resolution context. Process/definition variables form
- * the base scope, overlaid with any local variables carried on the element message content
- * (e.g. a multi-instance item).
- */
-function getScope(context) {
-  const environment = context && context.environment;
-  const variables = environment ? environment.variables : {};
-  const local = context && context.content && context.content.variables;
-  return { ...variables, ...local };
+  return evaluateFeel(templatedString, getFeelScope(context?.environment, context?.content?.variables));
 }
 
 /**
@@ -16937,7 +17050,15 @@ function FeelScripts() {
 }
 
 class FeelScriptRegistry {
-  register() {}
+  register() {
+    return undefined;
+  }
+  /**
+   * @param {string} _scriptFormat
+   * @param {{ id: string, [x: string]: any }} activity
+   * @returns {import('bpmn-elements').Script | undefined} the FEEL script, or undefined when
+   *   the activity has no `zeebe:script`
+   */
   getScript(_scriptFormat, activity) {
     const expression = getScriptExpression(activity);
     if (expression === undefined) return undefined;
@@ -16951,7 +17072,7 @@ class FeelScript {
   }
   execute(scope, callback) {
     try {
-      const value = isFeelExpression(this.expression) ? evaluateFeel(this.expression, { ...scope.environment.variables }) : this.expression;
+      const value = isFeelExpression(this.expression) ? evaluateFeel(this.expression, getFeelScope(scope.environment)) : this.expression;
       callback(null, value);
     } catch (err) {
       callback(err);
@@ -16972,8 +17093,8 @@ function getScriptExpression(activity) {
 /**
  * A flow extension activated by bpmn-elements around an element's run.
  * @typedef {object} FlowExtension
- * @property {(message: any) => void} activate
- * @property {(message?: any) => void} deactivate
+ * @property {(message: import('bpmn-elements').ElementBrokerMessage) => void} activate
+ * @property {(message?: import('bpmn-elements').ElementBrokerMessage) => void} deactivate
  */
 
 /**
@@ -17035,6 +17156,7 @@ exports.evaluateFeel = evaluateFeel;
 exports.evaluateFeelUnaryTest = evaluateFeelUnaryTest;
 exports.extendFn = extendFn;
 exports.extensions = extensions;
+exports.getFeelScope = getFeelScope;
 exports.isFeelExpression = isFeelExpression;
 exports.resolveValue = resolveValue;
 exports.stripFeel = stripFeel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0dep/bpmn-extensions",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Flow extensions for bpmn-elements: FEEL expressions and the zeebe-namespace BPMN extension elements",
   "type": "module",
   "module": "src/index.js",
@@ -51,18 +51,26 @@
     "access": "public"
   },
   "peerDependencies": {
-    "bpmn-elements": ">=18.0.4"
+    "bpmn-elements": ">=18.0.12"
   },
   "dependencies": {
     "feelin": "^7.0.1"
   },
+  "overrides": {
+    "mocha": {
+      "yargs": "^18.1.0"
+    }
+  },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@rollup/plugin-commonjs": "^29.0.3",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "bpmn-elements": "^18.0.4",
+    "@types/chai": "^5.2.3",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^26.1.1",
+    "bpmn-elements": "^18.0.12",
     "bpmn-moddle": "^9.0.1",
-    "c8": "^11.0.0",
+    "c8": "^12.0.0",
     "chai": "^6.2.2",
     "debug": "^4.4.3",
     "dts-buddy": "^0.8.2",