@uipath/maestro-builder-sdk 6.68.7 → 6.69.0

package/dist/case/check.d.ts

@@ -1,80 +1,48 @@
 /**
- * case/check — fast static validation of a BuiltCase before serialization.
+ * case/check — fast validation of a BuiltCase.
  *
  * Surfaces the common `uip maestro case validate` failures early (task without
  * an entry rule, case/stage without a completion rule, an unsatisfiable
- * `required-tasks-completed`, unresolved stage/task references, duplicate stage
- * labels) so authoring gets instant feedback. The authoritative gate is still
- * `uip maestro case validate` / `@uipath/case-schema` on the emitted file.
+ * `required-tasks-completed`) so authoring gets instant feedback, and runs the
+ * serializer in collect mode (`serializerRefusals`), so it also reports every
+ * refusal `compile` would raise (unresolved stage/task references, duplicate
+ * stage labels, a connector input the operation does not declare), each from
+ * its one implementation and placed on its task, stage or trigger
+ * (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.5, phase 8). The authoritative gate
+ * is still `uip maestro case validate` / `@uipath/case-schema` on the emitted file.
  */
 import type { BuiltCase } from './case-sdk.js';
 import { type ConnectorCheckOpts } from '../core/connector-checks.js';
-import type { EventSubscription } from '../core/actions.js';
-import { type EventCheckOpts } from '../core/event-checks.js';
+import type { Library } from '../core/library.js';
 export interface Diagnostic {
     level: 'error' | 'warning';
     code: string;
     message: string;
+    /** What the finding is about: a task's name, a stage's label, a trigger's label. */
     where?: string;
     suggestion?: string;
+    /** The id of the node `where` names, for a refusal the serializer placed on one (`serializerRefusals`). */
+    nodeId?: string;
 }
 /**
  * The connector-library facts Case `check` reads, from the same `Library`
  * instance `compile` serializes against (`caseCheckOpts` in `./cli-library.ts`).
  *
- * Deliberately NARROWER than Flow's bag. An error here must be a refusal Case
- * `compile` actually makes. Case `serialize` resolves the connector operation and
- * the event, and validates a connector task's inputs and resolves its lookups
- * through the shared `buildConnectorInputs` (`connectorInputs`, `lookups`,
- * `resolutions`), and refuses a connection/folder label bindings.json cannot
- * turn into a resource key (`bindings`, `bindingLabelRefusal`), and refuses an
- * event on an unverified BYOA connection (`eventFacts`, `byoa`).
+ * `check` runs the serializer in collect mode (`serializerRefusals`), with
+ * `library` and `bindings`, so every refusal `compile` makes (an operation or
+ * event the library cannot resolve, a connector input the operation does not
+ * declare, an unrecorded lookup, a binding label bindings.json cannot answer,
+ * an unverified BYOA connection, an external task's descriptor contract) is
+ * reported from its one implementation. The other hooks feed the warnings only
+ * `check` gives: the schema-readiness warnings and the lookup rules of
+ * `checkConnectorLookups`.
  *
- * Every hook fails open: without a library, `check` stays a pure function of the
- * built model.
+ * Every hook fails open: without a library, `check` judges a connector task up
+ * to the library, as `compile` would.
  */
-export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'connectorResolveError' | 'connectorInputs' | 'lookups' | 'resolutions' | 'schemaReadiness' | 'bindings'> & Pick<EventCheckOpts, 'eventFacts' | 'byoa'> & {
-    /**
-     * What Case `compile` would refuse an event subscription with, or `undefined`
-     * when it resolves: `EVENT_UNKNOWN` (the event is not in the library, or
-     * refuses the `object`) or `EVENT_GENERIC_NO_OBJECT` (a GENERIC event with no
-     * `object`). Built on `resolveCaseSubscription`, the call compile makes.
-     */
-    /**
-     * What Case `compile` would refuse an External Agent / External Workflow
-     * task's resolved descriptor with (`externalDescriptorRefusal`), or
-     * `undefined`: also `undefined` when the descriptor does not resolve, which
-     * `connectorResolveError` reports.
-     */
-    externalDescriptorError?: (kind: 'external-agent' | 'external-workflow', descriptor: {
-        key: string;
-        action: string;
-        version?: string;
-        object?: string;
-    }) => string | undefined;
-    /**
-     * What Case `compile` would refuse an External Agent / External Workflow
-     * task's mode and event with, judged against what the library records for
-     * the object (`externalExecution`): EXTERNAL_TASK_MODE (no mode from the
-     * author or the library), EXTERNAL_TASK_MODE_MISMATCH, EXTERNAL_TASK_EVENT.
-     * `undefined` when they are fine, or the descriptor does not resolve.
-     */
-    externalExecutionError?: (owner: string, descriptor: {
-        key: string;
-        action: string;
-        version?: string;
-        object?: string;
-    }, authored: {
-        mode?: unknown;
-        event?: unknown;
-    }) => {
-        code: string;
-        message: string;
-    } | undefined;
-    subscriptionError?: (kind: 'trigger' | 'event', subscription: EventSubscription) => {
-        code: string;
-        message: string;
-    } | undefined;
+export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'lookups' | 'resolutions' | 'schemaReadiness' | 'bindings'> & {
+    /** The library `compile` serializes against, for the serializer `check` runs. */
+    library?: Library;
 };
 /**
  * Validate a built case.

package/dist/case/check.js

@@ -1,16 +1,9 @@
-import { businessEventProblems } from './business-event-shape.js';
-import { isUnboundInArg, unboundInArgMessage } from './in-arg-binding.js';
-import { ruleShapeProblems } from './rule-options.js';
 import { types } from '../core/expr.js';
-import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS, authoredCaseVersion, caseVersionMismatch } from './format-profile.js';
+import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS, authoredCaseVersion } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
-import { caseJsonPreservation, caseJsonPreservationErrors, preservedBindings } from './preserve.js';
-import { EQUALS_EXPR_DIALECT, checkBindingLabels, checkConnectorContract, checkConnectorLookups, checkConnectorSchema, } from '../core/connector-checks.js';
-import { checkEventResolution } from '../core/event-checks.js';
-import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, externalExecution } from './external.js';
-import { isResourceLabelRefusal, resolveResourceRef } from './resource-identity.js';
-import { taskShapeProblems } from './task-shape.js';
+import { EQUALS_EXPR_DIALECT, checkConnectorLookups, checkConnectorSchema, } from '../core/connector-checks.js';
 import { isConnectorPlaceholder } from './connector-placeholder.js';
+import { serialize } from './serialize.js';
 const TYPE_NAMES = new Set(Object.values(types));
 // audit-case-coverage: rule-slot table start
 // This runtime table must equal the committed matrix's rejected cells. The audit
@@ -26,17 +19,6 @@ const ILLEGAL = [];
  */
 export function check(built, opts = {}) {
     const diags = [];
-    // The same registry `serialize` resolves against, so the two agree on which
-    // labels a decompiled source's preserved binding rows answer.
-    const bindings = preservedBindings(opts.bindings, caseJsonPreservation(built));
-    if (bindings !== opts.bindings)
-        opts = { ...opts, bindings };
-    for (const message of caseJsonPreservationErrors(caseJsonPreservation(built)))
-        diags.push({
-            level: 'error',
-            code: 'PRESERVATION_COLLISION',
-            message: `Invalid Case JSON preservation payload: ${message}.`,
-        });
     if (!built.id)
         diags.push({ level: 'error', code: 'NO_ID', message: 'casePlan() requires an id.' });
     const requestedVersion = authoredCaseVersion(built);
@@ -46,10 +28,7 @@ export function check(built, opts = {}) {
             code: 'VERSION_DEPRECATED',
             message: `.version(${JSON.stringify(requestedVersion)}) is deprecated: the Case JSON schema version is declared with .schemaVersion(), which accepts only versions this build can write. This SDK writes ${CASE_FORMAT_PROFILE.writeVersion}.`,
         });
-        // `serialize` refuses it too (`caseVersionMismatch`, one rule, one message).
-        const mismatch = caseVersionMismatch(built);
-        if (mismatch)
-            diags.push({ level: 'error', code: 'VERSION_MISMATCH', message: mismatch });
+        // A version this build cannot write is the serializer's VERSION_MISMATCH.
     }
     // The DECLARED grammar version (`.schemaVersion()`), as opposed to the
     // deprecated `.version()` above. It is already refused at the call, so this
@@ -97,55 +76,10 @@ export function check(built, opts = {}) {
                 where,
             });
     }
-    const stageLabels = new Set();
-    const taskNames = new Set();
-    let selectNextStageCount = 0;
-    for (const stage of built.stages) {
+    // A repeated stage label or task name, and the select-next-stage exit rules,
+    // are the serializer's (DUP_STAGE, DUP_TASK, SELECT_NEXT_STAGE_*).
+    for (const stage of built.stages)
         checkName('Stage label', stage.label, stage.label);
-        if (stageLabels.has(stage.label))
-            diags.push({ level: 'error', code: 'DUP_STAGE', message: `Duplicate stage label "${stage.label}".`, where: stage.label });
-        stageLabels.add(stage.label);
-        for (const exit of stage.exit) {
-            if (!exit.selectNextStage)
-                continue;
-            selectNextStageCount += 1;
-            if (exit.type !== 'wait-for-user')
-                diags.push({
-                    level: 'error',
-                    code: 'SELECT_NEXT_STAGE_EXIT_TYPE',
-                    message: `Stage "${stage.label}" configures selectNextStage on an exit that is not type "wait-for-user".`,
-                    where: stage.label,
-                });
-            if (!exit.selectNextStage.objectName.trim())
-                diags.push({
-                    level: 'error',
-                    code: 'SELECT_NEXT_STAGE_OBJECT_NAME',
-                    message: `Stage "${stage.label}" selectNextStage.objectName must name a Data Fabric entity.`,
-                    where: stage.label,
-                });
-            // Its connector's labels resolve through the same `bindingRef` as a
-            // connector task's, so they get the same binding-label rules.
-            const connector = exit.selectNextStage.connector;
-            if (connector)
-                checkBindingLabels('select-next-stage connector', connector, opts, (code, message) => diags.push({ level: 'error', code, message, where: stage.label }), { key: connector.connectorKey });
-        }
-        for (const lane of stage.lanes)
-            for (const t of lane) {
-                // Task displayNames must be unique across the case: the platform rejects
-                // duplicates (CRITICAL), and a bare selected-tasks-completed reference
-                // would silently mis-resolve to the first task of that name.
-                if (taskNames.has(t.name))
-                    diags.push({
-                        level: 'error',
-                        code: 'DUP_TASK',
-                        message: `Duplicate task displayName "${t.name}" — task names must be unique across the case.`,
-                        where: `${stage.label}/${t.name}`,
-                    });
-                taskNames.add(t.name);
-                // Also register the qualified `Stage/Task` key so a qualified reference resolves.
-                taskNames.add(`${stage.label}/${t.name}`);
-            }
-    }
     // Condition `displayName`s must be unique across the whole case — `uip maestro
     // case validate` rejects a repeat as CASE_MGMT_RULE_NAME_DUPLICATE, at error
     // severity. The namespace spans stage entry, stage exit and task entry
@@ -209,12 +143,6 @@ export function check(built, opts = {}) {
                 for (const c of task.entry)
                     checkConditionName(c.displayName, `task "${task.name}" entry`);
     }
-    if (selectNextStageCount > 1)
-        diags.push({
-            level: 'error',
-            code: 'SELECT_NEXT_STAGE_MULTIPLE',
-            message: 'A case can configure selectNextStage on at most one exit because the wire contract has one case-level connector.',
-        });
     if (built.stages.length === 0)
         diags.push({ level: 'error', code: 'NO_STAGES', message: 'Case has no stages.' });
     const hasCompletion = built.caseExit.some((c) => c.marksCaseComplete !== false);
@@ -224,35 +152,11 @@ export function check(built, opts = {}) {
             code: 'NO_CASE_COMPLETION',
             message: 'Case has no completion rule — add .completeWhen(rule(\'required-stages-completed\')).',
         });
-    // Business events: `metadata.businessEvents` names, matched exactly by an
-    // `api-event` rule's `businessEventType`. `uip maestro case validate` rejects a
-    // rule naming none (BUSINESS_EVENT_NOT_SELECTED) or an undeclared one
-    // (BUSINESS_EVENT_NOT_FOUND); both are reported here, at the rule.
-    const businessEvents = new Set((built.businessEvents ?? []).map((event) => event.name));
-    for (const problem of businessEventProblems(built.businessEvents ?? []))
-        diags.push({ level: 'error', code: problem.code, message: problem.message });
-    const refEvent = (r, where) => {
-        if (r.rule !== 'api-event')
-            return;
-        if (!r.businessEvent)
-            diags.push({
-                level: 'error',
-                code: 'API_EVENT_NO_BUSINESS_EVENT',
-                message: 'Rule "api-event" names no business event, so it listens for nothing — pass { businessEvent: \'<name>\' } with a name declared by .businessEvent(\'<name>\').',
-                where,
-            });
-        else if (!businessEvents.has(r.businessEvent))
-            diags.push({
-                level: 'error',
-                code: 'UNKNOWN_BUSINESS_EVENT',
-                message: `Rule "api-event" listens for business event "${r.businessEvent}", which the case does not declare — add .businessEvent(${JSON.stringify(r.businessEvent)}) to the case.`,
-                where,
-            });
-    };
+    // The business events' shapes, a rule's shape, an `api-event` rule's event,
+    // and a rule's stage and task references are the serializer's
+    // (`businessEventProblems`, `ruleShapeProblems`, API_EVENT_NO_BUSINESS_EVENT,
+    // UNKNOWN_BUSINESS_EVENT, UNKNOWN_STAGE_REF, UNKNOWN_TASK_REF).
     const refPlacement = (r, slot, where) => {
-        for (const problem of ruleShapeProblems(r))
-            diags.push({ level: 'error', code: problem.code, message: problem.message, where });
-        refEvent(r, where);
         const bad = ILLEGAL.find((x) => x.rule === r.rule && x.slot === slot);
         if (bad)
             diags.push({
@@ -263,28 +167,16 @@ export function check(built, opts = {}) {
             });
     };
     const refStage = (r, where) => {
-        if ((r.rule === 'selected-stage-completed' || r.rule === 'selected-stage-exited')) {
-            if (!r.stage || !stageLabels.has(r.stage))
-                diags.push({ level: 'error', code: 'UNKNOWN_STAGE_REF', message: `Rule "${r.rule}" references unknown stage "${r.stage}".`, where });
-        }
-        if (r.rule === 'selected-tasks-completed') {
-            if (!r.tasks?.length && !r.expression)
-                diags.push({
-                    level: 'warning',
-                    code: 'RULE_TASKS_REQUIRED',
-                    message: 'Rule "selected-tasks-completed" has neither selected tasks nor an expression gate — pass { tasks: [...] } or use when(expression).',
-                    where,
-                });
-            for (const n of r.tasks ?? [])
-                if (!taskNames.has(n))
-                    diags.push({ level: 'error', code: 'UNKNOWN_TASK_REF', message: `Rule "selected-tasks-completed" references unknown task "${n}".`, where });
-        }
+        if (r.rule === 'selected-tasks-completed' && !r.tasks?.length && !r.expression)
+            diags.push({
+                level: 'warning',
+                code: 'RULE_TASKS_REQUIRED',
+                message: 'Rule "selected-tasks-completed" has neither selected tasks nor an expression gate — pass { tasks: [...] } or use when(expression).',
+                where,
+            });
     };
-    // An In-arg with no `{ from }` binds to the primary trigger; when the case has
-    // none, `serialize` refuses it with the same code (in-arg-binding.ts).
-    for (const vd of built.vars)
-        if (isUnboundInArg(vd, built.triggers))
-            diags.push({ level: 'error', code: 'CASE_IN_ARG_UNBOUND', message: unboundInArgMessage(vd.name, built.triggers), where: vd.name });
+    // An In-arg with no `{ from }` and no primary trigger to bind to is the
+    // serializer's CASE_IN_ARG_UNBOUND (in-arg-binding.ts), reported per arg.
     // ── `=js:vars.<name>` resolvability — REMOVED, superseded by #257 ───────────
     // This file briefly carried a VAR_NOT_REFERENCEABLE error asserting that only a
     // trigger-bound In-arg (`.input(shape, { from })`) could be read as `=js:vars.x`,
@@ -303,7 +195,7 @@ export function check(built, opts = {}) {
     // positive that blocks emit (this gate runs before serialization), so it must be
     // re-derived from the serializer rather than from remembered probe results.
     for (const stage of built.stages) {
-        checkStage(stage, diags, refStage, refPlacement, opts.bindings, opts.externalExecutionError !== undefined);
+        checkStage(stage, diags, refStage, refPlacement);
         stage.slaRules.forEach((s, i) => checkSla(s, `stage "${stage.label}" SLA #${i + 1}`, diags));
     }
     built.slaRules.forEach((s, i) => checkSla(s, `case SLA #${i + 1}`, diags));
@@ -314,98 +206,88 @@ export function check(built, opts = {}) {
                 refPlacement(r, 'case-exit', 'case-exit');
             }
     checkLibraryConnectors(built, opts, diags);
+    diags.push(...serializerRefusals(built, opts, diags));
     return diags;
 }
 /**
- * The connector-library rules (#1014): every place Case `serialize` resolves a
- * connector against the library, checked with the same call and the same text.
+ * Every refusal `compile` would raise for `built`: the serializer, run in
+ * collect mode (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.5, phase 8), so each
+ * rule it enforces is reported from its one implementation, placed on the
+ * task, stage or trigger it is about (`where`, `nodeId`).
  *
- * - a connector task and an External Agent / External Workflow task resolve
- *   their operation (`library.resolve`): CONNECTOR_NOT_IN_LIBRARY,
- *   CONNECTOR_OBJECT_REQUIRED, CONNECTOR_OBJECT_NOT_GENERIC; then their inputs
- *   (`buildConnectorInputs`): CONNECTOR_INPUT, LOOKUP_UNRESOLVED;
- * - an external task's resolved descriptor (`externalDescriptorRefusal`):
- *   EXTERNAL_TASK_DESCRIPTOR_CONTRACT; and its mode and event against what the
- *   library records for the object (`externalExecution`): EXTERNAL_TASK_MODE,
- *   EXTERNAL_TASK_MODE_MISMATCH, EXTERNAL_TASK_EVENT;
- * - an event trigger, a wait-for-connector task and a wait-for-connector rule
- *   resolve their subscription (`resolveCaseSubscription`): EVENT_UNKNOWN,
- *   EVENT_GENERIC_NO_OBJECT.
- *
- * A connector task also gets the schema-readiness warnings, because the
- * `connectors-local` overlay `registry prepare` writes is what Case compile
- * resolves against too.
+ * LIBRARY_REQUIRED is not reported: without a library `check` fails open, as
+ * its library rules always have. A throw that is no refusal comes back as
+ * COMPILE_FAILED, on its node, which is what `compile` says; on a node `check`
+ * already refuses it is that refusal's consequence and is not repeated. An
+ * `internal SDK error:` is passed on, unless `check` or the serializer already
+ * found an error, which the author has to fix first.
+ */
+function serializerRefusals(built, opts, found) {
+    const collected = [];
+    try {
+        serialize(built, {
+            ...(opts.library ? { library: opts.library } : {}),
+            ...(opts.bindings ? { bindings: opts.bindings } : {}),
+            collect: (r) => collected.push(r),
+        });
+    }
+    catch (error) {
+        if (!found.some((d) => d.level === 'error') && !collected.some((r) => r.code !== 'LIBRARY_REQUIRED'))
+            throw error;
+    }
+    const out = [];
+    const seen = new Set();
+    for (const r of collected) {
+        if (r.code === 'LIBRARY_REQUIRED')
+            continue;
+        // Only a crash on a node is the consequence of a finding there; a scope-level
+        // one (no `where`) is reported even beside a case-level error such as NO_ID.
+        if (r.code === 'COMPILE_FAILED' && r.where !== undefined && found.some((d) => d.level === 'error' && d.where === r.where))
+            continue;
+        // One finding per node: the same refusal twice there is one rule broken once.
+        const key = `${r.code}\n${r.where ?? ''}\n${r.message}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({
+            level: 'error', code: r.code, message: r.message,
+            ...(r.where !== undefined ? { where: r.where } : {}),
+            ...(r.suggestion !== undefined ? { suggestion: r.suggestion } : {}),
+            ...(r.nodeId !== undefined ? { nodeId: r.nodeId } : {}),
+        });
+    }
+    return out;
+}
+/**
+ * The connector-library warnings only `check` gives (#1014): a connector task's
+ * schema-readiness warnings, because the `connectors-local` overlay `registry
+ * prepare` writes is what Case compile resolves against too, and the lookup
+ * rules of `checkConnectorLookups` (a pasted id, a match key the field does not
+ * declare). Everything compile refuses (the operation, its inputs, an
+ * unrecorded lookup, the binding labels, the event subscriptions, an external
+ * task's descriptor) is the serializer's (`serializerRefusals`).
  */
 function checkLibraryConnectors(built, opts, diags) {
-    const reporter = (_where, at) => (d) => {
+    const reporter = (at) => (d) => {
         diags.push({ level: d.level, code: d.code, message: d.message, where: at, ...(d.suggestion ? { suggestion: d.suggestion } : {}) });
     };
-    const subscription = (kind, sub, where, at) => {
-        // The call `resolvedSubscriptionBag` makes (`resolveCaseSubscription`), so
-        // check refuses exactly what compile refuses, with the same text.
-        const refused = opts.subscriptionError?.(kind, sub);
-        if (refused !== undefined)
-            diags.push({ level: 'error', code: refused.code, message: `${where}: ${refused.message}`, where: at });
-        checkBindingLabels(where, sub, opts, (code, message) => diags.push({ level: 'error', code, message, where: at }), { key: sub.connector, action: sub.event });
-        // From the shared event rules, the two Case compile enforces: a `where` lookup
-        // nobody recorded (LOOKUP_UNRESOLVED, a warning) and an unverified BYOA
-        // connection (EVENT_BYOA_UNVERIFIED). Only their hooks are passed, so nothing
-        // else in them fires.
-        checkEventResolution(sub, where, kind, {
-            resolutions: opts.resolutions ?? {},
-            ...(opts.eventFacts ? { eventFacts: opts.eventFacts } : {}),
-            ...(opts.byoa ? { byoa: opts.byoa } : {}),
-            ...(opts.bindings ? { bindings: opts.bindings } : {}),
-        }, (code, message) => diags.push({ level: 'error', code, message, where: at }), (code, message) => diags.push({ level: 'warning', code, message, where: at }));
-    };
-    const rules = (conditions, where) => {
-        for (const c of conditions)
-            for (const g of c.rules)
-                for (const r of g)
-                    if (r.rule === 'wait-for-connector' && isSubscription(r.connector))
-                        subscription('event', r.connector, `wait-for-connector rule in ${where}`, where);
-    };
-    built.triggers.forEach((t, i) => {
-        if (t.kind !== 'event' || !t.eventSubscription)
-            return;
-        const name = t.name ?? `Trigger ${i + 1}`;
-        subscription('trigger', t.eventSubscription, `Event trigger "${name}"`, name);
-    });
     for (const stage of built.stages) {
-        rules(stage.entry, `stage "${stage.label}" entry`);
-        rules(stage.exit, `stage "${stage.label}" exit`);
         for (const t of stage.lanes.flat()) {
-            rules(t.entry, `task "${t.name}" entry`);
             // A placeholder (`.unresolved('connector')`) names no operation to resolve.
             if (t.kind === 'connector' && t.connector && !isConnectorPlaceholder(t)) {
                 const where = `Connector task "${t.name}"`;
                 const spec = t.connector;
-                checkConnectorLookups(where, spec, opts, EQUALS_EXPR_DIALECT, reporter(where, t.name));
-                checkConnectorSchema(where, spec, opts, EQUALS_EXPR_DIALECT, reporter(where, t.name));
-                checkConnectorContract(where, spec, opts, reporter(where, t.name));
+                // An unrecorded lookup is the serializer's LOOKUP_UNRESOLVED.
+                checkConnectorLookups(where, spec, opts, EQUALS_EXPR_DIALECT, reporter(t.name), false);
+                checkConnectorSchema(where, spec, opts, EQUALS_EXPR_DIALECT, reporter(t.name));
             }
             if ((t.kind === 'external-agent' || t.kind === 'external-workflow')
                 && t.external?.connector?.key?.trim() && t.external.connector.action?.trim()) {
                 const where = `${t.kind === 'external-agent' ? 'External Agent' : 'External Workflow'} task "${t.name}"`;
-                const spec = t.external.connector;
-                checkConnectorLookups(where, spec, opts, EQUALS_EXPR_DIALECT, reporter(where, t.name));
-                checkConnectorContract(where, spec, opts, reporter(where, t.name));
-                const refused = opts.externalDescriptorError?.(t.kind, spec);
-                if (refused !== undefined)
-                    diags.push({ level: 'error', code: EXTERNAL_TASK_DESCRIPTOR_CONTRACT, message: `${where}: ${refused}`, where: t.name });
-                const execution = opts.externalExecutionError?.(where, spec, t.external);
-                if (execution !== undefined)
-                    diags.push({ level: 'error', code: execution.code, message: execution.message, where: t.name });
+                checkConnectorLookups(where, t.external.connector, opts, EQUALS_EXPR_DIALECT, reporter(t.name), false);
             }
-            if (t.kind === 'wait-for-connector' && isSubscription(t.waitConnector))
-                subscription('event', t.waitConnector, `Wait-for-connector task "${t.name}"`, t.name);
         }
     }
-    rules(built.caseExit, 'case exit');
-}
-/** A resolved subscription, not a placeholder; the test `serialize`'s `isResolvedSubscription` makes. */
-function isSubscription(spec) {
-    return !!spec && typeof spec === 'object' && 'connector' in spec && 'event' in spec;
 }
 /**
  * SLA guardrails surfaced early: zero at-risk percentages that the engine
@@ -446,9 +328,7 @@ function isNilOrEmpty(value) {
         return Object.keys(value).length === 0;
     return false;
 }
-function checkStage(stage, diags, refStage, refPlacement, bindings, 
-/** A library judges external tasks' mode and event (`externalExecutionError`). */
-externalJudge) {
+function checkStage(stage, diags, refStage, refPlacement) {
     const where = `stage "${stage.label}"`;
     if (stage.exception && stage.required !== false)
         diags.push({
@@ -518,9 +398,9 @@ externalJudge) {
         });
     for (const t of tasks) {
         // A timer with no or several values, an action field key compile does not
-        // write: serialize refuses the same shapes with the same text (task-shape.ts).
-        for (const problem of taskShapeProblems(t))
-            diags.push({ level: 'error', code: problem.code, message: problem.message, where: t.name });
+        // write, a `=bindings.<label>` resource name bindings.json cannot answer, and
+        // an external task's mode, connection and folder are the serializer's
+        // (`taskShapeProblems`, `resolveResourceRef`, EXTERNAL_TASK_*).
         const invalidBinding = [...(t.inputs ?? []), ...(t.outputs ?? [])]
             .find((binding) => !TYPE_NAMES.has(binding.type));
         if (invalidBinding)
@@ -530,16 +410,6 @@ externalJudge) {
                 message: `Task "${t.name}" binding "${'var' in invalidBinding ? invalidBinding.var : invalidBinding.name}" has unsupported type ${JSON.stringify(invalidBinding.type)}. Use a type name such as "string" or "jsonSchema"; jsonSchema(...) is only for declaring a structured case variable.`,
                 where: t.name,
             });
-        // The builder binds a resource task itself: it mints the name/folderPath
-        // binding pair from the literal name and folder. A `=bindings.<label>` name
-        // or folder is read through bindings.json first, the way a connector's
-        // `connection:` label is; one bindings.json cannot answer is refused with the
-        // same text serialize throws (`resolveResourceRef`).
-        if (t.ref) {
-            const resolved = resolveResourceRef(t.ref, bindings, `Task "${t.name}"`);
-            if (isResourceLabelRefusal(resolved))
-                diags.push({ level: 'error', code: resolved.code, message: resolved.message, where: t.name });
-        }
         // A custom row (`{ assign }`) is evaluated in array order, after the rows
         // before it on the same task: it cannot read itself or a later row's
         // variable (it would see the old value). `uip maestro case validate
@@ -628,39 +498,13 @@ externalJudge) {
                     message: `${family} task "${t.name}" has no configuration; empty data degrades to a runtime no-op placeholder.`,
                     where: t.name,
                 });
-            else {
-                // The authored mode and event alone. With a library at hand, the
-                // library pass judges them against the object instead (and reports a
-                // missing mode), so they are judged here only without one.
-                const libraryJudges = externalJudge
-                    && !!t.external.connector?.key?.trim() && !!t.external.connector?.action?.trim();
-                if (!libraryJudges) {
-                    const judged = externalExecution(`${family} task "${t.name}"`, t.external, undefined);
-                    if (judged?.code !== undefined)
-                        diags.push({ level: 'error', code: judged.code, message: judged.message, where: t.name });
-                }
-                if (!t.external.connector?.key?.trim() || !t.external.connector?.action?.trim())
-                    diags.push({
-                        level: 'error',
-                        code: 'EXTERNAL_TASK_DESCRIPTOR',
-                        message: `${family} task "${t.name}" requires a generated Integration Service descriptor.`,
-                        where: t.name,
-                    });
-                if (!t.external.connector?.connection?.trim())
-                    diags.push({
-                        level: 'error',
-                        code: 'EXTERNAL_TASK_CONNECTION',
-                        message: `${family} task "${t.name}" requires a non-empty connection binding name.`,
-                        where: t.name,
-                    });
-                if (!t.external.connector?.folder?.trim())
-                    diags.push({
-                        level: 'error',
-                        code: 'EXTERNAL_TASK_FOLDER',
-                        message: `${family} task "${t.name}" requires a non-empty folder binding name.`,
-                        where: t.name,
-                    });
-            }
+            else if (!t.external.connector?.key?.trim() || !t.external.connector?.action?.trim())
+                diags.push({
+                    level: 'error',
+                    code: 'EXTERNAL_TASK_DESCRIPTOR',
+                    message: `${family} task "${t.name}" requires a generated Integration Service descriptor.`,
+                    where: t.name,
+                });
         }
         if (stage.exception && t.runOnce !== undefined)
             diags.push({

package/dist/case/cli-library.d.ts

@@ -4,13 +4,10 @@ import type { CaseCheckOpts } from './check.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.

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;

package/dist/case/subscription.js

@@ -16,19 +16,29 @@ function caseObjectOption(object) {
 /**
  * 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 function resolveCaseSubscription(library, kind, sub, byoa) {
-    const rc = library.resolveEvent(kind, sub.connector, sub.event, sub.version, sub.object);
+    let rc;
+    try {
+        rc = library.resolveEvent(kind, sub.connector, sub.event, sub.version, sub.object);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('internal SDK error:'))
+            throw error;
+        throw new CompileRefusal('EVENT_UNKNOWN', error instanceof Error ? error.message : String(error));
+    }
     const noObject = genericEventObjectRefusal(rc, sub, caseObjectOption);
     if (noObject)
         throw new GenericEventNoObjectError(noObject);

package/dist/core/refusals.js

@@ -6,8 +6,9 @@
  *     stops `compile` from writing. A serializer warning (`CONNECTION_STUB`) is
  *     `lint` too: it never blocks.
  *   - `lowering`: `compile` cannot write a correct `.flow` (or caseplan, or `.bpmn`). It always
- *     stops `compile`; for a Flow, `check` reports it too, from the serializer it runs in
- *     collect mode (`SerializeOpts.collect`), so the rule lives in one place.
+ *     stops `compile`; for a Flow or a Case, `check` reports it too, from the serializer it
+ *     runs in collect mode (`SerializeOpts.collect`, `CaseSerializeOpts.collect`), so the rule
+ *     lives in one place.
  *   - `draft`: an unfinished canvas node (no connection yet, a required input
  *     left empty, a generic operation with no object). These are the codes a
  *     draft-tolerant compile collects instead of throwing (`DraftCode` in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.68.7",
+  "version": "6.69.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "436dbc08c3130fcde3197adec572df61116f4ede"
+  "gitref": "f1c4fc99c993d7cc8defcda32496be344f018a23"
 }