@uipath/maestro-builder-sdk 6.70.9 → 6.71.1

package/dist/serialize.js

@@ -22,9 +22,7 @@ import { endOutcomeRefusal, fanInRefusal, hitlEndHazards, hitlFanInto } from './
 import { resolveVersionCarried } from './core/nodes/versioned.js';
 import { indexCarriedDefinitions } from './core/carried-definitions.js';
 import { connectionConnectors } from './bindings-v2.js';
-import { BindingRefusal, GUID_RE, bindingLabelRefusal, bindingMissingMessage, missingBindingLabels } from './core/binding-messages.js';
-import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
-import { genericEventObjectRefusal } from './core/event-checks.js';
+import { BindingRefusal, GUID_RE, bindingLabelRefusal } from './core/binding-messages.js';
 import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitViolation } from './core/hitl-routing.js';
 import { STICKY_NOTE_TYPE, STICKY_NOTE_TYPE_VERSION } from './core/definitionless-node-types.js';
 import { placeholderPosition } from './node-placement.js';
@@ -32,7 +30,6 @@ import { hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
 import { assertNodeEnvelope } from './core/node-envelope.js';
 import { fnv1aX4Uuid, stableId } from './core/stable-id.js';
-import { EVENT_FILTER_OPERATORS, readEventFilter, eventFilterProblem, eventFilterJmes, eventFilterTreeLeaf, jmesString, jmesStringProblem } from './core/event-filters.js';
 import { FLOW_EXPR_DIALECT } from './core/connector-checks.js';
 import { connectorInputErrors as coreConnectorInputErrors } from './core/connector-inputs.js';
 /**
@@ -49,7 +46,7 @@ export function connectorInputErrors(rc, inputs, resolutions = {}, lookups = {})
         render: (value) => renderDeep(value, NO_RENAME),
     });
 }
-import { isLookupToken, resolveEventWhere, } from './core/lookups.js';
+import { isLookupToken, } from './core/lookups.js';
 import { migrateToSchemaVersion } from './migrate.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { resolveSchemaVersion } from './schema-version.js';
@@ -64,6 +61,7 @@ import { SUBFLOW_START_LABEL } from './core/subflow-start.js';
 import { endContentKey } from './flow-end-content.js';
 import { terminateStepClashMessage, terminateTwiceMessage } from './flow-terminate-names.js';
 import { jsonClone } from './core/json-clone.js';
+import { eventDetail, eventTarget, libraryRequiredForEvent, refuseUnverifiedByoa, resolveEvent, } from './core/event-subscription.js';
 import { subNodeId } from './core/node-id-placeholder.js';
 import { JOB_ATTACHMENT_REF, jobAttachmentDefinition } from './core/agent-sidecar.js';
 // core-definitions.json is an object keyed by "<nodeType>@<version>".
@@ -510,44 +508,6 @@ function connectionStubReason(value) {
         return 'not a GUID';
     return undefined;
 }
-/** What `registry prepare` takes for an event subscription: its connector key and curated event name. */
-function eventTarget(sub) {
-    return typeof sub.connector === 'string' && sub.connector !== ''
-        ? { key: sub.connector, ...(typeof sub.event === 'string' && sub.event !== '' ? { action: sub.event } : {}) }
-        : undefined;
-}
-/**
- * Throw `check`'s EVENT_BYOA_UNVERIFIED for a subscription whose event only
- * fires on a BYOA connection and whose bound connection `prepare` never checked
- * — the one condition in `core/byoa.ts`, fed from the same library and
- * bindings, so a flow check refuses never compiles.
- *
- * `where` is check's spelling of the site (`trigger` for `onEvent`, entry points
- * included; `waitForEvent "<step>"`), so the two print the same sentence.
- */
-function refuseUnverifiedByoa(opts, where, sub) {
-    const library = opts.library;
-    if (!library || typeof library.eventFacts !== 'function')
-        return;
-    const object = typeof sub.object === 'string' && sub.object !== '' ? sub.object : undefined;
-    const message = byoaUnverified(where, { connector: sub.connector, event: sub.event, ...(object ? { object } : {}), connection: sub.connection }, library.eventFacts(sub.connector, sub.event, object), library.byoaVerifications, opts.bindings);
-    if (message)
-        throw new ByoaRefusal(message);
-}
-/**
- * Refuse a connector-bound node (connector step, event trigger, `.entryPoint`
- * onEvent, `waitForEvent`) that names no `connection` or no `folder` label.
- * (An inline agent's connector tool is #875's: `check` refuses it as
- * INLINE_AGENT_TOOL_CONNECTOR_NO_CONNECTION, and serialize leaves it unbound.)
- * `resolveBinding` returns `undefined` for an absent label, which used to reach
- * the node as `detail.connectionId: null` with no binding — valid to compile,
- * refused by `flow validate` (flow-builder-sdk#890): BINDING_MISSING.
- */
-function requireBindingPair(where, labels, target) {
-    const missing = missingBindingLabels(labels);
-    if (missing.length > 0)
-        throw new BindingRefusal('BINDING_MISSING', bindingMissingMessage(where, missing, target));
-}
 /**
  * Resolve a symbolic connection/folder name to the resource key that is inlined
  * as `connectionId` / `connectionFolderKey`.
@@ -627,6 +587,14 @@ function resolveBinding(opts, name, attribute, where, target) {
     }
     return value;
 }
+/** What the shared event-subscription emission (`core/event-subscription.ts`) needs from these options. */
+function eventEnv(opts) {
+    return {
+        ...(opts.library !== undefined ? { library: opts.library } : {}),
+        ...(opts.bindings !== undefined ? { bindings: opts.bindings } : {}),
+        resolveBinding: (name, attribute, where, target) => resolveBinding(opts, name, attribute, where, target),
+    };
+}
 /** An entry answers to `name` but carries no resourceKey or default — the placeholder route, still a warning. */
 function declaredWithoutKey(bindings, name) {
     return (bindings?.declared?.() ?? []).includes(name) || bindings?.entry?.(name) !== undefined;
@@ -717,51 +685,6 @@ export function resolveContributionDefinition(ref, requestedVersion, where) {
     }
     throw new CompileRefusal('CONTRIBUTION_INVALID', `${where}: unknown DefinitionReference source "${ref.source}".`);
 }
-/**
- * `library.resolveEvent` for one subscription, or EVENT_UNKNOWN: whatever it
- * throws (a connector or event the library does not carry, a version or object
- * it does not resolve) is that one condition, an event compile cannot place.
- * `where` names the site as `check` always has (`trigger`, `waitForEvent "x"`).
- */
-function resolveEvent(library, kind, sub, where) {
-    try {
-        return library.resolveEvent(kind, sub.connector, sub.event, sub.version, sub.object);
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith('internal SDK error:'))
-            throw error;
-        throw new CompileRefusal('EVENT_UNKNOWN', `${where}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * LIBRARY_REQUIRED for an event subscription at `site`, after the refusals that
- * need no library: its binding labels, judged as `eventDetail` judges them, so a
- * run without a library (`check`'s inner loop) still hears about them. The
- * refusal carries the connection the node is bound to, so its collect-mode
- * stand-in still takes part in the file-wide connection rule (`connectionConnectors`).
- */
-function libraryRequiredForEvent(opts, sub, nodeId, site, call) {
-    let use;
-    if (sub !== null && typeof sub === 'object') {
-        // With no library no parameter is declared, so every `where` key lands in
-        // eventParameters and folds into the match expression, exactly as
-        // `eventDetail` places an undeclared key. A lookup token is a value only
-        // a library resolves; it is not judged here.
-        if (sub.where !== null && typeof sub.where === 'object') {
-            const scope = Object.fromEntries(Object.entries(sub.where).filter(([, v]) => !isLookupToken(v)));
-            eventScopeClauses(flattenWhere(scope, new Set()), nodeId);
-        }
-        if (Array.isArray(sub.filters))
-            eventFilterReads(sub.filters, nodeId);
-        requireBindingPair(site, sub, eventTarget(sub));
-        const connection = resolveBinding(opts, sub.connection, 'connection', `event node "${nodeId}"`, eventTarget(sub));
-        resolveBinding(opts, sub.folder, 'folder', `event node "${nodeId}"`, eventTarget(sub));
-        const connector = eventTarget(sub)?.key;
-        if (connection !== undefined && connector !== undefined)
-            use = { connector, connection };
-    }
-    return new LibraryRequiredRefusal(`${call} needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`, use);
-}
 /** The trigger kinds a `.trigger()` or `.entryPoint()` spec may carry. */
 const TRIGGER_KINDS = new Set(['manual', 'scheduled', 'event', 'form', 'conversation', 'voice']);
 /**
@@ -856,272 +779,6 @@ function renderMap(m, rename = NO_RENAME) {
  * `contains` is the only operator the deployed corpus uses, and it maps to the
  * designer's `Contains`.
  */
-/**
- * Flatten a nested `where` onto the DOTTED parameter names the wire uses.
- *
- * The generated `…Where` interface splits a dotted event parameter into an
- * object — `channelData.channel.id` becomes
- * `channelData: ConnectorValue<ChannelDataInput>` — so an author following the
- * types writes the nested shape, while `bucketOf` and the `filterExpression`
- * clause both key on the declared dotted name. Without this the nested shape
- * missed the bucket lookup and then stringified, emitting
- * `channelData == '[object Object]'`: a subscription matching nothing, from a
- * document that compiled clean and passed `check`.
- *
- * Descent STOPS as soon as a path names a declared parameter, so a parameter
- * that genuinely takes an object value is passed through whole rather than
- * shredded. A lookup token is a value, never a branch.
- */
-function flattenWhere(where, declared) {
-    const out = {};
-    const walk = (value, path) => {
-        if (path && declared.has(path)) {
-            out[path] = value;
-            return;
-        }
-        const plain = typeof value === 'object' && value !== null && !Array.isArray(value)
-            && !isLookupToken(value)
-            && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
-        if (plain) {
-            for (const [k, v] of Object.entries(value))
-                walk(v, path ? `${path}.${k}` : k);
-            return;
-        }
-        if (path)
-            out[path] = value;
-    };
-    walk(where, '');
-    return out;
-}
-/**
- * A subscription's `filters`, each leaf read structurally (`readEventFilter`),
- * or the refusal of the first leaf compile cannot lower: no field, no operator
- * or two, a value no operator takes, a backslash JMESPath engines read apart.
- * Needs no library, so a run without one judges the leaves too
- * (`libraryRequiredForEvent`).
- */
-function eventFilterReads(filters, nodeId) {
-    const operators = Object.keys(EVENT_FILTER_OPERATORS).join(', ');
-    const at = `event node "${nodeId}": filters`;
-    return filters.map((f, i) => {
-        const { keys, read } = readEventFilter(f);
-        const field = f?.field;
-        if (typeof field !== 'string' || field === '') {
-            throw new CompileRefusal('EVENT_FILTER_NO_FIELD', `${at}[${i}] has no \`field\` — name a field on the event payload, e.g. 'subject'.`);
-        }
-        if (keys.length === 0) {
-            throw new CompileRefusal('EVENT_FILTER_NO_VALUE', `${at}[${i}] has no operator. Write exactly one of ${operators} with its value — `
-                + `\`contains\` is a case-sensitive substring test, the same one Integration Service applies `
-                + `server-side; \`lessThan\`/\`greaterThan\` order a number or an ISO date.`, `{ field: '${field}', contains: '<text>' }`);
-        }
-        if (keys.length > 1) {
-            throw new CompileRefusal('EVENT_FILTER_MANY_OPERATORS', `${at}[${i}] carries ${keys.length} operators (${keys.join(', ')}); a condition has exactly `
-                + `one. Write two conditions instead — they are ANDed.`);
-        }
-        if (!read) {
-            throw new CompileRefusal('EVENT_FILTER_NO_VALUE', `${at}[${i}] gives \`${keys[0]}\` a value that is not a string, number or boolean.`);
-        }
-        // An ambiguous backslash first: `eventFilterProblem` would report it too.
-        const problem = eventFilterProblem(read);
-        const backslash = typeof read.value === 'string' && jmesStringProblem(read.value) !== undefined;
-        if (problem) {
-            throw new CompileRefusal(backslash ? 'EVENT_FILTER_BACKSLASH' : 'EVENT_FILTER_BAD_VALUE', `${at}[${i}] on \`${read.field}\`: ${problem}`);
-        }
-        return read;
-    });
-}
-/**
- * The match-expression clauses of a subscription's EVENT parameters, one
- * `k == '<value>'` per value, or the refusal of the first value compile cannot
- * write there. The clause compares against a JMESPath string, so the value must
- * be a string, number or boolean: an object or array would be stringified to
- * `'[object Object]'` (or a comma list), a subscription that matches nothing
- * (EVENT_WHERE_NOT_SCALAR). A string with a backslash JMESPath engines read
- * apart is EVENT_FILTER_BACKSLASH. An absent or empty value (`''` or `[]`, so a
- * `where` built from a possibly-empty list) writes no clause.
- *
- * Only event parameters fold into the expression; a query or path parameter is
- * sent with the request that registers the subscription and is never read as
- * JMESPath, so neither rule applies to it.
- */
-function eventScopeClauses(eventParameters, nodeId) {
-    return Object.entries(eventParameters)
-        .filter(([, v]) => v !== undefined && v !== null && v !== '' && !(Array.isArray(v) && v.length === 0))
-        .map(([k, v]) => {
-        if (typeof v !== 'string' && typeof v !== 'number' && typeof v !== 'boolean') {
-            throw new CompileRefusal('EVENT_WHERE_NOT_SCALAR', `event node "${nodeId}": \`where.${k}\` is ${Array.isArray(v) ? 'an array' : isLookupToken(v) ? 'an unresolved lookup() nested inside an object' : 'an object'}, `
-                + `and an event parameter is matched as one text value (\`${k} == '<value>'\`): written as it is, `
-                + `the subscription would compare against ${JSON.stringify(String(v))} and match nothing. `
-                + `Give \`${k}\` a string, number or boolean.`, `where: { '${k}': '<value>' }`);
-        }
-        const problem = jmesStringProblem(String(v));
-        if (problem)
-            throw new CompileRefusal('EVENT_FILTER_BACKSLASH', `event node "${nodeId}": \`where.${k}\`: ${problem}`);
-        return `${k} == ${jmesString(String(v))}`;
-    });
-}
-function eventDetail(rc, sub, nodeId, opts, site) {
-    requireBindingPair(site, sub, eventTarget(sub));
-    const conn = resolveBinding(opts, sub.connection, 'connection', `event node "${nodeId}"`, eventTarget(sub));
-    const folder = resolveBinding(opts, sub.folder, 'folder', `event node "${nodeId}"`, eventTarget(sub));
-    const op = (rc.entry?.operation ?? {});
-    const filters = sub.filters ?? [];
-    // A GENERIC event with no `object` would carry `objectName: ""`: it validates
-    // and the platform's dispatcher refuses it. Refused here, at the layer that
-    // would otherwise emit it, with the text every family's compile shares.
-    const objectName = String(op.objectName ?? '');
-    const noObject = genericEventObjectRefusal(rc, sub, (o) => `onEvent(…, { object: '${o}' })`);
-    if (noObject) {
-        // The object an author put in `where` by mistake is the value to move.
-        const scopeObject = sub.where && typeof sub.where === 'object'
-            ? Object.entries(sub.where).find(([k]) => /^(objectName|entityName|object)$/i.test(k))?.[1]
-            : undefined;
-        throw new CompileRefusal('EVENT_GENERIC_NO_OBJECT', `event node "${nodeId}": ${noObject}`, `object: '${scopeObject !== undefined ? String(scopeObject) : '<Object>'}'`);
-    }
-    // An unresolved `where` lookup is swapped for its recorded id — the id
-    // `prepare --resolve` stored under the EVENT-form node type — or refused.
-    // Same rule as connector inputs: emitting a placeholder for a value nobody
-    // resolved would subscribe the trigger to the wrong folder/channel/queue.
-    const where = resolveEventWhere(sub.where, opts.library?.lookupResolutions ?? {}, `event node "${nodeId}"`);
-    // A subscription's parameters do not all travel in the same slot. The
-    // connector declares which, and the library bakes it per field as `bucket`:
-    // measured against designer-authored triggers, Jira's `project`/`issuetype`
-    // and GitHub's `repo` land in `queryParameters`, Asana's `projectId` in
-    // `pathParameters` and its `workspaceId` in `queryParameters`, while
-    // Outlook's `parentFolderId` — which the connector declares through the
-    // field's own `events.<OPERATION>` map rather than as a typed request
-    // parameter — lands in `eventParameters`. Emitting all of them as event
-    // parameters puts three of those four in a slot the runtime does not read.
-    const bucketOf = new Map();
-    const declaredOrder = [];
-    for (const f of (rc.v1def
-        ?.eventParameters?.fields ?? [])) {
-        if (typeof f?.name !== 'string')
-            continue;
-        declaredOrder.push(f.name);
-        if (typeof f?.bucket === 'string')
-            bucketOf.set(f.name, f.bucket);
-    }
-    const eventParameters = {};
-    const queryParameters = {};
-    const pathParameters = {};
-    // FLATTENED first: everything below keys on the DECLARED name, which is dotted
-    // (`channelData.channel.id`), while the generated `…Where` interface splits
-    // that into an object — so an author following the types writes the nested
-    // shape. Un-flattened it missed `bucketOf` (landing in the wrong slot) and
-    // then stringified into the match expression as
-    // `channelData == '[object Object]'`: a subscription that matches nothing,
-    // compiled clean and passed `check`.
-    for (const [k, v] of Object.entries(flattenWhere(where, new Set(declaredOrder)))) {
-        const slot = bucketOf.get(k);
-        (slot === 'query' ? queryParameters : slot === 'path' ? pathParameters : eventParameters)[k] = v;
-    }
-    // Only EVENT parameters fold into the match expression. They are the
-    // subscription's own scope — the mandatory clause the platform AND-joins —
-    // whereas a query or path parameter is part of the request that registers
-    // the subscription, not a property of the events it matches.
-    const scopeClauses = eventScopeClauses(eventParameters, nodeId);
-    // Each authored filter is read structurally (which operator, which value) and
-    // lowered with the designer's own grammar — see `event-filters.ts` for the
-    // measured table.
-    const conditions = eventFilterReads(filters, nodeId);
-    const filterClauses = conditions.map((c) => `(${eventFilterJmes(c)})`);
-    const filterExpression = [
-        ...scopeClauses,
-        ...(filterClauses.length > 0 ? [`(${filterClauses.join('&&')})`] : []),
-    ].join(' && ');
-    const instanceParameters = {
-        connectorKey: rc.connectorKey,
-        objectName,
-        activityType: op.activityType,
-        version: rc.version,
-        eventOperation: op.eventOperation,
-        eventMode: op.eventMode,
-        supportsStreaming: op.supportsStreaming ?? false,
-    };
-    const tree = conditions.length === 0 ? null : {
-        groupOperator: 0,
-        index: 0,
-        filters: conditions.map((c, i) => ({
-            ...eventFilterTreeLeaf(c),
-            // Deterministic, so recompiling the same flow is byte-identical (the
-            // designer mints random uuids here; a random one would churn every build).
-            uiId: stableId(`${nodeId}:${c.field}:${String(c.value)}:${i}`),
-        })),
-        groups: [],
-        uuId: stableId(`${nodeId}:filters`),
-    };
-    // The node's own Property binding: how the platform registers the
-    // subscription, and where `flow debug` reads its query parameters from.
-    // Pinned to designer-authored artifacts — the START form carries every
-    // subscription parameter as `{defaultValue, isExpression}` whatever its
-    // bucket (Jira `project,issuetype`; Asana `workspaceId,projectId`; Outlook
-    // `parentFolderId`), while the mid-flow WAIT form carries an EMPTY value and
-    // empty parameter lists: it joins a subscription the trigger registers,
-    // rather than registering one of its own.
-    const isStartForm = rc.nodeType.includes('.connector.trigger.');
-    const allParameters = {
-        ...eventParameters, ...queryParameters, ...pathParameters,
-    };
-    // Declared order, not the order the author happened to write `where` in, so
-    // the same subscription always emits the same bytes.
-    const orderedNames = [
-        ...declaredOrder.filter((n) => n in allParameters),
-        ...Object.keys(allParameters).filter((n) => !declaredOrder.includes(n)),
-    ];
-    const subscriptionValue = {};
-    if (isStartForm) {
-        for (const name of orderedNames) {
-            subscriptionValue[name] = { defaultValue: allParameters[name], isExpression: false };
-        }
-    }
-    const parameterList = isStartForm ? orderedNames.join(',') : '';
-    const propertyBinding = {
-        resource: 'Property',
-        key: op.eventOperation ?? '',
-        value: subscriptionValue,
-        activityDisplayName: 'connector-activity',
-        metadata: {
-            ActivityName: 'connector-activity',
-            BindingsVersion: '2.2',
-            ObjectName: objectName,
-            // The trigger resource is keyed by the CONNECTION the subscription is
-            // registered against, so two connections keep two trigger resources.
-            ...(conn ? { ParentResourceKey: `EventTrigger.${conn}` } : {}),
-            TriggerCreateParameters: parameterList,
-            DebugQueryParameters: parameterList,
-        },
-    };
-    return {
-        connector: rc.connectorKey,
-        ...(conn ? { connectionId: conn, connectionResourceId: conn } : {}),
-        ...(folder ? { connectionFolderKey: folder } : {}),
-        eventParameters,
-        // Emitted only when populated, mirroring the connector-activity slots:
-        // no archived artifact carries an empty one.
-        ...(Object.keys(queryParameters).length ? { queryParameters } : {}),
-        ...(Object.keys(pathParameters).length ? { pathParameters } : {}),
-        objectName,
-        eventType: op.eventOperation,
-        eventMode: op.eventMode,
-        filterExpression,
-        configuration: '=jsonString:' + JSON.stringify({
-            essentialConfiguration: {
-                instanceParameters,
-                objectName,
-                packageVersion: rc.version,
-                connectorVersion: null,
-                executionType: null,
-                httpMethod: null,
-                path: null,
-                filter: tree,
-            },
-        }),
-        ...(rc.activityTypeId ? { uiPathActivityTypeId: rc.activityTypeId } : {}),
-        bindings: [propertyBinding],
-        errorState: { issues: [] },
-    };
-}
 /**
  * Recursively render Exprs nested inside objects/arrays (for connector inputs).
  *
@@ -2458,9 +2115,9 @@ function serializeFlow(built, opts) {
             ? (() => {
                 const sub = built.trigger.subscription;
                 if (!opts.library)
-                    throw libraryRequiredForEvent(opts, sub, built.triggerId ?? 'start', 'event trigger', 'onEvent()');
+                    throw libraryRequiredForEvent(eventEnv(opts), sub, built.triggerId ?? 'start', 'event trigger', 'onEvent()');
                 const rc = resolveEvent(opts.library, 'trigger', sub, 'trigger');
-                refuseUnverifiedByoa(opts, 'trigger', sub);
+                refuseUnverifiedByoa(eventEnv(opts), 'trigger', sub);
                 return rc;
             })()
             : undefined;
@@ -2513,7 +2170,7 @@ function serializeFlow(built, opts) {
                     // `detail` (see eventDetail).
                     entryPointId: stableId(`${built.id}:start:entryPoint`),
                     isDefaultEntryPoint: true,
-                    detail: eventDetail(eventTriggerRc, built.trigger.subscription, triggerId, opts, 'event trigger'),
+                    detail: eventDetail(eventTriggerRc, built.trigger.subscription, triggerId, eventEnv(opts), 'event trigger'),
                 }
                 : built.trigger?.kind === 'scheduled'
                     ? scheduleInputs(built.trigger.inputs, triggerId)
@@ -2814,6 +2471,7 @@ function serializeFlow(built, opts) {
             resourceNodeId: (explicit, seed, at) => resourceNodeId(scope, explicit, seed, at),
             emitted: (typeName, v) => emittedDefs.get(`${typeName}@${v}`),
             library: opts.library,
+            events: eventEnv(opts),
             // Rendered once: placement renders the contribution's inputs again, so the
             // result is marked as the file's, as `render` marks a `lit`'s copy. A copy,
             // so an author object the walk returned as is (a `lit`'s own) stays unmarked
@@ -3150,7 +2808,8 @@ function serializeFlow(built, opts) {
                 return def === undefined ? undefined : { port: definitionHasErrorPort(def), typeName: def.nodeType, version: def.version };
             }
             const port = typeof impl.errorPort === 'function' ? impl.errorPort(spec, undefined) : impl.errorPort === true;
-            return { port, typeName: impl.typeName, version: resolved.version };
+            const named = impl.namedNode?.(spec);
+            return { port, typeName: named?.typeName ?? impl.typeName, version: step.options?.version ?? named?.version ?? resolved.version };
         }
         catch (error) {
             if (error instanceof CompileRefusal)
@@ -3193,36 +2852,6 @@ function serializeFlow(built, opts) {
             subflows[id] = emitSubflowBody(spec.child, id, step.name);
             return [{ node: id, port: successPort(NODE_TYPE.subflow) }];
         }
-        if (spec.kind === 'waitEvent') {
-            const sub = spec.subscription;
-            // An event wait resumes or it does not: it has no error port to route.
-            // Recorded before anything can refuse the step, so a stand-in keeps it.
-            declaredErrorPorts.set(scope.pending.get(step.name) ?? step.name, {
-                port: false, typeName: `uipath.connector.event.${sub?.connector}.${sub?.event}`, version: step.options?.version ?? sub?.version ?? '1.0.0',
-            });
-            if (!opts.library) {
-                throw libraryRequiredForEvent(opts, sub, scope.pending.get(step.name) ?? step.name, `waitForEvent "${step.name}"`, `waitForEvent "${step.name}"`);
-            }
-            const rc = resolveEvent(opts.library, 'event', sub, `waitForEvent "${step.name}"`);
-            refuseUnverifiedByoa(opts, `waitForEvent "${step.name}"`, sub);
-            const id = stepUid(scope, step.name);
-            const node = makeNode(rc.nodeType, id, step.name, { parentId, requestedVersion: step.options?.version, def: rc.v1def });
-            declaredErrorPorts.set(id, { port: false, typeName: rc.nodeType, version: String(rc.v1def?.version ?? node.typeVersion) });
-            node.inputs = { detail: eventDetail(rc, sub, id, opts, `waitForEvent "${step.name}"`) };
-            // Same connection-binding closure as the connector branch (G-19).
-            const { entries: waitConnBindings } = connectionResourceBindings({
-                def: rc.v1def,
-                connectorKey: rc.connectorKey,
-                connectionId: resolveBinding(opts, sub.connection, 'connection', `waitForEvent "${step.name}"`, eventTarget(sub)),
-                folderKey: resolveBinding(opts, sub.folder, 'folder', `waitForEvent "${step.name}"`, eventTarget(sub)),
-            }, resourceBindings);
-            for (const b of waitConnBindings)
-                resourceBindings.set(b.id, b);
-            scope.nodes.push(node);
-            for (const t of tails)
-                addEdge(scope, t, id);
-            return [{ node: id, port: successPort(rc.nodeType) }];
-        }
         // A custom FlowAction subclass carries no `kind`; it compiles through its
         // own contribution (design §4). Anything else without a recognized kind is
         // an authoring error — it must NOT fall through into the script branch
@@ -3963,13 +3592,13 @@ function serializeFlow(built, opts) {
                 else if (epSpec.kind === 'event') {
                     const sub = epSpec.subscription;
                     if (!opts.library)
-                        throw libraryRequiredForEvent(opts, sub, ep.id, `onEvent() entry point "${ep.id}"`, 'onEvent()');
+                        throw libraryRequiredForEvent(eventEnv(opts), sub, ep.id, `onEvent() entry point "${ep.id}"`, 'onEvent()');
                     const rc = resolveEvent(opts.library, 'trigger', sub, 'trigger');
-                    refuseUnverifiedByoa(opts, 'trigger', sub);
+                    refuseUnverifiedByoa(eventEnv(opts), 'trigger', sub);
                     node = makeNode(rc.nodeType, ep.id, epLabel, { def: rc.v1def, requestedVersion });
                     node.inputs = {
                         entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),
-                        detail: eventDetail(rc, sub, ep.id, opts, `onEvent() entry point "${ep.id}"`),
+                        detail: eventDetail(rc, sub, ep.id, eventEnv(opts), `onEvent() entry point "${ep.id}"`),
                     };
                     const { entries } = connectionResourceBindings({
                         def: rc.v1def,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.70.9",
+  "version": "6.71.1",
   "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": "89c9c37af44dc7763bc2334209b79935aff68e7a"
+  "gitref": "7cd35a2caf9c3ca33c5f5f8c0caae6577d6dc77d"
 }