@uipath/maestro-builder-sdk 6.68.4 → 6.68.6

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

@@ -437,9 +437,10 @@ export type ConnectorSpecData = Extract<ActionSpec, {
  * and `hybrid` as `Async…Execution`, and writes the value itself into the task's
  * `executionType` context.
  *
- * `hybrid` is refused for now (EXTERNAL_TASK_HYBRID_UNSUPPORTED): the Designer
- * also writes an event pair for it (`operation`, `eventMode`) that the connector
- * library does not carry (#1387). Add a task on a hybrid object in Studio Web.
+ * An `async` or `hybrid` object also answers through an event, which the
+ * Designer saves next to it; pass that pair as {@link ExternalTaskOptions.event}.
+ * A `hybrid` task without it is refused (EXTERNAL_TASK_EVENT), since the task
+ * would have nothing to wait on.
  *
  * It does not decide whether the stage waits for the task. A task the stage must
  * not wait on is `.required(false)`, whatever its execution type. For example, a
@@ -447,6 +448,27 @@ export type ConnectorSpecData = Extract<ActionSpec, {
  * it.
  */
 export type ExternalExecutionMode = 'sync' | 'async' | 'hybrid';
+/**
+ * The event an `async` or `hybrid` external object answers with, as Integration
+ * Service reports it for the connector object.
+ *
+ * @remarks
+ * Like the execution type, a property of the connector object, not a choice:
+ * 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
+ * `{ operation: 'TRIGGER_CREATED', mode: 'polling' }`.
+ */
+export interface ExternalEventPair {
+    /** The event operation, e.g. `TRIGGER_CREATED`: the task's `operation` context row. */
+    operation: string;
+    /** How the event is received: the task's `eventMode` context row. */
+    mode: 'polling' | 'webhooks';
+}
 /** Required wiring and typed inputs for an external agent/workflow invocation. */
 export interface ExternalTaskOptions<I extends Record<string, unknown>> {
     /** Symbolic Integration Service connection name declared in `bindings.json`. */
@@ -460,6 +482,12 @@ export interface ExternalTaskOptions<I extends Record<string, unknown>> {
      * `.required(false)`. See {@link 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}.
+     */
+    event?: ExternalEventPair;
     /** Inputs statically checked by the generated connector descriptor. */
     inputs: I;
 }
@@ -467,6 +495,8 @@ export interface ExternalTaskOptions<I extends Record<string, unknown>> {
 export interface ExternalTaskSpecData {
     /** The connector object's `executionType`. */
     mode: ExternalExecutionMode;
+    /** The event an `async` or `hybrid` object answers with, when given. */
+    event?: ExternalEventPair;
     /** Shared connector action identity, inputs, and symbolic bindings. */
     connector: ConnectorSpecData;
 }
@@ -683,9 +713,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;
 }
@@ -1431,10 +1462,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**
@@ -1445,7 +1494,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

@@ -334,6 +334,7 @@ class TaskBuilder {
         this.setKind(kind);
         this._external = {
             mode: opts.mode,
+            ...(opts.event !== undefined ? { event: { ...opts.event } } : {}),
             connector: makeConnector(descriptor, opts.inputs, {
                 connection: opts.connection,
                 folder: opts.folder,
@@ -955,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**
@@ -969,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.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_HYBRID_UNSUPPORTED, externalHybridRefusal, isExternalExecutionMode } from './external.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 { 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`,
@@ -623,13 +629,11 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
                         message: `${family} task "${t.name}" mode must be the connector object's executionType: "sync", "async" or "hybrid".`,
                         where: t.name,
                     });
-                else if (t.external.mode === 'hybrid')
-                    diags.push({
-                        level: 'error',
-                        code: EXTERNAL_TASK_HYBRID_UNSUPPORTED,
-                        message: externalHybridRefusal(`${family} task "${t.name}"`),
-                        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',

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, externalDescriptorRefusal, externalHybridRefusal, externalServiceType, isExternalExecutionMode } from './external.js';
+import { EXTERNAL_TASK_CONTEXT, EXTERNAL_TASK_EVENT_CONTEXT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode } from './external.js';
 import { preserveSchemaVersion } from '../schema-version.js';
 import { ownEntry } from '../core/own-entry.js';
 import { isUnrestorableSlotId, taskFingerprint } from './preserve.js';
@@ -618,7 +619,9 @@ function connectorCall(task, refs, library) {
 /**
  * Lift an External Agent / External Workflow task saved in the Case Designer's
  * shape (the one `serialize` emits): a connector activity's context and input
- * containers plus the object's `executionType`, which becomes `mode`. The
+ * containers plus the object's `executionType`, which becomes `mode`, and the
+ * event pair an async / hybrid object answers with (`operation` and `eventMode`
+ * rows), which becomes `event`. The
  * service type must be the one that execution type gives, so a plan whose two
  * disagree is refused rather than lifted to a source that would compile to
  * something else.
@@ -637,19 +640,20 @@ function externalCall(task, refs, library) {
         throw new Error(`${owner} data.bindings must be an empty array; bindings live at case root.`);
     if (!Array.isArray(data.context))
         throw new Error(`${owner} requires a resolved context array.`);
-    // A hybrid task carries an event pair the SDK cannot write back (#1387): refuse
-    // it by name, before its extra context rows are reported as unknown.
-    if (data.context.some((row) => row?.name === 'executionType' && row.value === 'hybrid'))
-        throw new Error(externalHybridRefusal(owner));
-    // Exactly the context rows serialize writes (the Designer's set): an unknown
-    // or repeated row would be dropped by the lift and lost on recompile.
+    // Exactly the context rows serialize writes (the Designer's set, plus the
+    // event pair an async / hybrid object answers with): an unknown or repeated
+    // row would be dropped by the lift and lost on recompile.
     const contextNames = data.context.map((row) => String(row?.name ?? ''));
-    const unknownContext = contextNames.find((name, at) => !EXTERNAL_TASK_CONTEXT.includes(name) || contextNames.indexOf(name) !== at);
+    const unknownContext = contextNames.find((name, at) => !(EXTERNAL_TASK_CONTEXT.includes(name) || EXTERNAL_TASK_EVENT_CONTEXT.includes(name)) || contextNames.indexOf(name) !== at);
     if (unknownContext !== undefined)
         throw new Error(`${owner} has unsupported or repeated context row "${unknownContext}".`);
     const absentContext = EXTERNAL_TASK_CONTEXT.find((name) => !contextNames.includes(name));
     if (absentContext)
         throw new Error(`${owner} is missing context row "${absentContext}".`);
+    // The pair is written whole or not at all, so half of one cannot be lifted.
+    const eventRows = EXTERNAL_TASK_EVENT_CONTEXT.filter((name) => contextNames.includes(name));
+    if (eventRows.length === 1)
+        throw new Error(`${owner} carries context row "${eventRows[0]}" without "${EXTERNAL_TASK_EVENT_CONTEXT.find((name) => name !== eventRows[0])}"; the event pair is saved whole.`);
     const context = contextMap(data);
     const stringValue = (name) => {
         const row = context.get(name);
@@ -672,6 +676,18 @@ 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).
+    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.
+    if (mode === 'sync' && event)
+        throw new Error(`${owner} has context rows "operation" (${JSON.stringify(event.operation)}) and "eventMode" ` +
+            `(${JSON.stringify(event.mode)}) on executionType "sync"; a sync object answers inline and has no event. ` +
+            `Remove the two rows, or fix executionType and serviceType if the object is async or hybrid.`);
+    const eventRefused = externalEventRefusal(owner, mode, event);
+    if (eventRefused)
+        throw new Error(eventRefused);
     const identity = library.identifyAction({
         connectorKey: stringValue('connectorKey'),
         httpMethod: stringValue('method'),
@@ -691,6 +707,7 @@ function externalCall(task, refs, library) {
         ['connection', tsLiteral(binding('connection'))],
         ['folder', tsLiteral(binding('folderKey'))],
         ['mode', tsLiteral(mode)],
+        ['event', event ? opts([['operation', tsLiteral(event.operation)], ['mode', tsLiteral(event.mode)]]) : undefined],
         ['inputs', tsLiteral(inputs)],
     ]);
     const method = kind === 'external-agent' ? 'externalAgent' : 'externalWorkflow';
@@ -1072,13 +1089,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)} })`);
@@ -1114,6 +1143,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;
@@ -1561,7 +1594,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

@@ -8,32 +8,43 @@
  * `buildConnectorInputs`, which `check` already runs as `connectorInputs`.
  */
 import type { ResolvedConnector } from '../core/library.js';
-import type { ExternalExecutionMode } from './case-sdk.js';
+import type { ExternalEventPair, ExternalExecutionMode } from './case-sdk.js';
 /**
  * The context rows `serialize` writes on an external task: the set the Case
  * Designer saves for a sync object (`uip`'s
  * `tests/fixtures/external-tasks/designer-saved.json`, the Snowflake Cortex
- * agent). `decompile` refuses a task with any other row, since the lift would
- * drop it without a word. A `hybrid` task (which also carries `operation` and
- * `eventMode`) is refused before this check; see {@link externalHybridRefusal}.
+ * agent). An `async` or `hybrid` task may also carry
+ * {@link EXTERNAL_TASK_EVENT_CONTEXT}. `decompile` refuses a task with any other
+ * row, since the lift would drop it without a word.
  */
 export declare const EXTERNAL_TASK_CONTEXT: readonly string[];
-/** Check's code for {@link externalHybridRefusal}. */
-export declare const EXTERNAL_TASK_HYBRID_UNSUPPORTED = "EXTERNAL_TASK_HYBRID_UNSUPPORTED";
 /**
- * Why an external task on a `hybrid` object cannot be compiled or decompiled
- * yet. The Case Designer saves such a task with an event pair (context
- * `operation`, e.g. `TRIGGER_CREATED`, and `eventMode`, e.g. `polling`, also in
- * the metadata's `activityPropertyConfiguration`) that it reads from live
- * Integration Service metadata. The connector library does not carry that pair
- * (#1387), so the SDK cannot write the task faithfully, and a guessed pair could
- * deploy a task that never completes. `check`, `serialize` and `decompile` all
- * refuse with this text.
+ * The two context rows that carry the event an `async` / `hybrid` object
+ * answers with (`ExternalEventPair`): `operation` (e.g. `TRIGGER_CREATED`) and
+ * `eventMode` (e.g. `polling`). The Designer writes them after `objectName`,
+ * before `executionType` (the Power Automate flow in `designer-saved.json`).
+ */
+export declare const EXTERNAL_TASK_EVENT_CONTEXT: readonly string[];
+/** Check's and compile's code for {@link externalEventRefusal}. */
+export declare const EXTERNAL_TASK_EVENT = "EXTERNAL_TASK_EVENT";
+/** The event modes Integration Service reports for an object's events. */
+export declare function isExternalEventMode(value: unknown): value is ExternalEventPair['mode'];
+/**
+ * Why this task's event pair cannot be written, or `undefined`.
+ *
+ * A `hybrid` object answers through an event, and the Case Designer saves that
+ * event with the task (context `operation` and `eventMode`, and the same pair in
+ * the metadata's `activityPropertyConfiguration`). Without it the task has
+ * nothing to wait on, so `hybrid` needs the pair. An `async` object takes it
+ * when given. A `sync` object answers inline and has none, so a pair there is a
+ * wrong `mode` or a wrong pair. `check`, `serialize` and `decompile` all use this.
  *
  * @param owner - The task as the message names it, e.g. `External Workflow task "Run"`.
- * @returns The refusal.
+ * @param mode - The task's execution type (already known to be valid).
+ * @param event - The authored or saved pair, if any.
+ * @returns The refusal, or `undefined`.
  */
-export declare function externalHybridRefusal(owner: string): string;
+export declare function externalEventRefusal(owner: string, mode: ExternalExecutionMode, event: unknown): string | undefined;
 /** The execution types an external task accepts: the values Integration Service reports. */
 export declare function isExternalExecutionMode(value: unknown): value is ExternalExecutionMode;
 /**

package/dist/case/external.js

@@ -3,34 +3,61 @@ import { CASE_FORMAT_PROFILE } from './format-profile.js';
  * The context rows `serialize` writes on an external task: the set the Case
  * Designer saves for a sync object (`uip`'s
  * `tests/fixtures/external-tasks/designer-saved.json`, the Snowflake Cortex
- * agent). `decompile` refuses a task with any other row, since the lift would
- * drop it without a word. A `hybrid` task (which also carries `operation` and
- * `eventMode`) is refused before this check; see {@link externalHybridRefusal}.
+ * agent). An `async` or `hybrid` task may also carry
+ * {@link EXTERNAL_TASK_EVENT_CONTEXT}. `decompile` refuses a task with any other
+ * row, since the lift would drop it without a word.
  */
 export const EXTERNAL_TASK_CONTEXT = [
     'connectorKey', 'connection', 'resourceKey', 'folderKey', 'objectName', 'method', 'path',
     'executionType', 'metadata', 'activityConfigurationVersion',
 ];
-/** Check's code for {@link externalHybridRefusal}. */
-export const EXTERNAL_TASK_HYBRID_UNSUPPORTED = 'EXTERNAL_TASK_HYBRID_UNSUPPORTED';
 /**
- * Why an external task on a `hybrid` object cannot be compiled or decompiled
- * yet. The Case Designer saves such a task with an event pair (context
- * `operation`, e.g. `TRIGGER_CREATED`, and `eventMode`, e.g. `polling`, also in
- * the metadata's `activityPropertyConfiguration`) that it reads from live
- * Integration Service metadata. The connector library does not carry that pair
- * (#1387), so the SDK cannot write the task faithfully, and a guessed pair could
- * deploy a task that never completes. `check`, `serialize` and `decompile` all
- * refuse with this text.
+ * The two context rows that carry the event an `async` / `hybrid` object
+ * answers with (`ExternalEventPair`): `operation` (e.g. `TRIGGER_CREATED`) and
+ * `eventMode` (e.g. `polling`). The Designer writes them after `objectName`,
+ * before `executionType` (the Power Automate flow in `designer-saved.json`).
+ */
+export const EXTERNAL_TASK_EVENT_CONTEXT = ['operation', 'eventMode'];
+/** Check's and compile's code for {@link externalEventRefusal}. */
+export const EXTERNAL_TASK_EVENT = 'EXTERNAL_TASK_EVENT';
+/** The event modes Integration Service reports for an object's events. */
+export function isExternalEventMode(value) {
+    return value === 'polling' || value === 'webhooks';
+}
+/**
+ * Why this task's event pair cannot be written, or `undefined`.
+ *
+ * A `hybrid` object answers through an event, and the Case Designer saves that
+ * event with the task (context `operation` and `eventMode`, and the same pair in
+ * the metadata's `activityPropertyConfiguration`). Without it the task has
+ * nothing to wait on, so `hybrid` needs the pair. An `async` object takes it
+ * when given. A `sync` object answers inline and has none, so a pair there is a
+ * wrong `mode` or a wrong pair. `check`, `serialize` and `decompile` all use this.
  *
  * @param owner - The task as the message names it, e.g. `External Workflow task "Run"`.
- * @returns The refusal.
+ * @param mode - The task's execution type (already known to be valid).
+ * @param event - The authored or saved pair, if any.
+ * @returns The refusal, or `undefined`.
  */
-export function externalHybridRefusal(owner) {
-    return (`${owner} is on a "hybrid" object, which Case cannot compile yet: the connector library does not carry ` +
-        `the event pair the Case Designer writes for it (operation, e.g. "TRIGGER_CREATED", and eventMode, e.g. "polling"), ` +
-        `so the task cannot be written faithfully. Add this task in Studio Web for now; ` +
-        `https://github.com/UiPath/builder-sdk/issues/1387 tracks the library change.`);
+export function externalEventRefusal(owner, mode, event) {
+    if (event === undefined) {
+        if (mode !== 'hybrid')
+            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.`);
+    }
+    if (mode === 'sync')
+        return `${owner} is on a "sync" object, which answers inline and has no event; drop event, or fix mode.`;
+    const pair = event;
+    if (typeof pair !== 'object' || pair === null || typeof pair.operation !== 'string' || !pair.operation.trim())
+        return `${owner} event.operation must be the object's non-empty event operation, e.g. "TRIGGER_CREATED".`;
+    // Written as given, and Integration Service matches it exactly: " TRIGGER_CREATED" would never match.
+    if (pair.operation !== pair.operation.trim())
+        return `${owner} event.operation ${JSON.stringify(pair.operation)} has surrounding whitespace; write it exactly as the object reports it, e.g. "TRIGGER_CREATED".`;
+    if (!isExternalEventMode(pair.mode))
+        return `${owner} event.mode must be "polling" or "webhooks"; got ${JSON.stringify(pair.mode)}.`;
+    return undefined;
 }
 /** The execution types an external task accepts: the values Integration Service reports. */
 export function isExternalExecutionMode(value) {

package/dist/case/in-arg-binding.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Which trigger a case In-arg (`.input()`) binds to — the rule `check` reports,
+ * `serialize` applies and `decompile` follows, kept in one place so they cannot
+ * drift (builder-sdk#1368).
+ *
+ * An In-arg's value arrives from a trigger: the caseplan carries a formal slot
+ * in `variables.inputs[]`, a same-name `variables.inputOutputs[]` companion
+ * keyed to the trigger node, and a bridge on that node. That is the only shape
+ * the Case Designer writes, and `uip maestro case validate --strict` refuses an
+ * In-arg with no companion (STRICT_INPUTOUTPUTS_COMPANION). So an In-arg always
+ * binds:
+ *
+ *   - `.input(shape, { from: t })` binds to `t`;
+ *   - with no `{ from }`, it binds to the PRIMARY trigger: the case's only
+ *     trigger (the one `.trigger()` added, or the implicit manual trigger when
+ *     none was added, whatever its kind); with several, the one trigger that is
+ *     not a timer — the one a caller starts the case through;
+ *   - with no `{ from }` and no single such trigger (several non-timer
+ *     triggers, or only timers) there is no right guess, and the case is
+ *     refused with CASE_IN_ARG_UNBOUND.
+ *
+ * This is the rule `uip maestro case sdd convert` applies to an `In` row with a
+ * blank `sourceTriggers` cell (cli `sdd-convert/variables.ts`,
+ * `boundTriggerFor`), and the one its `in_arg_trigger_bind` grader checks.
+ */
+import type { BuiltTrigger, CaseVarDecl } from './case-sdk.js';
+/**
+ * The index, among the triggers the case emits, of the one an In-arg without
+ * `{ from }` binds to.
+ *
+ * @param isTimer - For each emitted trigger, in order, whether it is a timer.
+ *   An empty list stands for the implicit manual trigger.
+ * @returns The trigger's index, or `undefined` when no single trigger qualifies.
+ */
+export declare function implicitInArgTrigger(isTimer: readonly boolean[]): number | undefined;
+/**
+ * {@link implicitInArgTrigger} over a built case's declared triggers.
+ *
+ * @param triggers - The case's `.trigger()` list.
+ * @returns The index of the trigger a `{ from }`-less In-arg binds to, or `undefined`.
+ */
+export declare function implicitInArgBuiltTrigger(triggers: readonly BuiltTrigger[]): number | undefined;
+/**
+ * Whether an In-arg declared without `{ from }` has no trigger to bind to.
+ *
+ * @param vd - The declared variable.
+ * @param triggers - The case's `.trigger()` list.
+ * @returns `true` when the In-arg must name its trigger with `{ from }`.
+ */
+export declare function isUnboundInArg(vd: CaseVarDecl, triggers: readonly BuiltTrigger[]): boolean;
+/**
+ * The CASE_IN_ARG_UNBOUND message.
+ *
+ * @param name - The In-arg's name.
+ * @param triggers - The case's `.trigger()` list.
+ * @returns The message both `check` and `serialize` report.
+ */
+export declare function unboundInArgMessage(name: string, triggers: readonly BuiltTrigger[]): string;

package/dist/case/in-arg-binding.js

@@ -0,0 +1,48 @@
+/**
+ * The index, among the triggers the case emits, of the one an In-arg without
+ * `{ from }` binds to.
+ *
+ * @param isTimer - For each emitted trigger, in order, whether it is a timer.
+ *   An empty list stands for the implicit manual trigger.
+ * @returns The trigger's index, or `undefined` when no single trigger qualifies.
+ */
+export function implicitInArgTrigger(isTimer) {
+    if (isTimer.length <= 1)
+        return 0;
+    const callable = isTimer.flatMap((timer, i) => (timer ? [] : [i]));
+    return callable.length === 1 ? callable[0] : undefined;
+}
+/**
+ * {@link implicitInArgTrigger} over a built case's declared triggers.
+ *
+ * @param triggers - The case's `.trigger()` list.
+ * @returns The index of the trigger a `{ from }`-less In-arg binds to, or `undefined`.
+ */
+export function implicitInArgBuiltTrigger(triggers) {
+    return implicitInArgTrigger(triggers.map((t) => t.kind === 'timer'));
+}
+/**
+ * Whether an In-arg declared without `{ from }` has no trigger to bind to.
+ *
+ * @param vd - The declared variable.
+ * @param triggers - The case's `.trigger()` list.
+ * @returns `true` when the In-arg must name its trigger with `{ from }`.
+ */
+export function isUnboundInArg(vd, triggers) {
+    return vd.direction === 'in' && !vd.sourceTrigger && implicitInArgBuiltTrigger(triggers) === undefined;
+}
+/**
+ * The CASE_IN_ARG_UNBOUND message.
+ *
+ * @param name - The In-arg's name.
+ * @param triggers - The case's `.trigger()` list.
+ * @returns The message both `check` and `serialize` report.
+ */
+export function unboundInArgMessage(name, triggers) {
+    const callable = triggers.filter((t) => t.kind !== 'timer').length;
+    const why = callable === 0
+        ? `all ${triggers.length} of the case's triggers are timers`
+        : `${callable} of the case's ${triggers.length} triggers are not timers`;
+    return `In-arg "${name}" has no { from }, and ${why}, so there is no primary trigger to bind it to. `
+        + `Pass .input({ ${name}: ... }, { from: <trigger> }) to name the trigger whose start supplies it, or declare it with .var() if no trigger supplies it.`;
+}