@uipath/maestro-builder-sdk 6.68.3 → 6.68.5

package/dist/case/compile-cli.js

@@ -29,9 +29,9 @@ import { defaultBindingsFile } from '../workdir.js';
 import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 import { CASE_FORMAT_PROFILE } from './format-profile.js';
-import { isInSolutionKey, SOLUTION_FOLDER } from './resource-identity.js';
+import { deriveCaseBindingsV2 } from './bindings-v2.js';
+import { BINDINGS_V2_DOCUMENT_VERSION } from '../core/bindings-v2-resource.js';
 import { sha256Uuid } from '../core/stable-id.js';
-import { isRecord } from '../core/node-envelope.js';
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: compile <case.ts | BaseName> [-o <project>/caseplan.case]');
@@ -315,210 +315,16 @@ function syncEntryPoints(caseplan, outPath) {
  * artifact. `resources refresh` reads bindings_v2.json, not caseplan.json, and
  * succeeds with zero warnings when the sidecar is stale or empty.
  *
- * Non-connector resources come from the root binding rows only, as in
- * `uip maestro case bindings sync`.
- * A connector's connection and folder relationship comes from the context[]
- * that references both binding ids.
- * No-op when compiling outside a scaffolded project.
+ * The entries are what `uip maestro case bindings sync` derives
+ * ({@link deriveCaseBindingsV2}). No-op when compiling outside a scaffolded
+ * project.
  */
 function syncBindingsV2(caseplan, outPath) {
     const sidecarPath = join(dirname(outPath), 'bindings_v2.json');
     if (!existsSync(sidecarPath))
         return -1;
-    const bindings = Array.isArray(caseplan.bindings)
-        ? caseplan.bindings.filter(isRecord)
-        : [];
-    const byId = new Map(bindings
-        .filter((binding) => typeof binding.id === 'string')
-        .map((binding) => [binding.id, binding]));
-    const resources = [];
-    // One entry per (resource, resourceKey) group of root binding rows, in the
-    // shape `uip maestro case bindings sync` derives (`deriveCaseBindingsV2` in
-    // cli case-bindings-service.ts). `validate --strict` compares the two
-    // entry by entry as serialized JSON, so field order matters as well as
-    // field values.
-    const groups = new Map();
-    for (const binding of bindings) {
-        const resource = stringValue(binding.resource);
-        const key = stringValue(binding.resourceKey);
-        if (!resource || !key || typeof binding.propertyAttribute !== 'string')
-            continue;
-        if (resource.toLowerCase() === 'connection')
-            continue;
-        const groupKey = `${resource}\0${key}`;
-        const group = groups.get(groupKey);
-        if (group)
-            group.push(binding);
-        else
-            groups.set(groupKey, [binding]);
-    }
-    const seenConnections = new Set();
-    const connectionResources = [];
-    visitRecords(caseplan, (record) => {
-        if (!Array.isArray(record.context))
-            return;
-        const context = new Map(record.context
-            .filter(isRecord)
-            .filter((row) => typeof row.name === 'string')
-            .map((row) => [row.name, row.value]));
-        const connector = stringValue(context.get('connectorKey'));
-        const connectionId = referencedBindingValue(context.get('connection'), byId);
-        const folderKey = referencedBindingValue(context.get('folderKey'), byId);
-        if (!connector || !connectionId || !folderKey || seenConnections.has(connectionId))
-            return;
-        seenConnections.add(connectionId);
-        connectionResources.push({
-            resource: 'Connection',
-            key: connectionId,
-            value: {
-                connectionId: { defaultValue: connectionId },
-                folderKey: { defaultValue: folderKey },
-            },
-            metadata: { connector },
-        });
-    });
-    const labels = bindingLabels(caseplan.nodes);
-    for (const group of groups.values())
-        resources.push(sidecarResourceEntry(group, labels));
-    resources.push(...connectionResources);
-    writeJsonFile(sidecarPath, { version: '2.0', resources });
+    const resources = deriveCaseBindingsV2(caseplan);
+    writeJsonFile(sidecarPath, { version: BINDINGS_V2_DOCUMENT_VERSION, resources });
     return resources.length;
 }
-/**
- * The Case Designer's label for each value slot of an app or process entry.
- * These resources get the Designer shape (cli#5003, MST-16424): an `id`, each
- * slot flagged and labelled, and the `BindingsVersion` / `SolutionsSupport`
- * metadata without which deploy cannot override the entry.
- */
-const DESIGNER_SLOT_NAMES = new Map([
-    ['app', { name: 'App name', folderPath: 'Folder path', solutionsSupport: true }],
-    ['process', { name: 'Process name', folderPath: 'Folder path', solutionsSupport: true }],
-    ['ixpDeployment', { name: 'name', folderPath: 'Folder path', solutionsSupport: false }],
-]);
-/** The bindings version deploy needs to override an entry. */
-const RESOURCE_BINDINGS_VERSION = '2.2';
-/**
- * One sidecar entry for a group of root binding rows that share a resource and
- * a resource key. The subtype comes from the rows only: a Flow's rows carry
- * none, so its entry has none either, as the Designer saves it.
- *
- * `metadata.ActivityName` labels a Designer-shaped entry with the first task
- * that references one of its rows ({@link bindingLabels}).
- */
-function sidecarResourceEntry(group, labels) {
-    const resource = group[0].resource;
-    const key = group[0].resourceKey;
-    const attributeDefault = (attribute) => {
-        const found = group.find((binding) => binding.propertyAttribute === attribute)?.default;
-        return typeof found === 'string' ? found : undefined;
-    };
-    // An in-solution resource binds an empty folderPath in the caseplan, while
-    // the sidecar names its folder by the sentinel the key carries.
-    const folderPath = isInSolutionKey(key) ? SOLUTION_FOLDER : attributeDefault('folderPath');
-    const name = attributeDefault('name');
-    const subType = group.map((binding) => binding.resourceSubType).find((found) => found !== undefined);
-    const designer = DESIGNER_SLOT_NAMES.get(resource);
-    if (designer) {
-        const value = {};
-        if (folderPath !== undefined) {
-            value.folderPath = { defaultValue: folderPath, isExpression: false, displayName: designer.folderPath };
-        }
-        if (name !== undefined) {
-            value.name = { defaultValue: name, isExpression: false, displayName: designer.name };
-        }
-        const activityName = group
-            .map((binding) => (typeof binding.id === 'string' ? labels.get(binding.id) : undefined))
-            .find((found) => found !== undefined);
-        return {
-            resource,
-            key,
-            id: `${resource}${key}`,
-            value,
-            metadata: {
-                ...(activityName !== undefined && { ActivityName: activityName }),
-                BindingsVersion: RESOURCE_BINDINGS_VERSION,
-                DisplayLabel: 'name',
-                ...(designer.solutionsSupport && { SolutionsSupport: 'true' }),
-                ...(subType !== undefined && { subType }),
-            },
-        };
-    }
-    const value = {};
-    if (name !== undefined)
-        value.name = { defaultValue: name };
-    if (folderPath !== undefined)
-        value.folderPath = { defaultValue: folderPath };
-    // A solution-resource picker (such as a Data Fabric entity) carries its folder key as a slot of its own.
-    const folderKey = attributeDefault('folderKey');
-    if (folderKey !== undefined)
-        value.folderKey = { defaultValue: folderKey };
-    return {
-        resource,
-        key,
-        value,
-        metadata: {
-            BindingsVersion: RESOURCE_BINDINGS_VERSION,
-            ...(subType !== undefined && { subType }),
-        },
-    };
-}
-/**
- * The label of the first object that references each binding id
- * (`=bindings.<id>`), in document order: the nearest enclosing `displayName`,
- * `display.label` or `label`. The same walk as the CLI's
- * `collectBindingLabels`, so both name an entry after the same task.
- */
-function bindingLabels(nodes) {
-    const found = new Map();
-    const ownLabel = (node) => {
-        const display = isRecord(node.display) ? node.display.label : undefined;
-        return [node.displayName, display, node.label].map(stringValue).find((label) => label !== undefined);
-    };
-    const walk = (node, label) => {
-        if (typeof node === 'string') {
-            if (label !== undefined && node.startsWith('=bindings.')) {
-                const id = node.slice('=bindings.'.length);
-                if (!found.has(id))
-                    found.set(id, label);
-            }
-            return;
-        }
-        if (Array.isArray(node)) {
-            for (const item of node)
-                walk(item, label);
-            return;
-        }
-        if (!isRecord(node))
-            return;
-        const scoped = ownLabel(node) ?? label;
-        for (const value of Object.values(node))
-            walk(value, scoped);
-    };
-    walk(nodes ?? [], undefined);
-    return found;
-}
-function referencedBindingValue(value, bindings) {
-    const ref = stringValue(value);
-    if (!ref)
-        return undefined;
-    if (!ref.startsWith('=bindings.'))
-        return ref;
-    const binding = bindings.get(ref.slice('=bindings.'.length));
-    return binding && (stringValue(binding.default) ?? stringValue(binding.resourceKey));
-}
-function visitRecords(value, visit) {
-    if (Array.isArray(value)) {
-        for (const item of value)
-            visitRecords(item, visit);
-        return;
-    }
-    if (!isRecord(value))
-        return;
-    visit(value);
-    for (const child of Object.values(value))
-        visitRecords(child, visit);
-}
-function stringValue(value) {
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
 runWhenInvokedDirectly(import.meta.url, 'compile', run);

package/dist/case/decompile.js

@@ -1,7 +1,7 @@
 import { commentText } from '../core/comment-text.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 +618,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 +639,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 +675,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 +706,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';

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/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_HYBRID_UNSUPPORTED, externalDescriptorRefusal, externalHybridRefusal, externalServiceType, isExternalExecutionMode, } from './external.js';
+import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_EVENT, externalDescriptorRefusal, externalEventRefusal, externalServiceType, isExternalExecutionMode, } 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';
@@ -1739,7 +1739,7 @@ function businessRuleTaskData(task, resolver, elementId, ids) {
  * the op's output schema. Connection/folder resolve through `bindings` and are
  * referenced as `=bindings.<id>`, with the binding entry collected at case root.
  */
-function connectorTaskData(spec, resolver, elementId, where, executionType) {
+function connectorTaskData(spec, resolver, elementId, where, executionType, event) {
     if (!resolver.library)
         throw new CompileRefusal('LIBRARY_REQUIRED', `connector task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
     const rc = resolver.library.resolve(spec.key, spec.action, spec.version, spec.object);
@@ -1787,7 +1787,7 @@ function connectorTaskData(spec, resolver, elementId, where, executionType) {
     // from the `body` slot. This used to drop the whole wire and push a filled
     // file part into the body, where the runtime does not look for it (#1420).
     const fileParts = (slots.multipartParameters ?? []).filter((part) => part.dataType.toLowerCase() === 'file');
-    context.push(io('metadata', 'json', { body: connectorMetadata(rc, op, slots, elementId, executionType) }));
+    context.push(io('metadata', 'json', { body: connectorMetadata(rc, op, slots, elementId, executionType, event) }));
     const inputs = [
         ioSlot('pathParameters', pathParameters, `${elementId}`),
         ioSlot('queryParameters', queryParameters, `${elementId}`),
@@ -1816,14 +1816,20 @@ function externalTaskData(kind, spec, resolver, elementId, where) {
         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".`);
-    if (spec.mode === 'hybrid')
-        throw new CompileRefusal(EXTERNAL_TASK_HYBRID_UNSUPPORTED, externalHybridRefusal(where));
+    const eventRefused = externalEventRefusal(where, spec.mode, spec.event);
+    if (eventRefused)
+        throw new CompileRefusal(EXTERNAL_TASK_EVENT, eventRefused);
     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);
+    const data = connectorTaskData(spec.connector, resolver, elementId, where, spec.mode, spec.event);
     const context = data.context;
     const metadataAt = context.findIndex((row) => row.name === 'metadata');
-    context.splice(metadataAt, 0, io('executionType', 'string', { value: spec.mode }));
+    // 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.push(io('activityConfigurationVersion', 'string', { value: 'v2' }));
     return { ...data, serviceType: externalServiceType(kind, spec.mode) };
 }
@@ -1957,7 +1963,7 @@ function folderBindingRef(resolver, name, connection, site) {
  * Generic activity, and the library version where the platform writes
  * `packageVersion: "1.0.0"` (#1420).
  */
-function connectorMetadata(rc, op, slots, seed, executionType) {
+function connectorMetadata(rc, op, slots, seed, executionType, event) {
     // The part DECLARATIONS only: a file part's value rides on its `file` input.
     const multipartParameters = (slots.multipartParameters ?? []).map(({ name, dataType }) => ({ name, dataType }));
     // The configuration replays the authored values (a schema action's parent
@@ -1973,6 +1979,9 @@ function connectorMetadata(rc, op, slots, seed, executionType) {
             uiPathActivityTypeId: rc.activityTypeId ?? '',
             errorState: { issues: [] },
             ...(executionType ? { executionType } : {}),
+            // The event an async / hybrid object answers with, named as the Designer
+            // names it here (`eventType`, where the context row is `operation`).
+            ...(event ? { eventType: event.operation, eventMode: event.mode } : {}),
         },
         activityMetadata: {
             activity: {

package/dist/core/bindings-v2-resource.d.ts

@@ -0,0 +1,51 @@
+/**
+ * One `bindings_v2.json` resource row, and the connection row every artifact
+ * writes.
+ *
+ * Flow (`bindings-v2.ts`) and Case (`case/bindings-v2.ts`) both declare a
+ * connector's connection in the project sidecar, and the CLI checks each
+ * against its own generator: `uip maestro flow pack` for Flow, `uip maestro
+ * case bindings sync` (`connectionEntry` in cli
+ * `packages/case-tool/src/services/case-bindings-service.ts`) for Case. Both
+ * generators write the same row — the Designer shape, `id` + flagged
+ * `ConnectionId` slot + `BindingsVersion` / `UseConnectionService` metadata.
+ * The CLI compares rows as serialized JSON, so the key order below is part of
+ * the contract.
+ *
+ * Case used to write its own older row (`connectionId` slot, a lower-case
+ * `connector` metadata key) and `validate --strict` reported it stale
+ * (builder-sdk#1382). One builder for both artifacts is what keeps the two
+ * from drifting apart again.
+ */
+/** One declared solution resource. */
+export interface BindingsV2Resource {
+    resource: string;
+    key: string;
+    id?: string;
+    value: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    [k: string]: unknown;
+}
+/** The `bindings_v2.json` document version every generator writes. */
+export declare const BINDINGS_V2_DOCUMENT_VERSION = "2.0";
+/** The per-resource `metadata.BindingsVersion` deploy needs to override an entry. */
+export declare const RESOURCE_BINDINGS_VERSION = "2.2";
+/** What one connection row is made of. Optional parts are left out of the row when absent. */
+export interface ConnectionResourceParts {
+    /** `connection` in a `.flow`, `Connection` in a caseplan: each artifact keeps its own spelling. */
+    resource: string;
+    /** The connection's resource key. */
+    key: string;
+    /** The `ConnectionId` slot's value; the key when the binding row has no default. */
+    connectionId: string;
+    /** The connection binding's name: the slot's `displayName` and `metadata.DisplayLabel`. */
+    displayLabel?: string;
+    /** The folder key slot. Case writes it; Flow's pack does not. */
+    folderKey?: string;
+    /** The label of the first step or task that uses the connection. */
+    activityName?: string;
+    /** The connector the connection belongs to. */
+    connector?: string;
+}
+/** The connection row, in the Designer shape both CLI generators derive. */
+export declare function connectionResource(parts: ConnectionResourceParts): BindingsV2Resource;

package/dist/core/bindings-v2-resource.js

@@ -0,0 +1,50 @@
+/**
+ * One `bindings_v2.json` resource row, and the connection row every artifact
+ * writes.
+ *
+ * Flow (`bindings-v2.ts`) and Case (`case/bindings-v2.ts`) both declare a
+ * connector's connection in the project sidecar, and the CLI checks each
+ * against its own generator: `uip maestro flow pack` for Flow, `uip maestro
+ * case bindings sync` (`connectionEntry` in cli
+ * `packages/case-tool/src/services/case-bindings-service.ts`) for Case. Both
+ * generators write the same row — the Designer shape, `id` + flagged
+ * `ConnectionId` slot + `BindingsVersion` / `UseConnectionService` metadata.
+ * The CLI compares rows as serialized JSON, so the key order below is part of
+ * the contract.
+ *
+ * Case used to write its own older row (`connectionId` slot, a lower-case
+ * `connector` metadata key) and `validate --strict` reported it stale
+ * (builder-sdk#1382). One builder for both artifacts is what keeps the two
+ * from drifting apart again.
+ */
+/** The `bindings_v2.json` document version every generator writes. */
+export const BINDINGS_V2_DOCUMENT_VERSION = '2.0';
+/** The per-resource `metadata.BindingsVersion` deploy needs to override an entry. */
+export const RESOURCE_BINDINGS_VERSION = '2.2';
+/** The connection row, in the Designer shape both CLI generators derive. */
+export function connectionResource(parts) {
+    const { resource, key, connectionId, displayLabel, folderKey, activityName, connector } = parts;
+    const value = {
+        ConnectionId: {
+            defaultValue: connectionId,
+            isExpression: false,
+            ...(displayLabel !== undefined && { displayName: displayLabel }),
+        },
+    };
+    if (folderKey !== undefined)
+        value.folderKey = { defaultValue: folderKey };
+    return {
+        resource,
+        key,
+        // The generators concatenate resource and key with no separator.
+        id: `${resource}${key}`,
+        value,
+        metadata: {
+            ...(activityName !== undefined && { ActivityName: activityName }),
+            BindingsVersion: RESOURCE_BINDINGS_VERSION,
+            ...(displayLabel !== undefined && { DisplayLabel: displayLabel }),
+            UseConnectionService: 'true',
+            ...(connector !== undefined && { Connector: connector }),
+        },
+    };
+}

package/dist/core/refusals.d.ts

@@ -274,8 +274,8 @@ export declare const REFUSALS: {
     readonly EXTERNAL_TASK_DESCRIPTOR: "lint";
     readonly EXTERNAL_TASK_DESCRIPTOR_CONTRACT: "lowering";
     readonly EXTERNAL_TASK_EMPTY_DATA: "lint";
+    readonly EXTERNAL_TASK_EVENT: "lowering";
     readonly EXTERNAL_TASK_FOLDER: "lowering";
-    readonly EXTERNAL_TASK_HYBRID_UNSUPPORTED: "lowering";
     readonly EXTERNAL_TASK_MODE: "lowering";
     readonly EXTRACT_SCHEMA_SHAPE: "lint";
     readonly FAKE_JOIN: "lint";

package/dist/core/refusals.js

@@ -325,8 +325,8 @@ export const REFUSALS = {
     EXTERNAL_TASK_DESCRIPTOR: 'lint',
     EXTERNAL_TASK_DESCRIPTOR_CONTRACT: 'lowering',
     EXTERNAL_TASK_EMPTY_DATA: 'lint',
+    EXTERNAL_TASK_EVENT: 'lowering',
     EXTERNAL_TASK_FOLDER: 'lowering',
-    EXTERNAL_TASK_HYBRID_UNSUPPORTED: 'lowering',
     EXTERNAL_TASK_MODE: 'lowering',
     EXTRACT_SCHEMA_SHAPE: 'lint',
     FAKE_JOIN: 'lint',