@uipath/maestro-builder-sdk 6.8.4 → 6.8.6

package/dist/registry/prepare/pipeline.js

@@ -28,17 +28,17 @@ import { resolve } from "node:path";
 import { PACKAGE_NAME } from "../../package-name.js";
 import { afterLast } from "../compat/pystr.js";
 import { extractCanonical, isHttpPassthrough, nodeOf } from "../library-build/canonical.js";
-import { createBuildContext, isResourcesList, registryGet } from "../library-build/context.js";
+import { createBuildContext, isResourcesList, registryProbe } from "../library-build/context.js";
 import { enrichEntry } from "../library-build/enrich.js";
 import { expandGenericForConnector, genericTemplatesByOp } from "../library-build/generic-expand.js";
 import { planLibrary } from "../library-build/plan.js";
 import { MemoryResponseCache } from "../uip/response-cache.js";
-import { registryActions } from "./actions.js";
+import { registryCatalog } from "./actions.js";
 import { discoverConnection, lookupConnection, mergeBindings, restoreBindings, snapshotBindings, } from "./connections.js";
 import { prepareEvent } from "./event.js";
 import { descriptorUsage } from "./handoff.js";
 import { ResolutionsExhausted, allParentsResolved, resolvedParentValues, writeResolutions } from "./ledger.js";
-import { PREPARE_COMMAND, PrepareRefusal, bindingsLine, candidateLabel, connectionLine, generatedModulesLine, genericActionNeedsObjectMessage, inputFieldNote, keptSchemaMessage, lookupVocabularyLines, missingGenericSchemaMessage, missingParentsNote, nextLine, noCanonicalEntryMessage, objectFlagsOnlyForGenericMessage, objectNoteLine, objectRecordedLine, parentFieldNamesMismatchMessage, parentOnlyMessage, prefixed, preparedSummaryLine, rejectedParentFieldsMessage, rerunAgainstLine, resolvedParentsNote, tsNote, unresolvedActionMessage, } from "./messages.js";
+import { PREPARE_COMMAND, PrepareRefusal, bindingsLine, candidateLabel, connectionLine, generatedModulesLine, genericActionNeedsObjectMessage, inputFieldNote, keptSchemaMessage, lookupVocabularyLines, missingGenericSchemaMessage, missingParentsNote, nextLine, noCanonicalEntryMessage, objectFlagsOnlyForGenericMessage, objectNoteLine, objectRecordedLine, parentFieldNamesMismatchMessage, parentOnlyMessage, prefixed, preparedSummaryLine, rejectedParentFieldsMessage, rerunAgainstLine, resolvedParentsNote, registryGetFailedMessage, tsNote, unresolvedOperationMessage, } from "./messages.js";
 import { ObjectMatchRefusal, RESOLUTIONS_FILENAME, matchObject, recordObjectResolution } from "./objects.js";
 import { countInputFields, keepPreparedSchema, lookupSpecsFromOverlay, mergeFilesInto, parentFields as overlayParentFields, schemaActionParents, } from "./overlay.js";
 import { declaredParents, objectActionRequest, objectActionSpecs, parseFields } from "./parents.js";
@@ -163,7 +163,10 @@ export async function prepareConnector(options, ports) {
             connectionId: connected.connectionId,
             connection: options.connection,
             pinned,
-        }, error.plan, error.first);
+        }, error.plan, 
+        // The wrapper, not `error.first`: same facts, and its message names every
+        // miss of the run rather than only the first.
+        error);
         // Undo the bindings this run wrote for the connection that cannot serve
         // the lookups, then start over pinned to the one that can. Re-running
         // rather than switching in place is deliberate: the overlay and its
@@ -204,8 +207,8 @@ async function prepareOnConnection(options, ports, connected) {
     const { connectionId, bound, rollback } = connected;
     const ctx = createBuildContext({ client: ports.client, caches: ports.caches ?? memoryCaches(), reporter: ports.reporter, concurrency: 1, timeoutMs: ports.timeoutMs }, { connectionId, parentFields });
     const nodeType = `uipath.connector.${connectorKey}.${action}`;
-    const cacheName = await registryGet(ctx, nodeType, true);
-    if (cacheName === undefined) {
+    const actionProbe = await registryProbe(ctx, nodeType);
+    if ("miss" in actionProbe) {
         // Not an activity. Connector EVENTS live one namespace over, and their
         // registry definition only answers with a connection, which this command
         // has by now. Same loop, different twin pair.
@@ -227,13 +230,19 @@ async function prepareOnConnection(options, ports, connected) {
             bindings: rollback,
             prepareCommand: command,
         });
-        if (event !== undefined) {
+        if (!("missed" in event)) {
             return { kind: "event", nodeType: event.eventNodeType, connectionId, bound, objectName: event.objectName };
         }
-        const actions = await registryActions(ports.client, connectorKey, ports.timeoutMs);
-        throw new PrepareRefusal(unresolvedActionMessage(connectorKey, action, nodeType, actions), "ACTION_UNKNOWN");
+        const probes = [actionProbe.miss, event.missed];
+        // Only the CLI's "Node not found" says a node is absent. Any other failure
+        // of either lookup is reported as the failure it is, never as a verdict.
+        if (probes.some((probe) => !probe.notFound)) {
+            throw new PrepareRefusal(registryGetFailedMessage(connectorKey, action, probes), "REGISTRY_GET_FAILED");
+        }
+        const catalog = await registryCatalog(ports.client, connectorKey, ports.timeoutMs);
+        throw new PrepareRefusal(unresolvedOperationMessage({ connectorKey, name: action, probes, catalog }), "OPERATION_UNKNOWN");
     }
-    const payload = ctx.caches.registry.read(cacheName);
+    const payload = ctx.caches.registry.read(actionProbe.name);
     // The registry's own declaration of parent inputs, read from the same reply.
     const declared = declaredParents(payload);
     let entry = extractCanonical(nodeOf(payload));

package/dist/registry/prepare/resolve.d.ts

@@ -36,7 +36,21 @@ export interface LookupExhaustedFacts {
     pages: number;
     /** True when a cap, not the collection's end, stopped the scan. */
     capped: boolean;
+    /**
+     * Every distinct value the scan saw at `by`, when the whole collection was
+     * read and holds at most {@link CANDIDATE_LIMIT} records — what to pick from.
+     */
+    candidates?: readonly string[];
+    /** A value the scan saw that equals the wanted one ignoring case; the match itself is exact. */
+    near?: string;
 }
+/**
+ * A collection this small is listed in full when a value is not in it. The
+ * 2026-09-23 run guessed `send_as` 'Bot token' from the field's description
+ * while `available_tokens` held two records, 'Bot' and 'User', and the refusal
+ * said only "scanned 2 record(s)".
+ */
+export declare const CANDIDATE_LIMIT = 20;
 /**
  * The collection was read to the end on THIS connection and had no match
  * (`_resolve.LookupExhausted`).
@@ -63,6 +77,8 @@ export declare class LookupExhausted extends ResolutionRefusal {
     readonly scanned: number;
     readonly pages: number;
     readonly capped: boolean;
+    readonly candidates?: readonly string[];
+    readonly near?: string;
     constructor(message: string, facts: LookupExhaustedFacts);
 }
 /** One `--resolve <field>:<by>=<value>`, parsed. */
@@ -97,8 +113,17 @@ type SpecTable = ReadonlyMap<string, ResolveSpec> | Readonly<Record<string, Reso
  * unsubstituted `{placeholder}` in a URL, and the error the connector returns
  * for that names neither field.
  *
- * A field requested twice keeps its first position and its LAST `by`/`value`,
- * as the Python's dict did.
+ * A field requested more than once keeps its first position and EVERY distinct
+ * `by`/`value`, in the order given; an exact repeat collapses. DELIBERATE
+ * DIVERGENCE FROM THE PYTHON, whose dict kept one request per field — its LAST
+ * `by`/`value` — and dropped the rest without a word. That is fatal for a
+ * multiselect: `--resolve users[*]:…=A --resolve users[*]:…=B --resolve
+ * users[*]:…=C`, one command as the library page prints it, resolved and
+ * recorded only C (2026-09-23, skill-flow-ipe-multiselect), and the probe of
+ * the other connections asked only about C too.
+ *
+ * A PREREQUISITE given more than one value is refused: its id is substituted
+ * into the dependent's collection path, and one placeholder takes one id.
  */
 export declare function orderResolutions(requested: readonly ResolveRequest[], specs: SpecTable): ResolveRequest[];
 /**

package/dist/registry/prepare/resolve.js

@@ -22,6 +22,7 @@ import { pyFloatRepr } from "../codecs/pyjson.js";
 import { pyStrip, pyStripChars, splitOnce } from "../compat/pystr.js";
 import { Refusal } from "../errors.js";
 import { isResourcesRunList } from "../uip/commands.js";
+import { failureReason } from "../uip/envelope.js";
 import { isPlainObject, notJsonReason, pyOr, pyRepr, pyStrAny, pyTruthy } from "./support.js";
 /**
  * A scan has to stop somewhere, and the caps must be set against the MEASURED
@@ -50,6 +51,13 @@ export class ResolutionRefusal extends Refusal {
         this.name = "ResolutionRefusal";
     }
 }
+/**
+ * A collection this small is listed in full when a value is not in it. The
+ * 2026-09-23 run guessed `send_as` 'Bot token' from the field's description
+ * while `available_tokens` held two records, 'Bot' and 'User', and the refusal
+ * said only "scanned 2 record(s)".
+ */
+export const CANDIDATE_LIMIT = 20;
 /**
  * The collection was read to the end on THIS connection and had no match
  * (`_resolve.LookupExhausted`).
@@ -76,6 +84,8 @@ export class LookupExhausted extends ResolutionRefusal {
     scanned;
     pages;
     capped;
+    candidates;
+    near;
     constructor(message, facts) {
         super(message, "RESOLVE_NO_MATCH");
         this.name = "LookupExhausted";
@@ -86,6 +96,10 @@ export class LookupExhausted extends ResolutionRefusal {
         this.scanned = facts.scanned;
         this.pages = facts.pages;
         this.capped = facts.capped;
+        if (facts.candidates !== undefined)
+            this.candidates = facts.candidates;
+        if (facts.near !== undefined)
+            this.near = facts.near;
     }
 }
 /**
@@ -123,13 +137,27 @@ function specOf(specs, field) {
  * unsubstituted `{placeholder}` in a URL, and the error the connector returns
  * for that names neither field.
  *
- * A field requested twice keeps its first position and its LAST `by`/`value`,
- * as the Python's dict did.
+ * A field requested more than once keeps its first position and EVERY distinct
+ * `by`/`value`, in the order given; an exact repeat collapses. DELIBERATE
+ * DIVERGENCE FROM THE PYTHON, whose dict kept one request per field — its LAST
+ * `by`/`value` — and dropped the rest without a word. That is fatal for a
+ * multiselect: `--resolve users[*]:…=A --resolve users[*]:…=B --resolve
+ * users[*]:…=C`, one command as the library page prints it, resolved and
+ * recorded only C (2026-09-23, skill-flow-ipe-multiselect), and the probe of
+ * the other connections asked only about C too.
+ *
+ * A PREREQUISITE given more than one value is refused: its id is substituted
+ * into the dependent's collection path, and one placeholder takes one id.
  */
 export function orderResolutions(requested, specs) {
     const byField = new Map();
-    for (const request of requested)
-        byField.set(request[0], request);
+    for (const request of requested) {
+        const same = byField.get(request[0]);
+        if (same === undefined)
+            byField.set(request[0], [request]);
+        else if (!same.some(([, by, value]) => by === request[1] && value === request[2]))
+            same.push(request);
+    }
     const ordered = [];
     const placed = new Set();
     const place = (field, trail) => {
@@ -141,7 +169,14 @@ export function orderResolutions(requested, specs) {
         }
         const dependsOn = specOf(specs, field)?.dependsOn;
         for (const prerequisite of Array.isArray(dependsOn) ? dependsOn : []) {
-            if (byField.has(prerequisite)) {
+            const given = byField.get(prerequisite);
+            if (given !== undefined && given.length > 1) {
+                throw new ResolutionRefusal(`cannot resolve ${pyRepr(field)}: its collection is addressed through ` +
+                    `${pyRepr(prerequisite)}, which was given ${given.length} values ` +
+                    `(${given.map(([, by, value]) => `${by}=${pyRepr(value)}`).join(", ")}). ` +
+                    `The path takes one id; keep one --resolve ${prerequisite}:<by>=<value> and re-run.`, "RESOLVE_AMBIGUOUS_PREREQUISITE");
+            }
+            if (given !== undefined) {
                 place(prerequisite, [...trail, field]);
             }
             else {
@@ -151,7 +186,7 @@ export function orderResolutions(requested, specs) {
             }
         }
         placed.add(field);
-        ordered.push(byField.get(field));
+        ordered.push(...byField.get(field));
     };
     for (const [field] of requested)
         place(field, []);
@@ -327,7 +362,7 @@ export function parseListingDocument(text) {
 export async function listPage(client, connectorKey, collection, connectionId, query) {
     const result = await client.run(isResourcesRunList(connectorKey, collection, connectionId, query));
     if (result.code !== 0) {
-        throw new ResolutionRefusal(`listing ${collection} failed: ${pyStrip(result.stderr) || "no output"}`, "RESOLVE_LISTING_FAILED");
+        throw new ResolutionRefusal(`listing ${collection} failed: ${failureReason(result)}`, "RESOLVE_LISTING_FAILED");
     }
     const envelope = parseListingDocument(result.stdout);
     if (!isPlainObject(envelope)) {
@@ -433,9 +468,21 @@ export async function resolveOne(client, connectorKey, spec, field, by, value, c
         query = query ? `${query}&${filtered}` : filtered;
     }
     const scan = scanCollection(client, connectorKey, collection, connectionId, query);
+    // What the collection DOES hold at `by`, for the refusal: kept only while it
+    // could still be listed in full, plus the first case-insensitive equal.
+    const held = [];
+    let near;
     let step = await scan.next();
     while (!step.done) {
         for (const record of step.value) {
+            const at = readPath(record, by);
+            if (at !== null && at !== undefined) {
+                const text = pyStrAny(at);
+                if (held.length <= CANDIDATE_LIMIT && !held.includes(text))
+                    held.push(text);
+                if (near === undefined && text !== value && text.toLowerCase() === value.toLowerCase())
+                    near = text;
+            }
             if (matchRecord(record, by, value)) {
                 const got = readPath(record, send);
                 if (got === null) {
@@ -463,8 +510,24 @@ export async function resolveOne(client, connectorKey, spec, field, by, value, c
     // The listing command is still offered, once, by the caller's terminal
     // report — where every connection has been tried and seeing what IS there
     // is finally the next step rather than a detour.
+    //
+    // What it DOES carry is what the collection holds, when that is small enough
+    // to read in one line, and a case-only near miss: facts about this
+    // connection, not a remedy. `matchRecord` stays exact — nothing is picked.
+    //
+    // Never under a server-side filter: the scan then read only the records the
+    // filter returned (`name like '%Coder Eval%'` gives 'Coder Evals' and 'Coder
+    // Eval Test'), and listing that subset as what the collection "holds" would
+    // be false. 693 library operations declare a `filterPattern`.
+    const candidates = !capped && !pyTruthy(filterPattern) && scanned <= CANDIDATE_LIMIT && held.length > 0 ? held : undefined;
     throw new LookupExhausted(`${field}: no record in ${pyRepr(collection)} has ${by}=${pyRepr(value)} ` +
         `(scanned ${scanned} record(s) across ${pages + 1} page(s)` +
         (capped ? `; STOPPED AT THE ${MAX_SCANNED}-record cap, so the value may be further in` : "; collection exhausted") +
-        `) on connection ${connectionId}.`, { field, collection, by, value, scanned, pages: pages + 1, capped });
+        `) on connection ${connectionId}.` +
+        (near !== undefined ? ` Did you mean ${pyRepr(near)}? The match is exact, case included.` : "") +
+        (candidates !== undefined ? ` It holds: ${candidates.map(pyRepr).join(", ")}.` : ""), {
+        field, collection, by, value, scanned, pages: pages + 1, capped,
+        ...(candidates !== undefined ? { candidates } : {}),
+        ...(near !== undefined ? { near } : {}),
+    });
 }

package/dist/registry/uip/envelope.d.ts

@@ -1,12 +1,4 @@
-/**
- * Reading what `uip … --output json` prints.
- *
- * The CLI is chatty: an update banner, a tool-version warning and a
- * `ManifestClient` diagnostic can precede the JSON document, and the document
- * itself is a `{ Result, Data, Message, … }` envelope whose key casing has
- * varied between tools. Three Python callers each had their own loop for
- * finding the document; this is the one loop, and the one accessor.
- */
+import type { UipResult } from "./client.js";
 /** The shape every `uip` JSON response shares, read case-insensitively. */
 export interface UipEnvelope {
     Result?: unknown;
@@ -35,3 +27,46 @@ export declare function isSuccess(envelope: UipEnvelope | undefined): boolean;
 export declare function dataItems(envelope: UipEnvelope | undefined): unknown[];
 /** The last `limit` characters of a stream, for a message. */
 export declare function tail(text: string, limit?: number): string;
+/**
+ * Why a `uip` call failed, as text a message can quote after a colon. Never empty.
+ *
+ * `uip … --output json` prints its FAILURE envelope on stdout, not stderr:
+ * `OutputFormatter.error` hands it to `logOutput`, which writes through
+ * `sink.writeOut` (uipath-cli `packages/common/src/formatter.ts:1657-1688` and
+ * `:654-675`). For example, `registry get` of a node the catalog does not serve
+ * exits 1 with this on stdout:
+ *
+ * ```json
+ * { "Result": "Failure", "Message": "Node not found",
+ *   "Instructions": "No node found with node type: uipath.connector.trigger.…" }
+ * ```
+ *
+ * and, on stderr, nothing, or a `[ManifestClient] fetchDynamicNodes ok: …`
+ * diagnostic, or a self-update banner. Callers that quoted stderr printed
+ * `registry get failed for <nodeType>: ` with nothing after the colon (2026-09-23
+ * eval, `skill-flow-datafabric-trigger-lifecycle`, v2 command 33).
+ *
+ * So the envelope is read first. The order is:
+ *
+ *  1. a call the client refused (`OfflineUipClient`): no process ran, and its
+ *     stderr already says so (`offline: refused to run …`), so that text is kept;
+ *  2. a call killed by its timeout: `timed out`, whatever partial output it left;
+ *  3. a non-Success envelope on stdout (found past any banner, keys read
+ *     case-insensitively): `<Message>: <Instructions>`, or whichever is present;
+ *  4. the end of stderr, then the end of stdout;
+ *  5. `no output`.
+ */
+export declare function failureReason(result: UipResult): string;
+/**
+ * True when a failed `registry get` answered the CLI's own "not in the catalog"
+ * envelope, `Message: "Node not found"` (uipath-cli
+ * `packages/maestro-sdk/src/registry/command.ts:595-600`).
+ *
+ * Only that answer says the node is ABSENT. Every other failure — `Error
+ * retrieving node` (`command.ts:586-591`, which carries the thrown error in
+ * `Instructions`), a refusal, a timeout, output that is not JSON — says the
+ * lookup did not work, which is a different fact with a different remedy. The
+ * `Message` is the discriminator because the envelope's `ErrorCode` is the
+ * generic `unknown_error` for both (`formatter.ts:1490-1502`).
+ */
+export declare function isNodeNotFound(result: UipResult): boolean;

package/dist/registry/uip/envelope.js

@@ -6,7 +6,12 @@
  * itself is a `{ Result, Data, Message, … }` envelope whose key casing has
  * varied between tools. Three Python callers each had their own loop for
  * finding the document; this is the one loop, and the one accessor.
+ *
+ * It is also the one place that decides why a call FAILED ({@link failureReason}).
+ * Callers outside `registry/uip/` do not read a result's stderr themselves;
+ * `tests/uip-stderr-gate.test.ts` holds them to that.
  */
+import { pyStrip } from "../compat/pystr.js";
 /**
  * The first JSON document in `text`, or `undefined`.
  *
@@ -82,3 +87,78 @@ export function dataItems(envelope) {
 export function tail(text, limit = 300) {
     return text.length <= limit ? text : text.slice(text.length - limit);
 }
+/** A non-empty trimmed string, or `undefined`. */
+function said(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const text = pyStrip(value);
+    return text === "" ? undefined : text;
+}
+/**
+ * Why a `uip` call failed, as text a message can quote after a colon. Never empty.
+ *
+ * `uip … --output json` prints its FAILURE envelope on stdout, not stderr:
+ * `OutputFormatter.error` hands it to `logOutput`, which writes through
+ * `sink.writeOut` (uipath-cli `packages/common/src/formatter.ts:1657-1688` and
+ * `:654-675`). For example, `registry get` of a node the catalog does not serve
+ * exits 1 with this on stdout:
+ *
+ * ```json
+ * { "Result": "Failure", "Message": "Node not found",
+ *   "Instructions": "No node found with node type: uipath.connector.trigger.…" }
+ * ```
+ *
+ * and, on stderr, nothing, or a `[ManifestClient] fetchDynamicNodes ok: …`
+ * diagnostic, or a self-update banner. Callers that quoted stderr printed
+ * `registry get failed for <nodeType>: ` with nothing after the colon (2026-09-23
+ * eval, `skill-flow-datafabric-trigger-lifecycle`, v2 command 33).
+ *
+ * So the envelope is read first. The order is:
+ *
+ *  1. a call the client refused (`OfflineUipClient`): no process ran, and its
+ *     stderr already says so (`offline: refused to run …`), so that text is kept;
+ *  2. a call killed by its timeout: `timed out`, whatever partial output it left;
+ *  3. a non-Success envelope on stdout (found past any banner, keys read
+ *     case-insensitively): `<Message>: <Instructions>`, or whichever is present;
+ *  4. the end of stderr, then the end of stdout;
+ *  5. `no output`.
+ */
+export function failureReason(result) {
+    if (result.refused === true)
+        return said(result.stderr) ?? "not run (offline client refused the call)";
+    if (result.timedOut === true)
+        return "timed out (the call was killed before it answered)";
+    const envelope = parseEnvelope(result.stdout);
+    if (envelope !== undefined && !isSuccess(envelope)) {
+        const parts = [said(getCI(envelope, "Message")), said(getCI(envelope, "Instructions"))].filter((part) => part !== undefined);
+        if (parts.length > 0)
+            return parts.join(": ");
+    }
+    const stderr = said(result.stderr);
+    if (stderr !== undefined)
+        return tail(stderr);
+    const stdout = said(result.stdout);
+    if (stdout !== undefined)
+        return tail(stdout);
+    return "no output";
+}
+/**
+ * True when a failed `registry get` answered the CLI's own "not in the catalog"
+ * envelope, `Message: "Node not found"` (uipath-cli
+ * `packages/maestro-sdk/src/registry/command.ts:595-600`).
+ *
+ * Only that answer says the node is ABSENT. Every other failure — `Error
+ * retrieving node` (`command.ts:586-591`, which carries the thrown error in
+ * `Instructions`), a refusal, a timeout, output that is not JSON — says the
+ * lookup did not work, which is a different fact with a different remedy. The
+ * `Message` is the discriminator because the envelope's `ErrorCode` is the
+ * generic `unknown_error` for both (`formatter.ts:1490-1502`).
+ */
+export function isNodeNotFound(result) {
+    if (result.code === 0 || result.refused === true || result.timedOut === true)
+        return false;
+    const envelope = parseEnvelope(result.stdout);
+    if (envelope === undefined || isSuccess(envelope))
+        return false;
+    return said(getCI(envelope, "Message"))?.toLowerCase() === "node not found";
+}

package/dist/serialize.js

@@ -13,6 +13,7 @@ import { dirname, join } from 'node:path';
 import { Expr, toExpr, SCHEDULE_PRESETS, DELAY_PRESETS, parseIxpProjectType, flatNameOf, flatNameSegmentsOf } from './flow-sdk.js';
 import { FlowAction, FlowTrigger } from './core/node-classes.js';
 import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
+import { dataFabricUnknownInputs } from './core/typed-raw-node.js';
 import { bindingSelfNameMessage } from './core/binding-messages.js';
 import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeSlug } from './core/hitl-routing.js';
 import { declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
@@ -3474,8 +3475,18 @@ function eventDetail(rc, sub, nodeId, opts) {
         errorState: { issues: [] },
     };
 }
-/** Recursively render Exprs nested inside objects/arrays (for connector inputs). */
+/**
+ * Recursively render Exprs nested inside objects/arrays (for connector inputs).
+ *
+ * A lookup token is REFUSED, never rendered. `buildConnectorInputs` swaps every
+ * token it can place — a field's whole value, or an element of an array — so a
+ * token that reaches here sits where nothing resolves it: inside an object value,
+ * or in a custom node's inputs. Recursing into it would put `{"__lookup": …}` on
+ * the wire where the connector expects an id.
+ */
 function renderDeep(val, rename = NO_RENAME) {
+    if (isLookupToken(val))
+        throw new Error(misplacedLookupMessage(val));
     if (val instanceof Expr)
         return renderValue(val, rename);
     if (Array.isArray(val))
@@ -3488,6 +3499,13 @@ function renderDeep(val, rename = NO_RENAME) {
     }
     return val;
 }
+/** Why {@link renderDeep} refused a token: where a lookup CAN go, and what it would have emitted. */
+function misplacedLookupMessage(token) {
+    const { field, by, value } = token.__lookup;
+    return (`lookup('${field}') (${by}=${JSON.stringify(value)}) is in a position no lookup is resolved from: ` +
+        `a lookup() must be the whole value of a connector input, or an element of an array input. ` +
+        `Emitting it here would send a raw {"__lookup": …} object where the connector expects an id.`);
+}
 function newScope(outputs, vars = []) {
     return {
         nodes: [],
@@ -3911,7 +3929,14 @@ export function serialize(built, opts = {}) {
             display: { label, ...(def?.display?.icon ? { icon: def.display.icon } : {}) },
         };
         col++;
-        if (def?.model)
+        // A Data Fabric node gets no node-level `model`, whichever path emits it
+        // (the typed verbs, or a rawNode through emitContribution). Studio Web
+        // never writes one (flow-core node.ts: "`node.model` is never written";
+        // canvas `nodeToInstance` omits it), and export seeds it from the
+        // definition (services bpmn-to-xml.ts), so a copy here can only go stale.
+        // `outputs` stay: the canvas persists them (`source: '=response'`), and
+        // `variables.nodes[]` is derived from them.
+        if (def?.model && !type.startsWith('core.datafabric.'))
             node.model = subNodeId(clone(def.model), id);
         if (def?.outputDefinition)
             node.outputs = subNodeId(clone(def.outputDefinition), id);
@@ -4153,6 +4178,12 @@ export function serialize(built, opts = {}) {
         const connectorRefusal = connectorRawNodeRefusal(def.nodeType);
         if (connectorRefusal)
             throw new Error(`${where}: ${connectorRefusal}`);
+        // A Data Fabric key the product never reads (`_sortOptions`) is refused for
+        // every contribution, whichever class or SDK copy made it: `validate`
+        // cannot see it, and the node would ignore it at run time.
+        const unknownInput = dataFabricUnknownInputs(def.nodeType, def.version, contribution.inputs);
+        if (unknownInput?.severity === 'error')
+            throw new Error(`${where}: ${unknownInput.message}`);
         const id = stepUid(scope, stepName);
         const node = makeNode(def.nodeType, id, stepName, { parentId, def, requestedVersion });
         node.inputs = renderDeep(contribution.inputs ?? {}, scope.rename);
@@ -6118,16 +6149,35 @@ function buildConnectorInputs(rc, inputs, rename = NO_RENAME, resolutions = {},
         // NOT rendered as a placeholder: emitting something for a value nobody
         // resolved would produce a flow that compiles and then talks to the wrong
         // record, which is exactly the failure the lookup surface exists to remove.
-        if (isLookupToken(nested.value)) {
-            const resolved = resolvedValue(nested.value, resolutions);
-            if (resolved === undefined) {
-                if (policy.unresolvedLookups !== 'ignore')
-                    errs.push(unresolvedLookupMessage(nested.value));
+        //
+        // A token is swapped wherever the field's value can hold one: the whole
+        // value, or an element of an array at any depth. A multiselect is
+        // `users: [lookup(…), lookup(…)]` — the form `ConnectorLookupValue`'s array
+        // branch types and the generated `## Example` prints — and until this swapped
+        // only the whole-value case, so every token inside the array reached
+        // validation as an object ("expected string, got object") with every lookup
+        // recorded. An unresolved element under 'ignore' becomes `null`, which
+        // validation skips, so `check` still type-checks the resolved siblings.
+        const unresolved = [];
+        const swapped = swapLookupTokens(nested.value, resolutions, unresolved);
+        if (unresolved.length) {
+            if (policy.unresolvedLookups !== 'ignore') {
+                for (const token of unresolved)
+                    errs.push(unresolvedLookupMessage(token));
                 continue;
             }
-            nested = { ...nested, value: resolved };
+            if (isLookupToken(nested.value))
+                continue;
         }
-        validateConnectorFieldValue(f, nested.value, flat ? 0 : nested.projectedArrays, errs);
+        nested = { ...nested, value: swapped };
+        // A FLAT key whose wire name ends in `[*]` names one array: an array value
+        // there is checked element by element, as the nested form is. A flat scalar
+        // keeps depth 0 and is emitted as the scalar it is — the product wraps it
+        // into a one-element list (flow-v1 `convertDotNotationToNested`).
+        const depth = flat
+            ? (f.name.endsWith('[*]') && Array.isArray(nested.value) ? 1 : 0)
+            : nested.projectedArrays;
+        validateConnectorFieldValue(f, nested.value, depth, errs);
         if (f.location === 'multipart') {
             partValues.set(f.name, renderDeep(nested.value, rename));
             continue;
@@ -6195,6 +6245,29 @@ function buildConnectorInputs(rc, inputs, rename = NO_RENAME, resolutions = {},
     }
     return slots;
 }
+/**
+ * `value` with every lookup token swapped for its recorded id: the value itself,
+ * or the elements of an array at any depth. An unrecorded token is pushed to
+ * `unresolved` and stands as `null`, so an array keeps its length.
+ *
+ * Objects are NOT descended: a lookup's place is a field's value or an element
+ * of an array field (`ConnectorLookupValue`), and a nested path such as
+ * `contacts[*].id` reaches here already projected to its leaf array. A token
+ * anywhere else is refused by {@link renderDeep}.
+ */
+function swapLookupTokens(value, resolutions, unresolved) {
+    if (isLookupToken(value)) {
+        const resolved = resolvedValue(value, resolutions);
+        if (resolved === undefined) {
+            unresolved.push(value);
+            return null;
+        }
+        return resolved;
+    }
+    if (Array.isArray(value))
+        return value.map((item) => swapLookupTokens(item, resolutions, unresolved));
+    return value;
+}
 /**
  * `inputMetadata.multipart.bodyFieldName` names the CONTAINER part — the one the
  * runtime composes from `bodyParameters`. Measured on the designer's own nodes in

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

@@ -100,6 +100,15 @@
       "objectName": "create_issue",
       "path": "uipath-atlassian-jira/generic/create_issue/create@1.0.0.json"
     },
+    {
+      "nodeType": "uipath.connector.uipath-getresponse-getresponse.send-newsletter",
+      "version": "1.0.0",
+      "connectorKey": "uipath-getresponse-getresponse",
+      "label": "Send Newsletter",
+      "activityType": "Curated",
+      "objectName": "NewslettersSend-draft",
+      "path": "uipath-getresponse-getresponse/send-newsletter@1.0.0.json"
+    },
     {
       "nodeType": "uipath.connector.uipath-google-vertex.execute-google-vertex-agent",
       "version": "1.0.0",
@@ -136,6 +145,15 @@
       "objectName": "triggerFlow",
       "path": "uipath-microsoft-powerautomate/invoke-a-microsoft-power-automate-flow@1.0.0.json"
     },
+    {
+      "nodeType": "uipath.connector.uipath-salesforce-slack.create-group-direct-message",
+      "version": "1.0.0",
+      "connectorKey": "uipath-salesforce-slack",
+      "label": "Create Group Direct Message",
+      "activityType": "Curated",
+      "objectName": "conversations_open",
+      "path": "uipath-salesforce-slack/create-group-direct-message@1.0.0.json"
+    },
     {
       "nodeType": "uipath.connector.uipath-salesforce-slack.send-message-to-user",
       "version": "1.0.0",