@uipath/maestro-builder-sdk 6.11.5 → 6.12.0

package/dist/core/library.js

@@ -11,7 +11,7 @@ import { join } from 'node:path';
 import { prepareCommand } from './cli-spelling.js';
 import { loadListEnvelopes, lookupListEnvelope } from './list-envelope.js';
 import { lookupSpecOf } from './lookups.js';
-import { loadInvariantCollections, loadLookupResolutions } from './lookup-store.js';
+import { loadByoaLedger, loadInvariantCollections, loadLookupResolutions } from './lookup-store.js';
 export class Library {
     layers = [];
     /** The LIST-ENVELOPE LEDGER, overlay first so a prepared entry can add a row. */
@@ -24,10 +24,17 @@ export class Library {
      * id from someone else's connection.
      */
     lookupResolutions;
+    /**
+     * The BYOA checks `prepare` recorded (`resolutions.json` → `byoa`), from the
+     * overlay only, for the same reason as {@link lookupResolutions}: whether a
+     * connection is BYOA is a fact about one tenant.
+     */
+    byoaVerifications;
     /** Collections the ledger declares connector-invariant; overlay unions over baked. */
     invariantCollections;
     constructor(dir, opts = {}) {
         this.lookupResolutions = loadLookupResolutions(opts.overlayDir);
+        this.byoaVerifications = loadByoaLedger(opts.overlayDir);
         this.invariantCollections = new Set([
             ...loadInvariantCollections(dir),
             ...loadInvariantCollections(opts.overlayDir),
@@ -434,6 +441,45 @@ export class Library {
                 .some(([name, value]) => name !== 'type' && Boolean(value)),
         };
     }
+    /**
+     * Whether a connector event needs a BYOA (bring-your-own-app) connection, and
+     * whether its webhook URL must be registered by hand — or `undefined` when no
+     * layer carries the event in either form.
+     *
+     * Read from the `.v1def.json` sidecar, where the library build stamps the
+     * facts from the event's `triggers objects` row and `prepare` stores them on
+     * the overlay. A fact is TRUE when ANY layer, in either form (`.event.` or
+     * `.trigger.`), says so: the requirement belongs to the event object, not to
+     * a tenant, and an overlay written by an older `prepare` — which stored the
+     * `describe` answer, `false` for Slack `message-received-in-slack` — must not
+     * hide the true fact a newer baked library carries.
+     *
+     * `check` and `compile` read this through the one rule in `core/byoa.ts`.
+     */
+    eventFacts(key, event, objectName) {
+        let found = false;
+        const facts = { byoaConnection: false, isWebhookUrlVisible: false };
+        for (const layer of this.layers) {
+            for (const kind of ['event', 'trigger']) {
+                let rc;
+                try {
+                    rc = this.resolveInLayer(layer, `uipath.connector.${kind}.${key}.${event}`, undefined, objectName);
+                }
+                catch {
+                    continue; // an ambiguous object is resolveEvent's refusal to report
+                }
+                if (!rc)
+                    continue;
+                found = true;
+                const v1def = (rc.v1def ?? {});
+                if (v1def.byoaConnection === true)
+                    facts.byoaConnection = true;
+                if (v1def.isWebhookUrlVisible === true)
+                    facts.isWebhookUrlVisible = true;
+            }
+        }
+        return found ? facts : undefined;
+    }
     /**
      * The filterable-field names a connector event declares — the vocabulary a
      * `filters` leaf may name.

package/dist/core/lookup-store.d.ts

@@ -1,3 +1,4 @@
+import type { ByoaLedger } from './byoa.js';
 import type { LookupResolutions } from './lookups.js';
 /**
  * Load `<overlayDir>/resolutions.json`, or an empty map.
@@ -8,6 +9,17 @@ import type { LookupResolutions } from './lookups.js';
  * behaviour an author wants from a missing resolution anyway.
  */
 export declare function loadLookupResolutions(overlayDir: string | undefined): LookupResolutions;
+/**
+ * Load the `byoa` section of `<overlayDir>/resolutions.json` — the BYOA checks
+ * `registry prepare` recorded (see `core/byoa.ts`) — or an empty map.
+ *
+ * Lenient like {@link loadLookupResolutions}: an absent or malformed file reads
+ * as EMPTY, and the consequence of empty is the EVENT_BYOA_UNVERIFIED error
+ * naming the `prepare` command that records the check. Read fresh on every
+ * call rather than cached: `prepare` rewrites this file, and a stale "never
+ * checked" answer would refuse a flow that was just verified.
+ */
+export declare function loadByoaLedger(overlayDir: string | undefined): ByoaLedger;
 /**
  * The invariant-collection ledger's `objectName` set, from a library dir.
  *

package/dist/core/lookup-store.js

@@ -45,6 +45,31 @@ export function loadLookupResolutions(overlayDir) {
     RESOLUTION_CACHE.set(overlayDir, rows);
     return rows;
 }
+/**
+ * Load the `byoa` section of `<overlayDir>/resolutions.json` — the BYOA checks
+ * `registry prepare` recorded (see `core/byoa.ts`) — or an empty map.
+ *
+ * Lenient like {@link loadLookupResolutions}: an absent or malformed file reads
+ * as EMPTY, and the consequence of empty is the EVENT_BYOA_UNVERIFIED error
+ * naming the `prepare` command that records the check. Read fresh on every
+ * call rather than cached: `prepare` rewrites this file, and a stale "never
+ * checked" answer would refuse a flow that was just verified.
+ */
+export function loadByoaLedger(overlayDir) {
+    if (!overlayDir)
+        return {};
+    const file = join(overlayDir, 'resolutions.json');
+    if (!existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        const byoa = parsed?.byoa;
+        return byoa && typeof byoa === 'object' && !Array.isArray(byoa) ? byoa : {};
+    }
+    catch {
+        return {};
+    }
+}
 /**
  * The invariant-collection ledger's `objectName` set, from a library dir.
  *

package/dist/index.d.ts

@@ -24,9 +24,12 @@ export type { CaseRule, CaseRuleInput, CaseRuleGrid, WhenExpression, CaseJsonPre
 export { serialize as serializeCase } from './case/serialize.js';
 export { decompile as decompileCase, decompileWithDiagnostics as decompileCaseWithDiagnostics } from './case/decompile.js';
 export { bpmn } from './bpmn/bpmn-sdk.js';
-export type { BuiltBpmn, BpmnNode, BpmnFlow, BpmnVarDecl, EventDef, GatewayKind, EventKind, LoopSpec, RetrySpec, ActivityOpts, HttpOpts, } from './bpmn/bpmn-sdk.js';
+export type { BuiltBpmn, BpmnNode, BpmnFlow, BpmnVarDecl, EventDef, GatewayKind, EventKind, LoopSpec, RetrySpec, ActivityOpts, HttpOpts, ActivityBodyFn, ArmBodyFn, HandlerOpts, ErrorHandlerOpts, TimerHandlerOpts, MessageHandlerOpts, ChooseArm, ChooseOpts, SplitOpts, JoinOpts, EventSubProcessOpts, FlowMode, } from './bpmn/bpmn-sdk.js';
+export { PathBuilder, ActivityBuilder } from './bpmn/bpmn-sdk.js';
+export { renderGraph as renderBpmnGraph, graphModel as bpmnGraphModel } from './bpmn/graph.js';
+export type { GraphScope as BpmnGraphScope, GraphNode as BpmnGraphNode, GraphEdge as BpmnGraphEdge } from './bpmn/graph.js';
 export { registryTypeNames, registryType, isSnapshotType } from './bpmn/typed-node.js';
-export type { RegistryTypeSpec, RegistryContextField, RegistryOutput } from './bpmn/typed-node.js';
+export type { RegistryTypeSpec, RegistryContextField, RegistryInputField, RegistryOutput, TypedContextRow, TypedInputRow, TypedOutputRow } from './bpmn/typed-node.js';
 export { serialize as serializeBpmn } from './bpmn/serialize.js';
 export { check as checkBpmn } from './bpmn/check.js';
 export type { Diagnostic as BpmnDiagnostic } from './bpmn/check.js';

package/dist/index.js

@@ -27,6 +27,9 @@ export { serialize as serializeCase } from './case/serialize.js';
 export { decompile as decompileCase, decompileWithDiagnostics as decompileCaseWithDiagnostics } from './case/decompile.js';
 // BPMN authoring API. `bpmn()` exposes only BPMN methods.
 export { bpmn } from './bpmn/bpmn-sdk.js';
+export { PathBuilder, ActivityBuilder } from './bpmn/bpmn-sdk.js';
+// The resolved wiring `bpmn check --graph` prints, for a tool that wants it as data.
+export { renderGraph as renderBpmnGraph, graphModel as bpmnGraphModel } from './bpmn/graph.js';
 // The registry snapshot the typed nodes emit from — exposed so the coverage
 // ledger and its audit read the same source the emitter does. `isSnapshotType`
 // separates the two answers `registryType` now gives: a type the snapshot carries

package/dist/registry/generators/descriptors.d.ts

@@ -40,7 +40,7 @@ export declare function emitLookupsBlock(specs: ReadonlyMap<string, LookupSpecDa
  * parameters (HTTP Webhook) or one nothing has described yet, and an empty
  * interface would refuse every key in both cases.
  */
-export declare function emitEvent(entry: LibraryEntry, inFields: readonly LibraryField[], inputTree: TypeTree, outputTree: TypeTree, name: string, inputTypes: NamedTypeRegistry, outputTypes: NamedTypeRegistry, invariant?: ReadonlySet<string>): string[];
+export declare function emitEvent(entry: LibraryEntry, inFields: readonly LibraryField[], inputTree: TypeTree, outputTree: TypeTree, name: string, inputTypes: NamedTypeRegistry, outputTypes: NamedTypeRegistry, invariant?: ReadonlySet<string>, v1def?: V1Definition): string[];
 /** One operation: its `Inputs`/`Outputs` interfaces, doc comment and `descriptor()` const. */
 export declare function emitOp(entry: LibraryEntry, v1def: V1Definition, inputTree: TypeTree, outputTree: TypeTree, name: string, inputTypes: NamedTypeRegistry, outputTypes: NamedTypeRegistry, invariant?: ReadonlySet<string>): string[];
 /**

package/dist/registry/generators/descriptors.js

@@ -18,6 +18,7 @@
  * event's per-object variants are skipped because they share their template's
  * node type and so would emit the same const twice.
  */
+import { prepareCommand } from "../../core/cli-spelling.js";
 import { PACKAGE_NAME } from "../../package-name.js";
 import { pyJsonString, pyJsonStringify } from "../codecs/pyjson.js";
 import { sortedByCodePoint, sortedStrings } from "../compat/compare.js";
@@ -165,7 +166,7 @@ function versionOf(entry) {
  * parameters (HTTP Webhook) or one nothing has described yet, and an empty
  * interface would refuse every key in both cases.
  */
-export function emitEvent(entry, inFields, inputTree, outputTree, name, inputTypes, outputTypes, invariant = new Set()) {
+export function emitEvent(entry, inFields, inputTree, outputTree, name, inputTypes, outputTypes, invariant = new Set(), v1def = {}) {
     const nodeType = entry.nodeType;
     const eventId = afterLast(nodeType, ".");
     const connectorKey = pyTruthy(entry.connector?.key) ? entry.connector.key : "";
@@ -196,6 +197,23 @@ export function emitEvent(entry, inFields, inputTree, outputTree, name, inputTyp
         lines.push(` * Start a flow on it with \`onEvent(${name}, { where: { … } })\`, or pause for it`);
         lines.push(` * with \`waitForEvent(${name}, { … })\`; \`where\` carries its event parameters.`);
     }
+    // The facts the library build stamped from the event's `triggers objects`
+    // row. An author holding only the descriptor must learn the requirement here:
+    // on a standard connection the trigger deploys and never fires.
+    if (v1def.byoaConnection === true) {
+        lines.push(" *");
+        lines.push(" * Requires a BYOA (bring-your-own-app) connection — on a standard one the");
+        lines.push(" * trigger deploys and never fires. Bind it with");
+        // Spelled for whoever ran the generator, like every `check` remedy.
+        lines.push(` * \`${prepareCommand(pyStr(connectorKey), eventId, "--connection-id", "<id>")}\`,`);
+        lines.push(" * which refuses a standard connection and records the check `compile` requires;");
+        lines.push(" * `uip is connections list --byoa --all-folders` lists the BYOA connections.");
+    }
+    if (v1def.isWebhookUrlVisible === true) {
+        lines.push(" *");
+        lines.push(" * After deploying, register the trigger's webhook URL in the connector app's");
+        lines.push(" * event-subscription settings; `registry prepare` prints the instructions.");
+    }
     // INSIDE the block: `emitLookupComment` returns bare ` * ` body lines.
     if (specs.size > 0) {
         lines.push(" *");
@@ -222,7 +240,7 @@ export function emitOp(entry, v1def, inputTree, outputTree, name, inputTypes, ou
     const runtime = entry.runtime ?? {};
     const inFields = descriptorInputFields(entry, v1def);
     if (isEventNodeType(nodeType)) {
-        return emitEvent(entry, inFields, inputTree, outputTree, name, inputTypes, outputTypes, invariant);
+        return emitEvent(entry, inFields, inputTree, outputTree, name, inputTypes, outputTypes, invariant, v1def);
     }
     const lines = [];
     lines.push(...emitInterface(`${name}Inputs`, false, inputTypes, inputTree, true));

package/dist/registry/generators/markdown/page.js

@@ -1,12 +1,13 @@
 /**
  * One library entry rendered to Markdown: header → schema-dynamic notice →
- * choosing the object → resolving the field set → required inputs → optional
+ * connection requirements (events) → choosing the object → resolving the field set → required inputs → optional
  * inputs → resolving lookups → example → filtering → outputs. Ported from
  * `render_op`; the page is `"\n".join(lines)` with no trailing newline.
  */
 import { afterLast, pyStr } from "../../compat/pystr.js";
 import { dictOf, getStr, pyOr, pyTruthy } from "./pyvalue.js";
 import { choosingObjectLines } from "./sections/choosing-object.js";
+import { eventFactsLines } from "./sections/event-facts.js";
 import { exampleLines } from "./sections/example.js";
 import { eventFilterLines } from "./sections/filtering.js";
 import { headerLines } from "./sections/header.js";
@@ -28,6 +29,7 @@ export function renderOp(j, v1def, symbol, invariant) {
     const out = [];
     out.push(...headerLines(j, nodeType));
     out.push(...schemaDynamicLines(j, nodeType));
+    out.push(...eventFactsLines(j, v1def));
     const fields = assembleFields(j, v1def);
     const required = fields.filter((f) => pyTruthy(f.required));
     const optional = fields.filter((f) => !pyTruthy(f.required));

package/dist/registry/generators/markdown/sections/event-facts.d.ts

@@ -0,0 +1,2 @@
+import { type Dict } from "../pyvalue.js";
+export declare function eventFactsLines(j: Dict, v1def: Dict | undefined): string[];

package/dist/registry/generators/markdown/sections/event-facts.js

@@ -0,0 +1,45 @@
+/**
+ * `## Connection requirements`: the event facts an author has to act on before
+ * the trigger can fire — a BYOA (bring-your-own-app) connection, and a webhook
+ * URL registered by hand. Emitted only when a fact is TRUE, so every other
+ * event page is unchanged. The facts are the sidecar's, which the library build
+ * stamps from the event's `triggers objects` row (#848).
+ */
+import { prepareCommand } from "../../../../core/cli-spelling.js";
+import { isEventNodeType } from "../../../model/library.js";
+import { dictOf, getStr } from "../pyvalue.js";
+export function eventFactsLines(j, v1def) {
+    const nodeType = getStr(j, "nodeType", "");
+    if (!isEventNodeType(nodeType))
+        return [];
+    const facts = dictOf(v1def);
+    const byoa = facts.byoaConnection === true;
+    const webhook = facts.isWebhookUrlVisible === true;
+    if (!byoa && !webhook)
+        return [];
+    const key = getStr(dictOf(j.connector), "key", "<connector>");
+    const event = nodeType.slice(nodeType.lastIndexOf(".") + 1);
+    const out = ["## Connection requirements", ""];
+    if (byoa) {
+        out.push("**Requires a BYOA connection.** This event fires only on a BYOA " +
+            "(bring-your-own-app) connection — one created with your own OAuth app. " +
+            "On a standard connection the trigger deploys and never fires. Prepare " +
+            "the event on the connection you bind: it refuses a standard connection " +
+            "and records a BYOA one, and `check` and `compile` refuse this event on a " +
+            "connection that was never checked (`EVENT_BYOA_UNVERIFIED`).");
+        out.push("");
+        out.push("```bash");
+        out.push(prepareCommand(key, event, "--connection-id", "<id>"));
+        out.push("uip is connections list --byoa --all-folders   # the BYOA connections");
+        out.push("```");
+        out.push("");
+    }
+    if (webhook) {
+        out.push("**Register the webhook URL.** The connector's app delivers these events " +
+            "to a URL Integration Service issues. After deploying, copy the trigger's " +
+            "webhook URL into the app's event-subscription settings; `registry prepare` " +
+            "prints the connector's own instructions.");
+        out.push("");
+    }
+    return out;
+}

package/dist/registry/library-build/events.d.ts

@@ -48,15 +48,43 @@ export declare function normalizeBucketFields(parameters: unknown): Dict[];
  * survives the merge.
  */
 export declare function unionEventParameters(declared: unknown, objectParameters: unknown): Dict[];
-/** `merge_describe_into_node`: fold a `triggers describe` answer into a registry trigger definition (a copy). */
-export declare function mergeDescribeIntoNode(node: Dict, describe: Dict, objectParameters?: unknown): Dict;
+/** The three event facts: the API's (PascalCase) spelling and the stored (camelCase) one. */
+declare const EVENT_FACTS: ReadonlyArray<readonly [string, "eventMode" | "byoaConnection" | "isWebhookUrlVisible"]>;
+/** The facts one source states, under their stored names; a fact the source does not state is absent. */
+export type StatedEventFacts = Partial<Record<(typeof EVENT_FACTS)[number][1], unknown>>;
+/**
+ * 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 declare function resolveEventFacts(objectRow: unknown, fallback: unknown): StatedEventFacts;
+/**
+ * `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 declare function mergeDescribeIntoNode(node: Dict, describe: Dict, objectParameters?: unknown, objectRow?: unknown): Dict;
 export interface EventFacts {
     eventMode: string;
     byoaConnection: boolean;
     isWebhookUrlVisible: boolean;
     textBlocks: string[];
 }
-/** `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 declare function eventFacts(node: Dict, objectRow: unknown): EventFacts;
 /**
  * `triggers_objects_cached`: cached `uip is triggers objects <key> <OPERATION>`,
@@ -106,3 +134,4 @@ export declare function expandGenericEvents(ctx: BuildContext, templates: Librar
  * input with curated events described in place.
  */
 export declare function resolveConnectorEvents(ctx: BuildContext, entries: LibraryEntry[]): Promise<[LibraryEntry[], LibraryEntry[]]>;
+export {};

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 ` +