@uipath/maestro-builder-sdk 6.37.0 → 6.39.0

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

@@ -163,6 +163,10 @@ export type BpmnNode = {
     inputs: Record<string, unknown>;
     /** Variable the response lands in; defaults to `<id>_response`. */
     outputVar?: string;
+    /** Variable the error payload lands in; defaults to `<id>_Error`. */
+    errorVar?: string;
+    /** Extra mapped output rows, by the variable each writes — see `BpmnConnectorOpts.outputs`. */
+    outputs?: Record<string, string | ConnectorOutputRow>;
     /** `=`-expression that, when true, skips this activity (`uipath:activity/@skipCondition`). */
     skipCondition?: string;
 }) | (ActivityNodeFields & {
@@ -3140,6 +3144,20 @@ declare abstract class ScopeBuilder {
     vars(entries: VarEntry[]): this;
     private declareVar;
 }
+/**
+ * One extra output row on a connector task, spelled out — the object form of an entry in
+ * {@link BpmnConnectorOpts}' `outputs`.
+ */
+export interface ConnectorOutputRow {
+    /** The `=`-expression against the result, e.g. `'=response.Id'`. */
+    source: string;
+    /** The row's `name`; defaults to the variable. The designer names a row after the field it reads. */
+    name?: string;
+    /** The row's `type`; defaults to the variable's declared type, else `string`. */
+    type?: string;
+    /** The designer's `custom="true"` mark on a row the author added in the variables panel. */
+    custom?: boolean;
+}
 /**
  * `.connector()` options: the shared connector options, plus the BPMN-only
  * display `name` and output-variable override.
@@ -3164,6 +3182,21 @@ export type BpmnConnectorOpts = ConnectorOpts & ActivityOpts & {
      * always lands in `<id>_Error`.
      */
     outputVar?: string;
+    /**
+     * Variable the error payload lands in. Defaults to `<id>_Error`, the name every
+     * `.connector()` has always written; an import names whatever the file bound
+     * (`error12`), so decompile can lift a connector task without renaming its variable.
+     */
+    errorVar?: string;
+    /**
+     * Extra output rows beside the response and the Error, by the variable each
+     * writes: `{ invoiceId: '=response.Id' }` writes `<uipath:output name="invoiceId"
+     * source="=response.Id" var="invoiceId"/>`; the object form names and types the row
+     * (`{ id5: { source: '=response.Id', name: 'Id', type: 'string' } }`), which is how a
+     * designer-added row reads back from an import. Each variable is declared for you
+     * unless you declared it.
+     */
+    outputs?: Record<string, string | ConnectorOutputRow>;
 };
 /** A sub-process body: the same graph methods, plus an internal node builder. */
 export declare class SubProcessBuilder extends ScopeBuilder {

package/dist/bpmn/bpmn-sdk.js

@@ -943,9 +943,13 @@ class ScopeBuilder {
             object: spec.object,
             inputs: spec.inputs,
             outputVar: bpmnOpts.outputVar,
+            errorVar: bpmnOpts.errorVar,
+            outputs: bpmnOpts.outputs,
             skipCondition: bpmnOpts.skipCondition,
+            tags: bpmnOpts.tags,
             retry: bpmnOpts.retry,
             loop: bpmnOpts.loop,
+            errorMapping: bpmnOpts.errorMapping,
         }, body);
     }
     /**

package/dist/bpmn/check.js

@@ -67,6 +67,7 @@ export function check(built, opts = {}) {
     checkVariableOrder(built, diags);
     checkDocumentIds(built, diags);
     checkFolderBindings(built, diags);
+    checkIntsvcActivities(built, diags);
     checkEntryPointId(built, diags);
     checkMethodParentheses(built, diags);
     checkConnectorRows(built, diags);
@@ -99,6 +100,21 @@ function checkConnectors(built, opts, diags) {
         checkConnectorLookups(where, n, opts, EQUALS_EXPR_DIALECT, report);
         checkConnectorSchema(where, n, opts, EQUALS_EXPR_DIALECT, report);
         checkConnectorContract(where, n, opts, report);
+        // Two rows writing one variable: an `outputs` key that is also the response or
+        // error variable. Both rows would be emitted and the later write wins at run time.
+        const response = n.outputVar ?? `${n.id}_response`;
+        const error = n.errorVar ?? `${n.id}_Error`;
+        for (const varId of Object.keys(n.outputs ?? {})) {
+            if (varId !== response && varId !== error)
+                continue;
+            report({
+                level: 'error',
+                code: 'CONNECTOR_OUTPUT_VAR_CLASH',
+                message: `${where}: outputs maps "${varId}", which is already the task's ${varId === response ? 'response' : 'error'} variable ` +
+                    `(\`${varId === response ? 'outputVar' : 'errorVar'}\`); two rows would write it. Map the extra row to another variable, ` +
+                    `or drop it and read \`vars.${varId}\` directly.`,
+            });
+        }
     }
 }
 /**
@@ -365,6 +381,242 @@ function checkFolderBindings(built, diags) {
         }
     }
 }
+/** The `method` vocabulary of the Integration Service activity catalog (`MethodName`). */
+const INTSVC_METHODS = new Set(['GET', 'GETBYID', 'POST', 'PUT', 'PATCH', 'DELETE']);
+/** The catalog's identity fields on an `Intsvc.ActivityExecution` task, in the order the message names them. */
+const INTSVC_IDENTITY = ['connectorKey', 'objectName', 'operation', 'method', 'path'];
+/**
+ * A hand-filled `Intsvc.ActivityExecution` task: what the catalog, the refresh and
+ * the runtime require of its context that `uip maestro bpmn validate` does not report.
+ *
+ * `.connector()` and `.dataService()` write this task from the library; an author
+ * who reaches for `.activity(id, 'Intsvc.ActivityExecution', …)` — the route the skill
+ * names for a connector the library lacks — fills the identity rows by hand from
+ * `uip is activities list <key>`, and the 2026-10-16 eval run measured what goes wrong
+ * (141 SDK-authored files, 109 such tasks): `objectName: 'N/A'` and `method: 'N/A'`
+ * copied from the catalog's GENERIC rows (5 tasks — `validate` reported them Valid, and
+ * they dispatch to nothing), an empty `operation` (5), `<METHOD_FROM_CLI>`-style template
+ * placeholders left in place, and a `connection` that `uip maestro bpmn refresh` then
+ * refused with `connection must reference a root binding as "=bindings.<id>"`.
+ *
+ * What the registry's own field notes say the rows are: `operation` is the catalog
+ * activity's `Name`, `objectName` its `ObjectName`, `method` its `MethodName`, `path` the
+ * request path `is resources describe` returns, and `connection` "points to a root binding
+ * for a Connection resource" with `folderKey` a second binding for the same key. Real
+ * exports agree on the shape and differ on one spelling: `operation` is the catalog Name
+ * on the canvas (`UpdateEntityRecordV2`) and the CRUD verb in 94 of 108 hand-written v1
+ * tasks (`Create`, `Retrieve`), so that field is held to "an identifier", not a list.
+ * `method` IS a closed list: GET, GETBYID, POST, PUT, PATCH, DELETE, measured over every
+ * task in both arms and the corpus.
+ *
+ * Errors where the task cannot dispatch or the platform refuses it; warnings where it
+ * deploys but the SDK cannot tell it is right.
+ */
+function checkIntsvcActivities(built, diags) {
+    // The bindings the compiled process will carry: the ones declared with `.binding()`,
+    // and the ones `serialize` synthesizes for every `.connector()`, `.eventTrigger()` /
+    // `.waitForEvent()` and external task from the symbolic names they read (ids equal
+    // to the names, `connector.ts` `bindingRef`) — a hand-filled task may reuse those.
+    const declared = new Map(built.bindings.map((b) => [b.id, { resource: String(b.resource ?? ''), propertyAttribute: String(b.propertyAttribute ?? '') }]));
+    for (const n of allNodes(built.nodes)) {
+        if (n.kind !== 'connector' && n.kind !== 'connectorEvent' && n.kind !== 'externalTask')
+            continue;
+        if (n.connection && !declared.has(n.connection))
+            declared.set(n.connection, { resource: 'Connection', propertyAttribute: 'ConnectionId' });
+        if (n.folder && !declared.has(n.folder))
+            declared.set(n.folder, { resource: 'Connection', propertyAttribute: 'folderKey' });
+    }
+    const expr = (v) => typeof v === 'string' && v.startsWith('=');
+    const text = (v) => (typeof v === 'string' ? v : v === undefined || v === null ? undefined : String(v));
+    for (const n of allNodes(built.nodes)) {
+        if (n.kind !== 'typed' || n.type !== 'Intsvc.ActivityExecution')
+            continue;
+        // `contextRows`, when given, REPLACE `context` at emission (typed-node.ts), so only
+        // the rows are the task's context then; a record field beside them is not emitted.
+        const ctx = {};
+        if (n.contextRows)
+            for (const row of n.contextRows)
+                ctx[row.name] = row.value ?? row.body ?? '';
+        else
+            Object.assign(ctx, n.context);
+        const where = n.id;
+        const key = text(ctx['connectorKey']) ?? '<connector-key>';
+        // 1. A catalog placeholder: `N/A` from a generic row, or a template's `<…>`.
+        for (const field of INTSVC_IDENTITY) {
+            const v = text(ctx[field]);
+            if (v === undefined)
+                continue;
+            const placeholder = /^n\/a$/i.test(v.trim()) || /^(<|&lt;)[^<>]*(>|&gt;)$/.test(v.trim());
+            if (!placeholder)
+                continue;
+            diags.push({
+                level: 'error',
+                code: 'INTSVC_CATALOG_PLACEHOLDER',
+                message: `"${n.id}" (Intsvc.ActivityExecution) has ${field}="${v}", which dispatches to nothing. ` +
+                    (/^n\/a$/i.test(v.trim())
+                        ? `"N/A" is what \`uip is activities list ${key}\` prints on a GENERIC record verb (Create/Retrieve/Update/Delete Record), ` +
+                            `whose object is chosen at design time: set objectName to an object from \`uip is resources list ${key} --connection-id <id>\`, ` +
+                            `method to that verb's HTTP method, and path from \`uip is resources describe ${key} <object> --operation <Verb> --connection-id <id>\`. ` +
+                            `For a curated activity, objectName and method are the row's ObjectName and MethodName.`
+                        : `Replace the placeholder with the catalog's value (\`uip is activities list ${key} --output json\`: Name → operation, ObjectName → objectName, MethodName → method; ` +
+                            `\`uip is resources describe\` → path).`) +
+                    ` Or let the library write the task: \`uip maestro registry prepare ${key} --action <name>\` then \`.connector()\`.`,
+                where,
+            });
+        }
+        // 2. `method` is the catalog's closed vocabulary.
+        const method = text(ctx['method']);
+        // An empty one is EMPTY_REQUIRED_FIELD's (the registry marks it required), as for `operation`.
+        if (method !== undefined && method.trim() !== '' && !expr(method) && !/^n\/a$/i.test(method.trim()) && !/^(<|&lt;)/.test(method.trim()) && !INTSVC_METHODS.has(method.trim())) {
+            diags.push({
+                level: 'error',
+                code: 'INTSVC_METHOD_UNKNOWN',
+                message: `"${n.id}" (Intsvc.ActivityExecution) has method="${method}"; the activity catalog's MethodName is one of ` +
+                    `${[...INTSVC_METHODS].join(', ')}` +
+                    (INTSVC_METHODS.has(method.trim().toUpperCase()) ? ` — write it in upper case: "${method.trim().toUpperCase()}".` : `. Read it from \`uip is activities list ${key} --output json\` (MethodName).`),
+                where,
+            });
+        }
+        // 3. `operation` is the catalog activity's Name (or the CRUD verb hand-written exports use): an identifier.
+        const operation = text(ctx['operation']);
+        if (operation !== undefined && operation.trim() !== '' && !expr(operation) && !/^n\/a$/i.test(operation.trim()) && !/^(<|&lt;)/.test(operation.trim())
+            && !/^[A-Za-z][A-Za-z0-9_]*$/.test(operation.trim())) {
+            diags.push({
+                level: 'error',
+                code: 'INTSVC_OPERATION_NOT_IDENTIFIER',
+                message: `"${n.id}" (Intsvc.ActivityExecution) has operation="${operation}"; the registry defines it as the activity catalog's Name ` +
+                    `(\`uip is activities list ${key}\`: CreateTestSet, QueryEntityRecordsCurated) — an identifier, not a REST slug or a label.`,
+                where,
+            });
+        }
+        // 4. `objectName` spelled as a REST path: validates, dispatches to nothing. Only a
+        // `/` says so — `::` is in curated ObjectNames too (`v2::webSearch`, airdk).
+        const objectName = text(ctx['objectName']);
+        if (objectName !== undefined && !expr(objectName) && objectName.includes('/')) {
+            diags.push({
+                level: 'warning',
+                code: 'INTSVC_OBJECT_NAME_SLUG',
+                message: `"${n.id}" (Intsvc.ActivityExecution) has objectName="${objectName}", which reads as a REST path, not an object. The platform matches ` +
+                    `on the catalog's ObjectName (\`uip is activities list ${key}\`: TestSet, UploadAttachment, v2::webSearch); a path validates and then dispatches to nothing.`,
+                where,
+            });
+        }
+        // 5. The path's placeholders each need a `target: 'path'` input row of that name.
+        const path = text(ctx['path']);
+        if (path !== undefined && !expr(path)) {
+            if (!path.startsWith('/')) {
+                diags.push({
+                    level: 'warning',
+                    code: 'INTSVC_PATH_NOT_ABSOLUTE',
+                    message: `"${n.id}" (Intsvc.ActivityExecution) has path="${path}"; the request path \`is resources describe\` returns starts with "/" (e.g. "/v2/{ProjectId}/testsets").`,
+                    where,
+                });
+            }
+            const params = [...path.matchAll(/\{([^{}]+)\}/g)].map((m) => m[1]);
+            if (params.length > 0) {
+                // Bound by a row of that name targeting the path, or by a path AGGREGATE —
+                // `inputs: { pathParameters: { ProjectId } }` emits one `target="pathParameters"`
+                // row holding every placeholder (an expression-valued aggregate binds them all).
+                const PATH_TARGETS = new Set(['path', 'pathvariable', 'pathparameters']);
+                const bound = new Set();
+                let aggregateExpression = false;
+                const aggregate = (value) => {
+                    if (expr(value))
+                        aggregateExpression = true;
+                    else if (value && typeof value === 'object')
+                        for (const k of Object.keys(value))
+                            bound.add(k);
+                };
+                for (const r of n.inputRows ?? []) {
+                    const target = (r.target ?? '').toLowerCase();
+                    if (target === 'pathparameters' || target === 'pathvariable' || PATH_TARGETS.has(r.name.toLowerCase()))
+                        aggregate(r.body ?? r.value);
+                    if (PATH_TARGETS.has(target))
+                        bound.add(r.name);
+                }
+                if (!n.inputRows)
+                    for (const key of ['pathParameters', 'pathVariable'])
+                        if (key in (n.inputs ?? {}))
+                            aggregate(n.inputs[key]);
+                const unbound = aggregateExpression ? [] : params.filter((p) => !bound.has(p));
+                if (unbound.length > 0) {
+                    diags.push({
+                        level: 'warning',
+                        code: 'INTSVC_PATH_PARAM_UNBOUND',
+                        message: `"${n.id}" (Intsvc.ActivityExecution) path "${path}" has placeholder(s) ${unbound.map((p) => `{${p}}`).join(', ')} with no input row ` +
+                            `of that name targeting the path. Write \`inputs: { pathParameters: { ${unbound[0]}: '…' } }\` (the other fields stay ` +
+                            `beside it), or an \`inputRows\` row \`{ name: '${unbound[0]}', type: 'string', value: '…', target: 'path' }\` — a bare ` +
+                            `\`inputs: { ${unbound[0]} }\` lands in the body and leaves the placeholder unfilled.`,
+                        where,
+                    });
+                }
+            }
+        }
+        // 6. The connection and folder rows: binding references to declared Connection bindings.
+        const bindingRow = (field, attribute) => {
+            const v = text(ctx[field]);
+            if (v === undefined || v.trim() === '')
+                return;
+            if (!v.startsWith('=bindings.')) {
+                // A literal gets the binding to declare with that value; any other
+                // expression (`=vars.connId`) is told what refresh needs instead — a
+                // connection is resolved from a root binding, never computed at run time.
+                const label = field === 'connection' ? 'conn' : 'folder';
+                const refusal = `\`uip maestro bpmn refresh\` refuses it with \`${field} must reference a root binding as "=bindings.<id>"\``;
+                diags.push({
+                    level: 'error',
+                    code: 'INTSVC_CONNECTION_NOT_BINDING',
+                    message: expr(v)
+                        ? `"${n.id}" (Intsvc.ActivityExecution) has ${field}="${v}", an expression; ${refusal}. A ${field} is resolved from a root binding, ` +
+                            `not computed: declare \`.binding('${label}', { resource: 'Connection', propertyAttribute: '${attribute}', value: '<${field === 'connection' ? 'connection id' : 'folder key'}>' })\` ` +
+                            `and write ${field}: '=bindings.${label}'.`
+                        : `"${n.id}" (Intsvc.ActivityExecution) has ${field}="${v}", a literal; ${refusal}. Declare ` +
+                            `\`.binding('${label}', { resource: 'Connection', propertyAttribute: '${attribute}', value: '${v}' })\` ` +
+                            `and write ${field}: '=bindings.${label}'.`,
+                    where,
+                });
+                return;
+            }
+            const id = v.slice('=bindings.'.length);
+            const b = declared.get(id);
+            if (!b) {
+                diags.push({
+                    level: 'error',
+                    code: 'INTSVC_BINDING_UNDECLARED',
+                    message: `"${n.id}" (Intsvc.ActivityExecution) reads ${field}="${v}" but the process declares no binding "${id}" ` +
+                        `(\`uip maestro bpmn validate\` reports MISSING_BINDING). Declare it at the root: ` +
+                        `\`.binding('${id}', { resource: 'Connection', propertyAttribute: '${attribute}', value: '<${field === 'connection' ? 'connection id' : 'folder key'}>' })\`` +
+                        (field === 'folderKey' ? ' — keyed by its connection; the builder pairs it with the connection this task reads.' : '.'),
+                    where,
+                });
+                return;
+            }
+            const attr = b.propertyAttribute;
+            const resource = b.resource;
+            if (attr.toLowerCase() !== attribute.toLowerCase() || resource.toLowerCase() !== 'connection') {
+                diags.push({
+                    level: 'error',
+                    code: 'INTSVC_BINDING_MISMATCH',
+                    message: `"${n.id}" (Intsvc.ActivityExecution) reads ${field}="${v}", but binding "${id}" is resource "${resource}" / ` +
+                        `propertyAttribute "${attr}"; the ${field} row needs resource "Connection" / propertyAttribute "${attribute}".`,
+                    where,
+                });
+            }
+        };
+        bindingRow('connection', 'ConnectionId');
+        bindingRow('folderKey', 'folderKey');
+        if (text(ctx['connection']) === undefined) {
+            diags.push({
+                level: 'warning',
+                code: 'INTSVC_CONNECTION_MISSING',
+                message: `"${n.id}" (Intsvc.ActivityExecution) names no connection. The registry says to omit \`connection\` and \`folderKey\` only ` +
+                    `when the activity uses none; a connector activity almost always does. Declare a Connection binding and read it as ` +
+                    `connection: '=bindings.<id>' (\`uip is connections list ${key} --all-folders --output json\` lists the ids).`,
+                where,
+            });
+        }
+    }
+}
 /**
  * Every `id` in the document must be unique — including across KINDS.
  *

package/dist/bpmn/connector-lift-verify.d.ts

@@ -0,0 +1,32 @@
+import type { Library } from '../core/library.js';
+import type { ConnectorLiftSummary } from './decompile.js';
+type Moddle = any;
+/** The outcome of verifying one decompile's lifted connector tasks. */
+export interface ConnectorLiftVerdict {
+    /** Lifted elements whose recompiled task differs beyond the regenerated fields, with what differed. */
+    failed: Map<string, string>;
+}
+/**
+ * The part of a connector task that a lift must reproduce, as one comparable
+ * string. Row order does not matter (rows are sorted by name); a scalar row's
+ * `type` attribute and the response row's schema body do not either.
+ */
+export declare function canonicalConnectorTask(el: Moddle): string;
+/**
+ * Whether each lifted connector task recompiles to the task the file carried, the
+ * regenerated fields aside.
+ *
+ * Each call is compiled ON ITS OWN — the decompiled preamble (bindings, variables,
+ * schemas), a start event, the one `.connector()` line, an end event — rather than
+ * the whole process, so a lift the library refuses (a body field it does not carry)
+ * is the only one refused, and a process with no other way to compile (a start event
+ * missing its connection, say) still gets its connector tasks verified.
+ *
+ * @param originalXml - The `.bpmn` that was decompiled.
+ * @param summary - What the lift did: the ids, the calls, and the preamble to compile them under.
+ * @param sdkEntry - Absolute path of the `bpmn-sdk.js` to build against.
+ * @param library - The connector library the lift named operations through.
+ * @returns The lifted elements that did not come back the same, each with the reason.
+ */
+export declare function verifyConnectorLifts(originalXml: string, summary: Pick<ConnectorLiftSummary, 'lifted' | 'calls' | 'preamble'>, sdkEntry: string, library: Library): Promise<ConnectorLiftVerdict>;
+export {};

package/dist/bpmn/connector-lift-verify.js

@@ -0,0 +1,220 @@
+/**
+ * connector-lift-verify — the check that makes decompile's connector lift safe to write.
+ *
+ * A connector task written back as `.connector(key, action, inputs, …)` is NOT
+ * byte-identical on recompile, by design: the SDK regenerates what the canvas wrote
+ * and the file carried — the `metadata` blob (`designTimeMetadata`, `metadataState`,
+ * `telemetryData`), the `operation` verb, the `type` of each scalar row, the response
+ * row's schema body, `activityConfigurationVersion`. Everything else about the task
+ * must come back exactly: the element and its name, every other context row, every
+ * payload row's name, target and value, every output row's name, source and variable.
+ * This builds the lifted source, compiles it with the same library, and compares each
+ * lifted element against the original under exactly that list — so a lift that lost
+ * an input, picked the wrong action or renamed a variable is refused, element by
+ * element, and `decompile-cli` writes those verbatim with the reason.
+ *
+ * Same stance as `lift-verify.ts` for `--style nested`: the lift's rules are an
+ * argument, this is the measurement.
+ */
+import BpmnModdle from 'bpmn-moddle';
+import { createRequire } from 'node:module';
+import { buildSource } from './lift-verify.js';
+import { serialize } from './serialize.js';
+const require = createRequire(import.meta.url);
+const uipathDescriptor = require('./uipath-moddle.v1.json');
+/**
+ * Context rows the SDK regenerates from the library on compile; not compared.
+ * `activity` is the op identity the SDK writes beside `objectName` (the platform
+ * validator requires it, exports omit it) and `operation` the library's verb where
+ * the canvas writes the curated name; `metadata` is the canvas blob; the
+ * configuration version is #1287's stamp.
+ */
+const REGENERATED_CONTEXT = new Set(['metadata', 'operation', 'activity', 'activityConfigurationVersion']);
+function stableJson(value) {
+    return JSON.stringify(value, (_key, v) => v && typeof v === 'object' && !Array.isArray(v)
+        ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, v[k]]))
+        : v);
+}
+/** A row body as a comparable string: parsed JSON when it is JSON, the text otherwise. */
+function bodyText(body) {
+    if (body === undefined || body === null)
+        return undefined;
+    const text = String(body);
+    try {
+        return stableJson(JSON.parse(text));
+    }
+    catch {
+        return text;
+    }
+}
+function payloadOf(el) {
+    return (el.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Activity');
+}
+/**
+ * The part of a connector task that a lift must reproduce, as one comparable
+ * string. Row order does not matter (rows are sorted by name); a scalar row's
+ * `type` attribute and the response row's schema body do not either.
+ */
+export function canonicalConnectorTask(el) {
+    const payload = payloadOf(el);
+    const context = Object.fromEntries((payload?.context?.input ?? [])
+        .filter((r) => !REGENERATED_CONTEXT.has(r.name))
+        .map((r) => [r.name, r.body !== undefined ? bodyText(r.body) : (r.value ?? '')]));
+    const inputs = (payload?.input ?? [])
+        .map((r) => ({ name: r.name, target: r.target ?? null, value: r.body !== undefined ? bodyText(r.body) : String(r.value ?? '') }))
+        // `.connector()` always writes the request body row, `{}` when nothing fills it;
+        // an export writes none for an operation with no body. The same request either way.
+        .filter((r) => !(r.name === 'body' && r.target === 'body' && r.value === '{}'))
+        .sort((a, b) => String(a.name).localeCompare(String(b.name)));
+    const outputs = (payload?.output ?? [])
+        .map((r) => ({ name: r.name, source: r.source ?? null, var: r.var ?? null, custom: r.custom ?? null, target: r.target ?? null }))
+        .sort((a, b) => String(a.name).localeCompare(String(b.name)) || String(a.var).localeCompare(String(b.var)));
+    // The activity's other extensions — tags, retry, error mapping — and its loop
+    // characteristics: options `.connector()` takes, so a lift that lost one is refused.
+    const extensions = (el.extensionElements?.values ?? [])
+        .filter((x) => x.$type !== 'uipath:Activity' && x.$type !== 'uipath:EntryPointId')
+        .map(plain)
+        .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+    return stableJson({
+        element: el.$type,
+        name: el.name ?? null,
+        type: payload?.type?.value ?? null,
+        skipCondition: payload?.skipCondition ?? null,
+        context,
+        inputs,
+        outputs,
+        extensions,
+        loop: el.loopCharacteristics ? plain(el.loopCharacteristics) : null,
+    });
+}
+/** A moddle element as plain data: its own properties, recursively, without the `$`-prefixed bookkeeping. */
+function plain(value) {
+    if (Array.isArray(value))
+        return value.map(plain);
+    if (value && typeof value === 'object') {
+        const out = { $type: value.$type };
+        for (const [k, v] of Object.entries(value)) {
+            if (k.startsWith('$'))
+                continue;
+            out[k] = plain(v);
+        }
+        return out;
+    }
+    return value;
+}
+/**
+ * Every variable id the document declares or a node's output row writes. An isolated
+ * call still reads the process's variables in its expressions (`vars.response11[0].Id`),
+ * and the build's expression check refuses a read of an undeclared one — so the ones
+ * the preamble does not already declare are stubbed into the verification source.
+ */
+function declaredVariableIds(root) {
+    const ids = new Set();
+    const fromExt = (owner) => {
+        for (const ext of owner.extensionElements?.values ?? []) {
+            if (ext.$type !== 'uipath:Variables')
+                continue;
+            for (const list of [ext.input, ext.inputOutput, ext.output])
+                for (const v of list ?? [])
+                    if (v.id)
+                        ids.add(v.id);
+        }
+    };
+    const walk = (container) => {
+        fromExt(container);
+        for (const el of container.flowElements ?? []) {
+            fromExt(el);
+            for (const ext of el.extensionElements?.values ?? [])
+                for (const row of ext.output ?? [])
+                    if (row.var)
+                        ids.add(row.var);
+            if (el.$type === 'bpmn:SubProcess')
+                walk(el);
+        }
+    };
+    for (const r of root.rootElements ?? []) {
+        if (r.$type === 'bpmn:Process')
+            walk(r);
+        else
+            fromExt(r);
+    }
+    return [...ids];
+}
+function elementsById(root) {
+    const out = new Map();
+    const walk = (container) => {
+        for (const el of container.flowElements ?? []) {
+            out.set(el.id, el);
+            if (el.$type === 'bpmn:SubProcess')
+                walk(el);
+        }
+    };
+    for (const r of root.rootElements ?? [])
+        if (r.$type === 'bpmn:Process')
+            walk(r);
+    return out;
+}
+/**
+ * Whether each lifted connector task recompiles to the task the file carried, the
+ * regenerated fields aside.
+ *
+ * Each call is compiled ON ITS OWN — the decompiled preamble (bindings, variables,
+ * schemas), a start event, the one `.connector()` line, an end event — rather than
+ * the whole process, so a lift the library refuses (a body field it does not carry)
+ * is the only one refused, and a process with no other way to compile (a start event
+ * missing its connection, say) still gets its connector tasks verified.
+ *
+ * @param originalXml - The `.bpmn` that was decompiled.
+ * @param summary - What the lift did: the ids, the calls, and the preamble to compile them under.
+ * @param sdkEntry - Absolute path of the `bpmn-sdk.js` to build against.
+ * @param library - The connector library the lift named operations through.
+ * @returns The lifted elements that did not come back the same, each with the reason.
+ */
+export async function verifyConnectorLifts(originalXml, summary, sdkEntry, library) {
+    const failed = new Map();
+    if (summary.lifted.length === 0)
+        return { failed };
+    const moddle = new BpmnModdle({ uipath: uipathDescriptor });
+    const original = (await moddle.fromXML(originalXml, { lax: true })).rootElement;
+    const before = elementsById(original);
+    // Declared by the preamble means a `.var()` call or a `.vars([{ id, … }])` entry — not
+    // a mention in `.preserve({ variableOrder })`, which lists derived declarations the
+    // preamble does not write.
+    const declares = (v) => {
+        const q = JSON.stringify(v).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return new RegExp(`\\.var\\(${q}|\\{ id: ${q}, (?:name|type|direction)`).test(summary.preamble);
+    };
+    const stubs = declaredVariableIds(original)
+        .filter((v) => !declares(v))
+        .map((v) => `  .var(${JSON.stringify(v)}, "object")`)
+        .join('\n');
+    for (const id of summary.lifted) {
+        const call = summary.calls.get(id);
+        const a = before.get(id);
+        if (!call || !a) {
+            failed.set(id, call ? 'not in the original' : 'the lift recorded no call for it');
+            continue;
+        }
+        const source = `${summary.preamble}\n${stubs ? `${stubs}\n` : ''}  .startEvent("verify_start")\n  ${call}\n  .endEvent("verify_end")\n` +
+            `  .sequenceFlow("verify_start", ${JSON.stringify(id)})\n  .sequenceFlow(${JSON.stringify(id)}, "verify_end")\n  .build();\n`;
+        let recompiled;
+        try {
+            recompiled = await serialize(await buildSource(source, sdkEntry), { library });
+        }
+        catch (e) {
+            // The first three lines: the refusal and, for a build error, the diagnostic under it.
+            failed.set(id, `the lifted call did not compile: ${e.message.split('\n').slice(0, 3).join(' ').trim()}`);
+            continue;
+        }
+        const b = elementsById((await moddle.fromXML(recompiled, { lax: true })).rootElement).get(id);
+        if (!b) {
+            failed.set(id, 'not in the recompiled process');
+            continue;
+        }
+        const ca = canonicalConnectorTask(a);
+        const cb = canonicalConnectorTask(b);
+        if (ca !== cb)
+            failed.set(id, `recompiled task differs:\n    was ${ca}\n    now ${cb}`);
+    }
+    return { failed };
+}

package/dist/bpmn/connector.d.ts

@@ -33,6 +33,18 @@ export interface ConnectorCtx {
     library?: Library;
     bindings?: Bindings;
     bindingSink: Map<string, Record<string, unknown>>;
+    /**
+     * The bindings the author declared in source (`.binding()`), by id. A connector
+     * naming one of them takes its `resourceKey` and `default` from the declaration,
+     * the way it takes them from a bindings.json entry: without this, a `.binding('c',
+     * { value: '<guid>' })` paired with `connection: 'c'` wrote `resourceKey="c"` into
+     * the task's context — the id where every real export writes the connection's key.
+     */
+    declaredBindings?: ReadonlyMap<string, {
+        name?: string;
+        default?: string;
+        resourceKey?: string;
+    }>;
     /**
      * Declared Maestro `type` for a variable id, for typing an author-mapped output
      * row. Optional so the connector emitter (which writes its own rows) is

package/dist/bpmn/connector.js

@@ -116,6 +116,21 @@ export function createConnectorTask(ctx, n) {
                     },
                 }),
             }),
+            // Extra mapped rows — `outputs: { <var>: '=response.<field>' }`, or the object
+            // form naming and typing the row — after the two the library implies, where
+            // every export puts the rows an author added in the designer.
+            ...Object.entries(n.outputs ?? {}).map(([varId, spec]) => {
+                const row = typeof spec === 'string' ? { source: spec } : spec;
+                const props = {
+                    name: row.name ?? varId,
+                    type: row.type ?? ctx.varTypeOf?.(varId) ?? 'string',
+                    source: row.source,
+                    var: varId,
+                };
+                if (row.custom)
+                    props.custom = true;
+                return m.create('uipath:Output', props);
+            }),
         ],
     });
     return m.create('bpmn:SendTask', {
@@ -180,7 +195,7 @@ export function connectorBindingRef(ctx, name, resource, propertyAttribute, disp
 function bindingRef(ctx, name, resource, propertyAttribute, displayName, companionKey) {
     if (!name)
         return undefined;
-    const entry = ctx.bindings?.entry(name);
+    const entry = (ctx.bindings?.entry(name) ?? ctx.declaredBindings?.get(name));
     const id = entry?.id ?? name;
     // `default` is the deploy-time VALUE the runtime resolves, not the author's symbolic
     // name for the binding. An entry that states only a `resourceKey` — which is what a