@uipath/maestro-builder-sdk 6.68.5 → 6.68.7

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.`;
+}

package/dist/case/serialize.js

@@ -19,7 +19,7 @@ import { bindingLabelRefusal } from '../core/binding-messages.js';
 import { resolveEventWhere } from '../core/lookups.js';
 import { resolveCaseSubscription } from './subscription.js';
 import { dedupeConditionNames } from './rule-names.js';
-import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_EVENT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode, } from './external.js';
+import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, externalDescriptorRefusal, externalExecution, externalServiceType, } from './external.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS, caseVersionMismatch } from './format-profile.js';
 import { isResourceLabelRefusal, resolveResourceRef, resourceIdentity } from './resource-identity.js';
 import { ownEntry } from '../core/own-entry.js';
@@ -31,6 +31,7 @@ import { readEventFilterLeaf, eventFilterTreeLeaf } from '../core/event-filters.
 import { responseJsonSchema } from '../core/connector-response-schema.js';
 import { ruleShapeProblems } from './rule-options.js';
 import { CompileRefusal } from '../core/compile-refusal.js';
+import { implicitInArgBuiltTrigger, unboundInArgMessage } from './in-arg-binding.js';
 import { taskShapeProblems } from './task-shape.js';
 import { connectorPlaceholderData, isConnectorPlaceholder } from './connector-placeholder.js';
 /** The ids a serialize pass hashed from element ids, by the document it returned. */
@@ -258,7 +259,7 @@ export function serialize(built, opts = {}) {
     // outputs bound (collected during stage emission above). A declared var wins
     // on a name clash. An own-name output (`id == var`) writes no root entry: like
     // the Designer, the output row is itself the variable `=vars.<id>` reads.
-    const variables = emitVariables(built.vars, ids, triggerNodeByRef);
+    const variables = emitVariables(built.vars, ids, triggerNodeByRef, triggerNodes, built.triggers);
     const inputOutputs = variables.inputOutputs;
     const declared = new Set(inputOutputs.map((e) => e.id));
     for (const [name, companion] of resolver.varCompanions)
@@ -960,7 +961,8 @@ function reseed(value, ids) {
             value[key] = next;
     }
 }
-function emitVariables(vars, ids, triggerNodeByRef) {
+function emitVariables(vars, ids, triggerNodeByRef, triggerNodes, triggers) {
+    const implicit = implicitInArgBuiltTrigger(triggers);
     const inputs = [];
     const outputs = [];
     const inputOutputs = [];
@@ -1002,26 +1004,38 @@ function emitVariables(vars, ids, triggerNodeByRef) {
             id: slotId,
             name: vd.name,
             type: vd.type,
-            ...encodedDefault(vd),
+            // A trigger-bound In-arg always carries a default, `""` when none was
+            // authored. It is written here, ahead of a structured var's schema, so
+            // `{ type }` and `{ type, default: "" }` emit the same bytes and a
+            // decompile (which reads the `""` back) recompiles byte-identically.
+            ...(vd.direction === 'in' ? { default: encodedDefault(vd).default ?? '' } : encodedDefault(vd)),
+            ...jsonSchemaFields(vd),
         };
-        Object.assign(entry, jsonSchemaFields(vd));
-        if (vd.direction === 'in' && vd.sourceTrigger) {
-            // Trigger-bound In-arg: formal slot + companion + a bridge on the trigger
-            // node that copies the slot into the companion at fire (see the skill's
-            // variables/io-binding + global-vars § In argument). Its companion is keyed
-            // to the trigger node, so it does not also take a root companion.
-            const node = triggerNodeByRef.get(vd.sourceTrigger);
-            if (!node)
-                throw new CompileRefusal('CASE_IN_ARG_TRIGGER_NOT_ADDED', `In-arg "${vd.name}" is bound via { from } to a trigger that was not added with .trigger(...).`);
-            entry.default = vd.default === undefined ? '' : encodedDefault(vd).default;
+        if (vd.direction === 'in') {
+            // An In-arg is always trigger-bound: formal slot + companion + a bridge on
+            // the trigger node that copies the slot into the companion at fire (see the
+            // skill's variables/io-binding + global-vars § In argument). Its companion
+            // is keyed to the trigger node, so it does not also take a root companion.
+            // The Designer writes no other In-arg shape, and `uip maestro case validate
+            // --strict` refuses an In-arg without its companion
+            // (STRICT_INPUTOUTPUTS_COMPANION). Without `{ from }` the arg binds to the
+            // primary trigger (in-arg-binding.ts); when there is none it is refused
+            // (`check` reports the same code first).
+            let node;
+            if (vd.sourceTrigger) {
+                node = triggerNodeByRef.get(vd.sourceTrigger);
+                if (!node)
+                    throw new CompileRefusal('CASE_IN_ARG_TRIGGER_NOT_ADDED', `In-arg "${vd.name}" is bound via { from } to a trigger that was not added with .trigger(...).`);
+            }
+            else if (implicit !== undefined)
+                node = triggerNodes[implicit];
+            else
+                throw new CompileRefusal('CASE_IN_ARG_UNBOUND', unboundInArgMessage(vd.name, triggers));
             entry.elementId = node.id;
             inputs.push(entry);
             inputOutputs.push({ id: vd.name, name: vd.name, type: vd.type, elementId: node.id, ...jsonSchemaFields(vd) });
             appendTriggerBridge(node, { name: vd.name, type: vd.type, source: `=vars.${slotId}`, var: vd.name });
         }
-        else if (vd.direction === 'in') {
-            inputs.push(entry); // bare declaration (unbound In-arg; readable only via a trigger)
-        }
         else if (vd.direction === 'out') {
             outputs.push(entry); // formal declaration
             inputOutputs.push(readableCompanion(vd)); // …made readable as `vars.<name>`
@@ -1814,24 +1828,26 @@ function externalTaskData(kind, spec, resolver, elementId, where) {
     const refused = externalDescriptorRefusal(kind, rc);
     if (refused)
         throw new CompileRefusal(EXTERNAL_TASK_DESCRIPTOR_CONTRACT, refused);
-    if (!isExternalExecutionMode(spec.mode))
-        throw new CompileRefusal('EXTERNAL_TASK_MODE', `${kind} task mode must be the connector object's executionType: "sync", "async" or "hybrid".`);
-    const eventRefused = externalEventRefusal(where, spec.mode, spec.event);
-    if (eventRefused)
-        throw new CompileRefusal(EXTERNAL_TASK_EVENT, eventRefused);
+    // The authored mode and event, else the library's (#1369): the same call check makes.
+    const execution = externalExecution(where, spec, rc.entry?.operation ?? {});
+    if (!execution)
+        throw new Error(`internal SDK error: ${where} was judged without its library operation.`);
+    if (execution.code !== undefined)
+        throw new CompileRefusal(execution.code, execution.message);
+    const { mode, event } = execution;
     if (!spec.connector.connection || !spec.connector.folder)
         throw new CompileRefusal(spec.connector.connection ? 'EXTERNAL_TASK_FOLDER' : 'EXTERNAL_TASK_CONNECTION', `${kind} task requires non-empty connection and folder binding names.`);
-    const data = connectorTaskData(spec.connector, resolver, elementId, where, spec.mode, spec.event);
+    const data = connectorTaskData(spec.connector, resolver, elementId, where, mode, event);
     const context = data.context;
     const metadataAt = context.findIndex((row) => row.name === 'metadata');
     // The Designer's order: the event pair (when the object answers through one),
     // then the execution type, just before `metadata`.
-    context.splice(metadataAt, 0, ...(spec.event ? [
-        io('operation', 'string', { value: spec.event.operation }),
-        io('eventMode', 'string', { value: spec.event.mode }),
-    ] : []), io('executionType', 'string', { value: spec.mode }));
+    context.splice(metadataAt, 0, ...(event ? [
+        io('operation', 'string', { value: event.operation }),
+        io('eventMode', 'string', { value: event.mode }),
+    ] : []), io('executionType', 'string', { value: mode }));
     context.push(io('activityConfigurationVersion', 'string', { value: 'v2' }));
-    return { ...data, serviceType: externalServiceType(kind, spec.mode) };
+    return { ...data, serviceType: externalServiceType(kind, mode) };
 }
 /** A context/output name/value entry (the caseplan `InputOutput` shape). */
 function io(name, type, extra) {

package/dist/core/refusals.d.ts

@@ -151,6 +151,7 @@ export declare const REFUSALS: {
     readonly CASE_APP_DETAILS_TYPE: "lint";
     readonly CASE_EXPORT_NOT_BUILT: "lowering";
     readonly CASE_IN_ARG_TRIGGER_NOT_ADDED: "lowering";
+    readonly CASE_IN_ARG_UNBOUND: "lowering";
     readonly CASE_LAYOUT_NODE_MATCH: "lowering";
     readonly CASE_LAYOUT_UNKNOWN_FIELD: "lowering";
     readonly CASE_NO_DEFAULT_EXPORT: "lowering";
@@ -277,6 +278,7 @@ export declare const REFUSALS: {
     readonly EXTERNAL_TASK_EVENT: "lowering";
     readonly EXTERNAL_TASK_FOLDER: "lowering";
     readonly EXTERNAL_TASK_MODE: "lowering";
+    readonly EXTERNAL_TASK_MODE_MISMATCH: "lowering";
     readonly EXTRACT_SCHEMA_SHAPE: "lint";
     readonly FAKE_JOIN: "lint";
     readonly FILE_NOT_FOUND: "lowering";

package/dist/core/refusals.js

@@ -199,6 +199,7 @@ export const REFUSALS = {
     CASE_APP_DETAILS_TYPE: 'lint',
     CASE_EXPORT_NOT_BUILT: 'lowering',
     CASE_IN_ARG_TRIGGER_NOT_ADDED: 'lowering',
+    CASE_IN_ARG_UNBOUND: 'lowering',
     CASE_LAYOUT_NODE_MATCH: 'lowering',
     CASE_LAYOUT_UNKNOWN_FIELD: 'lowering',
     CASE_NO_DEFAULT_EXPORT: 'lowering',
@@ -328,6 +329,7 @@ export const REFUSALS = {
     EXTERNAL_TASK_EVENT: 'lowering',
     EXTERNAL_TASK_FOLDER: 'lowering',
     EXTERNAL_TASK_MODE: 'lowering',
+    EXTERNAL_TASK_MODE_MISMATCH: 'lowering',
     EXTRACT_SCHEMA_SHAPE: 'lint',
     FAKE_JOIN: 'lint',
     FILE_NOT_FOUND: 'lowering',

package/dist/registry/library-build/enrich.d.ts

@@ -1,5 +1,6 @@
 import type { LibraryEntry } from "../model/library.js";
 import { type BuildContext } from "./context.js";
+import { type Dict } from "./py.js";
 /**
  * Registry `httpMethod` (e.g. `GETBYID`) → a guess at the `is resources`
  * operation name, for an entry whose canonical `operation.name` is empty.
@@ -18,6 +19,25 @@ export declare function discoverOperationName(ctx: BuildContext, entry: LibraryE
  * payload; `objectDisplayName` and `display.operationLabel` fill gaps only.
  */
 export declare function applyDescribe(entry: LibraryEntry, data: unknown): LibraryEntry;
+/**
+ * Record an external agent's or automation's execution facts on its operation,
+ * from the describe payload (#1369, #1387).
+ *
+ * Integration Service keeps them on the object's metadata, not in the registry
+ * node: `executionType` (`sync`, `async` or `hybrid`) and, for an `async` or
+ * `hybrid` object, the event it answers with. `uip is resources describe`
+ * reports them as `ExecutionType`, `EventType` and `EventMode` (uip#5702,
+ * read with the same `externalExecutionOf` as `case spec`). They become
+ * `operation.executionType` and `operation.executionEvent` (`{ operation, mode }`),
+ * which Case and BPMN derive the task's `mode` and `event` from. The event is
+ * kept apart from `eventOperation` / `eventMode`, which mark a connector EVENT
+ * entry (a trigger) and which `identifyEvent` matches on.
+ *
+ * Only an `AgentExecution` / `ProcessExecution` operation gets them, and only
+ * what the payload states (an execution type outside the three is not stored): a describe from a CLI that does not report them
+ * leaves the entry as it was, so an older build stays byte-identical.
+ */
+export declare function applyExternalExecution(operation: Dict, data: unknown): void;
 /**
  * `enrich_entry`: augment a canonical entry with `is resources describe` data.
  * On any failure the entry is returned as it was, so the pipeline degrades

package/dist/registry/library-build/enrich.js

@@ -78,6 +78,7 @@ export function applyDescribe(entry, data) {
     const opCurated = pick(opData, "Curated", "curated");
     if (pyTruthy(opCurated) && !pyTruthy(get(display, "operationLabel")))
         display.operationLabel = opCurated;
+    applyExternalExecution(operation, data);
     // Parameters (path / query) — raw shape, camelCase keys.
     const params = pyOr(pick(data, "Parameters", "parameters"), []);
     if (pyTruthy(params))
@@ -92,6 +93,45 @@ export function applyDescribe(entry, data) {
         e.outputSchema = { fields: normalizeFieldKeys(responseFields) };
     return entry;
 }
+/** The operation subtypes Case's and BPMN's external agent / workflow tasks run. */
+const EXTERNAL_SUBTYPES = new Set(["AgentExecution", "ProcessExecution"]);
+/** The execution types Integration Service reports, as Case and BPMN read them. */
+const EXECUTION_TYPES = new Set(["sync", "async", "hybrid"]);
+/**
+ * Record an external agent's or automation's execution facts on its operation,
+ * from the describe payload (#1369, #1387).
+ *
+ * Integration Service keeps them on the object's metadata, not in the registry
+ * node: `executionType` (`sync`, `async` or `hybrid`) and, for an `async` or
+ * `hybrid` object, the event it answers with. `uip is resources describe`
+ * reports them as `ExecutionType`, `EventType` and `EventMode` (uip#5702,
+ * read with the same `externalExecutionOf` as `case spec`). They become
+ * `operation.executionType` and `operation.executionEvent` (`{ operation, mode }`),
+ * which Case and BPMN derive the task's `mode` and `event` from. The event is
+ * kept apart from `eventOperation` / `eventMode`, which mark a connector EVENT
+ * entry (a trigger) and which `identifyEvent` matches on.
+ *
+ * Only an `AgentExecution` / `ProcessExecution` operation gets them, and only
+ * what the payload states (an execution type outside the three is not stored): a describe from a CLI that does not report them
+ * leaves the entry as it was, so an older build stays byte-identical.
+ */
+export function applyExternalExecution(operation, data) {
+    if (!EXTERNAL_SUBTYPES.has(String(get(operation, "subType") ?? "")))
+        return;
+    // Stored only as one of the three values Case and BPMN read, lowercased: a
+    // `Hybrid` kept verbatim would be ignored downstream and read as "no record".
+    const reported = pick(data, "ExecutionType", "executionType");
+    const executionType = typeof reported === "string" ? reported.trim().toLowerCase() : "";
+    if (!EXECUTION_TYPES.has(executionType))
+        return;
+    operation.executionType = executionType;
+    if (executionType === "sync")
+        return;
+    const eventType = pick(data, "EventType", "eventType");
+    const eventMode = pick(data, "EventMode", "eventMode");
+    if (typeof eventType === "string" && eventType && typeof eventMode === "string" && eventMode)
+        operation.executionEvent = { operation: eventType, mode: eventMode };
+}
 /**
  * `enrich_entry`: augment a canonical entry with `is resources describe` data.
  * On any failure the entry is returned as it was, so the pipeline degrades

package/dist/registry/model/library.d.ts

@@ -85,6 +85,16 @@ export interface EntryOperation {
     objectFromDiscovery?: boolean;
     eventOperation?: string;
     eventMode?: string;
+    /**
+     * An external agent's or automation's `executionType` (`sync`, `async`,
+     * `hybrid`), on an `AgentExecution` / `ProcessExecution` operation only.
+     */
+    executionType?: string;
+    /** The event an `async` / `hybrid` external object answers with. */
+    executionEvent?: {
+        operation: string;
+        mode: string;
+    };
     schemaAction?: SchemaAction | null;
     dispatchStyle?: string;
     paramGrammars?: unknown;

package/package.json

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