@0dep/bpmn-extensions 0.0.2 → 0.0.4

package/src/ElementExtensions.js

@@ -1,7 +1,15 @@
 import { getExtensions } from './getExtensions.js';
+import { getFeelScope } from './feel.js';
 
 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.
+export const ON_ENTER_TAG = '0dep-bpmn-extensions:on-enter';
+export const ON_EXECUTED_TAG = '0dep-bpmn-extensions:on-executed';
+export const ON_START_TAG = '0dep-bpmn-extensions:on-start';
+export const ON_END_TAG = '0dep-bpmn-extensions:on-end';
+
 /**
  * Activity-level extensions.
  *
@@ -10,43 +18,55 @@ const SUBPROCESS_TYPES = new Set(['bpmn:SubProcess', 'bpmn:AdHocSubProcess', 'bp
  * proceeding — the same mechanism bpmn-elements uses for extension formatting.
  */
 export 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 {
@@ -56,7 +76,10 @@ export 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 {
@@ -66,7 +89,10 @@ export 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 });
@@ -78,13 +104,17 @@ export 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
@@ -96,13 +126,16 @@ export 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 };
     }
@@ -132,6 +165,10 @@ export 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

package/src/Expressions.js

@@ -1,4 +1,4 @@
-import { isFeelExpression, evaluateFeel } from './feel.js';
+import { isFeelExpression, evaluateFeel, getFeelScope } from './feel.js';
 
 /**
  * FEEL-aware expressions implementation for bpmn-elements.
@@ -7,7 +7,7 @@ import { isFeelExpression, evaluateFeel } from './feel.js';
  * 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}}
  */
 export function FeelExpressions() {
   return {
@@ -27,23 +27,12 @@ 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));
 }

package/src/ProcessExtensions.js

@@ -6,8 +6,12 @@ import { getExtensions } from './getExtensions.js';
  * the result to the process variables.
  */
 export class ProcessExtensions {
+  /**
+   * @param {import('bpmn-elements').Process} bp
+   */
   constructor(bp) {
     this.process = bp;
+    /** @type {import('./getExtensions.js').ExtensionHandlers} */
     this.extensions = getExtensions(bp);
   }
   activate() {
@@ -21,6 +25,9 @@ export 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,

package/src/SubProcessExtensions.js

@@ -1,4 +1,4 @@
-import { ElementExtensions } from './ElementExtensions.js';
+import { ElementExtensions, ON_ENTER_TAG, ON_EXECUTED_TAG, ON_START_TAG, ON_END_TAG } from './ElementExtensions.js';
 
 /**
  * Sub-process extensions.
@@ -14,14 +14,14 @@ export 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) {

package/src/extensions/FeelScripts.js

@@ -1,4 +1,4 @@
-import { isFeelExpression, evaluateFeel } from '../feel.js';
+import { isFeelExpression, evaluateFeel, getFeelScope } from '../feel.js';
 
 /**
  * A bpmn-elements `scripts` implementation for script tasks.
@@ -16,7 +16,15 @@ export 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;
@@ -30,7 +38,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);

package/src/extensions/Form.js

@@ -1,4 +1,4 @@
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * `zeebe:formDefinition`.
@@ -13,7 +13,7 @@ export 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) }),

package/src/extensions/IoMapping.js

@@ -1,4 +1,4 @@
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * `zeebe:ioMapping`.
@@ -28,7 +28,7 @@ export 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;
@@ -42,7 +42,7 @@ export 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;

package/src/extensions/LoopCharacteristics.js

@@ -21,7 +21,7 @@ export 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) {

package/src/extensions/Properties.js

@@ -1,4 +1,4 @@
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * `zeebe:properties`.
@@ -11,7 +11,7 @@ export 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;

package/src/extensions/Subscription.js

@@ -0,0 +1,30 @@
+import { resolveValue, getFeelScope } from '../feel.js';
+
+/**
+ * `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(...)`).
+ */
+export 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)),
+    };
+  }
+}

package/src/extensions/TaskDefinition.js

@@ -1,5 +1,5 @@
 import { ServiceError } from '../Errors.js';
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * `zeebe:taskDefinition`.
@@ -22,13 +22,19 @@ export 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);
   }

package/src/extensions/formatters.js

@@ -1,16 +1,23 @@
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * Format an activity on enter from its behaviour and extensions: documentation and,
  * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups).
  */
 export 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;
@@ -37,15 +44,21 @@ export class FormatActivity {
  * Format a process on enter: documentation.
  */
 export 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;
   }
@@ -58,7 +71,7 @@ export 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(',')

package/src/feel.js

@@ -40,11 +40,11 @@ export 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
  */
 export function evaluateFeelUnaryTest(expression, input, context) {
-  const { value } = unaryTest(stripFeel(expression), { ...(context || {}), '?': input });
-  return value;
+  const { value } = unaryTest(stripFeel(expression), { ...context, '?': input });
+  return value === true;
 }
 
 /**
@@ -58,3 +58,18 @@ export function resolveValue(value, context) {
   if (isFeelExpression(value)) return evaluateFeel(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>}
+ */
+export function getFeelScope(environment, localVariables) {
+  return { services: environment?.services, ...environment?.variables, ...localVariables };
+}

package/src/getExtensions.js

@@ -6,24 +6,31 @@ import { ExecutionListeners } from './extensions/ExecutionListeners.js';
 import { Form } from './extensions/Form.js';
 import { LoopCharacteristics } from './extensions/LoopCharacteristics.js';
 import { JobService } from './extensions/TaskDefinition.js';
+import { Subscription } from './extensions/Subscription.js';
+
+/**
+ * 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}
  */
-export function getExtensions(element) {
+export function getExtensions(element, context) {
   const result = {};
   const isProcess = element.type === 'bpmn:Process';
 
@@ -67,6 +74,18 @@ export 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'

package/src/index.js

@@ -5,15 +5,15 @@ import { SubProcessExtensions } from './SubProcessExtensions.js';
 export { ElementExtensions, ProcessExtensions, SubProcessExtensions };
 export { FeelExpressions } from './Expressions.js';
 export { FeelScripts } from './extensions/FeelScripts.js';
-export { isFeelExpression, stripFeel, evaluateFeel, evaluateFeelUnaryTest, resolveValue } from './feel.js';
+export { isFeelExpression, stripFeel, evaluateFeel, evaluateFeelUnaryTest, resolveValue, getFeelScope } from './feel.js';
 export { JobService } from './extensions/TaskDefinition.js';
 export { ServiceError, FormatError } from './Errors.js';
 
 /**
  * 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
  */
 
 /**