@uipath/maestro-builder-sdk 6.18.1 → 6.18.3

package/dist/api-index.md

@@ -204,7 +204,7 @@ could hand you spans for a version you do not have.
 | `ran` | function | `dist/core/expr.d.ts:95-141` | Expressions and types | Did this step run? |
 | `rawNode` | function | `dist/core/node-classes.d.ts:180-242` | Supporting types | Place a node this SDK has no factory for, carrying its definition verbatim (`uipath.exotic.thing@2.1` and the manifest… |
 | `RawReference` | type | `dist/core/lookups.d.ts:190-198` | Supporting types |  |
-| `refuseLookupToken` | function | `dist/core/lookups.d.ts:207-226` | Generated descriptors | Refuse a lookup token where the family cannot resolve one. |
+| `refuseLookupToken` | function | `dist/core/lookups.d.ts:207-223` | Generated descriptors | Refuse a lookup token where the family cannot resolve one. |
 | `RemoteA2aToolRef` | interface | `dist/core/actions.d.ts:1745-1765` | Supporting types | A remote A2A (agent-to-agent) endpoint the agent may delegate to. |
 | `resolvedValue` | function | `dist/core/lookups.d.ts:172-179` | Generated descriptors | The recorded id for a token, or `undefined`. |
 | `ReturnFieldType` | type | `dist/core/actions.d.ts:1317-1334` | Supporting types | A JSON-schema-ish type for one field of a step's declared `returns`. |

package/dist/case/check.d.ts

@@ -9,7 +9,7 @@
  */
 import type { BuiltCase } from './case-sdk.js';
 import { type ConnectorCheckOpts } from '../core/connector-checks.js';
-import type { EventCheckOpts } from '../core/event-checks.js';
+import type { EventSubscription } from '../core/actions.js';
 export interface Diagnostic {
     level: 'error' | 'warning';
     code: string;
@@ -21,17 +21,28 @@ export interface Diagnostic {
  * The connector-library facts Case `check` reads, from the same `Library`
  * instance `compile` serializes against (`caseCheckOpts` in `./cli-library.ts`).
  *
- * Deliberately NARROWER than Flow's and BPMN's bag. An error here must be a
- * refusal Case `compile` actually makes, and Case `serialize` resolves the
- * connector operation and the event (`library.resolve` / `resolveEvent`) but does
- * not validate connector inputs, binding labels or BYOA. Those rules stay off
- * until Case compile enforces them; passing them here would refuse sources that
- * compile accepts.
+ * Deliberately NARROWER than Flow's bag. An error here must be a refusal Case
+ * `compile` actually makes. Case `serialize` resolves the connector operation and
+ * the event, and validates a connector task's inputs and resolves its lookups
+ * through the shared `buildConnectorInputs` (`connectorInputs`, `lookups`,
+ * `resolutions`). It does not check binding labels or BYOA, so those hooks stay
+ * off until Case compile enforces them.
  *
  * Every hook fails open: without a library, `check` stays a pure function of the
  * built model.
  */
-export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'connectorResolveError' | 'schemaReadiness'> & Pick<EventCheckOpts, 'eventResolveError'>;
+export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'connectorResolveError' | 'connectorInputs' | 'lookups' | 'resolutions' | 'schemaReadiness'> & {
+    /**
+     * What Case `compile` would refuse an event subscription with, or `undefined`
+     * when it resolves: `EVENT_UNKNOWN` (the event is not in the library, or
+     * refuses the `object`) or `EVENT_GENERIC_NO_OBJECT` (a GENERIC event with no
+     * `object`). Built on `resolveCaseSubscription`, the call compile makes.
+     */
+    subscriptionError?: (kind: 'trigger' | 'event', subscription: EventSubscription) => {
+        code: string;
+        message: string;
+    } | undefined;
+};
 /**
  * Validate a built case.
  *

package/dist/case/check.js

@@ -2,7 +2,7 @@ import { types } from '../core/expr.js';
 import { authoredCaseVersion, CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors } from './preserve.js';
-import { EQUALS_EXPR_DIALECT, checkConnectorContract, checkConnectorSchema, } from '../core/connector-checks.js';
+import { EQUALS_EXPR_DIALECT, checkConnectorContract, checkConnectorLookups, checkConnectorSchema, } from '../core/connector-checks.js';
 const TYPE_NAMES = new Set(Object.values(types));
 // audit-case-coverage: rule-slot table start
 // This runtime table must equal the committed matrix's rejected cells. The audit
@@ -271,7 +271,8 @@ export function check(built, opts = {}) {
  *   their operation (`library.resolve`): CONNECTOR_NOT_IN_LIBRARY,
  *   CONNECTOR_OBJECT_REQUIRED, CONNECTOR_OBJECT_NOT_GENERIC;
  * - an event trigger, a wait-for-connector task and a wait-for-connector rule
- *   resolve their subscription (`library.resolveEvent`): EVENT_UNKNOWN.
+ *   resolve their subscription (`resolveCaseSubscription`): EVENT_UNKNOWN,
+ *   EVENT_GENERIC_NO_OBJECT.
  *
  * A connector task also gets the schema-readiness warnings, because the
  * `connectors-local` overlay `registry prepare` writes is what Case compile
@@ -282,16 +283,11 @@ function checkLibraryConnectors(built, opts, diags) {
         diags.push({ level: d.level, code: d.code, message: d.message, where: at, ...(d.suggestion ? { suggestion: d.suggestion } : {}) });
     };
     const subscription = (kind, sub, where, at) => {
-        // Exactly the arguments `resolvedSubscriptionBag` passes to `resolveEvent`.
-        // It passes no `object` (a Case compile gap, tracked separately), so neither
-        // does this: check must refuse what compile refuses, no more.
-        const unresolved = opts.eventResolveError?.(kind, {
-            connector: sub.connector,
-            event: sub.event,
-            ...(sub.version !== undefined ? { version: sub.version } : {}),
-        });
-        if (unresolved !== undefined)
-            diags.push({ level: 'error', code: 'EVENT_UNKNOWN', message: `${where}: ${unresolved}`, where: at });
+        // The call `resolvedSubscriptionBag` makes (`resolveCaseSubscription`), so
+        // check refuses exactly what compile refuses, with the same text.
+        const refused = opts.subscriptionError?.(kind, sub);
+        if (refused !== undefined)
+            diags.push({ level: 'error', code: refused.code, message: `${where}: ${refused.message}`, where: at });
     };
     const rules = (conditions, where) => {
         for (const c of conditions)
@@ -314,6 +310,7 @@ function checkLibraryConnectors(built, opts, diags) {
             if (t.kind === 'connector' && t.connector) {
                 const where = `Connector task "${t.name}"`;
                 const spec = t.connector;
+                checkConnectorLookups(where, spec, opts, EQUALS_EXPR_DIALECT, reporter(where, t.name));
                 checkConnectorSchema(where, spec, opts, EQUALS_EXPR_DIALECT, reporter(where, t.name));
                 checkConnectorContract(where, spec, opts, reporter(where, t.name));
             }

package/dist/case/cli-library.d.ts

@@ -4,9 +4,11 @@ import type { CaseCheckOpts } from './check.js';
  * Case's check options from a library the CLI already opened, or `{}` without one.
  *
  * Only the hooks for refusals Case `compile` makes (see {@link CaseCheckOpts}):
- * the operation and event resolution, and the schema-readiness warnings. The
- * field-contract, binding-label and BYOA hooks of the shared bag are left out,
- * because Case `serialize` does not enforce them.
+ * the operation and event resolution (the event through `resolveCaseSubscription`,
+ * compile's own call), a connector task's field contract and lookups (the
+ * `=`-expression validator Case compile runs), and the schema-readiness warnings.
+ * The binding-label and BYOA hooks of the shared bag are left out, because Case
+ * `serialize` does not enforce them.
  *
  * @param library - The library `openCliLibrary` returned, or `undefined`.
  * @returns The options for Case `check`.

package/dist/case/cli-library.js

@@ -8,13 +8,16 @@
  * both `case check` and `case compile`'s check pass call.
  */
 import { connectorCheckOpts } from '../core/cli-library.js';
+import { EVENT_GENERIC_NO_OBJECT, GenericEventNoObjectError, resolveCaseSubscription } from './subscription.js';
 /**
  * Case's check options from a library the CLI already opened, or `{}` without one.
  *
  * Only the hooks for refusals Case `compile` makes (see {@link CaseCheckOpts}):
- * the operation and event resolution, and the schema-readiness warnings. The
- * field-contract, binding-label and BYOA hooks of the shared bag are left out,
- * because Case `serialize` does not enforce them.
+ * the operation and event resolution (the event through `resolveCaseSubscription`,
+ * compile's own call), a connector task's field contract and lookups (the
+ * `=`-expression validator Case compile runs), and the schema-readiness warnings.
+ * The binding-label and BYOA hooks of the shared bag are left out, because Case
+ * `serialize` does not enforce them.
  *
  * @param library - The library `openCliLibrary` returned, or `undefined`.
  * @returns The options for Case `check`.
@@ -25,7 +28,21 @@ export function caseCheckOpts(library) {
     const shared = connectorCheckOpts(library);
     return {
         connectorResolveError: shared.connectorResolveError,
+        connectorInputs: shared.connectorInputs,
+        lookups: shared.lookups,
+        resolutions: shared.resolutions,
         schemaReadiness: shared.schemaReadiness,
-        eventResolveError: shared.eventResolveError,
+        subscriptionError: (kind, sub) => {
+            try {
+                resolveCaseSubscription(library, kind, sub);
+                return undefined;
+            }
+            catch (error) {
+                return {
+                    code: error instanceof GenericEventNoObjectError ? EVENT_GENERIC_NO_OBJECT : 'EVENT_UNKNOWN',
+                    message: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
     };
 }

package/dist/case/decompile.js

@@ -190,6 +190,8 @@ function resolvedSubscriptionSource(bag, owner, kind, refs) {
     return opts([
         ['connector', tsLiteral(identity.key)],
         ['event', tsLiteral(identity.event)],
+        // A GENERIC event's object is the author's choice, so it comes back as `object`.
+        ['object', identity.object !== undefined ? tsLiteral(identity.object) : undefined],
         ['where', where !== undefined ? tsLiteral(where) : undefined],
         ['filters', filters !== undefined ? tsLiteral(filters) : undefined],
         ['connection', connection !== undefined ? tsLiteral(connection) : undefined],

package/dist/case/serialize.js

@@ -9,8 +9,10 @@
  * name) are resolved here to the generated ids.
  */
 import { IdGen } from './ids.js';
-import { transportHttpMethod } from '../core/connector-inputs.js';
+import { buildConnectorInputs, nestConnectorBody, transportHttpMethod } from '../core/connector-inputs.js';
+import { EQUALS_EXPR_DIALECT } from '../core/connector-checks.js';
 import { refuseLookupToken } from '../core/lookups.js';
+import { resolveCaseSubscription } from './subscription.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { resolveSchemaVersion } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors, } from './preserve.js';
@@ -885,7 +887,7 @@ function resolvedSubscriptionBag(kind, spec, resolver, elementId) {
     if (!resolver.library)
         throw new Error(`${kind === 'trigger' ? 'event trigger' : 'wait-for-connector'} needs the connector library — `
             + `pass { library } to serialize or use uip maestro case compile --library.`);
-    const rc = resolver.library.resolveEvent(kind, spec.connector, spec.event, spec.version);
+    const rc = resolveCaseSubscription(resolver.library, kind, spec);
     const op = rc.entry.operation ?? {};
     const context = [io('connectorKey', 'string', { value: rc.connectorKey })];
     const connection = bindingRef(resolver, spec.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`);
@@ -1082,7 +1084,6 @@ function connectorTaskData(spec, resolver, elementId) {
         throw new Error(`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);
     const op = rc.entry.operation ?? {};
-    const params = Array.isArray(op.parameters) ? op.parameters : [];
     const context = [
         io('connectorKey', 'string', { value: rc.connectorKey }),
     ];
@@ -1096,31 +1097,31 @@ function connectorTaskData(spec, resolver, elementId) {
     if (folderRef)
         context.push(io('folderKey', 'string', { value: `=bindings.${folderRef.id}` }));
     context.push(io('objectName', 'string', { value: op.objectName ?? spec.action }), io('method', 'string', { value: transportHttpMethod(rc.httpMethod) }), io('path', 'string', { value: rc.endpoint }), io('metadata', 'json', { body: connectorMetadata(rc, op) }));
-    // inputs: split declared parameters into path/query slots; the rest is the body.
+    // inputs: the shared validator (`core/connector-inputs.ts`), the one Flow's and
+    // BPMN's serializers and every family's `check` run. It refuses a missing
+    // required field, an unknown or mistyped input, and swaps a `lookup()` token for
+    // the id `registry prepare --resolve` recorded (refusing one nobody recorded).
+    // Case used to split the inputs itself: an unknown name went to the body
+    // unchecked, and every token was refused, because nothing here read
+    // `resolutions.json` (#1034, #1036).
     //
-    // Guard BEFORE the split. These values are emitted verbatim, so an unresolved
-    // lookup ships as `{"__lookup": …}` where the connector wants an id — verified
-    // by probe before this existed. Only Flow reads resolutions.json.
-    for (const [name, value] of Object.entries(spec.inputs ?? {})) {
-        refuseLookupToken(value, 'case', name);
-    }
-    const pathParameters = {};
-    const queryParameters = {};
-    const body = { ...spec.inputs };
-    for (const p of params) {
-        const name = String(p.name ?? '');
-        if (!(name in body))
-            continue;
-        const camel = toCamel(name);
-        if (p.type === 'path') {
-            pathParameters[camel] = body[name];
-            delete body[name];
-        }
-        else if (p.type === 'query') {
-            queryParameters[camel] = body[name];
-            delete body[name];
-        }
-    }
+    // The ROUTING is the library's (a field's location is a property of the
+    // operation); the SPELLING of the path/query keys is Case's own: the Case
+    // designer camelCases them (`send_as` → `sendAs`, see
+    // `fixtures/execute-connector-activity.sample.json`), and the body is nested.
+    const slots = buildConnectorInputs(rc, spec.inputs ?? {}, {
+        dialect: EQUALS_EXPR_DIALECT,
+        resolutions: resolver.library.lookupResolutions,
+        lookups: resolver.library.lookupSpecs(spec.key, spec.action, spec.version, spec.object),
+    });
+    const camelKeys = (slot) => Object.fromEntries(Object.entries(slot ?? {}).map(([name, value]) => [toCamel(name), value]));
+    const pathParameters = camelKeys(slots.pathParameters);
+    const queryParameters = camelKeys(slots.queryParameters);
+    // Case has no multipart wire: a filled file part stays in the body, where it
+    // has always gone.
+    const parts = Object.fromEntries((slots.multipartParameters ?? [])
+        .filter((part) => part.value !== undefined).map((part) => [part.name, part.value]));
+    const body = nestConnectorBody({ ...(slots.bodyParameters ?? {}), ...parts });
     const inputs = [
         ioSlot('pathParameters', pathParameters, `${elementId}`),
         ioSlot('queryParameters', queryParameters, `${elementId}`),

package/dist/case/subscription.d.ts

@@ -0,0 +1,30 @@
+/**
+ * case/subscription — how Case resolves a connector event subscription against
+ * the library, shared by `serialize` (which throws) and `check` (which reports).
+ *
+ * One function, so the two cannot drift: the event trigger, the
+ * wait-for-connector task and the wait-for-connector rule all resolve here, with
+ * the author's `object` (#1033), and a GENERIC event that names no object is
+ * refused here with the text Flow's compile uses too
+ * (`genericEventObjectRefusal`).
+ */
+import type { EventSubscription } from '../core/actions.js';
+import type { Library, ResolvedConnector } from '../core/library.js';
+/** Check's code for {@link GenericEventNoObjectError}; Flow and BPMN `check` use the same one. */
+export declare const EVENT_GENERIC_NO_OBJECT = "EVENT_GENERIC_NO_OBJECT";
+/** A GENERIC event subscription that names no object. */
+export declare class GenericEventNoObjectError extends Error {
+    readonly code = "EVENT_GENERIC_NO_OBJECT";
+}
+/**
+ * Resolve a Case event subscription: `library.resolveEvent` with the
+ * subscription's own `version` and `object`, then refuse a GENERIC event the
+ * author named no object for.
+ *
+ * @param library - The connector library.
+ * @param kind - `trigger` for an event trigger, `event` for a wait-for-connector task or rule.
+ * @param sub - The authored subscription.
+ * @returns The resolved event.
+ * @throws What `resolveEvent` throws, or {@link GenericEventNoObjectError}.
+ */
+export declare function resolveCaseSubscription(library: Library, kind: 'trigger' | 'event', sub: EventSubscription): ResolvedConnector;

package/dist/case/subscription.js

@@ -0,0 +1,29 @@
+import { genericEventObjectRefusal } from '../core/event-checks.js';
+/** Check's code for {@link GenericEventNoObjectError}; Flow and BPMN `check` use the same one. */
+export const EVENT_GENERIC_NO_OBJECT = 'EVENT_GENERIC_NO_OBJECT';
+/** A GENERIC event subscription that names no object. */
+export class GenericEventNoObjectError extends Error {
+    code = EVENT_GENERIC_NO_OBJECT;
+}
+/** How a Case subscription spells the `object` of a GENERIC event, for the refusal text. */
+function caseObjectOption(object) {
+    return `{ connector, event, object: '${object}', … } in the subscription`;
+}
+/**
+ * Resolve a Case event subscription: `library.resolveEvent` with the
+ * subscription's own `version` and `object`, then refuse a GENERIC event the
+ * author named no object for.
+ *
+ * @param library - The connector library.
+ * @param kind - `trigger` for an event trigger, `event` for a wait-for-connector task or rule.
+ * @param sub - The authored subscription.
+ * @returns The resolved event.
+ * @throws What `resolveEvent` throws, or {@link GenericEventNoObjectError}.
+ */
+export function resolveCaseSubscription(library, kind, sub) {
+    const rc = library.resolveEvent(kind, sub.connector, sub.event, sub.version, sub.object);
+    const noObject = genericEventObjectRefusal(rc, sub, caseObjectOption);
+    if (noObject)
+        throw new GenericEventNoObjectError(noObject);
+    return rc;
+}

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

@@ -136,4 +136,35 @@ export declare function eventParamsFor(subscription: unknown, opts: EventCheckOp
  * under the event-form node type — the form `prepare` stores.
  */
 export declare function checkEventResolution(subscription: unknown, where: string, kind: 'trigger' | 'event', opts: EventCheckOpts, error: (code: string, message: string, suggestion?: string) => void, warn: (code: string, message: string, suggestion?: string) => void, eventParams?: EventParamFields): void;
+/**
+ * The compile-time refusal of a GENERIC event subscription that names no object,
+ * or `undefined` when the resolved event is fine.
+ *
+ * A GENERIC event (`activityType: GenericTrigger` — Data Fabric, Salesforce,
+ * ServiceNow, Jira, … `record-created`/`record-updated`) fires for ONE object of
+ * the connection, and its library entry names none: the author's `object` is the
+ * only source. `Library.resolveEvent` stamps that object into the resolved
+ * operation's `objectName`; without it the operation's `objectName` stays `''`,
+ * and a node built from it validates and is refused by the platform's dispatcher
+ * ("missing objectName"), or watches nothing.
+ *
+ * Every family's serializer that emits a connector event calls this on the
+ * connector `resolveEvent` returned, so the refusal has one text. Case `check`
+ * calls it on the same resolution, so it reports exactly what Case `compile`
+ * throws.
+ *
+ * @param rc - What `library.resolveEvent(kind, connector, event, version, object)` returned.
+ * @param sub - The authored subscription (only `where` is read, for the hint).
+ * @param objectOption - How this family spells the `object` option, given the object.
+ * @returns The refusal message (no site prefix), or `undefined`.
+ */
+export declare function genericEventObjectRefusal(rc: {
+    nodeType: string;
+    connectorKey: string;
+    entry?: {
+        operation?: Record<string, unknown>;
+    };
+}, sub: {
+    where?: unknown;
+}, objectOption: (object: string) => string): string | undefined;
 export declare function checkEventSubscription(subscription: unknown, where: string, at: (code: string, message: string, suggestion?: string) => void, warn?: (code: string, message: string, suggestion?: string) => void, eventParams?: EventParamFields): void;

package/dist/core/event-checks.js

@@ -204,6 +204,44 @@ export function checkEventResolution(subscription, where, kind, opts, error, war
         });
     }
 }
+/**
+ * The compile-time refusal of a GENERIC event subscription that names no object,
+ * or `undefined` when the resolved event is fine.
+ *
+ * A GENERIC event (`activityType: GenericTrigger` — Data Fabric, Salesforce,
+ * ServiceNow, Jira, … `record-created`/`record-updated`) fires for ONE object of
+ * the connection, and its library entry names none: the author's `object` is the
+ * only source. `Library.resolveEvent` stamps that object into the resolved
+ * operation's `objectName`; without it the operation's `objectName` stays `''`,
+ * and a node built from it validates and is refused by the platform's dispatcher
+ * ("missing objectName"), or watches nothing.
+ *
+ * Every family's serializer that emits a connector event calls this on the
+ * connector `resolveEvent` returned, so the refusal has one text. Case `check`
+ * calls it on the same resolution, so it reports exactly what Case `compile`
+ * throws.
+ *
+ * @param rc - What `library.resolveEvent(kind, connector, event, version, object)` returned.
+ * @param sub - The authored subscription (only `where` is read, for the hint).
+ * @param objectOption - How this family spells the `object` option, given the object.
+ * @returns The refusal message (no site prefix), or `undefined`.
+ */
+export function genericEventObjectRefusal(rc, sub, objectOption) {
+    const op = (rc.entry?.operation ?? {});
+    if (op.activityType !== 'GenericTrigger' || String(op.objectName ?? '') !== '')
+        return undefined;
+    const scopeObject = sub.where && typeof sub.where === 'object'
+        ? Object.entries(sub.where)
+            .find(([k]) => /^(objectName|entityName|object)$/i.test(k))?.[1]
+        : undefined;
+    return `${rc.nodeType} is a GENERIC event — it watches ONE object of the connection `
+        + `(an entity, a table, a custom object) and its library entry carries no default. Name it with the `
+        + `\`object\` option: ${objectOption(scopeObject !== undefined ? String(scopeObject) : '<Object>')}. `
+        + (scopeObject !== undefined
+            ? `\`where: { objectName }\` is not it — \`where\` holds event PARAMETERS, and this operation has none. `
+            : '')
+        + `\`uip is triggers objects ${rc.connectorKey} ${String(op.eventOperation ?? '<EVENT>')} --connection-id <id>\` lists the objects.`;
+}
 export function checkEventSubscription(subscription, where, at, warn, eventParams) {
     const sub = subscription;
     if (!sub || typeof sub !== 'object') {

package/dist/core/lookups.d.ts

@@ -207,16 +207,13 @@ export declare function lookupSpecOf(reference: RawReference, invariant?: Readon
 /**
  * Refuse a lookup token where the family cannot resolve one.
  *
- * `lookup()` is a FLOW surface today: only `serialize.ts` substitutes a
- * recorded resolution, and only `check.ts` reports an unresolved one. Case and
- * BPMN pass connector input values straight into their emitted payload, so a
- * token reaching either one is embedded verbatim — a `.case` carrying
- * `{"__lookup": {…}}` where the connector expects an id.
- *
- * That is silent wrongness, which is the failure this whole surface exists to
- * remove; emitting it from the tool that removes it would be the worst possible
- * outcome. Until Case and BPMN read `resolutions.json` too, they refuse the
- * token and say so.
+ * Connector-activity inputs resolve their lookups in every family through
+ * `buildConnectorInputs` (`core/connector-inputs.ts`), which reads
+ * `connectors-local/resolutions.json`. This guard is for the sites that do not
+ * go through it yet: a Case event subscription's `where`, whose values Case
+ * copies into its emitted payload verbatim. A token reaching one would be
+ * embedded as `{"__lookup": {…}}` where the connector expects an id, which is
+ * silent wrongness, so it is refused instead.
  *
  * @param value - A connector input value.
  * @param family - The authoring family, for the message.

package/dist/core/lookups.js

@@ -261,16 +261,13 @@ function byAlias(lookupName) {
 /**
  * Refuse a lookup token where the family cannot resolve one.
  *
- * `lookup()` is a FLOW surface today: only `serialize.ts` substitutes a
- * recorded resolution, and only `check.ts` reports an unresolved one. Case and
- * BPMN pass connector input values straight into their emitted payload, so a
- * token reaching either one is embedded verbatim — a `.case` carrying
- * `{"__lookup": {…}}` where the connector expects an id.
- *
- * That is silent wrongness, which is the failure this whole surface exists to
- * remove; emitting it from the tool that removes it would be the worst possible
- * outcome. Until Case and BPMN read `resolutions.json` too, they refuse the
- * token and say so.
+ * Connector-activity inputs resolve their lookups in every family through
+ * `buildConnectorInputs` (`core/connector-inputs.ts`), which reads
+ * `connectors-local/resolutions.json`. This guard is for the sites that do not
+ * go through it yet: a Case event subscription's `where`, whose values Case
+ * copies into its emitted payload verbatim. A token reaching one would be
+ * embedded as `{"__lookup": {…}}` where the connector expects an id, which is
+ * silent wrongness, so it is refused instead.
  *
  * @param value - A connector input value.
  * @param family - The authoring family, for the message.

package/dist/serialize.js

@@ -20,6 +20,7 @@ import { isAnswerField } from './core/hitl-answers.js';
 import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingMissingMessage, bindingSelfNameMessage, bindingUndeclaredMessage, missingBindingLabels, undeclaredBinding } from './core/binding-messages.js';
 import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
+import { genericEventObjectRefusal } from './core/event-checks.js';
 import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeSlug } from './core/hitl-routing.js';
 import { declaredExits, hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
@@ -4115,25 +4116,13 @@ function eventDetail(rc, sub, nodeId, opts, site) {
     const folder = resolveBinding(opts, sub.folder, 'folder', `event node "${nodeId}"`, eventTarget(sub));
     const op = (rc.entry?.operation ?? {});
     const filters = sub.filters ?? [];
-    // A GENERIC event (`activityType: GenericTrigger` — Data Fabric, Salesforce,
-    // ServiceNow, Jira, … `record-created`/`record-updated`) fires for ONE object of
-    // the connection, and the library entry names none: the author's `object` is
-    // the only source. Without it the node would carry `objectName: ""` — it
-    // validates, and the platform's dispatcher refuses it ("missing objectName") or
-    // the designer shows a trigger bound to nothing. Refused here, at the layer
-    // that would otherwise emit it.
+    // 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 ?? '');
-    if (op.activityType === 'GenericTrigger' && objectName === '') {
-        const scopeObject = Object.entries(sub.where ?? {})
-            .find(([k]) => /^(objectName|entityName|object)$/i.test(k))?.[1];
-        throw new Error(`event node "${nodeId}": ${rc.nodeType} is a GENERIC event — it watches ONE object of the connection `
-            + `(an entity, a table, a custom object) and its library entry carries no default. Name it with the `
-            + `\`object\` option: onEvent(…, { object: '${scopeObject ?? '<Object>'}' }). `
-            + (scopeObject !== undefined
-                ? `\`where: { objectName }\` is not it — \`where\` holds event PARAMETERS, and this operation has none. `
-                : '')
-            + `\`uip is triggers objects ${rc.connectorKey} ${String(op.eventOperation ?? '<EVENT>')} --connection-id <id>\` lists the objects.`);
-    }
+    const noObject = genericEventObjectRefusal(rc, sub, (o) => `onEvent(…, { object: '${o}' })`);
+    if (noObject)
+        throw new Error(`event node "${nodeId}": ${noObject}`);
     // 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.18.1",
+  "version": "6.18.3",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "6598e64a2bc931298fcb9938dc4868d5760243e6"
+  "gitref": "e2e0a41da39b08bb97a105483f436232f0e36c2e"
 }