@uipath/maestro-builder-sdk 6.15.5 → 6.16.0

package/dist/bpmn/decompile.js

@@ -56,6 +56,7 @@ import BpmnModdle from 'bpmn-moddle';
 import { createRequire } from 'node:module';
 import { registryType, rowDeclaration } from './typed-node.js';
 import { errorSchema, errorSchemaWithResponse } from './bpmn-sdk.js';
+import { SCRIPT_ARGS_ENVELOPE, defaultScriptInputSchema } from './serialize.js';
 import { BPMN_SCHEMA_VERSIONS } from './format-profile.js';
 import { preserveSchemaVersion } from '../schema-version.js';
 const require = createRequire(import.meta.url);
@@ -654,7 +655,17 @@ function scriptVersionOf(el) {
 /** A `uipath:mapping` script task. */
 function emitScriptTask(chain, el, payload, type) {
     const args = (payload?.input ?? []).find((r) => r.name === 'args');
-    const inputs = args ? safeJson(args.body) : undefined;
+    // The serializer writes the product's envelope — `vars`/`metadata`, and the default
+    // inputSchema declaring them — on every script task, so the source need not repeat
+    // them: an `args` that is exactly the envelope decompiles to no `inputs` at all, and
+    // only what the designer added (`"iterator[0]":"=iterator[0]"`) comes through. A
+    // schema that differs from the default (the designer's carries `$schema`) is kept.
+    const rawInputs = args ? safeJson(args.body) : undefined;
+    const inputs = rawInputs
+        ? Object.fromEntries(Object.entries(rawInputs).filter(([k, v]) => !(k in SCRIPT_ARGS_ENVELOPE) || v !== SCRIPT_ARGS_ENVELOPE[k]))
+        : undefined;
+    const schemaBody = payload?.context?.inputSchema?.body;
+    const schemaIsDefault = schemaBody !== undefined && rawInputs !== undefined && JSON.stringify(safeJson(schemaBody)) === JSON.stringify(defaultScriptInputSchema(rawInputs));
     const outputs = {};
     for (const row of payload?.output ?? [])
         outputs[row.var ?? row.name] = row.source;
@@ -680,7 +691,7 @@ function emitScriptTask(chain, el, payload, type) {
             'type',
             type !== undefined && type !== 'BPMN.Variables' && type !== 'BPMN.ScriptTask' ? str(type) : undefined,
         ],
-        ['inputSchema', payload?.context?.inputSchema?.body !== undefined ? jsonLiteral(payload.context.inputSchema.body) : undefined],
+        ['inputSchema', schemaBody !== undefined && !schemaIsDefault ? jsonLiteral(schemaBody) : undefined],
         ['inputs', record(inputs)],
         ['outputs', verbatim ? undefined : record(outputs)],
         ['outputRows', verbatim],

package/dist/bpmn/intsvc.d.ts

@@ -66,6 +66,14 @@ export declare function intsvcOutputVar(n: EventNode | ExternalNode): string | u
  * @returns The moddle element.
  */
 export declare function createConnectorEvent(ctx: ConnectorCtx, n: EventNode): El;
+/**
+ * The `body` of a connector event node: the subscription's filter in the one place the
+ * platform reads it. `scope` (the `filter` option — the operation's event parameters, by
+ * equality) becomes both the `queryParams` and the leading `(k == 'v')` clauses;
+ * `filters` (payload conditions) follow, each in parentheses, all AND-joined. No scope and
+ * no filters is `{}`, which is what the designer writes for an unfiltered subscription.
+ */
+export declare function eventFilterBody(nodeId: string, scope: Record<string, unknown> | undefined, filters: readonly unknown[] | undefined): Record<string, unknown>;
 /**
  * An external agent / workflow invocation.
  *

package/dist/bpmn/intsvc.js

@@ -1,5 +1,6 @@
 import { createTypedNode, typedNodeOutputVar } from './typed-node.js';
 import { connectorBindingRef } from './connector.js';
+import { eventFilterJmes, eventFilterProblem, readEventFilter } from '../core/event-filters.js';
 /**
  * Which extension type an external invocation lowers to.
  *
@@ -96,8 +97,18 @@ export function createConnectorEvent(ctx, n) {
         // and watches nothing. A curated entry carries its own and the author passes none.
         objectName: n.object ?? op.objectName ?? '',
     };
-    if (n.filter !== undefined)
-        inputs.filter = n.filter;
+    // The subscription's filter goes in the `body` row, where the platform reads it:
+    // `PO.BpmnEngine` `BpmnInputExtensions.GetEventFilters` takes `body.filters.expression`
+    // (and `queryParams` registers the scope with the connector). This emitter used to write
+    // `<uipath:input name="filter" target="filter">{…}</uipath:input>`, an input no handler
+    // reads: on flow-v2-run-12 the wait so scoped validated and matched every mail in the
+    // mailbox (outlook-waitfor-email 1.00 → 0.43), while the v1 arm and every Studio Web
+    // export write `{"filters":{"expression":"(parentFolderId == '…') && (contains(subject, '…'))"},"queryParams":{"parentFolderId":"…"}}`.
+    //
+    // The expression is the scope's equality clauses AND-joined with the authored
+    // `filters`, each lowered by the designer's own grammar (`core/event-filters.ts`) — the
+    // same lowering the Flow serializer does for `onEvent`/`waitForEvent`.
+    inputs.body = eventFilterBody(n.id, n.filter, n.filters);
     if (n.parameters !== undefined)
         inputs.parameters = n.parameters;
     return createTypedNode(ctx.m, n.id, type, {
@@ -108,6 +119,36 @@ export function createConnectorEvent(ctx, n) {
         skipCondition: n.skipCondition,
     }, (varId) => ctx.varTypeOf?.(varId));
 }
+/**
+ * The `body` of a connector event node: the subscription's filter in the one place the
+ * platform reads it. `scope` (the `filter` option — the operation's event parameters, by
+ * equality) becomes both the `queryParams` and the leading `(k == 'v')` clauses;
+ * `filters` (payload conditions) follow, each in parentheses, all AND-joined. No scope and
+ * no filters is `{}`, which is what the designer writes for an unfiltered subscription.
+ */
+export function eventFilterBody(nodeId, scope, filters) {
+    const scopeEntries = Object.entries(scope ?? {}).filter(([, v]) => v !== undefined && v !== null && String(v) !== '');
+    const scopeClauses = scopeEntries.map(([k, v]) => `(${k} == '${String(v).replace(/'/g, "\\'")}')`);
+    const conditions = (filters ?? []).map((leaf, i) => {
+        const { read } = readEventFilter(leaf);
+        if (!read) {
+            throw new Error(`connector event "${nodeId}": filters[${i}] must carry a field and exactly ONE operator ` +
+                `(contains, startsWith, endsWith, equals, notEquals, lessThan, lessThanOrEqual, greaterThan, ` +
+                `greaterThanOrEqual) — got ${JSON.stringify(leaf)}.`);
+        }
+        const problem = eventFilterProblem(read);
+        if (problem)
+            throw new Error(`connector event "${nodeId}": filters[${i}] on \`${read.field}\`: ${problem}`);
+        return `(${eventFilterJmes(read)})`;
+    });
+    const expression = [...scopeClauses, ...conditions].join(' && ');
+    const body = {};
+    if (expression !== '')
+        body.filters = { expression };
+    if (scopeEntries.length > 0)
+        body.queryParams = Object.fromEntries(scopeEntries);
+    return body;
+}
 /**
  * An external agent / workflow invocation.
  *

package/dist/bpmn/serialize.d.ts

@@ -26,6 +26,20 @@ export declare function serialize(built: BuiltBpmn, opts?: BpmnSerializeOpts): P
  */
 export declare function finalizeBpmnXml(xml: string): string;
 export declare function processId(id: string): string;
+/**
+ * The `args` keys every Studio Web script task carries, in the order the designer writes
+ * them. The platform runtime injects these — and only these — into the script's scope.
+ */
+export declare const SCRIPT_ARGS_ENVELOPE: {
+    readonly vars: "=vars";
+    readonly metadata: "=metadata";
+};
+/**
+ * The `uipath:inputSchema` the product writes for a script task's `args`: `vars` and
+ * `metadata` as objects, plus an untyped property per extra key. Exported so the
+ * decompiler can recognise it and leave it out of the source.
+ */
+export declare function defaultScriptInputSchema(args: Record<string, unknown>): Record<string, unknown>;
 /**
  * The variable declarations a scope's output-bearing nodes imply.
  *

package/dist/bpmn/serialize.js

@@ -444,21 +444,50 @@ function buildErrorMappingExt(ctx, rows) {
         }),
     });
 }
+/**
+ * The `args` keys every Studio Web script task carries, in the order the designer writes
+ * them. The platform runtime injects these — and only these — into the script's scope.
+ */
+export const SCRIPT_ARGS_ENVELOPE = { vars: '=vars', metadata: '=metadata' };
+/**
+ * The `uipath:inputSchema` the product writes for a script task's `args`: `vars` and
+ * `metadata` as objects, plus an untyped property per extra key. Exported so the
+ * decompiler can recognise it and leave it out of the source.
+ */
+export function defaultScriptInputSchema(args) {
+    const properties = {};
+    for (const k of Object.keys(args))
+        properties[k] = k in SCRIPT_ARGS_ENVELOPE ? { type: 'object' } : {};
+    return { type: 'object', properties };
+}
 function createScriptTask(ctx, n) {
     const { m } = ctx;
+    // The `args` row is the product's fixed envelope — `vars` and `metadata`, always, in
+    // that order — with the author's `inputs` after it. The platform runtime injects the
+    // ENVELOPE into the script's scope and nothing else: in flow-v2-run-12 every script
+    // that read an `inputs` key as a bare identifier faulted on the cloud with
+    // `<key> is not defined` (3 of 3 cloud-executed script tasks; `check`, `compile` and
+    // `uip maestro bpmn validate` had all passed), while every Studio Web export in
+    // `research/bpmn-roundtrip` and every v1-authored process in the same run carries
+    // exactly this envelope and reads `vars.<id>`. The author's keys are kept so an import
+    // round-trips (`iterator[0]` is how the designer scopes a loop body) and so a key the
+    // author knows the runtime honours can still be passed; a bare read of one is what
+    // `check` reports as SCRIPT_BARE_INPUT_REF. See docs/BPMN_EVAL_RUN12_FINDINGS.md §4 P0-1.
+    const args = { ...SCRIPT_ARGS_ENVELOPE, ...n.inputs };
+    const inputSchema = n.inputSchema ?? defaultScriptInputSchema(args);
     const mapping = m.create('uipath:Mapping', {
         version: 'v1',
         type: m.create('uipath:Type', { value: n.type, version: 'v1' }),
-        // The context holds only the schema here — a script task has no context ROWS.
-        context: n.inputSchema === undefined
-            ? undefined
-            : m.create('uipath:Context', {
-                inputSchema: m.create('uipath:InputSchema', {
-                    type: 'jsonSchema',
-                    body: typeof n.inputSchema === 'string' ? n.inputSchema : JSON.stringify(n.inputSchema),
-                }),
+        // The context holds only the schema here — a script task has no context ROWS. Real
+        // script tasks all carry the schema; the product refuses to run without the envelope
+        // it declares, so an absent one is filled in rather than left out.
+        context: m.create('uipath:Context', {
+            inputSchema: m.create('uipath:InputSchema', {
+                type: 'jsonSchema',
+                body: typeof inputSchema === 'string' ? inputSchema : JSON.stringify(inputSchema),
             }),
-        input: [m.create('uipath:Input', { name: 'args', type: 'json', target: 'bodyField', body: JSON.stringify(n.inputs) })],
+        }),
+        input: [m.create('uipath:Input', { name: 'args', type: 'json', target: 'bodyField', body: JSON.stringify(args) })],
         // Spelled-out rows win over derived ones: `outputs` names each row after the
         // variable it writes, and the product names it after what the script returns
         // while binding a differently-named variable. See ScriptTaskOpts.outputRows.

package/dist/bpmn/typed-node.js

@@ -1,5 +1,6 @@
 import { createRequire } from 'node:module';
 import { resolveFromRegistry } from './registry-fallback.js';
+import { nestConnectorBody } from '../core/connector-inputs.js';
 import { types } from '../core/expr.js';
 const require = createRequire(import.meta.url);
 const REGISTRY = require('./registry-types.json');
@@ -64,7 +65,20 @@ export function isSnapshotType(type) {
  * constant for the one type known to need it rather than derived.
  */
 export const REGISTRY_GAPS = {
-    'Orchestrator.StartAgentJob': { resourceSubType: 'Agent' },
+    // `folderKey` — the job-start family's v1 addressing field. The registry declares
+    // `folderId`, but the engine's v1 branch reads `FolderKey` (`ExecuteApiWorkflowArgs`:
+    // `input.GetValueFromContext<string>(nameof(OrchestratorFolderContext.FolderKey))`), and
+    // the v1 skill verified live that `releaseKey` without it faults with `Could not get
+    // value for key:FolderKey from context in input`. Emitted only for a node addressed by
+    // `releaseKey` — see `OrchestratorOpts.folderKey`.
+    'Orchestrator.StartAgentJob': { resourceSubType: 'Agent', extraContext: ['folderKey'] },
+    'Orchestrator.StartJob': { extraContext: ['folderKey'] },
+    'Orchestrator.ExecuteApiWorkflowAsync': { extraContext: ['folderKey'] },
+    'Orchestrator.StartAgenticProcess': { extraContext: ['folderKey'] },
+    'Orchestrator.StartAgenticProcessAsync': { extraContext: ['folderKey'] },
+    'Orchestrator.StartCaseMgmtProcess': { extraContext: ['folderKey'] },
+    'Orchestrator.StartCaseMgmtProcessAsync': { extraContext: ['folderKey'] },
+    'Orchestrator.BusinessRules': { extraContext: ['folderKey'] },
     // `notEnforcedInputs` — required InputFields the platform does NOT actually enforce.
     //
     // MEASURED, on a real trigger that carries `connection`, `folderKey`, `connectorKey`,
@@ -226,9 +240,19 @@ function contextRows(m, type, spec, supplied, verbatim = false) {
         return rows;
     }
     for (const field of spec.context) {
-        const value = supplied[field.name] ?? field.default;
+        let value = supplied[field.name] ?? field.default;
         if (value === undefined || value === null)
             continue;
+        // A json field whose REGISTRY default is the text `null` is unrunnable as declared:
+        // the platform parses the row to a JSON null and `IntSvcUnifiedHttpRequestArgs`
+        // throws `Body cannot be null` on it (incident 102018 — flow-v2-run-12
+        // slack-http-fallback, a GET with no body, faulted on exactly this after check,
+        // compile and validate had passed). Omitting the row is the same null. So a
+        // default of `null` on a json field is written as `{}`, the empty object the handler
+        // accepts; an author who wrote `null` themselves still gets it verbatim, and an
+        // import's `"null"` text round-trips untouched (see decompile's json-row rules).
+        if (field.type === 'json' && !(field.name in supplied) && field.default === 'null')
+            value = {};
         emitted.add(field.name);
         // A `json` field goes in the CDATA BODY, not a `value` attribute. The product
         // validator parses that field as JSON and reads the attribute WITHOUT XML
@@ -266,6 +290,28 @@ function contextRows(m, type, spec, supplied, verbatim = false) {
     }
     return rows;
 }
+/**
+ * The `target` values a payload row can carry — `BpmnInputTarget` in PO.BpmnEngine
+ * (`InputResolutionActivities` routes `Body`/`BodyField`/`Header`/`PathVariable`/`Query`/
+ * `PathParameters`/`QueryParameters`/`File`), plus the connector emitter's `multipart`.
+ * An undeclared `separateInputs` key that is one of these addresses a slot; any other
+ * key is a field — see `inputRows`.
+ */
+const PAYLOAD_TARGETS = new Set([
+    'body',
+    'bodyField',
+    'header',
+    'headers',
+    'pathVariable',
+    'pathParameters',
+    'query',
+    'queryParameters',
+    'file',
+    'multipart',
+]);
+function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 /**
  * The payload rows, per the type's `inputPattern`.
  *
@@ -308,11 +354,37 @@ function inputRows(m, spec, inputs) {
         // `recordId` as `"1111-…"`, quotes included, where every real export writes
         // `type="string" value="1111-…"`. A structured value is still a json body; a
         // scalar is written as the `value` attribute, the way a declared scalar is.
+        //
+        // An undeclared key is a TARGET, then — `body`, `pathParameters`, `queryParameters`
+        // — and only a target. A key that is none of the platform's targets is a request
+        // FIELD the author wrote where a slot belongs (`inputs: { script: '…' }` on
+        // `Intsvc.ActivityExecution`), and keyed as its own target it reaches a row the
+        // platform never reads: on flow-v2-run-12 the JDBC `execute-query-synchronously` node
+        // so written went out as `<uipath:input name="script" … target="script"/>` and every
+        // one of seven cloud runs faulted `Integration Services bad request`, while the v1 arm's
+        // `<uipath:input name="body" target="body">{"script":"…"}</uipath:input>` completed
+        // first time. Such keys fold into the type's own payload row (`inputName`/`inputTarget`,
+        // `body` for the Integration Service family), nested by their dotted ids, exactly as
+        // `.connector()` writes a request. A type with no payload row keeps keying them.
         const declared = new Map(spec.inputs.map((f) => [f.name, f]));
-        return keys.map((k) => {
+        const fieldKeys = spec.inputName !== null && spec.inputTarget !== null
+            ? keys.filter((k) => !declared.has(k) && !PAYLOAD_TARGETS.has(k) && k !== spec.inputName)
+            : [];
+        const folded = new Set(fieldKeys);
+        const rows = keys
+            .filter((k) => !folded.has(k))
+            .map((k) => {
             const field = declared.get(k);
-            return payloadInput(m, k, field?.target ?? k, inputs[k], field?.type ?? inferredInputType(inputs[k]));
+            let value = inputs[k];
+            if (k === spec.inputName && fieldKeys.length > 0 && isPlainRecord(value)) {
+                value = { ...nestConnectorBody(Object.fromEntries(fieldKeys.map((f) => [f, inputs[f]]))), ...value };
+            }
+            return payloadInput(m, k, field?.target ?? k, value, field?.type ?? inferredInputType(value));
         });
+        if (fieldKeys.length > 0 && !keys.includes(spec.inputName)) {
+            rows.push(payloadInput(m, spec.inputName, spec.inputTarget, nestConnectorBody(Object.fromEntries(fieldKeys.map((f) => [f, inputs[f]]))), 'json'));
+        }
+        return rows;
     }
     if (!spec.inputName)
         return [];

package/dist/bpmn/uipath-moddle.v1.json

@@ -267,6 +267,16 @@
           "name": "skipCondition",
           "isAttr": true,
           "type": "String"
+        },
+        {
+          "name": "argumentOverrides",
+          "isAttr": true,
+          "type": "String"
+        },
+        {
+          "name": "argumentsInput",
+          "isAttr": true,
+          "type": "String"
         }
       ]
     },
@@ -301,6 +311,16 @@
           "name": "skipCondition",
           "isAttr": true,
           "type": "String"
+        },
+        {
+          "name": "argumentOverrides",
+          "isAttr": true,
+          "type": "String"
+        },
+        {
+          "name": "argumentsInput",
+          "isAttr": true,
+          "type": "String"
         }
       ]
     },

package/dist/check.js

@@ -16,7 +16,7 @@ import { hitlDerivesOutcomeHandles, hitlExitModel, hitlRoutesPerOutcome } from '
 import { childStepLists, declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { compareSchemaVersions, schemaVersionRefusal } from './schema-version.js';
-import { planFlowGlobals } from './flow-variables.js';
+import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-variables.js';
 export function check(built, opts = {}) {
     let diags = [];
     const uses = collectConnectionUses(() => { diags = checkFlow(built, [], opts); });
@@ -81,11 +81,17 @@ function checkFlow(built, ancestors, opts = {}) {
         declared.add(built.triggerId);
     for (const ep of built.entryPoints ?? [])
         declared.add(ep.id);
+    // A variable an input feeds with `{ shared }` is declared by the SDK when the
+    // author did not declare it (#924), so it is a readable `$vars.<name>` too.
+    const sharedAutoVars = planSharedInputs({ roots: sharedInputRoots(built), outputs: built.outputs, vars: built.vars }).autoVars;
+    for (const a of sharedAutoVars)
+        declared.add(a.name);
     // Declared type per name, for the output/return category check below.
     const typeOf = new Map([
         ...built.inputs.map((x) => [x.name, String(x.type)]),
         ...(built.entryPoints ?? []).flatMap((ep) => ep.inputs.map((x) => [x.name, String(x.type)])),
         ...built.vars.map((x) => [x.name, String(x.type)]),
+        ...sharedAutoVars.map((x) => [x.name, x.type]),
     ]);
     const outputType = new Map(built.outputs.map((x) => [x.name, String(x.type)]));
     const stepNames = new Set();
@@ -1411,6 +1417,14 @@ function checkSubflow(step, child, inputs, parent, ancestors, diags) {
         at('SUBFLOW_CHILD_TRIGGER', `Subflow "${step}" runs a flow with its own \`.trigger(…)\`. A subflow is started by its caller, never by a `
             + `trigger of its own — the schedule would be dropped. Remove the .trigger() from "${child.id}".`);
     }
+    // `{ shared }` merges one input across a flow's ROOTS (#924). A subflow has
+    // one root, its caller, so there is nothing to merge; serialize refuses it.
+    for (const inp of child.inputs) {
+        if (inp.shared === undefined)
+            continue;
+        at('SHARED_INPUT_IN_SUBFLOW', `Subflow "${step}" runs "${child.id}", whose input "${inp.name}" has { shared: "${inp.shared}" }. A subflow has `
+            + `one root — its caller — so there is nothing to merge. Read the input with input('${inp.name}') inside the child.`);
+    }
     const declared = new Map(child.inputs.map((i) => [i.name, String(i.type)]));
     const given = inputs ?? {};
     for (const key of Object.keys(given)) {
@@ -1653,7 +1667,14 @@ const INTERVAL_WORDS = [
  * said `Errors: 0`, validate refused the file).
  */
 function checkGlobalNames(built, diags) {
-    for (const p of planFlowGlobals({ inputs: built.inputs ?? [], outputs: built.outputs ?? [], vars: built.vars ?? [] }).problems) {
+    // `{ shared }` inputs (#924) may add `.var()`s; the plan is the serializer's
+    // own (`emittableGlobals`), so check and the emitted file agree on them.
+    const shared = planSharedInputs({ roots: sharedInputRoots(built), outputs: built.outputs ?? [], vars: built.vars ?? [] });
+    for (const p of shared.problems) {
+        diags.push({ level: p.level, code: p.code, message: p.message, ...(p.suggestion ? { suggestion: p.suggestion } : {}) });
+    }
+    const vars = [...(built.vars ?? []), ...shared.autoVars];
+    for (const p of planFlowGlobals({ inputs: built.inputs ?? [], outputs: built.outputs ?? [], vars }).problems) {
         diags.push({ level: 'error', code: p.code, message: p.message, ...(p.suggestion ? { suggestion: p.suggestion } : {}) });
     }
 }
@@ -1665,7 +1686,12 @@ function checkGlobalNames(built, diags) {
  */
 function checkNodeUpdates(built, diags) {
     const inputs = new Set(built.inputs.map((v) => v.name));
-    const writable = new Set([...built.vars.map((v) => v.name), ...built.outputs.map((v) => v.name)]);
+    const writable = new Set([
+        ...built.vars.map((v) => v.name),
+        ...built.outputs.map((v) => v.name),
+        // A variable declared by `{ shared }` (#924) is a `.var()` like any other.
+        ...planSharedInputs({ roots: sharedInputRoots(built), outputs: built.outputs, vars: built.vars }).autoVars.map((v) => v.name),
+    ]);
     const visit = (steps) => {
         for (const s of steps) {
             const updates = s.options?.updates;

package/dist/core/connector-inputs.d.ts

@@ -78,3 +78,23 @@ interface ConnectorSlots {
         };
     };
 }
+/**
+ * Fold a body keyed by the registry's dotted field ids into the nested request
+ * object those ids describe: `{"fields.project.key":"CE"}` → `{"fields":{"project":{"key":"CE"}}}`.
+ *
+ * `buildConnectorInputs` keeps the DOTTED keys on purpose — Flow's `bodyParameters` is a
+ * flat map and Flow's runtime (`convertDotNotationToNested`) nests it before the call.
+ * The Maestro BPMN runtime does not: `IntSvcSendTaskHandler` sends the `body` input as
+ * written, so a dotted key reaches the connector as a literal property name. Measured on
+ * flow-v2-run-12: the SDK's Jira `create-issue` body went out flat and Integration
+ * Service answered 400 `project: Specify a valid project ID or key`; the v1 arm, which
+ * writes the nested form by hand, created the ticket. A BPMN body therefore goes through
+ * this before it is serialised.
+ *
+ * A `[*]` segment names an array. On a leaf (`users[*]`) an array value is kept and a
+ * scalar becomes a one-element list, as the product's own conversion does; on an inner
+ * segment (`attachments[*].url`) each element of an array value becomes one object, and
+ * a scalar one. Later keys win over earlier ones at the same leaf; a nested object the
+ * author already wrote under a plain key is merged into, not replaced.
+ */
+export declare function nestConnectorBody(flat: Record<string, unknown>): Record<string, unknown>;

package/dist/core/connector-inputs.js

@@ -259,6 +259,57 @@ const SLOT_FOR_LOCATION = {
     query: 'queryParameters',
     path: 'pathParameters',
 };
+/**
+ * Fold a body keyed by the registry's dotted field ids into the nested request
+ * object those ids describe: `{"fields.project.key":"CE"}` → `{"fields":{"project":{"key":"CE"}}}`.
+ *
+ * `buildConnectorInputs` keeps the DOTTED keys on purpose — Flow's `bodyParameters` is a
+ * flat map and Flow's runtime (`convertDotNotationToNested`) nests it before the call.
+ * The Maestro BPMN runtime does not: `IntSvcSendTaskHandler` sends the `body` input as
+ * written, so a dotted key reaches the connector as a literal property name. Measured on
+ * flow-v2-run-12: the SDK's Jira `create-issue` body went out flat and Integration
+ * Service answered 400 `project: Specify a valid project ID or key`; the v1 arm, which
+ * writes the nested form by hand, created the ticket. A BPMN body therefore goes through
+ * this before it is serialised.
+ *
+ * A `[*]` segment names an array. On a leaf (`users[*]`) an array value is kept and a
+ * scalar becomes a one-element list, as the product's own conversion does; on an inner
+ * segment (`attachments[*].url`) each element of an array value becomes one object, and
+ * a scalar one. Later keys win over earlier ones at the same leaf; a nested object the
+ * author already wrote under a plain key is merged into, not replaced.
+ */
+export function nestConnectorBody(flat) {
+    const out = {};
+    for (const [name, value] of Object.entries(flat)) {
+        const parts = connectorPath(name);
+        place(out, parts, 0, value);
+    }
+    return out;
+}
+function place(target, parts, index, value) {
+    const part = parts[index];
+    const last = index === parts.length - 1;
+    if (last) {
+        target[part.key] = part.array && !Array.isArray(value) ? [value] : value;
+        return;
+    }
+    if (part.array) {
+        const elements = Array.isArray(value) ? value : [value];
+        const existing = Array.isArray(target[part.key]) ? target[part.key] : [];
+        target[part.key] = elements.map((element, i) => {
+            const slot = isRecord(existing[i]) ? existing[i] : {};
+            place(slot, parts, index + 1, element);
+            return slot;
+        });
+        return;
+    }
+    const next = isRecord(target[part.key]) ? target[part.key] : {};
+    target[part.key] = next;
+    place(next, parts, index + 1, value);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function connectorPath(name) {
     return name.split('.').map((raw) => ({
         key: raw.endsWith('[*]') ? raw.slice(0, -3) : raw,

package/dist/core/event-checks.d.ts

@@ -9,12 +9,14 @@
  * `.waitForEvent()` node carries the same facts under its own names, and
  * `bpmn/check.ts` adapts one to the other.
  *
- * What BPMN does NOT carry is `filters` — payload filtering is a Flow surface —
- * so the `EVENT_FILTER_*` family simply does not fire there. The rules that do
- * are the ones about the SUBSCRIPTION: whether it resolves at all, whether a
- * generic event named its object, and whether its scope names parameters the
- * operation actually declares. `skill-bpmn-outlook-waitfor-email` in
- * `flow-v2-run-8` failed on exactly that last question.
+ * BPMN carries `filters` too, since flow-v2-run-12: both families write payload
+ * conditions into the subscription the platform reads (Flow's `filterExpression`,
+ * BPMN's `body.filters.expression`), lowered by the same grammar, so the
+ * `EVENT_FILTER_*` family fires for both. The subscription rules are the rest:
+ * whether it resolves at all, whether a generic event named its object, and whether
+ * its scope names parameters the operation actually declares.
+ * `skill-bpmn-outlook-waitfor-email` in `flow-v2-run-8` failed on exactly that last
+ * question, and in run 12 on having nowhere to put a payload condition.
  */
 import { type LookupResolutions } from './lookups.js';
 import { type ByoaEventFacts, type ByoaLedger } from './byoa.js';

package/dist/core/event-checks.js

@@ -9,12 +9,14 @@
  * `.waitForEvent()` node carries the same facts under its own names, and
  * `bpmn/check.ts` adapts one to the other.
  *
- * What BPMN does NOT carry is `filters` — payload filtering is a Flow surface —
- * so the `EVENT_FILTER_*` family simply does not fire there. The rules that do
- * are the ones about the SUBSCRIPTION: whether it resolves at all, whether a
- * generic event named its object, and whether its scope names parameters the
- * operation actually declares. `skill-bpmn-outlook-waitfor-email` in
- * `flow-v2-run-8` failed on exactly that last question.
+ * BPMN carries `filters` too, since flow-v2-run-12: both families write payload
+ * conditions into the subscription the platform reads (Flow's `filterExpression`,
+ * BPMN's `body.filters.expression`), lowered by the same grammar, so the
+ * `EVENT_FILTER_*` family fires for both. The subscription rules are the rest:
+ * whether it resolves at all, whether a generic event named its object, and whether
+ * its scope names parameters the operation actually declares.
+ * `skill-bpmn-outlook-waitfor-email` in `flow-v2-run-8` failed on exactly that last
+ * question, and in run 12 on having nowhere to put a payload condition.
  */
 import { isLookupToken, resolvedValue, unresolvedLookupMessage, } from './lookups.js';
 import { prepareCommand } from './cli-spelling.js';