@uipath/maestro-builder-sdk 6.36.1 → 6.38.0

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) => {
@@ -2032,15 +2275,37 @@ rehome) {
             // a bodied declaration through: ten `error<n>` declarations owned by boundary
             // events in `claims-triage` were skipped as derived and then nobody derived them
             // — they vanished from the recompiled process.
-            if (payload && type && type !== 'BPMN.Variables' && typeDescribesElement(localName(el.$type), type)) {
+            // A script task's default payload type is `BPMN.Variables` — the same type a
+            // variable-assignment task carries, which derives nothing. The script task with
+            // spelled-out rows is admitted by its element, not its type: those rows are the
+            // declaration on the way back in (`implicitNodeVars`' script arm), so they are
+            // skipped here too, or the source redeclares every one of them in `.vars()`.
+            const spelledOutScriptRows = localName(el.$type) === 'scriptTask' && type === 'BPMN.Variables' && outputRowsNeedSpellingOut(payload);
+            if (payload && type && (spelledOutScriptRows || (type !== 'BPMN.Variables' && typeDescribesElement(localName(el.$type), type)))) {
                 for (const row of payload.output ?? []) {
                     if (!row.var)
                         continue;
-                    // A script task's rows are NOT spelled-out `outputRows` on the way back —
-                    // `implicitNodeVars` derives its declarations from `outputs` keys, so they
-                    // carry the id as the name and that arm's own wire type. Every other typed
-                    // node's rows go through `rowDeclaration`, the same call the serializer makes.
-                    candidates.set(row.var, type === 'BPMN.ScriptTask'
+                    // 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
+                    // out (`emitScriptTask` writes `outputRows` exactly when this holds) are
+                    // declared through `rowDeclaration` on the way back in, like every other
+                    // typed node's, so they are matched the same way here.
+                    candidates.set(row.var, type === 'BPMN.ScriptTask' && !outputRowsNeedSpellingOut(payload)
                         ? { owner: el.id, wire: 'string' }
                         : { owner: el.id, ...rowDeclaration({ name: row.name, type: row.type, schema: row.body }) });
                 }
@@ -2084,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/intsvc.d.ts

@@ -35,11 +35,11 @@ type ExternalNode = Extract<BpmnNode, {
 /**
  * The extension type a Phase 3d node lowers to, WITHOUT consulting the library.
  *
- * The emitters below take a connector event's type from the library's
- * `runtime.serviceType`, which is the authority. This is the same answer derived
- * from the node alone, so the serializer can declare the node's output variable
- * before it has resolved anything — and the emitter asserts the two agree, so the
- * shortcut cannot silently diverge.
+ * The method the author called decides the placement — `.eventTrigger()` a start
+ * event, `.waitForEvent()` a receive task — so the type is known from the node alone,
+ * and the serializer can declare the node's output variable before it has resolved
+ * anything. The emitter uses this same value; the library only has to say the
+ * operation is a connector event.
  */
 export declare function intsvcServiceType(n: EventNode | ExternalNode): string;
 /**
@@ -55,11 +55,10 @@ export declare function intsvcOutputVar(n: EventNode | ExternalNode): string | u
 /**
  * A connector event node — `Intsvc.EventTrigger` or `Intsvc.WaitForEvent`.
  *
- * The extension type comes from the LIBRARY (`runtime.serviceType`), not from the
- * method the author called. That is deliberate: the descriptor is the authority on
- * which placement it describes, so a `trigger` descriptor reached through
- * `.waitForEvent()` is caught here rather than emitting a start-event type onto a
- * receive task — a mismatch both offline validators accept.
+ * The extension type comes from the method the author called; the library only has
+ * to say the operation is a connector event (`runtime.serviceType` is one of the
+ * event types). A prepared descriptor carries the START form's runtime whichever
+ * method reaches it, so the placement, not the descriptor, decides the type.
  *
  * @param ctx - Serializer context: moddle, library, bindings, binding sink.
  * @param n - The authored node.

package/dist/bpmn/intsvc.js

@@ -1,6 +1,7 @@
 import { createTypedNode, typedNodeOutputVar } from './typed-node.js';
 import { connectorBindingRef } from './connector.js';
 import { eventFilterJmes, eventFilterProblem, jmesString, jmesStringProblem, readEventFilter } from '../core/event-filters.js';
+import { resolveEventWhere } from '../core/lookups.js';
 /**
  * Which extension type an external invocation lowers to.
  *
@@ -19,11 +20,11 @@ const EVENT_SERVICE_TYPE = { trigger: 'Intsvc.EventTrigger', event: 'Intsvc.Wait
 /**
  * The extension type a Phase 3d node lowers to, WITHOUT consulting the library.
  *
- * The emitters below take a connector event's type from the library's
- * `runtime.serviceType`, which is the authority. This is the same answer derived
- * from the node alone, so the serializer can declare the node's output variable
- * before it has resolved anything — and the emitter asserts the two agree, so the
- * shortcut cannot silently diverge.
+ * The method the author called decides the placement — `.eventTrigger()` a start
+ * event, `.waitForEvent()` a receive task — so the type is known from the node alone,
+ * and the serializer can declare the node's output variable before it has resolved
+ * anything. The emitter uses this same value; the library only has to say the
+ * operation is a connector event.
  */
 export function intsvcServiceType(n) {
     return n.kind === 'connectorEvent'
@@ -45,11 +46,10 @@ export function intsvcOutputVar(n) {
 /**
  * A connector event node — `Intsvc.EventTrigger` or `Intsvc.WaitForEvent`.
  *
- * The extension type comes from the LIBRARY (`runtime.serviceType`), not from the
- * method the author called. That is deliberate: the descriptor is the authority on
- * which placement it describes, so a `trigger` descriptor reached through
- * `.waitForEvent()` is caught here rather than emitting a start-event type onto a
- * receive task — a mismatch both offline validators accept.
+ * The extension type comes from the method the author called; the library only has
+ * to say the operation is a connector event (`runtime.serviceType` is one of the
+ * event types). A prepared descriptor carries the START form's runtime whichever
+ * method reaches it, so the placement, not the descriptor, decides the type.
  *
  * @param ctx - Serializer context: moddle, library, bindings, binding sink.
  * @param n - The authored node.
@@ -67,14 +67,20 @@ export function createConnectorEvent(ctx, n) {
         throw new Error(`connector event ${n.key}/${n.eventName} has no runtime.serviceType in the library; ` +
             `it cannot be authored as a BPMN node.`);
     }
-    // The library is the authority, but the serializer has already declared this
-    // node's output variable from the placement alone (`intsvcServiceType`). If the
-    // two ever disagree, that variable is wrong — so say so rather than emit it.
+    // The PLACEMENT decides the extension type — `.eventTrigger()` starts the
+    // process (`Intsvc.EventTrigger`), `.waitForEvent()` pauses it (`Intsvc.WaitForEvent`)
+    // — and the serializer has already declared this node's output variable from it
+    // (`intsvcServiceType`). The library's `runtime.serviceType` only has to agree
+    // that the operation IS a connector event: the platform ships one operation for
+    // both placements, the baked library carries the wait form under `.event.`, and
+    // `prepare` writes the same entry with the START form's runtime block (measured
+    // on `uipath-microsoft-outlook365/email-received`, 2026-10-16) — so reading the
+    // placement off that field refused every prepared `.waitForEvent()` with "use
+    // .eventTrigger() instead", while the unprepared same node compiled.
     const expected = intsvcServiceType(n);
-    if (type !== expected) {
+    if (type !== 'Intsvc.EventTrigger' && type !== 'Intsvc.WaitForEvent') {
         throw new Error(`connector event "${n.id}" was authored as a ${n.subscribe} (${expected}), but the library ` +
-            `describes ${n.key}/${n.eventName} as ${type}. Use ` +
-            `${type === 'Intsvc.EventTrigger' ? '.eventTrigger()' : '.waitForEvent()'} instead.`);
+            `describes ${n.key}/${n.eventName} as ${type}, which is not a connector event.`);
     }
     const conn = connectorBindingRef(ctx, n.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`);
     const folder = connectorBindingRef(ctx, n.folder, 'Connection', 'folderKey', 'FolderKey', conn?.resourceKey);
@@ -108,10 +114,17 @@ export function createConnectorEvent(ctx, n) {
     // 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);
+    // A `lookup()` token in the scope is replaced by the id `prepare --resolve`
+    // recorded, as Flow's and Case's serializers do; an unrecorded one is refused
+    // with the command that records it. Stringified, a token was `[object Object]`.
+    const scope = resolveEventWhere(n.filter, ctx.library.lookupResolutions, `connector event "${n.id}"`);
+    inputs.body = eventFilterBody(n.id, scope, n.filters);
     if (n.parameters !== undefined)
         inputs.parameters = n.parameters;
-    return createTypedNode(ctx.m, n.id, type, {
+    return createTypedNode(ctx.m, n.id, 
+    // The placement's type, so a prepared `.event.` entry carrying the start form's
+    // runtime cannot turn a wait into a start event (see the check above).
+    expected, {
         name: n.name ?? rc.entry.display?.label ?? n.eventName,
         inputs,
         outputVar: n.outputVar,

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
@@ -154,14 +155,7 @@ export async function serialize(built, opts = {}) {
             version: meta.caseManagement.version,
             value: meta.caseManagement.value,
         }));
-    // Process-level marker that accompanies an Integration Service connector graph.
-    // Derived from the GRAPH, not from whether connector wiring happened to produce
-    // a binding: a connector with no connection/folder produced no binding and so
-    // used to lose the marker, and a DECOMPILED connector — which carries explicit
-    // `.binding()` calls rather than derived ones — lost it too.
-    if (allNodes(built.nodes).some(isIntsvcConnectorNode)) {
-        processExt.push(m.create('uipath:IntsvcActivityConfig', { version: 'v2' }));
-    }
+    // No process `intsvcActivityConfig`: the CLI packs Connection rows only for V1 nodes (https://github.com/UiPath/builder-sdk/issues/1298 tracks V2).
     if (processExt.length)
         processProps.extensionElements = m.create('bpmn:ExtensionElements', { values: processExt });
     processProps.flowElements = flowElements;
@@ -671,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
@@ -711,13 +713,27 @@ export function implicitNodeVars(nodes, declared) {
             claim(typedNodeOutputVar(n.id, n.trigger.type, n.trigger.outputVar), n.id);
         }
         else if (n.kind === 'scriptTask') {
-            // `object` (emitted as `json`), not `string`. Under the v3 contract a script
-            // returns `{ response: <whatever it returned> }`, so an output nobody declared
-            // holds arbitrary JSON — declaring a number or an object as `string` is the
-            // mis-declaration this fallback exists to avoid. An output the AUTHOR declared
-            // keeps its own type: `claim` skips an id already taken.
-            for (const varId of Object.keys(n.outputs))
-                claim(varId, n.id);
+            if (n.outputRows) {
+                // Spelled-out rows state their declaration, as a typed node's do — the same
+                // `rowDeclaration` call, so `nodeDeclaredVars`, this, and decompile's skip set
+                // agree. Deriving from `outputs` alone here left a script task authored with
+                // `outputRows` declaring nothing on the wire: the checker (once it counted the
+                // rows) passed, and `uip maestro bpmn validate` reported MISSING_ROOT_VARIABLE
+                // on the task and VARIABLE_DOES_NOT_EXIST on every read of its variables.
+                for (const row of n.outputRows) {
+                    const d = rowDeclaration(row);
+                    claim(row.var, n.id, d.type, d);
+                }
+            }
+            else {
+                // `object` (emitted as `json`), not `string`. Under the v3 contract a script
+                // returns `{ response: <whatever it returned> }`, so an output nobody declared
+                // holds arbitrary JSON — declaring a number or an object as `string` is the
+                // mis-declaration this fallback exists to avoid. An output the AUTHOR declared
+                // keeps its own type: `claim` skips an id already taken.
+                for (const varId of Object.keys(n.outputs))
+                    claim(varId, n.id);
+            }
         }
     }
     return out;
@@ -950,15 +966,6 @@ export function publicDeclarationScope(nodes, processId) {
 function cap(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
-/**
- * Whether a node is an Integration Service connector activity — the `.connector()`
- * method, or the same extension types reached through `.activity()`.
- */
-function isIntsvcConnectorNode(n) {
-    if (n.kind === 'connector')
-        return true;
-    return n.kind === 'typed' && (n.type === 'Intsvc.ActivityExecution' || n.type === 'Intsvc.AsyncExecution');
-}
 /** Flatten a scope's nodes (recursing sub-processes) for global scans. */
 export function allNodes(nodes) {
     const out = [];

package/dist/cli-library.js

@@ -1,4 +1,5 @@
 import { connectorCheckOpts } from './core/cli-library.js';
+import { synthesizedDefinitionRefusal } from './core/synthesized-definition.js';
 import { connectorInputErrors } from './serialize.js';
 export { openCliLibrary, connectorCheckOpts, eventResolveErrorFor, byoaCheckOpts } from './core/cli-library.js';
 /**
@@ -10,7 +11,8 @@ export { openCliLibrary, connectorCheckOpts, eventResolveErrorFor, byoaCheckOpts
  * cannot disagree.
  */
 export function flowCheckOpts(library, bindings) {
-    const shared = connectorCheckOpts(library, bindings, connectorInputErrors);
+    // Flow's own refusal of an operation `prepare` synthesized from Integration Service (BPMN-only).
+    const shared = connectorCheckOpts(library, bindings, connectorInputErrors, synthesizedDefinitionRefusal);
     if (!library)
         return shared;
     return {