@uipath/maestro-builder-sdk 6.68.7 → 6.69.1

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.