@uipath/maestro-builder-sdk 6.60.0 → 6.61.0

package/dist/nodes/http/flow/node-type.js

@@ -68,7 +68,8 @@ function plainHttpInputs(i, ctx) {
     if (i.connection !== undefined
         || i.folder !== undefined
         || i.targetConnector !== undefined) {
-        throw new CompileRefusal('HTTP_BINDING_REQUIRES_MANAGED', 'standalone http cannot use Integration Service connection settings; set managed: true');
+        throw new CompileRefusal('HTTP_BINDING_REQUIRES_MANAGED', `Step "${ctx.step}" supplies Integration Service connection settings to the standalone HTTP node. `
+            + 'Only the managed node can use connection, folder, or targetConnector.', 'managed: true');
     }
     return {
         ...defaults(ctx, PLAIN),
@@ -92,7 +93,8 @@ function managedHttpBinding(i, ctx) {
         return undefined;
     if (typeof i.connection !== 'string' || i.connection.trim() === ''
         || typeof i.folder !== 'string' || i.folder.trim() === '') {
-        throw new CompileRefusal('HTTP_MANAGED_BINDING_INCOMPLETE', 'managed http connection mode requires both a non-empty connection and folder');
+        throw new CompileRefusal('HTTP_MANAGED_BINDING_INCOMPLETE', `Managed HTTP step "${ctx.step}" must name both a non-empty \`connection\` and \`folder\`. The platform `
+            + 'needs the pair to resolve the Integration Service connection at runtime.', `connection: 'http', folder: 'shared'`);
     }
     // The same resolution a connector step gets: a self-referential binding is an
     // error, a stub is a warning.
@@ -122,11 +124,12 @@ function managedHttpBinding(i, ctx) {
  */
 function managedHttpInputs(i, binding, ctx) {
     if (i.targetConnector !== undefined && !binding) {
-        throw new CompileRefusal('HTTP_TARGET_CONNECTOR_REQUIRES_BINDING', 'managed http targetConnector requires both a non-empty connection and folder');
+        throw new CompileRefusal('HTTP_TARGET_CONNECTOR_REQUIRES_BINDING', `Managed HTTP step "${ctx.step}" sets \`targetConnector\` without a connection and folder. `
+            + 'A connector-specific fallback needs the binding pair whose authentication it reuses.', `connection: 'slack', folder: 'shared'`);
     }
     if (i.targetConnector !== undefined
         && (typeof i.targetConnector !== 'string' || i.targetConnector.trim() === '')) {
-        throw new CompileRefusal('HTTP_TARGET_CONNECTOR_EMPTY', 'managed http targetConnector must be a non-empty connector key');
+        throw new CompileRefusal('HTTP_TARGET_CONNECTOR_EMPTY', `Managed HTTP step "${ctx.step}" sets an empty \`targetConnector\`; name its Integration Service connector key.`, `targetConnector: 'uipath-salesforce-slack'`);
     }
     const url = ctx.render(i.url);
     const bodyParameters = {

package/dist/nodes/queue/flow/check.d.ts

@@ -44,7 +44,8 @@ export declare function queueItemExprMessage(step: string, typeName: string, ver
  *  - `returns` on a step that does not wait (there is nothing per-tenant to
  *    declare), and a `wait: true` step whose result nothing can read.
  *  - a non-ISO `dueDate` / `deferDate`.
- *  - an expression in `item` when the definition stores the item as one JSON
- *    string (1.0): the serializer refuses it, so `check` reports it first.
+ *
+ * An expression in `item` when the definition stores the item as one JSON
+ * string (1.0) is the serializer's QUEUE_ITEM_EXPR_UNSUPPORTED.
  */
-export declare function checkQueueItem(inputs: QueueItemInputs | undefined, ctx: FlowCheckContext, typeName: string): void;
+export declare function checkQueueItem(inputs: QueueItemInputs | undefined, ctx: FlowCheckContext): void;

package/dist/nodes/queue/flow/check.js

@@ -64,10 +64,11 @@ export function queueItemExprMessage(step, typeName, version, field) {
  *  - `returns` on a step that does not wait (there is nothing per-tenant to
  *    declare), and a `wait: true` step whose result nothing can read.
  *  - a non-ISO `dueDate` / `deferDate`.
- *  - an expression in `item` when the definition stores the item as one JSON
- *    string (1.0): the serializer refuses it, so `check` reports it first.
+ *
+ * An expression in `item` when the definition stores the item as one JSON
+ * string (1.0) is the serializer's QUEUE_ITEM_EXPR_UNSUPPORTED.
  */
-export function checkQueueItem(inputs, ctx, typeName) {
+export function checkQueueItem(inputs, ctx) {
     const step = ctx.step;
     // Severity is the catalog's (QUEUE_DIAGNOSTICS): `at` and `warn` name the intent.
     const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
@@ -109,10 +110,10 @@ export function checkQueueItem(inputs, ctx, typeName) {
     else {
         const itemIsString = itemDataIsString(ctx.definition());
         for (const [k, v] of Object.entries(item)) {
-            if (v instanceof Expr && itemIsString) {
-                at('QUEUE_ITEM_EXPR_UNSUPPORTED', queueItemExprMessage(step, typeName, ctx.version, k));
+            // An expression where the pinned version stores one JSON string is the
+            // serializer's QUEUE_ITEM_EXPR_UNSUPPORTED.
+            if (v instanceof Expr && itemIsString)
                 continue;
-            }
             // An Expr is a reference the runtime resolves — its VALUE may be anything,
             // and nothing local can know, so it is not flagged here.
             if (v instanceof Expr)

package/dist/nodes/queue/flow/node-type.js

@@ -338,7 +338,7 @@ function queueAt(typeName, wait) {
                 ],
             };
         },
-        check: ({ inputs }, ctx) => checkQueueItem(inputs, ctx, typeName),
+        check: ({ inputs }, ctx) => checkQueueItem(inputs, ctx),
         // check collected no expressions for a queue step before the port; unchanged by it.
         expressions: () => [],
         output: ({ inputs }) => queueOutput(inputs, wait),

package/dist/nodes/transform/flow/check.d.ts

@@ -4,3 +4,5 @@ import { type TransformInputs } from './spec.js';
 /** Every code the Transform rules emit; all are errors. */
 export declare const TRANSFORM_DIAGNOSTICS: DiagnosticCatalog;
 export declare function checkTransform(inputs: TransformInputs, ctx: FlowCheckContext): void;
+/** Nearest member of a closed vocabulary, for a "did you mean" suggestion. */
+export declare function nearestIn(value: unknown, vocab: string[]): string | undefined;

package/dist/nodes/transform/flow/check.js

@@ -166,12 +166,9 @@ function checkVariant(step, inputs, ops, at) {
     if (variant === undefined || variant === null)
         return; // generic — chains freely
     const variants = Object.keys(VARIANT_OPERATION);
-    if (typeof variant !== 'string' || !variants.includes(variant)) {
-        at('TRANSFORM_VARIANT_UNKNOWN', `Transform "${step}" has variant ${JSON.stringify(variant)}, which is not a Transform node type. `
-            + `The emitted node would be "core.action.transform.${String(variant)}", which no runtime resolves. `
-            + `Valid: ${variants.join(', ')} — or omit \`variant\` for the generic chaining Transform.`, nearestIn(variant, variants));
+    // A variant that is not a Transform node type is the serializer's TRANSFORM_VARIANT_UNKNOWN.
+    if (typeof variant !== 'string' || !variants.includes(variant))
         return;
-    }
     const expected = ownEntry(VARIANT_OPERATION, variant);
     if (ops.length !== 1) {
         at('TRANSFORM_VARIANT_ONE_OP', `Transform "${step}" is the "${variant}" variant but carries ${ops.length} operations. A variant node runs `
@@ -190,7 +187,7 @@ function checkVariant(step, inputs, ops, at) {
     }
 }
 /** Nearest member of a closed vocabulary, for a "did you mean" suggestion. */
-function nearestIn(value, vocab) {
+export function nearestIn(value, vocab) {
     const v = typeof value === 'string' ? value.toLowerCase() : '';
     return vocab.find((c) => c.replace(/[-_]/g, '') === v.replace(/[^a-z]/g, ''))
         ?? vocab.find((c) => c.startsWith(v) || (v !== '' && v.startsWith(c)));

package/dist/nodes/transform/flow/node-type.js

@@ -10,7 +10,7 @@ import { Expr } from '../../../core/expr.js';
 import { wireExprBody } from '../../../core/wire-expr.js';
 import { jsonClone } from '../../../core/json-clone.js';
 import { VARIANT_OPERATION } from './spec.js';
-import { checkTransform } from './check.js';
+import { checkTransform, nearestIn } from './check.js';
 import { CompileRefusal } from '../../../core/compile-refusal.js';
 /**
  * Emit a transform's `inputs` in the canonical shape the node's runtime reads:
@@ -207,12 +207,12 @@ function transformAt(typeName, variant, version, factory) {
         kind: 'transform', typeName, version, factory: 'transform', definition: 'bundled',
         rawNode: { factory },
         serialize: ({ inputs }, ctx) => {
-            // Only the generic type matches an UNKNOWN variant, so check reports it
-            // (TRANSFORM_VARIANT_UNKNOWN). A compile that skipped check refuses here
-            // rather than emit the generic node, which would run and be the wrong node.
+            // Only the generic type matches an UNKNOWN variant: refused here rather
+            // than emit the generic node, which would run and be the wrong node.
             if (variant === undefined && inputs?.variant !== undefined && inputs.variant !== null) {
-                throw new CompileRefusal('TRANSFORM_VARIANT_UNKNOWN', `transform step "${ctx.step}": variant ${JSON.stringify(inputs.variant)} is not a Transform node type `
-                    + `(${VARIANTS.join(', ')}), so there is no node to emit. Fix the variant, or omit it for the generic Transform.`);
+                throw new CompileRefusal('TRANSFORM_VARIANT_UNKNOWN', `Transform "${ctx.step}" has variant ${JSON.stringify(inputs.variant)}, which is not a Transform node type. `
+                    + `The emitted node would be "core.action.transform.${String(inputs.variant)}", which no runtime resolves. `
+                    + `Valid: ${VARIANTS.join(', ')} — or omit \`variant\` for the generic chaining Transform.`, nearestIn(inputs.variant, VARIANTS));
             }
             const base = ctx.definition(typeName, version)?.outputDefinition;
             const typed = transformOutputs(base);

package/dist/raw-node.js

@@ -73,18 +73,18 @@ class RawNode extends FlowAction {
         this.spec = spec;
     }
     /**
-     * `check` surfaces the connector refusal as an error, a typed family as a
-     * warning, and an input a registered node type never reads as an error at a
-     * bundled version (a warning at any other); `compile` throws the errors
-     * (see {@link contribute}).
+     * `check` surfaces a typed family as a warning, and an input a registered node
+     * type never reads as a warning at a version the SDK does not bundle. The
+     * errors (a connector operation, an unread input at a bundled version) are
+     * `compile`'s refusals, which `check` reports by running it (see
+     * {@link contribute} and the serializer's `emitContribution`).
      */
     diagnostics() {
-        const refusal = connectorRawNodeRefusal(this.spec.nodeType);
-        if (refusal)
-            return [{ code: 'RAW_NODE_CONNECTOR', severity: 'error', message: refusal }];
+        if (connectorRawNodeRefusal(this.spec.nodeType))
+            return [];
         const out = [];
         const unknown = rawNodeInputProblem(this.spec.nodeType, this.spec.version, this.spec.inputs);
-        if (unknown)
+        if (unknown?.severity === 'warning')
             out.push({ code: 'RAW_NODE_UNKNOWN_INPUT', ...unknown });
         const typed = rawNodeTypedFamilyWarning(this.spec.nodeType);
         if (typed)

package/dist/serialize.d.ts

@@ -1,8 +1,7 @@
 import type { DefinitionReference } from './core/node-classes.js';
 import type { BuiltFlow } from './flow-sdk.js';
 import type { Library } from './library.js';
-import { type BindingRefusalCode } from './core/binding-messages.js';
-import type { Bindings } from './bindings.js';
+import { type BindingRefusalCode, type BindingsView } from './core/binding-messages.js';
 import { CONNECTOR_INPUT_MISSING, connectorInputErrors as coreConnectorInputErrors } from './core/connector-inputs.js';
 /**
  * What `compile` would refuse these connector inputs with, or `undefined` when it
@@ -35,9 +34,24 @@ export interface DraftFinding {
     /** The sentence the strict compile refuses with. */
     message: string;
 }
+/** A refusal a collect-mode serialize reported instead of throwing (see {@link SerializeOpts.collect}). */
+export interface CollectedRefusal {
+    code: string;
+    /** The sentence an ordinary compile refuses with. */
+    message: string;
+    /** What to write instead, when the refusal knows ({@link CompileRefusal.suggestion}). */
+    suggestion?: string;
+    /** The step whose emission threw; absent for a scope-level refusal. */
+    step?: string;
+    /** The node id claimed for `step`. */
+    nodeId?: string;
+    /** The calling steps of the subflows `step` sits in, outermost first; absent at the root. */
+    subflows?: string[];
+}
 export interface SerializeOpts {
     library?: Library;
-    bindings?: Bindings;
+    /** The project's bindings.json (`Bindings`), or any view that answers the label rules. */
+    bindings?: BindingsView;
     /**
      * Receives each {@link SerializeWarning}. `compile-cli` prints them as
      * `⚠ [CODE] …` after `check()`'s diagnostics; a caller that passes nothing
@@ -57,6 +71,27 @@ export interface SerializeOpts {
      * ordinary compile), behaviour is unchanged.
      */
     draft?: (finding: DraftFinding) => void;
+    /**
+     * Collect mode, for `check` (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.5).
+     *
+     * When given, a {@link CompileRefusal} that escapes one step's emission (or a
+     * root trigger's) is reported here, with the step's name and its node id, and
+     * an opaque stand-in takes the node's place (see `standInNode`), so the edges
+     * to and from it still resolve and every later step is judged too. A throw
+     * that is no refusal is reported the same way, as COMPILE_FAILED. A refusal at
+     * a site past a step's own emission (an edge out of it, a port list on it, a
+     * join it feeds) is reported on that step and emission goes on (`refuseOn`).
+     * A refusal that names no one step (two steps with one name, a variable plan,
+     * a layout key) is scope-level: it is reported with no step, and collection
+     * stops there, so `serialize` returns `undefined`. An `internal SDK error:`
+     * throw is never caught. The output, stand-ins and all, is for nothing to
+     * read: no caller writes it.
+     *
+     * For instance, a flow whose `notify` step names an input its connector does
+     * not declare, and whose `ticket` step pins an unregistered version, reports
+     * both, each on its own step, where an ordinary compile stops at the first.
+     */
+    collect?: (refusal: CollectedRefusal) => void;
     /**
      * Filled in by `serialize` with the extra files the flow needs beside the
      * `.flow`, relative to it: one `<source>/agent.json` per inline agent, plus a