@uipath/maestro-builder-sdk 6.68.5 → 6.68.7

package/dist/bpmn/intsvc.js

@@ -191,6 +191,16 @@ export function createExternalTask(ctx, n) {
             `${n.key}/${n.action} is "${String(op.subType ?? 'untyped')}". ` +
             `The shipped library has very few of these — ${wanted === 'AgentExecution' ? '2' : '1'} operation(s).`);
     }
+    // The object's execution type, when the library records it (#1369): a `mode`
+    // that contradicts it compiles the other contract, which validate accepts and
+    // the run gets wrong. Studio Web runs `hybrid` as `async`.
+    const recorded = op.executionType;
+    if (recorded === 'sync' || recorded === 'async' || recorded === 'hybrid') {
+        const runs = recorded === 'sync' ? 'sync' : 'async';
+        if (n.mode !== runs)
+            throw new CompileRefusal('EXTERNAL_TASK_MODE_MISMATCH', `external ${n.family} "${n.id}" has mode "${n.mode}", but the connector library records ${n.key}/${n.action}'s ` +
+                `executionType as "${recorded}", which runs ${runs}; the node would run the wrong contract. Use mode: "${runs}".`);
+    }
     const conn = connectorBindingRef(ctx, n.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`);
     const folder = connectorBindingRef(ctx, n.folder, 'Connection', 'folderKey', 'FolderKey', conn?.resourceKey);
     if (!conn || !folder) {

package/dist/case/case-sdk.d.ts

@@ -430,9 +430,12 @@ export type ConnectorSpecData = Extract<ActionSpec, {
  * reports it for the connector object.
  *
  * @remarks
- * This is a property of the connector object, not a choice about the case: copy
- * it from the activity's `case spec` result
- * (`Data.EssentialConfiguration.essentialConfiguration.executionType`). The Case
+ * This is a property of the connector object, not a choice about the case. The
+ * connector library records it for the object when it was built or prepared
+ * from Integration Service metadata that reports it, and compile then takes it
+ * from there: leave `mode` out. Otherwise copy it from the activity's `case spec`
+ * result (`Data.EssentialConfiguration.essentialConfiguration.executionType`).
+ * A `mode` the library contradicts is refused (EXTERNAL_TASK_MODE_MISMATCH). The Case
  * Designer saves `sync` as the `Sync…Execution` service type and both `async`
  * and `hybrid` as `Async…Execution`, and writes the value itself into the task's
  * `executionType` context.
@@ -457,10 +460,10 @@ export type ExternalExecutionMode = 'sync' | 'async' | 'hybrid';
  * the Case Designer reads it from the object's metadata (its first event mode
  * and that mode's first event type) and saves it as the task's `operation` and
  * `eventMode` context rows, and as `eventType` / `eventMode` in the metadata's
- * `activityPropertyConfiguration`. Copy it from the same two rows of the
- * activity's `case spec` result (`caseShape.context`). `decompile` lifts it from
- * a saved task. For
- * example, the Power Automate "Invoke a Flow" object (`hybrid`) answers with
+ * `activityPropertyConfiguration`. Like `mode`, compile takes it from the
+ * connector library when the library records it; otherwise copy it from the same
+ * two rows of the activity's `case spec` result (`caseShape.context`).
+ * `decompile` lifts it from a saved task. For example, the Power Automate "Invoke a Flow" object (`hybrid`) answers with
  * `{ operation: 'TRIGGER_CREATED', mode: 'polling' }`.
  */
 export interface ExternalEventPair {
@@ -476,16 +479,18 @@ export interface ExternalTaskOptions<I extends Record<string, unknown>> {
     /** Symbolic Orchestrator folder binding name declared in `bindings.json`. */
     folder: string;
     /**
-     * The connector object's `executionType` from its `case spec` result. Required:
-     * the connector library does not carry it yet (#1369), and a wrong value passes
-     * `validate` but runs the wrong contract. Not whether the stage waits: that is
+     * The connector object's `executionType`. Leave it out when the connector
+     * library records it (compile reads it from there); otherwise copy it from the
+     * `case spec` result. Compile refuses a task with no mode from either
+     * (EXTERNAL_TASK_MODE), and one the library contradicts
+     * (EXTERNAL_TASK_MODE_MISMATCH). Not whether the stage waits: that is
      * `.required(false)`. See {@link ExternalExecutionMode}.
      */
-    mode: ExternalExecutionMode;
+    mode?: ExternalExecutionMode;
     /**
-     * The event an `async` or `hybrid` object answers with. Required for `hybrid`;
-     * optional for `async`; refused for `sync`, which answers inline. See
-     * {@link ExternalEventPair}.
+     * The event an `async` or `hybrid` object answers with. Leave it out when the
+     * connector library records it. A `hybrid` task needs one from either place;
+     * a `sync` one refuses it, since it answers inline. See {@link ExternalEventPair}.
      */
     event?: ExternalEventPair;
     /** Inputs statically checked by the generated connector descriptor. */
@@ -493,9 +498,9 @@ export interface ExternalTaskOptions<I extends Record<string, unknown>> {
 }
 /** Normalized descriptor and execution mode stored on a built external task. */
 export interface ExternalTaskSpecData {
-    /** The connector object's `executionType`. */
-    mode: ExternalExecutionMode;
-    /** The event an `async` or `hybrid` object answers with, when given. */
+    /** The connector object's `executionType`, when authored (else the library's). */
+    mode?: ExternalExecutionMode;
+    /** The event an `async` or `hybrid` object answers with, when authored (else the library's). */
     event?: ExternalEventPair;
     /** Shared connector action identity, inputs, and symbolic bindings. */
     connector: ConnectorSpecData;
@@ -713,9 +718,10 @@ export interface CaseVarDecl {
     body?: unknown;
     /**
      * In-args only: the trigger this argument is bound to (its value arrives when
-     * that trigger fires). Set via `.input(shape, { from })`. When present, the arg
-     * emits the full three-entry binding (formal slot + companion + trigger-output
-     * bridge); when absent it stays a bare declaration.
+     * that trigger fires). Set via `.input(shape, { from })`. Every In-arg emits the
+     * full three-entry binding (formal slot + companion + trigger-output bridge):
+     * when this is absent the arg binds to the primary trigger, and a case with
+     * none refuses it (CASE_IN_ARG_UNBOUND). See `.input()`.
      */
     sourceTrigger?: BuiltTrigger;
 }
@@ -1461,10 +1467,28 @@ declare class CaseBuilder {
     layout(layout: CaseLayout): this;
     /**
      * Declare case In-args. Each value is a {@link TypeDesc}, or `{ type, default }`
-     * to set a default. Pass `{ from: <trigger> }` to bind the args to a trigger —
-     * their value arrives when it fires, readable as `=vars.<name>` — and they are
-     * projected into that trigger's `entry-points.json` input schema. A declared
-     * In-arg is readable as `=vars.<name>` (its `inputOutputs` companion resolves it).
+     * to set a default. An In-arg is always bound to a trigger: its value arrives
+     * when that trigger starts the case, it is readable as `=vars.<name>` (its
+     * `inputOutputs` companion, keyed to the trigger, resolves it), and it is
+     * projected into that trigger's `entry-points.json` input schema.
+     *
+     * Which trigger:
+     * - `{ from: <trigger> }` binds the args to that trigger.
+     * - Without `{ from }`, they bind to the primary trigger. That is the case's
+     *   only trigger (the one added with `.trigger()`, or the implicit manual
+     *   trigger when none was added), or, when there are several, the one that is
+     *   not a timer. `uip maestro case sdd convert` reads a blank
+     *   `sourceTriggers` the same way.
+     * - Without `{ from }` in a case with no primary trigger (several non-timer
+     *   triggers, or only timers), `check` and `compile` refuse the plan with
+     *   `CASE_IN_ARG_UNBOUND`. Pass `{ from }`, or use `.var()` for a value no
+     *   trigger supplies.
+     *
+     * @example
+     * **Declare an In-arg on the primary trigger (here the implicit manual one)**
+     * ```ts
+     * casePlan('x').input({ invoiceNumber: { type: 'string', default: 'INV-1042' } })
+     * ```
      *
      * @example
      * **Bind case In-args to a trigger's payload**
@@ -1475,7 +1499,8 @@ declare class CaseBuilder {
      * ```
      *
      * @param shape - In-arg names to types, or `{ type, default }`.
-     * @param opts - `{ from: <trigger> }` binds the args to a trigger's payload.
+     * @param opts - `{ from: <trigger> }` binds the args to that trigger. Required
+     *   when the case has no primary trigger.
      * @returns This builder, so calls chain.
      */
     input(shape: Record<string, TypeDesc | JsonSchemaType | {

package/dist/case/case-sdk.js

@@ -333,7 +333,7 @@ class TaskBuilder {
     external(kind, descriptor, opts) {
         this.setKind(kind);
         this._external = {
-            mode: opts.mode,
+            ...(opts.mode !== undefined ? { mode: opts.mode } : {}),
             ...(opts.event !== undefined ? { event: { ...opts.event } } : {}),
             connector: makeConnector(descriptor, opts.inputs, {
                 connection: opts.connection,
@@ -956,10 +956,28 @@ class CaseBuilder {
     }
     /**
      * Declare case In-args. Each value is a {@link TypeDesc}, or `{ type, default }`
-     * to set a default. Pass `{ from: <trigger> }` to bind the args to a trigger —
-     * their value arrives when it fires, readable as `=vars.<name>` — and they are
-     * projected into that trigger's `entry-points.json` input schema. A declared
-     * In-arg is readable as `=vars.<name>` (its `inputOutputs` companion resolves it).
+     * to set a default. An In-arg is always bound to a trigger: its value arrives
+     * when that trigger starts the case, it is readable as `=vars.<name>` (its
+     * `inputOutputs` companion, keyed to the trigger, resolves it), and it is
+     * projected into that trigger's `entry-points.json` input schema.
+     *
+     * Which trigger:
+     * - `{ from: <trigger> }` binds the args to that trigger.
+     * - Without `{ from }`, they bind to the primary trigger. That is the case's
+     *   only trigger (the one added with `.trigger()`, or the implicit manual
+     *   trigger when none was added), or, when there are several, the one that is
+     *   not a timer. `uip maestro case sdd convert` reads a blank
+     *   `sourceTriggers` the same way.
+     * - Without `{ from }` in a case with no primary trigger (several non-timer
+     *   triggers, or only timers), `check` and `compile` refuse the plan with
+     *   `CASE_IN_ARG_UNBOUND`. Pass `{ from }`, or use `.var()` for a value no
+     *   trigger supplies.
+     *
+     * @example
+     * **Declare an In-arg on the primary trigger (here the implicit manual one)**
+     * ```ts
+     * casePlan('x').input({ invoiceNumber: { type: 'string', default: 'INV-1042' } })
+     * ```
      *
      * @example
      * **Bind case In-args to a trigger's payload**
@@ -970,7 +988,8 @@ class CaseBuilder {
      * ```
      *
      * @param shape - In-arg names to types, or `{ type, default }`.
-     * @param opts - `{ from: <trigger> }` binds the args to a trigger's payload.
+     * @param opts - `{ from: <trigger> }` binds the args to that trigger. Required
+     *   when the case has no primary trigger.
      * @returns This builder, so calls chain.
      */
     input(shape, opts = {}) {

package/dist/case/check.d.ts

@@ -52,6 +52,25 @@ export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'connectorResolveError' | '
         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;

package/dist/case/check.js

@@ -1,4 +1,5 @@
 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';
@@ -6,7 +7,7 @@ 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 { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, externalExecution } from './external.js';
 import { isResourceLabelRefusal, resolveResourceRef } from './resource-identity.js';
 import { taskShapeProblems } from './task-shape.js';
 import { isConnectorPlaceholder } from './connector-placeholder.js';
@@ -279,6 +280,11 @@ export function check(built, opts = {}) {
                     diags.push({ level: 'error', code: 'UNKNOWN_TASK_REF', message: `Rule "selected-tasks-completed" references unknown task "${n}".`, 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 });
     // ── `=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`,
@@ -297,7 +303,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, opts.bindings, opts.externalExecutionError !== undefined);
         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));
@@ -319,7 +325,9 @@ export function check(built, opts = {}) {
  *   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;
+ *   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.
@@ -385,6 +393,9 @@ function checkLibraryConnectors(built, opts, diags) {
                 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 });
             }
             if (t.kind === 'wait-for-connector' && isSubscription(t.waitConnector))
                 subscription('event', t.waitConnector, `Wait-for-connector task "${t.name}"`, t.name);
@@ -435,7 +446,9 @@ function isNilOrEmpty(value) {
         return Object.keys(value).length === 0;
     return false;
 }
-function checkStage(stage, diags, refStage, refPlacement, bindings) {
+function checkStage(stage, diags, refStage, refPlacement, bindings, 
+/** A library judges external tasks' mode and event (`externalExecutionError`). */
+externalJudge) {
     const where = `stage "${stage.label}"`;
     if (stage.exception && stage.required !== false)
         diags.push({
@@ -616,17 +629,15 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
                     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 });
+                // 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({

package/dist/case/cli-library.js

@@ -8,7 +8,7 @@
  * both `case check` and `case compile`'s check pass call.
  */
 import { connectorCheckOpts } from '../core/cli-library.js';
-import { externalDescriptorRefusal } from './external.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.
@@ -48,6 +48,17 @@ export function caseCheckOpts(library, bindings) {
             }
             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);

package/dist/case/decompile.js

@@ -1,7 +1,8 @@
 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';
@@ -675,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.
@@ -698,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);
@@ -1088,13 +1102,25 @@ function reassignedOwnNameTargets(plan) {
     }
     return targets;
 }
-function emitVariables(out, depth, plan, triggerNameById) {
+function emitVariables(out, depth, plan, triggerNameById, triggerIsTimer) {
     const variables = plan.variables ?? {};
     const produced = producedVariableNames(plan);
     for (const input of variables.inputs ?? []) {
-        const from = input.elementId && triggerNameById.get(input.elementId);
+        let from = input.elementId && triggerNameById.get(input.elementId);
+        // An In-arg with no trigger is a shape only older SDKs wrote (builder-sdk
+        // #1368): no companion, so nothing binds it. A bare `.input()` now binds to
+        // the primary trigger, which is what this source recompiles to. When the
+        // case has no primary trigger a bare `.input()` is refused
+        // (CASE_IN_ARG_UNBOUND), so the source names the first trigger and says so.
+        if (!input.elementId && implicitInArgTrigger(triggerIsTimer) === undefined) {
+            from = triggerNameById.values().next().value;
+            out.line(depth, `// The source document left In-arg "${commentText(input.name)}" unbound and the case has no primary trigger; it is bound to the first trigger here (builder-sdk#1368).`);
+        }
         const fromOpts = from ? `, { from: ${from} }` : '';
-        out.line(depth, `.input({ ${key(input.name)}: ${varSpec(input)} }${fromOpts})`);
+        // Compile writes `default: ""` on every In-arg that authored none, so the
+        // empty default is not authored content and the source leaves it out.
+        const spec = varSpec(input.default === '' ? { ...input, default: undefined } : input);
+        out.line(depth, `.input({ ${key(input.name)}: ${spec} }${fromOpts})`);
     }
     for (const output of variables.outputs ?? [])
         out.line(depth, `.output({ ${key(output.name)}: ${varSpec(output)} })`);
@@ -1130,6 +1156,10 @@ function bridgeRows(plan, triggerId, bag) {
     }
     return bridges;
 }
+function isTimerTrigger(node) {
+    const serviceType = triggerData(node).bag?.serviceType;
+    return serviceType === 'Intsvc.TimerTrigger' || serviceType === 'timer';
+}
 function triggerSource(node, index, plan, refs) {
     const { label, description, bag } = triggerData(node);
     const name = label !== `Trigger ${index + 1}` ? tsLiteral(label) : undefined;
@@ -1577,7 +1607,7 @@ export function decompileWithDiagnostics(plan, options = {}) {
             throw new Error('allowAdhocOptionalStageTasks must be boolean.');
         out.line(depth, metadata.allowAdhocOptionalStageTasks ? '.allowAdhocTasks()' : '.allowAdhocTasks(false)');
     }
-    emitVariables(out, depth, plan, triggerNameById);
+    emitVariables(out, depth, plan, triggerNameById, triggers.map(isTimerTrigger));
     triggers.forEach((_trigger, index) => out.line(depth, `.trigger(trigger${index + 1})`));
     (metadata.slaRules ?? []).forEach((sla, index) => out.line(depth, `.sla(${slaSource(sla, index)})`));
     for (const event of metadata.businessEvents ?? [])

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";
 /**

package/dist/case/external.js

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