@uipath/maestro-builder-sdk 6.4.0 → 6.5.0

package/dist/registry/generators/type-tree.d.ts

@@ -0,0 +1,65 @@
+import type { LibraryField } from "../model/library.js";
+/** Registry field `type` → TypeScript type; anything else is `unknown`. */
+export declare const TYPE_MAP: Readonly<Record<string, string>>;
+/**
+ * Python truthiness for a JSON-shaped value. JavaScript agrees on `null`,
+ * `false`, `0` and `""` but calls an empty array or object truthy; the Python
+ * generator tested `field.get("required")`, `runtime.get("requiresConnection")`
+ * and the like with a bare `if`, so the emitted bytes depend on this rule.
+ */
+export declare function pyTruthy(value: unknown): boolean;
+/** `TYPE_MAP.get(str(field["type"] or "").lower(), "unknown")`. */
+export declare function tsType(field: {
+    type?: unknown;
+}): string;
+/**
+ * A field as the tree holds it: the library's declaration plus the `__lookup`
+ * flag `descriptors.ts` sets on a field whose type must also accept a token.
+ */
+export type TreeField = LibraryField & {
+    __lookup?: boolean;
+};
+/** `{ rootSegment → node }`: the roots of one operation's inputs or outputs. */
+export type TypeTree = Map<string, TypeNode>;
+/** One node in a tree reconstructed from flattened connector field paths. */
+export declare class TypeNode {
+    /** Every cardinality this segment was declared with; `true` is `[*]`. */
+    readonly arrayModes: Set<boolean>;
+    /** Every TypeScript type a declaration of this segment mapped to. */
+    readonly declaredTypes: Set<string>;
+    /** The first field declared on this exact segment; its description is rendered. */
+    declared: TreeField | undefined;
+    opaqueObject: boolean;
+    opaqueArray: boolean;
+    required: boolean;
+    readonly children: TypeTree;
+    constructor(isArray?: boolean);
+    addDeclaration(field: TreeField): void;
+}
+/**
+ * Split `items[*].owner.id` into `[["items", true], ["owner", false], ["id", false]]`.
+ * A malformed name (an empty segment, as in `a..b` or `[*]`) is kept whole as
+ * one quoted property.
+ */
+export declare function splitFieldPath(name: string): Array<[segment: string, isArray: boolean]>;
+/** The roots of the tree for one flat field list; a field without a name is skipped. */
+export declare function buildTypeTree(fields: readonly TreeField[]): TypeTree;
+/**
+ * Merge repeated occurrences into one reusable connector-level type. A child
+ * only the source has is adopted by reference, so the two trees share it.
+ */
+export declare function mergeTypeNodes(target: TypeNode, source: TypeNode): void;
+/**
+ * The interface name for a nested segment: singularised when the segment is an
+ * array, PascalCased, prefixed with `Nested` when it would start with a digit.
+ */
+export declare function nestedTypeName(fieldName: string, node: TypeNode, suffix?: string): string;
+/** True when the node or any descendant is required. */
+export declare function subtreeRequired(node: TypeNode): boolean;
+/**
+ * Stable structural identity — the Python's nested tuple, as one canonical
+ * string. Input types reuse only exact shapes, so two nodes share an interface
+ * iff their fingerprints are equal. Children are ordered by name, as
+ * `sorted(node.children.items())` orders them.
+ */
+export declare function typeFingerprint(node: TypeNode): string;

package/dist/registry/generators/type-tree.js

@@ -0,0 +1,179 @@
+/**
+ * The type tree a descriptor's interfaces are rendered from.
+ *
+ * A connector declares its fields flat — `items[*].owner.id` — and the
+ * descriptor exposes them as natural nested objects and arrays. This module
+ * rebuilds that nesting: one {@link TypeNode} per path segment, carrying every
+ * declaration that landed on it (a segment can be declared both as a scalar and
+ * as an array, or by several fields with different types) so the renderer can
+ * union them. Ported from the `TypeNode` half of `generate_connectors_ts.py`;
+ * `type-registry.ts` names and de-duplicates the nodes and `descriptors.ts`
+ * renders them.
+ */
+import { sortedStrings } from "../compat/compare.js";
+import { pyStr } from "../compat/pystr.js";
+import { pascal, singular } from "../naming.js";
+/** Registry field `type` → TypeScript type; anything else is `unknown`. */
+export const TYPE_MAP = {
+    string: "string",
+    number: "number",
+    integer: "number",
+    float: "number",
+    double: "number",
+    long: "number",
+    boolean: "boolean",
+    bool: "boolean",
+    object: "Record<string, unknown>",
+    array: "unknown[]",
+    json: "unknown",
+    file: "string",
+};
+/**
+ * Python truthiness for a JSON-shaped value. JavaScript agrees on `null`,
+ * `false`, `0` and `""` but calls an empty array or object truthy; the Python
+ * generator tested `field.get("required")`, `runtime.get("requiresConnection")`
+ * and the like with a bare `if`, so the emitted bytes depend on this rule.
+ */
+export function pyTruthy(value) {
+    if (value === null || value === undefined || value === false || value === "")
+        return false;
+    if (typeof value === "number")
+        return value !== 0; // NaN is truthy in Python
+    if (typeof value === "bigint")
+        return value !== 0n;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (value instanceof Map || value instanceof Set)
+        return value.size > 0;
+    if (typeof value === "object")
+        return Object.keys(value).length > 0;
+    return true;
+}
+/** `str(value or "")`: the coercion the generator applied before comparing a type name. */
+function strOrEmpty(value) {
+    return pyTruthy(value) ? pyStr(value) : "";
+}
+/** `TYPE_MAP.get(str(field["type"] or "").lower(), "unknown")`. */
+export function tsType(field) {
+    return TYPE_MAP[strOrEmpty(field.type).toLowerCase()] ?? "unknown";
+}
+/** One node in a tree reconstructed from flattened connector field paths. */
+export class TypeNode {
+    /** Every cardinality this segment was declared with; `true` is `[*]`. */
+    arrayModes = new Set();
+    /** Every TypeScript type a declaration of this segment mapped to. */
+    declaredTypes = new Set();
+    /** The first field declared on this exact segment; its description is rendered. */
+    declared = undefined;
+    opaqueObject = false;
+    opaqueArray = false;
+    required = false;
+    children = new Map();
+    constructor(isArray = false) {
+        this.arrayModes.add(isArray);
+    }
+    addDeclaration(field) {
+        if (this.declared === undefined)
+            this.declared = field;
+        const declaredType = strOrEmpty(field.type).toLowerCase();
+        this.declaredTypes.add(tsType(field));
+        this.opaqueObject = this.opaqueObject || declaredType === "object";
+        this.opaqueArray = this.opaqueArray || declaredType === "array";
+        this.required = this.required || pyTruthy(field.required);
+    }
+}
+/**
+ * Split `items[*].owner.id` into `[["items", true], ["owner", false], ["id", false]]`.
+ * A malformed name (an empty segment, as in `a..b` or `[*]`) is kept whole as
+ * one quoted property.
+ */
+export function splitFieldPath(name) {
+    const parts = [];
+    for (const raw of name.split(".")) {
+        const isArray = raw.endsWith("[*]");
+        const segment = isArray ? raw.slice(0, -3) : raw;
+        if (!segment)
+            return [[name, false]];
+        parts.push([segment, isArray]);
+    }
+    return parts;
+}
+/** The roots of the tree for one flat field list; a field without a name is skipped. */
+export function buildTypeTree(fields) {
+    const roots = new Map();
+    for (const field of fields) {
+        const name = field.name;
+        if (!pyTruthy(name))
+            continue;
+        let cursor = roots;
+        let node;
+        for (const [segment, isArray] of splitFieldPath(pyStr(name))) {
+            let next = cursor.get(segment);
+            if (next === undefined) {
+                next = new TypeNode(isArray);
+                cursor.set(segment, next);
+            }
+            node = next;
+            node.arrayModes.add(isArray);
+            cursor = node.children;
+        }
+        if (node !== undefined)
+            node.addDeclaration(field);
+    }
+    return roots;
+}
+/**
+ * Merge repeated occurrences into one reusable connector-level type. A child
+ * only the source has is adopted by reference, so the two trees share it.
+ */
+export function mergeTypeNodes(target, source) {
+    for (const mode of source.arrayModes)
+        target.arrayModes.add(mode);
+    for (const type of source.declaredTypes)
+        target.declaredTypes.add(type);
+    target.opaqueObject = target.opaqueObject || source.opaqueObject;
+    target.opaqueArray = target.opaqueArray || source.opaqueArray;
+    target.required = target.required || source.required;
+    if (target.declared === undefined)
+        target.declared = source.declared;
+    for (const [childName, sourceChild] of source.children) {
+        const targetChild = target.children.get(childName);
+        if (targetChild === undefined)
+            target.children.set(childName, sourceChild);
+        else
+            mergeTypeNodes(targetChild, sourceChild);
+    }
+}
+/**
+ * The interface name for a nested segment: singularised when the segment is an
+ * array, PascalCased, prefixed with `Nested` when it would start with a digit.
+ */
+export function nestedTypeName(fieldName, node, suffix = "") {
+    const source = node.arrayModes.has(true) || node.opaqueArray ? singular(fieldName) : fieldName;
+    let name = pascal(source);
+    name = /^[A-Za-z_$]/.test(name) ? name : `Nested${name}`;
+    return `${name}${suffix}`;
+}
+/** True when the node or any descendant is required. */
+export function subtreeRequired(node) {
+    if (node.required)
+        return true;
+    for (const child of node.children.values())
+        if (subtreeRequired(child))
+            return true;
+    return false;
+}
+/**
+ * Stable structural identity — the Python's nested tuple, as one canonical
+ * string. Input types reuse only exact shapes, so two nodes share an interface
+ * iff their fingerprints are equal. Children are ordered by name, as
+ * `sorted(node.children.items())` orders them.
+ */
+export function typeFingerprint(node) {
+    const modes = [...node.arrayModes].sort((a, b) => Number(a) - Number(b));
+    const types = sortedStrings(node.declaredTypes);
+    const children = sortedStrings(node.children.keys()).map((name) => [name, typeFingerprint(node.children.get(name))]);
+    // An internal key, never emitted: JSON is unambiguous for these shapes, so
+    // equal strings mean equal tuples.
+    return JSON.stringify([modes, types, node.opaqueObject, node.opaqueArray, node.required, children]);
+}

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

@@ -0,0 +1,57 @@
+import type { LibraryEntry } from "../model/library.js";
+import { type BuildContext, type BuildPorts } from "./context.js";
+import { type LibraryPlan } from "./plan.js";
+export type CatalogScope = "all" | "tier1" | "tier2";
+export interface BuildOptions {
+    /** `--output-dir`: removed and rewritten. */
+    outputDir: string;
+    /** `--triggers-output`; defaults to `<dirname(normpath(outputDir))>/registry-triggers.json`. */
+    triggersOutput?: string;
+    /**
+     * `--connectors a,b`, already split and stripped. `undefined` is a full
+     * build (the published catalog); a list — even an empty one — is a curated
+     * subset, as `if args.connectors:` on the raw string was.
+     */
+    connectors?: readonly string[];
+    /** `--catalog-scope` (default `all`). */
+    catalogScope?: CatalogScope;
+    skipEnrichment?: boolean;
+    skipConnectorEnrichment?: boolean;
+    skipGenericExpansion?: boolean;
+}
+export interface BuildResult {
+    /** The node types the build materialized, after scope filtering. */
+    nodeTypes: string[];
+    /** The entries as planned, in planning order. */
+    entries: LibraryEntry[];
+    plan: LibraryPlan;
+    /** Entry files written — `write_library`'s return value. */
+    written: number;
+    triggersOutput: string;
+    triggerCount: number;
+}
+/** The Python's default: beside the output directory. */
+export declare function defaultTriggersOutput(outputDir: string): string;
+/** `{c.strip() for c in text.split(",") if c.strip()}`, in first-seen order. */
+export declare function parseConnectorsFlag(text: string): string[];
+/**
+ * `registry_search`: the connector node types the registry lists, from the
+ * cached raw stdout of `flow registry search --filter tags:in=connector` —
+ * fetched once when the cache has no `_search_results.json`.
+ */
+export declare function registrySearch(ctx: BuildContext): Promise<string[]>;
+/**
+ * `fetch_all`: the registry response of every node type, from the cache or
+ * fetched in parallel. `nodeType → cache name`; a node type whose fetch failed
+ * is absent (and was reported by `registryGet`).
+ */
+export declare function fetchAll(ctx: BuildContext, nodeTypes: readonly string[]): Promise<Map<string, string>>;
+/**
+ * `fetch_connector_records_for_keys`: one `is connectors metadata` per key,
+ * sorted and deduplicated; `key → record`, `null` where the lookup failed.
+ */
+export declare function fetchConnectorRecordsForKeys(ctx: BuildContext, keys: Iterable<string>): Promise<Map<string, unknown>>;
+/** `fetch_connector_records`: one record per unique connector key in `entries`. */
+export declare function fetchConnectorRecords(ctx: BuildContext, entries: readonly LibraryEntry[]): Promise<Map<string, unknown>>;
+/** The whole generator, `main()` minus argument parsing and cache cleanup. */
+export declare function buildLibrary(options: BuildOptions, ports: BuildPorts): Promise<BuildResult>;

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

@@ -0,0 +1,286 @@
+/**
+ * `main()` of `generate_library_json.py`, as a function of its options and
+ * ports: search → scope → trigger side-file → fetch → extract → enrich →
+ * connector records → generic expansion → events → curated overrides → plan →
+ * write.
+ *
+ * Every remote call goes through the {@link BuildContext} built from the ports,
+ * so a build against a `--keep-temp` cache the Python left behind makes no call
+ * at all — which is how the port is proven byte-for-byte. The two `sys.exit(
+ * "<message>")` gates are thrown as {@link Refusal}s carrying the same text.
+ */
+import { dirname, join, normalize } from "node:path";
+import { sortedStrings } from "../compat/compare.js";
+import { pyStr } from "../compat/pystr.js";
+import { mapConcurrent } from "../concurrency.js";
+import { Refusal, messageOf } from "../errors.js";
+import { registrySearchConnectors } from "../uip/commands.js";
+import { applyCuratedOverrides, extractCanonical, filterNodeTypesByTier, mergeConnectorRecord, nodeOf, scopedConnectorKey, selectPublishedConnectors, } from "./canonical.js";
+import { SEARCH_RESULTS_NAME, createBuildContext, isConnectorGet, registryCacheName, registryGet, } from "./context.js";
+import { enrichAll } from "./enrich.js";
+import { resolveConnectorEvents } from "./events.js";
+import { expandAllGenerics, sortExpandedEntries } from "./generic-expand.js";
+import { orphanCheck, planLibrary, triggerRows } from "./plan.js";
+import { get, item, pyIter, pyOr, pyReprStrList, truthy } from "./py.js";
+import { writePlan, writeTriggerSideFile } from "./write.js";
+/** The Python's default: beside the output directory. */
+export function defaultTriggersOutput(outputDir) {
+    return join(dirname(normalize(outputDir)) || ".", "registry-triggers.json");
+}
+/** `{c.strip() for c in text.split(",") if c.strip()}`, in first-seen order. */
+export function parseConnectorsFlag(text) {
+    const seen = new Set();
+    for (const part of text.split(",")) {
+        const key = part.trim();
+        if (key)
+            seen.add(key);
+    }
+    return [...seen];
+}
+/** `", ".join(missing[:10])` plus ` (+N more)` past ten. */
+function missingPreview(missing) {
+    const preview = missing.slice(0, 10).join(", ");
+    const remainder = missing.length > 10 ? ` (+${missing.length - 10} more)` : "";
+    return `${preview}${remainder}`;
+}
+/**
+ * `registry_search`: the connector node types the registry lists, from the
+ * cached raw stdout of `flow registry search --filter tags:in=connector` —
+ * fetched once when the cache has no `_search_results.json`.
+ */
+export async function registrySearch(ctx) {
+    if (!ctx.caches.registry.has(SEARCH_RESULTS_NAME)) {
+        ctx.reporter.info("Running registry search...");
+        const result = await ctx.client.run(registrySearchConnectors(), ctx.timeoutMs === undefined ? undefined : { timeoutMs: ctx.timeoutMs });
+        if (result.code !== 0)
+            throw new Refusal(`Registry search failed: ${result.stderr}`, "REGISTRY_SEARCH_FAILED");
+        ctx.caches.registry.write(SEARCH_RESULTS_NAME, undefined, result.stdout);
+    }
+    const data = ctx.caches.registry.read(SEARCH_RESULTS_NAME);
+    const out = [];
+    for (const entry of pyIter(get(data, "Data", []))) {
+        const nodeType = item(entry, "NodeType");
+        if (typeof nodeType === "string" && nodeType.startsWith("uipath.connector."))
+            out.push(nodeType);
+    }
+    return out;
+}
+/**
+ * `fetch_all`: the registry response of every node type, from the cache or
+ * fetched in parallel. `nodeType → cache name`; a node type whose fetch failed
+ * is absent (and was reported by `registryGet`).
+ */
+export async function fetchAll(ctx, nodeTypes) {
+    const results = new Map();
+    const toFetch = [];
+    let alreadyCached = 0;
+    for (const nt of nodeTypes) {
+        const name = registryCacheName(nt);
+        if (ctx.caches.registry.has(name)) {
+            results.set(nt, name);
+            alreadyCached += 1;
+        }
+        else {
+            toFetch.push(nt);
+        }
+    }
+    if (alreadyCached)
+        ctx.reporter.info(`  ${alreadyCached} connectors already cached, ${toFetch.length} to fetch`);
+    if (toFetch.length > 0) {
+        let done = 0;
+        const names = await mapConcurrent(toFetch, ctx.concurrency, async (nt) => {
+            const name = await registryGet(ctx, nt);
+            done += 1;
+            if (done % 50 === 0 || done === toFetch.length)
+                ctx.reporter.info(`  Fetched ${done}/${toFetch.length}`);
+            return name;
+        });
+        toFetch.forEach((nt, i) => {
+            const name = names[i];
+            if (name)
+                results.set(nt, name);
+        });
+    }
+    return results;
+}
+/**
+ * `fetch_connector_records_for_keys`: one `is connectors metadata` per key,
+ * sorted and deduplicated; `key → record`, `null` where the lookup failed.
+ */
+export async function fetchConnectorRecordsForKeys(ctx, keys) {
+    const sorted = sortedStrings(new Set([...keys].filter((key) => truthy(key))));
+    ctx.reporter.info(`  Looking up ${sorted.length} connector records...`);
+    let done = 0;
+    const records = await mapConcurrent(sorted, ctx.concurrency, async (key) => {
+        let record;
+        try {
+            record = await isConnectorGet(ctx, key);
+        }
+        catch {
+            record = undefined;
+        }
+        done += 1;
+        if (done % 50 === 0 || done === sorted.length)
+            ctx.reporter.info(`  Fetched ${done}/${sorted.length} connector records`);
+        return record ?? null;
+    });
+    return new Map(sorted.map((key, i) => [key, records[i]]));
+}
+/** `fetch_connector_records`: one record per unique connector key in `entries`. */
+export function fetchConnectorRecords(ctx, entries) {
+    const keys = entries.map((e) => item(item(e, "connector"), "key")).filter((key) => truthy(key));
+    return fetchConnectorRecordsForKeys(ctx, keys);
+}
+/** The whole generator, `main()` minus argument parsing and cache cleanup. */
+export async function buildLibrary(options, ports) {
+    const ctx = createBuildContext(ports);
+    const info = (line) => ctx.reporter.info(line);
+    const warn = (line) => ctx.reporter.warn(line);
+    const concurrency = ctx.concurrency;
+    let nodeTypes = await registrySearch(ctx);
+    info(`Found ${nodeTypes.length} connector node types`);
+    let connectorRecords;
+    if (options.connectors !== undefined) {
+        // Curated subset: the requested connectors' action AND connector-event
+        // node types. The START form stays out — `registry get` refuses it
+        // without a --connection-id.
+        const allow = new Set(options.connectors);
+        const before = nodeTypes.length;
+        nodeTypes = nodeTypes.filter((nt) => {
+            const key = scopedConnectorKey(nt);
+            return key !== null && allow.has(key);
+        });
+        const matched = new Set([...allow].filter((key) => nodeTypes.some((nt) => `${nt}.`.includes(`.${key}.`))));
+        info(`Curated subset: kept ${nodeTypes.length}/${before} node types for ${matched.size}/${allow.size} connectors ` +
+            pyReprStrList(sortedStrings(matched)));
+        const missing = [...allow].filter((key) => !matched.has(key));
+        if (missing.length > 0) {
+            warn(`  WARN: no registry nodes matched these connector keys: ${pyReprStrList(sortedStrings(missing))}`);
+        }
+    }
+    else {
+        // A full build ships the PUBLISHED catalog, not everything the build
+        // tenant happens to see.
+        const before = nodeTypes.length;
+        const [kept, dropped] = selectPublishedConnectors(nodeTypes);
+        nodeTypes = kept;
+        if (dropped.length > 0) {
+            info(`Published catalog: kept ${nodeTypes.length}/${before} node types, dropped ${dropped.length} ` +
+                `tenant-local connector(s) ${pyReprStrList(dropped)}`);
+        }
+    }
+    const catalogScope = options.catalogScope ?? "all";
+    if (catalogScope === "tier1" || catalogScope === "tier2") {
+        const tierNumber = catalogScope.slice(-1);
+        const scopeKeys = new Set(nodeTypes.map((nt) => scopedConnectorKey(nt)).filter((key) => Boolean(key)));
+        info(`Resolving Tier ${tierNumber} scope from metadata for ${scopeKeys.size} connector keys...`);
+        connectorRecords = await fetchConnectorRecordsForKeys(ctx, scopeKeys);
+        const missingMetadata = sortedStrings([...connectorRecords].filter(([, record]) => record === null).map(([key]) => key));
+        if (missingMetadata.length > 0) {
+            throw new Refusal(`Tier ${tierNumber} filtering requires connector metadata for every candidate connector, but lookup ` +
+                `failed for: ${missingPreview(missingMetadata)}`, "TIER_METADATA_MISSING");
+        }
+        const before = nodeTypes.length;
+        const [kept, matchingKeys] = filterNodeTypesByTier(nodeTypes, connectorRecords, catalogScope);
+        nodeTypes = kept;
+        if (matchingKeys.size === 0) {
+            throw new Refusal(`Tier ${tierNumber} filtering selected no connectors. Expected the Tier field from ` +
+                `\`uip is connectors metadata\` to contain '${tierNumber}'.`, "TIER_EMPTY");
+        }
+        info(`Tier ${tierNumber} scope: kept ${nodeTypes.length}/${before} action node types for ${matchingKeys.size} connectors`);
+    }
+    // Side-file: every trigger nodeType the registry search exposed.
+    const triggersOutput = options.triggersOutput || defaultTriggersOutput(options.outputDir);
+    info(`Writing trigger side-file → ${triggersOutput}`);
+    let triggerCount = 0;
+    if (!ctx.caches.registry.has(SEARCH_RESULTS_NAME)) {
+        warn(`  WARN: search cache missing at ${SEARCH_RESULTS_NAME}; can't write triggers side-file`);
+    }
+    else {
+        const rows = triggerRows(ctx.caches.registry.read(SEARCH_RESULTS_NAME));
+        triggerCount = writeTriggerSideFile(rows, triggersOutput);
+        info(`  wrote ${triggerCount} triggers to ${triggersOutput}`);
+    }
+    info(`Fetching connector details (concurrency=${concurrency})...`);
+    const cacheFiles = await fetchAll(ctx, nodeTypes);
+    info(`Successfully fetched ${cacheFiles.size} connectors`);
+    info("Extracting connector entries (Curated + Generic)...");
+    let entries = [];
+    const v1defSources = new Map();
+    const byActivity = new Map();
+    for (const nt of sortedStrings(cacheFiles.keys())) {
+        const name = cacheFiles.get(nt);
+        try {
+            const entry = extractCanonical(nodeOf(ctx.caches.registry.read(name)));
+            if (truthy(entry)) {
+                entries.push(entry);
+                v1defSources.set(item(entry, "nodeType"), name);
+                // `entry["operation"].get("activityType", "") or "(empty)"`, printed
+                // with `str()`: a `True` stays `True`, not `true`, in the count line.
+                const at = pyStr(pyOr(get(item(entry, "operation"), "activityType", ""), "(empty)"));
+                byActivity.set(at, (byActivity.get(at) ?? 0) + 1);
+            }
+        }
+        catch (e) {
+            warn(`  WARN: error processing ${nt}: ${messageOf(e)}`);
+        }
+    }
+    info(`Found ${entries.length} entries total: ` +
+        sortedStrings(byActivity.keys())
+            .map((k) => `${k}=${byActivity.get(k)}`)
+            .join(", "));
+    if (!options.skipEnrichment) {
+        info(`Enriching via \`is resources describe\` (concurrency=${concurrency})...`);
+        entries = await enrichAll(ctx, entries);
+    }
+    if (!options.skipConnectorEnrichment) {
+        info(`Enriching via \`is connectors metadata\` (concurrency=${concurrency})...`);
+        if (connectorRecords === undefined)
+            connectorRecords = await fetchConnectorRecords(ctx, entries);
+        const missingMetadata = sortedStrings([...connectorRecords].filter(([, record]) => record === null).map(([key]) => key));
+        if (missingMetadata.length > 0) {
+            throw new Refusal("Connector metadata is required to classify schema discovery, but `uip is connectors metadata` " +
+                `failed for: ${missingPreview(missingMetadata)}. Upgrade the UiPath CLI or rerun after checking authentication.`, "CONNECTOR_METADATA_MISSING");
+        }
+        let named = 0;
+        for (const e of entries) {
+            const key = item(item(e, "connector"), "key");
+            mergeConnectorRecord(e, connectorRecords.get(key) ?? null);
+            if (truthy(get(item(e, "connector"), "name")))
+                named += 1;
+        }
+        const schemaDynamic = entries.filter((e) => truthy(get(item(e, "runtime"), "requiresConnectionForSchema"))).length;
+        info(`  Named ${named}/${entries.length} entries from connector records`);
+        info(`  schema-dynamic from connector capabilities: ${schemaDynamic}/${entries.length}`);
+    }
+    if (!options.skipGenericExpansion) {
+        info(`Expanding Generic CRUD by (object, operation) (concurrency=${concurrency})...`);
+        const [kept, expanded] = await expandAllGenerics(ctx, entries);
+        // DELIBERATE FIX: the Python appended expansions in thread-completion
+        // order; sorted, a build is a function of its inputs (see
+        // `sortExpandedEntries`).
+        entries = [...kept, ...sortExpandedEntries(expanded)];
+    }
+    info(`Resolving connector events (concurrency=${concurrency})...`);
+    const [described, expandedEvents] = await resolveConnectorEvents(ctx, entries);
+    entries = [...described, ...sortExpandedEntries(expandedEvents)];
+    // Curated op remaps — applied last so they override anything enrichment or
+    // expansion produced.
+    const overridden = applyCuratedOverrides(entries);
+    if (overridden)
+        info(`  Applied ${overridden} curated op override(s)`);
+    info("Writing canonical library...");
+    const loadNode = (nodeType) => {
+        const name = v1defSources.get(nodeType);
+        return name ? nodeOf(ctx.caches.registry.read(name)) : undefined;
+    };
+    const plan = planLibrary(entries, loadNode);
+    for (const line of plan.warnings)
+        warn(line);
+    const orphans = orphanCheck(plan.files, plan.index);
+    if (orphans.length > 0)
+        warn(`  WARN: ${orphans.length} entry file(s) have no index row: ${orphans.slice(0, 5).join(", ")}`);
+    const written = writePlan(plan, options.outputDir);
+    info(`Wrote ${written} library entries + index.json`);
+    return { nodeTypes, entries, plan, written, triggersOutput, triggerCount };
+}