@uipath/maestro-builder-sdk 6.36.1 → 6.37.0

package/dist/core/lookups.js

@@ -166,6 +166,39 @@ export function resolvedValue(token, resolutions) {
     const { nodeType, field, by, value } = token.__lookup;
     return resolutions[lookupKey(nodeType, field, by, value)]?.value;
 }
+/**
+ * The event form of a node type — `uipath.connector.event.<key>.<op>` — for one
+ * written without a role segment, else `undefined`. A role-less type is what the
+ * string form `lookup(key, action, field)` keys a token under.
+ */
+function eventFormOf(nodeType) {
+    const m = /^uipath\.connector\.(?!event\.|trigger\.)(.+)$/.exec(nodeType);
+    return m ? `uipath.connector.event.${m[1]}` : undefined;
+}
+/**
+ * {@link resolvedValue} for a token on an event's `where`.
+ *
+ * `prepare` records an event's resolutions under the EVENT form of the node type,
+ * which the descriptor form `lookup({ connector, event }, field)` keys a token
+ * under too. The string form `lookup(key, action, field)` cannot know it is being
+ * used on an event and keys the token under the activity form, so a recorded
+ * resolution was never found for it: on the 2026-10-16 run an author whose
+ * `prepare --resolve parentFolderId:displayName=Inbox` had succeeded still saw
+ * `LOOKUP_UNRESOLVED` from `check` and a refusal from `compile`, and pasted the
+ * id in by hand. The token's own key is tried first; the event form second.
+ *
+ * @param token - The unresolved lookup, from either `lookup()` form.
+ * @param resolutions - Everything `prepare --resolve` has recorded.
+ * @returns The connector-facing id, when either key was resolved.
+ */
+export function resolvedEventValue(token, resolutions) {
+    const own = resolvedValue(token, resolutions);
+    if (own !== undefined)
+        return own;
+    const { nodeType, field, by, value } = token.__lookup;
+    const eventForm = eventFormOf(nodeType);
+    return eventForm === undefined ? undefined : resolutions[lookupKey(eventForm, field, by, value)]?.value;
+}
 /**
  * The message for a lookup nothing has resolved — the command that fixes it.
  *
@@ -282,7 +315,7 @@ export function resolveEventWhere(where, resolutions, site) {
             out[key] = value;
             continue;
         }
-        const resolved = resolvedValue(value, resolutions);
+        const resolved = resolvedEventValue(value, resolutions);
         if (resolved === undefined)
             throw new Error(`${site}: \`where.${key}\` ` + unresolvedLookupMessage(value));
         out[key] = resolved;

package/dist/core/synthesized-definition.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The one refusal Flow adds on top of `Library.resolve`: an operation whose
+ * sidecar `registry prepare` synthesized from Integration Service
+ * (`prepare/integration-service.ts`) has no registry node behind it. A BPMN
+ * `sendTask` carries its own identity and rows, so BPMN compiles it; a Flow
+ * node embeds the registry's whole definition — form, handles, model — which
+ * no describe supplies, so Flow refuses it here, in `check` and `compile`
+ * alike, instead of emitting a node the designer cannot open.
+ */
+import { ConnectorResolveError } from './connector-resolve-error.js';
+import type { ResolvedConnector } from './library.js';
+/** The marker `prepare` writes on a sidecar it built from Integration Service. */
+export declare const SYNTHESIZED_FROM_INTEGRATION_SERVICE = "integration-service";
+/** Flow's refusal for a resolved operation with no registry definition, or `undefined` when it has one. */
+export declare function synthesizedDefinitionRefusal(rc: Pick<ResolvedConnector, 'v1def' | 'connectorKey' | 'nodeType'>): ConnectorResolveError | undefined;

package/dist/core/synthesized-definition.js

@@ -0,0 +1,22 @@
+/**
+ * The one refusal Flow adds on top of `Library.resolve`: an operation whose
+ * sidecar `registry prepare` synthesized from Integration Service
+ * (`prepare/integration-service.ts`) has no registry node behind it. A BPMN
+ * `sendTask` carries its own identity and rows, so BPMN compiles it; a Flow
+ * node embeds the registry's whole definition — form, handles, model — which
+ * no describe supplies, so Flow refuses it here, in `check` and `compile`
+ * alike, instead of emitting a node the designer cannot open.
+ */
+import { ConnectorResolveError } from './connector-resolve-error.js';
+/** The marker `prepare` writes on a sidecar it built from Integration Service. */
+export const SYNTHESIZED_FROM_INTEGRATION_SERVICE = 'integration-service';
+/** Flow's refusal for a resolved operation with no registry definition, or `undefined` when it has one. */
+export function synthesizedDefinitionRefusal(rc) {
+    const origin = rc.v1def?.synthesizedFrom;
+    if (origin !== SYNTHESIZED_FROM_INTEGRATION_SERVICE)
+        return undefined;
+    const action = String(rc.nodeType).replace(/^uipath\.connector\.[^.]+\./, '');
+    return new ConnectorResolveError('CONNECTOR_NO_FLOW_DEFINITION', `connector ${rc.connectorKey} ${action} was prepared from Integration Service because the Flow node catalog serves no node for ${rc.connectorKey}; `
+        + 'a Flow step or inline agent tool needs that node (its form, handles and model), so this operation compiles in BPMN only. '
+        + `Author it as a BPMN .connector(), or check \`uip maestro flow registry search ${rc.connectorKey}\` after \`registry pull --force\` in case the catalog has since gained it.`);
+}

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

@@ -130,4 +130,20 @@ export declare function isResourcesList(ctx: BuildContext, connectorKey: string,
  * files are deliberately not reused: that output omitted the discovery
  * capabilities and would silently mark every connector static.
  */
+/** `uip is activities list`'s answer: its rows, or why it could not be read. */
+export type IsActivitiesCatalog = {
+    rows: unknown[];
+} | {
+    failure: string;
+};
+/**
+ * Cached `uip is activities list <key>`: the connector's activity catalog
+ * (every row, curated or not — the caller filters on `IsCurated`), or the
+ * failure in the CLI's own words ({@link failureReason}): a refusal, output
+ * that is not JSON, or a `Result: Failure` envelope (an expired token, a 5xx,
+ * a connector the tenant has not enabled). Cached beside the `is resources`
+ * payloads — it is the same catalog service, read without a connection — and
+ * a cached failure keeps its reason.
+ */
+export declare function isActivitiesCatalog(ctx: BuildContext, connectorKey: string): Promise<IsActivitiesCatalog>;
 export declare function isConnectorGet(ctx: BuildContext, connectorKey: string): Promise<unknown>;

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

@@ -16,7 +16,7 @@
 import { createHash } from "node:crypto";
 import { pyJsonStringify } from "../codecs/pyjson.js";
 import { sortedByKeys } from "../compat/compare.js";
-import { isConnectorsMetadata, isResourcesDescribeObject, isResourcesDescribeOperation, isResourcesList as isResourcesListArgv, registryGet as registryGetArgv, } from "../uip/commands.js";
+import { isActivitiesList as isActivitiesListArgv, isConnectorsMetadata, isResourcesDescribeObject, isResourcesDescribeOperation, isResourcesList as isResourcesListArgv, registryGet as registryGetArgv, } from "../uip/commands.js";
 import { CACHED_FAILURE, isCachedFailure, safeCacheName } from "../uip/response-cache.js";
 import { failureReason, isNodeNotFound } from "../uip/envelope.js";
 import { get, isPyDict, pyOr, pyTruthy } from "./py.js";
@@ -251,11 +251,38 @@ export async function isResourcesList(ctx, connectorKey, options = {}) {
     return Array.isArray(payload.Data) ? payload.Data : undefined;
 }
 /**
- * `is_connector_get`: cached `uip is connectors metadata <key>`, answering the
- * first element of `Data` or `undefined`. The legacy `connectors get` cache
- * files are deliberately not reused: that output omitted the discovery
- * capabilities and would silently mark every connector static.
+ * Cached `uip is activities list <key>`: the connector's activity catalog
+ * (every row, curated or not — the caller filters on `IsCurated`), or the
+ * failure in the CLI's own words ({@link failureReason}): a refusal, output
+ * that is not JSON, or a `Result: Failure` envelope (an expired token, a 5xx,
+ * a connector the tenant has not enabled). Cached beside the `is resources`
+ * payloads — it is the same catalog service, read without a connection — and
+ * a cached failure keeps its reason.
  */
+export async function isActivitiesCatalog(ctx, connectorKey) {
+    const name = `${safeCacheName(connectorKey, "_activities_list")}.json`;
+    if (ctx.caches.is.has(name)) {
+        const cached = ctx.caches.is.read(name);
+        const data = get(cached, "Data");
+        if (Array.isArray(data))
+            return { rows: data };
+        return { failure: String(pyOr(get(cached, "Message"), "the cached answer carries no rows")) };
+    }
+    const result = await runUip(ctx, isActivitiesListArgv(connectorKey));
+    if (refused(result))
+        return { failure: failureReason(result) };
+    const parsed = parseStdout(result.stdout);
+    if (parsed === undefined)
+        return { failure: failureReason(result) };
+    const payload = envelope(parsed);
+    if (get(payload, "Result") !== "Success") {
+        const failure = failureReason(result);
+        writeCache(ctx.caches.is, name, { Result: "Failure", Message: failure, [CACHED_FAILURE]: true });
+        return { failure };
+    }
+    writeCache(ctx.caches.is, name, payload);
+    return Array.isArray(payload.Data) ? { rows: payload.Data } : { failure: "the answer carries no Data rows" };
+}
 export async function isConnectorGet(ctx, connectorKey) {
     const name = `${safeCacheName(connectorKey, "_connector_metadata")}.json`;
     const firstRow = (payload) => {

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

@@ -56,6 +56,21 @@ export interface RegistryCatalog {
      */
     failure?: string;
 }
+/** Whether `registry pull --force` refreshed the local catalog copy, or why not. */
+export type RegistryRefresh = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * `uip maestro flow registry pull --force`: refresh the local catalog copy the
+ * probes and the search answer from. It never refreshes itself, so before
+ * `prepare` concludes that the catalog serves nothing for a connector it pulls
+ * once and looks again; a stale copy would otherwise send a connector the
+ * catalog does serve down the BPMN-only path, and state it as fact.
+ */
+export declare function refreshRegistryCatalog(client: UipClient, timeoutMs?: number): Promise<RegistryRefresh>;
 /**
  * `registry search <key>`, read for both catalogs. This runs only on the
  * failure path, to tell the author what the catalog does serve.

package/dist/registry/prepare/actions.js

@@ -18,7 +18,7 @@
  */
 import { compareCodePoints, sortedStrings } from "../compat/compare.js";
 import { editDistance } from "../../core/edit-distance.js";
-import { registrySearch } from "../uip/commands.js";
+import { registryPull, registrySearch } from "../uip/commands.js";
 import { failureReason, findJsonDocument, tail } from "../uip/envelope.js";
 import { isPlainObject, pyOr } from "./support.js";
 /**
@@ -141,6 +141,17 @@ export function registryEventIds(payload, connectorKey) {
         forms: ["trigger", "event"].filter((form) => forms.get(id).has(form)),
     }));
 }
+/**
+ * `uip maestro flow registry pull --force`: refresh the local catalog copy the
+ * probes and the search answer from. It never refreshes itself, so before
+ * `prepare` concludes that the catalog serves nothing for a connector it pulls
+ * once and looks again; a stale copy would otherwise send a connector the
+ * catalog does serve down the BPMN-only path, and state it as fact.
+ */
+export async function refreshRegistryCatalog(client, timeoutMs) {
+    const result = await client.run(registryPull(), timeoutMs === undefined ? undefined : { timeoutMs });
+    return result.code === 0 ? { ok: true } : { ok: false, reason: failureReason(result) };
+}
 /**
  * `registry search <key>`, read for both catalogs. This runs only on the
  * failure path, to tell the author what the catalog does serve.

package/dist/registry/prepare/integration-service.d.ts

@@ -0,0 +1,105 @@
+import { SYNTHESIZED_FROM_INTEGRATION_SERVICE } from "../../core/synthesized-definition.js";
+import { type BuildContext } from "../library-build/context.js";
+import type { LibraryEntry } from "../model/library.js";
+/** The marker a synthesized sidecar carries; Flow refuses a definition that has it. One owner, `core/`, so the writer and the refuser cannot drift. */
+export { SYNTHESIZED_FROM_INTEGRATION_SERVICE };
+/** One row of `uip is activities list`, the fields this module reads. */
+export interface IsActivity {
+    /** The activity's own name, PascalCase: `CreateTestSet`. */
+    name: string;
+    displayName: string;
+    description: string;
+    /** The IS object the activity addresses: `TestSet`. */
+    objectName: string;
+    /** The HTTP verb as the catalog spells it: `POST`, `GETBYID`, `PATCH`, … */
+    method: string;
+}
+/** Why the Integration Service path could not prepare the action. */
+export type IntegrationServiceMiss = 
+/** The catalog could not be listed (`reason`: the CLI's own words), or lists no curated activity (no `reason`). */
+{
+    kind: "no-catalog";
+    reason?: string;
+}
+/** The catalog lists curated activities, none of which is the action; their ids, for the refusal. */
+ | {
+    kind: "no-such-activity";
+    activities: string[];
+}
+/** The activity's HTTP method maps to no `is resources` verb, so there is no describe to read. */
+ | {
+    kind: "no-operation";
+    activity: IsActivity;
+}
+/** The activity exists but `is resources describe` returned no schema for it. */
+ | {
+    kind: "no-schema";
+    activity: IsActivity;
+    operation: string;
+};
+export interface IntegrationServicePrepared {
+    entry: LibraryEntry;
+    /**
+     * The action id the entry goes by: the activity's own name in kebab case,
+     * whatever spelling the author gave (`--action "Create Test Set"` prepares
+     * `create-test-set`). The overlay path and the handoff use it.
+     */
+    action: string;
+    /** The registry-shaped node `planLibrary` builds the sidecar from. */
+    node: Record<string, unknown>;
+    activity: IsActivity;
+    /** The `is resources` verb the describe was read under (`Create`, `Retrieve`, …). */
+    operation: string;
+}
+/**
+ * The action id an activity goes by: its PascalCase name in kebab case —
+ * `CreateTestSet` → `create-test-set`, `AssignTestCasesToReq` →
+ * `assign-test-cases-to-req`, `CreateV2Attachment` → `create-v2-attachment`.
+ * A run of capitals stays one word (`GetPDFReport` → `get-pdf-report`).
+ */
+export declare function activityActionId(name: string): string;
+/** The curated rows of an activities listing, in the catalog's order. */
+export declare function curatedActivities(rows: readonly unknown[]): IsActivity[];
+/**
+ * The curated activity an author's action names: by action id first
+ * (`create-test-set`), then by the activity's own name or display name,
+ * case-insensitively — `CreateTestSet`, `"Create Test Set"` and `create test set`
+ * all reach it. The spellings are compared both as given and in kebab case, so a
+ * display name with spaces matches whether or not the author kebab-cased it.
+ */
+export declare function matchActivity(activities: readonly IsActivity[], action: string): IsActivity | undefined;
+/** The `is resources` verb an activity's HTTP method reads under; `undefined` for a verb the catalog has no describe for. */
+export declare function describeOperationFor(method: string): string | undefined;
+/**
+ * Prepare one action from Integration Service: the entry and the node the
+ * sidecar is built from, or why not.
+ */
+export declare function integrationServiceEntry(ctx: BuildContext, input: {
+    connectorKey: string;
+    action: string;
+}): Promise<IntegrationServicePrepared | {
+    miss: IntegrationServiceMiss;
+}>;
+/**
+ * The library entry for one described activity — the shape `extractCanonical`
+ * writes from a registry node, filled from the describe instead: the IS
+ * object and verb, the path and its parameters, the request fields as the
+ * input schema. `httpMethod` keeps the catalog's spelling (`GETBYID` for a
+ * get-by-id, as registry entries do); the wire maps it. The entry goes by the
+ * activity's own action id, never the author's spelling: a display name would
+ * put spaces (or a `/`) in the overlay path and a second entry next to the id.
+ */
+export declare function synthesizeEntry(input: {
+    connectorKey: string;
+    activity: IsActivity;
+    operation: string;
+    described: Record<string, unknown>;
+    connector: unknown;
+}): LibraryEntry;
+/**
+ * The node `planLibrary` turns into the `.v1def.json` sidecar — the little a
+ * BPMN compile reads of one (`inputDefinition.fields` for the body, the model's
+ * type and service type) and the marker Flow refuses on. `buildV1Definition`
+ * keeps every key here.
+ */
+export declare function synthesizeNode(entry: LibraryEntry, described: Record<string, unknown>): Record<string, unknown>;

package/dist/registry/prepare/integration-service.js

@@ -0,0 +1,218 @@
+/**
+ * Prepare a connector operation the Flow node catalog does not serve, from
+ * Integration Service itself.
+ *
+ * `prepare` names an operation through `uip maestro flow registry get
+ * uipath.connector.<key>.<action>`: the registry node is the library entry's
+ * source and its `.v1def.json` sidecar. Some connectors have no node there at
+ * all, yet Integration Service serves them in full: `uip is activities list
+ * <key>` lists the curated activities with their object and HTTP method, and
+ * `uip is resources describe <key> <object> --operation <verb>` returns the
+ * path, the path/query parameters and the request and response fields. Told
+ * "op not in library", an author hand-fills `.activity('Intsvc.ActivityExecution')`
+ * tasks and gets the identity rows wrong.
+ *
+ * A BPMN connector task needs no registry node: the `sendTask` carries its own
+ * identity (`objectName`, `method`, `path`, `connectorKey`) and rows, which is
+ * exactly what the describe returns. So when the catalog serves NOTHING for the
+ * connector — not a misspelt action on a connector it does serve — this builds
+ * the library entry and a sidecar from the activity catalog and the describe,
+ * and the ordinary overlay write, descriptor regeneration and handoff follow.
+ * The sidecar is marked `synthesizedFrom: "integration-service"`: a Flow node
+ * embeds the registry's whole definition (form, handles, model), which no
+ * describe can supply, so Flow's compile and check refuse the entry with
+ * CONNECTOR_NO_FLOW_DEFINITION rather than emit a node the designer cannot open.
+ *
+ * Every `uip` call goes through the {@link BuildContext}; everything else is
+ * pure over the parsed replies.
+ */
+import { SCHEMA_VERSION, normalizeFieldKeys, pick } from "../library-build/canonical.js";
+import { SYNTHESIZED_FROM_INTEGRATION_SERVICE } from "../../core/synthesized-definition.js";
+import { isActivitiesCatalog, isConnectorGet, isDescribeOperation } from "../library-build/context.js";
+import { HTTP_METHOD_TO_OPERATION } from "../library-build/enrich.js";
+import { get, pyOr } from "../library-build/py.js";
+import { isPlainObject } from "./support.js";
+/** The marker a synthesized sidecar carries; Flow refuses a definition that has it. One owner, `core/`, so the writer and the refuser cannot drift. */
+export { SYNTHESIZED_FROM_INTEGRATION_SERVICE };
+/**
+ * The action id an activity goes by: its PascalCase name in kebab case —
+ * `CreateTestSet` → `create-test-set`, `AssignTestCasesToReq` →
+ * `assign-test-cases-to-req`, `CreateV2Attachment` → `create-v2-attachment`.
+ * A run of capitals stays one word (`GetPDFReport` → `get-pdf-report`).
+ */
+export function activityActionId(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+        .replace(/[\s_]+/g, "-")
+        .toLowerCase();
+}
+/** The curated rows of an activities listing, in the catalog's order. */
+export function curatedActivities(rows) {
+    const out = [];
+    for (const row of rows) {
+        if (!isPlainObject(row))
+            continue;
+        if (String(pyOr(get(row, "IsCurated"), "")).toLowerCase() !== "yes")
+            continue;
+        const name = String(pyOr(get(row, "Name"), "")).trim();
+        const objectName = String(pyOr(get(row, "ObjectName"), "")).trim();
+        const method = String(pyOr(get(row, "MethodName"), "")).trim().toUpperCase();
+        if (!name || !objectName || objectName === "N/A" || !method || method === "N/A")
+            continue;
+        out.push({
+            name,
+            displayName: String(pyOr(get(row, "DisplayName"), name)),
+            description: String(pyOr(get(row, "Description"), "")),
+            objectName,
+            method,
+        });
+    }
+    return out;
+}
+/**
+ * The curated activity an author's action names: by action id first
+ * (`create-test-set`), then by the activity's own name or display name,
+ * case-insensitively — `CreateTestSet`, `"Create Test Set"` and `create test set`
+ * all reach it. The spellings are compared both as given and in kebab case, so a
+ * display name with spaces matches whether or not the author kebab-cased it.
+ */
+export function matchActivity(activities, action) {
+    const wanted = action.trim().toLowerCase();
+    const wantedId = activityActionId(action.trim());
+    return (activities.find((a) => activityActionId(a.name) === wanted)
+        ?? activities.find((a) => a.name.toLowerCase() === wanted)
+        ?? activities.find((a) => a.displayName.trim().toLowerCase() === wanted)
+        ?? activities.find((a) => activityActionId(a.displayName) === wantedId));
+}
+/** The `is resources` verb an activity's HTTP method reads under; `undefined` for a verb the catalog has no describe for. */
+export function describeOperationFor(method) {
+    return HTTP_METHOD_TO_OPERATION.get(method.toUpperCase());
+}
+/**
+ * Prepare one action from Integration Service: the entry and the node the
+ * sidecar is built from, or why not.
+ */
+export async function integrationServiceEntry(ctx, input) {
+    const { connectorKey, action } = input;
+    const catalog = await isActivitiesCatalog(ctx, connectorKey);
+    if ("failure" in catalog)
+        return { miss: { kind: "no-catalog", reason: catalog.failure } };
+    const activities = curatedActivities(catalog.rows);
+    if (activities.length === 0)
+        return { miss: { kind: "no-catalog" } };
+    const activity = matchActivity(activities, action);
+    if (!activity)
+        return { miss: { kind: "no-such-activity", activities: activities.map((a) => activityActionId(a.name)) } };
+    // No guess for a method the table does not list: a describe read under the
+    // wrong verb returns another operation's path, and the entry would target it.
+    const operation = describeOperationFor(activity.method);
+    if (operation === undefined)
+        return { miss: { kind: "no-operation", activity } };
+    const described = await isDescribeOperation(ctx, connectorKey, activity.objectName, operation);
+    if (!isPlainObject(described))
+        return { miss: { kind: "no-schema", activity, operation } };
+    const connector = await isConnectorGet(ctx, connectorKey);
+    const entry = synthesizeEntry({ connectorKey, activity, operation, described, connector });
+    return { entry, action: activityActionId(activity.name), node: synthesizeNode(entry, described), activity, operation };
+}
+/**
+ * The library entry for one described activity — the shape `extractCanonical`
+ * writes from a registry node, filled from the describe instead: the IS
+ * object and verb, the path and its parameters, the request fields as the
+ * input schema. `httpMethod` keeps the catalog's spelling (`GETBYID` for a
+ * get-by-id, as registry entries do); the wire maps it. The entry goes by the
+ * activity's own action id, never the author's spelling: a display name would
+ * put spaces (or a `/`) in the overlay path and a second entry next to the id.
+ */
+export function synthesizeEntry(input) {
+    const { connectorKey, activity, operation, described, connector } = input;
+    const op = pyOr(pick(described, "Operation", "operation"), {});
+    const path = String(pyOr(pick(op, "Path", "path"), ""));
+    const method = String(pyOr(pick(op, "Method", "method"), activity.method)).toUpperCase();
+    const label = String(pyOr(pick(op, "Curated", "curated"), activity.displayName));
+    const parameters = normalizeFieldKeys(pyOr(pick(described, "Parameters", "parameters"), []));
+    const requestFields = normalizeFieldKeys(pyOr(pick(described, "RequestFields", "requestFields"), []));
+    const responseFields = normalizeFieldKeys(pyOr(pick(described, "ResponseFields", "responseFields"), []));
+    const connectorName = String(pyOr(get(connector, "Name"), connectorKey));
+    const icon = String(pyOr(get(connector, "Image"), ""));
+    const entry = {
+        schemaVersion: SCHEMA_VERSION,
+        nodeType: `uipath.connector.${connectorKey}.${activityActionId(activity.name)}`,
+        version: "1.0.0",
+        category: "connector",
+        tags: ["connector", "activity"],
+        connector: { key: connectorKey, name: connectorName },
+        operation: {
+            name: operation,
+            objectName: activity.objectName,
+            objectDisplayName: String(pyOr(pick(described, "DisplayName", "displayName"), activity.objectName)),
+            httpMethod: method,
+            path,
+            pathTemplate: path,
+            subType: "standard",
+            supportsStreaming: false,
+            activityType: "Curated",
+            parameters,
+        },
+        display: {
+            label,
+            description: activity.description || `(${connectorName}) ${label}`,
+            icon,
+            iconBackground: "",
+            iconBackgroundDark: "",
+            operationLabel: label,
+        },
+        runtime: {
+            bpmnType: "bpmn:SendTask",
+            serviceType: "Intsvc.ActivityExecution",
+            activityConfigurationVersion: "v1",
+            requiresConnection: true,
+            requiresFolderKey: true,
+            requiresConnectionForSchema: true,
+        },
+        inputSchema: { fields: requestFields },
+        outputSchema: { fields: responseFields },
+        provenance: {
+            source: SYNTHESIZED_FROM_INTEGRATION_SERVICE,
+            activity: activity.name,
+            method: activity.method,
+        },
+    };
+    return entry;
+}
+/**
+ * The node `planLibrary` turns into the `.v1def.json` sidecar — the little a
+ * BPMN compile reads of one (`inputDefinition.fields` for the body, the model's
+ * type and service type) and the marker Flow refuses on. `buildV1Definition`
+ * keeps every key here.
+ */
+export function synthesizeNode(entry, described) {
+    const e = entry;
+    const outputFields = normalizeFieldKeys(pyOr(pick(described, "ResponseFields", "responseFields"), []));
+    return {
+        nodeType: e.nodeType,
+        version: e.version,
+        category: e.category,
+        tags: e.tags,
+        display: { label: e.display.label, description: e.display.description, icon: e.display.icon },
+        model: {
+            type: "bpmn:SendTask",
+            serviceType: "Intsvc.ActivityExecution",
+            bindings: { resource: "connection", propertyAttribute: "ConnectionId" },
+            context: [
+                { name: "connectorKey", value: e.connector.key },
+                { name: "objectName", value: e.operation.objectName },
+                { name: "operation", value: e.operation.name },
+                { name: "method", value: e.operation.httpMethod },
+                { name: "path", value: e.operation.path },
+                { name: "connection", value: "" },
+                { name: "folderKey", value: "" },
+                { name: "activityConfigurationVersion", value: "v1" },
+            ],
+        },
+        inputDefinition: { fields: e.inputSchema.fields },
+        outputDefinition: { output: { fields: outputFields }, error: {} },
+        synthesizedFrom: SYNTHESIZED_FROM_INTEGRATION_SERVICE,
+    };
+}

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

@@ -21,7 +21,8 @@
  *     `core/cli-spelling.ts`) without this module reading the environment.
  */
 import { Refusal } from "../errors.js";
-import { type RegistryCatalog } from "./actions.js";
+import { type RegistryCatalog, type RegistryRefresh } from "./actions.js";
+import type { IntegrationServiceMiss } from "./integration-service.js";
 export declare const PREFIX = "prepare-connector: ";
 /** The spelling the Python hard-coded into every pasteable re-run. */
 export declare const PREPARE_COMMAND = "npx flow-sdk registry prepare";
@@ -101,6 +102,10 @@ export declare function unresolvedOperationMessage(input: {
     name: string;
     probes: readonly ProbeMiss[];
     catalog: RegistryCatalog;
+    /** What Integration Service said, when the catalog served nothing for the connector and IS was asked instead. */
+    integrationService?: IntegrationServiceMiss;
+    /** Whether the catalog was refreshed before that conclusion. */
+    registryRefresh?: RegistryRefresh;
 }): string;
 /**
  * A `registry get` probe failed for a reason other than "Node not found" — an
@@ -133,6 +138,41 @@ export declare function inputFieldNote(count: number | undefined | null): string
 export declare function tsNote(jsonOnly: boolean, connectorKey: string): string;
 /** The action path's success line. */
 export declare function preparedSummaryLine(nodeType: string, out: string, ts: string, variants: number, fieldNote: string): string;
+/**
+ * "The catalog serves no node for <key>", worded by what was measured: a fact
+ * after a forced pull, the local copy's answer when the pull failed or did not
+ * run (`registry get` and `registry search` answer from a copy that never
+ * refreshes itself).
+ */
+export declare function catalogServesNothingPhrase(key: string, refresh: RegistryRefresh | undefined): string;
+/** The progress line before the one `registry pull --force` the fallback runs. */
+export declare function refreshingCatalogLine(key: string): string;
+/** The warning when that pull failed; the fallback continues against the local copy. */
+export declare function catalogRefreshFailedLine(reason: string): string;
+/** The note when the author's `--action` spelling was not the entry's id. */
+export declare function actionCanonicalizedLine(given: string, actionId: string): string;
+/**
+ * What Integration Service serves when the Flow catalog serves nothing for a
+ * connector: the curated activities' action ids, so the author re-runs with
+ * one of them, or why the one they named could not be read.
+ */
+export declare function integrationServiceLines(key: string, name: string, miss: IntegrationServiceMiss, refresh?: RegistryRefresh): string[];
+/** The action path's source line when Integration Service supplied the entry. */
+export declare function preparedFromIntegrationServiceLine(key: string, activity: {
+    name: string;
+    objectName: string;
+    method: string;
+}, refresh?: RegistryRefresh): string;
+/**
+ * The pasteable BPMN call for an operation prepared from Integration Service —
+ * the only family that compiles it, so the Flow import handoff is not printed
+ * for it. Required inputs are named with their type; the rest are left to the
+ * descriptor the overlay carries.
+ */
+export declare function bpmnConnectorUsageLines(connectorKey: string, action: string, required: ReadonlyArray<{
+    name: string;
+    type: string;
+}>, boundConnection?: string, boundFolder?: string): string[];
 /** Why this run did not overwrite the overlay (`_keep_prepared_schema`). */
 export declare function keptSchemaMessage(action: string, kept: number, discarded: number): string;
 /** The set was SHAPED right but resolved to nothing new: a VALUE is wrong for this connection. */