@uipath/maestro-builder-sdk 6.14.4 → 6.15.0

package/dist/bpmn/bpmn-sdk.d.ts

@@ -216,6 +216,12 @@ export type BpmnNode = {
     key: string;
     eventName: string;
     version?: string;
+    /**
+     * The OBJECT a GENERIC event watches — a Data Fabric entity, a Salesforce or
+     * ServiceNow object, a Jira record type. Required for such an event and
+     * refused for a curated one, exactly as it is on the Flow subscription.
+     */
+    object?: string;
     /** Symbolic binding names, as `.connector()` takes them. */
     connection?: string;
     folder?: string;
@@ -1313,6 +1319,16 @@ export interface ConnectorEventOpts extends ActivityOpts {
     folderPath?: string;
     /** Pin the descriptor version, as `.connector()` does. */
     version?: string;
+    /**
+     * The OBJECT a GENERIC event watches (`record-created` and its kin on Data
+     * Fabric, Salesforce, ServiceNow, Jira). Such an event's library entry carries
+     * no default, so without this the node emits `objectName: ""`, validates, and
+     * watches nothing. A CURATED event has its object built in and refuses one here.
+     * `uip is triggers objects <connector> <EVENT> --connection-id <id>` lists what
+     * the bound connection exposes; `check` reports EVENT_GENERIC_NO_OBJECT and
+     * EVENT_OBJECT_NOT_GENERIC for the two ways to get it wrong.
+     */
+    object?: string;
     /**
      * The `where` scope narrowing the subscription, when the operation declares
      * parameters. `Library.eventParameterFields()` is the authority on which names an

package/dist/bpmn/bpmn-sdk.js

@@ -1513,6 +1513,7 @@ class ScopeBuilder {
             key: connector,
             eventName: event,
             version: opts.version,
+            object: opts.object,
             connection: opts.connection,
             folder: opts.folder,
             folderPath: opts.folderPath,
@@ -1558,6 +1559,7 @@ class ScopeBuilder {
             key: connector,
             eventName: event,
             version: opts.version,
+            object: opts.object,
             connection: opts.connection,
             folder: opts.folder,
             folderPath: opts.folderPath,

package/dist/bpmn/check-cli.js

@@ -3,32 +3,49 @@
  * check-cli — fast static validation of a <Name>.bpmn.ts (no output file).
  *
  * Usage:
- *   node --experimental-strip-types check-cli.js <bpmn.ts | BaseName> [--graph]
+ *   node --experimental-strip-types check-cli.js <bpmn.ts | BaseName> [--graph] \
+ *       [--library <library-json dir>] [--connectors-local <overlay dir>] [--bindings <bindings.json>]
  *
  * Exit 0 = clean; exit 1 = at least one error. Warnings print but do not fail.
  * `--graph` also prints the resolved wiring to stdout — every element with the flows
  * leaving it, implied edges marked — see graph.ts.
  */
+import { existsSync } from 'node:fs';
 import { reportDiagnostics, reportResult } from '../cli-result.js';
 import { resolveBpmnFile, loadBuiltBpmn } from './load.js';
 import { check } from './check.js';
 import { graphModel, renderGraph } from './graph.js';
+import { Bindings } from '../core/bindings.js';
+import { connectorCheckOpts, flagValue, openCliLibrary } from '../core/cli-library.js';
 import { runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
+/** Flags that take a value — their argument is never the source positional. */
+const VALUE_FLAGS = new Set(['--library', '--connectors-local', '--bindings']);
+/**
+ * The connector facts, resolved exactly as `compile-cli` resolves them, so the
+ * inner loop and the emit rung cannot disagree about a field, a lookup or a
+ * binding name. Silent when there is no library and no bindings.json — `check`
+ * stays a pure function of the built model then, as it always was.
+ */
+function bpmnCheckOpts(argv) {
+    const bindFile = flagValue(argv, '--bindings')
+        ?? (existsSync('bindings.json') ? 'bindings.json' : undefined);
+    return connectorCheckOpts(openCliLibrary(argv), bindFile ? new Bindings(bindFile) : undefined);
+}
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
-        console.error('usage: check <bpmn.ts | BaseName> [--graph]');
+        console.error('usage: check <bpmn.ts | BaseName> [--graph] [--library <dir>] [--connectors-local <dir>] [--bindings <file>]');
         return 2;
     }
     ensureTypeScriptRuntime();
     const graph = argv.includes('--graph');
-    const input = argv.find((a) => !a.startsWith('--'));
+    const input = argv.find((a, i) => !a.startsWith('--') && !VALUE_FLAGS.has(argv[i - 1]));
     if (input === undefined) {
-        console.error('usage: check <bpmn.ts | BaseName> [--graph]');
+        console.error('usage: check <bpmn.ts | BaseName> [--graph] [--library <dir>] [--connectors-local <dir>] [--bindings <file>]');
         return 2;
     }
     const built = await loadBuiltBpmn(resolveBpmnFile(input));
-    const diags = check(built);
+    const diags = check(built, bpmnCheckOpts(argv));
     reportDiagnostics(diags);
     if (graph) {
         // The graph goes to stdout and the diagnostics to stderr, so a reviewer can

package/dist/bpmn/check.d.ts

@@ -16,10 +16,24 @@
  * platform rule it corresponds to and how the two differ.
  */
 import { type BuiltBpmn } from './bpmn-sdk.js';
+import { type ConnectorCheckOpts } from '../core/connector-checks.js';
+import { type EventCheckOpts } from '../core/event-checks.js';
 export interface Diagnostic {
     level: 'error' | 'warning';
     code: string;
     message: string;
     where?: string;
 }
-export declare function check(built: BuiltBpmn): Diagnostic[];
+/**
+ * The facts this check cannot derive from the built model.
+ *
+ * Everything here comes from the connector library and the project's
+ * `bindings.json`, and every rule that reads one fails OPEN without it: `check`
+ * stays the fast inner-loop rung and a BPMN process with no connectors needs no
+ * library at all. The CLIs supply the bag (`bpmn/check-cli.ts`), from the same
+ * `Library` instance `compile` serializes against, so the two rungs cannot
+ * disagree about a field or a binding name.
+ */
+export interface BpmnCheckOpts extends ConnectorCheckOpts, EventCheckOpts {
+}
+export declare function check(built: BuiltBpmn, opts?: BpmnCheckOpts): Diagnostic[];

package/dist/bpmn/check.js

@@ -16,8 +16,10 @@
  * platform rule it corresponds to and how the two differ.
  */
 import { nodeDeclaredVars } from './bpmn-sdk.js';
-import { folderCompanionKeys, implicitNodeVars, processId } from './serialize.js';
+import { allNodes, folderCompanionKeys, implicitNodeVars, processId } from './serialize.js';
 import { KNOWN_METHOD_SET } from './known-methods.js';
+import { EQUALS_EXPR_DIALECT, checkConnectorContract, checkConnectorLookups, checkConnectorSchema, checkBindingLabels, } from '../core/connector-checks.js';
+import { checkEventResolution, checkEventSubscription, eventParamsFor, } from '../core/event-checks.js';
 import { bindingRequiredFields, missingRequiredContext, missingRequiredInputs, registryType, REGISTRY_GAPS, unsatisfiableRequiredInputs, } from './typed-node.js';
 /**
  * Service types the platform expects to name a concrete Orchestrator resource.
@@ -57,7 +59,7 @@ const GATEWAY_KINDS = new Set(['exclusiveGateway', 'parallelGateway', 'inclusive
  * connector's failure is the commonest error-handling shape there is.
  */
 const ACTIVITY_KINDS = new Set(['task', 'scriptTask', 'subProcess', 'connector', 'typed', 'connectorEvent', 'externalTask']);
-export function check(built) {
+export function check(built, opts = {}) {
     const diags = [];
     if (!built.id)
         diags.push({ level: 'error', code: 'NO_ID', message: 'bpmn() requires an id.' });
@@ -69,8 +71,73 @@ export function check(built) {
     checkFolderBindings(built, diags);
     checkEntryPointId(built, diags);
     checkMethodParentheses(built, diags);
+    checkConnectors(built, opts, diags);
+    checkConnectorEvents(built, opts, diags);
     return diags;
 }
+/**
+ * The library-backed connector rules, shared with Flow (`core/connector-checks.ts`).
+ *
+ * BPMN had none of these: a `.connector()` node carrying an unresolved `lookup()`,
+ * an object with no materialized schema, or a connection label that answers with
+ * its own name reached `compile` unremarked, and the author found out from `uip
+ * maestro bpmn validate`, a tenant, or a faulted run. The `skill-bpmn-e2e-
+ * customer-escalation-triage` card in `flow-v2-run-8` packed a `bindings_v2.json`
+ * carrying the literal strings `jiraConnection` and `slackConnection` where
+ * connection ids belong — BINDING_SELF_NAME, had anything been asking.
+ *
+ * Sub-processes are walked too: a connector inside one resolves against the same
+ * library and binds through the same file.
+ */
+function checkConnectors(built, opts, diags) {
+    for (const n of allNodes(built.nodes)) {
+        if (n.kind !== 'connector')
+            continue;
+        const where = `Connector task "${n.id}"`;
+        const report = (d) => {
+            diags.push({ level: d.level, code: d.code, message: d.message, where });
+        };
+        checkConnectorLookups(where, n, opts, EQUALS_EXPR_DIALECT, report);
+        checkConnectorSchema(where, n, opts, EQUALS_EXPR_DIALECT, report);
+        checkConnectorContract(where, n, opts, report);
+    }
+}
+/**
+ * The connector-EVENT rules, shared with Flow (`core/event-checks.ts`).
+ *
+ * Those functions duck-type the subscription — `{ connector, event, where,
+ * object, version, connection }` — so the adapter is naming: BPMN calls the
+ * connector `key`, the event `eventName`, and the subscription scope `filter`.
+ *
+ * `filters` is deliberately absent. Payload filtering is a Flow surface; a BPMN
+ * connector event carries none, so the `EVENT_FILTER_*` family never fires here.
+ * The rules that do are the ones about the SUBSCRIPTION — whether it resolves at
+ * all, whether a generic event named its object, and whether its scope names
+ * parameters the operation actually declares. `skill-bpmn-outlook-waitfor-email`
+ * in `flow-v2-run-8` failed on that last one.
+ */
+function checkConnectorEvents(built, opts, diags) {
+    for (const n of allNodes(built.nodes)) {
+        if (n.kind !== 'connectorEvent')
+            continue;
+        const where = `${n.subscribe === 'trigger' ? 'Event trigger' : 'waitForEvent'} "${n.id}"`;
+        const subscription = {
+            connector: n.key,
+            event: n.eventName,
+            ...(n.version !== undefined ? { version: n.version } : {}),
+            ...(n.object !== undefined ? { object: n.object } : {}),
+            ...(n.filter !== undefined ? { where: n.filter } : {}),
+            ...(n.connection !== undefined ? { connection: n.connection } : {}),
+        };
+        const at = (level) => (code, message) => {
+            diags.push({ level, code, message, where });
+        };
+        const params = eventParamsFor(subscription, opts);
+        checkEventSubscription(subscription, where, at('error'), at('warning'), params);
+        checkEventResolution(subscription, where, n.subscribe, opts, at('error'), at('warning'), params);
+        checkBindingLabels(where, n, opts, (code, message) => diags.push({ level: 'error', code, message, where }), { key: n.key, action: n.eventName });
+    }
+}
 /**
  * A known method NAMED but not CALLED — `=vars.s.ToUpper` where `ToUpper()` was meant.
  *

package/dist/bpmn/compile-cli.js

@@ -3,23 +3,28 @@
  * compile-cli — <Name>.bpmn.ts → <Name>.bpmn
  *
  * Usage:
- *   node --experimental-strip-types compile-cli.js <bpmn.ts | BaseName> [-o out.bpmn]
+ *   node --experimental-strip-types compile-cli.js <bpmn.ts | BaseName> [-o out.bpmn] \
+ *       [--library <library-json dir>] [--connectors-local <overlay dir>] [--bindings <bindings.json>]
+ *
+ * --library defaults to $FLOW_SDK_LIBRARY_JSON, else the shared cache `registry
+ * pull` fills; --connectors-local defaults to ./connectors-local when it has an
+ * index.json, the directory `registry prepare` writes; --bindings to
+ * ./bindings.json when present.
  *
  * Runs the fast static check first; if it passes, serializes to Maestro `.bpmn`
  * XML (semantic-only — no diagram). The authoritative deploy gate is
  * `uip maestro bpmn validate`; a separate "tidy" step lays the diagram out.
  */
 import { reportResult } from '../cli-result.js';
-import { writeFileSync, existsSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
+import { writeFileSync } from 'node:fs';
+import { basename, resolve } from 'node:path';
 import { resolveBpmnFile, loadBuiltBpmn } from './load.js';
 import { serialize } from './serialize.js';
 import { check } from './check.js';
-import { Library } from '../core/library.js';
 import { Bindings } from '../core/bindings.js';
+import { connectorCheckOpts, openCliLibrary } from '../core/cli-library.js';
 import { runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
-import { resolveLibraryDir } from '../registry/cache.js';
 import { defaultBindingsFile } from '../workdir.js';
 function opt(argv, name) {
     const i = argv.indexOf(name);
@@ -27,10 +32,10 @@ function opt(argv, name) {
 }
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
-        console.error('usage: compile <bpmn.ts | BaseName> [-o out.bpmn]');
+        console.error('usage: compile <bpmn.ts | BaseName> [-o out.bpmn] [--library <dir>] [--connectors-local <dir>] [--bindings <file>]');
         return 2;
     }
-    const flags = new Set(['-o', '--library', '--bindings']);
+    const flags = new Set(['-o', '--library', '--connectors-local', '--bindings']);
     const pos = argv.find((a, i) => !flags.has(a) && !flags.has(argv[i - 1]));
     if (!pos) {
         console.error('compile: missing <bpmn.ts | BaseName>');
@@ -39,19 +44,24 @@ export async function run(argv) {
     const file = resolveBpmnFile(pos);
     ensureTypeScriptRuntime();
     const built = await loadBuiltBpmn(file);
-    const diags = check(built);
+    // Connector service tasks resolve against the library, through the same helper
+    // Flow and Case use — which also picks up the `connectors-local/` overlay that
+    // `uip maestro registry prepare` writes. BPMN used to construct the library
+    // without it, so a prepare resolved an operation against the live connection,
+    // wrote the overlay, and compile ignored it.
+    const library = openCliLibrary(argv);
+    const bindFile = opt(argv, '--bindings') ?? defaultBindingsFile();
+    const bindings = new Bindings(bindFile);
+    // The same facts `check-cli` runs on, from the instance about to serialize:
+    // the inner loop and the emit rung must not disagree about a field or a
+    // binding name, which is only guaranteed if they ask the same library.
+    const diags = check(built, connectorCheckOpts(library, bindFile ? bindings : undefined));
     for (const d of diags)
         console.error(`  ${d.level === 'error' ? '✗' : '⚠'} [${d.code}] ${d.message}`);
     if (diags.some((d) => d.level === 'error')) {
         console.error(`compile: ${diags.filter((d) => d.level === 'error').length} error(s); not emitting.`);
         return 1;
     }
-    // Connector service tasks resolve against the library (like Flow's/Case's
-    // compile-cli); load it only when present, and bindings.json alongside the .ts.
-    const libDir = resolveLibraryDir(opt(argv, '--library'));
-    const library = libDir && existsSync(join(libDir, 'index.json')) ? new Library(libDir) : undefined;
-    const bindFile = opt(argv, '--bindings') ?? defaultBindingsFile();
-    const bindings = new Bindings(bindFile);
     const xml = await serialize(built, { library, bindings });
     const base = basename(file).replace(/\.bpmn\.ts$|\.ts$/, '');
     const out = opt(argv, '-o') ?? `${base}.bpmn`;

package/dist/bpmn/connector.js

@@ -1,6 +1,7 @@
 import { connectorOutputVars } from './bpmn-sdk.js';
 import { transportHttpMethod } from '../config.js';
-import { refuseLookupToken } from '../core/lookups.js';
+import { EQUALS_EXPR_DIALECT } from '../core/connector-checks.js';
+import { buildConnectorInputs } from '../core/connector-inputs.js';
 export function createConnectorTask(ctx, n) {
     const { m } = ctx;
     if (!ctx.library)
@@ -54,21 +55,35 @@ export function createConnectorTask(ctx, n) {
     // resolved field (`operation.parameters` for path/query, the multipart `file` part),
     // and an input the library does not declare goes to the body, where an untagged
     // input has always gone.
-    const fieldsByName = new Map(rc.fields.map((f) => [f.name, f]));
+    // The ROUTING is the shared validator's (`core/connector-inputs.ts`), the one
+    // Flow's serializer and both families' `check` already run: it reports a missing
+    // required field, an unknown or mistyped input, and — the reason BPMN could not
+    // keep its own fourteen-line version — swaps a `lookup()` token for the id
+    // `registry prepare --resolve` recorded. BPMN used to refuse a token outright,
+    // so `skill-bpmn-paginated-reference-lookup` could resolve a Slack channel id
+    // and then emit a process that did not carry it. The values need no lowering:
+    // a BPMN input is already a plain value or an `=`-expression string.
+    const slots = buildConnectorInputs(rc, n.inputs ?? {}, {
+        dialect: EQUALS_EXPR_DIALECT,
+        resolutions: ctx.library.lookupResolutions,
+        lookups: typeof ctx.library.lookupSpecs === 'function'
+            ? ctx.library.lookupSpecs(n.key, n.action, n.version, n.object)
+            : {},
+    });
     const paramRows = [];
-    const body = {};
-    for (const [name, value] of Object.entries(n.inputs ?? {})) {
-        // BPMN copies these values into the emitted rows verbatim, so an unresolved
-        // lookup would ship as `{"__lookup": …}` where the connector wants an id.
-        // Only Flow reads connectors-local/resolutions.json today.
-        refuseLookupToken(value, 'bpmn', name);
-        const location = fieldsByName.get(name)?.location ?? 'body';
-        if (location === 'body') {
-            body[name] = value;
-            continue;
-        }
-        paramRows.push(paramInput(m, name, location, value));
+    for (const [name, value] of Object.entries(slots.pathParameters ?? {})) {
+        paramRows.push(paramInput(m, name, 'path', value));
+    }
+    for (const [name, value] of Object.entries(slots.queryParameters ?? {})) {
+        paramRows.push(paramInput(m, name, 'query', value));
+    }
+    // A multipart CONTAINER part is valueless by design — the runtime composes it
+    // from the body — so only the parts the author filled become rows.
+    for (const part of slots.multipartParameters ?? []) {
+        if (part.value !== undefined)
+            paramRows.push(paramInput(m, part.name, 'multipart', part.value));
     }
+    const body = slots.bodyParameters ?? {};
     // ── outputs — response schema + standard Error ──
     const responseSchema = rc.entry.outputSchema
         ? schemaFromFields(rc.entry.outputSchema.fields ?? [])

package/dist/bpmn/intsvc.js

@@ -58,7 +58,7 @@ export function createConnectorEvent(ctx, n) {
     if (!ctx.library)
         throw new Error(`connector event "${n.id}" needs the connector library — pass { library } to serialize ` +
             `or use uip maestro bpmn compile --library.`);
-    const rc = ctx.library.resolveEvent(n.subscribe, n.key, n.eventName, n.version);
+    const rc = ctx.library.resolveEvent(n.subscribe, n.key, n.eventName, n.version, n.object);
     const op = (rc.entry.operation ?? {});
     const runtime = rc.entry.runtime ?? {};
     const type = runtime.serviceType;
@@ -91,7 +91,10 @@ export function createConnectorEvent(ctx, n) {
         folderPath: n.folderPath ?? '/Shared',
         folderKey: `=bindings.${folder.id}`,
         operation: op.eventOperation ?? '',
-        objectName: op.objectName ?? '',
+        // A GENERIC event's library entry names no object — the author's is the only
+        // one there is, and without it the node emits `objectName: ""`, validates,
+        // and watches nothing. A curated entry carries its own and the author passes none.
+        objectName: n.object ?? op.objectName ?? '',
     };
     if (n.filter !== undefined)
         inputs.filter = n.filter;

package/dist/bpmn/serialize.d.ts

@@ -90,3 +90,5 @@ export declare function folderCompanionKeys(built: BuiltBpmn, sink: Map<string,
  * An explicit `elementId` always wins, and `null` still means "write none".
  */
 export declare function publicDeclarationScope(nodes: BpmnNode[], processId: string): (v: BpmnVarDecl) => string;
+/** Flatten a scope's nodes (recursing sub-processes) for global scans. */
+export declare function allNodes(nodes: BpmnNode[]): BpmnNode[];

package/dist/bpmn/serialize.js

@@ -932,7 +932,7 @@ function isIntsvcConnectorNode(n) {
     return n.kind === 'typed' && (n.type === 'Intsvc.ActivityExecution' || n.type === 'Intsvc.AsyncExecution');
 }
 /** Flatten a scope's nodes (recursing sub-processes) for global scans. */
-function allNodes(nodes) {
+export function allNodes(nodes) {
     const out = [];
     for (const n of nodes) {
         out.push(n);

package/dist/case/compile-cli.js

@@ -17,10 +17,9 @@ import { resolveCaseFile, loadBuiltCase } from './load.js';
 import { serialize } from './serialize.js';
 import { check } from './check.js';
 import { entryPointIO } from './entry-points.js';
-import { Library } from '../core/library.js';
 import { Bindings } from '../core/bindings.js';
-import { resolveLibraryDir } from '../registry/cache.js';
-import { defaultBindingsFile, defaultOverlayDir } from '../workdir.js';
+import { openCliLibrary } from '../core/cli-library.js';
+import { defaultBindingsFile } from '../workdir.js';
 import { runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 import { CASE_FORMAT_PROFILE } from './format-profile.js';
@@ -54,12 +53,10 @@ export async function run(argv) {
     // bindings.json from alongside the case when present. Resolved through the same
     // helper Flow and BPMN use, so `registry pull` serves all three families —
     // reading the env directly skipped the shared cache, and a Case that compiled
-    // fine right after a pull on Flow failed here for no visible reason.
-    const libDir = resolveLibraryDir(opt(argv, '--library'));
-    // A `prepare-connector` overlay, auto-detected next to the case (like bindings.json).
-    const overlayDir = opt(argv, '--connectors-local')
-        ?? defaultOverlayDir();
-    const library = libDir && existsSync(join(libDir, 'index.json')) ? new Library(libDir, { overlayDir }) : undefined;
+    // fine right after a pull on Flow failed here for no visible reason. The helper
+    // also auto-detects the `connectors-local/` overlay `registry prepare` writes,
+    // which is what the three copies of these lines used to each decide for itself.
+    const library = openCliLibrary(argv);
     const bindFile = opt(argv, '--bindings') ?? defaultBindingsFile();
     const bindings = new Bindings(bindFile);
     const caseplan = serialize(built, { library, bindings });

package/dist/case/serialize.js

@@ -14,7 +14,7 @@ import { refuseLookupToken } from '../core/lookups.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { resolveSchemaVersion } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors, } from './preserve.js';
-import { readEventFilter, eventFilterProblem, eventFilterTreeLeaf } from '../event-filters.js';
+import { readEventFilter, eventFilterProblem, eventFilterTreeLeaf } from '../core/event-filters.js';
 /**
  * Condition `displayName` allocator.
  *

package/dist/check-cli.js

@@ -9,7 +9,7 @@ import { reportDiagnostics } from './cli-result.js';
 import { defaultBindingsFile } from './workdir.js';
 import { resolveFlowFile, loadBuiltFlow } from './load.js';
 import { check } from './check.js';
-import { byoaCheckOpts, eventResolveErrorFor, openCliLibrary } from './cli-library.js';
+import { connectorCheckOpts, openCliLibrary } from './core/cli-library.js';
 import { Bindings } from './bindings.js';
 import { connectorInputErrors } from './serialize.js';
 import { runWhenInvokedDirectly } from './cli-run.js';
@@ -37,41 +37,13 @@ function checkOpts(argv) {
     // lives in it, and without it every already-resolved lookup would be reported
     // as still owed — telling the author to re-run a `prepare` they already ran.
     const library = openCliLibrary(argv);
+    // The connector and event hooks are the shared bag every family fills
+    // (`core/cli-library.ts`); what Flow adds is the one hook only it has a site for.
+    const shared = connectorCheckOpts(library, bindings);
     if (!library)
-        return bindings ? { bindings } : {};
+        return shared;
     return {
-        eventResolveError: eventResolveErrorFor(library),
-        ...byoaCheckOpts(library),
-        eventParams: (connector, event, object) => {
-            try {
-                return library.eventParameterFields(connector, event, object);
-            }
-            catch {
-                // An unresolvable operation is EVENT_UNKNOWN's business, reported from
-                // `eventResolveError` above; here it just means "unknown".
-                return undefined;
-            }
-        },
-        eventFilterFields: (connector, event, object) => {
-            try {
-                return library.eventFilterFields(connector, event, object);
-            }
-            catch {
-                return undefined; // unknown fails open, same as every callback here
-            }
-        },
-        lookups: (connector, action, version, object) => library.lookupSpecs(connector, action, version, object),
-        resolutions: library.lookupResolutions,
-        schemaReadiness: (connector, action, version, object) => {
-            try {
-                return library.schemaReadiness(connector, action, version, object);
-            }
-            catch {
-                // An unreadable entry means "unknown", and unknown fails open — the
-                // same rule as every other callback here.
-                return undefined;
-            }
-        },
+        ...shared,
         listEnvelope: (connector, operation, version, object) => {
             try {
                 return library.resolve(connector, operation, version, object).listEnvelope;
@@ -91,7 +63,6 @@ function checkOpts(argv) {
                 return undefined;
             }
         },
-        ...(bindings ? { bindings } : {}),
     };
 }
 export async function run(argv) {