@uipath/maestro-builder-sdk 6.68.6 → 6.69.0

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, EXTERNAL_TASK_EVENT, externalEventRefusal, isExternalExecutionMode } 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);
+        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,93 +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;
- * - 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 });
+                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
@@ -441,7 +328,7 @@ function isNilOrEmpty(value) {
         return Object.keys(value).length === 0;
     return false;
 }
-function checkStage(stage, diags, refStage, refPlacement, bindings) {
+function checkStage(stage, diags, refStage, refPlacement) {
     const where = `stage "${stage.label}"`;
     if (stage.exception && stage.required !== false)
         diags.push({
@@ -511,9 +398,9 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
         });
     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)
@@ -523,16 +410,6 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
                 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
@@ -621,41 +498,13 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
                     message: `${family} task "${t.name}" has no configuration; empty data degrades to a runtime no-op placeholder.`,
                     where: t.name,
                 });
-            else {
-                if (!isExternalExecutionMode(t.external.mode))
-                    diags.push({
-                        level: 'error',
-                        code: 'EXTERNAL_TASK_MODE',
-                        message: `${family} task "${t.name}" mode must be the connector object's executionType: "sync", "async" or "hybrid".`,
-                        where: t.name,
-                    });
-                else {
-                    const refused = externalEventRefusal(`${family} task "${t.name}"`, t.external.mode, t.external.event);
-                    if (refused)
-                        diags.push({ level: 'error', code: EXTERNAL_TASK_EVENT, message: refused, 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 } 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,35 +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);
-        },
-        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/decompile.js

@@ -2,7 +2,7 @@ import { commentText } from '../core/comment-text.js';
 import { implicitInArgTrigger } from './in-arg-binding.js';
 import { tsLiteral, tsNumber } from '../core/ts-literal.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
-import { EXTERNAL_TASK_CONTEXT, EXTERNAL_TASK_EVENT_CONTEXT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode } from './external.js';
+import { EXTERNAL_TASK_CONTEXT, EXTERNAL_TASK_EVENT_CONTEXT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode, libraryExecution } from './external.js';
 import { preserveSchemaVersion } from '../schema-version.js';
 import { ownEntry } from '../core/own-entry.js';
 import { isUnrestorableSlotId, taskFingerprint } from './preserve.js';
@@ -676,8 +676,8 @@ function externalCall(task, refs, library) {
     const serviceType = externalServiceType(kind, mode);
     if (data.serviceType !== serviceType)
         throw new Error(`${owner} has serviceType "${String(data.serviceType ?? '')}", but its executionType "${mode}" saves as "${serviceType}".`);
-    // The event the object answers with, as saved: the same rule compile applies,
-    // so a lifted task always compiles back (a hybrid task without one does not).
+    // The event the object answers with, as saved, judged by compile's event rule
+    // here, and against the library's record below (`externalExecution` in compile).
     const event = eventRows.length ? { operation: stringValue('operation'), mode: stringValue('eventMode') } : undefined;
     // A saved plan has no `event` option to drop, so a sync task with event rows
     // gets its own text naming the rows; every other case is compile's rule.
@@ -699,6 +699,19 @@ function externalCall(task, refs, library) {
     const refused = externalDescriptorRefusal(kind, resolved);
     if (refused)
         throw new Error(`${owner}: ${refused}`);
+    // Compile refuses a mode or event the library contradicts (#1369), so a task
+    // saved against a different record would lift to source that does not compile
+    // back: refuse it here, by name, before the author edits anything.
+    const recorded = libraryExecution(resolved.entry?.operation);
+    if (recorded.mode !== undefined && recorded.mode !== mode)
+        throw new Error(`${owner} is saved with executionType "${mode}", but the connector library records the object's ` +
+            `executionType as "${recorded.mode}", so the lifted source would not compile back. Re-save the task in Studio Web, ` +
+            `or rebuild the library (registry prepare) if the object changed.`);
+    if (event !== undefined && recorded.event !== undefined
+        && (event.operation !== recorded.event.operation || event.mode !== recorded.event.mode))
+        throw new Error(`${owner} is saved with event ${JSON.stringify(event)}, but the connector library records the object's ` +
+            `event as ${JSON.stringify(recorded.event)}, so the lifted source would not compile back. Re-save the task in Studio Web, ` +
+            `or rebuild the library (registry prepare) if the object changed.`);
     if (!Array.isArray(data.inputs))
         throw new Error(`${owner} inputs must be an array.`);
     const inputs = connectorInputs(data.inputs, resolved, owner);

package/dist/case/external.d.ts

@@ -58,6 +58,52 @@ export declare function isExternalExecutionMode(value: unknown): value is Extern
  * @returns The service type.
  */
 export declare function externalServiceType(kind: 'external-agent' | 'external-workflow', mode: ExternalExecutionMode): string;
+/** Check's and compile's code when an authored `mode` disagrees with the library. */
+export declare const EXTERNAL_TASK_MODE_MISMATCH = "EXTERNAL_TASK_MODE_MISMATCH";
+/** A judged execution: the task's mode and event, or why it cannot be written. */
+export type ExternalExecution = {
+    mode: ExternalExecutionMode;
+    event?: ExternalEventPair;
+    code?: undefined;
+} | {
+    code: string;
+    message: string;
+};
+/**
+ * The execution facts the connector library records for the object
+ * (`operation.executionType` and `operation.executionEvent`, from
+ * `registry build-library` / `registry prepare`, #1369). A value the SDK does
+ * not know is ignored, as if it were absent.
+ */
+export declare function libraryExecution(operation: unknown): {
+    mode?: ExternalExecutionMode;
+    event?: ExternalEventPair;
+};
+/**
+ * The mode and event an external task is written with: what the author passed,
+ * else what the connector library records for the object. `check` and
+ * `serialize` both call this, so they refuse the same tasks with the same text.
+ *
+ * - `mode` comes from the author or the library. With neither, the task is
+ *   refused (EXTERNAL_TASK_MODE): a guessed default would compile an `async`
+ *   object to the sync contract without a word (#1370 was closed for that).
+ * - An authored `mode` the library contradicts is refused
+ *   (EXTERNAL_TASK_MODE_MISMATCH): the plan would run the wrong contract.
+ * - `event` comes from the author or, for an `async` / `hybrid` object, the
+ *   library; an authored one the library contradicts is refused
+ *   (EXTERNAL_TASK_EVENT), and so is any pair {@link externalEventRefusal} refuses.
+ *
+ * @param owner - The task as the message names it, e.g. `External Workflow task "Run"`.
+ * @param authored - The task's authored `mode` and `event`.
+ * @param operation - The resolved library entry's `operation`, or `undefined`
+ *   when no library is at hand (model-only `check`, which then judges only what
+ *   was authored and reports no missing mode).
+ * @returns The mode and event, or the refusal.
+ */
+export declare function externalExecution(owner: string, authored: {
+    mode?: unknown;
+    event?: unknown;
+}, operation: unknown): ExternalExecution | undefined;
 /** Check's code for {@link externalDescriptorRefusal}. */
 export declare const EXTERNAL_TASK_DESCRIPTOR_CONTRACT = "EXTERNAL_TASK_DESCRIPTOR_CONTRACT";
 /**