@uipath/maestro-builder-sdk 6.36.1 → 6.37.0

package/dist/api-index.md

@@ -37,7 +37,7 @@ could hand you spans for a version you do not have.
 
 ## `@uipath/maestro-builder-sdk`
 
-230 symbol(s). Import from `@uipath/maestro-builder-sdk`.
+231 symbol(s). Import from `@uipath/maestro-builder-sdk`.
 
 | Symbol | Kind | Declaration | Area | Summary |
 | --- | --- | --- | --- | --- |
@@ -180,15 +180,15 @@ could hand you spans for a version you do not have.
 | `js` | function | `dist/core/expr.d.ts:247-282` | Expressions and types | Build a raw JS *expression* (a condition or computation). |
 | `lit` | function | `dist/core/expr.d.ts:22-28` | Expressions and types | A constant value baked directly into a node input. |
 | `lookup` | function | `dist/core/lookups.d.ts:95-102` | Generated descriptors | Begin resolving a lookup field on a generated descriptor. |
-| `lookup` | function | `dist/core/lookups.d.ts:103-122` | Generated descriptors | Begin resolving a lookup field addressed by connector key and action. |
-| `lookup` | function | `dist/core/lookups.d.ts:123-137` | Generated descriptors | Begin resolving a `where` parameter on a trigger descriptor that carries a lookup table. |
-| `lookup` | function | `dist/core/lookups.d.ts:138-159` | Generated descriptors | Begin resolving a `where` parameter on a connector-EVENT descriptor. |
+| `lookup` | function | `dist/core/lookups.d.ts:103-127` | Generated descriptors | Begin resolving a lookup field addressed by connector key and action. |
+| `lookup` | function | `dist/core/lookups.d.ts:128-142` | Generated descriptors | Begin resolving a `where` parameter on a trigger descriptor that carries a lookup table. |
+| `lookup` | function | `dist/core/lookups.d.ts:143-164` | Generated descriptors | Begin resolving a `where` parameter on a connector-EVENT descriptor. |
 | `LookupBuilder` | type | `dist/core/lookups.d.ts:64-71` | Generated descriptors | What `lookup(...)` returns: the generic form plus any generated aliases. |
 | `lookupKey` | function | `dist/core/lookups.d.ts:55-63` | Generated descriptors | The identity of one resolution, as `prepare` records it and `compile` reads it. |
-| `LookupResolution` | interface | `dist/core/lookups.d.ts:160-169` | Generated descriptors | One recorded resolution, as `connectors-local/resolutions.json` stores it. |
-| `LookupResolutions` | type | `dist/core/lookups.d.ts:170-171` | Generated descriptors | Every recorded resolution, keyed by lookupKey. |
+| `LookupResolution` | interface | `dist/core/lookups.d.ts:165-174` | Generated descriptors | One recorded resolution, as `connectors-local/resolutions.json` stores it. |
+| `LookupResolutions` | type | `dist/core/lookups.d.ts:175-176` | Generated descriptors | Every recorded resolution, keyed by lookupKey. |
 | `LookupSpec` | interface | `dist/core/lookups.d.ts:11-36` | Generated descriptors | One lookup field's retrieval contract, generated from `reference`. |
-| `lookupSpecOf` | function | `dist/core/lookups.d.ts:199-206` | Generated descriptors | The LookupSpec for one field, or `undefined` when it earns no helper. |
+| `lookupSpecOf` | function | `dist/core/lookups.d.ts:221-228` | Generated descriptors | The LookupSpec for one field, or `undefined` when it earns no helper. |
 | `LookupStrategy` | type | `dist/core/lookups.d.ts:1-10` | Generated descriptors | How `prepare` should retrieve the collection, chosen from the metadata. |
 | `LookupToken` | interface | `dist/core/lookups.d.ts:37-52` | Generated descriptors | An unresolved lookup: what `.byEmail(…)` returns. |
 | `LoopOptions` | interface | `dist/flow-sdk.d.ts:487-511` | Option shapes | Loop-specific options. |
@@ -214,10 +214,11 @@ could hand you spans for a version you do not have.
 | `QueuePriority` | type | `dist/nodes/queue/flow/spec.d.ts:9-10` | Supporting types | The three priorities an Orchestrator queue item can carry. |
 | `ran` | function | `dist/core/expr.d.ts:95-141` | Expressions and types | Did this step run? |
 | `rawNode` | function | `dist/raw-node.d.ts:9-71` | Supporting types | Place a node this SDK has no factory for, carrying its definition verbatim (`uipath.exotic.thing@2.1` and the manifest… |
-| `RawReference` | type | `dist/core/lookups.d.ts:190-198` | Supporting types |  |
+| `RawReference` | type | `dist/core/lookups.d.ts:212-220` | Supporting types |  |
 | `RemoteA2aToolRef` | interface | `dist/core/actions.d.ts:1285-1305` | Supporting types | A remote A2A (agent-to-agent) endpoint the agent may delegate to. |
-| `resolvedValue` | function | `dist/core/lookups.d.ts:172-179` | Generated descriptors | The recorded id for a token, or `undefined`. |
-| `resolveEventWhere` | function | `dist/core/lookups.d.ts:207-224` | Generated descriptors | An event subscription's `where` with every lookup token swapped for the id `registry prepare --resolve` recorded, or a… |
+| `resolvedEventValue` | function | `dist/core/lookups.d.ts:185-201` | Generated descriptors | resolvedValue for a token on an event's `where`. |
+| `resolvedValue` | function | `dist/core/lookups.d.ts:177-184` | Generated descriptors | The recorded id for a token, or `undefined`. |
+| `resolveEventWhere` | function | `dist/core/lookups.d.ts:229-246` | Generated descriptors | An event subscription's `where` with every lookup token swapped for the id `registry prepare --resolve` recorded, or a… |
 | `ReturnFieldType` | type | `dist/core/actions.d.ts:821-838` | Supporting types | A JSON-schema-ish type for one field of a step's declared `returns`. |
 | `ReturnOptions` | interface | `dist/flow-sdk.d.ts:445-486` | Option shapes | `.return(...)`-specific options. |
 | `rpaWorkflow` | function | `dist/core/actions.d.ts:1797-1841` | Actions | Invoke a deployed RPA (robotic process automation) workflow — a classic UI-automation process, published to… |
@@ -259,7 +260,7 @@ could hand you spans for a version you do not have.
 | `TriggerSpec` | type | `dist/flow-sdk.d.ts:162-180` | Supporting types | What starts the flow. |
 | `TypeDesc` | type | `dist/core/expr.d.ts:385` | Supporting types |  |
 | `types` | const | `dist/core/expr.d.ts:369-384` | Expressions and types | Variable type descriptors (map to Flow variable `type` values). |
-| `unresolvedLookupMessage` | function | `dist/core/lookups.d.ts:180-189` | Generated descriptors | The message for a lookup nothing has resolved — the command that fixes it. |
+| `unresolvedLookupMessage` | function | `dist/core/lookups.d.ts:202-211` | Generated descriptors | The message for a lookup nothing has resolved — the command that fixes it. |
 | `v` | function | `dist/core/expr.d.ts:29-41` | Expressions and types | Reference a flow variable or output by name → `$vars.<name>`. |
 | `VarDecl` | interface | `dist/flow-sdk.d.ts:59-71` | Supporting types | 7 field(s) |
 | `VarSpec` | interface | `dist/flow-sdk.d.ts:72-127` | Supporting types | The rich spelling of a variable declaration: pass it instead of a bare `types.*` descriptor wherever `.input()` /… |

package/dist/api-members.md

@@ -109,7 +109,7 @@ not find it either.
 | `businessRule` | property | `BuiltTask` | `dist/case/case-sdk.d.ts:542-543` |
 | `businessRule` | method | `ScopeBuilder` | `dist/bpmn/bpmn-sdk.d.ts:2538-2602` |
 | `businessRule` | method | `TaskBuilder` | `dist/case/case-sdk.d.ts:833-861` |
-| `by` | property | `LookupResolution` | `dist/core/lookups.d.ts:164` |
+| `by` | property | `LookupResolution` | `dist/core/lookups.d.ts:169` |
 | `by` | property | `LookupSpec` | `dist/core/lookups.d.ts:27-28` |
 | `cachedAgentCard` | property | `RemoteA2aToolRef` | `dist/core/actions.d.ts:1299-1300` |
 | `callContext` | property | `EndCallInputs` | `dist/core/actions.d.ts:332-337` |
@@ -361,7 +361,7 @@ not find it either.
 | `field` | property | `DataFabricSort` | `dist/nodes/data-fabric/flow/spec.d.ts:54-55` |
 | `field` | property | `FieldMapping` | `dist/nodes/transform/flow/spec.d.ts:28-29` |
 | `field` | property | `FilterRule` | `dist/nodes/transform/flow/spec.d.ts:13-14` |
-| `field` | property | `LookupResolution` | `dist/core/lookups.d.ts:163` |
+| `field` | property | `LookupResolution` | `dist/core/lookups.d.ts:168` |
 | `fields` | property | `DataFabricReadInputs` | `dist/nodes/data-fabric/flow/spec.d.ts:105-106` |
 | `fields` | property | `EscalationRef` | `dist/core/actions.d.ts:1538-1542` |
 | `fields` | property | `HitlInputs` | `dist/nodes/hitl/flow/spec.d.ts:201-210` |
@@ -583,7 +583,7 @@ not find it either.
 | `marksCaseComplete` | property | `BuiltCaseExitCondition` | `dist/case/case-sdk.d.ts:372` |
 | `marksStageComplete` | property | `BuiltExitCondition` | `dist/case/case-sdk.d.ts:339` |
 | `marksStageComplete` | property | `ExitOpts` | `dist/case/case-sdk.d.ts:710-711` |
-| `match` | property | `LookupResolution` | `dist/core/lookups.d.ts:165-166` |
+| `match` | property | `LookupResolution` | `dist/core/lookups.d.ts:170-171` |
 | `matches` | property | `FormFieldCondition` | `dist/core/actions.d.ts:129-130` |
 | `matchNames` | property | `GuardrailSelector` | `dist/core/actions.d.ts:844-845` |
 | `maxDuration` | property | `RetrySpec` | `dist/bpmn/bpmn-sdk.d.ts:805-806` |
@@ -717,7 +717,7 @@ not find it either.
 | `nodes` | property | `FlowLayout` | `dist/flow-sdk.d.ts:780-781` |
 | `nodes` | property | `ScopeStorage` | `dist/bpmn/bpmn-sdk.d.ts:1935-1936` |
 | `nodeType` | property | `ConnectorMeta` | `dist/core/connectors.d.ts:62` |
-| `nodeType` | property | `LookupResolution` | `dist/core/lookups.d.ts:162` |
+| `nodeType` | property | `LookupResolution` | `dist/core/lookups.d.ts:167` |
 | `notify` | property | `EscalationOpts` | `dist/case/case-sdk.d.ts:130-131` |
 | `notIn` | property | `FormFieldCondition` | `dist/core/actions.d.ts:127-128` |
 | `numExchanges` | property | `WaitForMessageInputs` | `dist/nodes/conversation/flow/spec.d.ts:31-35` |
@@ -1130,7 +1130,7 @@ not find it either.
 | `value` | property | `FilterRule` | `dist/nodes/transform/flow/spec.d.ts:16-23` |
 | `value` | property | `FormFieldOption` | `dist/core/actions.d.ts:100-101` |
 | `value` | property | `InOutField` | `dist/core/actions.d.ts:245-246` |
-| `value` | property | `LookupResolution` | `dist/core/lookups.d.ts:167-168` |
+| `value` | property | `LookupResolution` | `dist/core/lookups.d.ts:172-173` |
 | `value` | property | `LookupSpec` | `dist/core/lookups.d.ts:29-30` |
 | `value` | property | `PortArm` | `dist/flow-sdk.d.ts:386-387` |
 | `value` | property | `ShownField` | `dist/core/actions.d.ts:213-219` |

package/dist/bpmn/check.js

@@ -69,6 +69,7 @@ export function check(built, opts = {}) {
     checkFolderBindings(built, diags);
     checkEntryPointId(built, diags);
     checkMethodParentheses(built, diags);
+    checkConnectorRows(built, diags);
     checkConnectors(built, opts, diags);
     checkConnectorEvents(built, opts, diags);
     return diags;
@@ -219,6 +220,69 @@ function checkMethodParentheses(built, diags) {
     };
     walk(built.nodes, built.flows);
 }
+/** The Integration Service activity types, whose payload rows the platform reads only by `target`. */
+const CONNECTOR_ACTIVITY_TYPES = new Set(['Intsvc.ActivityExecution', 'Intsvc.AsyncExecution']);
+/**
+ * The targets the platform's reader knows (`UiPathExtensionsProvider`): anything else —
+ * an empty string included — falls through its switch to `Body`, and the row becomes the
+ * whole request body. `pathParameters` / `queryParameters` are the aggregate forms.
+ */
+const PLATFORM_ROW_TARGETS = new Set(['body', 'bodyField', 'header', 'path', 'query', 'file', 'pathParameters', 'queryParameters']);
+/**
+ * A connector activity's payload rows, as the platform reads them.
+ *
+ * Integration Service reads a connector's payload rows by target only, and its reader
+ * maps a missing, empty or unknown target to `Body` — so such a row does not vanish,
+ * it REPLACES the request body. The 2026-10-16 eval run's agent wrote
+ * `inputRows: [{ name: 'script', type: 'string', value }]` for a JDBC query: it
+ * validated, and faulted live with `Value for required parameter 'script' not found`,
+ * while the v1 arm's `<uipath:input name="body" target="body">{"script":"…"}</uipath:input>`
+ * ran. `inputs: { script }` folds a request field into the body row, so the remedy is
+ * the plain record for a body field, or the row's own target when it is a real slot.
+ * And because an `inputRows` list REPLACES `inputs` at emission (typed-node.ts), a
+ * node that sets both silently drops every `inputs` field — the same live fault.
+ */
+function checkConnectorRows(built, diags) {
+    for (const n of allNodes(built.nodes)) {
+        if (n.kind !== 'typed' || !CONNECTOR_ACTIVITY_TYPES.has(n.type))
+            continue;
+        if (n.inputRows && Object.keys(n.inputs ?? {}).length > 0) {
+            diags.push({
+                level: 'error',
+                code: 'CONNECTOR_INPUTS_SHADOWED',
+                where: n.id,
+                message: `Connector activity "${n.id}" sets both \`inputs\` (${Object.keys(n.inputs).map((k) => `"${k}"`).join(', ')}) and \`inputRows\`; ` +
+                    `an \`inputRows\` list replaces \`inputs\` entirely at emission, so those fields are never sent. Spell them as rows too ` +
+                    `(a body field as \`{ name: 'body', type: 'json', target: 'body', body: { … } }\`), or drop \`inputRows\` and write every field in \`inputs\`.`,
+            });
+        }
+        for (const row of n.inputRows ?? []) {
+            const target = row.target ?? '';
+            if (target === '') {
+                diags.push({
+                    level: 'error',
+                    code: 'CONNECTOR_INPUT_ROW_NO_TARGET',
+                    where: n.id,
+                    message: `Connector activity "${n.id}" input row "${row.name}" has no target. Integration Service reads a connector's ` +
+                        `payload rows by target, and its reader maps a missing or empty one to the request body — so this row validates and ` +
+                        `then becomes the WHOLE body, replacing the body row. Give the row its target — \`target: 'body'\` folds it into ` +
+                        `the request body, \`path\`/\`query\`/\`file\` are the other slots — or move EVERY row to \`inputs: { ${row.name}: … }\` ` +
+                        `and drop \`inputRows\`: an \`inputRows\` list, when present, replaces \`inputs\` entirely.`,
+                });
+            }
+            else if (!PLATFORM_ROW_TARGETS.has(target)) {
+                diags.push({
+                    level: 'error',
+                    code: 'CONNECTOR_INPUT_ROW_TARGET_UNKNOWN',
+                    where: n.id,
+                    message: `Connector activity "${n.id}" input row "${row.name}" has target "${target}", which the platform's reader does not know; ` +
+                        `it falls through to the request body, so this row would replace the body. Use one of ` +
+                        `${[...PLATFORM_ROW_TARGETS].map((t) => `'${t}'`).join(', ')}.`,
+                });
+            }
+        }
+    }
+}
 const GUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 /**
  * `.metadata({ entryPointId })` must be a GUID.

package/dist/bpmn/connector.js

@@ -26,6 +26,9 @@ export function createConnectorTask(ctx, n) {
         // authored for rather than an inferred one.
         ctxInput(m, 'operation', 'string', op.name ?? op.objectName ?? n.action),
         ctxInput(m, 'connectorKey', 'string', rc.connectorKey),
+        // The registry template's own value, and the one the CLI's V1 packaging path keys
+        // on; V2 (`Data.V2`) is tracked in https://github.com/UiPath/builder-sdk/issues/1298, blocked on UiPath/cli#5209.
+        ctxInput(m, 'activityConfigurationVersion', 'string', 'v1'),
     ];
     const connRef = bindingRef(ctx, n.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`);
     if (connRef) {

package/dist/bpmn/declared-vars.js

@@ -58,8 +58,15 @@ export function nodeDeclaredVars(n) {
     }
     if (n.kind === 'typed')
         return typedNodeDeclaredVars(n);
-    if (n.kind === 'scriptTask')
+    // Spelled-out rows REPLACE the derived ones, so they are the whole answer — the
+    // same rule as `typedNodeDeclaredVars`. Reading only `outputs` here left a script
+    // task authored with `outputRows` (the form decompile writes) declaring nothing,
+    // so every `vars.<row.var>` downstream was EXPR_UNDECLARED_REF.
+    if (n.kind === 'scriptTask') {
+        if (n.outputRows)
+            return n.outputRows.map((r) => r.var).filter((v) => v !== undefined);
         return Object.keys(n.outputs);
+    }
     if (n.kind === 'task')
         return Object.keys(n.set);
     return [];

package/dist/bpmn/decompile.js

@@ -2032,15 +2032,23 @@ 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 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 }) });
                 }

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

@@ -154,14 +154,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;
@@ -711,13 +704,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 +957,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 {

package/dist/core/cli-library.d.ts

@@ -1,4 +1,4 @@
-import { Library, type ResolvedConnector } from './library.js';
+import { ConnectorResolveError, Library, type ResolvedConnector } from './library.js';
 import type { BindingsView } from './binding-messages.js';
 import { type ConnectorCheckOpts } from './connector-checks.js';
 import type { LookupResolutions, LookupSpec } from './lookups.js';
@@ -32,9 +32,15 @@ export declare function openCliLibrary(argv: readonly string[]): Library | undef
  * recorded by `registry prepare --resolve` would be reported as still owed,
  * telling the author to re-run a prepare they already ran.
  */
-export declare function connectorCheckOpts(library: Library | undefined, bindings?: BindingsView, inputErrors?: ConnectorInputValidator): ConnectorCheckOpts & EventCheckOpts;
+export declare function connectorCheckOpts(library: Library | undefined, bindings?: BindingsView, inputErrors?: ConnectorInputValidator, refuse?: ConnectorRefusal): ConnectorCheckOpts & EventCheckOpts;
 /** A family's field-contract validator: `compile`'s refusal for these inputs, or `undefined`. */
 export type ConnectorInputValidator = (rc: ResolvedConnector, inputs: Record<string, unknown>, resolutions: LookupResolutions, lookups: Readonly<Record<string, LookupSpec>>) => string | undefined;
+/**
+ * A family's own refusal of an operation the library DID resolve — Flow's
+ * `synthesizedDefinitionRefusal` — applied after `library.resolve`, so check
+ * and compile refuse the same entry with the same code and text.
+ */
+export type ConnectorRefusal = (rc: ResolvedConnector) => ConnectorResolveError | undefined;
 /**
  * `check`'s EVENT_UNKNOWN verdict: the message `library.resolveEvent` throws
  * for a subscription, or `undefined` when it resolves.

package/dist/core/cli-library.js

@@ -57,12 +57,12 @@ export function openCliLibrary(argv) {
  * recorded by `registry prepare --resolve` would be reported as still owed,
  * telling the author to re-run a prepare they already ran.
  */
-export function connectorCheckOpts(library, bindings, inputErrors = (rc, inputs, resolutions, lookups) => connectorInputErrors(rc, inputs, resolutions, lookups, { dialect: EQUALS_EXPR_DIALECT })) {
+export function connectorCheckOpts(library, bindings, inputErrors = (rc, inputs, resolutions, lookups) => connectorInputErrors(rc, inputs, resolutions, lookups, { dialect: EQUALS_EXPR_DIALECT }), refuse) {
     if (!library)
         return bindings ? { bindings } : {};
     // One memoized resolve per connector step, shared by `connectorResolveError`
     // and `connectorInputs`, so the second hook does not resolve again.
-    const resolve = connectorResolver(library);
+    const resolve = connectorResolver(library, refuse);
     return {
         eventResolveError: eventResolveErrorFor(library),
         ...byoaCheckOpts(library),
@@ -129,14 +129,16 @@ const CONNECTOR_RESOLVE_FAILED = 'CONNECTOR_RESOLVE_FAILED';
  * "unknown" used to let `check` pass a step `compile` then died on (#1015); the
  * event twin, `eventResolveErrorFor`, already reported every throw.
  */
-function connectorResolver(library) {
+function connectorResolver(library, refuse) {
     const memo = new Map();
     return (spec) => {
         const id = JSON.stringify([spec.key, spec.action, spec.version ?? null, spec.object ?? null]);
         let r = memo.get(id);
         if (!r) {
             try {
-                r = { rc: library.resolve(spec.key, spec.action, spec.version, spec.object) };
+                const rc = library.resolve(spec.key, spec.action, spec.version, spec.object);
+                const refused = refuse?.(rc);
+                r = refused ? { error: { code: refused.code, message: refused.message } } : { rc };
             }
             catch (error) {
                 r = error instanceof ConnectorResolveError

package/dist/core/connector-resolve-error.d.ts

@@ -15,7 +15,13 @@ export type ConnectorResolveCode =
  * The index lists the operation, but its entry file or `.v1def.json` sidecar is
  * missing or not valid JSON: the library on disk is incomplete (#1015).
  */
- | 'CONNECTOR_LIBRARY_ENTRY_UNREADABLE';
+ | 'CONNECTOR_LIBRARY_ENTRY_UNREADABLE'
+/**
+ * Flow only: the sidecar was synthesized from Integration Service by `registry
+ * prepare` (no registry node exists), and a Flow node needs the registry's
+ * definition. BPMN compiles the same entry (`core/synthesized-definition.ts`).
+ */
+ | 'CONNECTOR_NO_FLOW_DEFINITION';
 /**
  * The refusal `Library.resolve` throws, with a `code` for each reason.
  *

package/dist/core/event-checks.js

@@ -18,7 +18,7 @@
  * `skill-bpmn-outlook-waitfor-email` in `flow-v2-run-8` failed on exactly that last
  * question, and in run 12 on having nowhere to put a payload condition.
  */
-import { isLookupToken, resolvedValue, unresolvedLookupMessage, } from './lookups.js';
+import { isLookupToken, resolvedEventValue, unresolvedLookupMessage, } from './lookups.js';
 import { prepareCommand } from './cli-spelling.js';
 import { EVENT_FILTER_OPERATORS, readEventFilter, eventFilterProblem, jmesStringProblem } from './event-filters.js';
 import { EVENT_BYOA_UNVERIFIED, byoaUnverified } from './byoa.js';
@@ -129,7 +129,7 @@ export function checkEventResolution(subscription, where, kind, opts, error, war
     for (const [key, value] of scope) {
         if (!isLookupToken(value))
             continue;
-        if (resolvedValue(value, resolutions) !== undefined)
+        if (resolvedEventValue(value, resolutions) !== undefined)
             continue;
         warn('LOOKUP_UNRESOLVED', `${where}: \`where.${key}\` ` + unresolvedLookupMessage(value)
             + `\nCompile will fail until this is recorded.`);

package/dist/core/lookups.d.ts

@@ -114,6 +114,11 @@ export declare function lookup<D extends LookupBearing, F extends keyof NonNulla
  * and there are no typed aliases, so only the generic `.by(name, value)` is
  * available. A consistent trade rather than a new one.
  *
+ * On a connector EVENT's `where` (`.waitForEvent()` / `.eventTrigger()` /
+ * `onEvent()`), `action` is the event id and the token is matched against the
+ * resolution `prepare` recorded for the event as well, so this form and
+ * `lookup({ connector, event }, field)` resolve alike.
+ *
  * @param key - The connector library key, e.g. `'uipath-salesforce-slack'`.
  * @param action - The operation id, e.g. `'send-message-to-user'`.
  * @param field - The lookup field, e.g. `'channel'`.
@@ -177,6 +182,23 @@ export type LookupResolutions = Readonly<Record<string, LookupResolution>>;
  * @returns The connector-facing id, when this exact `(nodeType, field, by, value)` was resolved.
  */
 export declare function resolvedValue(token: LookupToken, resolutions: LookupResolutions): string | undefined;
+/**
+ * {@link resolvedValue} for a token on an event's `where`.
+ *
+ * `prepare` records an event's resolutions under the EVENT form of the node type,
+ * which the descriptor form `lookup({ connector, event }, field)` keys a token
+ * under too. The string form `lookup(key, action, field)` cannot know it is being
+ * used on an event and keys the token under the activity form, so a recorded
+ * resolution was never found for it: on the 2026-10-16 run an author whose
+ * `prepare --resolve parentFolderId:displayName=Inbox` had succeeded still saw
+ * `LOOKUP_UNRESOLVED` from `check` and a refusal from `compile`, and pasted the
+ * id in by hand. The token's own key is tried first; the event form second.
+ *
+ * @param token - The unresolved lookup, from either `lookup()` form.
+ * @param resolutions - Everything `prepare --resolve` has recorded.
+ * @returns The connector-facing id, when either key was resolved.
+ */
+export declare function resolvedEventValue(token: LookupToken, resolutions: LookupResolutions): string | undefined;
 /**
  * The message for a lookup nothing has resolved — the command that fixes it.
  *