@uipath/maestro-builder-sdk 6.70.9 → 6.71.0

package/dist/check.js

@@ -571,17 +571,6 @@ function checkFlow(built, ancestors, opts = {}) {
                         outputReaders.set(stepName, (field, rest, at, d) => rule(stepName, field, rest, inputs, at, d));
                     }
                 }
-                if (s.spec.kind === 'waitEvent') {
-                    const stepName = s.name;
-                    const push = (level) => (code, message, suggestion) => diags.push({
-                        level, code, message, step: stepName,
-                        ...(suggestion ? { suggestion } : {}),
-                    });
-                    // What compile refuses (the event itself, its filters, its binding
-                    // labels) is the serializer's, reported from its run.
-                    checkEventSubscription(s.spec.subscription, `waitForEvent "${stepName}"`, push('error'), push('warning'), eventParamsFor(s.spec.subscription, opts), false);
-                    checkEventResolution(s.spec.subscription, `waitForEvent "${stepName}"`, 'event', opts, push('error'), push('warning'), eventParamsFor(s.spec.subscription, opts), false);
-                }
                 if (s.spec.kind === 'subflow') {
                     // Only a real child goes in the map: a missing one is reported by
                     // checkSubflow, and recursing into `undefined` would crash the check
@@ -2419,6 +2408,17 @@ function checkRegisteredStep(entry, s, exprs, errorSource, opts, diags, typeOf,
             options: opts,
             bindingLabels: (where, labels, _use, target) => checkBindingLabels(where, labels, opts, (code, message) => diags.push({ level: 'error', code, step: s.name, message }), target),
             resources: { derivedNodeId: () => { }, claimNodeId: () => undefined, claimFolder: () => undefined },
+            eventSubscription: (subscription, where) => {
+                const push = (level) => (code, message, suggestion) => diags.push({
+                    level, code, message, step: s.name,
+                    ...(suggestion ? { suggestion } : {}),
+                });
+                // What compile refuses (the event itself, its filters, its binding
+                // labels) is the serializer's, reported from its run.
+                const params = eventParamsFor(subscription, opts);
+                checkEventSubscription(subscription, where, push('error'), push('warning'), params, false);
+                checkEventResolution(subscription, where, 'event', opts, push('error'), push('warning'), params, false);
+            },
             // The operation, its field contract and its binding labels are the
             // serializer's (CONNECTOR_*, BINDING_*), reported from its run.
             connector: (c) => {

package/dist/core/event-subscription.d.ts

@@ -0,0 +1,113 @@
+/**
+ * An Integration Service event subscription as Flow emits it — the node body an
+ * event trigger (`onEvent`, `.entryPoint()`), and a mid-flow wait
+ * (`waitForEvent`), share: `inputs.detail`, the library's resolution of the
+ * event, and the refusals compile makes before and without a library.
+ *
+ * Moved from serialize.ts in Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md,
+ * so the connector family's event wait and the triggers that serialize still
+ * places read one copy. What serialize held in `SerializeOpts` comes in as an
+ * {@link EventEmitEnv}: the library, the bindings, and how a binding label
+ * resolves.
+ */
+import type { EventSubscription } from './actions.js';
+import { type BindingsView, type PrepareTarget } from './binding-messages.js';
+import { CompileRefusal } from './compile-refusal.js';
+import { readEventFilter } from './event-filters.js';
+import type { Library, ResolvedConnector } from './library.js';
+/** What an event subscription's emission needs from the compile: the library, the bindings, and how a label resolves. */
+export interface EventEmitEnv {
+    readonly library?: Library;
+    readonly bindings?: BindingsView;
+    /** A connection or folder label to the key the node carries, with compile's refusals and warnings. */
+    resolveBinding(name: string | undefined, attribute: 'connection' | 'folder', where: string, target?: PrepareTarget): string | undefined;
+}
+/** What `registry prepare` takes for an event subscription: its connector key and curated event name. */
+export declare function eventTarget(sub: {
+    connector?: unknown;
+    event?: unknown;
+}): PrepareTarget | 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.
+ */
+export declare function refuseUnverifiedByoa(env: EventEmitEnv, where: string, sub: {
+    connector: string;
+    event: string;
+    object?: string;
+    connection?: unknown;
+}): void;
+/**
+ * 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.
+ */
+export declare function requireBindingPair(where: string, labels: {
+    connection?: unknown;
+    folder?: unknown;
+}, target?: PrepareTarget): void;
+/**
+ * `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"`).
+ */
+export declare function resolveEvent(library: Library, kind: 'trigger' | 'event', sub: EventSubscription, where: string): ReturnType<Library['resolveEvent']>;
+/**
+ * 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`).
+ */
+export declare function libraryRequiredForEvent(env: EventEmitEnv, sub: EventSubscription, nodeId: string, site: string, call: string): CompileRefusal;
+/**
+ * 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.
+ */
+export declare function flattenWhere(where: Record<string, unknown>, declared: ReadonlySet<string>): Record<string, unknown>;
+/**
+ * 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`).
+ */
+export declare function eventFilterReads(filters: readonly unknown[], nodeId: string): Array<NonNullable<ReturnType<typeof readEventFilter>['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.
+ */
+export declare function eventScopeClauses(eventParameters: Record<string, unknown>, nodeId: string): string[];
+export declare function eventDetail(rc: ResolvedConnector, sub: EventSubscription, nodeId: string, env: EventEmitEnv, site: string): Record<string, unknown>;

package/dist/core/event-subscription.js

@@ -0,0 +1,356 @@
+import { BindingRefusal, bindingMissingMessage, missingBindingLabels } from './binding-messages.js';
+import { ByoaRefusal, byoaUnverified } from './byoa.js';
+import { CompileRefusal, LibraryRequiredRefusal } from './compile-refusal.js';
+import { genericEventObjectRefusal } from './event-checks.js';
+import { EVENT_FILTER_OPERATORS, eventFilterJmes, eventFilterProblem, eventFilterTreeLeaf, jmesString, jmesStringProblem, readEventFilter, } from './event-filters.js';
+import { isLookupToken, resolveEventWhere } from './lookups.js';
+import { stableId } from './stable-id.js';
+/** What `registry prepare` takes for an event subscription: its connector key and curated event name. */
+export 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.
+ */
+export function refuseUnverifiedByoa(env, where, sub) {
+    const library = env.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, env.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.
+ */
+export function requireBindingPair(where, labels, target) {
+    const missing = missingBindingLabels(labels);
+    if (missing.length > 0)
+        throw new BindingRefusal('BINDING_MISSING', bindingMissingMessage(where, missing, target));
+}
+/**
+ * `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"`).
+ */
+export 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`).
+ */
+export function libraryRequiredForEvent(env, 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 = env.resolveBinding(sub.connection, 'connection', `event node "${nodeId}"`, eventTarget(sub));
+        env.resolveBinding(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);
+}
+/**
+ * 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.
+ */
+export 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`).
+ */
+export 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.
+ */
+export 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))}`;
+    });
+}
+export function eventDetail(rc, sub, nodeId, env, site) {
+    requireBindingPair(site, sub, eventTarget(sub));
+    const conn = env.resolveBinding(sub.connection, 'connection', `event node "${nodeId}"`, eventTarget(sub));
+    const folder = env.resolveBinding(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, env.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: [] },
+    };
+}

package/dist/core/nodes/registry.d.ts

@@ -67,7 +67,9 @@ export declare class NodeTypeRegistry<Ctx extends ArtifactContexts> {
      * whose `typeNamePrefix` it starts with (and whose `typeNameMatches`, if any,
      * accepts it) — or undefined when no type owns it.
      * The bare prefix counts: it is what an empty `key` builds, and the old lift
-     * read it as its factory, so it still does.
+     * read it as its factory, so it still does. Two prefix types that would both
+     * own a name (a nested prefix the outer narrowing failed to leave alone) are
+     * an SDK bug, and throw.
      */
     byTypeName(typeName: string): Registered<Ctx> | undefined;
     /** Every registered kind, sorted. */

package/dist/core/nodes/registry.js

@@ -5,6 +5,18 @@ import { CompileRefusal } from '../compile-refusal.js';
 function owns(p, typeName) {
     return typeName.startsWith(p.prefix) && (p.matches?.(typeName) ?? true);
 }
+/**
+ * Whether one prefix sits strictly inside the other and the outer one is
+ * narrowed to leave it alone: the connector operations' `uipath.connector.`
+ * holds the event wait's `uipath.connector.event.`, and the operations'
+ * `typeNameMatches` rejects every event name. A name under the inner prefix is
+ * the probe; `byTypeName` still refuses a name two prefixes would both own.
+ */
+function nests(a, b) {
+    const [outer, inner] = a.prefix.length < b.prefix.length ? [a, b] : [b, a];
+    return inner.prefix !== outer.prefix && inner.prefix.startsWith(outer.prefix)
+        && outer.matches !== undefined && !outer.matches(`${inner.prefix}probe.probe`);
+}
 export class NodeTypeRegistry {
     artifact;
     #builtIn;
@@ -84,7 +96,8 @@ export class NodeTypeRegistry {
                     if (type.typeName !== `${prefix}*`) {
                         problems.push(`${where}: a type that owns the names under "${prefix}" is named "${prefix}*", not "${type.typeName}"`);
                     }
-                    const overlap = index.byPrefix.find((p) => p.prefix.startsWith(prefix) || prefix.startsWith(p.prefix));
+                    const self = { prefix, ...(type.typeNameMatches ? { matches: type.typeNameMatches.bind(type) } : {}) };
+                    const overlap = index.byPrefix.find((p) => (p.prefix.startsWith(prefix) || prefix.startsWith(p.prefix)) && !nests(self, p));
                     if (overlap)
                         problems.push(`${where}: prefix "${prefix}" overlaps "${overlap.prefix}" (${placeOf(overlap.entry)})`);
                     const shadowed = [...index.byTypeName.keys()].find((n) => n.startsWith(prefix) && (type.typeNameMatches?.(n) ?? true));
@@ -156,13 +169,19 @@ export class NodeTypeRegistry {
      * whose `typeNamePrefix` it starts with (and whose `typeNameMatches`, if any,
      * accepts it) — or undefined when no type owns it.
      * The bare prefix counts: it is what an empty `key` builds, and the old lift
-     * read it as its factory, so it still does.
+     * read it as its factory, so it still does. Two prefix types that would both
+     * own a name (a nested prefix the outer narrowing failed to leave alone) are
+     * an SDK bug, and throw.
      */
     byTypeName(typeName) {
         const exact = this.#index.byTypeName.get(typeName);
         if (exact)
             return exact;
-        return this.#index.byPrefix.find((p) => owns(p, typeName))?.entry;
+        const owners = this.#index.byPrefix.filter((p) => owns(p, typeName));
+        if (owners.length > 1) {
+            throw new Error(`internal SDK error: the node type name "${typeName}" is owned by ${owners.map((o) => placeOf(o.entry)).join(' and ')}; exactly one may.`);
+        }
+        return owners[0]?.entry;
     }
     /** Every registered kind, sorted. */
     kinds() {

package/dist/decompile.js

@@ -912,13 +912,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
         return lifted;
     switch (node.type) {
         default:
-            // A mid-flow connector EVENT wait (`uipath.connector.event.<key>.<event>`
-            // placed as a step rather than as the start node).
-            if (node.type.startsWith('uipath.connector.event.')) {
-                const sub = emitEventSubscription(node, imp, inputNames);
-                if (sub !== undefined)
-                    return `${imp.use('waitForEvent')}(${sub})`;
-            }
             // Every family this SDK AUTHORS is recovered above — a guard test asserts
             // it (`flow-decompile-families.test.ts`). Reaching here means a node type
             // the SDK cannot author: a hand-written file, a newer platform family, or

package/dist/flow-node-type.d.ts

@@ -16,6 +16,7 @@ import type { DefinitionReference, NodeContribution } from './core/node-classes.
 import type { CheckOpts } from './check.js';
 import type { SerializeOpts } from './serialize.js';
 import type { DeclaredExit, NoExits } from './core/step-ports.js';
+import type { EventEmitEnv } from './core/event-subscription.js';
 /**
  * What a Flow node type's `serialize` returns: the node's type-owned fields.
  *
@@ -240,6 +241,12 @@ export interface FlowSerializeContext {
     emitted(typeName: string, version: string): unknown;
     /** The connector library serialize was given, for a type that resolves a connector operation. */
     readonly library: SerializeOpts['library'];
+    /**
+     * What an event subscription's shared emission (`core/event-subscription.ts`)
+     * needs: the library, the bindings, and how a label resolves, with compile's
+     * refusals and warnings.
+     */
+    readonly events: EventEmitEnv;
     /**
      * Render a value and every `Expr` nested in its objects and arrays, as a
      * connector's inputs are. A `lookup()` token is refused: it belongs only where a
@@ -408,6 +415,14 @@ export interface FlowCheckContext {
         key: string;
         action?: string;
     }): void;
+    /**
+     * Run the rules every event subscription shares, against the library facts
+     * check was given (`options`): the subscription's own shape and its
+     * resolution against the library. `where` is how the site is named
+     * (`waitForEvent "<step>"`). What compile refuses is the serializer's,
+     * reported from its run; each rule is reported at its own severity.
+     */
+    eventSubscription(subscription: unknown, where: string): void;
     /**
      * Run the rules every Integration Service operation shares that compile does
      * not: its lookups and its schema readiness, against the library facts check
@@ -564,6 +579,16 @@ export interface FlowNodeType<Spec> extends NodeType<Spec, FlowNodeContribution,
      * `errorPort`, so the two rungs give one answer; undefined when it cannot.
      */
     checkDefinition?(spec: Spec, options: CheckOpts): unknown;
+    /**
+     * The node a spec builds, as far as the spec itself names it, for a per-tenant
+     * prefix type: its concrete type name, and the version the spec pins. A refused
+     * step's stand-in names its node by it, before any definition is in hand (an
+     * event wait refused for want of a library still names its event).
+     */
+    namedNode?(spec: Spec): {
+        typeName: string;
+        version?: string;
+    } | undefined;
 }
 /** A Flow node type with several versions. */
 export type FlowVersionedNodeType<Spec> = VersionedNodeType<Spec, FlowNodeContribution, FlowContexts, FlowNodeType<Spec>>;