@uipath/maestro-builder-sdk 6.60.0 → 6.61.0

package/dist/cli-library.d.ts

@@ -15,7 +15,8 @@ export { openCliLibrary, connectorCheckOpts, eventResolveErrorFor, byoaCheckOpts
 /**
  * Flow's check options from a library the CLI already opened: the shared
  * connector and event hooks, Flow's own field validator (it renders Flow
- * expressions, as `serialize` does), and the measured list envelopes.
+ * expressions, as `serialize` does), the measured list envelopes, and the
+ * library and bindings its serializer pass compiles with.
  *
  * One builder for `flow check` and `flow compile`'s check pass, so the two
  * cannot disagree.

package/dist/cli-library.js

@@ -5,14 +5,19 @@ export { openCliLibrary, connectorCheckOpts, eventResolveErrorFor, byoaCheckOpts
 /**
  * Flow's check options from a library the CLI already opened: the shared
  * connector and event hooks, Flow's own field validator (it renders Flow
- * expressions, as `serialize` does), and the measured list envelopes.
+ * expressions, as `serialize` does), the measured list envelopes, and the
+ * library and bindings its serializer pass compiles with.
  *
  * One builder for `flow check` and `flow compile`'s check pass, so the two
  * cannot disagree.
  */
 export function flowCheckOpts(library, bindings) {
     // Flow's own refusal of an operation `prepare` synthesized from Integration Service (BPMN-only).
-    const shared = connectorCheckOpts(library, bindings, connectorInputErrors, synthesizedDefinitionRefusal);
+    // The serializer pass gets what `compile` serializes with.
+    const shared = {
+        ...connectorCheckOpts(library, bindings, connectorInputErrors, synthesizedDefinitionRefusal),
+        ...(library ? { library } : {}),
+    };
     if (!library)
         return shared;
     return {

package/dist/cli-result.d.ts

@@ -32,8 +32,22 @@ export declare function reportDiagnostics(diags: ReadonlyArray<{
     level: string;
     code: string;
     message: string;
+    step?: string;
     suggestion?: string;
 }>): void;
+/**
+ * One diagnostic as `check` and `compile` print it: its mark and code, the
+ * message, the step it is on (unless the message already names it), and the
+ * suggestion. For instance
+ * `✗ [STEP_SWITCH_EXIT_UNKNOWN] no exit named "maybe". … (step "route")`.
+ */
+export declare function diagnosticLine(d: {
+    level: string;
+    code: string;
+    message: string;
+    step?: string;
+    suggestion?: string;
+}): string;
 /**
  * The error diagnostic for a throw that ends a compile: the error's own string
  * `code` when it carries one, else `COMPILE_FAILED`.

package/dist/cli-result.js

@@ -44,9 +44,26 @@ export function reportDiagnostics(diags) {
     reportResult({
         errors: diags.filter((d) => d.level === 'error').length,
         warnings: diags.filter((d) => d.level !== 'error').length,
-        diagnostics: diags.map((d) => ({ level: d.level, code: d.code, message: d.message, ...(d.suggestion ? { suggestion: d.suggestion } : {}) })),
+        diagnostics: diags.map((d) => ({
+            level: d.level, code: d.code, message: d.message,
+            ...(d.step !== undefined ? { step: d.step } : {}),
+            ...(d.suggestion ? { suggestion: d.suggestion } : {}),
+        })),
     });
 }
+/**
+ * One diagnostic as `check` and `compile` print it: its mark and code, the
+ * message, the step it is on (unless the message already names it), and the
+ * suggestion. For instance
+ * `✗ [STEP_SWITCH_EXIT_UNKNOWN] no exit named "maybe". … (step "route")`.
+ */
+export function diagnosticLine(d) {
+    // A step inside a subflow is `<caller> › <step>`; the message names the innermost one.
+    const named = d.step !== undefined && d.message.includes(`"${d.step.split(' › ').pop()}"`);
+    return `${d.level === 'error' ? '✗' : '⚠'} [${d.code}] ${d.message}`
+        + (d.step !== undefined && !named ? ` (step "${d.step}")` : '')
+        + (d.suggestion ? ` (did you mean "${d.suggestion}"?)` : '');
+}
 /**
  * The error diagnostic for a throw that ends a compile: the error's own string
  * `code` when it carries one, else `COMPILE_FAILED`.

package/dist/compile-cli.js

@@ -17,7 +17,7 @@
  * product's own gates are supposed to answer. `.build()` still throws on
  * structural problems; only the diagnostic pass is skipped.
  */
-import { reportDiagnostics, reportResult, thrownDiagnostic } from './cli-result.js';
+import { diagnosticLine, reportDiagnostics, reportResult, thrownDiagnostic } from './cli-result.js';
 import { writeJsonFile } from './core/json-file.js';
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
 import { basename, dirname, join, relative, resolve } from 'node:path';
@@ -80,7 +80,7 @@ export async function run(argv) {
         const diags = check(built, flowCheckOpts(library, bindings));
         const errors = diags.filter((d) => d.level === 'error');
         for (const d of diags)
-            console.error(`  ${d.level === 'error' ? '✗' : '⚠'} [${d.code}] ${d.message}${d.suggestion ? ` (did you mean "${d.suggestion}"?)` : ''}`);
+            console.error(`  ${diagnosticLine(d)}`);
         diagnostics.push(...diags);
         if (errors.length) {
             reportDiagnostics(diagnostics);

package/dist/core/compile-refusal.d.ts

@@ -17,5 +17,11 @@
  */
 export declare class CompileRefusal extends Error {
     readonly code: string;
-    constructor(code: string, message: string);
+    /**
+     * What to write instead, when the refusal knows (`check` reports it as the
+     * diagnostic's `suggestion`). For instance `value: 'approve'` for a
+     * `.stepSwitch` arm that names an exit the step does not declare.
+     */
+    readonly suggestion?: string;
+    constructor(code: string, message: string, suggestion?: string);
 }

package/dist/core/compile-refusal.js

@@ -17,10 +17,18 @@
  */
 export class CompileRefusal extends Error {
     code;
-    constructor(code, message) {
+    /**
+     * What to write instead, when the refusal knows (`check` reports it as the
+     * diagnostic's `suggestion`). For instance `value: 'approve'` for a
+     * `.stepSwitch` arm that names an exit the step does not declare.
+     */
+    suggestion;
+    constructor(code, message, suggestion) {
         super(message);
         // `name` stays `Error`, so a converted `throw new Error(…)` prints exactly as
         // it did (`Error: …` in `String(e)` and stacks). A subclass names itself.
         this.code = code;
+        if (suggestion !== undefined)
+            this.suggestion = suggestion;
     }
 }

package/dist/core/connector-checks.d.ts

@@ -154,7 +154,12 @@ export interface ConnectorCheckOpts {
  * author about everything ELSE that is wrong, which is the whole point of
  * running the cheap pass first.
  */
-export declare function checkConnectorLookups(where: string, spec: ConnectorSpec, opts: ConnectorCheckOpts, dialect: ExprDialect, report: ReportConnector): void;
+export declare function checkConnectorLookups(where: string, spec: ConnectorSpec, opts: ConnectorCheckOpts, dialect: ExprDialect, report: ReportConnector, 
+/**
+ * Whether to warn LOOKUP_UNRESOLVED. Flow's `check` does not: it runs the
+ * serializer, which refuses the node under that code.
+ */
+unresolvedWarning?: boolean): void;
 /**
  * The schema rules: an unprepared object, and unprepared custom fields.
  *
@@ -179,9 +184,7 @@ export declare function checkConnectorSchema(where: string, spec: ConnectorSpec,
  * bindings.json for the names); without them `check` stays a pure function of the
  * built model and says nothing, as before.
  */
-export declare function checkConnectorContract(where: string, spec: ConnectorSpec, opts: ConnectorCheckOpts, report: ReportConnector, 
-/** The activity's own id, for {@link connectionConnectorConflicts}; omit to record nothing. */
-id?: string): void;
+export declare function checkConnectorContract(where: string, spec: ConnectorSpec, opts: ConnectorCheckOpts, report: ReportConnector): void;
 /**
  * The binding-label rules `serialize`'s `resolveBinding` enforces, for one
  * `{ connection, folder }` pair — reported at every site that resolves one
@@ -195,12 +198,7 @@ id?: string): void;
 export declare function checkBindingLabels(where: string, labels: {
     connection?: unknown;
     folder?: unknown;
-} | undefined, opts: ConnectorCheckOpts, report: (code: 'BINDING_SELF_NAME' | 'BINDING_UNDECLARED', message: string) => void, target?: PrepareTarget, 
-/** The activity, and the connector its connection must belong to, for {@link connectionConnectorConflicts}. */
-use?: {
-    id: string;
-    connector: string | undefined;
-}): void;
+} | undefined, opts: ConnectorCheckOpts, report: (code: 'BINDING_SELF_NAME' | 'BINDING_UNDECLARED', message: string) => void, target?: PrepareTarget): void;
 /**
  * BINDING_MISSING: a connector-bound node with no `connection` or no `folder`
  * label — the sentence compile throws (see `requireBindingPair` in serialize).
@@ -231,23 +229,3 @@ export declare function lookupPhrases(field: string, lookup: LookupSpec, spec: C
     target: string;
     call: string;
 };
-/** One activity's use of a connection label, as the connector the connection must belong to. */
-export interface ConnectionUse {
-    /** The activity's own id — Flow's step name, BPMN's element id. */
-    id: string;
-    label: string;
-    connector: string;
-}
-/** Run `check`, and hand back the connection uses its binding-label rules saw. */
-export declare function collectConnectionUses(check: () => void): ConnectionUse[];
-/**
- * CONNECTION_CONNECTOR_CONFLICT — the rule `serialize` enforces on the emitted
- * document (`connectionConnectors`, bindings-v2.ts), reported here with the same
- * sentence so `check` does not print `✓ no issues` for a source `compile` then
- * refuses. Labels are grouped by what they resolve to, so two labels bound to
- * one connection id are one connection, as they are in the artifact.
- */
-export declare function connectionConnectorConflicts(uses: readonly ConnectionUse[], opts: ConnectorCheckOpts): {
-    id: string;
-    message: string;
-}[];

package/dist/core/connector-checks.js

@@ -26,7 +26,7 @@ import { isLookupToken, resolvedValue, } from './lookups.js';
 import { Expr } from './expr.js';
 import { extractRefs } from './expr-check.js';
 import { prepareCommand, resolveFlagArg } from './cli-spelling.js';
-import { bindingLabelRefusal, bindingMissingMessage, connectionConnectorConflictMessage, missingBindingLabels, } from './binding-messages.js';
+import { bindingLabelRefusal, bindingMissingMessage, missingBindingLabels, } from './binding-messages.js';
 /**
  * Flow: an input is an {@link Expr} object. A non-literal one is runtime; a
  * literal one (`lit(…)`) carries the constant it was built from.
@@ -80,7 +80,12 @@ export const EQUALS_EXPR_DIALECT = {
  * author about everything ELSE that is wrong, which is the whole point of
  * running the cheap pass first.
  */
-export function checkConnectorLookups(where, spec, opts, dialect, report) {
+export function checkConnectorLookups(where, spec, opts, dialect, report, 
+/**
+ * Whether to warn LOOKUP_UNRESOLVED. Flow's `check` does not: it runs the
+ * serializer, which refuses the node under that code.
+ */
+unresolvedWarning = true) {
     const specs = opts.lookups?.(spec.key, spec.action, spec.version, spec.object);
     const resolutions = opts.resolutions ?? {};
     // One LOOKUP_LITERAL_ID per field: a multiselect of three pasted ids is one
@@ -170,7 +175,7 @@ export function checkConnectorLookups(where, spec, opts, dialect, report) {
     };
     for (const [name, value] of Object.entries(spec.inputs ?? {}))
         visit(value, [name]);
-    if (unresolved.length)
+    if (unresolved.length && unresolvedWarning)
         report(unresolvedDiagnostic(where, spec, unresolved));
     if (literals.length)
         report(literalIdDiagnostic(where, spec, literals, dialect.descriptors));
@@ -328,9 +333,7 @@ export function checkConnectorSchema(where, spec, opts, dialect, report) {
  * bindings.json for the names); without them `check` stays a pure function of the
  * built model and says nothing, as before.
  */
-export function checkConnectorContract(where, spec, opts, report, 
-/** The activity's own id, for {@link connectionConnectorConflicts}; omit to record nothing. */
-id) {
+export function checkConnectorContract(where, spec, opts, report) {
     const target = { key: spec.key, action: spec.action, version: spec.version, object: spec.object };
     // The operation itself first: an operation compile cannot resolve has no field
     // contract to check, and `connectorInputs` answers "unknown" for it.
@@ -344,7 +347,7 @@ id) {
             report({ level: 'error', code: 'CONNECTOR_INPUT', message: `${where}: ${inputErr}` });
         }
     }
-    checkBindingLabels(where, spec, opts, (code, message) => report({ level: 'error', code, message }), { key: spec.key, action: spec.action }, id === undefined ? undefined : { id, connector: spec.key });
+    checkBindingLabels(where, spec, opts, (code, message) => report({ level: 'error', code, message }), { key: spec.key, action: spec.action });
 }
 /**
  * The binding-label rules `serialize`'s `resolveBinding` enforces, for one
@@ -356,13 +359,7 @@ id) {
  * Silent without a bindings.json, and for a label that resolves to anything
  * other than its own name (stub values are compile's CONNECTION_STUB warning).
  */
-export function checkBindingLabels(where, labels, opts, report, target, 
-/** The activity, and the connector its connection must belong to, for {@link connectionConnectorConflicts}. */
-use) {
-    const label = labels?.connection;
-    if (use?.connector && typeof label === 'string' && label !== '') {
-        connectionUsage?.push({ id: use.id, label, connector: use.connector });
-    }
+export function checkBindingLabels(where, labels, opts, report, target) {
     const bindings = opts.bindings;
     if (!bindings || !labels)
         return;
@@ -485,49 +482,3 @@ function runtimeLookupDiagnostic(where, spec, field, lookup, js, dialect) {
             : '');
     return { level: isEmail ? 'error' : 'warning', code: 'LOOKUP_RUNTIME_VALUE', message };
 }
-/**
- * The connection uses {@link checkBindingLabels} saw during the current check —
- * the model and every child model, which share one `bindings[]`. Module state
- * rather than a `ConnectorCheckOpts` field because a check is synchronous and
- * this is not an input; {@link collectConnectionUses} saves and restores it, so
- * a nested check cannot mix two models.
- */
-let connectionUsage;
-/** Run `check`, and hand back the connection uses its binding-label rules saw. */
-export function collectConnectionUses(check) {
-    const outer = connectionUsage;
-    connectionUsage = [];
-    try {
-        check();
-        return connectionUsage;
-    }
-    finally {
-        connectionUsage = outer;
-    }
-}
-/**
- * CONNECTION_CONNECTOR_CONFLICT — the rule `serialize` enforces on the emitted
- * document (`connectionConnectors`, bindings-v2.ts), reported here with the same
- * sentence so `check` does not print `✓ no issues` for a source `compile` then
- * refuses. Labels are grouped by what they resolve to, so two labels bound to
- * one connection id are one connection, as they are in the artifact.
- */
-export function connectionConnectorConflicts(uses, opts) {
-    const byConnection = new Map();
-    for (const use of uses) {
-        const key = opts.bindings?.resolve(use.label) ?? use.label;
-        const byConnector = byConnection.get(key) ?? new Map();
-        byConnection.set(key, byConnector);
-        byConnector.set(use.connector, [...(byConnector.get(use.connector) ?? []), use.id]);
-    }
-    const out = [];
-    for (const [key, byConnector] of byConnection) {
-        if (byConnector.size < 2)
-            continue;
-        out.push({
-            id: [...byConnector.values()][1][0],
-            message: connectionConnectorConflictMessage(key, byConnector),
-        });
-    }
-    return out;
-}

package/dist/core/connector-inputs.js

@@ -22,7 +22,7 @@
  * The ROUTING is the library's business either way: a field's location is a
  * property of the operation, not of the family emitting it.
  */
-import { isLookupToken, resolvedValue, unresolvedLookupMessage, } from './lookups.js';
+import { isLookupToken, resolvedValue, unresolvedLookupMessage, unresolvedLookupsMessage, } from './lookups.js';
 import { prepareCommand } from './cli-spelling.js';
 import { editDistance } from './edit-distance.js';
 /** Flow's dialect, re-exported so `serialize.ts` need not reach past this module. */
@@ -101,6 +101,8 @@ export function buildConnectorInputs(rc, inputs, opts) {
     const fields = (rc.fields ?? []);
     const byName = new Map(fields.map((f) => [f.name, f]));
     const errs = validateNestedConnectorKeys(fields, inputs, byName, dialect);
+    /** The unresolved lookups among `errs`: when they are all of them, the refusal is LOOKUP_UNRESOLVED. */
+    const owed = [];
     const routed = {
         bodyParameters: {}, pathParameters: {}, queryParameters: {},
     };
@@ -149,6 +151,7 @@ export function buildConnectorInputs(rc, inputs, opts) {
             if (policy.unresolvedLookups !== 'ignore') {
                 for (const token of unresolved)
                     errs.push(unresolvedLookupMessage(token));
+                owed.push(...unresolved);
                 continue;
             }
             if (isLookupToken(nested.value))
@@ -171,6 +174,11 @@ export function buildConnectorInputs(rc, inputs, opts) {
         const slot = ownEntry(SLOT_FOR_LOCATION, location) ?? 'bodyParameters';
         routed[slot][f.name] = render(nested.value);
     }
+    // Inputs that are fine but for lookups `prepare` has not recorded are that one
+    // condition, LOOKUP_UNRESOLVED, with the one command that records them all.
+    if (errs.length && owed.length === errs.length) {
+        throw new CompileRefusal('LOOKUP_UNRESOLVED', `connector ${rc.nodeType}: ${unresolvedLookupsMessage(owed)}`);
+    }
     if (errs.length) {
         // Name the location of each required field: a "missing required input" on a
         // path parameter reads very differently from one on a body field, and the

package/dist/core/event-checks.d.ts

@@ -135,7 +135,14 @@ export declare function eventParamsFor(subscription: unknown, opts: EventCheckOp
  * (compile repeats it as the hard failure), with the recorded answer looked up
  * under the event-form node type — the form `prepare` stores.
  */
-export declare function checkEventResolution(subscription: unknown, where: string, kind: 'trigger' | 'event', opts: EventCheckOpts, error: (code: string, message: string, suggestion?: string) => void, warn: (code: string, message: string, suggestion?: string) => void, eventParams?: EventParamFields): void;
+export declare function checkEventResolution(subscription: unknown, where: string, kind: 'trigger' | 'event', opts: EventCheckOpts, error: (code: string, message: string, suggestion?: string) => void, warn: (code: string, message: string, suggestion?: string) => void, eventParams?: EventParamFields, 
+/**
+ * Whether to report what `compile` refuses — an event the library cannot
+ * resolve (EVENT_UNKNOWN), an unverified BYOA connection, an unresolved
+ * `where` lookup. Flow's `check` passes `false`: it runs its serializer,
+ * which refuses each under the same code.
+ */
+compileRefusals?: boolean): void;
 /**
  * The compile-time refusal of a GENERIC event subscription that names no object,
  * or `undefined` when the resolved event is fine.
@@ -167,4 +174,10 @@ export declare function genericEventObjectRefusal(rc: {
 }, sub: {
     where?: unknown;
 }, objectOption: (object: string) => string): string | undefined;
-export declare function checkEventSubscription(subscription: unknown, where: string, at: (code: string, message: string, suggestion?: string) => void, warn?: (code: string, message: string, suggestion?: string) => void, eventParams?: EventParamFields): void;
+export declare function checkEventSubscription(subscription: unknown, where: string, at: (code: string, message: string, suggestion?: string) => void, warn?: (code: string, message: string, suggestion?: string) => void, eventParams?: EventParamFields, 
+/**
+ * Whether to report what `compile` refuses — a generic event with no object,
+ * a filter leaf it cannot lower, an ambiguous backslash. Flow's `check`
+ * passes `false`: it runs its serializer, which refuses each under the same code.
+ */
+compileRefusals?: boolean): void;

package/dist/core/event-checks.js

@@ -77,7 +77,14 @@ export function eventParamsFor(subscription, opts) {
  * (compile repeats it as the hard failure), with the recorded answer looked up
  * under the event-form node type — the form `prepare` stores.
  */
-export function checkEventResolution(subscription, where, kind, opts, error, warn, eventParams) {
+export function checkEventResolution(subscription, where, kind, opts, error, warn, eventParams, 
+/**
+ * Whether to report what `compile` refuses — an event the library cannot
+ * resolve (EVENT_UNKNOWN), an unverified BYOA connection, an unresolved
+ * `where` lookup. Flow's `check` passes `false`: it runs its serializer,
+ * which refuses each under the same code.
+ */
+compileRefusals = true) {
     const sub = subscription;
     if (!sub || typeof sub.connector !== 'string' || typeof sub.event !== 'string'
         || sub.connector === '' || sub.event === '')
@@ -97,11 +104,12 @@ export function checkEventResolution(subscription, where, kind, opts, error, war
         ...(typeof sub.object === 'string' ? { object: sub.object } : {}),
     });
     if (unresolved !== undefined) {
-        error('EVENT_UNKNOWN', `${where}: ${unresolved}`);
+        if (compileRefusals)
+            error('EVENT_UNKNOWN', `${where}: ${unresolved}`);
         return;
     }
     const object = typeof sub.object === 'string' && sub.object !== '' ? sub.object : undefined;
-    const byoa = opts.eventFacts && byoaUnverified(where, { connector: connectorKey, event: eventName, ...(object ? { object } : {}), connection: sub.connection }, opts.eventFacts(connectorKey, eventName, object), opts.byoa, opts.bindings);
+    const byoa = compileRefusals && opts.eventFacts && byoaUnverified(where, { connector: connectorKey, event: eventName, ...(object ? { object } : {}), connection: sub.connection }, opts.eventFacts(connectorKey, eventName, object), opts.byoa, opts.bindings);
     if (byoa)
         error(EVENT_BYOA_UNVERIFIED, byoa);
     if (eventParams?.objectUnprepared && object) {
@@ -126,7 +134,7 @@ export function checkEventResolution(subscription, where, kind, opts, error, war
     const resolutions = opts.resolutions ?? {};
     const scope = sub.where && typeof sub.where === 'object'
         ? Object.entries(sub.where) : [];
-    for (const [key, value] of scope) {
+    for (const [key, value] of compileRefusals ? scope : []) {
         if (!isLookupToken(value))
             continue;
         if (resolvedEventValue(value, resolutions) !== undefined)
@@ -242,7 +250,14 @@ export function genericEventObjectRefusal(rc, sub, objectOption) {
             : '')
         + `\`uip is triggers objects ${rc.connectorKey} ${String(op.eventOperation ?? '<EVENT>')} --connection-id <id>\` lists the objects.`;
 }
-export function checkEventSubscription(subscription, where, at, warn, eventParams) {
+export function checkEventSubscription(subscription, where, at, warn, eventParams, 
+/**
+ * Whether to report what `compile` refuses — a generic event with no object,
+ * a filter leaf it cannot lower, an ambiguous backslash. Flow's `check`
+ * passes `false`: it runs its serializer, which refuses each under the same code.
+ */
+compileRefusals = true) {
+    const refuse = compileRefusals ? at : () => { };
     const sub = subscription;
     if (!sub || typeof sub !== 'object') {
         at('EVENT_NO_SUBSCRIPTION', `${where} has no event subscription. Pass one: `
@@ -276,7 +291,7 @@ export function checkEventSubscription(subscription, where, at, warn, eventParam
     for (const [path, value] of scopeEntries.flatMap(([k, v]) => scopeStrings(v, k))) {
         const ambiguous = jmesStringProblem(value);
         if (ambiguous)
-            at('EVENT_FILTER_BACKSLASH', `${where}'s \`where.${path}\`: ${ambiguous}`);
+            refuse('EVENT_FILTER_BACKSLASH', `${where}'s \`where.${path}\`: ${ambiguous}`);
     }
     // The OBJECT half of the contract. A GENERIC event (`record-created` on Data
     // Fabric, Salesforce, ServiceNow, Jira, …) fires for ONE object of the connection
@@ -286,7 +301,7 @@ export function checkEventSubscription(subscription, where, at, warn, eventParam
     // built in, so an `object` there names a choice that does not exist.
     if (eventParams?.generic) {
         if (object === undefined) {
-            at('EVENT_GENERIC_NO_OBJECT', `${where} subscribes to a GENERIC event: \`${String(sub.connector)}\` \`${String(sub.event)}\` fires for ONE `
+            refuse('EVENT_GENERIC_NO_OBJECT', `${where} subscribes to a GENERIC event: \`${String(sub.connector)}\` \`${String(sub.event)}\` fires for ONE `
                 + `object of the connection (an entity, a table, a custom object) and the library carries no default. `
                 + `Name it with \`object\`.`
                 + (scopeObject !== undefined
@@ -347,28 +362,28 @@ export function checkEventSubscription(subscription, where, at, warn, eventParam
             filters.forEach((f, i) => {
                 const leaf = f;
                 if (!leaf || typeof leaf.field !== 'string' || leaf.field === '') {
-                    at('EVENT_FILTER_NO_FIELD', `${where}'s filters[${i}] has no \`field\` — name a field on the event payload, e.g. 'subject'.`);
+                    refuse('EVENT_FILTER_NO_FIELD', `${where}'s filters[${i}] has no \`field\` — name a field on the event payload, e.g. 'subject'.`);
                 }
                 const { keys, read } = readEventFilter(leaf);
                 if (keys.length === 0) {
-                    at('EVENT_FILTER_NO_VALUE', `${where}'s filters[${i}] has no operator. Write exactly one of ${operators} with its value — `
+                    refuse('EVENT_FILTER_NO_VALUE', `${where}'s filters[${i}] has no operator. Write exactly one of ${operators} with its value — `
                         + `\`contains\` is a case-sensitive substring test, the same one Integration Service applies `
                         + `server-side; \`lessThan\`/\`greaterThan\` order a number or an ISO date.`, `{ field: '${typeof leaf?.field === 'string' ? leaf.field : 'subject'}', contains: '<text>' }`);
                 }
                 else if (keys.length > 1) {
-                    at('EVENT_FILTER_MANY_OPERATORS', `${where}'s filters[${i}] carries ${keys.length} operators (${keys.join(', ')}); a condition has exactly `
+                    refuse('EVENT_FILTER_MANY_OPERATORS', `${where}'s filters[${i}] carries ${keys.length} operators (${keys.join(', ')}); a condition has exactly `
                         + `one. Write two conditions instead — they are ANDed.`);
                 }
                 else if (!read) {
-                    at('EVENT_FILTER_NO_VALUE', `${where}'s filters[${i}] gives \`${keys[0]}\` a value that is not a string, number or boolean.`);
+                    refuse('EVENT_FILTER_NO_VALUE', `${where}'s filters[${i}] gives \`${keys[0]}\` a value that is not a string, number or boolean.`);
                 }
                 else {
                     const ambiguous = typeof read.value === 'string' ? jmesStringProblem(read.value) : undefined;
                     const problem = eventFilterProblem(read);
                     if (ambiguous)
-                        at('EVENT_FILTER_BACKSLASH', `${where}'s filters[${i}] on \`${read.field}\`: ${ambiguous}`);
+                        refuse('EVENT_FILTER_BACKSLASH', `${where}'s filters[${i}] on \`${read.field}\`: ${ambiguous}`);
                     else if (problem)
-                        at('EVENT_FILTER_BAD_VALUE', `${where}'s filters[${i}] on \`${read.field}\`: ${problem}`);
+                        refuse('EVENT_FILTER_BAD_VALUE', `${where}'s filters[${i}] on \`${read.field}\`: ${problem}`);
                 }
             });
         }

package/dist/core/hitl-routing.d.ts

@@ -87,9 +87,18 @@ type EdgeLike = {
  * bare `completed` never is, unless the task asked for it with
  * `legacyCompleted: true` (`legacyCompleted` here).
  */
-export declare function hitlExitViolation(node: NodeLike, port: string, legacyCompleted?: boolean): {
+export declare function hitlExitViolation(node: NodeLike, port: string, legacyCompleted?: boolean, 
+/**
+ * How the task's main path leaves it, when the caller knows: on its primary
+ * outcome (`{ primary }`, a task routed per outcome), or on every outcome
+ * (`'every-outcome'`). It picks the remedy a `completed` refusal names.
+ */
+routing?: {
+    primary: string;
+} | 'every-outcome'): {
     code: 'HITL_COMPLETED_PORT_GONE' | 'HITL_OUTCOME_PORT_UNKNOWN';
     message: string;
+    suggestion?: string;
 } | undefined;
 /**
  * The post-emit half of the guard: every edge of an emitted scope, whatever

package/dist/core/hitl-routing.js

@@ -183,7 +183,13 @@ function outcomeIdsOf(node) {
  * bare `completed` never is, unless the task asked for it with
  * `legacyCompleted: true` (`legacyCompleted` here).
  */
-export function hitlExitViolation(node, port, legacyCompleted = false) {
+export function hitlExitViolation(node, port, legacyCompleted = false, 
+/**
+ * How the task's main path leaves it, when the caller knows: on its primary
+ * outcome (`{ primary }`, a task routed per outcome), or on every outcome
+ * (`'every-outcome'`). It picks the remedy a `completed` refusal names.
+ */
+routing) {
     if (!OUTCOME_HANDLE_NODE_TYPES.has(String(node.type)))
         return undefined;
     const ids = outcomeIdsOf(node);
@@ -193,17 +199,26 @@ export function hitlExitViolation(node, port, legacyCompleted = false) {
     if (port === 'completed') {
         if (legacyCompleted)
             return undefined;
+        const ports = ids.map((i) => `"outcome-${i}"`).join(', ');
         return {
             code: 'HITL_COMPLETED_PORT_GONE',
-            message: `human task "${String(node.id)}" has outcomes (${declared}), so the product draws no `
-                + `'completed' handle on it — an edge there is remapped to the primary outcome and every other `
-                + `outcome loses its path.`,
+            message: `Port "completed" does not exist on human task "${String(node.id)}". It has outcomes, so the `
+                + `product draws one handle per outcome (${ports}) and no 'completed' — an edge there is remapped to `
+                + `the primary outcome and the others lose their path.`
+                + (routing === 'every-outcome' ? ' .step() after this task already continues every outcome to the next step.'
+                    : routing !== undefined ? ` The FIRST outcome ("${routing.primary}") is what continues the main path.` : ''),
+            ...(routing === 'every-outcome'
+                ? { suggestion: "drop the 'completed' route — .step() continues every outcome — or route each outcome with .stepSwitch" }
+                : routing !== undefined
+                    ? { suggestion: `route the outcomes (.stepToList('outcome-${ids[1] ?? ids[0]}', …)), or continue every outcome to the next step with outcomePorts: false` }
+                    : {}),
         };
     }
     if (port.startsWith('outcome-') && !ids.includes(port.slice('outcome-'.length))) {
         return {
             code: 'HITL_OUTCOME_PORT_UNKNOWN',
-            message: `human task "${String(node.id)}" has no outcome for port "${port}" — it declares ${declared}.`,
+            message: `human task "${String(node.id)}" has no outcome for port "${port}" — it declares ${declared}. `
+                + `Ids are the outcome names slugified (lowercase, non-alphanumerics to '-').`,
         };
     }
     return undefined;

package/dist/core/lookups.d.ts

@@ -209,6 +209,19 @@ export declare function resolvedEventValue(token: LookupToken, resolutions: Look
  * @returns A diagnostic whose last line can be pasted into a shell.
  */
 export declare function unresolvedLookupMessage(token: LookupToken): string;
+/**
+ * The message for every lookup one node still owes, with the ONE `prepare` that
+ * records them all (it takes every `--resolve` in one invocation). For instance:
+ *
+ *   inputs `channel` (profile.email="ada@x.com"), `send_as` (name="bot") are unresolved lookups. …
+ *     npx flow-sdk registry prepare uipath-salesforce-slack --action send-message-to-user \
+ *       --resolve channel:profile.email=ada@x.com \
+ *       --resolve send_as:name=bot
+ *
+ * @param tokens - The node's unresolved lookups, at least one, all of one node type.
+ * @returns A message whose last lines can be pasted into a shell.
+ */
+export declare function unresolvedLookupsMessage(tokens: readonly LookupToken[]): string;
 type RawReference = {
     objectName?: string;
     path?: string;

package/dist/core/lookups.js

@@ -230,6 +230,32 @@ export function unresolvedLookupMessage(token) {
         // is a glob and a real name has spaces, and the last line is meant to paste.
         `    --resolve ${resolveFlagArg(field, by, String(value))}`);
 }
+/**
+ * The message for every lookup one node still owes, with the ONE `prepare` that
+ * records them all (it takes every `--resolve` in one invocation). For instance:
+ *
+ *   inputs `channel` (profile.email="ada@x.com"), `send_as` (name="bot") are unresolved lookups. …
+ *     npx flow-sdk registry prepare uipath-salesforce-slack --action send-message-to-user \
+ *       --resolve channel:profile.email=ada@x.com \
+ *       --resolve send_as:name=bot
+ *
+ * @param tokens - The node's unresolved lookups, at least one, all of one node type.
+ * @returns A message whose last lines can be pasted into a shell.
+ */
+export function unresolvedLookupsMessage(tokens) {
+    if (tokens.length === 1)
+        return unresolvedLookupMessage(tokens[0]);
+    const { nodeType } = tokens[0].__lookup;
+    const rest = nodeType.replace(/^uipath\.connector\.(?:trigger\.|event\.)?/, '');
+    const dot = rest.lastIndexOf('.');
+    const key = dot > 0 ? rest.slice(0, dot) : rest;
+    const action = dot > 0 ? rest.slice(dot + 1) : rest;
+    const named = tokens.map((t) => `\`${t.__lookup.field}\` (${t.__lookup.by}=${JSON.stringify(t.__lookup.value)})`);
+    const args = tokens.map((t) => `    --resolve ${resolveFlagArg(t.__lookup.field, t.__lookup.by, String(t.__lookup.value))}`);
+    return `inputs ${named.join(', ')} are unresolved lookups. `
+        + `Compile does not make network calls, so the values have to be resolved first:\n`
+        + `  ${prepareCommand(key, action)} \\\n${args.join(' \\\n')}`;
+}
 // ─── Classification, mirroring `_lookups.py` ─────────────────────────────────
 //
 // The generator decides which fields get a helper; `check` has to agree, or it

package/dist/core/refusals.d.ts

@@ -55,6 +55,7 @@ export declare const REFUSALS: {
     readonly CARRIED_DEFINITION_CONFLICT: "lowering";
     readonly CARRIED_DEFINITION_INVALID: "lowering";
     readonly CEQL_UNPARSEABLE: "lowering";
+    readonly COMPILE_FAILED: "lowering";
     readonly CONNECTION_CONNECTOR_CONFLICT: "draft";
     readonly CONNECTION_STUB: "lint";
     readonly CONNECTOR_IMPORT_NOT_A_FILE: "lowering";
@@ -209,6 +210,7 @@ export declare const REFUSALS: {
     readonly HITL_OUTCOME_ACTION: "lint";
     readonly HITL_OUTCOME_BAD_ID: "lint";
     readonly HITL_OUTCOME_NO_NAME: "lint";
+    readonly HITL_OUTCOME_PORTS_NONE: "lowering";
     readonly HITL_OUTCOME_PORTS_OFF: "lowering";
     readonly HITL_OUTCOME_PORTS_VARIANT: "lowering";
     readonly HITL_OUTCOME_PORT_MISPLACED: "lint";