@0dep/bpmn-extensions 0.0.3 → 0.0.5

package/README.md

@@ -1,6 +1,6 @@
 # @0dep/bpmn-extensions
 
-[![Built latest](https://github.com/zerodep/bpmn-extensions/actions/workflows/build-latest.yaml/badge.svg)](https://github.com/zerodep/bpmn-extensions/actions/workflows/build-latest.yaml)[![Coverage Status](https://coveralls.io/repos/github/zerodep/bpmn-extensions/badge.svg?branch=main)](https://coveralls.io/github/zerodep/bpmn-extensions?branch=main)[![npm version](https://img.shields.io/npm/v/@0dep/bpmn-extensions)](https://www.npmjs.com/package/@0dep/bpmn-extensions)
+[![Built latest](https://github.com/zerodep/bpmn-extensions/actions/workflows/build-latest.yaml/badge.svg)](https://github.com/zerodep/bpmn-extensions/actions/workflows/build-latest.yaml)[![Coverage Status](https://coveralls.io/repos/github/zerodep/bpmn-extensions/badge.svg?branch=main)](https://coveralls.io/github/zerodep/bpmn-extensions?branch=main)
 
 Flow extensions for [bpmn-elements](https://github.com/paed01/bpmn-elements) with
 [FEEL](https://www.omg.org/dmn/) expression support.
@@ -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).
@@ -32,6 +38,9 @@ npm install @0dep/bpmn-extensions bpmn-elements
   process's input becomes variables local to its children.
 - **`zeebe:taskHeaders`** / **`zeebe:properties`** — exposed on the element content.
 - **`zeebe:assignmentDefinition`** — assignee / candidate users / groups for user tasks.
+- **`zeebe:priorityDefinition`** / **`zeebe:taskSchedule`** — a user task's `priority` and
+  `dueDate` / `followUpDate` resolved onto the element content for a task list to order and
+  remind by; FEEL date results are exposed as ISO 8601 strings.
 - **`zeebe:formDefinition`** — resolves a user task's form (`formId` / `formKey` / `externalReference`,
   `bindingType`) onto the element content for a task list to render.
 - **`zeebe:executionListeners`** — blocking start/end job workers around an element, called as
@@ -48,11 +57,15 @@ npm install @0dep/bpmn-extensions bpmn-elements
 ## API
 
 - `extensions(element, context)` — the flow extensions factory; pass it as an environment extension.
+  Elements that carry no zeebe extension data (and nothing else to format) get no extension attached
+  at all and run untouched; call activities and processes are always attached, since they propagate
+  io across process boundaries.
 - `extendFn(behaviour)` — moddle-context-serializer behaviour extender (lifts the extension data
   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
@@ -62,7 +75,7 @@ Wire it into a bpmn-elements definition (see `test/helpers/testHelpers.js` for t
 ```javascript
 import { createRequire } from 'node:module';
 import { strict as assert } from 'node:assert';
-import BpmnModdle from 'bpmn-moddle';
+import { BpmnModdle } from 'bpmn-moddle';
 import * as elements from 'bpmn-elements';
 import { Serializer, TypeResolver } from 'moddle-context-serializer';
 import { extensions, extendFn, FeelExpressions, FeelScripts } from '@0dep/bpmn-extensions';

package/dist/index.js

@@ -11609,9 +11609,9 @@ function getSpecializer(spec) {
  *
  * @return {T[]}
  */
-const nativeHasOwnProperty$1 = Object.prototype.hasOwnProperty;
+const nativeHasOwnProperty = Object.prototype.hasOwnProperty;
 
-function isNil$2(obj) {
+function isNil$1(obj) {
   return obj == null;
 }
 
@@ -11623,8 +11623,8 @@ function isNil$2(obj) {
  *
  * @return {Boolean}
  */
-function has$1(target, key) {
-  return !isNil$2(target) && nativeHasOwnProperty$1.call(target, key);
+function has(target, key) {
+  return !isNil$1(target) && nativeHasOwnProperty.call(target, key);
 }
 
 let nextTagID = 0;
@@ -13107,7 +13107,7 @@ class VariableContext {
         continue;
       }
 
-      if (has$1(merged, key)) {
+      if (has(merged, key)) {
 
         // deep merge nested contexts
         merged[key] = this.__merge(merged[key], value);
@@ -13241,7 +13241,7 @@ class Variables {
         return null;
       }
 
-      if (!isNil$2(scope.value)) {
+      if (!isNil$1(scope.value)) {
         return scope.value;
       }
     }
@@ -13871,33 +13871,6 @@ const parser = LRParser.deserialize({
   tokenPrec: 2660
 });
 
-/**
- * Flatten array, one level deep.
- *
- * @template T
- *
- * @param {T[][] | T[] | null} [arr]
- *
- * @return {T[]}
- */
-const nativeHasOwnProperty = Object.prototype.hasOwnProperty;
-
-function isNil$1(obj) {
-  return obj == null;
-}
-
-/**
- * Return true, if target owns a property with the given key.
- *
- * @param {Object} target
- * @param {String} key
- *
- * @return {Boolean}
- */
-function has(target, key) {
-  return !isNil$1(target) && nativeHasOwnProperty.call(target, key);
-}
-
 function isNil(e) {
     return e === null || e === undefined;
 }
@@ -16222,30 +16195,50 @@ 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).
+ * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups),
+ * `zeebe:priorityDefinition` (priority), and `zeebe:taskSchedule` (due/follow-up date).
  */
 class FormatActivity {
   /**
    * @param {import('bpmn-elements').Activity} activity
    * @param {any} assignmentDefinition
+   * @param {any} [priorityDefinition]
+   * @param {any} [taskSchedule]
    */
-  constructor(activity, assignmentDefinition) {
+  constructor(activity, assignmentDefinition, priorityDefinition, taskSchedule) {
     this.activity = activity;
     this.assignmentDefinition = assignmentDefinition;
+    this.priorityDefinition = priorityDefinition;
+    this.taskSchedule = taskSchedule;
   }
   /**
    * @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;
     if (documentation && !elementApi.content.description) {
       const text = documentation[0]?.text;
-      if (text) result.description = resolveValue(text, scope);
+      if (text) result.description = /** @type {string} */ (resolveValue(text, scope));
     }
 
     const assignment = this.assignmentDefinition;
@@ -16258,6 +16251,22 @@ class FormatActivity {
       if (groups) result.candidateGroups = groups;
     }
 
+    const priority = this.priorityDefinition?.priority;
+    if (priority !== undefined) {
+      const resolved = resolveValue(priority, scope);
+      // A static attribute value is a string — expose a numeric one as a number (like retries).
+      const num = Number(resolved);
+      /** @type {Number | string | undefined} */
+      result.priority = typeof resolved === 'string' && resolved.trim() !== '' && Number.isFinite(num) ? num : resolved;
+    }
+
+    const schedule = this.taskSchedule;
+    if (schedule) {
+      const { dueDate, followUpDate } = schedule;
+      if (dueDate !== undefined) result.dueDate = resolveDate(dueDate, scope);
+      if (followUpDate !== undefined) result.followUpDate = resolveDate(followUpDate, scope);
+    }
+
     return result;
   }
 }
@@ -16280,15 +16289,33 @@ class FormatProcess {
     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 = /** @type {string} */ (resolveValue(text, getFeelScope(elementApi.environment)));
     }
     return result;
   }
 }
 
+/**
+ * Resolve a due/follow-up date to an ISO 8601 string. A FEEL temporal result (a luxon
+ * DateTime) or a Date is ISO-stringified — content is JSON-serialized on `getState()`, so a
+ * string is the shape that survives a recover round trip. Anything else passes through as-is.
+ * @param {any} value
+ * @param {any} scope
+ * @returns {string | undefined} Date as iso string
+ */
+function resolveDate(value, scope) {
+  const resolved = resolveValue(value, scope);
+  if (typeof resolved?.toISO === 'function') return resolved.toISO();
+  if (resolved instanceof Date) return resolved.toISOString();
+  return resolved;
+}
+
 /**
  * Resolve a candidate users/groups value to a string array. A FEEL expression may yield an
  * array directly, otherwise a comma-separated string is split.
+ * @param {any} value
+ * @param {any} scope
+ * @returns {string[] | undefined}
  */
 function resolveList(value, scope) {
   if (!value) return undefined;
@@ -16329,7 +16356,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;
@@ -16343,7 +16370,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;
@@ -16399,7 +16426,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;
@@ -16495,7 +16522,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) }),
@@ -16528,7 +16555,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) {
@@ -16583,7 +16610,7 @@ JobService.prototype.execute = function execute(executionMessage, callback) {
 
   let jobType;
   try {
-    jobType = resolveValue(this.taskType, environment.variables);
+    jobType = resolveValue(this.taskType, getFeelScope(environment));
   } catch (err) {
     return callback(err);
   }
@@ -16618,7 +16645,7 @@ class Subscription {
   resolve(elementApi) {
     return {
       message: this.message,
-      correlationKey: resolveValue(this.correlationKey, elementApi.environment.variables),
+      correlationKey: resolveValue(this.correlationKey, getFeelScope(elementApi.environment)),
     };
   }
 }
@@ -16637,6 +16664,7 @@ class Subscription {
  * @property {any} [calledDecision]
  * @property {Function} [Service]
  * @property {Subscription} [subscription]
+ * @property {boolean} [isEmpty] no zeebe extension data found and nothing to format — the element needs no extension
  */
 
 /**
@@ -16649,10 +16677,15 @@ function getExtensions(element, context) {
   const result = {};
   const isProcess = element.type === 'bpmn:Process';
 
-  let assignmentDefinition;
+  let assignmentDefinition, priorityDefinition, taskSchedule;
+  let foundZeebe = false;
   const values = element.behaviour.extensionElements?.values;
   if (values) {
     for (const ext of values) {
+      // Any zeebe-namespaced extension element counts as found — including ones with no
+      // handler (e.g. the bare `zeebe:userTask` marker), which keep the element extension
+      // loaded so e.g. a native user task's completion payload is merged.
+      if (ext.$type.startsWith('zeebe:')) foundZeebe = true;
       switch (ext.$type) {
         case 'zeebe:IoMapping':
           result.io = new IoMapping(element, ext);
@@ -16666,6 +16699,12 @@ function getExtensions(element, context) {
         case 'zeebe:AssignmentDefinition':
           assignmentDefinition = ext;
           break;
+        case 'zeebe:PriorityDefinition':
+          priorityDefinition = ext;
+          break;
+        case 'zeebe:TaskSchedule':
+          taskSchedule = ext;
+          break;
         case 'zeebe:ExecutionListeners':
           if (ext.listeners?.length) result.listeners = new ExecutionListeners(element, ext);
           break;
@@ -16707,7 +16746,16 @@ function getExtensions(element, context) {
   );
   if (loopExtension?.outputCollection) result.loop = new LoopCharacteristics(loopExtension);
 
-  result.format = isProcess ? new FormatProcess(element) : new FormatActivity(element, assignmentDefinition);
+  // Nothing zeebe-flavoured and nothing to format — the element needs no extension. A call
+  // activity is never inert: its output unwrap/merge is type-driven (the standard BPMN
+  // `calledElement` attribute needs no zeebe elements). Ignored for processes — a called
+  // process always needs its inbound input promoted, whatever it carries itself.
+  result.isEmpty =
+    !foundZeebe && !result.subscription && !loopExtension && !element.behaviour.documentation && element.type !== 'bpmn:CallActivity';
+
+  result.format = isProcess
+    ? new FormatProcess(element)
+    : new FormatActivity(element, assignmentDefinition, priorityDefinition, taskSchedule);
 
   return result;
 }
@@ -16846,7 +16894,7 @@ class ElementExtensions {
 
     // 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 };
     }
@@ -17009,22 +17057,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) {
-  return { ...context?.environment?.variables, ...context?.content?.variables };
+  return evaluateFeel(templatedString, getFeelScope(context?.environment, context?.content?.variables));
 }
 
 /**
@@ -17049,12 +17089,12 @@ class FeelScriptRegistry {
   /**
    * @param {string} _scriptFormat
    * @param {{ id: string, [x: string]: any }} activity
-   * @returns {import('bpmn-elements').Script} the FEEL script, or undefined when the activity
-   *   has no `zeebe:script` — bpmn-elements handles that, but `IScripts` declares a bare `Script`
+   * @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 /** @type {any} */ (undefined);
+    if (expression === undefined) return undefined;
     return new FeelScript(expression);
   }
 }
@@ -17065,7 +17105,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);
@@ -17092,20 +17132,32 @@ function getScriptExpression(activity) {
 
 /**
  * Flow extensions factory. Pass it to the engine via the environment `extensions` option.
+ *
+ * Returns undefined for an element that carries no zeebe extension data and nothing else to
+ * format (no documentation, not a call activity) — bpmn-elements skips falsy extensions, so
+ * plain elements run untouched, with no broker subscriptions or format-queue traffic.
  * @param {import('bpmn-elements').Activity | import('bpmn-elements').Process} element
  * @param {import('bpmn-elements').ContextInstance} context
- * @returns {FlowExtension}
+ * @returns {FlowExtension | undefined}
  */
 function extensions(element, context) {
   switch (element.type) {
     case 'bpmn:Process':
+      // A process is always attached: a called process needs its inbound input promoted
+      // even when it carries no zeebe extension data of its own.
       return new ProcessExtensions(element, context);
     case 'bpmn:SubProcess':
     case 'bpmn:AdHocSubProcess':
-    case 'bpmn:Transaction':
-      return new SubProcessExtensions(element, context);
-    default:
-      return new ElementExtensions(element, context);
+    case 'bpmn:Transaction': {
+      const subProcessExtensions = new SubProcessExtensions(element, context);
+      if (subProcessExtensions.extensions.isEmpty) return undefined;
+      return subProcessExtensions;
+    }
+    default: {
+      const elementExtensions = new ElementExtensions(element, context);
+      if (elementExtensions.extensions.isEmpty) return undefined;
+      return elementExtensions;
+    }
   }
 }
 
@@ -17149,6 +17201,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.3",
+  "version": "0.0.5",
   "description": "Flow extensions for bpmn-elements: FEEL expressions and the zeebe-namespace BPMN extension elements",
   "type": "module",
   "module": "src/index.js",
@@ -69,7 +69,7 @@
     "@types/mocha": "^10.0.10",
     "@types/node": "^26.1.1",
     "bpmn-elements": "^18.0.12",
-    "bpmn-moddle": "^9.0.1",
+    "bpmn-moddle": "^10.1.0",
     "c8": "^12.0.0",
     "chai": "^6.2.2",
     "debug": "^4.4.3",

package/src/ElementExtensions.js

@@ -1,4 +1,5 @@
 import { getExtensions } from './getExtensions.js';
+import { getFeelScope } from './feel.js';
 
 const SUBPROCESS_TYPES = new Set(['bpmn:SubProcess', 'bpmn:AdHocSubProcess', 'bpmn:Transaction']);
 
@@ -134,7 +135,7 @@ export class ElementExtensions {
 
     // 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 };
     }

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.
@@ -27,20 +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) {
-  return { ...context?.environment?.variables, ...context?.content?.variables };
+  return evaluateFeel(templatedString, getFeelScope(context?.environment, context?.content?.variables));
 }

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.
@@ -22,12 +22,12 @@ class FeelScriptRegistry {
   /**
    * @param {string} _scriptFormat
    * @param {{ id: string, [x: string]: any }} activity
-   * @returns {import('bpmn-elements').Script} the FEEL script, or undefined when the activity
-   *   has no `zeebe:script` — bpmn-elements handles that, but `IScripts` declares a bare `Script`
+   * @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 /** @type {any} */ (undefined);
+    if (expression === undefined) return undefined;
     return new FeelScript(expression);
   }
 }
@@ -38,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

@@ -1,4 +1,4 @@
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * `zeebe:subscription` — rides on the referenced `bpmn:Message`, not on the catching element.
@@ -24,7 +24,7 @@ export class Subscription {
   resolve(elementApi) {
     return {
       message: this.message,
-      correlationKey: resolveValue(this.correlationKey, elementApi.environment.variables),
+      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`.
@@ -34,7 +34,7 @@ JobService.prototype.execute = function execute(executionMessage, callback) {
 
   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,29 +1,34 @@
-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).
+ * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups),
+ * `zeebe:priorityDefinition` (priority), and `zeebe:taskSchedule` (due/follow-up date).
  */
 export class FormatActivity {
   /**
    * @param {import('bpmn-elements').Activity} activity
    * @param {any} assignmentDefinition
+   * @param {any} [priorityDefinition]
+   * @param {any} [taskSchedule]
    */
-  constructor(activity, assignmentDefinition) {
+  constructor(activity, assignmentDefinition, priorityDefinition, taskSchedule) {
     this.activity = activity;
     this.assignmentDefinition = assignmentDefinition;
+    this.priorityDefinition = priorityDefinition;
+    this.taskSchedule = taskSchedule;
   }
   /**
    * @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;
     if (documentation && !elementApi.content.description) {
       const text = documentation[0]?.text;
-      if (text) result.description = resolveValue(text, scope);
+      if (text) result.description = /** @type {string} */ (resolveValue(text, scope));
     }
 
     const assignment = this.assignmentDefinition;
@@ -36,6 +41,22 @@ export class FormatActivity {
       if (groups) result.candidateGroups = groups;
     }
 
+    const priority = this.priorityDefinition?.priority;
+    if (priority !== undefined) {
+      const resolved = resolveValue(priority, scope);
+      // A static attribute value is a string — expose a numeric one as a number (like retries).
+      const num = Number(resolved);
+      /** @type {Number | string | undefined} */
+      result.priority = typeof resolved === 'string' && resolved.trim() !== '' && Number.isFinite(num) ? num : resolved;
+    }
+
+    const schedule = this.taskSchedule;
+    if (schedule) {
+      const { dueDate, followUpDate } = schedule;
+      if (dueDate !== undefined) result.dueDate = resolveDate(dueDate, scope);
+      if (followUpDate !== undefined) result.followUpDate = resolveDate(followUpDate, scope);
+    }
+
     return result;
   }
 }
@@ -58,15 +79,33 @@ export class FormatProcess {
     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 = /** @type {string} */ (resolveValue(text, getFeelScope(elementApi.environment)));
     }
     return result;
   }
 }
 
+/**
+ * Resolve a due/follow-up date to an ISO 8601 string. A FEEL temporal result (a luxon
+ * DateTime) or a Date is ISO-stringified — content is JSON-serialized on `getState()`, so a
+ * string is the shape that survives a recover round trip. Anything else passes through as-is.
+ * @param {any} value
+ * @param {any} scope
+ * @returns {string | undefined} Date as iso string
+ */
+function resolveDate(value, scope) {
+  const resolved = resolveValue(value, scope);
+  if (typeof resolved?.toISO === 'function') return resolved.toISO();
+  if (resolved instanceof Date) return resolved.toISOString();
+  return resolved;
+}
+
 /**
  * Resolve a candidate users/groups value to a string array. A FEEL expression may yield an
  * array directly, otherwise a comma-separated string is split.
+ * @param {any} value
+ * @param {any} scope
+ * @returns {string[] | undefined}
  */
 function resolveList(value, scope) {
   if (!value) return undefined;

package/src/feel.js

@@ -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

@@ -22,6 +22,7 @@ import { Subscription } from './extensions/Subscription.js';
  * @property {any} [calledDecision]
  * @property {Function} [Service]
  * @property {Subscription} [subscription]
+ * @property {boolean} [isEmpty] no zeebe extension data found and nothing to format — the element needs no extension
  */
 
 /**
@@ -34,10 +35,15 @@ export function getExtensions(element, context) {
   const result = {};
   const isProcess = element.type === 'bpmn:Process';
 
-  let assignmentDefinition;
+  let assignmentDefinition, priorityDefinition, taskSchedule;
+  let foundZeebe = false;
   const values = element.behaviour.extensionElements?.values;
   if (values) {
     for (const ext of values) {
+      // Any zeebe-namespaced extension element counts as found — including ones with no
+      // handler (e.g. the bare `zeebe:userTask` marker), which keep the element extension
+      // loaded so e.g. a native user task's completion payload is merged.
+      if (ext.$type.startsWith('zeebe:')) foundZeebe = true;
       switch (ext.$type) {
         case 'zeebe:IoMapping':
           result.io = new IoMapping(element, ext);
@@ -51,6 +57,12 @@ export function getExtensions(element, context) {
         case 'zeebe:AssignmentDefinition':
           assignmentDefinition = ext;
           break;
+        case 'zeebe:PriorityDefinition':
+          priorityDefinition = ext;
+          break;
+        case 'zeebe:TaskSchedule':
+          taskSchedule = ext;
+          break;
         case 'zeebe:ExecutionListeners':
           if (ext.listeners?.length) result.listeners = new ExecutionListeners(element, ext);
           break;
@@ -92,7 +104,16 @@ export function getExtensions(element, context) {
   );
   if (loopExtension?.outputCollection) result.loop = new LoopCharacteristics(loopExtension);
 
-  result.format = isProcess ? new FormatProcess(element) : new FormatActivity(element, assignmentDefinition);
+  // Nothing zeebe-flavoured and nothing to format — the element needs no extension. A call
+  // activity is never inert: its output unwrap/merge is type-driven (the standard BPMN
+  // `calledElement` attribute needs no zeebe elements). Ignored for processes — a called
+  // process always needs its inbound input promoted, whatever it carries itself.
+  result.isEmpty =
+    !foundZeebe && !result.subscription && !loopExtension && !element.behaviour.documentation && element.type !== 'bpmn:CallActivity';
+
+  result.format = isProcess
+    ? new FormatProcess(element)
+    : new FormatActivity(element, assignmentDefinition, priorityDefinition, taskSchedule);
 
   return result;
 }

package/src/index.js

@@ -5,7 +5,7 @@ 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';
 
@@ -18,20 +18,32 @@ export { ServiceError, FormatError } from './Errors.js';
 
 /**
  * Flow extensions factory. Pass it to the engine via the environment `extensions` option.
+ *
+ * Returns undefined for an element that carries no zeebe extension data and nothing else to
+ * format (no documentation, not a call activity) — bpmn-elements skips falsy extensions, so
+ * plain elements run untouched, with no broker subscriptions or format-queue traffic.
  * @param {import('bpmn-elements').Activity | import('bpmn-elements').Process} element
  * @param {import('bpmn-elements').ContextInstance} context
- * @returns {FlowExtension}
+ * @returns {FlowExtension | undefined}
  */
 export function extensions(element, context) {
   switch (element.type) {
     case 'bpmn:Process':
+      // A process is always attached: a called process needs its inbound input promoted
+      // even when it carries no zeebe extension data of its own.
       return new ProcessExtensions(element, context);
     case 'bpmn:SubProcess':
     case 'bpmn:AdHocSubProcess':
-    case 'bpmn:Transaction':
-      return new SubProcessExtensions(element, context);
-    default:
-      return new ElementExtensions(element, context);
+    case 'bpmn:Transaction': {
+      const subProcessExtensions = new SubProcessExtensions(element, context);
+      if (subProcessExtensions.extensions.isEmpty) return undefined;
+      return subProcessExtensions;
+    }
+    default: {
+      const elementExtensions = new ElementExtensions(element, context);
+      if (elementExtensions.extensions.isEmpty) return undefined;
+      return elementExtensions;
+    }
   }
 }
 

package/types/index.d.ts

@@ -4,8 +4,12 @@ declare module '@0dep/bpmn-extensions' {
 	 * */
 	/**
 	 * Flow extensions factory. Pass it to the engine via the environment `extensions` option.
+	 *
+	 * Returns undefined for an element that carries no zeebe extension data and nothing else to
+	 * format (no documentation, not a call activity) — bpmn-elements skips falsy extensions, so
+	 * plain elements run untouched, with no broker subscriptions or format-queue traffic.
 	 * */
-	export function extensions(element: import("bpmn-elements").Activity | import("bpmn-elements").Process, context: import("bpmn-elements").ContextInstance): FlowExtension;
+	export function extensions(element: import("bpmn-elements").Activity | import("bpmn-elements").Process, context: import("bpmn-elements").ContextInstance): FlowExtension | undefined;
 	/**
 	 * Behaviour extend function for moddle-context-serializer.
 	 *
@@ -171,6 +175,16 @@ declare module '@0dep/bpmn-extensions' {
 	 * @param context Variables in scope for FEEL evaluation
 	 * */
 	export function resolveValue(value: any, context?: Record<string, any>): any;
+	/**
+	 * 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 localVariables scope-local overlay
+	 * */
+	export function getFeelScope(environment?: import("bpmn-elements").Environment, localVariables?: Record<string, any>): Record<string, any>;
 	export class ServiceError extends Error {
 		constructor(jobType: any);
 		code: string;
@@ -200,22 +214,33 @@ declare module '@0dep/bpmn-extensions' {
 		calledDecision?: any;
 		Service?: Function | undefined;
 		subscription?: Subscription | undefined;
+		/**
+		 * no zeebe extension data found and nothing to format — the element needs no extension
+		 */
+		isEmpty?: boolean | undefined;
 	};
 	/**
 	 * Format an activity on enter from its behaviour and extensions: documentation and,
-	 * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups).
+	 * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups),
+	 * `zeebe:priorityDefinition` (priority), and `zeebe:taskSchedule` (due/follow-up date).
 	 */
 	class FormatActivity {
 		
-		constructor(activity: import("bpmn-elements").Activity, assignmentDefinition: any);
+		constructor(activity: import("bpmn-elements").Activity, assignmentDefinition: any, priorityDefinition?: any, taskSchedule?: any);
 		activity: import("bpmn-elements").Activity;
 		assignmentDefinition: any;
+		priorityDefinition: any;
+		taskSchedule: any;
 		
 		resolve(elementApi: import("bpmn-elements").IApi<import("bpmn-elements").Activity>): {
-			description: any;
+			description: string;
 			assignee: any;
-			candidateUsers: any[];
-			candidateGroups: any[];
+			candidateUsers: string[];
+			candidateGroups: string[];
+			
+			priority: number | string | undefined;
+			dueDate: string | undefined;
+			followUpDate: string | undefined;
 		};
 	}
 	/**
@@ -227,7 +252,7 @@ declare module '@0dep/bpmn-extensions' {
 		process: import("bpmn-elements").Process;
 		
 		resolve(elementApi: import("bpmn-elements").IApi<import("bpmn-elements").Process>): {
-			description: any;
+			description: string;
 		};
 	}
 	/**
@@ -338,7 +363,7 @@ declare module '@0dep/bpmn-extensions' {
 		get hasOutputCollection(): boolean;
 		/**
 		 * @param indexedOutput bpmn-elements index-keyed instance outputs
-		 * @param baseScope process variables in scope for `outputElement`
+		 * @param baseScope base scope for `outputElement` (services + process variables)
 		 * */
 		aggregate(indexedOutput: Record<string, any> | undefined, baseScope: Record<string, any>): any[];
 	}

package/types/index.d.ts.map

@@ -15,6 +15,7 @@
 		"evaluateFeel",
 		"evaluateFeelUnaryTest",
 		"resolveValue",
+		"getFeelScope",
 		"ServiceError",
 		"FormatError",
 		"FormatActivity",
@@ -65,6 +66,6 @@
 		null,
 		null
 	],
-	"mappings": ";;;;;;;iBAwBgBA,UAAUA;;;;;;;;iBAqBVC,QAAQA;;;;;;;;;;;;;;;;iBClCRC,eAAeA;;;;;;;;;;;;;;iBCEfC,WAAWA;;;;;;;;;;;;;;;iBCIXC,UAAUA;cAAVA,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCCbC,iBAAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCXjBC,iBAAiBA;;;;;;;;;;;;;;;;;;;cCIjBC,oBAAoBA;;;;;;;iBCEjBC,gBAAgBA;;;;iBAShBC,SAASA;;;;;;iBAUTC,YAAYA;;;;;;;;iBAYZC,qBAAqBA;;;;;;iBAYrBC,YAAYA;cCxDfC,YAAYA;;;;;;;cAQZC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;OCFXC,cAAcA;;;;;;;;;;;;;;;;OAuCdC,aAAaA;;;;;;;;;;;;;;;;;;;;OChCbC,SAASA;;;;;;;;;;;;;;;;;;;;;;;OCPTC,WAAWA;;;;;;;;;;;OCEXC,UAAUA;;;;;;;;;;;;;;;OCIVC,kBAAkBA;;;;;;;;;;;;;;;;;;;OCFlBC,IAAIA;;;;;;;;;;;;;;;;;;;;;;OCGJC,mBAAmBA;;;;;;;;;;;;;;;;;;;OCHnBC,YAAYA",
+	"mappings": ";;;;;;;;;;;iBA4BgBA,UAAUA;;;;;;;;iBA6BVC,QAAQA;;;;;;;;;;;;;;;;iBC9CRC,eAAeA;;;;;;;;;;;;;;iBCEfC,WAAWA;;;;;;;;;;;;;;;iBCIXC,UAAUA;cAAVA,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCEbC,iBAAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCZjBC,iBAAiBA;;;;;;;;;;;;;;;;;;;cCIjBC,oBAAoBA;;;;;;;iBCEjBC,gBAAgBA;;;;iBAShBC,SAASA;;;;;;iBAUTC,YAAYA;;;;;;;;iBAYZC,qBAAqBA;;;;;;iBAYrBC,YAAYA;;;;;;;;;;iBAgBZC,YAAYA;cCxEfC,YAAYA;;;;;;;cAQZC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OCDXC,cAAcA;;;;;;;;;;;;;;;;;;;;;;OA2DdC,aAAaA;;;;;;;;;;;;;;;;;;;;OCrDbC,SAASA;;;;;;;;;;;;;;;;;;;;;;;OCPTC,WAAWA;;;;;;;;;;;OCEXC,UAAUA;;;;;;;;;;;;;;;OCIVC,kBAAkBA;;;;;;;;;;;;;;;;;;;OCFlBC,IAAIA;;;;;;;;;;;;;;;;;;;;;;OCGJC,mBAAmBA;;;;;;;;;;;;;;;;;;;OCHnBC,YAAYA",
 	"ignoreList": []
 }