@uipath/maestro-builder-sdk 6.36.0 → 6.37.0

package/dist/bpmn/registry-types.json

@@ -7,7 +7,10 @@
   ],
   "provenance": {
     "typeCount": 30,
-    "uipVersion": "1.203.0-preview.180"
+    "uipVersion": "1.203.0-preview.180",
+    "refreshed": {
+      "Orchestrator.BusinessRules": "1.205.0-preview.256"
+    }
   },
   "types": {
     "A2A.AgentExecution": {
@@ -1277,40 +1280,35 @@
       "inputTarget": "bodyField",
       "context": [
         {
-          "name": "releaseKey",
-          "displayName": "Process",
+          "name": "name",
+          "displayName": "Business rule",
           "type": "string",
-          "required": false,
+          "required": true,
           "hidden": true,
-          "binding": false,
+          "binding": true,
           "default": null,
           "bindingInfo": {
-            "resource": "process",
-            "propertyAttribute": "Key"
+            "resource": "BusinessRule",
+            "propertyAttribute": "name",
+            "resourceKeyPattern": "${metadata.folderPath}.${metadata.name}"
           }
         },
-        {
-          "name": "folderId",
-          "displayName": null,
-          "type": "string",
-          "required": false,
-          "hidden": true,
-          "binding": false,
-          "default": null,
-          "bindingInfo": null
-        },
         {
           "name": "folderPath",
           "displayName": null,
           "type": "string",
-          "required": false,
+          "required": true,
           "hidden": true,
-          "binding": false,
+          "binding": true,
           "default": null,
-          "bindingInfo": null
+          "bindingInfo": {
+            "resource": "BusinessRule",
+            "propertyAttribute": "folderPath",
+            "resourceKeyPattern": "${metadata.folderPath}.${metadata.name}"
+          }
         },
         {
-          "name": "name",
+          "name": "_label",
           "displayName": null,
           "type": "string",
           "required": false,
@@ -1322,11 +1320,19 @@
       ],
       "inputs": [],
       "output": {
-        "name": "Execute business rule [Preview]",
-        "type": "Orchestrator.BusinessRules",
-        "source": null,
+        "name": "output",
+        "type": "jsonSchema",
+        "source": "=result",
         "relative": true
       },
+      "additionalOutputs": [
+        {
+          "name": "Error",
+          "type": "jsonSchema",
+          "source": "=Error",
+          "relative": true
+        }
+      ],
       "eventDefinition": null,
       "requiresDiscovery": true,
       "bindingPattern": "businessRule"

package/dist/bpmn/resource-key-pattern.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A binding field's resource key from the registry's `resourceKeyPattern`
+ * (`${metadata.folderPath}.${metadata.name}` on a business rule), resolved from the
+ * node's context values. Pure: the builder supplies the declared bindings a
+ * `=bindings.<b>` reference is read through.
+ */
+/**
+ * What a pattern resolves to from one node's context: the key and the ids of the
+ * declared bindings it was read through; `blocked` when it would resolve except for a
+ * `=bindings.<b>` reference no declared binding supplies a value for (the author is
+ * told what to declare rather than given a wrong pair); `undefined` when the pattern
+ * does not apply to this context at all, so the caller keys the binding by the value,
+ * as it always has.
+ */
+export type ResourceKeyResolution = {
+    key: string;
+    referenced: string[];
+} | {
+    blocked: {
+        field: string;
+        ref: string;
+    };
+} | undefined;
+/**
+ * Resolve `pattern` from `context`. A placeholder that is not `metadata.<field>`, a
+ * context field that is absent or not a string, or an `=` expression that is not a
+ * `=bindings.<b>` reference each make the pattern inapplicable (`undefined`) — so
+ * `${metadata.key}` on a job start, whose context has no `key`, leaves the key to the
+ * value. A `=bindings.<b>` value contributes the DECLARED value of `b`, never the
+ * expression text: a key is never evaluated.
+ *
+ * @param pattern - The field's `resourceKeyPattern`, or `undefined` for none.
+ * @param context - The node's context values as the author gave them.
+ * @param lookup - The declared binding for an id, with its `default` value, or `undefined`.
+ */
+export declare function resolveResourceKeyPattern(pattern: string | undefined, context: Record<string, unknown>, lookup: (bindingId: string) => {
+    default?: unknown;
+} | undefined): ResourceKeyResolution;

package/dist/bpmn/resource-key-pattern.js

@@ -0,0 +1,47 @@
+/**
+ * A binding field's resource key from the registry's `resourceKeyPattern`
+ * (`${metadata.folderPath}.${metadata.name}` on a business rule), resolved from the
+ * node's context values. Pure: the builder supplies the declared bindings a
+ * `=bindings.<b>` reference is read through.
+ */
+/**
+ * Resolve `pattern` from `context`. A placeholder that is not `metadata.<field>`, a
+ * context field that is absent or not a string, or an `=` expression that is not a
+ * `=bindings.<b>` reference each make the pattern inapplicable (`undefined`) — so
+ * `${metadata.key}` on a job start, whose context has no `key`, leaves the key to the
+ * value. A `=bindings.<b>` value contributes the DECLARED value of `b`, never the
+ * expression text: a key is never evaluated.
+ *
+ * @param pattern - The field's `resourceKeyPattern`, or `undefined` for none.
+ * @param context - The node's context values as the author gave them.
+ * @param lookup - The declared binding for an id, with its `default` value, or `undefined`.
+ */
+export function resolveResourceKeyPattern(pattern, context, lookup) {
+    if (pattern === undefined)
+        return undefined;
+    const placeholders = [...pattern.matchAll(/\$\{([\w.]+)\}/g)].map((m) => m[1]);
+    const values = new Map();
+    const referenced = [];
+    for (const name of placeholders) {
+        if (!name.startsWith('metadata.'))
+            return undefined;
+        const contextField = name.slice('metadata.'.length);
+        const v = context[contextField];
+        if (typeof v !== 'string')
+            return undefined;
+        if (!v.startsWith('=')) {
+            values.set(name, v);
+            continue;
+        }
+        if (!v.startsWith('=bindings.'))
+            return undefined;
+        const refId = v.slice('=bindings.'.length);
+        const decl = lookup(refId);
+        if (decl === undefined || typeof decl.default !== 'string')
+            return { blocked: { field: contextField, ref: v } };
+        values.set(name, decl.default);
+        referenced.push(refId);
+    }
+    const key = pattern.replace(/\$\{([\w.]+)\}/g, (_m, name) => values.get(name) ?? '');
+    return { key: key.startsWith('.') ? key.slice(1) : key, referenced };
+}

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/bpmn/typed-node.d.ts

@@ -36,6 +36,13 @@ export interface RegistryContextField {
     bindingInfo: {
         resource: string | null;
         propertyAttribute: string | null;
+        /**
+         * How the binding's `resourceKey` is built from the node's context values, e.g.
+         * `${metadata.folderPath}.${metadata.name}` for a business rule. Absent on
+         * entries materialized before the field was carried; the emitter then keys the
+         * binding by the bound value itself, as it always did.
+         */
+        resourceKeyPattern?: string;
     } | null;
 }
 /**
@@ -88,6 +95,11 @@ export interface RegistryTypeSpec {
     /** The payload fields the registry declares; empty for types with dynamic inputs. */
     inputs: RegistryInputField[];
     output: RegistryOutput | null;
+    /**
+     * Output rows the type writes besides `output` — a business rule's `Error` row
+     * (`source="=Error"`). Each lands in `<id>_<name>`. Absent when the type has none.
+     */
+    additionalOutputs?: RegistryOutput[];
     /** e.g. `bpmn:messageEventDefinition` — what makes a message event a message event. */
     eventDefinition: string | null;
     /** True when authoring needs a tenant read (a connection, a process, a queue). */
@@ -347,6 +359,11 @@ export interface TypedNodeInput {
     /** The type's emission spec, supplied inline — see `ActivityNodeOpts.spec`. */
     spec?: RegistryTypeSpec;
 }
+/**
+ * The variables a typed node's ADDITIONAL output rows write (`<id>_<name>`), in
+ * registry order — a business rule's `<id>_Error`. Empty for every type without them.
+ */
+export declare function typedNodeAdditionalOutputVars(id: string, type: string, inline?: RegistryTypeSpec): string[];
 /** The variable a typed node's output row writes, or `undefined` when it has none. */
 export declare function typedNodeOutputVar(id: string, type: string, outputVar?: string, inline?: RegistryTypeSpec): string | undefined;
 /** `uipath:input` payload rows exactly as the caller spelled them, deriving nothing. */

package/dist/bpmn/typed-node.js

@@ -191,6 +191,15 @@ function identifierize(name) {
         .map((w, i) => (i === 0 ? w.charAt(0).toLowerCase() + w.slice(1) : w.charAt(0).toUpperCase() + w.slice(1)))
         .join('');
 }
+/**
+ * The variables a typed node's ADDITIONAL output rows write (`<id>_<name>`), in
+ * registry order — a business rule's `<id>_Error`. Empty for every type without them.
+ */
+export function typedNodeAdditionalOutputVars(id, type, inline) {
+    // The row's name as it is, not identifierized: `Error` → `<id>_Error`, the variable a
+    // connector task's error row has always landed in.
+    return (registryType(type, inline).additionalOutputs ?? []).map((o) => `${id}_${o.name}`);
+}
 /** The variable a typed node's output row writes, or `undefined` when it has none. */
 export function typedNodeOutputVar(id, type, outputVar, inline) {
     const spec = registryType(type, inline);
@@ -536,6 +545,16 @@ varType) {
     const out = outVar ? outputRow(m, spec, outVar) : undefined;
     if (out)
         rows.push(out);
+    // The rows the registry declares beside the main one, in its order and at the
+    // default variable each — a business rule's `Error` row. They sit between the
+    // type's own row and the author's, which is where every real export puts them.
+    const extraVars = typedNodeAdditionalOutputVars(id, type, spec);
+    (spec.additionalOutputs ?? []).forEach((o, i) => {
+        const props = { name: o.name, type: o.type, var: extraVars[i] };
+        if (o.source)
+            props.source = o.source;
+        rows.push(m.create('uipath:Output', props));
+    });
     for (const [varId, source] of Object.entries(input.outputs ?? {})) {
         // Type the row from the variable it writes, not `'string'` unconditionally.
         //

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.
  *

package/dist/core/lookups.js

@@ -166,6 +166,39 @@ export function resolvedValue(token, resolutions) {
     const { nodeType, field, by, value } = token.__lookup;
     return resolutions[lookupKey(nodeType, field, by, value)]?.value;
 }
+/**
+ * The event form of a node type — `uipath.connector.event.<key>.<op>` — for one
+ * written without a role segment, else `undefined`. A role-less type is what the
+ * string form `lookup(key, action, field)` keys a token under.
+ */
+function eventFormOf(nodeType) {
+    const m = /^uipath\.connector\.(?!event\.|trigger\.)(.+)$/.exec(nodeType);
+    return m ? `uipath.connector.event.${m[1]}` : 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 function resolvedEventValue(token, resolutions) {
+    const own = resolvedValue(token, resolutions);
+    if (own !== undefined)
+        return own;
+    const { nodeType, field, by, value } = token.__lookup;
+    const eventForm = eventFormOf(nodeType);
+    return eventForm === undefined ? undefined : resolutions[lookupKey(eventForm, field, by, value)]?.value;
+}
 /**
  * The message for a lookup nothing has resolved — the command that fixes it.
  *
@@ -282,7 +315,7 @@ export function resolveEventWhere(where, resolutions, site) {
             out[key] = value;
             continue;
         }
-        const resolved = resolvedValue(value, resolutions);
+        const resolved = resolvedEventValue(value, resolutions);
         if (resolved === undefined)
             throw new Error(`${site}: \`where.${key}\` ` + unresolvedLookupMessage(value));
         out[key] = resolved;

package/dist/core/synthesized-definition.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The one refusal Flow adds on top of `Library.resolve`: an operation whose
+ * sidecar `registry prepare` synthesized from Integration Service
+ * (`prepare/integration-service.ts`) has no registry node behind it. A BPMN
+ * `sendTask` carries its own identity and rows, so BPMN compiles it; a Flow
+ * node embeds the registry's whole definition — form, handles, model — which
+ * no describe supplies, so Flow refuses it here, in `check` and `compile`
+ * alike, instead of emitting a node the designer cannot open.
+ */
+import { ConnectorResolveError } from './connector-resolve-error.js';
+import type { ResolvedConnector } from './library.js';
+/** The marker `prepare` writes on a sidecar it built from Integration Service. */
+export declare const SYNTHESIZED_FROM_INTEGRATION_SERVICE = "integration-service";
+/** Flow's refusal for a resolved operation with no registry definition, or `undefined` when it has one. */
+export declare function synthesizedDefinitionRefusal(rc: Pick<ResolvedConnector, 'v1def' | 'connectorKey' | 'nodeType'>): ConnectorResolveError | undefined;

package/dist/core/synthesized-definition.js

@@ -0,0 +1,22 @@
+/**
+ * The one refusal Flow adds on top of `Library.resolve`: an operation whose
+ * sidecar `registry prepare` synthesized from Integration Service
+ * (`prepare/integration-service.ts`) has no registry node behind it. A BPMN
+ * `sendTask` carries its own identity and rows, so BPMN compiles it; a Flow
+ * node embeds the registry's whole definition — form, handles, model — which
+ * no describe supplies, so Flow refuses it here, in `check` and `compile`
+ * alike, instead of emitting a node the designer cannot open.
+ */
+import { ConnectorResolveError } from './connector-resolve-error.js';
+/** The marker `prepare` writes on a sidecar it built from Integration Service. */
+export const SYNTHESIZED_FROM_INTEGRATION_SERVICE = 'integration-service';
+/** Flow's refusal for a resolved operation with no registry definition, or `undefined` when it has one. */
+export function synthesizedDefinitionRefusal(rc) {
+    const origin = rc.v1def?.synthesizedFrom;
+    if (origin !== SYNTHESIZED_FROM_INTEGRATION_SERVICE)
+        return undefined;
+    const action = String(rc.nodeType).replace(/^uipath\.connector\.[^.]+\./, '');
+    return new ConnectorResolveError('CONNECTOR_NO_FLOW_DEFINITION', `connector ${rc.connectorKey} ${action} was prepared from Integration Service because the Flow node catalog serves no node for ${rc.connectorKey}; `
+        + 'a Flow step or inline agent tool needs that node (its form, handles and model), so this operation compiles in BPMN only. '
+        + `Author it as a BPMN .connector(), or check \`uip maestro flow registry search ${rc.connectorKey}\` after \`registry pull --force\` in case the catalog has since gained it.`);
+}

package/dist/registry/library-build/context.d.ts

@@ -130,4 +130,20 @@ export declare function isResourcesList(ctx: BuildContext, connectorKey: string,
  * files are deliberately not reused: that output omitted the discovery
  * capabilities and would silently mark every connector static.
  */
+/** `uip is activities list`'s answer: its rows, or why it could not be read. */
+export type IsActivitiesCatalog = {
+    rows: unknown[];
+} | {
+    failure: string;
+};
+/**
+ * Cached `uip is activities list <key>`: the connector's activity catalog
+ * (every row, curated or not — the caller filters on `IsCurated`), or the
+ * failure in the CLI's own words ({@link failureReason}): a refusal, output
+ * that is not JSON, or a `Result: Failure` envelope (an expired token, a 5xx,
+ * a connector the tenant has not enabled). Cached beside the `is resources`
+ * payloads — it is the same catalog service, read without a connection — and
+ * a cached failure keeps its reason.
+ */
+export declare function isActivitiesCatalog(ctx: BuildContext, connectorKey: string): Promise<IsActivitiesCatalog>;
 export declare function isConnectorGet(ctx: BuildContext, connectorKey: string): Promise<unknown>;

package/dist/registry/library-build/context.js

@@ -16,7 +16,7 @@
 import { createHash } from "node:crypto";
 import { pyJsonStringify } from "../codecs/pyjson.js";
 import { sortedByKeys } from "../compat/compare.js";
-import { isConnectorsMetadata, isResourcesDescribeObject, isResourcesDescribeOperation, isResourcesList as isResourcesListArgv, registryGet as registryGetArgv, } from "../uip/commands.js";
+import { isActivitiesList as isActivitiesListArgv, isConnectorsMetadata, isResourcesDescribeObject, isResourcesDescribeOperation, isResourcesList as isResourcesListArgv, registryGet as registryGetArgv, } from "../uip/commands.js";
 import { CACHED_FAILURE, isCachedFailure, safeCacheName } from "../uip/response-cache.js";
 import { failureReason, isNodeNotFound } from "../uip/envelope.js";
 import { get, isPyDict, pyOr, pyTruthy } from "./py.js";
@@ -251,11 +251,38 @@ export async function isResourcesList(ctx, connectorKey, options = {}) {
     return Array.isArray(payload.Data) ? payload.Data : undefined;
 }
 /**
- * `is_connector_get`: cached `uip is connectors metadata <key>`, answering the
- * first element of `Data` or `undefined`. The legacy `connectors get` cache
- * files are deliberately not reused: that output omitted the discovery
- * capabilities and would silently mark every connector static.
+ * Cached `uip is activities list <key>`: the connector's activity catalog
+ * (every row, curated or not — the caller filters on `IsCurated`), or the
+ * failure in the CLI's own words ({@link failureReason}): a refusal, output
+ * that is not JSON, or a `Result: Failure` envelope (an expired token, a 5xx,
+ * a connector the tenant has not enabled). Cached beside the `is resources`
+ * payloads — it is the same catalog service, read without a connection — and
+ * a cached failure keeps its reason.
  */
+export async function isActivitiesCatalog(ctx, connectorKey) {
+    const name = `${safeCacheName(connectorKey, "_activities_list")}.json`;
+    if (ctx.caches.is.has(name)) {
+        const cached = ctx.caches.is.read(name);
+        const data = get(cached, "Data");
+        if (Array.isArray(data))
+            return { rows: data };
+        return { failure: String(pyOr(get(cached, "Message"), "the cached answer carries no rows")) };
+    }
+    const result = await runUip(ctx, isActivitiesListArgv(connectorKey));
+    if (refused(result))
+        return { failure: failureReason(result) };
+    const parsed = parseStdout(result.stdout);
+    if (parsed === undefined)
+        return { failure: failureReason(result) };
+    const payload = envelope(parsed);
+    if (get(payload, "Result") !== "Success") {
+        const failure = failureReason(result);
+        writeCache(ctx.caches.is, name, { Result: "Failure", Message: failure, [CACHED_FAILURE]: true });
+        return { failure };
+    }
+    writeCache(ctx.caches.is, name, payload);
+    return Array.isArray(payload.Data) ? { rows: payload.Data } : { failure: "the answer carries no Data rows" };
+}
 export async function isConnectorGet(ctx, connectorKey) {
     const name = `${safeCacheName(connectorKey, "_connector_metadata")}.json`;
     const firstRow = (payload) => {