@uipath/maestro-builder-sdk 6.35.1 → 6.36.1

package/dist/bpmn/bpmn-sdk.d.ts

@@ -2454,6 +2454,17 @@ declare abstract class ScopeBuilder {
      * is left alone.
      */
     private bindRequiredContext;
+    /**
+     * A binding field's resource key from its `resourceKeyPattern`, with the declared
+     * bindings the key was read through — or `undefined` when the pattern does not
+     * resolve from this context (see `resolveResourceKeyPattern`), in which case the
+     * caller keys the binding by the value, as it always has.
+     *
+     * @throws when the pattern resolves except for a `=bindings.<b>` reference that no
+     * `.binding()` before this node declares with a value: that key would otherwise be
+     * built, so the author is told what to declare rather than given a wrong pair.
+     */
+    private resourceKeyFromPattern;
     /** @internal Shared body of the Orchestrator process-invocation methods. */
     private orchestratorNode;
     /**
@@ -2530,12 +2541,23 @@ declare abstract class ScopeBuilder {
      *
      * @remarks
      * **Not a DMN decision table**, despite the element and the label. The registry spec
-     * is an Orchestrator process invocation — `releaseKey`/`folderId`/`folderPath`/`name`
-     * plus `JobArguments`, `BindingPattern: businessRule` over `Resource: process` —
-     * structurally identical to {@link ScopeBuilder.startProcess}. `process` names a
-     * package whose Orchestrator process type is `BusinessRules`; whatever decision logic
-     * exists lives INSIDE that package, not in the `.bpmn`. So this is the job-start
-     * family's sixth member, not a rules subsystem, and it shares every option with it.
+     * is an Orchestrator process invocation — `name`/`folderPath` plus `JobArguments` —
+     * structurally a {@link ScopeBuilder.startProcess}. `process` names a package whose
+     * Orchestrator process type is `BusinessRules`; whatever decision logic exists lives
+     * INSIDE that package, not in the `.bpmn`. So this is the job-start family's sixth
+     * member, not a rules subsystem.
+     *
+     * Where it departs from the family, the registry says so and this follows it:
+     *
+     *  - the task is `version="v3"` — below v3 the engine cannot run the `.uirule`
+     *    package a BusinessRules project deploys — so a rule is always addressed by
+     *    name, and `releaseKey` / `folderKey` are refused;
+     *  - `name` and `folderPath` are each bound to a `BusinessRule` resource
+     *    (`propertyAttribute` `name` / `folderPath`), both keyed `<folder>.<name>`
+     *    (`<name>` alone when the folder is empty), declared on your behalf as
+     *    `<id>_name` / `<id>_folderPath`; an unbound `_label` carries the rule's name;
+     *  - two output rows: `output` (`=result`, in `outputVar`) and `Error` (`=Error`,
+     *    in `<id>_Error`), both `jsonSchema`.
      *
      * Distinct from the Case SDK's `rule()`, which declares DNF lifecycle conditions
      * (`case-entered`, `required-tasks-completed`, …) deciding when a stage enters or
@@ -2555,7 +2577,7 @@ declare abstract class ScopeBuilder {
      *     process: 'DiscountTier',
      *     folder: 'Finance',
      *     input: { amount: 4200 },
-     *     outputs: { tier: '=response.tier' },
+     *     outputs: { tier: '=result.DiscountTier.tier' },
      *   })
      *   .endEvent('done')
      *   .sequenceFlow('start', 'tier')
@@ -2564,9 +2586,16 @@ declare abstract class ScopeBuilder {
      * ```
      *
      * @param id - The element id, unique in the process and used by `sequenceFlow`.
+     *
+     * **The result is keyed by decision name.** The platform's `output` row is the whole
+     * result (`source="=result"`) and a decision's column reads as
+     * `=result.<Decision>.<column>` — `vars.<id>_businessRuleResponse.<Decision>.<column>`
+     * downstream — never `=result.<column>` (canvas spec `outputNotes`; `uip rules describe
+     * <name>` lists the decisions and columns, and only a decision-keyed rule, one whose
+     * `OutputArguments` carry `x-uipath-decision-keyed`, fits this row).
      * @param opts - Which rule package, folder, and input arguments. `outputVar` defaults
-     * to `<id>_businessRuleResponse` — see the note in the implementation for why this one
-     * type does not take its default from the spec.
+     * to `<id>_businessRuleResponse`. `releaseKey` and `folderKey` are refused: a v3 rule
+     * is addressed by name.
      * @param body - Boundary events attached to this activity, declared on the {@link ActivityBuilder} it receives.
      * @returns This builder, so calls chain.
      */

package/dist/bpmn/bpmn-sdk.js

@@ -3,6 +3,7 @@ import { checkBpmnExpressions, BpmnBuildError } from './bpmn-expr-check.js';
 import { BPMN_SCHEMA_VERSIONS } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
 import { bindingRequiredFields, REGISTRY_GAPS, registryType } from './typed-node.js';
+import { resolveResourceKeyPattern } from './resource-key-pattern.js';
 import { DATA_SERVICE_ACTIVITY_TYPE, DATA_SERVICE_CONNECTOR_KEY, dataServiceWire } from './data-service.js';
 import { ownEntry } from '../core/own-entry.js';
 export { BpmnBuildError } from './bpmn-expr-check.js';
@@ -1213,22 +1214,75 @@ class ScopeBuilder {
             if (typeof value !== 'string' || value.startsWith('='))
                 continue;
             const bindingId = `${id}_${field.name}`;
+            // The key a pattern builds from the context values — a `=bindings.<b>` value as
+            // the DECLARED value of `b`, since a key is never evaluated as an expression.
+            // Resolved only for the fields the pattern names, and refused only when the
+            // pattern would otherwise resolve: a pattern that names nothing the context has
+            // (`${metadata.key}`, the live registry's pattern on a job start, whose context
+            // has no `key`) leaves the key to the value, as before. This snapshot carries no
+            // pattern for the job starts at all; `resource-key-pattern.ts` is tested on both.
+            const keyed = this.resourceKeyFromPattern(id, type, field, context);
             this._bindingRegistry.declare({
                 id: bindingId,
                 name: field.displayName ?? field.name,
                 resource: field.bindingInfo?.resource ?? 'process',
                 propertyAttribute: field.bindingInfo?.propertyAttribute ?? field.name,
-                // A fact the registry omits and the validator enforces — see REGISTRY_GAPS.
                 resourceSubType: ownEntry(REGISTRY_GAPS, type)?.resourceSubType,
                 default: value,
-                resourceKey: value,
+                resourceKey: keyed?.key ?? value,
             });
+            // A declared binding the key was read from shares it when the author left its own
+            // key unset, so the pair names one resource — only when the pattern resolved. One
+            // that already carries a DIFFERENT key (a folder binding two rules share, or an
+            // author's own key) would make this node's pair name two resources: refused, with
+            // the binding to declare instead.
+            if (keyed) {
+                for (const decl of keyed.referenced) {
+                    if (decl.resourceKey === undefined)
+                        decl.resourceKey = keyed.key;
+                    else if (decl.resourceKey !== keyed.key) {
+                        const resource = field.bindingInfo?.resource ?? 'process';
+                        throw new Error(`${type} "${id}": its ${resource} key "${keyed.key}" is read through =bindings.${decl.id}, whose resource key is already ` +
+                            `"${decl.resourceKey}" (another node's pair, or the binding's own), so the pair would name two resources. ` +
+                            `A ${resource} binding names one: declare one per node, e.g. ` +
+                            `\`.binding('${decl.id}_${id}', { resource: '${decl.resource}', propertyAttribute: '${decl.propertyAttribute}', value: '${decl.default}' })\`.`);
+                    }
+                }
+            }
             out[field.name] = `=bindings.${bindingId}`;
         }
         return out;
     }
+    /**
+     * A binding field's resource key from its `resourceKeyPattern`, with the declared
+     * bindings the key was read through — or `undefined` when the pattern does not
+     * resolve from this context (see `resolveResourceKeyPattern`), in which case the
+     * caller keys the binding by the value, as it always has.
+     *
+     * @throws when the pattern resolves except for a `=bindings.<b>` reference that no
+     * `.binding()` before this node declares with a value: that key would otherwise be
+     * built, so the author is told what to declare rather than given a wrong pair.
+     */
+    resourceKeyFromPattern(id, type, field, context) {
+        const pattern = field.bindingInfo?.resourceKeyPattern;
+        const byId = (bindingId) => this._bindingRegistry.bindings.find((b) => b.id === bindingId);
+        const resolved = resolveResourceKeyPattern(pattern, context, byId);
+        if (resolved === undefined)
+            return undefined;
+        if ('blocked' in resolved) {
+            const { field: blockedField, ref } = resolved.blocked;
+            const refId = ref.slice('=bindings.'.length);
+            const resource = field.bindingInfo?.resource ?? 'process';
+            throw new Error(`${type} "${id}": ${blockedField} reads ${ref}, which no .binding() declares with a value before this node, ` +
+                `so the ${resource} key \`${pattern}\` it is paired under cannot be built. Declare ` +
+                `\`.binding('${refId}', { resource: '${resource}', propertyAttribute: '${blockedField}', value: '…' })\` first, or pass the value itself.`);
+        }
+        return { key: resolved.key, referenced: resolved.referenced.map((bid) => byId(bid)).filter((d) => d !== undefined) };
+    }
     /** @internal Shared body of the Orchestrator process-invocation methods. */
-    orchestratorNode(id, type, opts, body) {
+    orchestratorNode(id, type, opts, body, 
+    /** A member's own departures from the family: the business rule's v3 stamp and `_label`. */
+    own = {}) {
         // The `uipath:type` version selects the engine's addressing branch — see
         // OrchestratorOpts.process. By name → v2 (`name` + `folderPath`); by key → v1
         // (`releaseKey` + `folderKey`). A literal release key becomes a `process`/`Key`
@@ -1254,12 +1308,13 @@ class ScopeBuilder {
             id,
             name: opts.name,
             type,
-            typeVersion: byKey ? 'v1' : 'v2',
+            typeVersion: own.typeVersion ?? (byKey ? 'v1' : 'v2'),
             context: this.bindRequiredContext(id, type, {
                 name: opts.process,
                 ...(opts.folder !== undefined ? { folderPath: opts.folder } : {}),
                 ...(releaseKey !== undefined ? { releaseKey } : {}),
                 ...(byKey && opts.folderKey !== undefined ? { folderKey: opts.folderKey } : {}),
+                ...(own.context ?? {}),
             }),
             inputs: opts.input ?? {},
             outputs: opts.outputs,
@@ -1355,12 +1410,23 @@ class ScopeBuilder {
      *
      * @remarks
      * **Not a DMN decision table**, despite the element and the label. The registry spec
-     * is an Orchestrator process invocation — `releaseKey`/`folderId`/`folderPath`/`name`
-     * plus `JobArguments`, `BindingPattern: businessRule` over `Resource: process` —
-     * structurally identical to {@link ScopeBuilder.startProcess}. `process` names a
-     * package whose Orchestrator process type is `BusinessRules`; whatever decision logic
-     * exists lives INSIDE that package, not in the `.bpmn`. So this is the job-start
-     * family's sixth member, not a rules subsystem, and it shares every option with it.
+     * is an Orchestrator process invocation — `name`/`folderPath` plus `JobArguments` —
+     * structurally a {@link ScopeBuilder.startProcess}. `process` names a package whose
+     * Orchestrator process type is `BusinessRules`; whatever decision logic exists lives
+     * INSIDE that package, not in the `.bpmn`. So this is the job-start family's sixth
+     * member, not a rules subsystem.
+     *
+     * Where it departs from the family, the registry says so and this follows it:
+     *
+     *  - the task is `version="v3"` — below v3 the engine cannot run the `.uirule`
+     *    package a BusinessRules project deploys — so a rule is always addressed by
+     *    name, and `releaseKey` / `folderKey` are refused;
+     *  - `name` and `folderPath` are each bound to a `BusinessRule` resource
+     *    (`propertyAttribute` `name` / `folderPath`), both keyed `<folder>.<name>`
+     *    (`<name>` alone when the folder is empty), declared on your behalf as
+     *    `<id>_name` / `<id>_folderPath`; an unbound `_label` carries the rule's name;
+     *  - two output rows: `output` (`=result`, in `outputVar`) and `Error` (`=Error`,
+     *    in `<id>_Error`), both `jsonSchema`.
      *
      * Distinct from the Case SDK's `rule()`, which declares DNF lifecycle conditions
      * (`case-entered`, `required-tasks-completed`, …) deciding when a stage enters or
@@ -1380,7 +1446,7 @@ class ScopeBuilder {
      *     process: 'DiscountTier',
      *     folder: 'Finance',
      *     input: { amount: 4200 },
-     *     outputs: { tier: '=response.tier' },
+     *     outputs: { tier: '=result.DiscountTier.tier' },
      *   })
      *   .endEvent('done')
      *   .sequenceFlow('start', 'tier')
@@ -1389,28 +1455,38 @@ class ScopeBuilder {
      * ```
      *
      * @param id - The element id, unique in the process and used by `sequenceFlow`.
+     *
+     * **The result is keyed by decision name.** The platform's `output` row is the whole
+     * result (`source="=result"`) and a decision's column reads as
+     * `=result.<Decision>.<column>` — `vars.<id>_businessRuleResponse.<Decision>.<column>`
+     * downstream — never `=result.<column>` (canvas spec `outputNotes`; `uip rules describe
+     * <name>` lists the decisions and columns, and only a decision-keyed rule, one whose
+     * `OutputArguments` carry `x-uipath-decision-keyed`, fits this row).
      * @param opts - Which rule package, folder, and input arguments. `outputVar` defaults
-     * to `<id>_businessRuleResponse` — see the note in the implementation for why this one
-     * type does not take its default from the spec.
+     * to `<id>_businessRuleResponse`. `releaseKey` and `folderKey` are refused: a v3 rule
+     * is addressed by name.
      * @param body - Boundary events attached to this activity, declared on the {@link ActivityBuilder} it receives.
      * @returns This builder, so calls chain.
      */
     businessRule(id, opts, body) {
-        // The ONE place this type departs from its family, and deliberately.
-        //
-        // Every other member takes its default output variable from the registry's
-        // `OutputName` (`Process response` → `<id>_processResponse`). This type's
-        // `OutputName` is literally its designer LABEL, `Execute business rule [Preview]`,
-        // so the derived default would be `<id>_executeBusinessRulePreview`: unreadable,
-        // and — worse — it encodes the preview marker in a name authors write expressions
-        // against. When `[Preview]` drops the label becomes `Execute business rule`, the
-        // derived default silently becomes `<id>_executeBusinessRule`, and every
-        // `vars.<id>_executeBusinessRulePreview` reference in every authored process starts
-        // resolving to undefined — a silent wrong-answer change from a cosmetic spec edit.
-        //
-        // Pinning it here makes the default independent of the label. The output ROW still
-        // carries the registry's own `name`, so the artifact is unchanged.
-        return this.orchestratorNode(id, 'Orchestrator.BusinessRules', { ...opts, outputVar: opts.outputVar ?? `${id}_businessRuleResponse` }, body);
+        if (opts.releaseKey !== undefined || opts.folderKey !== undefined) {
+            throw new Error(`businessRule('${id}'): a business rule is addressed by name and folder (version v3 binds the ` +
+                'BusinessRule resource by `name` + `folderPath`); drop `releaseKey` / `folderKey`.');
+        }
+        // The default output variable is pinned rather than derived. Derived, it would come
+        // from the registry's `OutputName`, which was once the designer LABEL, `Execute
+        // business rule [Preview]` — a `[Preview]` marker in a name authors write expressions
+        // against, and one that changed when the marker dropped. Pinning keeps every
+        // `vars.<id>_businessRuleResponse` reference valid across that kind of spec edit.
+        return this.orchestratorNode(id, 'Orchestrator.BusinessRules', 
+        // `folderPath` is a REQUIRED binding of the type: a rule in the running job's own
+        // folder is bound with an empty path, so the pair is keyed by the name alone
+        // (`uip maestro bpmn validate` accepts it); leaving the field out instead drew
+        // BINDING_REQUIRED and EMPTY_REQUIRED_FIELD from `check`.
+        { ...opts, folder: opts.folder ?? '', outputVar: opts.outputVar ?? `${id}_businessRuleResponse` }, body, 
+        // `_label` is the one unbound context field: the rule's name, which the canvas
+        // shows while `name` itself is a binding reference.
+        { typeVersion: 'v3', context: { _label: opts.process } });
     }
     /**
      * Add an item to an Orchestrator **queue** (`Orchestrator.CreateQueueItem`, or

package/dist/bpmn/declared-vars.js

@@ -1,4 +1,4 @@
-import { typedNodeOutputVar } from './typed-node.js';
+import { typedNodeAdditionalOutputVars, typedNodeOutputVar } from './typed-node.js';
 /**
  * The variables a connector task's output rows land in.
  *
@@ -38,7 +38,7 @@ export function typedNodeDeclaredVars(n) {
     if (n.outputRows)
         return n.outputRows.map((r) => r.var).filter((v) => v !== undefined);
     const v = typedNodeOutputVar(n.id, n.type, n.outputVar, n.spec);
-    return [...(v ? [v] : []), ...Object.keys(n.outputs ?? {})];
+    return [...(v ? [v] : []), ...typedNodeAdditionalOutputVars(n.id, n.type, n.spec), ...Object.keys(n.outputs ?? {})];
 }
 /**
  * Every variable name a node DECLARES by writing to it — the platform counts a

package/dist/bpmn/decompile.js

@@ -419,18 +419,32 @@ function outputsOf(payload, _id, type) {
     const rows = payload?.output ?? [];
     const extras = {};
     let outputVar;
-    const specName = type ? registryType(type).output?.name : undefined;
+    const spec = type ? registryType(type) : undefined;
+    const specName = spec?.output?.name;
+    // A row the registry declares beside the main one (a business rule's `Error`) is
+    // re-emitted by the builder, so lifting it as an extra would write it twice on the
+    // way back. Matched by NAME (and source): an export that binds it to a variable
+    // other than the derived `<id>_<name>` is spelled out verbatim instead
+    // (`outputRowsNeedSpellingOut`), which carries that variable through exactly.
+    const declaredBeside = new Map((spec?.additionalOutputs ?? []).map((o) => [o.name, o.source ?? undefined]));
     for (const row of rows) {
         if (specName !== undefined && row.name === specName) {
             // Only worth emitting when it differs from the default the builder derives.
             outputVar = row.var;
             continue;
         }
+        if (declaredBeside.has(row.name) && (declaredBeside.get(row.name) === undefined || declaredBeside.get(row.name) === row.source))
+            continue;
         if (row.source !== undefined)
             extras[row.var ?? row.name] = row.source;
     }
     return { outputVar, extras };
 }
+/** The variable the builder derives for each row the registry declares beside the main one. */
+function derivedExtraVars(id, type) {
+    const spec = type ? registryType(type) : undefined;
+    return new Map((spec?.additionalOutputs ?? []).map((o) => [o.name, `${id}_${o.name}`]));
+}
 /**
  * Whether these rows can be reproduced by the compact `outputVar` + `outputs` pair,
  * or need spelling out.
@@ -445,10 +459,16 @@ function outputsOf(payload, _id, type) {
  * form stays in use wherever it is exact, so the 30 other extension types decompile
  * to exactly the source they did before, and only a row that genuinely needs the
  * long form gets it.
+ *
+ * A row the registry declares beside the main one (`derivedBeside`: a business rule's
+ * `Error`) that an export binds to a variable other than the derived `<id>_<name>`
+ * needs it too: the compact form cannot rename that row, and lifting it as an extra
+ * would have the builder add its own beside it.
  */
-function outputRowsNeedSpellingOut(payload) {
+function outputRowsNeedSpellingOut(payload, derivedBeside = new Map()) {
     const rows = payload?.output ?? [];
-    return rows.some((row) => row.body !== undefined ||
+    return rows.some((row) => (derivedBeside.has(row.name) && row.var !== undefined && row.var !== derivedBeside.get(row.name)) ||
+        row.body !== undefined ||
         row.custom !== undefined ||
         row.description !== undefined ||
         row.target !== undefined ||
@@ -522,7 +542,7 @@ function emitTypedNode(chain, el, payload, type) {
     const verbatimContext = contextRowsNeedSpellingOut(payload, type) ? emitContextRows(payload) : undefined;
     const { outputVar, extras } = outputsOf(payload, id, type);
     const defaultVar = spec.output ? `${id}_${identifierize(spec.output.name)}` : undefined;
-    const verbatimRows = outputRowsNeedSpellingOut(payload) ? emitOutputRows(payload) : undefined;
+    const verbatimRows = outputRowsNeedSpellingOut(payload, derivedExtraVars(id, type)) ? emitOutputRows(payload) : undefined;
     chain.add(`.activity(${tsText(id)}, ${tsText(type)}${optionalArg(opts([
         ['name', el.name !== undefined ? tsText(el.name) : undefined],
         // Only when it differs from the registry's own template, so an

package/dist/bpmn/registry-types.json

@@ -7,7 +7,10 @@
   ],
   "provenance": {
     "typeCount": 30,
-    "uipVersion": "1.203.0-preview.180"
+    "uipVersion": "1.203.0-preview.180",
+    "refreshed": {
+      "Orchestrator.BusinessRules": "1.205.0-preview.256"
+    }
   },
   "types": {
     "A2A.AgentExecution": {
@@ -1277,40 +1280,35 @@
       "inputTarget": "bodyField",
       "context": [
         {
-          "name": "releaseKey",
-          "displayName": "Process",
+          "name": "name",
+          "displayName": "Business rule",
           "type": "string",
-          "required": false,
+          "required": true,
           "hidden": true,
-          "binding": false,
+          "binding": true,
           "default": null,
           "bindingInfo": {
-            "resource": "process",
-            "propertyAttribute": "Key"
+            "resource": "BusinessRule",
+            "propertyAttribute": "name",
+            "resourceKeyPattern": "${metadata.folderPath}.${metadata.name}"
           }
         },
-        {
-          "name": "folderId",
-          "displayName": null,
-          "type": "string",
-          "required": false,
-          "hidden": true,
-          "binding": false,
-          "default": null,
-          "bindingInfo": null
-        },
         {
           "name": "folderPath",
           "displayName": null,
           "type": "string",
-          "required": false,
+          "required": true,
           "hidden": true,
-          "binding": false,
+          "binding": true,
           "default": null,
-          "bindingInfo": null
+          "bindingInfo": {
+            "resource": "BusinessRule",
+            "propertyAttribute": "folderPath",
+            "resourceKeyPattern": "${metadata.folderPath}.${metadata.name}"
+          }
         },
         {
-          "name": "name",
+          "name": "_label",
           "displayName": null,
           "type": "string",
           "required": false,
@@ -1322,11 +1320,19 @@
       ],
       "inputs": [],
       "output": {
-        "name": "Execute business rule [Preview]",
-        "type": "Orchestrator.BusinessRules",
-        "source": null,
+        "name": "output",
+        "type": "jsonSchema",
+        "source": "=result",
         "relative": true
       },
+      "additionalOutputs": [
+        {
+          "name": "Error",
+          "type": "jsonSchema",
+          "source": "=Error",
+          "relative": true
+        }
+      ],
       "eventDefinition": null,
       "requiresDiscovery": true,
       "bindingPattern": "businessRule"

package/dist/bpmn/resource-key-pattern.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A binding field's resource key from the registry's `resourceKeyPattern`
+ * (`${metadata.folderPath}.${metadata.name}` on a business rule), resolved from the
+ * node's context values. Pure: the builder supplies the declared bindings a
+ * `=bindings.<b>` reference is read through.
+ */
+/**
+ * What a pattern resolves to from one node's context: the key and the ids of the
+ * declared bindings it was read through; `blocked` when it would resolve except for a
+ * `=bindings.<b>` reference no declared binding supplies a value for (the author is
+ * told what to declare rather than given a wrong pair); `undefined` when the pattern
+ * does not apply to this context at all, so the caller keys the binding by the value,
+ * as it always has.
+ */
+export type ResourceKeyResolution = {
+    key: string;
+    referenced: string[];
+} | {
+    blocked: {
+        field: string;
+        ref: string;
+    };
+} | undefined;
+/**
+ * Resolve `pattern` from `context`. A placeholder that is not `metadata.<field>`, a
+ * context field that is absent or not a string, or an `=` expression that is not a
+ * `=bindings.<b>` reference each make the pattern inapplicable (`undefined`) — so
+ * `${metadata.key}` on a job start, whose context has no `key`, leaves the key to the
+ * value. A `=bindings.<b>` value contributes the DECLARED value of `b`, never the
+ * expression text: a key is never evaluated.
+ *
+ * @param pattern - The field's `resourceKeyPattern`, or `undefined` for none.
+ * @param context - The node's context values as the author gave them.
+ * @param lookup - The declared binding for an id, with its `default` value, or `undefined`.
+ */
+export declare function resolveResourceKeyPattern(pattern: string | undefined, context: Record<string, unknown>, lookup: (bindingId: string) => {
+    default?: unknown;
+} | undefined): ResourceKeyResolution;

package/dist/bpmn/resource-key-pattern.js

@@ -0,0 +1,47 @@
+/**
+ * A binding field's resource key from the registry's `resourceKeyPattern`
+ * (`${metadata.folderPath}.${metadata.name}` on a business rule), resolved from the
+ * node's context values. Pure: the builder supplies the declared bindings a
+ * `=bindings.<b>` reference is read through.
+ */
+/**
+ * Resolve `pattern` from `context`. A placeholder that is not `metadata.<field>`, a
+ * context field that is absent or not a string, or an `=` expression that is not a
+ * `=bindings.<b>` reference each make the pattern inapplicable (`undefined`) — so
+ * `${metadata.key}` on a job start, whose context has no `key`, leaves the key to the
+ * value. A `=bindings.<b>` value contributes the DECLARED value of `b`, never the
+ * expression text: a key is never evaluated.
+ *
+ * @param pattern - The field's `resourceKeyPattern`, or `undefined` for none.
+ * @param context - The node's context values as the author gave them.
+ * @param lookup - The declared binding for an id, with its `default` value, or `undefined`.
+ */
+export function resolveResourceKeyPattern(pattern, context, lookup) {
+    if (pattern === undefined)
+        return undefined;
+    const placeholders = [...pattern.matchAll(/\$\{([\w.]+)\}/g)].map((m) => m[1]);
+    const values = new Map();
+    const referenced = [];
+    for (const name of placeholders) {
+        if (!name.startsWith('metadata.'))
+            return undefined;
+        const contextField = name.slice('metadata.'.length);
+        const v = context[contextField];
+        if (typeof v !== 'string')
+            return undefined;
+        if (!v.startsWith('=')) {
+            values.set(name, v);
+            continue;
+        }
+        if (!v.startsWith('=bindings.'))
+            return undefined;
+        const refId = v.slice('=bindings.'.length);
+        const decl = lookup(refId);
+        if (decl === undefined || typeof decl.default !== 'string')
+            return { blocked: { field: contextField, ref: v } };
+        values.set(name, decl.default);
+        referenced.push(refId);
+    }
+    const key = pattern.replace(/\$\{([\w.]+)\}/g, (_m, name) => values.get(name) ?? '');
+    return { key: key.startsWith('.') ? key.slice(1) : key, referenced };
+}

package/dist/bpmn/typed-node.d.ts

@@ -36,6 +36,13 @@ export interface RegistryContextField {
     bindingInfo: {
         resource: string | null;
         propertyAttribute: string | null;
+        /**
+         * How the binding's `resourceKey` is built from the node's context values, e.g.
+         * `${metadata.folderPath}.${metadata.name}` for a business rule. Absent on
+         * entries materialized before the field was carried; the emitter then keys the
+         * binding by the bound value itself, as it always did.
+         */
+        resourceKeyPattern?: string;
     } | null;
 }
 /**
@@ -88,6 +95,11 @@ export interface RegistryTypeSpec {
     /** The payload fields the registry declares; empty for types with dynamic inputs. */
     inputs: RegistryInputField[];
     output: RegistryOutput | null;
+    /**
+     * Output rows the type writes besides `output` — a business rule's `Error` row
+     * (`source="=Error"`). Each lands in `<id>_<name>`. Absent when the type has none.
+     */
+    additionalOutputs?: RegistryOutput[];
     /** e.g. `bpmn:messageEventDefinition` — what makes a message event a message event. */
     eventDefinition: string | null;
     /** True when authoring needs a tenant read (a connection, a process, a queue). */
@@ -347,6 +359,11 @@ export interface TypedNodeInput {
     /** The type's emission spec, supplied inline — see `ActivityNodeOpts.spec`. */
     spec?: RegistryTypeSpec;
 }
+/**
+ * The variables a typed node's ADDITIONAL output rows write (`<id>_<name>`), in
+ * registry order — a business rule's `<id>_Error`. Empty for every type without them.
+ */
+export declare function typedNodeAdditionalOutputVars(id: string, type: string, inline?: RegistryTypeSpec): string[];
 /** The variable a typed node's output row writes, or `undefined` when it has none. */
 export declare function typedNodeOutputVar(id: string, type: string, outputVar?: string, inline?: RegistryTypeSpec): string | undefined;
 /** `uipath:input` payload rows exactly as the caller spelled them, deriving nothing. */

package/dist/bpmn/typed-node.js

@@ -191,6 +191,15 @@ function identifierize(name) {
         .map((w, i) => (i === 0 ? w.charAt(0).toLowerCase() + w.slice(1) : w.charAt(0).toUpperCase() + w.slice(1)))
         .join('');
 }
+/**
+ * The variables a typed node's ADDITIONAL output rows write (`<id>_<name>`), in
+ * registry order — a business rule's `<id>_Error`. Empty for every type without them.
+ */
+export function typedNodeAdditionalOutputVars(id, type, inline) {
+    // The row's name as it is, not identifierized: `Error` → `<id>_Error`, the variable a
+    // connector task's error row has always landed in.
+    return (registryType(type, inline).additionalOutputs ?? []).map((o) => `${id}_${o.name}`);
+}
 /** The variable a typed node's output row writes, or `undefined` when it has none. */
 export function typedNodeOutputVar(id, type, outputVar, inline) {
     const spec = registryType(type, inline);
@@ -536,6 +545,16 @@ varType) {
     const out = outVar ? outputRow(m, spec, outVar) : undefined;
     if (out)
         rows.push(out);
+    // The rows the registry declares beside the main one, in its order and at the
+    // default variable each — a business rule's `Error` row. They sit between the
+    // type's own row and the author's, which is where every real export puts them.
+    const extraVars = typedNodeAdditionalOutputVars(id, type, spec);
+    (spec.additionalOutputs ?? []).forEach((o, i) => {
+        const props = { name: o.name, type: o.type, var: extraVars[i] };
+        if (o.source)
+            props.source = o.source;
+        rows.push(m.create('uipath:Output', props));
+    });
     for (const [varId, source] of Object.entries(input.outputs ?? {})) {
         // Type the row from the variable it writes, not `'string'` unconditionally.
         //