@uipath/maestro-builder-sdk 6.37.0 → 6.39.0

package/dist/bpmn/declared-vars.js

@@ -15,7 +15,7 @@ import { typedNodeAdditionalOutputVars, typedNodeOutputVar } from './typed-node.
  * @internal
  */
 export function connectorOutputVars(n) {
-    return { response: n.outputVar ?? `${n.id}_response`, error: `${n.id}_Error` };
+    return { response: n.outputVar ?? `${n.id}_response`, error: n.errorVar ?? `${n.id}_Error` };
 }
 /**
  * The variables a typed node writes — the ONE definition of that set.
@@ -54,7 +54,7 @@ export function typedNodeDeclaredVars(n) {
 export function nodeDeclaredVars(n) {
     if (n.kind === 'connector') {
         const { response, error } = connectorOutputVars(n);
-        return [response, error];
+        return [response, error, ...Object.keys(n.outputs ?? {})];
     }
     if (n.kind === 'typed')
         return typedNodeDeclaredVars(n);

package/dist/bpmn/decompile-cli.js

@@ -4,6 +4,15 @@
  *
  * Usage:
  *   node --experimental-strip-types decompile-cli.js <Name.bpmn> [-o Name.bpmn.ts] [--import <specifier>] [--style explicit|nested] [--keep-flow-ids] [--keep-unused-bindings]
+ *       [--library <library-json dir>] [--connectors-local <overlay dir>] [--connectors lift|verbatim]
+ *
+ * `--connectors lift` (the default when a library opens — `--library`, else the
+ * cache `registry pull` filled) writes a connector task the library can name as
+ * `.connector(key, action, inputs, { connection, folder, … })`, and verifies each
+ * lift by recompiling: a task that does not come back the same, the fields the
+ * SDK regenerates aside, is written verbatim with the reason. `--connectors
+ * verbatim` keeps every task as the file spells it, which is also what happens
+ * with no library at all.
  *
  * The reverse of compile-cli: reads a `.bpmn` and emits builder source whose
  * default export re-serializes to the same XML. `--import` sets the module
@@ -29,6 +38,8 @@ import { defaultSourceOut, writeSource } from '../workdir.js';
 import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { decompile } from './decompile.js';
 import { sameGraph } from './lift-verify.js';
+import { verifyConnectorLifts } from './connector-lift-verify.js';
+import { openCliLibrary } from '../core/cli-library.js';
 import { BPMN_IMPORT } from '../package-name.js';
 import { fileURLToPath } from 'node:url';
 /**
@@ -62,9 +73,14 @@ export async function run(argv) {
             return 2;
         }
     }
+    const connectors = flagValue(argv, '--connectors') ?? 'lift';
+    if (connectors !== 'lift' && connectors !== 'verbatim') {
+        console.error(`decompile: --connectors must be lift or verbatim, not "${connectors}"`);
+        return 2;
+    }
     const keepFlowIds = argv.includes('--keep-flow-ids');
     const keepUnusedBindings = argv.includes('--keep-unused-bindings');
-    const flags = new Set(['-o', '--import', '--style']);
+    const flags = new Set(['-o', '--import', '--style', '--library', '--connectors-local', '--connectors']);
     const bare = new Set(['--keep-flow-ids', '--keep-unused-bindings']);
     const input = argv.find((a, i) => !bare.has(a) && !flags.has(a) && !flags.has(argv[i - 1]));
     if (!input) {
@@ -74,8 +90,34 @@ export async function run(argv) {
     const xml = readFileSync(input, 'utf8');
     const importSpecifier = flagValue(argv, '--import') ?? BPMN_IMPORT;
     let pruned = [];
-    const base0 = { importSpecifier, keepUnusedBindings, onPrune: (ids) => (pruned = ids) };
-    let source = await decompile(xml, base0);
+    // The connector lift: name each connector task through the library, then keep only
+    // the lifts that verify. One decompile to plan, one verify, and — only when a lift
+    // was refused — one more decompile with those tasks pinned verbatim. The pinned set
+    // then rides into the nested-style passes below, so the flat and nested sources the
+    // nested verify compares make the same connector decisions.
+    const library = connectors === 'lift' ? openCliLibrary(argv) : undefined;
+    const sdkEntry = fileURLToPath(new URL('./bpmn-sdk.js', import.meta.url));
+    let connectorSummary;
+    let verbatimConnectors = new Set();
+    const base0 = {
+        importSpecifier,
+        keepUnusedBindings,
+        onPrune: (ids) => (pruned = ids),
+        ...(library ? { library, connectors: 'lift' } : {}),
+        onConnectorLift: (s) => (connectorSummary = s),
+    };
+    let source = await decompile(xml, { ...base0, verbatimConnectors });
+    if (library && connectorSummary && connectorSummary.lifted.length > 0) {
+        const verdict = await verifyConnectorLifts(xml, connectorSummary, sdkEntry, library);
+        if (verdict.failed.size > 0) {
+            verbatimConnectors = new Set(verdict.failed.keys());
+            source = await decompile(xml, { ...base0, verbatimConnectors });
+            // The summary from the second pass says "did not verify"; carry the measured reason.
+            if (connectorSummary) {
+                connectorSummary.verbatim = connectorSummary.verbatim.map((v) => ({ id: v.id, reason: verdict.failed.get(v.id) ?? v.reason }));
+            }
+        }
+    }
     let lifted;
     let fallback;
     if (style === 'nested') {
@@ -83,10 +125,11 @@ export async function run(argv) {
         // package's own entry, whatever specifier the written file carries — the check is
         // about the graph, not about module resolution. The flow ids the lift renamed are
         // the one sanctioned difference.
-        const sdkEntry = fileURLToPath(new URL('./bpmn-sdk.js', import.meta.url));
         for (const sequenceMode of [true, false]) {
             let summary;
-            const nested = await decompile(xml, { ...base0, style: 'nested', relabelFlows: !keepFlowIds, sequenceMode, onLift: (s) => (summary = s) });
+            const nested = await decompile(xml, {
+                ...base0, verbatimConnectors, style: 'nested', relabelFlows: !keepFlowIds, sequenceMode, onLift: (s) => (summary = s),
+            });
             const renamed = new Map((summary?.renamedFlows ?? []).map((r) => [r.from, r.to]));
             const verdict = await sameGraph(source, nested, sdkEntry, renamed);
             if (verdict.same) {
@@ -107,6 +150,15 @@ export async function run(argv) {
         console.log(`decompile: dropped ${pruned.length} binding(s) nothing references — ${pruned.slice(0, 8).join(', ')}` +
             `${pruned.length > 8 ? `, and ${pruned.length - 8} more` : ''}. Pass --keep-unused-bindings to echo them.`);
     }
+    if (connectorSummary && (connectorSummary.lifted.length || connectorSummary.verbatim.length)) {
+        const kept = connectorSummary.verbatim.length
+            ? `; verbatim: ${connectorSummary.verbatim.map((v) => `${v.id} (${v.reason.split('\n')[0]})`).join('; ')}`
+            : '';
+        console.log(`decompile: connectors — lifted ${connectorSummary.lifted.length} to .connector()${kept}`);
+    }
+    else if (connectors === 'lift' && !library) {
+        console.log('decompile: no connector library found, connector tasks written verbatim — pass --library <library-json dir> to lift them');
+    }
     if (lifted) {
         const flat = lifted.leftFlat.length ? `; left flat: ${lifted.leftFlat.map((r) => `${r.id} (${r.reason})`).join('; ')}` : '';
         const renamed = lifted.renamedFlows.length
@@ -118,7 +170,17 @@ export async function run(argv) {
     else if (fallback) {
         console.log(`decompile: --style nested could not be verified, wrote the flat form — ${fallback}`);
     }
-    reportResult({ path: resolve(out), style: lifted ? 'nested' : 'explicit', ...(lifted ? { lifted } : {}), ...(fallback ? { fallback } : {}) });
+    reportResult({
+        path: resolve(out),
+        style: lifted ? 'nested' : 'explicit',
+        ...(lifted ? { lifted } : {}),
+        ...(fallback ? { fallback } : {}),
+        // What the lift did, when a library was in play: the ids, not the preamble and
+        // calls the verifier consumed.
+        ...(library && connectorSummary && (connectorSummary.lifted.length || connectorSummary.verbatim.length)
+            ? { connectors: { lifted: connectorSummary.lifted, verbatim: connectorSummary.verbatim } }
+            : {}),
+    });
     return 0;
 }
 runWhenInvokedDirectly(import.meta.url, 'decompile', run);

package/dist/bpmn/decompile.d.ts

@@ -1,7 +1,31 @@
+import type { Library } from '../core/library.js';
 /** Options for {@link decompile}. */
 export interface BpmnDecompileOptions {
     /** Module specifier for the emitted `import { bpmn }` line. */
     importSpecifier?: string;
+    /**
+     * The connector library. With one, an `Intsvc.ActivityExecution` the library can
+     * name comes back as `.connector(key, action, inputs, { connection, folder, … })` —
+     * the call an author writes — instead of the verbatim `.activity()` form; see
+     * {@link BpmnDecompileOptions.connectors}. Without one, every connector task stays
+     * verbatim, as before.
+     */
+    library?: Library;
+    /**
+     * How a connector task is written back when a library is given. `'lift'` (the
+     * default) names the operation through the library and drops what the SDK
+     * regenerates on compile — the `metadata` blob the canvas writes
+     * (`designTimeMetadata`, `metadataState`), the CRUD `operation` verb, row types,
+     * the response row's schema body. `'verbatim'` keeps every row as the file spells
+     * it. A lift is best effort by construction and safe only with the check
+     * `decompile-cli` runs (`verifyConnectorLifts`): the lifted call must compile to the
+     * same task, those regenerated fields aside, or the element is written verbatim.
+     */
+    connectors?: 'lift' | 'verbatim';
+    /** Connector tasks to write verbatim whatever `connectors` says — the ones a verify refused. */
+    verbatimConnectors?: ReadonlySet<string>;
+    /** Called with what the connector lift did, after decompiling. */
+    onConnectorLift?: (summary: ConnectorLiftSummary) => void;
     /**
      * `'explicit'` (the default) renders the graph flat: one call per element, one
      * `.sequenceFlow()` per edge. `'nested'` LIFTS the regions that the builder's
@@ -103,4 +127,23 @@ export interface LiftSummary {
     /** Whether the top level was written in `.flowMode('sequence')`. */
     sequence: boolean;
 }
+/** What the connector lift did on one decompile — see `BpmnDecompileOptions.connectors`. */
+export interface ConnectorLiftSummary {
+    /** Element ids written as `.connector()`. */
+    lifted: string[];
+    /** Connector tasks written verbatim, each with the reason. */
+    verbatim: Array<{
+        id: string;
+        reason: string;
+    }>;
+    /**
+     * The source up to the first element — the import, the process call, its metadata,
+     * schemas, bindings and variables — so a verifier can compile one lifted call on its
+     * own (`verifyConnectorLifts`) instead of the whole process, where one refused lift
+     * would take every other down with it.
+     */
+    preamble: string;
+    /** Each lifted call's source line, by element id. */
+    calls: Map<string, string>;
+}
 export declare function decompile(xml: string, options?: BpmnDecompileOptions): Promise<string>;

package/dist/bpmn/decompile.js

@@ -244,7 +244,225 @@ function localName(type) {
     const local = type.split(':')[1] ?? type;
     return local.charAt(0).toLowerCase() + local.slice(1);
 }
+// The connector lift's state for one `decompile()` call. Planned in a pre-pass so the
+// variable block, which is written before any element, already knows which tasks come
+// back as `.connector()` — their declarations derive differently (`derivedVariableIds`).
+// The lift's per-decompile state. Module-level `let`s, reset at the top of `decompile()`
+// and read while it emits: nothing awaits between the reset and the last emit, and the
+// module is not re-entered, which is the invariant this relies on. A per-call context
+// object is the right shape if that ever changes.
+let runLibrary;
+let runLiftPlans = new Map();
+let runLiftSkipped = [];
+let runLiftCalls = new Map();
 /** The `uipath:*` payload element on an element, if it has one. */
+/** Context rows a connector task carries that `.connector()` writes itself, or that the lift reads. */
+const CONNECTOR_CONTEXT_ROWS = new Set([
+    'connectorKey', 'operation', 'objectName', 'method', 'path', 'connection', 'folderKey', 'resourceKey',
+    'metadata', 'activityConfigurationVersion', 'activity',
+]);
+/** Row targets `.connector()` can address — the library's parameter locations plus the body. */
+const CONNECTOR_ROW_TARGETS = new Set(['path', 'query', 'body', 'multipart', 'file']);
+/**
+ * Plan every connector task's lift in `container` (sub-processes included): the id →
+ * plan for the ones `.connector()` can express, and a reason for each one it cannot.
+ */
+function planConnectorLifts(container, skip) {
+    for (const el of container.flowElements ?? []) {
+        if (el.$type === 'bpmn:SubProcess')
+            planConnectorLifts(el, skip);
+        const payload = payloadOf(el);
+        if (!payload || extensionTypeOf(payload) !== 'Intsvc.ActivityExecution')
+            continue;
+        if (skip.has(el.id)) {
+            runLiftSkipped.push({ id: el.id, reason: 'the lift did not verify' });
+            continue;
+        }
+        const outcome = planConnectorLift(el, payload);
+        if (typeof outcome === 'string')
+            runLiftSkipped.push({ id: el.id, reason: outcome });
+        else
+            runLiftPlans.set(el.id, outcome);
+    }
+}
+/** The `=bindings.<id>` a context value references, or `undefined` for anything else. */
+function bindingIdOf(value) {
+    const m = typeof value === 'string' ? /^=bindings\.([A-Za-z0-9_]+)$/.exec(value) : null;
+    return m ? m[1] : undefined;
+}
+/**
+ * A row's value as `.connector()` takes it: an `=`-expression as the string it is;
+ * otherwise the literal, coerced to the type the library declares for the parameter,
+ * because the file writes every scalar row as `type="string"` (`value="false"`,
+ * `value="0"`) and the shared validator refuses a string where it declares a boolean
+ * or an integer.
+ */
+function liftedInputValue(raw, dataType) {
+    if (raw.startsWith('='))
+        return raw;
+    switch ((dataType ?? 'string').toLowerCase()) {
+        case 'boolean':
+            return raw === 'true' ? true : raw === 'false' ? false : raw;
+        case 'integer':
+        case 'number':
+            return raw.trim() !== '' && Number.isFinite(Number(raw)) ? Number(raw) : raw;
+        default:
+            return raw;
+    }
+}
+/**
+ * The `.connector()` call for one task, or why there is none. Everything here is a
+ * fact the lift needs and the generic form carries; what the SDK regenerates on
+ * compile is deliberately not read (see `BpmnDecompileOptions.connectors`).
+ */
+function planConnectorLift(el, payload) {
+    const library = runLibrary;
+    if (!library)
+        return 'no connector library';
+    const ctx = contextOf(payload);
+    const rows = payload.context?.input ?? [];
+    const unknownCtx = rows.map((r) => r.name).filter((n) => !CONNECTOR_CONTEXT_ROWS.has(n));
+    if (unknownCtx.length)
+        return `context row(s) .connector() does not write: ${unknownCtx.join(', ')}`;
+    if (rows.some((r) => r.required !== undefined || r.target !== undefined))
+        return 'a context row carries attributes the record form cannot';
+    const ctxString = (k) => (typeof ctx[k] === 'string' ? ctx[k] : undefined);
+    const connectorKey = ctxString('connectorKey');
+    if (!connectorKey)
+        return 'no connectorKey';
+    let identity;
+    try {
+        identity = library.identifyAction({
+            connectorKey,
+            httpMethod: ctxString('method'),
+            endpoint: ctxString('path'),
+            objectName: ctxString('objectName'),
+        });
+    }
+    catch (e) {
+        return `not in the library: ${e.message}`;
+    }
+    const connection = bindingIdOf(ctx.connection);
+    if (!connection)
+        return `connection is ${ctx.connection === undefined ? 'absent' : JSON.stringify(ctx.connection)}, not a =bindings.<id> reference`;
+    const folder = ctx.folderKey === undefined ? undefined : bindingIdOf(ctx.folderKey);
+    if (ctx.folderKey !== undefined && folder === undefined)
+        return `folderKey is ${JSON.stringify(ctx.folderKey)}, not a =bindings.<id> reference`;
+    let params;
+    let declared;
+    try {
+        const resolved = library.resolve(identity.key, identity.action, identity.version, identity.object);
+        params = new Map((resolved.entry.operation?.parameters ?? []).map((p) => [p.name, p.dataType]));
+        declared = new Set([...params.keys(), ...resolved.fields.map((f) => f.name)]);
+    }
+    catch (e) {
+        return `the library cannot resolve ${identity.key}/${identity.action}: ${e.message}`;
+    }
+    const inputs = {};
+    for (const row of payload.input ?? []) {
+        const target = row.target;
+        if (target === undefined || !CONNECTOR_ROW_TARGETS.has(target)) {
+            return `payload row "${row.name}" has ${target === undefined ? 'no target' : `target "${target}"`}`;
+        }
+        if (target === 'body') {
+            if (row.name !== 'body')
+                return `body row is named "${row.name}"`;
+            const body = safeJson(row.body ?? '{}');
+            if (!body || typeof body !== 'object' || Array.isArray(body))
+                return 'the body row is not a JSON object';
+            for (const [k, v] of Object.entries(body)) {
+                if (k in inputs)
+                    return `"${k}" appears both as a parameter row and in the body`;
+                // `.connector()` validates every input against the library, and a field the
+                // static library does not declare — an entity's own columns on a Data Fabric
+                // update, a form's fields — is refused until `registry prepare` loads it.
+                if (!declared.has(k) && !declared.has(k.split('.')[0])) {
+                    return `body field "${k}" is not in the library for ${identity.key}/${identity.action} (connection-specific; \`registry prepare\` loads it)`;
+                }
+                inputs[k] = v;
+            }
+            continue;
+        }
+        if (row.value === undefined)
+            return `payload row "${row.name}" carries no value attribute`;
+        if (row.name in inputs)
+            return `payload row "${row.name}" appears twice`;
+        inputs[row.name] = liftedInputValue(String(row.value), params.get(row.name));
+    }
+    let outputVar;
+    let errorVar;
+    const outputs = {};
+    for (const row of payload.output ?? []) {
+        const standard = (row.name === 'response' && row.source === '=response' && outputVar === undefined) ||
+            (row.name === 'Error' && row.source === '=Error' && errorVar === undefined);
+        // The two standard rows may carry a schema body — the SDK writes the library's
+        // response schema there, and regenerates it. Any other row's body, or a target or
+        // description on any row, is something `.connector()` cannot say.
+        if (row.target !== undefined || row.description !== undefined || (row.body !== undefined && !standard)) {
+            return `output row "${row.name}" carries attributes .connector() does not write`;
+        }
+        if (standard && row.name === 'response')
+            outputVar = row.var;
+        else if (standard)
+            errorVar = row.var;
+        else {
+            // An extra mapped row: `outputs` keys it by its variable, so one without a
+            // variable or a source, or a second row on the same variable, cannot be said.
+            if (typeof row.var !== 'string' || typeof row.source !== 'string')
+                return `output row "${row.name}" has no variable or no source`;
+            if (row.var in outputs)
+                return `two output rows write "${row.var}"`;
+            const plain = row.name === row.var && (row.type ?? 'string') === 'string' && !row.custom;
+            outputs[row.var] = plain
+                ? row.source
+                : { source: row.source, ...(row.name !== row.var ? { name: row.name } : {}), ...((row.type ?? 'string') !== 'string' ? { type: row.type } : {}), ...(row.custom ? { custom: true } : {}) };
+        }
+    }
+    return {
+        key: identity.key,
+        action: identity.action,
+        version: identity.version === '1.0.0' ? undefined : identity.version,
+        object: identity.object,
+        inputs,
+        connection,
+        folder,
+        outputVar: outputVar !== undefined && outputVar !== `${el.id}_response` ? outputVar : undefined,
+        errorVar: errorVar !== undefined && errorVar !== `${el.id}_Error` ? errorVar : undefined,
+        outputs: Object.keys(outputs).length ? outputs : undefined,
+    };
+}
+/** The `outputs` option of a lifted connector as source. */
+function connectorOutputsSource(outputs) {
+    return `{ ${Object.entries(outputs)
+        .map(([v, spec]) => `${key(v)}: ${typeof spec === 'string' ? tsText(spec) : opts([
+        ['source', tsText(spec.source)],
+        ['name', spec.name !== undefined ? tsText(spec.name) : undefined],
+        ['type', spec.type !== undefined ? tsText(spec.type) : undefined],
+        ['custom', spec.custom ? 'true' : undefined],
+    ])}`)
+        .join(', ')} }`;
+}
+/** A planned connector task as its `.connector()` call. */
+function emitConnectorLift(chain, el, payload, plan) {
+    const options = opts([
+        ['name', el.name !== undefined ? tsText(el.name) : undefined],
+        ['connection', tsText(plan.connection)],
+        ['folder', plan.folder !== undefined ? tsText(plan.folder) : undefined],
+        ['version', plan.version !== undefined ? tsText(plan.version) : undefined],
+        ['object', plan.object !== undefined ? tsText(plan.object) : undefined],
+        ['outputVar', plan.outputVar !== undefined ? tsText(plan.outputVar) : undefined],
+        ['errorVar', plan.errorVar !== undefined ? tsText(plan.errorVar) : undefined],
+        ['outputs', plan.outputs ? connectorOutputsSource(plan.outputs) : undefined],
+        ['skipCondition', payload.skipCondition !== undefined ? tsText(payload.skipCondition) : undefined],
+        ['tags', tagsOf(el)],
+        ['retry', emitRetry(retryOf(el))],
+        ['errorMapping', emitErrorMapping(errorMappingOf(el))],
+        ['loop', emitLoop(el)],
+    ]);
+    const call = `.connector(${tsText(el.id)}, ${tsText(plan.key)}, ${tsText(plan.action)}, ${record(plan.inputs) ?? '{}'}${optionalArg(options)})`;
+    runLiftCalls.set(el.id, call);
+    chain.add(call);
+}
 function payloadOf(el) {
     for (const ext of el.extensionElements?.values ?? []) {
         if (ext.$type === 'uipath:Activity' || ext.$type === 'uipath:Event' || ext.$type === 'uipath:Mapping')
@@ -1584,6 +1802,11 @@ function emitElement(chain, el, depth, indent) {
         if (kind === 'startEvent' && startEventDefinitionCarriesConfig(el)) {
             return emitTriggerStartEvent(chain, el, payload, type);
         }
+        // A connector task the library can name, planned in the pre-pass — see
+        // `BpmnDecompileOptions.connectors` for what the lift gives up and how it is checked.
+        const plan = runLiftPlans.get(el.id);
+        if (plan)
+            return emitConnectorLift(chain, el, payload, plan);
         return emitTypedNode(chain, el, payload, type);
     }
     switch (kind) {
@@ -1930,7 +2153,16 @@ export async function decompile(xml, options = {}) {
     // found none, so NOTHING was recognised as derived and every declaration was echoed
     // by hand. That was invisible — an echoed declaration takes the id before
     // `implicitNodeVars` can claim it, so the output was correct, just 112 lines of it.
-    const { ids: derived, folds } = derivedVariableIds(process, varsExt, host.rehome);
+    // The connector lift, planned first: the variable block below needs to know which
+    // tasks come back as `.connector()`, whose declarations derive as a connector's.
+    runLibrary = options.library;
+    runLiftPlans = new Map();
+    runLiftSkipped = [];
+    runLiftCalls = new Map();
+    if (options.library && (options.connectors ?? 'lift') === 'lift') {
+        planConnectorLifts(process, options.verbatimConnectors ?? new Set());
+    }
+    const { ids: derived, folds } = derivedVariableIds(process, varsExt, host.rehome, new Set(runLiftPlans.keys()));
     const schemaPlan = planSchemas([
         ...(varsExt?.input ?? []),
         ...(varsExt?.inputOutput ?? []),
@@ -1951,12 +2183,14 @@ export async function decompile(xml, options = {}) {
     // hand-editing". Only when something was actually folded: a document of explicit
     // `.var()` calls already states its order by their position, and the extra line would
     // be noise.
+    let preambleLines = 0;
     if (derived.size) {
         const ids = [...(varsExt?.input ?? []), ...(varsExt?.inputOutput ?? []), ...(varsExt?.output ?? [])].map((v) => v.id);
         chain.add(`.preserve({ variableOrder: [${ids.map(tsText).join(', ')}] })`);
     }
     try {
         emitVariablesInto(chain, host.container, host.rehome?.to ?? host.container.id, derived, host.rehome, schemaPlan, publicDeclarationScopeOf(process, host.rehome?.to ?? host.container.id));
+        preambleLines = chain.all.length;
         if (options.style === 'nested') {
             const sequence = options.sequenceMode ?? true;
             const summary = { handlers: 0, branches: 0, nets: 0, leftFlat: [], renamedFlows: [], sequence };
@@ -1975,11 +2209,18 @@ export async function decompile(xml, options = {}) {
     }
     finally {
         foldedVarSchemas = undefined;
+        runLibrary = undefined;
     }
     const importFrom = options.importSpecifier ?? './bpmn-sdk.js';
     const imported = ['bpmn', ...[...schemaPlan.imports].sort()].join(', ');
     const head = `import { ${imported} } from ${tsText(importFrom)};\n\nexport default bpmn(${tsText(process.id)})`;
     const name = process.name !== undefined ? `\n${indent}.name(${tsText(process.name)})` : '';
+    options.onConnectorLift?.({
+        lifted: [...runLiftPlans.keys()],
+        verbatim: runLiftSkipped,
+        preamble: `${host.note}${head}${name}\n${chain.all.slice(0, preambleLines).join('\n')}`,
+        calls: runLiftCalls,
+    });
     return `${host.note}${head}${name}\n${chain.all.join('\n')}\n${indent}.build();\n`;
 }
 /**
@@ -2010,7 +2251,9 @@ export async function decompile(xml, options = {}) {
  */
 function derivedVariableIds(process, varsExt, 
 /** The collaboration→process re-parenting, so `elementId` is compared post-move. */
-rehome) {
+rehome, 
+/** Connector tasks the lift writes as `.connector()`, whose declarations `implicitNodeVars` derives as a connector's. */
+lifted = new Set()) {
     // var id -> the declaration `implicitNodeVars` would derive for it
     const candidates = new Map();
     const walk = (container) => {
@@ -2042,6 +2285,20 @@ rehome) {
                 for (const row of payload.output ?? []) {
                     if (!row.var)
                         continue;
+                    // A lifted connector's two variables are claimed the way `.connector()` claims
+                    // them — `json`, named after the id, no schema — so a file's own `jsonSchema`
+                    // declaration with a body stays an explicit `.var()` rather than being folded
+                    // onto a row the lifted call no longer has.
+                    if (lifted.has(el.id)) {
+                        // A `.connector()` call has no row to fold a declaration's schema onto, so
+                        // a declaration that carries one stays explicit whatever its wire type —
+                        // `noFold` below — rather than vanishing into `foldedVarSchemas`, which the
+                        // lift never reads.
+                        // The wire type the row implies: `json` for the response and Error rows, the
+                        // row's own for an extra mapped row (`integer`), as `implicitNodeVars` declares.
+                        candidates.set(row.var, { owner: el.id, wire: rowDeclaration({ name: row.name, type: row.type }).wire, noFold: true });
+                        continue;
+                    }
                     // A script task's rows come back as `outputs` when that form reproduces
                     // them, and `implicitNodeVars` then derives their declarations from the
                     // keys: id as the name, that arm's own wire type. Rows that need spelling
@@ -2092,7 +2349,7 @@ rehome) {
         // against 28 rows, so without the fold almost every structured output stays an
         // explicit `.var()`.
         if (String(v.body ?? '') !== String(c.schema ?? '')) {
-            if (c.schema !== undefined || v.body === undefined)
+            if (c.schema !== undefined || v.body === undefined || c.noFold)
                 continue;
             folds.set(v.id, v.body);
         }

package/dist/bpmn/serialize.js

@@ -85,6 +85,7 @@ export async function serialize(built, opts = {}) {
         schemas: built.schemas,
         variableOrder: built.preservation?.variableOrder,
         bindingSink: new Map(),
+        declaredBindings: new Map(built.bindings.map((b) => [b.id, { name: b.name, default: b.default, resourceKey: b.resourceKey }])),
         varTypeOf: (varId) => authoredVarType.get(varId),
     };
     // `.name()` was accepted by the builder, stored on the built graph, and never
@@ -664,6 +665,14 @@ export function implicitNodeVars(nodes, declared) {
             const { response, error } = connectorOutputVars(n);
             claim(response, n.id);
             claim(error, n.id);
+            // An extra mapped row declares its variable as the row is typed (`string` when the
+            // row says nothing), not as `object`: `{ poCount: { source, type: 'integer' } }`
+            // writes an `integer` row and must declare an integer.
+            for (const [varId, spec] of Object.entries(n.outputs ?? {})) {
+                const row = typeof spec === 'string' ? { source: spec } : spec;
+                const d = rowDeclaration({ name: row.name ?? varId, type: row.type ?? 'string' });
+                claim(varId, n.id, d.type, d);
+            }
         }
         else if (n.kind === 'typed') {
             // Shared with the expression checker rather than repeated here. Repeating it is

package/lib/library-json.samples/index.json

@@ -180,6 +180,15 @@
       "activityType": "Curated",
       "objectName": "QueryEntityRecordsCurated",
       "path": "uipath-uipath-dataservice/query-entity-records@1.0.0.json"
+    },
+    {
+      "nodeType": "uipath.connector.uipath-uipath-dataservice.update-entity-record",
+      "version": "1.0.0",
+      "connectorKey": "uipath-uipath-dataservice",
+      "label": "Update Entity Record",
+      "activityType": "Curated",
+      "objectName": "UpdateEntityRecordV2",
+      "path": "uipath-uipath-dataservice/update-entity-record@1.0.0.json"
     }
   ]
 }