@uipath/maestro-builder-sdk 6.3.0 → 6.5.0

package/dist/registry/model/library.d.ts

@@ -0,0 +1,254 @@
+/**
+ * The shapes on disk.
+ *
+ * One connector operation is three files: a `.json` entry that says how it is
+ * addressed, a `.v1def.json` sidecar that is the platform's node definition
+ * verbatim, and a Markdown page an agent reads. `index.json` maps node types to
+ * entry paths. A project overlay written by `prepare` uses the same entry and
+ * sidecar shapes under `connectors-local/descriptors/`, plus a ledger of
+ * resolved ids and a bindings document.
+ *
+ * These are the types the registry code passes around. They are deliberately
+ * loose where the registry itself is loose — a node definition is whatever the
+ * platform served, and the generators copy fields they do not interpret — and
+ * tight where the SDK depends on a field.
+ */
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+/** A field's `reference`: where its id-valued input can be resolved from. */
+export interface FieldReference {
+    objectName?: string;
+    path?: string;
+    lookupNames?: string[];
+    lookupValue?: string;
+    filterPattern?: string;
+    childPath?: string;
+    dependsOn?: string[];
+    [key: string]: unknown;
+}
+/** One input or output field as the library records it. */
+export interface LibraryField {
+    name: string;
+    type?: string;
+    dataType?: string;
+    required?: boolean;
+    description?: string;
+    displayName?: string;
+    enum?: unknown[];
+    reference?: FieldReference;
+    /** `query` | `path` | `multipart` | `event` for operation parameters; absent for body fields. */
+    location?: string;
+    bucket?: string;
+    hidden?: boolean;
+    sortOrder?: number | null;
+    dependsOn?: string[];
+    [key: string]: unknown;
+}
+export interface ConnectorDiscovery {
+    type?: string;
+    hasObjectDiscovery?: boolean;
+    hasFieldDiscovery?: boolean;
+    hasCustomObjectDiscovery?: boolean;
+    hasCustomFieldDiscovery?: boolean;
+}
+export interface EntryConnector {
+    key: string;
+    name?: string;
+    tier?: string;
+    discovery?: ConnectorDiscovery;
+    [key: string]: unknown;
+}
+export type ActivityType = "Curated" | "Generic" | "GenericExpanded" | "CuratedTrigger" | "GenericTrigger" | "Http" | (string & {});
+export interface SchemaAction {
+    name?: string;
+    parents: string[];
+    trigger?: string;
+    replaces?: "input" | "output" | "both";
+    [key: string]: unknown;
+}
+export interface EntryOperation {
+    name: string;
+    objectName: string;
+    objectDisplayName?: string;
+    activityType: ActivityType;
+    httpMethod?: string;
+    path?: string;
+    pathTemplate?: string;
+    parameters?: LibraryField[];
+    subType?: string;
+    sourceNodeType?: string;
+    objectFromDiscovery?: boolean;
+    eventOperation?: string;
+    eventMode?: string;
+    schemaAction?: SchemaAction | null;
+    dispatchStyle?: string;
+    paramGrammars?: unknown;
+    [key: string]: unknown;
+}
+export interface EntryRuntime {
+    requiresConnection?: boolean;
+    requiresFolderKey?: boolean;
+    requiresConnectionForSchema?: boolean;
+    bpmnType?: string;
+    [key: string]: unknown;
+}
+export interface EventSchema {
+    eventParameters?: {
+        fields: LibraryField[];
+    };
+    filterFields?: {
+        fields: LibraryField[];
+    };
+    eventMode?: string;
+    byoaConnection?: boolean;
+    isWebhookUrlVisible?: boolean;
+}
+/** The canonical `<key>/<action>@<version>.json`. */
+export interface LibraryEntry {
+    nodeType: string;
+    version: string;
+    connector: EntryConnector;
+    operation: EntryOperation;
+    display: {
+        label?: string;
+        description?: string;
+        [key: string]: unknown;
+    };
+    runtime: EntryRuntime;
+    inputSchema: {
+        fields: LibraryField[];
+    };
+    outputSchema: {
+        fields: LibraryField[];
+    };
+    eventSchema?: EventSchema;
+    [key: string]: unknown;
+}
+/**
+ * The `.v1def.json` sidecar: the platform's node definition. Only the members
+ * the registry reads are named; everything else rides along untouched.
+ */
+export interface V1Definition {
+    inputDefinition?: {
+        fields?: LibraryField[];
+        [key: string]: unknown;
+    };
+    outputDefinition?: {
+        fields?: LibraryField[];
+        [key: string]: unknown;
+    };
+    eventParameters?: {
+        fields?: LibraryField[];
+        [key: string]: unknown;
+    };
+    filterFields?: {
+        fields?: LibraryField[];
+        [key: string]: unknown;
+    };
+    eventMode?: string;
+    byoaConnection?: boolean;
+    isWebhookUrlVisible?: boolean;
+    model?: {
+        bindings?: unknown[];
+        context?: Array<{
+            name?: string;
+            value?: unknown;
+        }>;
+        [key: string]: unknown;
+    };
+    form?: unknown;
+    supportsErrorHandling?: boolean;
+    inputDefaults?: Record<string, unknown>;
+    debug?: {
+        runtime?: string;
+    };
+    [key: string]: unknown;
+}
+/** One row of `index.json`. */
+export interface IndexRow {
+    nodeType: string;
+    version: string;
+    connectorKey: string;
+    label: string;
+    activityType: ActivityType;
+    objectName: string;
+    operationName: string;
+    path: string;
+    objectFromDiscovery?: true;
+    [key: string]: unknown;
+}
+export interface LibraryIndex {
+    schemaVersion: string;
+    entries: IndexRow[];
+    [key: string]: unknown;
+}
+/** `connectors-local/index.json`: the same rows, paths under `descriptors/`. */
+export type OverlayIndex = LibraryIndex;
+/** One recorded lookup resolution, keyed in the ledger by `lookupKey(...)`. */
+export interface LedgerResolution {
+    nodeType: string;
+    field: string;
+    by: string;
+    match: string;
+    value: string;
+}
+/** One recorded object decision under `objects[nodeType][requestedName]`. */
+export interface LedgerObject {
+    value: string;
+    displayName: string;
+    custom: boolean;
+    operation?: string;
+}
+/** `connectors-local/resolutions.json`. */
+export interface Ledger {
+    schemaVersion: string;
+    objects?: Record<string, Record<string, LedgerObject>>;
+    resolutions: Record<string, LedgerResolution>;
+}
+export interface BindingRow {
+    id: string;
+    name: string;
+    resource: string;
+    resourceKey: string;
+    default?: boolean;
+    propertyAttribute?: string;
+    [key: string]: unknown;
+}
+/** `bindings.json`. */
+export interface BindingsDocument {
+    schemaVersion: string;
+    bindings: BindingRow[];
+    [key: string]: unknown;
+}
+/** One row of `registry-triggers.json`, PascalCase except `connectorKey`. */
+export interface TriggerCatalogueRow {
+    NodeType: string;
+    DisplayName?: string;
+    Description?: string;
+    Version?: string;
+    connectorKey: string;
+}
+export interface TriggerCatalogue {
+    schemaVersion: string;
+    note?: string;
+    count: number;
+    triggers: TriggerCatalogueRow[];
+}
+/** `invariant-collections.json`: collections whose ids never depend on a connection. */
+export interface InvariantCollections {
+    collections: Array<{
+        objectName: string;
+        [key: string]: unknown;
+    }>;
+}
+/** Node-type prefixes that mark the three roles a connector node can play. */
+export declare const CONNECTOR_PREFIX = "uipath.connector.";
+export declare const TRIGGER_PREFIX = "uipath.connector.trigger.";
+export declare const EVENT_PREFIX = "uipath.connector.event.";
+/** True for a start trigger or a mid-flow event wait. */
+export declare function isEventNodeType(nodeType: string): boolean;

package/dist/registry/model/library.js

@@ -0,0 +1,23 @@
+/**
+ * The shapes on disk.
+ *
+ * One connector operation is three files: a `.json` entry that says how it is
+ * addressed, a `.v1def.json` sidecar that is the platform's node definition
+ * verbatim, and a Markdown page an agent reads. `index.json` maps node types to
+ * entry paths. A project overlay written by `prepare` uses the same entry and
+ * sidecar shapes under `connectors-local/descriptors/`, plus a ledger of
+ * resolved ids and a bindings document.
+ *
+ * These are the types the registry code passes around. They are deliberately
+ * loose where the registry itself is loose — a node definition is whatever the
+ * platform served, and the generators copy fields they do not interpret — and
+ * tight where the SDK depends on a field.
+ */
+/** Node-type prefixes that mark the three roles a connector node can play. */
+export const CONNECTOR_PREFIX = "uipath.connector.";
+export const TRIGGER_PREFIX = "uipath.connector.trigger.";
+export const EVENT_PREFIX = "uipath.connector.event.";
+/** True for a start trigger or a mid-flow event wait. */
+export function isEventNodeType(nodeType) {
+    return nodeType.startsWith(TRIGGER_PREFIX) || nodeType.startsWith(EVENT_PREFIX);
+}

package/dist/registry/naming.d.ts

@@ -0,0 +1,54 @@
+/** `send-message-to-user` → `SendMessageToUser`. */
+export declare function pascal(actionId: string): string;
+/** A small deterministic singulariser for array field names used as type names. */
+export declare function singular(name: string): string;
+/** The subset of an entry or index row that naming reads. */
+export interface NamedEntry {
+    nodeType?: string;
+    connectorKey?: string;
+    activityType?: string;
+    label?: string;
+    operation?: {
+        activityType?: string;
+        [key: string]: unknown;
+    } | null;
+    display?: {
+        label?: string;
+        [key: string]: unknown;
+    } | null;
+    [key: string]: unknown;
+}
+/**
+ * `(nodeType, activityType, label)` from either entry shape: the flat
+ * `index.json` row or the nested per-operation entry file.
+ */
+export declare function opIdentity(entry: NamedEntry): [nodeType: string, activityType: string, label: string];
+/**
+ * The exported const name for one operation, de-collided within its module.
+ *
+ * `seen` is the per-module set of names already emitted and it is MUTATED here;
+ * a later operation whose name collides gets a trailing `_`. A `GenericExpanded`
+ * entry is named from its display label because its action id is the shared
+ * generic verb.
+ */
+export declare function opSymbolName(entry: NamedEntry, seen: Set<string>): string;
+/** The connector key an entry belongs to, from the row or from its node type. */
+export declare function connectorKeyOf(entry: NamedEntry): string;
+/**
+ * `{ nodeType → exportedConstName }` for every operation a module will export.
+ *
+ * Groups by connector, walks connectors sorted by key and entries sorted by
+ * node type, exactly as the descriptor generator emits them. An operation with
+ * no entry in the map has no descriptor (a `GenericExpanded` one, by default).
+ */
+export declare function symbolIndex(entries: readonly NamedEntry[], includeGenericExpanded?: boolean): Map<string, string>;
+/** `profile.email` → `byEmail`; only the last dotted segment is used. */
+export declare function byAlias(lookupName: string): string;
+/**
+ * `{ lookupName → alias }` for every name that earns an unambiguous alias.
+ *
+ * Two names that camelise to one alias are BOTH dropped rather than awarded to
+ * whichever came first; they stay reachable through the generic `.by(name, v)`.
+ * An empty map is normal and means "generic form only".
+ */
+export declare function byAliases(lookupNames: readonly string[]): Map<string, string>;

package/dist/registry/naming.js

@@ -0,0 +1,142 @@
+/**
+ * Symbol-name derivation shared by the descriptor and Markdown generators.
+ *
+ * `library-json/` feeds two derived views: the TypeScript descriptors an author
+ * imports, and the Markdown an agent reads. The Markdown cites the TypeScript by
+ * name — `connector(SendMessageToUser, …)`, `.byEmail(…)` — and neither name
+ * exists in the JSON. Both are derived, here, once.
+ *
+ * The de-collision loop is the reason this cannot be re-derived per page: it is
+ * stateful across a whole connector module, so a second implementation walking
+ * in a different order would print an import that does not resolve. Both
+ * generators call {@link symbolIndex} and neither owns a copy.
+ *
+ * Ported from `integrations/scripts/_naming.py`; the behaviour is that file's.
+ */
+import { sortedByCodePoint, sortedStrings } from "./compat/compare.js";
+import { afterLast, beforeLast, upperFirst } from "./compat/pystr.js";
+/** `send-message-to-user` → `SendMessageToUser`. */
+export function pascal(actionId) {
+    const joined = actionId
+        .split(/[^A-Za-z0-9]+/)
+        .filter((w) => w.length > 0)
+        .map((w) => upperFirst(w))
+        .join("");
+    return joined || "Op";
+}
+/** A small deterministic singulariser for array field names used as type names. */
+export function singular(name) {
+    const lower = name.toLowerCase();
+    if (lower.endsWith("ies") && name.length > 3)
+        return `${name.slice(0, -3)}y`;
+    if (lower.endsWith("sses"))
+        return name.slice(0, -2);
+    if (lower.endsWith("s") && !lower.endsWith("ss") && !lower.endsWith("us"))
+        return name.slice(0, -1);
+    return name;
+}
+/**
+ * `(nodeType, activityType, label)` from either entry shape: the flat
+ * `index.json` row or the nested per-operation entry file.
+ */
+export function opIdentity(entry) {
+    const nodeType = entry.nodeType || "";
+    const operation = entry.operation;
+    const activityType = operation && typeof operation === "object" ? operation.activityType || "" : entry.activityType || "";
+    const display = entry.display;
+    let label = display && typeof display === "object" && display.label ? display.label : entry.label || "";
+    if (!label)
+        label = afterLast(nodeType, ".");
+    return [nodeType, activityType, label];
+}
+/**
+ * The exported const name for one operation, de-collided within its module.
+ *
+ * `seen` is the per-module set of names already emitted and it is MUTATED here;
+ * a later operation whose name collides gets a trailing `_`. A `GenericExpanded`
+ * entry is named from its display label because its action id is the shared
+ * generic verb.
+ */
+export function opSymbolName(entry, seen) {
+    const [nodeType, activityType, label] = opIdentity(entry);
+    const actionId = afterLast(nodeType, ".");
+    let name = pascal(activityType === "GenericExpanded" ? label : actionId);
+    while (seen.has(name))
+        name += "_";
+    seen.add(name);
+    return name;
+}
+/** The connector key an entry belongs to, from the row or from its node type. */
+export function connectorKeyOf(entry) {
+    if (entry.connectorKey)
+        return entry.connectorKey;
+    // `str.replace` replaces every occurrence; JavaScript's `replace` with a
+    // string pattern replaces only the first.
+    const rest = (entry.nodeType || "").replaceAll("uipath.connector.", "");
+    return rest.includes(".") ? beforeLast(rest, ".") : rest;
+}
+/**
+ * `{ nodeType → exportedConstName }` for every operation a module will export.
+ *
+ * Groups by connector, walks connectors sorted by key and entries sorted by
+ * node type, exactly as the descriptor generator emits them. An operation with
+ * no entry in the map has no descriptor (a `GenericExpanded` one, by default).
+ */
+export function symbolIndex(entries, includeGenericExpanded = false) {
+    const byConnector = new Map();
+    for (const entry of entries) {
+        const [, activityType] = opIdentity(entry);
+        if (activityType === "GenericExpanded" && !includeGenericExpanded)
+            continue;
+        const key = connectorKeyOf(entry);
+        const group = byConnector.get(key);
+        if (group)
+            group.push(entry);
+        else
+            byConnector.set(key, [entry]);
+    }
+    const names = new Map();
+    for (const key of sortedStrings(byConnector.keys())) {
+        const seen = new Set();
+        for (const entry of sortedByCodePoint(byConnector.get(key), (e) => e.nodeType || "")) {
+            // `names[entry["nodeType"]]` raised `KeyError` on a row without one. An
+            // index row is malformed without a node type, and silently keying it
+            // under `undefined` would hand a page a symbol nothing exports.
+            if (typeof entry.nodeType !== "string") {
+                throw new TypeError(`symbolIndex: an entry for connector '${key}' has no nodeType (label ${JSON.stringify(entry.label ?? entry.display?.label ?? "")})`);
+            }
+            names.set(entry.nodeType, opSymbolName(entry, seen));
+        }
+    }
+    return names;
+}
+/** `profile.email` → `byEmail`; only the last dotted segment is used. */
+export function byAlias(lookupName) {
+    const last = afterLast(lookupName, ".");
+    const words = last.split(/[^A-Za-z0-9]+/).filter((w) => w.length > 0);
+    if (words.length === 0)
+        return "";
+    return `by${words.map((w) => upperFirst(w)).join("")}`;
+}
+/**
+ * `{ lookupName → alias }` for every name that earns an unambiguous alias.
+ *
+ * Two names that camelise to one alias are BOTH dropped rather than awarded to
+ * whichever came first; they stay reachable through the generic `.by(name, v)`.
+ * An empty map is normal and means "generic form only".
+ */
+export function byAliases(lookupNames) {
+    const counts = new Map();
+    for (const name of lookupNames) {
+        const alias = byAlias(name);
+        if (alias)
+            counts.set(alias, (counts.get(alias) ?? 0) + 1);
+    }
+    const out = new Map();
+    for (const name of lookupNames) {
+        const alias = byAlias(name);
+        if (alias && counts.get(alias) === 1)
+            out.set(name, alias);
+    }
+    return out;
+}

package/dist/registry/orphans.d.ts

@@ -0,0 +1,4 @@
+/** Every file under `libraryPath` that no index row points at, sorted. */
+export declare function findOrphans(libraryPath: string): string[];
+/** {@link findOrphans}, as the fatal error the shell script raised. */
+export declare function assertNoOrphans(libraryPath: string): void;

package/dist/registry/orphans.js

@@ -0,0 +1,86 @@
+/**
+ * The ORPHAN CHECK: an entry file that `index.json` does not list is invisible.
+ *
+ * The resolver looks operations up through the index and never scans the tree,
+ * so a `<key>/<action>@<ver>.json` with no index row is dead weight — `compile`
+ * answers *"connector not in library"* for an operation whose definition is
+ * sitting right there. Measured on the shipped snapshot (2026-07-31) it found
+ * exactly one orphan in 7,030 entry files: the Data Service
+ * `query-entity-records` two path-to-GA scenarios are built on, GA and served
+ * by the tenant, and unauthorable. `library-json.samples/` now carries the
+ * corrected entry AND its index row, so the expected count is zero.
+ *
+ * Fatal rather than a warning, deliberately: this is the silent-degradation
+ * class the campaign keeps finding, and the fix for a new orphan is always the
+ * same one line in the overlay's index.
+ *
+ * The check is deliberately kept naive: a file is resolvable or it is not. In
+ * particular it does NOT forgive a file whose (nodeType, version) is indexed at
+ * some other path — forgiving that would have hidden the real problem, which is
+ * an overlay correction the index no longer points at. `curated-overlay.ts`
+ * refuses to create such a file in the first place, and says which correction
+ * it dropped, so this check has nothing to forgive.
+ *
+ * Ported from the inline `python3` heredoc in `unpack-library.sh`, which is why
+ * the skip list is the Python's literal one rather than anything derived.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { Refusal } from "./errors.js";
+import { listFiles } from "./files.js";
+import { sortedStrings } from "./compat/compare.js";
+/**
+ * Files that are not operation entries and so carry no index row by design.
+ *
+ * `list-envelopes.json` is the LIST-ENVELOPE LEDGER (a side-table keyed by
+ * nodeType, flow-builder-sdk#156); `invariant-collections.json` is the second
+ * such side-table, keyed by a reference's `objectName` instead
+ * (CONNECTOR_LOOKUP_DESIGN.md §5.3). Asking either for an index row is the
+ * wrong question. Dotfiles are excluded separately — see {@link isDotfile}.
+ */
+const SIDE_TABLES = new Set(["index.json", "list-envelopes.json", "invariant-collections.json"]);
+/**
+ * A dotfile is never an operation entry, so it can never have an index row.
+ *
+ * The Python walked every file and knew nothing about dotfiles, because the
+ * only tree it ever saw was a freshly unzipped one inside an image. Run the
+ * same check over a library a developer has opened in Finder and `.DS_Store`
+ * is an orphan; over one `registry pull` wrote and `.registry-source.json`
+ * (the url and sha256 the library came from) is another. Neither is a missing
+ * row — they are files the check was never meant to see.
+ */
+function isDotfile(name) {
+    return name.startsWith(".");
+}
+/** Every file under `libraryPath` that no index row points at, sorted. */
+export function findOrphans(libraryPath) {
+    const indexPath = join(libraryPath, "index.json");
+    if (!existsSync(indexPath))
+        return [];
+    const index = JSON.parse(readFileSync(indexPath, "utf8"));
+    const indexed = new Set((index.entries ?? [])
+        .map((entry) => entry.path)
+        .filter((path) => typeof path === "string"));
+    // Every file, not only `.json`: the Python excluded the three side-tables and
+    // the sidecars and nothing else, so a stray page or a leftover temp file is
+    // an orphan too — which is the point, since neither can be resolved either.
+    const files = listFiles(libraryPath, (rel) => {
+        const name = rel.slice(rel.lastIndexOf("/") + 1);
+        return !SIDE_TABLES.has(name) && !isDotfile(name) && !name.endsWith(".v1def.json");
+    });
+    return sortedStrings(files.filter((rel) => !indexed.has(rel)));
+}
+/** {@link findOrphans}, as the fatal error the shell script raised. */
+export function assertNoOrphans(libraryPath) {
+    const orphans = findOrphans(libraryPath);
+    if (orphans.length === 0)
+        return;
+    throw new Refusal([
+        `error: ${orphans.length} library entry file(s) have NO index.json entry,`,
+        '       so nothing can resolve them (`compile` says "connector not in library"):',
+        ...orphans.map((rel) => `         ${rel}`),
+        "       Fix: add each one's entry to typescript/sdk/lib/library-json.samples/index.json",
+        "       (with a corrected <key>/<action>@<ver>.json + .v1def.json beside it if the",
+        "       snapshot's copy is stale), then re-run.",
+    ].join("\n"), "LIBRARY_ORPHANS");
+}

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

@@ -0,0 +1,26 @@
+import type { UipClient } from "../uip/client.js";
+/**
+ * The action ids in a `registry search <key>` reply, sorted.
+ *
+ * Exact prefix only: the same search returns
+ * `uipath.agent.resource.tool.connector.<key>.<action>` and
+ * `uipath.connector.trigger.<key>.<event>`, which are not actions of this node
+ * and would read as alternatives an author could pass.
+ */
+export declare function registryActionIds(payload: unknown, connectorKey: string): string[];
+/**
+ * Candidates ranked by shared hyphen tokens, best first.
+ *
+ * Token overlap rather than edit distance because the two namespaces differ by
+ * whole words, not typos: the baked library's `list-all-records` against the
+ * registry's `list-records`. Python sorted `(overlap, -len, name)` descending,
+ * so ties on overlap prefer the SHORTER id, and ties on both fall back to the
+ * name in reverse code-point order.
+ */
+export declare function closestActions(action: string, candidates: readonly string[]): string[];
+/**
+ * `_registry_actions`: the action ids the registry serves for `connectorKey`,
+ * or `[]` when the search fails or does not answer JSON. This runs only on the
+ * failure path, where an empty answer is itself the message ("returned nothing").
+ */
+export declare function registryActions(client: UipClient, connectorKey: string, timeoutMs?: number): Promise<string[]>;

package/dist/registry/prepare/actions.js

@@ -0,0 +1,94 @@
+/**
+ * What the REGISTRY serves for a connector, for the failure path only.
+ *
+ * When `registry get uipath.connector.<key>.<action>` finds nothing — and the
+ * event namespaces do not have it either — the one question left is what the
+ * tenant actually serves for that connector, so the refusal can list it. That
+ * is a `registry search <key>` against the live catalog rather than a cached
+ * index, because a stale index is one of the ways this failure happens.
+ *
+ * Ported from `_registry_actions` / `_closest_actions` in
+ * `prepare_connector.py`. The fetch goes through the injected {@link UipClient};
+ * everything else is pure over the parsed reply.
+ */
+import { compareCodePoints, sortedStrings } from "../compat/compare.js";
+import { registrySearch } from "../uip/commands.js";
+import { isPlainObject, pyOr } from "./support.js";
+/**
+ * The action ids in a `registry search <key>` reply, sorted.
+ *
+ * Exact prefix only: the same search returns
+ * `uipath.agent.resource.tool.connector.<key>.<action>` and
+ * `uipath.connector.trigger.<key>.<event>`, which are not actions of this node
+ * and would read as alternatives an author could pass.
+ */
+export function registryActionIds(payload, connectorKey) {
+    // `json.loads(stdout).get("Data") or []`: a reply that is not an object has
+    // no `.get` and the Python would have crashed; a list is the useful answer.
+    if (!isPlainObject(payload))
+        return [];
+    const data = pyOr(payload.Data, []);
+    if (!Array.isArray(data))
+        return [];
+    const prefix = `uipath.connector.${connectorKey}.`;
+    const ids = new Set();
+    for (const entry of data) {
+        if (!isPlainObject(entry))
+            continue;
+        const nodeType = pyOr(entry.NodeType, "");
+        if (typeof nodeType !== "string" || !nodeType.startsWith(prefix))
+            continue;
+        const rest = nodeType.slice(prefix.length);
+        if (!rest.includes("."))
+            ids.add(rest);
+    }
+    return sortedStrings(ids);
+}
+/**
+ * Candidates ranked by shared hyphen tokens, best first.
+ *
+ * Token overlap rather than edit distance because the two namespaces differ by
+ * whole words, not typos: the baked library's `list-all-records` against the
+ * registry's `list-records`. Python sorted `(overlap, -len, name)` descending,
+ * so ties on overlap prefer the SHORTER id, and ties on both fall back to the
+ * name in reverse code-point order.
+ */
+export function closestActions(action, candidates) {
+    const wanted = new Set(action.split("-"));
+    const scored = candidates
+        .map((candidate) => {
+        const tokens = new Set(candidate.split("-"));
+        let overlap = 0;
+        for (const token of wanted)
+            if (tokens.has(token))
+                overlap += 1;
+        return { overlap, candidate };
+    })
+        .filter(({ overlap }) => overlap > 0);
+    scored.sort((a, b) => {
+        if (a.overlap !== b.overlap)
+            return b.overlap - a.overlap;
+        if (a.candidate.length !== b.candidate.length)
+            return a.candidate.length - b.candidate.length;
+        return compareCodePoints(b.candidate, a.candidate);
+    });
+    return scored.map(({ candidate }) => candidate);
+}
+/**
+ * `_registry_actions`: the action ids the registry serves for `connectorKey`,
+ * or `[]` when the search fails or does not answer JSON. This runs only on the
+ * failure path, where an empty answer is itself the message ("returned nothing").
+ */
+export async function registryActions(client, connectorKey, timeoutMs) {
+    const result = await client.run(registrySearch(connectorKey), timeoutMs === undefined ? undefined : { timeoutMs });
+    if (result.code !== 0)
+        return [];
+    let payload;
+    try {
+        payload = JSON.parse(result.stdout);
+    }
+    catch {
+        return [];
+    }
+    return registryActionIds(payload, connectorKey);
+}