@uipath/maestro-builder-sdk 6.68.6 → 6.69.0

package/dist/case/external.js

@@ -45,7 +45,8 @@ export function externalEventRefusal(owner, mode, event) {
             return undefined;
         return (`${owner} is on a "hybrid" object, which answers through an event: pass the event the object reports as ` +
             `event: { operation, mode } (for example { operation: "TRIGGER_CREATED", mode: "polling" }, ` +
-            `the "operation" and "eventMode" rows of the case spec result's caseShape.context). Without it the task has nothing to wait on.`);
+            `the "operation" and "eventMode" rows of the case spec result's caseShape.context), or prepare the connector so the ` +
+            `library records it. Without it the task has nothing to wait on.`);
     }
     if (mode === 'sync')
         return `${owner} is on a "sync" object, which answers inline and has no event; drop event, or fix mode.`;
@@ -79,6 +80,83 @@ export function externalServiceType(kind, mode) {
         return sync ? CASE_FORMAT_PROFILE.externalAgentSyncServiceType : CASE_FORMAT_PROFILE.externalAgentAsyncServiceType;
     return sync ? CASE_FORMAT_PROFILE.externalWorkflowSyncServiceType : CASE_FORMAT_PROFILE.externalWorkflowAsyncServiceType;
 }
+/** Check's and compile's code when an authored `mode` disagrees with the library. */
+export const EXTERNAL_TASK_MODE_MISMATCH = 'EXTERNAL_TASK_MODE_MISMATCH';
+/**
+ * The execution facts the connector library records for the object
+ * (`operation.executionType` and `operation.executionEvent`, from
+ * `registry build-library` / `registry prepare`, #1369). A value the SDK does
+ * not know is ignored, as if it were absent.
+ */
+export function libraryExecution(operation) {
+    const op = (operation ?? {});
+    const mode = isExternalExecutionMode(op.executionType) ? op.executionType : undefined;
+    const raw = op.executionEvent;
+    const event = mode !== undefined && mode !== 'sync' && typeof raw?.operation === 'string' && raw.operation
+        && isExternalEventMode(raw.mode)
+        ? { operation: raw.operation, mode: raw.mode }
+        : undefined;
+    return { ...(mode ? { mode } : {}), ...(event ? { event } : {}) };
+}
+/**
+ * The mode and event an external task is written with: what the author passed,
+ * else what the connector library records for the object. `check` and
+ * `serialize` both call this, so they refuse the same tasks with the same text.
+ *
+ * - `mode` comes from the author or the library. With neither, the task is
+ *   refused (EXTERNAL_TASK_MODE): a guessed default would compile an `async`
+ *   object to the sync contract without a word (#1370 was closed for that).
+ * - An authored `mode` the library contradicts is refused
+ *   (EXTERNAL_TASK_MODE_MISMATCH): the plan would run the wrong contract.
+ * - `event` comes from the author or, for an `async` / `hybrid` object, the
+ *   library; an authored one the library contradicts is refused
+ *   (EXTERNAL_TASK_EVENT), and so is any pair {@link externalEventRefusal} refuses.
+ *
+ * @param owner - The task as the message names it, e.g. `External Workflow task "Run"`.
+ * @param authored - The task's authored `mode` and `event`.
+ * @param operation - The resolved library entry's `operation`, or `undefined`
+ *   when no library is at hand (model-only `check`, which then judges only what
+ *   was authored and reports no missing mode).
+ * @returns The mode and event, or the refusal.
+ */
+export function externalExecution(owner, authored, operation) {
+    if (authored.mode !== undefined && !isExternalExecutionMode(authored.mode))
+        return {
+            code: 'EXTERNAL_TASK_MODE',
+            message: `${owner} mode must be the connector object's executionType: "sync", "async" or "hybrid".`,
+        };
+    const library = operation === undefined ? {} : libraryExecution(operation);
+    if (authored.mode !== undefined && library.mode !== undefined && authored.mode !== library.mode)
+        return {
+            code: EXTERNAL_TASK_MODE_MISMATCH,
+            message: `${owner} has mode "${authored.mode}", but the connector library records the object's executionType as ` +
+                `"${library.mode}"; the plan would run the wrong contract. Drop mode to use the library's, or fix it.`,
+        };
+    const mode = authored.mode ?? library.mode;
+    if (mode === undefined) {
+        if (operation === undefined)
+            return undefined; // model-only check: the library decides
+        return {
+            code: 'EXTERNAL_TASK_MODE',
+            message: `${owner} has no mode, and the connector library records no executionType for the object. ` +
+                `Pass mode: the object's executionType from its case spec result ` +
+                `(Data.EssentialConfiguration.essentialConfiguration.executionType), or rebuild the library with registry prepare.`,
+        };
+    }
+    const authoredEvent = authored.event;
+    if (authoredEvent !== undefined && library.event !== undefined
+        && (authoredEvent?.operation !== library.event.operation || authoredEvent?.mode !== library.event.mode))
+        return {
+            code: EXTERNAL_TASK_EVENT,
+            message: `${owner} has event ${JSON.stringify(authoredEvent)}, but the connector library records the object's event as ` +
+                `${JSON.stringify(library.event)}. Drop event to use the library's, or fix it.`,
+        };
+    const event = authoredEvent ?? (mode !== 'sync' ? library.event : undefined);
+    const refused = externalEventRefusal(owner, mode, event);
+    if (refused)
+        return { code: EXTERNAL_TASK_EVENT, message: refused };
+    return { mode, ...(event !== undefined ? { event } : {}) };
+}
 /** Check's code for {@link externalDescriptorRefusal}. */
 export const EXTERNAL_TASK_DESCRIPTOR_CONTRACT = 'EXTERNAL_TASK_DESCRIPTOR_CONTRACT';
 /**

package/dist/case/serialize.d.ts

@@ -1,13 +1,59 @@
 import { Library } from '../core/library.js';
-import { Bindings } from '../core/bindings.js';
+import { type BindingsView } from '../core/binding-messages.js';
 import { type CaseJsonPreservation } from './preserve.js';
 import type { BuiltCase } from './case-sdk.js';
+/** A refusal a collect-mode serialize reported instead of throwing (see {@link CaseSerializeOpts.collect}). */
+export interface CaseCollectedRefusal {
+    code: string;
+    /** The sentence an ordinary compile refuses with. */
+    message: string;
+    /** What to write instead, when the refusal knows ({@link CompileRefusal.suggestion}). */
+    suggestion?: string;
+    /**
+     * What the refusal is about, as `check` names it: a task's name, a stage's
+     * label, a trigger's label. Absent for a scope-level refusal.
+     */
+    where?: string;
+    /** The id of the node `where` names (the task, stage or trigger node). */
+    nodeId?: string;
+}
 /** Optional wiring for connector tasks — the library that resolves a connector
  * op, and the bindings that map its symbolic connection/folder to resources. */
 export interface CaseSerializeOpts {
     library?: Library;
-    bindings?: Bindings;
+    /** The project's bindings.json (`Bindings`), or any view that answers the label rules. */
+    bindings?: BindingsView;
+    /**
+     * Collect mode, for `check` (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.5, phase 8).
+     *
+     * When given, a {@link CompileRefusal} that escapes one node's emission is
+     * reported here instead of thrown, and emission goes on, so every later node
+     * is judged too. The nodes with their own catch are a trigger, a task, and
+     * each stage entry condition, exit condition and SLA (reported on its stage).
+     * A refused trigger or task is replaced by an opaque stand-in: its id, type
+     * and name, and `data: { standIn: true, spec: <the task as authored> }`, with
+     * nothing it had added to the root bindings. A throw that is no refusal is
+     * reported the same way, as COMPILE_FAILED, which is what `compile` reports.
+     * A refusal that names no one node (two stages with one label, a case exit
+     * rule, a variable default, a layout or preservation entry) is scope-level:
+     * it is reported with no `where`, and collection stops there, so `serialize`
+     * returns `undefined`. An `internal SDK error:` throw is never caught. The
+     * output is for nothing to read: no caller writes it.
+     *
+     * For instance, a case whose connector task "Notify" names an input the
+     * operation does not declare, and whose stage "Review" exits to a stage that
+     * does not exist, reports both, where an ordinary compile stops at the first.
+     */
+    collect?: (refusal: CaseCollectedRefusal) => void;
 }
+/**
+ * Serialize `built` to a caseplan. With {@link CaseSerializeOpts.collect}, the
+ * refusals are reported instead of thrown, and the result is `undefined` when
+ * a scope-level refusal stopped collection.
+ */
+export declare function serialize(built: BuiltCase, opts: CaseSerializeOpts & {
+    collect: NonNullable<CaseSerializeOpts['collect']>;
+}): Record<string, unknown> | undefined;
 export declare function serialize(built: BuiltCase, opts?: CaseSerializeOpts): Record<string, unknown>;
 export declare const CASE_NODE_LAYOUT_FIELDS: readonly ["position", "style", "measured", "width", "height", "zIndex"];
 /** How `applyPreservation` treats a field the target already has. */

package/dist/case/serialize.js

@@ -19,7 +19,7 @@ import { bindingLabelRefusal } from '../core/binding-messages.js';
 import { resolveEventWhere } from '../core/lookups.js';
 import { resolveCaseSubscription } from './subscription.js';
 import { dedupeConditionNames } from './rule-names.js';
-import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_EVENT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode, } from './external.js';
+import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, externalDescriptorRefusal, externalExecution, externalServiceType, } from './external.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS, caseVersionMismatch } from './format-profile.js';
 import { isResourceLabelRefusal, resolveResourceRef, resourceIdentity } from './resource-identity.js';
 import { ownEntry } from '../core/own-entry.js';
@@ -32,6 +32,7 @@ import { responseJsonSchema } from '../core/connector-response-schema.js';
 import { ruleShapeProblems } from './rule-options.js';
 import { CompileRefusal } from '../core/compile-refusal.js';
 import { implicitInArgBuiltTrigger, unboundInArgMessage } from './in-arg-binding.js';
+import { jsonClone } from '../core/json-clone.js';
 import { taskShapeProblems } from './task-shape.js';
 import { connectorPlaceholderData, isConnectorPlaceholder } from './connector-placeholder.js';
 /** The ids a serialize pass hashed from element ids, by the document it returned. */
@@ -92,6 +93,100 @@ function conditionNamer(built) {
     };
 }
 export function serialize(built, opts = {}) {
+    const collect = opts.collect;
+    if (!collect)
+        return serializeCase(built, opts);
+    try {
+        return serializeCase(built, opts);
+    }
+    catch (error) {
+        // A node's own refusal was taken by its catch (`collected`), so one that
+        // gets here was thrown outside any one node: scope-level, and collection
+        // stops. A throw that is no refusal is compile's COMPILE_FAILED; an internal
+        // SDK error is passed on.
+        const refusal = refusalOf(error);
+        collect({ code: refusal.code, message: refusal.message, ...(refusal.suggestion !== undefined ? { suggestion: refusal.suggestion } : {}) });
+        return undefined;
+    }
+}
+/**
+ * What a throw is, in collect mode: a refusal as it is, and any other throw (a
+ * `TypeError` on a spec the serializer has no refusal for) as COMPILE_FAILED,
+ * which is what `compile` reports for it. An `internal SDK error:` is passed on.
+ */
+function refusalOf(error) {
+    if (error instanceof CompileRefusal)
+        return error;
+    if (!(error instanceof Error) || error.message.startsWith('internal SDK error:'))
+        throw error;
+    return new CompileRefusal('COMPILE_FAILED', error.message);
+}
+/**
+ * Emit one node under collect mode's per-node catch. Outside collect mode this
+ * is just `emit()`. In it, a refusal escaping `emit` is reported on `where`
+ * (node `nodeId`), the root bindings and output ids the node had claimed are
+ * undone, and `standIn()` is returned in its place.
+ *
+ * The variable companions a node registered are kept, and its stand-in
+ * registers the rest (`standInCompanions`): they come from the outputs as
+ * authored, not from the part that was refused, so a preserved variable row or
+ * a read of one does not fail just because its writer was refused.
+ *
+ * The mark is the collections' sizes, so a node that emits cleanly costs
+ * nothing extra: every collection here is only added to, and Maps and Sets
+ * iterate in insertion order, so undoing is deleting what came after the mark.
+ */
+function collected(resolver, where, nodeId, emit, standIn) {
+    const collect = resolver.collect;
+    if (!collect)
+        return emit();
+    const mark = {
+        bindingSink: resolver.bindingSink.size,
+        offlineBindingIds: resolver.offlineBindingIds.size,
+        outputIds: resolver.outputIds.size,
+        elementSeededIds: resolver.elementSeededIds.length,
+    };
+    try {
+        return emit();
+    }
+    catch (error) {
+        const refusal = refusalOf(error);
+        collect({
+            code: refusal.code, message: refusal.message,
+            ...(refusal.suggestion !== undefined ? { suggestion: refusal.suggestion } : {}),
+            where, nodeId,
+        });
+        const after = (keys, size) => [...keys].slice(size);
+        for (const k of after(resolver.bindingSink.keys(), mark.bindingSink))
+            resolver.bindingSink.delete(k);
+        for (const k of after(resolver.offlineBindingIds.keys(), mark.offlineBindingIds))
+            resolver.offlineBindingIds.delete(k);
+        for (const k of after(resolver.outputIds, mark.outputIds))
+            resolver.outputIds.delete(k);
+        resolver.elementSeededIds.length = mark.elementSeededIds;
+        return standIn();
+    }
+}
+/** The root companions a stand-in's authored outputs need, the way an emitted node registers them. */
+function standInCompanions(resolver, outputs) {
+    for (const o of outputs ?? [])
+        if (!resolver.varCompanions.has(o.var))
+            resolver.varCompanions.set(o.var, { id: o.var, name: o.var, type: o.type, elementId: 'root', custom: true });
+}
+/**
+ * The value an author wrote, as plain JSON, for a stand-in. Deterministic, so
+ * two compiles of one unchanged task give equal stand-ins
+ * (docs/CHECK_COMPILE_CONTRACT_DESIGN.md D5).
+ */
+function authoredJson(value) {
+    try {
+        return value === undefined ? {} : jsonClone(value);
+    }
+    catch {
+        return {};
+    }
+}
+function serializeCase(built, opts) {
     const versionMismatch = caseVersionMismatch(built);
     if (versionMismatch)
         throw new CompileRefusal('VERSION_MISMATCH', versionMismatch);
@@ -119,6 +214,7 @@ export function serialize(built, opts = {}) {
         businessEvents: new Set((built.businessEvents ?? []).map((event) => event.name)),
         conditionName: conditionNamer(built),
         elementSeededIds: [],
+        ...(opts.collect ? { collect: opts.collect } : {}),
     };
     // Preallocate SLA + escalation ids (before any rule is emitted) so a
     // `sla-status-change` rule can resolve the `slaId`/`escalationId` it points at.
@@ -259,7 +355,7 @@ export function serialize(built, opts = {}) {
     // outputs bound (collected during stage emission above). A declared var wins
     // on a name clash. An own-name output (`id == var`) writes no root entry: like
     // the Designer, the output row is itself the variable `=vars.<id>` reads.
-    const variables = emitVariables(built.vars, ids, triggerNodeByRef, triggerNodes, built.triggers);
+    const variables = emitVariables(built.vars, ids, triggerNodeByRef, triggerNodes, built.triggers, resolver.collect);
     const inputOutputs = variables.inputOutputs;
     const declared = new Set(inputOutputs.map((e) => e.id));
     for (const [name, companion] of resolver.varCompanions)
@@ -961,7 +1057,7 @@ function reseed(value, ids) {
             value[key] = next;
     }
 }
-function emitVariables(vars, ids, triggerNodeByRef, triggerNodes, triggers) {
+function emitVariables(vars, ids, triggerNodeByRef, triggerNodes, triggers, collect) {
     const implicit = implicitInArgBuiltTrigger(triggers);
     const inputs = [];
     const outputs = [];
@@ -1019,8 +1115,9 @@ function emitVariables(vars, ids, triggerNodeByRef, triggerNodes, triggers) {
             // The Designer writes no other In-arg shape, and `uip maestro case validate
             // --strict` refuses an In-arg without its companion
             // (STRICT_INPUTOUTPUTS_COMPANION). Without `{ from }` the arg binds to the
-            // primary trigger (in-arg-binding.ts); when there is none it is refused
-            // (`check` reports the same code first).
+            // primary trigger (in-arg-binding.ts); when there is none it is refused.
+            // In collect mode each such arg is reported on its own name and left out,
+            // so `check` reports every one, once, from this rule.
             let node;
             if (vd.sourceTrigger) {
                 node = triggerNodeByRef.get(vd.sourceTrigger);
@@ -1029,8 +1126,13 @@ function emitVariables(vars, ids, triggerNodeByRef, triggerNodes, triggers) {
             }
             else if (implicit !== undefined)
                 node = triggerNodes[implicit];
-            else
-                throw new CompileRefusal('CASE_IN_ARG_UNBOUND', unboundInArgMessage(vd.name, triggers));
+            else {
+                const refusal = new CompileRefusal('CASE_IN_ARG_UNBOUND', unboundInArgMessage(vd.name, triggers));
+                if (!collect)
+                    throw refusal;
+                collect({ code: refusal.code, message: refusal.message, where: vd.name });
+                continue;
+            }
             entry.elementId = node.id;
             inputs.push(entry);
             inputOutputs.push({ id: vd.name, name: vd.name, type: vd.type, elementId: node.id, ...jsonSchemaFields(vd) });
@@ -1076,55 +1178,73 @@ function emitTriggers(triggers, ids, resolver) {
     const list = triggers.length ? triggers : [{ kind: 'manual' }];
     return list.map((t, i) => {
         const triggerId = i === 0 ? 'trigger_1' : ids.make('trigger_', 6, `trigger:${i}:${t.name ?? t.kind}`);
-        const data = {};
-        if (i > 0)
-            data.parentElement = { id: 'root', type: 'case-management:root' };
-        if (CASE_FORMAT_PROFILE.triggerTypeVersion)
-            data.typeVersion = CASE_FORMAT_PROFILE.triggerTypeVersion;
+        // Refused in collect mode, it is stood in, and every later node is still judged.
         const label = t.name ?? `Trigger ${i + 1}`;
-        if (CASE_FORMAT_PROFILE.triggerLabelField === 'display')
-            data.display = { label };
-        else
-            data.label = label;
-        if (t.description)
-            data.description = t.description;
-        if (t.kind === 'timer') {
-            data[CASE_FORMAT_PROFILE.triggerBagField] = {
-                timerType: 'timeCycle',
-                timeCycle: t.timeCycle,
-                serviceType: CASE_FORMAT_PROFILE.timerServiceType,
+        return collected(resolver, label, triggerId, () => emitTrigger(t, i, triggerId, resolver), () => {
+            standInCompanions(resolver, t.eventOutputs);
+            // Labelled as an emitted trigger is, so a `.layout({ triggers })` entry still finds it.
+            return {
+                id: triggerId,
+                [CASE_FORMAT_PROFILE.nodeTypeField]: CASE_FORMAT_PROFILE.triggerNodeType,
+                data: {
+                    ...(CASE_FORMAT_PROFILE.triggerLabelField === 'display' ? { display: { label } } : { label }),
+                    standIn: true,
+                    spec: authoredJson(t),
+                },
             };
-        }
-        else if (t.kind === 'event') {
-            // With no subscription this remains the byte-identical, serviceType-only
-            // placeholder. A subscription resolves through the same library/binding
-            // machinery as connector tasks and wait-for-connector bags.
-            const bag = t.eventSubscription
-                ? resolvedSubscriptionBag('trigger', t.eventSubscription, resolver, triggerId, `Event trigger "${label}"`)
-                : {
-                    serviceType: CASE_FORMAT_PROFILE.eventServiceType,
-                    // A placeholder that names its source object carries it the way
-                    // `case sdd convert` does: one `context[objectName]` row.
-                    ...(t.eventObject ? { context: [io('objectName', 'string', { value: t.eventObject })] } : {}),
-                };
-            if (t.eventOutputs?.length) {
-                const outputs = t.eventOutputs.map((o) => {
-                    const field = o.source.replace(/^=/, '').split('.').pop() || o.source;
-                    if (!resolver.varCompanions.has(o.var))
-                        resolver.varCompanions.set(o.var, { id: o.var, name: o.var, type: o.type, elementId: 'root', custom: true });
-                    return { name: field, var: o.var, source: o.source, type: o.type, value: o.var };
-                });
-                bag.outputs = [...(bag.outputs ?? []), ...outputs];
-            }
-            data[CASE_FORMAT_PROFILE.triggerBagField] = bag;
-        }
-        return {
-            id: triggerId,
-            [CASE_FORMAT_PROFILE.nodeTypeField]: CASE_FORMAT_PROFILE.triggerNodeType,
-            data,
-        };
+        });
     });
 }
+/** One trigger node (see {@link emitTriggers}). */
+function emitTrigger(t, i, triggerId, resolver) {
+    const data = {};
+    if (i > 0)
+        data.parentElement = { id: 'root', type: 'case-management:root' };
+    if (CASE_FORMAT_PROFILE.triggerTypeVersion)
+        data.typeVersion = CASE_FORMAT_PROFILE.triggerTypeVersion;
+    const label = t.name ?? `Trigger ${i + 1}`;
+    if (CASE_FORMAT_PROFILE.triggerLabelField === 'display')
+        data.display = { label };
+    else
+        data.label = label;
+    if (t.description)
+        data.description = t.description;
+    if (t.kind === 'timer') {
+        data[CASE_FORMAT_PROFILE.triggerBagField] = {
+            timerType: 'timeCycle',
+            timeCycle: t.timeCycle,
+            serviceType: CASE_FORMAT_PROFILE.timerServiceType,
+        };
+    }
+    else if (t.kind === 'event') {
+        // With no subscription this remains the byte-identical, serviceType-only
+        // placeholder. A subscription resolves through the same library/binding
+        // machinery as connector tasks and wait-for-connector bags.
+        const bag = t.eventSubscription
+            ? resolvedSubscriptionBag('trigger', t.eventSubscription, resolver, triggerId, `Event trigger "${label}"`)
+            : {
+                serviceType: CASE_FORMAT_PROFILE.eventServiceType,
+                // A placeholder that names its source object carries it the way
+                // `case sdd convert` does: one `context[objectName]` row.
+                ...(t.eventObject ? { context: [io('objectName', 'string', { value: t.eventObject })] } : {}),
+            };
+        if (t.eventOutputs?.length) {
+            const outputs = t.eventOutputs.map((o) => {
+                const field = o.source.replace(/^=/, '').split('.').pop() || o.source;
+                if (!resolver.varCompanions.has(o.var))
+                    resolver.varCompanions.set(o.var, { id: o.var, name: o.var, type: o.type, elementId: 'root', custom: true });
+                return { name: field, var: o.var, source: o.source, type: o.type, value: o.var };
+            });
+            bag.outputs = [...(bag.outputs ?? []), ...outputs];
+        }
+        data[CASE_FORMAT_PROFILE.triggerBagField] = bag;
+    }
+    return {
+        id: triggerId,
+        [CASE_FORMAT_PROFILE.nodeTypeField]: CASE_FORMAT_PROFILE.triggerNodeType,
+        data,
+    };
+}
 /** A stage's task sets as the serializer writes them — one set per parallel task (`v31TaskSets`). */
 function laneSets(lanes) {
     return v31TaskSets(lanes, (task) => task.entry.some((condition) => condition.rules.some((group) => group.some((r) => r.rule === 'runs-sequentially'))));
@@ -1149,14 +1269,18 @@ function emitStage(stage, lanes, si, stageId, laneTaskIds, ids, resolver) {
         data.description = stage.description;
     if (stage.required !== undefined)
         data.isRequired = stage.required;
+    // Each condition and SLA is judged on its own in collect mode, reported on the
+    // stage; a refused one is left out, and the stage's other parts are still judged.
+    const onStage = (emit) => collected(resolver, stage.label, stageId, emit, () => undefined);
+    const present = (items) => items.filter((item) => item !== undefined);
     if (stage.entry.length || stage.exception) {
-        data.entryConditions = stage.entry.map((c, i) => emitEntry(c, `${stage.label}:entry:${i}`, stageId, stage.label, ids, resolver));
+        data.entryConditions = present(stage.entry.map((c, i) => onStage(() => emitEntry(c, `${stage.label}:entry:${i}`, stageId, stage.label, ids, resolver))));
     }
     if (stage.exit.length || stage.exception) {
-        data.exitConditions = stage.exit.map((c, i) => emitExit(c, `${stage.label}:exit:${i}`, stageId, stage.label, ids, resolver));
+        data.exitConditions = present(stage.exit.map((c, i) => onStage(() => emitExit(c, `${stage.label}:exit:${i}`, stageId, stage.label, ids, resolver))));
     }
     if (stage.slaRules.length) {
-        data.slaRules = stage.slaRules.map((s, i, all) => emitSla(s, i, all.length, ids, resolver));
+        data.slaRules = present(stage.slaRules.map((s, i, all) => onStage(() => emitSla(s, i, all.length, ids, resolver))));
     }
     const nodeType = stage.exception && CASE_FORMAT_PROFILE.exceptionStageField === CASE_FORMAT_PROFILE.nodeTypeField
         ? CASE_FORMAT_PROFILE.exceptionStageValue
@@ -1172,8 +1296,23 @@ function emitStage(stage, lanes, si, stageId, laneTaskIds, ids, resolver) {
 }
 function emitTask(task, stageLabel, taskId, ids, resolver) {
     const type = task.kind === 'connector' ? CASE_FORMAT_PROFILE.connectorActivityNodeType : task.kind;
-    const node = { id: taskId, displayName: task.name, [CASE_FORMAT_PROFILE.nodeTypeField]: type };
     const stageId = resolver.stageIdByLabel.get(stageLabel);
+    // Collect mode's per-task catch: a refused task is stood in, and every later
+    // task is still judged.
+    return collected(resolver, task.name, taskId, () => emitTaskNode(task, stageLabel, stageId, taskId, type, ids, resolver), () => {
+        standInCompanions(resolver, task.outputs);
+        return {
+            id: taskId,
+            displayName: task.name,
+            [CASE_FORMAT_PROFILE.nodeTypeField]: type,
+            elementId: `${stageId}-${taskId}`,
+            data: { standIn: true, spec: authoredJson(task) },
+        };
+    });
+}
+/** One task node (see {@link emitTask}). */
+function emitTaskNode(task, stageLabel, stageId, taskId, type, ids, resolver) {
+    const node = { id: taskId, displayName: task.name, [CASE_FORMAT_PROFILE.nodeTypeField]: type };
     node.data = taskData(task, resolver, taskId, stageId, ids);
     // Every task carries `elementId: "<stageId>-<taskId>"`, the identity the
     // converter matches a task's io rows against:
@@ -1380,10 +1519,14 @@ function isResolvedSubscription(spec) {
 /** Resolve a Case event/wait subscription into the designer/runtime bag pinned
  * by the archived v1 artifacts. Placeholder bags never enter this path. */
 function resolvedSubscriptionBag(kind, spec, resolver, elementId, where) {
+    // The binding labels need no library, so they are judged first: a `check`
+    // without one still reports them.
+    refuseBindingLabels(resolver, spec, { where, target: { key: spec.connector, action: spec.event } });
     if (!resolver.library)
         throw new CompileRefusal('LIBRARY_REQUIRED', `${kind === 'trigger' ? 'event trigger' : 'wait-for-connector'} needs the connector library — `
             + `pass { library } to serialize or use uip maestro case compile --library.`);
-    const rc = resolveCaseSubscription(resolver.library, kind, spec, { where, bindings: resolver.bindings });
+    const library = resolver.library;
+    const rc = onTask(where, () => resolveCaseSubscription(library, kind, spec, { where, bindings: resolver.bindings }));
     const op = rc.entry.operation ?? {};
     const context = [io('connectorKey', 'string', { value: rc.connectorKey })];
     const target = { key: spec.connector, action: spec.event };
@@ -1399,7 +1542,7 @@ function resolvedSubscriptionBag(kind, spec, resolver, elementId, where) {
     return {
         serviceType: kind === 'trigger' ? CASE_FORMAT_PROFILE.eventServiceType : CASE_FORMAT_PROFILE.waitConnectorServiceType,
         context,
-        inputs: [eventInput(resolveEventWhere(spec.where, resolver.library.lookupResolutions, `${kind === 'trigger' ? 'event trigger' : 'wait-for-connector'} "${elementId}"`), elementId)],
+        inputs: [eventInput(resolveEventWhere(spec.where, library.lookupResolutions, where), elementId)],
         outputs: connectorOutputs(rc, elementId, resolver),
         bindings: [],
     };
@@ -1754,9 +1897,11 @@ function businessRuleTaskData(task, resolver, elementId, ids) {
  * referenced as `=bindings.<id>`, with the binding entry collected at case root.
  */
 function connectorTaskData(spec, resolver, elementId, where, executionType, event) {
+    refuseBindingLabels(resolver, spec, { where, target: { key: spec.key, action: spec.action } });
     if (!resolver.library)
         throw new CompileRefusal('LIBRARY_REQUIRED', `connector task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
-    const rc = resolver.library.resolve(spec.key, spec.action, spec.version, spec.object);
+    const library = resolver.library;
+    const rc = onTask(where, () => resolveOperation(library, spec));
     const op = rc.entry.operation ?? {};
     const context = [
         io('connectorKey', 'string', { value: rc.connectorKey }),
@@ -1784,11 +1929,11 @@ function connectorTaskData(spec, resolver, elementId, where, executionType, even
     // operation); the SPELLING of the path/query keys is Case's own: the Case
     // designer camelCases them (`send_as` → `sendAs`, see
     // `fixtures/execute-connector-activity.sample.json`), and the body is nested.
-    const slots = buildConnectorInputs(rc, spec.inputs ?? {}, {
+    const slots = onTask(where, () => buildConnectorInputs(rc, spec.inputs ?? {}, {
         dialect: EQUALS_EXPR_DIALECT,
-        resolutions: resolver.library.lookupResolutions,
-        lookups: resolver.library.lookupSpecs(spec.key, spec.action, spec.version, spec.object),
-    });
+        resolutions: library.lookupResolutions,
+        lookups: library.lookupSpecs(spec.key, spec.action, spec.version, spec.object),
+    }));
     const camelKeys = (slot) => Object.fromEntries(Object.entries(slot ?? {}).map(([name, value]) => [toCamel(name), value]));
     const pathParameters = camelKeys(slots.pathParameters);
     const queryParameters = camelKeys(slots.queryParameters);
@@ -1822,30 +1967,42 @@ function connectorTaskData(spec, resolver, elementId, where, executionType, even
  * "v2"`, and the sync or async service type that execution type gives.
  */
 function externalTaskData(kind, spec, resolver, elementId, where) {
+    // What needs no library first, so a `check` without one still reports it: the
+    // authored mode and event judged alone (`externalExecution` with no operation
+    // only refuses what is wrong whatever the library says), and the binding names.
+    const authored = externalExecution(where, spec, undefined);
+    if (authored?.code !== undefined)
+        throw new CompileRefusal(authored.code, authored.message);
+    if (!spec.connector.connection?.trim())
+        throw new CompileRefusal('EXTERNAL_TASK_CONNECTION', `${where} requires a non-empty connection binding name.`);
+    if (!spec.connector.folder?.trim())
+        throw new CompileRefusal('EXTERNAL_TASK_FOLDER', `${where} requires a non-empty folder binding name.`);
+    refuseBindingLabels(resolver, spec.connector, { where, target: { key: spec.connector.key, action: spec.connector.action } });
     if (!resolver.library)
         throw new CompileRefusal('LIBRARY_REQUIRED', `${kind} task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
-    const rc = resolver.library.resolve(spec.connector.key, spec.connector.action, spec.connector.version, spec.connector.object);
+    const library = resolver.library;
+    const rc = onTask(where, () => resolveOperation(library, spec.connector));
     const refused = externalDescriptorRefusal(kind, rc);
     if (refused)
-        throw new CompileRefusal(EXTERNAL_TASK_DESCRIPTOR_CONTRACT, refused);
-    if (!isExternalExecutionMode(spec.mode))
-        throw new CompileRefusal('EXTERNAL_TASK_MODE', `${kind} task mode must be the connector object's executionType: "sync", "async" or "hybrid".`);
-    const eventRefused = externalEventRefusal(where, spec.mode, spec.event);
-    if (eventRefused)
-        throw new CompileRefusal(EXTERNAL_TASK_EVENT, eventRefused);
-    if (!spec.connector.connection || !spec.connector.folder)
-        throw new CompileRefusal(spec.connector.connection ? 'EXTERNAL_TASK_FOLDER' : 'EXTERNAL_TASK_CONNECTION', `${kind} task requires non-empty connection and folder binding names.`);
-    const data = connectorTaskData(spec.connector, resolver, elementId, where, spec.mode, spec.event);
+        throw new CompileRefusal(EXTERNAL_TASK_DESCRIPTOR_CONTRACT, `${where}: ${refused}`);
+    // The authored mode and event, else the library's (#1369).
+    const execution = externalExecution(where, spec, rc.entry?.operation ?? {});
+    if (!execution)
+        throw new Error(`internal SDK error: ${where} was judged without its library operation.`);
+    if (execution.code !== undefined)
+        throw new CompileRefusal(execution.code, execution.message);
+    const { mode, event } = execution;
+    const data = connectorTaskData(spec.connector, resolver, elementId, where, mode, event);
     const context = data.context;
     const metadataAt = context.findIndex((row) => row.name === 'metadata');
     // The Designer's order: the event pair (when the object answers through one),
     // then the execution type, just before `metadata`.
-    context.splice(metadataAt, 0, ...(spec.event ? [
-        io('operation', 'string', { value: spec.event.operation }),
-        io('eventMode', 'string', { value: spec.event.mode }),
-    ] : []), io('executionType', 'string', { value: spec.mode }));
+    context.splice(metadataAt, 0, ...(event ? [
+        io('operation', 'string', { value: event.operation }),
+        io('eventMode', 'string', { value: event.mode }),
+    ] : []), io('executionType', 'string', { value: mode }));
     context.push(io('activityConfigurationVersion', 'string', { value: 'v2' }));
-    return { ...data, serviceType: externalServiceType(kind, spec.mode) };
+    return { ...data, serviceType: externalServiceType(kind, mode) };
 }
 /** A context/output name/value entry (the caseplan `InputOutput` shape). */
 function io(name, type, extra) {
@@ -1884,6 +2041,53 @@ function offlineBindingId(resolver, seed) {
     }
     return id;
 }
+/**
+ * A connector operation from the library. A throw `library.resolve` makes on no
+ * purpose is still a refusal, CONNECTOR_RESOLVE_FAILED, the code `check` has
+ * always given it (#1015).
+ */
+function resolveOperation(library, spec) {
+    try {
+        return library.resolve(spec.key, spec.action, spec.version, spec.object);
+    }
+    catch (error) {
+        if (error instanceof CompileRefusal || (error instanceof Error && error.message.startsWith('internal SDK error:')))
+            throw error;
+        throw new CompileRefusal('CONNECTOR_RESOLVE_FAILED', error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Run `fn`, naming the task or subscription site (`where`) in a refusal it throws. The library's
+ * refusals (the operation, its fields) name the connector, not the task: they
+ * say which task as `check` always has (`Connector task "Post": connector not
+ * in library: …`).
+ */
+function onTask(where, fn) {
+    try {
+        return fn();
+    }
+    catch (error) {
+        // A refusal that already names the site (a BYOA refusal) is passed on as it is.
+        if (!(error instanceof CompileRefusal) || error.message.startsWith(`${where}: `))
+            throw error;
+        throw new CompileRefusal(error.code, `${where}: ${error.message}`, error.suggestion);
+    }
+}
+/**
+ * Refuse a connection or folder label bindings.json cannot answer, before
+ * anything that needs the library: the refusal `bindingRef` and
+ * `folderBindingRef` make, so `check` reports it with no library too.
+ */
+function refuseBindingLabels(resolver, labels, site) {
+    for (const attribute of ['connection', 'folder']) {
+        const name = labels[attribute];
+        if (!name)
+            continue;
+        const refused = bindingLabelRefusal(resolver.bindings, name, attribute, site.where, site.target);
+        if (refused)
+            throw refused;
+    }
+}
 /** Resolve a symbolic connection/folder to a root binding entry (collected once),
  * returning its id + resourceKey for the `=bindings.<id>` reference. */
 function bindingRef(resolver, name, resource, propertyAttribute, displayName, site) {