@uipath/maestro-builder-sdk 6.68.7 → 6.69.1

package/dist/case/cli-library.js

@@ -8,18 +8,13 @@
  * both `case check` and `case compile`'s check pass call.
  */
 import { connectorCheckOpts } from '../core/cli-library.js';
-import { externalDescriptorRefusal, externalExecution } from './external.js';
-import { EVENT_GENERIC_NO_OBJECT, GenericEventNoObjectError, resolveCaseSubscription } from './subscription.js';
 /**
  * Case's check options from a library the CLI already opened, or `{}` without one.
  *
- * Only the hooks for refusals Case `compile` makes (see {@link CaseCheckOpts}):
- * the operation and event resolution (the event through `resolveCaseSubscription`,
- * compile's own call), a connector task's field contract and lookups (the
- * `=`-expression validator Case compile runs), and the schema-readiness warnings.
- * With `bindings`, the binding-label rules (BINDING_SELF_NAME, BINDING_UNDECLARED),
- * which Case `serialize` enforces through the same `bindingLabelRefusal`, and the
- * BYOA facts and ledger, for the refusal `resolveCaseSubscription` makes.
+ * The library and bindings themselves, for the serializer `check` runs in
+ * collect mode (it reports every refusal compile makes, from compile's own
+ * code), plus the hooks for the warnings only `check` gives: a connector task's
+ * lookup rules and the schema-readiness warnings.
  *
  * @param library - The library `openCliLibrary` returned, or `undefined`.
  * @param bindings - The project's bindings.json, as compile reads it.
@@ -30,46 +25,10 @@ export function caseCheckOpts(library, bindings) {
         return bindings ? { bindings } : {};
     const shared = connectorCheckOpts(library, bindings);
     return {
+        library,
         ...(bindings ? { bindings } : {}),
-        connectorResolveError: shared.connectorResolveError,
-        connectorInputs: shared.connectorInputs,
         lookups: shared.lookups,
         resolutions: shared.resolutions,
-        eventFacts: shared.eventFacts,
-        byoa: shared.byoa,
         schemaReadiness: shared.schemaReadiness,
-        externalDescriptorError: (kind, d) => {
-            let rc;
-            try {
-                rc = library.resolve(d.key, d.action, d.version, d.object);
-            }
-            catch {
-                return undefined; // connectorResolveError's to report
-            }
-            return externalDescriptorRefusal(kind, rc);
-        },
-        externalExecutionError: (owner, d, authored) => {
-            let rc;
-            try {
-                rc = library.resolve(d.key, d.action, d.version, d.object);
-            }
-            catch {
-                return undefined; // connectorResolveError's to report
-            }
-            const judged = externalExecution(owner, authored, rc.entry?.operation ?? {});
-            return judged?.code !== undefined ? { code: judged.code, message: judged.message } : undefined;
-        },
-        subscriptionError: (kind, sub) => {
-            try {
-                resolveCaseSubscription(library, kind, sub);
-                return undefined;
-            }
-            catch (error) {
-                return {
-                    code: error instanceof GenericEventNoObjectError ? EVENT_GENERIC_NO_OBJECT : 'EVENT_UNKNOWN',
-                    message: error instanceof Error ? error.message : String(error),
-                };
-            }
-        },
     };
 }

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

@@ -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,21 +1967,31 @@ 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);
-    // The authored mode and event, else the library's (#1369): the same call check makes.
+        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;
-    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, mode, event);
     const context = data.context;
     const metadataAt = context.findIndex((row) => row.name === 'metadata');
@@ -1886,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) {

package/dist/case/subscription.d.ts

@@ -22,16 +22,18 @@ export declare class GenericEventNoObjectError extends CompileRefusal {
 /**
  * Resolve a Case event subscription: `library.resolveEvent` with the
  * subscription's own `version` and `object`, then refuse a GENERIC event the
- * author named no object for.
+ * author named no object for. Whatever `resolveEvent` throws (a connector or
+ * event the library does not carry, a version or object it does not resolve)
+ * is one condition, an event compile cannot place: EVENT_UNKNOWN, as Flow's
+ * compile says.
  *
  * @param library - The connector library.
  * @param kind - `trigger` for an event trigger, `event` for a wait-for-connector task or rule.
  * @param sub - The authored subscription.
  * @param byoa - Where the subscription is and the bindings, to refuse an
- *   unverified BYOA connection; compile passes it, `check` does not (it reports
- *   that rule from the shared event rules).
+ *   unverified BYOA connection.
  * @returns The resolved event.
- * @throws What `resolveEvent` throws, {@link GenericEventNoObjectError}, or a `ByoaRefusal`.
+ * @throws EVENT_UNKNOWN, {@link GenericEventNoObjectError}, or a `ByoaRefusal`.
  */
 export declare function resolveCaseSubscription(library: Library, kind: 'trigger' | 'event', sub: EventSubscription, byoa?: {
     where: string;