@uipath/maestro-builder-sdk 6.11.4 → 6.11.6

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

@@ -261,39 +261,69 @@ export function unionEventParameters(declared, objectParameters) {
     }
     return withCascade([...merged.values()]);
 }
+/** The three event facts: the API's (PascalCase) spelling and the stored (camelCase) one. */
 const EVENT_FACTS = [
     ["EventMode", "eventMode"],
     ["ByoaConnection", "byoaConnection"],
     ["IsWebhookUrlVisible", "isWebhookUrlVisible"],
 ];
-/** `merge_describe_into_node`: fold a `triggers describe` answer into a registry trigger definition (a copy). */
-export function mergeDescribeIntoNode(node, describe, objectParameters = null) {
+/**
+ * THE precedence rule for the three event facts, used by every place that
+ * decides one: the `triggers objects` ROW wins, then `fallback`, and a fact
+ * neither states stays absent.
+ *
+ * `fallback` is whichever definition the caller holds — a `triggers describe`
+ * answer (PascalCase, generate time) or a registry node (camelCase, prepare
+ * time); both spellings are read. The row is the only one of the three sources
+ * that tells the truth about BYOA: Slack `message-received-in-slack` answers
+ * `ByoaConnection: true` in its objects row and `false` in both `describe` and
+ * the registry node. Generate time used to read `describe` alone while
+ * `prepare` read the row, so the library baked `false` for a BYOA-only event
+ * and nothing downstream could refuse a standard connection on it (#848).
+ * One function, so the two sides cannot drift again.
+ */
+export function resolveEventFacts(objectRow, fallback) {
+    const row = pyOr(objectRow, {});
+    const other = pyOr(fallback, {});
+    const out = {};
+    for (const [api, stored] of EVENT_FACTS) {
+        for (const [source, key] of [[row, api], [other, api], [other, stored]]) {
+            if (get(source, key) !== null) {
+                out[stored] = source[key];
+                break;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * `merge_describe_into_node`: fold a `triggers describe` answer into a registry
+ * trigger definition (a copy). The facts follow {@link resolveEventFacts}, so
+ * pass the event's `triggers objects` row when there is one: `prepare` stores
+ * this definition as the overlay, and `check` reads BYOA off the overlay.
+ */
+export function mergeDescribeIntoNode(node, describe, objectParameters = null, objectRow = null) {
     const out = { ...node };
     out.eventParameters = { fields: unionEventParameters(get(describe, "EventParameters"), objectParameters) };
     out.filterFields = { fields: camelFields(get(describe, "FilterFields")) };
     if (truthy(get(describe, "OutputFields"))) {
         out.outputResponseDefinition = { fields: camelFields(get(describe, "OutputFields")) };
     }
-    for (const [src, dst] of EVENT_FACTS)
-        if (get(describe, src) !== null)
-            out[dst] = describe[src];
+    Object.assign(out, resolveEventFacts(objectRow, describe));
     return out;
 }
-/** `event_facts`: the three facts that change how a subscription is prepared or tested; the object row wins. */
+/**
+ * `event_facts`: the three facts that change how a subscription is prepared or
+ * tested, by {@link resolveEventFacts} (the object row wins), with defaults.
+ */
 export function eventFacts(node, objectRow) {
     const row = pyOr(objectRow, {});
-    const fact = (rowKey, nodeKey, dflt) => {
-        if (get(row, rowKey) !== null)
-            return row[rowKey];
-        if (get(node, nodeKey) !== null)
-            return node[nodeKey];
-        return dflt;
-    };
+    const stated = resolveEventFacts(row, node);
     const textBlocks = pyOr(get(pyOr(get(row, "Design"), {}), "TextBlocks"), get(pyOr(get(row, "design"), {}), "textBlocks"), []);
     return {
-        eventMode: pyStr(pyOr(get(node, "eventMode"), "polling")),
-        byoaConnection: truthy(fact("ByoaConnection", "byoaConnection", false)),
-        isWebhookUrlVisible: truthy(fact("IsWebhookUrlVisible", "isWebhookUrlVisible", false)),
+        eventMode: pyStr(pyOr(stated.eventMode ?? null, "polling")),
+        byoaConnection: truthy(stated.byoaConnection ?? false),
+        isWebhookUrlVisible: truthy(stated.isWebhookUrlVisible ?? false),
         textBlocks: pyIter(textBlocks).map(textBlockText),
     };
 }
@@ -388,9 +418,8 @@ export function applyEventSchema(entry, describe, obj) {
     if (outputFields.length > 0)
         e.outputSchema = { fields: outputFields };
     const eventSchema = { eventParameters: fields, filterFields: camelFields(get(d, "FilterFields")) };
-    for (const [src, dst] of EVENT_FACTS)
-        if (get(d, src) !== null)
-            eventSchema[dst] = d[src];
+    // The objects row is the per-object fact sheet; describe is the fallback.
+    Object.assign(eventSchema, resolveEventFacts(o, d));
     e.eventSchema = eventSchema;
     return entry;
 }

package/dist/registry/prepare/byoa-ledger.d.ts

@@ -0,0 +1,12 @@
+import type { ConnectionRow } from "./connections.js";
+/**
+ * The ledger with `byoa[nodeType][connectionId]` set to a passing check. Pure:
+ * returns a new ledger. A re-run on the same connection rewrites the entry,
+ * `verifiedAt` included — the check was made again, so the snapshot is newer.
+ */
+export declare function recordByoa(ledger: Record<string, unknown>, nodeType: string, connectionId: string, row: ConnectionRow | undefined, verifiedAt: string): Record<string, unknown>;
+/**
+ * Record a passing BYOA check in `<outDir>/resolutions.json` and return that
+ * path: read (refusing a corrupt file before anything is written), record, write.
+ */
+export declare function recordByoaVerification(outDir: string, nodeType: string, connectionId: string, row: ConnectionRow | undefined, verifiedAt?: string): string;

package/dist/registry/prepare/byoa-ledger.js

@@ -0,0 +1,26 @@
+import { ledgerPath, readLedger, writeLedger } from "./objects.js";
+import { isPlainObject, pyGet, pyStrAny } from "./support.js";
+/**
+ * The ledger with `byoa[nodeType][connectionId]` set to a passing check. Pure:
+ * returns a new ledger. A re-run on the same connection rewrites the entry,
+ * `verifiedAt` included — the check was made again, so the snapshot is newer.
+ */
+export function recordByoa(ledger, nodeType, connectionId, row, verifiedAt) {
+    const sectionIn = ledger.byoa;
+    const section = isPlainObject(sectionIn) ? { ...sectionIn } : {};
+    const perEventIn = section[nodeType];
+    const perEvent = isPlainObject(perEventIn) ? { ...perEventIn } : {};
+    const name = pyStrAny(pyGet(row ?? {}, "Name", "") ?? "");
+    perEvent[connectionId] = { byoa: true, ...(name ? { connectionName: name } : {}), verifiedAt };
+    section[nodeType] = perEvent;
+    return { ...ledger, schemaVersion: "1", byoa: section };
+}
+/**
+ * Record a passing BYOA check in `<outDir>/resolutions.json` and return that
+ * path: read (refusing a corrupt file before anything is written), record, write.
+ */
+export function recordByoaVerification(outDir, nodeType, connectionId, row, verifiedAt = new Date().toISOString().slice(0, 10)) {
+    const path = ledgerPath(outDir);
+    writeLedger(path, recordByoa(readLedger(path), nodeType, connectionId, row, verifiedAt));
+    return path;
+}

package/dist/registry/prepare/event.d.ts

@@ -3,6 +3,7 @@ import { type EventFacts } from "../library-build/events.js";
 import { type Dict } from "../library-build/py.js";
 import type { LibraryEntry } from "../model/library.js";
 import type { UipClient } from "../uip/client.js";
+import { type ConnectionRow } from "./connections.js";
 /**
  * `_event_operation`: the operation key every trigger API takes.
  *
@@ -50,8 +51,11 @@ export interface BindingsRollback {
  * connection into `bindings.json` by the time the event's own metadata says it
  * is the wrong KIND, so the file is restored first. A listing that FAILED is
  * not a tenant with no BYOA connections; the remedies are opposite.
+ *
+ * Returns the connection's BYOA listing row when it passes, for the record
+ * `prepare` then writes (see `byoa-ledger.ts`).
  */
-export declare function refuseUnlessByoaConnection(client: UipClient, connectorKey: string, connectionId: string, rollback: BindingsRollback | undefined, warn: (line: string) => void): Promise<void>;
+export declare function refuseUnlessByoaConnection(client: UipClient, connectorKey: string, connectionId: string, rollback: BindingsRollback | undefined, warn: (line: string) => void): Promise<ConnectionRow>;
 export interface EventPrepareOptions {
     connectorKey: string;
     action: string;

package/dist/registry/prepare/event.js

@@ -21,12 +21,13 @@
  */
 import { extractCanonical, nodeOf } from "../library-build/canonical.js";
 import { registryProbe } from "../library-build/context.js";
-import { EventDiscoveryError, eventFacts, mergeDescribeIntoNode, triggersDescribe, triggersObjects, unionEventParameters, } from "../library-build/events.js";
+import { EventDiscoveryError, eventFacts, mergeDescribeIntoNode, resolveEventFacts, triggersDescribe, triggersObjects, unionEventParameters, } from "../library-build/events.js";
 import { get, isRecord } from "../library-build/py.js";
 import { planLibrary } from "../library-build/plan.js";
+import { recordByoaVerification } from "./byoa-ledger.js";
 import { ConnectionRefusal, byoaConnections, byoaListing, restoreBindings } from "./connections.js";
 import { writeResolutions } from "./ledger.js";
-import { PREPARE_COMMAND, PrepareRefusal, byoaListingFailedMessage, byoaRequiredMessage, describeFallbackWarning, generatedModulesLine, eventAllObjectsMessage, eventNextLine, eventParentFieldsMessage, eventSubscription, eventSummaryLine, filterableFieldsLine, genericEventNeedsObjectMessage, lookupVocabularyLines, objectNoteLine, objectOnCuratedEventMessage, objectRecordedLine, warnLine, webhookNoteLines, } from "./messages.js";
+import { PREPARE_COMMAND, PrepareRefusal, byoaListingFailedMessage, byoaRecordedLine, byoaRequiredMessage, describeFallbackWarning, generatedModulesLine, eventAllObjectsMessage, eventNextLine, eventParentFieldsMessage, eventSubscription, eventSummaryLine, filterableFieldsLine, genericEventNeedsObjectMessage, lookupVocabularyLines, objectNoteLine, objectOnCuratedEventMessage, objectRecordedLine, warnLine, webhookNoteLines, } from "./messages.js";
 import { RESOLUTIONS_FILENAME, matchObject, recordObjectResolution } from "./objects.js";
 import { lookupSpecsFromOverlay, mergeFilesInto } from "./overlay.js";
 import { regenerateDescriptors } from "./regenerate.js";
@@ -62,12 +63,15 @@ export function assembleEventDefinition(node, entry, describe, objectRow, eventN
     const objectParameters = objectRow === undefined ? null : pyGet(objectRow, "Parameters", null);
     let stored;
     if (describe !== undefined) {
-        stored = mergeDescribeIntoNode(node, describe, objectParameters);
+        stored = mergeDescribeIntoNode(node, describe, objectParameters, objectRow ?? null);
     }
     else {
         stored = { ...node };
         const declared = pyOr(get(stored, "eventParameters"), {});
         stored.eventParameters = { fields: unionEventParameters(get(declared, "fields"), objectParameters) };
+        // The row's facts win here too: this definition IS the overlay, and a
+        // describe outage on a BYOA event must not store the registry's `false`.
+        Object.assign(stored, resolveEventFacts(objectRow ?? null, stored));
     }
     const out = { ...entry };
     const outputDefinition = pyOr(get(stored, "outputResponseDefinition"), {});
@@ -88,6 +92,9 @@ export function assembleEventDefinition(node, entry, describe, objectRow, eventN
  * connection into `bindings.json` by the time the event's own metadata says it
  * is the wrong KIND, so the file is restored first. A listing that FAILED is
  * not a tenant with no BYOA connections; the remedies are opposite.
+ *
+ * Returns the connection's BYOA listing row when it passes, for the record
+ * `prepare` then writes (see `byoa-ledger.ts`).
  */
 export async function refuseUnlessByoaConnection(client, connectorKey, connectionId, rollback, warn) {
     const restore = () => {
@@ -104,8 +111,9 @@ export async function refuseUnlessByoaConnection(client, connectorKey, connectio
         restore();
         throw new PrepareRefusal(byoaListingFailedMessage(connectionId, error), "BYOA_LISTING_FAILED");
     }
-    if (rows.some((row) => pyStrAny(pyGet(row, "Id", null)) === connectionId))
-        return;
+    const match = rows.find((row) => pyStrAny(pyGet(row, "Id", null)) === connectionId);
+    if (match)
+        return match;
     restore();
     throw new PrepareRefusal(byoaRequiredMessage(connectionId, connectorKey, byoaListing(rows, connectorKey)), "BYOA_REQUIRED");
 }
@@ -212,14 +220,20 @@ export async function prepareEvent(ctx, options) {
         }
     }
     const facts = eventFacts(node, objectRow ?? null);
-    if (facts.byoaConnection) {
-        await refuseUnlessByoaConnection(ctx.client, connectorKey, connectionId, options.bindings, warn);
-    }
+    const byoaRow = facts.byoaConnection
+        ? await refuseUnlessByoaConnection(ctx.client, connectorKey, connectionId, options.bindings, warn)
+        : undefined;
     const definition = assembleEventDefinition(node, entry, describe, objectRow, eventNodeType);
     const plan = planLibrary([definition.entry], () => definition.node);
     for (const line of plan.warnings)
         warn(line);
     mergeFilesInto(plan.files, out);
+    if (byoaRow !== undefined) {
+        // What `check` and `compile` look for before they accept this event on this
+        // connection: the proof that the live check above ran and passed.
+        recordByoaVerification(out, eventNodeType, connectionId, byoaRow);
+        info(byoaRecordedLine(connectionId, pyPathJoin(outShown, RESOLUTIONS_FILENAME)));
+    }
     if (generic) {
         recordObjectResolution(out, eventNodeType, requestedObject, objectRow, operation);
         // Named as the author spelled `--out`, not as the file was resolved.

package/dist/registry/prepare/messages.d.ts

@@ -237,6 +237,8 @@ export declare function warnLine(error: unknown): string;
 /** The describe could not answer for a curated event; the definition's own sections stand in. */
 export declare function describeFallbackWarning(error: unknown, bakedObject: string): string;
 export declare function byoaListingFailedMessage(connectionId: string, error: unknown): string;
+/** The passing BYOA check, and where it was recorded for `check` / `compile`. */
+export declare function byoaRecordedLine(connectionId: string, ledgerPath: string): string;
 export declare function byoaRequiredMessage(connectionId: string, connectorKey: string, listing: string): string;
 export declare function eventSummaryLine(eventNodeType: string, out: string, operation: string, mode: string, whereParameters: number, filterFields: number): string;
 /** The first eight filterable field names, or nothing when the event has none. */

package/dist/registry/prepare/messages.js

@@ -548,6 +548,10 @@ export function byoaListingFailedMessage(connectionId, error) {
         "(bring-your-own-app) connection, and the BYOA listing needed to " +
         `check ${connectionId} against it failed: ${messageOf(error)}`);
 }
+/** The passing BYOA check, and where it was recorded for `check` / `compile`. */
+export function byoaRecordedLine(connectionId, ledgerPath) {
+    return `  byoa: ${connectionId} is a BYOA connection — recorded in ${ledgerPath}`;
+}
 export function byoaRequiredMessage(connectionId, connectorKey, listing) {
     return (`${PREFIX}this event object requires a BYOA ` +
         `(bring-your-own-app) connection, and ${connectionId} is not ` +

package/dist/serialize.js

@@ -16,6 +16,7 @@ import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
 import { dataFabricUnknownInputs } from './core/typed-raw-node.js';
 import { isAnswerField } from './core/hitl-answers.js';
 import { BindingRefusal, GUID_RE, bindingSelfNameMessage, bindingUndeclaredMessage, undeclaredBinding } from './core/binding-messages.js';
+import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
 import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeSlug } from './core/hitl-routing.js';
 import { declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
 import { buildConfiguration, transportHttpMethod } from './config.js';
@@ -27,6 +28,7 @@ import { migrateToSchemaVersion } from './migrate.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { resolveSchemaVersion } from './schema-version.js';
 import { prepareCommand } from './core/cli-spelling.js';
+import { QUEUE_ITEM_RECORD_SCHEMA } from './core/queue-record.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
 // core-definitions.json is an object keyed by "<nodeType>@<version>".
 const DEFS = JSON.parse(readFileSync(join(HERE, 'core-definitions.json'), 'utf8'));
@@ -2329,53 +2331,6 @@ function connectionResourceBindings(spec, existing) {
     });
     return { entries };
 }
-/**
- * The queue item's own Orchestrator record — the fields `core.action.queue.create`
- * publishes, declared so a downstream read is checkable.
- *
- * Unlike an rpa process's output arguments, this shape is NOT per-tenant: it is
- * Orchestrator's queue-item record, the same for every queue, so the author has
- * nothing to declare and `returns` is not needed for a fire-and-forget enqueue.
- * The dispatcher returns `env.Data` from `uip or queue-items add` verbatim, and
- * these are the fields a real add answered with (pinned 2026-07-28 against
- * `Shared/SupplierInvoices` on codereval; `gen-tests`' fixture for the node is the
- * same list). Declaring the EVIDENCED fields and no more is PR 10's payload-schema
- * pattern — an invented field would be #73's `firedAt` again.
- */
-const QUEUE_ITEM_RECORD_SCHEMA = {
-    type: 'object',
-    properties: {
-        Id: { type: 'number' },
-        Key: { type: 'string' },
-        UniqueKey: { type: 'string' },
-        Reference: { type: 'string' },
-        Status: { type: 'string' },
-        Priority: { type: 'string' },
-        QueueDefinitionName: { type: 'string' },
-        QueueDefinitionKey: { type: 'string' },
-        CreationTime: { type: 'string' },
-        StartProcessing: { type: 'string' },
-        EndProcessing: { type: 'string' },
-        Progress: { type: 'string' },
-        ReviewStatus: { type: 'string' },
-        DueDate: { type: 'string' },
-        RiskSlaDate: { type: 'string' },
-        DeferDate: { type: 'string' },
-        Encrypted: { type: 'boolean' },
-        SpecificContent: { type: 'object' },
-        Output: { type: 'object' },
-        OutputData: { type: 'string' },
-        Analytics: { type: 'object' },
-        AnalyticsData: { type: 'string' },
-        ProcessingExceptionType: { type: 'string' },
-        ProcessingExceptionReason: { type: 'string' },
-        SecondsInPreviousAttempts: { type: 'number' },
-        RetryNumber: { type: 'number' },
-        CreatorJobKey: { type: 'string' },
-        ExecutorJobKey: { type: 'string' },
-        RobotKey: { type: 'string' },
-    },
-};
 /**
  * Build the definition for one queue-item node.
  *
@@ -3258,6 +3213,24 @@ function eventTarget(sub) {
         ? { 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);
+}
 /**
  * Resolve a symbolic connection/folder name to the resource key that is inlined
  * as `connectionId` / `connectionFolderKey`.
@@ -4230,7 +4203,9 @@ export function serialize(built, opts = {}) {
             if (!opts.library)
                 throw new Error(`onEvent() needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
             const sub = built.trigger.subscription;
-            return opts.library.resolveEvent('trigger', sub.connector, sub.event, sub.version, sub.object);
+            const rc = opts.library.resolveEvent('trigger', sub.connector, sub.event, sub.version, sub.object);
+            refuseUnverifiedByoa(opts, 'trigger', sub);
+            return rc;
         })()
         : undefined;
     // The trigger node's id is `start` unless the flow renamed it. `input('x')`
@@ -5352,6 +5327,7 @@ export function serialize(built, opts = {}) {
                 throw new Error(`waitForEvent "${step.name}" needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
             const sub = spec.subscription;
             const rc = opts.library.resolveEvent('event', sub.connector, sub.event, sub.version, sub.object);
+            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 });
             node.inputs = { detail: eventDetail(rc, sub, id, opts) };
@@ -6206,6 +6182,7 @@ export function serialize(built, opts = {}) {
                     throw new Error(`onEvent() needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
                 const sub = epSpec.subscription;
                 const rc = opts.library.resolveEvent('trigger', sub.connector, sub.event, sub.version, sub.object);
+                refuseUnverifiedByoa(opts, 'trigger', sub);
                 node = makeNode(rc.nodeType, ep.id, 'Event trigger', { def: rc.v1def, requestedVersion });
                 node.inputs = {
                     entryPointId: stableId(`${built.id}:${ep.id}:entryPoint`),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.11.4",
+  "version": "6.11.6",
   "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": "8c18e5efb6f8dd4b2599f9591cabdff42feaf275"
+  "gitref": "db117054e312c3c2aa7b7b208d3a92fc68de7fb9"
 }