@uipath/maestro-builder-sdk 5.2.0

package/dist/generators/generate_library_json.py

@@ -0,0 +1,2527 @@
+#!/usr/bin/env python3
+"""
+Generate the canonical connector library from the UiPath Flow registry.
+
+For each enabled, cross-platform, non-experimental connector node type this
+script writes a single JSON file under `--output-dir` (default: `./library/`)
+with the shape below. The output is language-neutral and round-trips with
+Flow definitions: every field a Flow node needs is either in this file
+or derivable from a flow's per-node manifest.
+
+    library/
+      <connector-key>/
+        <action-id>@<version>.json          # curated, e.g. create-issue@1.0.0.json
+        <action-id>@<version>.v1def.json    # Flow definitions[] sidecar
+        generic/
+          <object>/
+            <op>@<version>.json             # Generic CRUD expanded per
+            <op>@<version>.v1def.json       # (object, operation) pair
+      ...
+      index.json                            # flat list of every entry, for tooling
+
+Per-entry shape:
+
+    {
+      "schemaVersion": "1",
+      "nodeType": "uipath.connector.uipath-microsoft-github.create-issue",
+      "version": "1.0.0",
+      "category": "...",
+      "tags": ["connector"],
+      "connector": { "key": "uipath-microsoft-github" },
+      "operation": {
+        "name": "Create",
+        "objectName": "create_issues",
+        "httpMethod": "POST",
+        "subType": "standard",
+        "supportsStreaming": false
+      },
+      "display": { "label": "...", "description": "...", "icon": "...",
+                   "iconBackground": "...", "iconBackgroundDark": "..." },
+      "runtime": {
+        "bpmnType": "bpmn:SendTask",
+        "serviceType": "Intsvc.ActivityExecution",
+        "activityConfigurationVersion": "1.0.0",
+        "requiresConnection": true,
+        "requiresFolderKey": true
+      },
+      "inputSchema":  { "fields": [ ... raw registry shape ... ] },
+      "outputSchema": { "fields": [ ... ] }
+    }
+
+The script keeps the CLI plumbing (registry search, parallel get, on-disk
+cache, resume support) from the cs2fil ancestor unchanged — only the
+extraction and write phases differ.
+
+Usage:
+    python3 generate_library_json.py [options]
+
+Options:
+    --output-dir PATH       Output directory (default: ./library)
+    --cache-dir PATH        Cache for raw `flow registry get` JSONs
+                            (default: ./.registry-cache)
+    --is-cache-dir PATH     Cache for raw `is resources describe` JSONs
+                            (default: ./.is-cache)
+    --skip-enrichment       Skip the second pass that calls
+                            `uip is resources describe` per entry
+    --keep-temp             Keep cache directories after run
+    --catalog-scope SCOPE   Connector catalog scope: all, tier1, or tier2
+                            (default: all). Tiers are resolved live from
+                            `uip is connectors metadata <connector-key>`.
+    --concurrency N         Parallel remote CLI calls (default: 10)
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import _events  # noqa: E402
+
+SCHEMA_VERSION = "1"
+
+# When set (by prepare_connector's single-op, connection-scoped path), every
+# `uip flow registry get` / `is resources describe` / `is resources list` call
+# appends `--connection-id <id>`. The bulk generator leaves this None (it runs
+# connection-less, yielding the thin schema-dynamic entries C4 later overlays).
+_CONNECTION_ID = None
+
+
+def set_connection_id(connection_id):
+    """Route all subsequent uip calls through this connection (see C4 / §E)."""
+    global _CONNECTION_ID
+    _CONNECTION_ID = connection_id
+
+
+def _conn_args():
+    """`['--connection-id', <id>]` when a connection is set, else `[]`."""
+    return ["--connection-id", _CONNECTION_ID] if _CONNECTION_ID else []
+
+
+_PARENT_FIELDS = {}
+
+
+def set_parent_fields(fields):
+    """Parent-field VALUES forwarded to `is resources describe -f name=value`.
+
+    A schema-dynamic operation resolves its real field set from the values of a
+    few parent fields, not from the connection alone. Jira `create-issue`, live
+    against one tenant: no `-f` describes to 2 fields (the parents themselves);
+    project `IN` + issue type Task describes to 19; the same project with Epic
+    describes to a DIFFERENT 22; a different project with its own Task describes
+    to 15. Both dimensions matter independently.
+
+    Too few parents is refused outright ("No api-type ObjectAction matched for
+    fields [...]"); a complete set carrying a value the connection does not have
+    is accepted and resolves back to just the parents. See
+    `failed_field_describes` for why the first needs carrying out of band.
+    """
+    global _PARENT_FIELDS
+    _PARENT_FIELDS = dict(fields or {})
+
+
+def _field_args():
+    """`['-f', 'name=value', ...]` for the parent fields set, else `[]`."""
+    args = []
+    for name, value in _PARENT_FIELDS.items():
+        args += ["-f", f"{name}={value}"]
+    return args
+
+
+_FAILED_FIELD_DESCRIBES = []
+
+
+def reset_failed_field_describes():
+    """Clear the record of describes that failed while parent fields were set."""
+    del _FAILED_FIELD_DESCRIBES[:]
+
+
+def failed_field_describes():
+    """The CLI's own `Message` for each describe that failed under `-f`.
+
+    Recorded only while parent fields are set, because that is when a failure is
+    diagnostic rather than ordinary catalog noise. An incomplete parent set is
+    rejected outright and helpfully:
+
+        Result:  Failure
+        Message: No api-type ObjectAction matched for fields
+                 [fields.project.key] on operation 'Create'
+
+    but the pipeline swallows it — `is_describe_operation` maps any non-Success
+    to `None`, and `enrich_entry` then returns the entry with its registry-
+    DECLARED fields intact. The caller sees a plausible small schema and no
+    error at all, so the good message has to be carried out of band.
+    """
+    return list(_FAILED_FIELD_DESCRIBES)
+
+
+def _note_failed_field_describe(connector_key, object_name, operation, message):
+    if _PARENT_FIELDS:
+        _FAILED_FIELD_DESCRIBES.append(
+            (connector_key, object_name, operation, message or "")
+        )
+
+
+def _field_scope():
+    """Cache discriminator for the parent-field set (empty when none is set).
+
+    The describe response is a function of these values, so a cache keyed only
+    on (connection, object, operation) would serve the first variant's fields
+    for every later one — the whole point of preparing per issue type.
+    """
+    if not _PARENT_FIELDS:
+        return ""
+    flat = "\0".join(f"{k}={v}" for k, v in sorted(_PARENT_FIELDS.items()))
+    return "f-" + hashlib.sha256(flat.encode()).hexdigest()[:12]
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def parse_args():
+    p = argparse.ArgumentParser(
+        description="Generate the canonical connector library from the UiPath Flow registry"
+    )
+    p.add_argument("--output-dir", default="./library",
+                   help="Output directory (default: ./library)")
+    p.add_argument("--cache-dir", default="./.registry-cache",
+                   help="Cache for `flow registry get` JSONs (default: ./.registry-cache)")
+    p.add_argument("--is-cache-dir", default="./.is-cache",
+                   help="Cache for `is resources describe` JSONs (default: ./.is-cache)")
+    p.add_argument("--connectors-cache-dir", default="./.is-connectors-cache",
+                   help="Cache for `is connectors metadata` JSONs "
+                        "(default: ./.is-connectors-cache)")
+    p.add_argument("--skip-enrichment", action="store_true",
+                   help="Skip the `is resources describe` enrichment pass")
+    p.add_argument("--skip-connector-enrichment", action="store_true",
+                   help="Skip the `is connectors metadata` connector-level pass")
+    p.add_argument("--skip-generic-expansion", action="store_true",
+                   help="Skip the Generic CRUD expansion pass (keeps Generic CRUD "
+                        "entries as un-expanded templates instead of materializing "
+                        "one entry per object/operation)")
+    p.add_argument("--triggers-output", default=None,
+                   help="Path for the trigger registry side-file (default: "
+                        "<parent of --output-dir>/registry-triggers.json). "
+                        "This is a catalog of every IS trigger node type "
+                        "found by `flow registry search`. The START form is "
+                        "not materialized into the main library because "
+                        "`flow registry get <trigger>` requires "
+                        "--connection-id, which would gate the full library "
+                        "build on the user having a connection for every "
+                        "trigger-supporting connector; its WAIT twin "
+                        "(`uipath.connector.event.<key>.<event>`) answers "
+                        "offline and IS generated, and the SDK derives the "
+                        "start form from it.")
+    p.add_argument("--keep-temp", action="store_true",
+                   help="Keep cache directories after run")
+    p.add_argument("--connectors", default=None,
+                   help="Comma-separated connector keys to include (e.g. "
+                        "'uipath-salesforce-slack,uipath-atlassian-jira'). When set, "
+                        "only these connectors' action node types are enriched + "
+                        "materialized — a CURATED subset of the full registry. Avoids "
+                        "the cost of enriching all ~149 connectors. Default: all.")
+    p.add_argument("--catalog-scope", choices=("all", "tier1", "tier2"),
+                   default="all",
+                   help="Connector catalog scope. 'tier1' and 'tier2' select "
+                        "connector keys whose live `uip is connectors metadata` "
+                        "Tier field is '1' or '2'; 'all' keeps the complete "
+                        "catalog (default: all).")
+    p.add_argument("--concurrency", type=int, default=10,
+                   help="Parallel remote CLI calls (default: 10)")
+    return p.parse_args()
+
+
+# ---------------------------------------------------------------------------
+# Registry interaction
+# ---------------------------------------------------------------------------
+
+def registry_search(cache_dir):
+    """Run uip flow registry search and return list of connector node types."""
+    search_file = os.path.join(cache_dir, "_search_results.json")
+    if not os.path.exists(search_file):
+        print("Running registry search...")
+        result = subprocess.run(
+            ["uip", "maestro", "flow", "registry", "search",
+             "--filter", "tags:in=connector", "--output", "json"],
+            capture_output=True, text=True
+        )
+        if result.returncode != 0:
+            print(f"Registry search failed: {result.stderr}", file=sys.stderr)
+            sys.exit(1)
+        os.makedirs(cache_dir, exist_ok=True)
+        with open(search_file, "w") as f:
+            f.write(result.stdout)
+
+    with open(search_file) as f:
+        data = json.load(f)
+
+    return [
+        entry["NodeType"]
+        for entry in data.get("Data", [])
+        if entry["NodeType"].startswith("uipath.connector.")
+    ]
+
+
+def write_triggers_side_file(cache_dir, output_path):
+    """Write a flat catalog of every IS trigger nodeType in the registry.
+
+    Triggers can't be materialized into the main library because
+    `uip flow registry get <trigger>` requires `--connection-id`, and the
+    library generator can't know which connection to use for the ~70
+    different trigger-supporting connectors. The registry SEARCH does list
+    every trigger nodeType with name + description + version + tags
+    (connection-less), so we capture those into a side-file. Downstream
+    tools (the emitter, the dispatcher, the n8n classification) consult this
+    file for trigger existence/lookup; full per-trigger schema fetch is
+    deferred to author time (when the user has a connection).
+    """
+    search_file = os.path.join(cache_dir, "_search_results.json")
+    if not os.path.exists(search_file):
+        print(f"  WARN: search cache missing at {search_file}; "
+              f"can't write triggers side-file", file=sys.stderr)
+        return 0
+
+    with open(search_file) as f:
+        data = json.load(f)
+
+    triggers = []
+    for entry in data.get("Data", []) or []:
+        node_type = entry.get("NodeType", "")
+        if not node_type.startswith("uipath.connector.trigger."):
+            continue
+        parts = node_type.split(".")
+        connector_key = parts[3] if len(parts) > 3 else ""
+        triggers.append({
+            "NodeType": node_type,
+            "DisplayName": entry.get("DisplayName", ""),
+            "Description": entry.get("Description", ""),
+            "Version": entry.get("Version", ""),
+            "connectorKey": connector_key,
+        })
+
+    triggers.sort(key=lambda t: (t["connectorKey"], t["NodeType"]))
+
+    envelope = {
+        "schemaVersion": "1",
+        "note": (
+            "Catalog of every IS trigger nodeType returned by "
+            "`uip maestro flow registry search --filter tags:in=connector`. "
+            "Full per-trigger schemas (filterFields, outputFields, eventMode) "
+            "require `--connection-id` on `uip flow registry get`, which "
+            "the library generator can't supply across all ~70 "
+            "trigger-supporting connectors. Use this side-file for the "
+            "'does an IS trigger exist for X provider?' question; fetch the "
+            "full schema at author time with `uip is triggers describe "
+            "<connector-key> <op> <object> --connection-id <id>`."
+        ),
+        "count": len(triggers),
+        "triggers": triggers,
+    }
+
+    os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
+    with open(output_path, "w") as f:
+        json.dump(envelope, f, indent=2)
+        f.write("\n")
+    print(f"  wrote {len(triggers)} triggers to {output_path}")
+    return len(triggers)
+
+
+def registry_get(node_type, cache_dir, quiet=False):
+    """Fetch a single connector's JSON, using cache if available.
+
+    `quiet` suppresses the failure WARN — for a caller probing which of
+    several node-type namespaces an action lives in, where a miss is an
+    expected answer rather than a problem to report.
+    """
+    safe_name = node_type.replace(".", "_")
+    cache_file = os.path.join(cache_dir, f"{safe_name}.json")
+    if os.path.exists(cache_file):
+        return cache_file
+
+    result = subprocess.run(
+        ["uip", "maestro", "flow", "registry", "get", node_type, "--output", "json"] + _conn_args(),
+        capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        if not quiet:
+            print(f"  WARN: registry get failed for {node_type}: {result.stderr.strip()}",
+                  file=sys.stderr)
+        return None
+
+    with open(cache_file, "w") as f:
+        f.write(result.stdout)
+    return cache_file
+
+
+def fetch_all(node_types, cache_dir, concurrency):
+    """Fetch all connector JSONs in parallel."""
+    os.makedirs(cache_dir, exist_ok=True)
+    results = {}
+    already_cached = 0
+    to_fetch = []
+
+    for nt in node_types:
+        safe_name = nt.replace(".", "_")
+        cache_file = os.path.join(cache_dir, f"{safe_name}.json")
+        if os.path.exists(cache_file):
+            results[nt] = cache_file
+            already_cached += 1
+        else:
+            to_fetch.append(nt)
+
+    if already_cached:
+        print(f"  {already_cached} connectors already cached, {len(to_fetch)} to fetch")
+
+    if to_fetch:
+        with ThreadPoolExecutor(max_workers=concurrency) as pool:
+            futures = {pool.submit(registry_get, nt, cache_dir): nt for nt in to_fetch}
+            done = 0
+            for future in as_completed(futures):
+                nt = futures[future]
+                done += 1
+                path = future.result()
+                if path:
+                    results[nt] = path
+                if done % 50 == 0 or done == len(to_fetch):
+                    print(f"  Fetched {done}/{len(to_fetch)}")
+
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Canonical extraction
+# ---------------------------------------------------------------------------
+# Connector entries are kept if they're enabled, cross-platform, and not
+# experimental. We no longer filter on `activityType == "Curated"` — Generic
+# CRUD actions and HTTP escape hatches are kept too. Curated entries land
+# at the connector top level unchanged; Generic CRUD entries are later
+# materialized into per-(object, operation) entries under
+# `<connector>/generic/<object>/<op>@<ver>.json` by `expand_all_generics`.
+
+# Ops the IS CLI exposes as a POST whose inputs are query-string params with a
+# required (often empty) body. A dispatcher reads `operation.dispatchStyle == "query-post"`
+# and dispatches `run create <obj> --query <inputs> --body '{}'` instead of the
+# default create→--body. Keyed by (connectorKey, objectName). The registry does not
+# expose per-parameter location, so this is a small explicit list rather than derived.
+CURATED_DISPATCH_STYLE = {
+    ("uipath-uipath-dataservice", "QueryEntityRecords_V3"): "query-post",
+    # The V2 curated sibling, and the one the REGISTRY node
+    # `uipath.connector.uipath-uipath-dataservice.query-entity-records` maps to:
+    # POST /v2/{entityName}/qer, every input a path or query parameter, body `{}`.
+    # Verified live 2026-07-31 — `run create … --query '{entityName,queryExpression,
+    # limit}' --body '{}'` returns the 8 BillingDisputeERP rows.
+    ("uipath-uipath-dataservice", "QueryEntityRecordsCurated"): "query-post",
+}
+
+# Per-parameter value-grammar tags, keyed by (connectorKey, objectName). A dispatcher
+# validates the COMPUTED input against `operation.paramGrammars` at every
+# dispatch boundary — fixture replay included, so `flow-cli test` catches a
+# malformed value offline. "sql-where": Data Service query expressions (RHS
+# string literals must be single-quoted; an unquoted `ACCT-98201-NE` parses as
+# subtraction server-side and 400s). Explicit list like dispatchStyle — the
+# registry doesn't describe value grammars.
+CURATED_PARAM_GRAMMARS = {
+    ("uipath-uipath-dataservice", "QueryEntityRecords_V3"): {"queryExpression": "sql-where"},
+    ("uipath-uipath-dataservice", "QueryEntityRecords"): {"queryExpression": "sql-where"},
+    ("uipath-uipath-dataservice", "QueryEntityRecordsCurated"): {"queryExpression": "sql-where"},
+}
+
+# A few connector ops the registry enumerates only in a form `uip is resources run`
+# can't dispatch. The Outlook reply op is enumerated as the MULTIPART `ReplyToEmailV2`
+# (its `body`/`file` are `multipart` params, which a JSON `--body` can't build). The
+# connector also exposes the non-multipart sibling `ReplyToEmail` (`id` in --query, the
+# reply text in --body) that Flow v1 uses and a dispatcher sends via the per-parameter
+# arg split. We curate a remap to that sibling so a clean regen reproduces the
+# live-runnable op rather than the undispatchable multipart one. Keyed by (connectorKey,
+# registry objectName); deep-merged into `operation` AFTER enrichment so it wins over the
+# `is resources describe` params. The node's `inputSchema` (the reply `comment` + message
+# fields) is left as enrichment derives it — only the query params + objectName/path change.
+CURATED_OP_OVERRIDE = {
+    ("uipath-microsoft-outlook365", "ReplyToEmailV2"): {
+        "operation": {
+            "objectName": "ReplyToEmail",
+            "path": "/ReplyToEmail",
+            "parameters": [
+                {"name": "id", "type": "query", "dataType": "string", "required": True,
+                 "displayName": "Message ID",
+                 "description": "The id of the email to reply to"},
+            ],
+        },
+    },
+}
+
+
+def apply_curated_overrides(entries):
+    """Deep-merge CURATED_OP_OVERRIDE into matching entries, AFTER enrichment, so the
+    curated shape wins over the registry-described one. Matches on (connectorKey,
+    objectName) using the entry's current (registry) objectName."""
+    n = 0
+    for e in entries:
+        key = (e.get("connector", {}).get("key", ""),
+               e.get("operation", {}).get("objectName", ""))
+        override = CURATED_OP_OVERRIDE.get(key)
+        if not override:
+            continue
+        for section, fields in override.items():
+            e.setdefault(section, {})
+            for k, v in fields.items():
+                e[section][k] = v
+        n += 1
+    if n:
+        print(f"  Applied {n} curated op override(s)")
+    return entries
+
+
+def _context_value(context, name):
+    """Return the `value` of a context entry by name, or None."""
+    for c in context:
+        if c.get("name") == name:
+            return c.get("value")
+    return None
+
+
+def _has_context(context, name):
+    return any(c.get("name") == name for c in context)
+
+
+def _parameter_metadata(connector_method_info):
+    """Field-shaped metadata carried by each method parameter, keyed by name.
+
+    A method parameter and a node field describe the same input in two
+    different schemas. These are the keys that exist on both sides, so they
+    are the only ones worth moving across: `format`, `mask`, `design`,
+    `sortOrder`, `curated`, `defaultValue` and `experimental` have no
+    counterpart on a field, and a node's own field vocabulary never carries
+    them.
+
+    `reference` is the one that matters most — it names the collection a value
+    is looked up in (a Slack channel, a Drive file), and without it an author
+    has no way to turn a display name into the id the API wants.
+    """
+    out = {}
+    for p in (connector_method_info or {}).get("parameters") or []:
+        name = p.get("name")
+        if not isinstance(name, str) or not name:
+            continue
+        meta = {}
+        if p.get("displayName") is not None:
+            meta["displayName"] = p["displayName"]
+        if p.get("reference") is not None:
+            meta["reference"] = p["reference"]
+        # A parameter's `enum` is deprecated in favour of `enhancedEnum`, whose
+        # `{name, value}` pairs flatten to the literals a field's `enum` holds.
+        if "enum" in p:
+            meta["enum"] = p["enum"]
+        elif p.get("enhancedEnum"):
+            values = [
+                e.get("value")
+                for e in p["enhancedEnum"]
+                if isinstance(e, dict) and e.get("value") is not None
+            ]
+            if values:
+                meta["enum"] = values
+        if meta:
+            out[name] = meta
+    return out
+
+
+def extract_canonical(json_path):
+    """Build a canonical-library entry from one raw registry JSON file.
+
+    Returns the entry dict, or None if the connector is filtered out
+    (not enabled, not curated, etc.).
+    """
+    with open(json_path) as f:
+        data = json.load(f)
+
+    node = data.get("Data", {}).get("Node")
+    if not node:
+        return None
+
+    node_type = node.get("nodeType", "")
+    model = node.get("model", {}) or {}
+    context = model.get("context", []) or []
+
+    # Activity-level metadata moved out of model.context.metadata into the
+    # editor form. Search `node.form.sections[*].fields[*].componentProps`
+    # for the `connectorDetail` block — it carries isEnabled / targetPlatform
+    # / isExperimental / configuration (a JSON string with activityType etc).
+    connector_detail = None
+    for section in (node.get("form", {}) or {}).get("sections", []) or []:
+        for f in section.get("fields", []) or []:
+            cp = (f.get("componentProps") or {}).get("connectorDetail")
+            if isinstance(cp, dict) and "configuration" in cp:
+                connector_detail = cp
+                break
+        if connector_detail:
+            break
+
+    if not connector_detail:
+        return None
+
+    if not connector_detail.get("isEnabled", False):
+        return None
+    if connector_detail.get("targetPlatform") != "CrossPlatform":
+        return None
+    if connector_detail.get("isExperimental", True):
+        return None
+
+    try:
+        config = json.loads(connector_detail.get("configuration", "{}"))
+    except json.JSONDecodeError:
+        return None
+
+    activity_type = config.get("activityType", "")
+
+    # Operation name — the human-readable verb (Create/Retrieve/etc.) lives
+    # on connectorMethodInfo when present; fall back to the model.context
+    # entry, then to the connectorDetail.configuration blob (Generic CRUD
+    # actions carry it only there).
+    cmi = node.get("connectorMethodInfo", {}) or {}
+    operation_name = (
+        cmi.get("operation")
+        or _context_value(context, "operation")
+        or config.get("operation")
+        or ""
+    )
+
+    # API endpoint path. `connectorMethodInfo.path` is in the un-enriched
+    # registry response (no connection-id needed) and matches the
+    # `inputs.detail.endpoint` field in Flow nodes — see uipath-maestro-flow
+    # connector plugin docs.
+    path = cmi.get("path") or ""
+
+    # Operation/object display name — what the editor uses for "objectDisplayName"
+    # in the Flow configuration blob. Lives under `connectorMethodInfo.curated`
+    # when present; we fall back to the top-level `display.label`.
+    curated = cmi.get("curated") or {}
+    object_display_name = curated.get("displayName") or ""
+
+    # Input fields. The registry describes an operation's inputs in two places
+    # and neither is reliably complete: `inputDefinition.fields` can be missing
+    # outright, or present but stripped down to name/type/required/description
+    # while `connectorMethodInfo.parameters` carries the lookup and the choice
+    # list for the very same input. So take the fields when they exist and fill
+    # their gaps from the parameters, and build them from the parameters when
+    # they do not. Gaps only: a value the node already states wins, because
+    # that is the node's own view of itself.
+    param_meta = _parameter_metadata(cmi)
+    declared_fields = node.get("inputDefinition", {}).get("fields") or []
+    input_fields = []
+    if declared_fields:
+        for declared in declared_fields:
+            merged = dict(declared)
+            for key, value in param_meta.get(merged.get("name"), {}).items():
+                merged.setdefault(key, value)
+            input_fields.append(merged)
+    else:
+        for p in cmi.get("parameters", []) or []:
+            f = {
+                "name": p.get("name", ""),
+                "type": p.get("dataType", "string"),
+                "required": p.get("required", False),
+                "description": p.get("description", ""),
+            }
+            f.update(param_meta.get(f["name"], {}))
+            input_fields.append(f)
+
+    output_fields = (
+        node.get("outputDefinition", {}).get("fields")
+        or node.get("outputResponseDefinition", {}).get("fields")
+        or []
+    )
+
+    display = node.get("display", {}) or {}
+
+    entry = {
+        "schemaVersion": SCHEMA_VERSION,
+        "nodeType": node_type,
+        "version": config.get("version", "") or node.get("version", ""),
+        "category": node.get("category", ""),
+        "tags": node.get("tags", []),
+        "connector": {
+            "key": config.get("connectorKey", ""),
+        },
+        "operation": {
+            "name": operation_name,
+            "objectName": config.get("objectName", ""),
+            "objectDisplayName": object_display_name,
+            "httpMethod": config.get("httpMethod", ""),
+            "path": path,
+            "subType": config.get("subType", ""),
+            "supportsStreaming": config.get("supportsStreaming", False),
+            "activityType": activity_type,
+            # A connector EVENT's operation is not `operation.name` — that is
+            # the object's CRUD verb (`Create` on outlook `email-received`).
+            # The event's own operation is the `model.context` entry the
+            # platform stamps (`EMAIL_RECEIVED`), and it is the key every
+            # trigger API takes: `is triggers objects/describe <key>
+            # <OPERATION>`. The SDK compares it too (`identifyEvent` reads
+            # `operation.eventOperation`), so carry it on the entry rather
+            # than making every reader dig through the sidecar's context.
+            **({"eventOperation": _context_value(context, "operation") or ""}
+               if str(activity_type).endswith("Trigger") else {}),
+            **({"eventMode": node.get("eventMode") or ""}
+               if str(activity_type).endswith("Trigger") and node.get("eventMode")
+               else {}),
+        },
+        "display": {
+            "label": display.get("label", "") or node.get("displayName", ""),
+            "description": display.get("description", "") or node.get("description", ""),
+            "icon": display.get("icon", ""),
+            "iconBackground": display.get("iconBackground", ""),
+            "iconBackgroundDark": display.get("iconBackgroundDark", ""),
+        },
+        "runtime": {
+            "bpmnType": model.get("type", ""),
+            "serviceType": model.get("serviceType", ""),
+            "activityConfigurationVersion": _context_value(context, "activityConfigurationVersion") or "",
+            "requiresConnection": _has_context(context, "connection"),
+            "requiresFolderKey": _has_context(context, "folderKey"),
+            # Connector discovery metadata replaces the old empty-schema
+            # heuristic later in merge_connector_record().
+            "requiresConnectionForSchema": False,
+        },
+        "inputSchema":  {"fields": input_fields},
+        "outputSchema": {"fields": output_fields},
+    }
+    # Some operations resolve their real field set from the VALUES of a few
+    # parent fields, so what is above is only what holds before any are known.
+    # Record what a caller has to do about it; without this the catalog reads
+    # as though Jira create-issue takes two inputs.
+    action = schema_action(cmi, input_fields)
+    if action:
+        entry["operation"]["schemaAction"] = action
+    # Curated dispatch-style override: a few ops the IS CLI exposes as a POST whose
+    # inputs are query-string params with a required (empty) body — a dispatcher must
+    # dispatch them as `run create <obj> --query <inputs> --body '{}'`, not the
+    # default create→--body. (Data Service `QueryEntityRecords_V3`:
+    # POST /v3/QueryEntityRecords/query, params entityScope/tenantEntityName/
+    # queryExpression in --query.)
+    _dispatch_style = CURATED_DISPATCH_STYLE.get(
+        (config.get("connectorKey", ""), config.get("objectName", ""))
+    )
+    if _dispatch_style:
+        entry["operation"]["dispatchStyle"] = _dispatch_style
+    # Curated per-parameter grammar tags (see CURATED_PARAM_GRAMMARS): keeps a
+    # clean library regen carrying the same validation contract the committed
+    # curated defs ship, so the dispatch-input gate survives restaging.
+    _param_grammars = CURATED_PARAM_GRAMMARS.get(
+        (config.get("connectorKey", ""), config.get("objectName", ""))
+    )
+    if _param_grammars:
+        entry["operation"]["paramGrammars"] = _param_grammars
+    return entry
+
+
+# ---------------------------------------------------------------------------
+# `is connectors metadata` enrichment (connector-level, not action-level)
+# ---------------------------------------------------------------------------
+#
+# Each connector record carries the display name and the four discovery
+# capabilities from element metadata. Phase 1 deliberately applies the derived
+# schema flag to every activity for the connector.
+
+def is_connector_get(connector_key, cache_dir):
+    """Cached `uip is connectors metadata <key>`.
+
+    Returns the parsed first-element dict, or None on any failure.
+    """
+    # Do not reuse legacy `connectors get` cache files: that output omitted the
+    # discovery capabilities and would silently mark every connector static.
+    safe = _safe_filename(connector_key, "_connector_metadata")
+    cache_file = os.path.join(cache_dir, f"{safe}.json")
+    if os.path.exists(cache_file):
+        with open(cache_file) as f:
+            d = json.load(f)
+        data = d.get("Data") or []
+        return data[0] if isinstance(data, list) and data else None
+    result = subprocess.run(
+        ["uip", "is", "connectors", "metadata", connector_key,
+         "--output", "json"],
+        capture_output=True, text=True
+    )
+    try:
+        payload = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return None
+    if payload.get("Result") != "Success":
+        with open(cache_file, "w") as f:
+            json.dump({"Result": "Failure", "_cached_failure": True}, f)
+        return None
+    with open(cache_file, "w") as f:
+        json.dump(payload, f)
+    data = payload.get("Data") or []
+    return data[0] if isinstance(data, list) and data else None
+
+
+def fetch_connector_records(entries, cache_dir, concurrency):
+    """Fetch one `is connectors metadata` per unique connector key in entries.
+
+    Returns a dict of connector_key → connector record (or None).
+    """
+    keys = sorted({e["connector"]["key"] for e in entries if e["connector"]["key"]})
+    return fetch_connector_records_for_keys(keys, cache_dir, concurrency)
+
+
+def fetch_connector_records_for_keys(keys, cache_dir, concurrency):
+    """Fetch `is connectors metadata` for an iterable of connector keys."""
+    os.makedirs(cache_dir, exist_ok=True)
+    keys = sorted({key for key in keys if key})
+    print(f"  Looking up {len(keys)} connector records...")
+    out = {}
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        futures = {pool.submit(is_connector_get, k, cache_dir): k for k in keys}
+        done = 0
+        for fut in as_completed(futures):
+            k = futures[fut]
+            done += 1
+            try:
+                out[k] = fut.result()
+            except Exception:
+                out[k] = None
+            if done % 50 == 0 or done == len(keys):
+                print(f"  Fetched {done}/{len(keys)} connector records")
+    return out
+
+
+def action_connector_key(node_type):
+    """Return the connector key for an ACTION node type, or None.
+
+    Action node types are `uipath.connector.<key>.<operation>`. The connector
+    event forms carry an extra segment
+    (`uipath.connector.{trigger,event}.<key>.<event>`) and are answered by
+    `event_connector_key` instead.
+    """
+    prefix = "uipath.connector."
+    if not node_type.startswith(prefix):
+        return None
+    remainder = node_type[len(prefix):]
+    if remainder.startswith(("trigger.", "event.")):
+        return None
+    connector_key, separator, _operation = remainder.partition(".")
+    return connector_key if separator and connector_key else None
+
+
+def event_connector_key(node_type):
+    """Return the connector key for a WAIT-form event node type, or None.
+
+    The platform ships every connector event twice — the mid-flow wait
+    `uipath.connector.event.<key>.<event>` and the start trigger
+    `uipath.connector.trigger.<key>.<event>` — and only the WAIT form is
+    answered here, because only it can be generated. `registry get` REFUSES
+    the start form without a live `--connection-id` (a build would then be
+    gated on owning a connection for every trigger-supporting connector),
+    while the wait form answers offline and carries the same identity and
+    payload schema. The SDK derives the start form from its wait sibling when
+    it resolves one (`deriveTriggerForm`), so the single generated entry
+    serves both node types.
+    """
+    prefix = "uipath.connector.event."
+    if not node_type.startswith(prefix):
+        return None
+    connector_key, separator, _event = node_type[len(prefix):].partition(".")
+    return connector_key if separator and connector_key else None
+
+
+def scoped_connector_key(node_type):
+    """The connector a node type belongs to, for SCOPE filtering.
+
+    A scope names CONNECTORS, so a scoped build has to be a subset of the full
+    one — same connectors, same node families. Keying scope on the action form
+    alone made it something else: every connector event silently vanished,
+    because `action_connector_key` answers None for them and None matches no
+    connector. Measured on the tier1 run of 2026-09-04: 507 action node types
+    kept and all 125 event node types dropped, so a scoped library disagreed
+    with the full library (448 events) about which events exist at all.
+    """
+    return action_connector_key(node_type) or event_connector_key(node_type)
+
+
+FIRST_PARTY_PREFIX = "uipath-"
+MOCK_MARKER = "mock"
+
+
+def is_first_party_connector(key):
+    """Does this connector key belong in the PUBLISHED catalog?
+
+    The registry answers with everything the tenant can see, which on a build
+    tenant is not the same set an author should be offered:
+
+    * `custom-<org>-<name>` are connectors somebody built on that tenant. They
+      exist nowhere else, so shipping them advertises operations that resolve
+      for no other user — measured on the 2026-09 build: 9 keys, 168 entries,
+      including `custom-codereval-nulldisplayrepro` and
+      `custom-codereval-customconnectortest`, which are bug repros.
+    * `uipath-mock-*` are the fixtures the eval harness dispatches against.
+      Three keys, 470 entries — the single largest of them, `uipath-mock-jira`
+      at 282, is bigger than most real connectors, so an agent searching for
+      "jira" meets the mock before the product.
+
+    Together 12 of 161 keys and 638 of 8,035 entries (7.9%). An explicit
+    `--connectors <key>` still builds either kind: naming one is a statement
+    that you want it, and the eval harness does.
+    """
+    lowered = str(key or "").lower()
+    return lowered.startswith(FIRST_PARTY_PREFIX) and MOCK_MARKER not in lowered
+
+
+def catalog_connector_key(node_type):
+    """The connector a node type belongs to, in ANY of its three forms.
+
+    `scoped_connector_key` answers the two forms a build can GENERATE — the
+    action and the WAIT event — and deliberately not the START trigger, which
+    `registry get` refuses without a live connection. Membership of a connector
+    is a different question from generability: `uipath.connector.trigger.<key>
+    .<event>` plainly belongs to `<key>`, and a catalog filter reading it as
+    "not a connector node" would keep a tenant-local connector's trigger while
+    dropping its own action and wait siblings — the same half-dropped catalog
+    `scoped_connector_key` was written to prevent, one form over.
+    """
+    key = scoped_connector_key(node_type)
+    if key:
+        return key
+    prefix = "uipath.connector.trigger."
+    if not str(node_type or "").startswith(prefix):
+        return None
+    candidate, _, event = node_type[len(prefix):].partition(".")
+    return candidate if candidate and event else None
+
+
+def select_published_connectors(node_types):
+    """`(kept node types, dropped connector keys)` for a FULL build.
+
+    A node type with no connector key at all is not a connector node, so the
+    catalog rule has nothing to say about it and it is kept — dropping those
+    would be this filter deleting core nodes. Splitting this out of `main` is
+    what makes the selection testable without a registry.
+    """
+    dropped = sorted({
+        key for key in (catalog_connector_key(nt) for nt in node_types)
+        if key and not is_first_party_connector(key)
+    })
+    if not dropped:
+        return list(node_types), []
+    kept = [
+        nt for nt in node_types
+        if is_first_party_connector(catalog_connector_key(nt))
+        or not catalog_connector_key(nt)
+    ]
+    return kept, dropped
+
+
+def connector_tier(record):
+    """Read the connector tier across CLI response casing variants."""
+    if not isinstance(record, dict):
+        return None
+    value = record.get("Tier")
+    if value is None:
+        value = record.get("tier")
+    return str(value).strip() if value is not None else None
+
+
+def normalized_connector_tier(record):
+    """Normalize current and legacy connector tier spellings."""
+    value = connector_tier(record)
+    if value is None:
+        return None
+    normalized = re.sub(r"[^a-z0-9]", "", value.lower())
+    if normalized in {"1", "t1", "tier1"}:
+        return "tier1"
+    if normalized in {"2", "t2", "tier2"}:
+        return "tier2"
+    return None
+
+
+def filter_node_types_by_tier(node_types, connector_records, tier):
+    """Keep the node types whose connector metadata declares `tier`.
+
+    Actions and connector events both, per `scoped_connector_key` — a tier is
+    a set of connectors, and dropping a connector's events while keeping its
+    actions ships a library that contradicts the full build.
+    """
+    if tier not in {"tier1", "tier2"}:
+        raise ValueError(f"unsupported connector tier: {tier}")
+    matching_keys = {
+        key for key, record in connector_records.items()
+        if normalized_connector_tier(record) == tier
+    }
+    return [
+        node_type for node_type in node_types
+        if scoped_connector_key(node_type) in matching_keys
+    ], matching_keys
+
+
+def merge_connector_record(entry, record):
+    """Stamp connector discovery metadata and its Phase 1 derived flag."""
+    if not record:
+        return entry
+    name = record.get("Name")
+    if name:
+        entry["connector"]["name"] = name
+    tier = connector_tier(record)
+    if tier is not None:
+        entry["connector"]["tier"] = tier
+    discovery = {
+        "type": record.get("DiscoveryType") or "",
+        "hasObjectDiscovery": _as_bool(record.get("HasObjectDiscovery")),
+        "hasFieldDiscovery": _as_bool(record.get("HasFieldDiscovery")),
+        "hasCustomObjectDiscovery": _as_bool(
+            record.get("HasCustomObjectDiscovery")
+        ),
+        "hasCustomFieldDiscovery": _as_bool(
+            record.get("HasCustomFieldDiscovery")
+        ),
+    }
+    entry["connector"]["discovery"] = discovery
+    entry["runtime"]["requiresConnectionForSchema"] = any(
+        value for key, value in discovery.items() if key != "type"
+    )
+    return entry
+
+
+def _as_bool(value):
+    """Accept the boolean JSON contract and older Yes/No cache rows."""
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.strip().lower() in {"true", "yes", "1"}
+    return False
+
+
+# ---------------------------------------------------------------------------
+# `is resources describe` enrichment
+# ---------------------------------------------------------------------------
+#
+# `flow registry get` (without --connection-id) returns a sparse view: many
+# connectors come back with empty inputDefinition/outputDefinition and no
+# connectorMethodInfo. `is resources describe <connector> <object>
+# --operation <op>` returns the same data plus path placeholders, parameter
+# split (path vs query), and full request/response field schemas — and
+# crucially does so without a connection ID for ALL schema-static connectors.
+#
+# Schema-DYNAMIC connectors (Salesforce SFDC and similar) return empty
+# requestFields/responseFields without a connection-id. We detect this and
+# tag the entry so downstream tooling knows to consult a per-flow sidecar.
+
+def _safe_filename(*parts):
+    """Sanitize parts of a filename so they survive on any FS."""
+    s = "__".join(parts)
+    return re.sub(r"[^a-zA-Z0-9_.@\-]+", "_", s)
+
+
+def _schema_cache_scope():
+    """Keep static and per-connection schema responses from sharing a cache."""
+    return _CONNECTION_ID or "_static"
+
+
+def _pick(d, *keys):
+    """Return the first non-None value among d[k] for k in keys.
+
+    The `uip is resources describe` CLI switched key casing from camelCase
+    to PascalCase at some point (e.g. `availableOperations` →
+    `AvailableOperations`, `requestFields` → `RequestFields`). Use this in
+    every IS-payload read so we keep working under either CLI version.
+    """
+    if not isinstance(d, dict):
+        return None
+    for k in keys:
+        v = d.get(k)
+        if v is not None:
+            return v
+    return None
+
+
+def _to_lower_camel(s):
+    """Map a PascalCase key to camelCase (first character lowered)."""
+    if not isinstance(s, str) or not s:
+        return s
+    if s[0].isupper():
+        return s[0].lower() + s[1:]
+    return s
+
+
+def _normalize_field_keys(value):
+    """Recursively lower-camel-case every dict key in `value`.
+
+    The IS CLI started returning PascalCase keys for parameters, fields,
+    and references; the existing library uses camelCase, so we normalize
+    on read to keep the on-disk schema stable across CLI versions.
+    """
+    if isinstance(value, dict):
+        return {
+            _to_lower_camel(k): _normalize_field_keys(v)
+            for k, v in value.items()
+        }
+    if isinstance(value, list):
+        return [_normalize_field_keys(v) for v in value]
+    return value
+
+
+def is_describe_operation(connector_key, object_name, operation, cache_dir):
+    """Cached `uip is resources describe <connector> <object> --operation <op>`.
+
+    Returns the parsed Data dict on success, or None on any failure (the
+    connector/object/operation combo doesn't exist, network error, etc.).
+    """
+    parts = [_schema_cache_scope(), connector_key, object_name, operation]
+    field_scope = _field_scope()
+    if field_scope:
+        parts.append(field_scope)
+    safe = _safe_filename(*parts)
+    cache_file = os.path.join(cache_dir, f"{safe}.json")
+    if os.path.exists(cache_file):
+        with open(cache_file) as f:
+            cached = json.load(f)
+        if cached.get("_cached_failure"):
+            _note_failed_field_describe(
+                connector_key, object_name, operation, cached.get("Message")
+            )
+        return cached.get("Data")
+
+    result = subprocess.run(
+        ["uip", "is", "resources", "describe", connector_key, object_name,
+         "--operation", operation, "--output", "json"]
+        + _conn_args() + _field_args(),
+        capture_output=True, text=True
+    )
+    try:
+        payload = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return None
+    if payload.get("Result") != "Success":
+        _note_failed_field_describe(
+            connector_key, object_name, operation, payload.get("Message")
+        )
+        # Cache the failure too, with a sentinel, so retries are skipped. Keep
+        # the message: it is the actionable half of a parent-field rejection.
+        with open(cache_file, "w") as f:
+            json.dump({
+                "Result": "Failure",
+                "_cached_failure": True,
+                "Message": payload.get("Message"),
+            }, f)
+        return None
+    with open(cache_file, "w") as f:
+        json.dump(payload, f)
+    return payload.get("Data")
+
+
+def is_describe_object(connector_key, object_name, cache_dir):
+    """Cached `uip is resources describe <connector> <object>` (no --operation).
+
+    Returns the parsed Data dict on success (with `AvailableOperations`),
+    or None on failure.
+    """
+    safe = _safe_filename(
+        _schema_cache_scope(), connector_key, object_name, "_operations"
+    )
+    cache_file = os.path.join(cache_dir, f"{safe}.json")
+    if os.path.exists(cache_file):
+        with open(cache_file) as f:
+            return json.load(f).get("Data")
+    result = subprocess.run(
+        ["uip", "is", "resources", "describe", connector_key, object_name,
+         "--output", "json"] + _conn_args(),
+        capture_output=True, text=True
+    )
+    try:
+        payload = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return None
+    if payload.get("Result") != "Success":
+        with open(cache_file, "w") as f:
+            json.dump({"Result": "Failure", "_cached_failure": True}, f)
+        return None
+    with open(cache_file, "w") as f:
+        json.dump(payload, f)
+    return payload.get("Data")
+
+
+def is_resources_list(connector_key, cache_dir, operation=None, refresh=False):
+    """Cached `uip is resources list <connector>` — returns the object catalog.
+
+    Each entry has `Name`, `DisplayName`, `Path`, `Type`, `SubType`.
+    Returns the list on success (possibly empty), or None on failure.
+
+    `refresh` bypasses BOTH caches — this module's file cache and the CLI's own.
+    `uip is resources list` answers from a local cache that never invalidates
+    itself, so an object the tenant gained after that cache was written reads as
+    nonexistent. Measured on uipath-salesforce-sfdc: 18 objects from the stale
+    cache, 864 with `--refresh`, and `InvoiceShare` only in the second. Refreshing
+    on every call would cost a round trip per connector, so callers ask for it
+    when a lookup misses (see `_list_generic_objects`).
+    """
+    safe = _safe_filename(
+        _schema_cache_scope(), connector_key, operation or "_all_operations",
+        "_resources_list"
+    )
+    cache_file = os.path.join(cache_dir, f"{safe}.json")
+    if not refresh and os.path.exists(cache_file):
+        with open(cache_file) as f:
+            d = json.load(f)
+        return d.get("Data") if isinstance(d.get("Data"), list) else None
+    command = ["uip", "is", "resources", "list", connector_key]
+    if operation:
+        command.extend(["--operation", operation])
+    if refresh:
+        command.append("--refresh")
+    command.extend(["--output", "json"])
+    result = subprocess.run(
+        command + _conn_args(),
+        capture_output=True, text=True
+    )
+    try:
+        payload = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return None
+    if payload.get("Result") != "Success":
+        with open(cache_file, "w") as f:
+            json.dump({"Result": "Failure", "_cached_failure": True}, f)
+        return None
+    with open(cache_file, "w") as f:
+        json.dump(payload, f)
+    return payload.get("Data") if isinstance(payload.get("Data"), list) else None
+
+
+# Map from registry httpMethod (e.g. "GETBYID") to a guess at the
+# `is resources` operation name. The `is resources` API uses verb names like
+# "Retrieve" / "List" / "Create"; the registry uses HTTP-method-shaped strings.
+HTTP_METHOD_TO_OPERATION = {
+    "GET": "List",
+    "GETBYID": "Retrieve",
+    "POST": "Create",
+    "PATCH": "Update",
+    "PUT": "Replace",
+    "DELETE": "Delete",
+}
+
+
+def discover_operation_name(entry, is_cache_dir):
+    """Find the `is resources` operation name for an entry whose
+    canonical `operation.name` is empty.
+
+    Strategy: list available operations on the object, then match by the
+    httpMethod we already extracted from the registry.
+    """
+    connector_key = entry["connector"]["key"]
+    object_name = entry["operation"]["objectName"]
+    http_method = entry["operation"]["httpMethod"]
+    if not connector_key or not object_name:
+        return None
+    obj_data = is_describe_object(connector_key, object_name, is_cache_dir)
+    if not obj_data:
+        return None
+    for op in _pick(obj_data, "AvailableOperations", "availableOperations") or []:
+        if _pick(op, "Method", "method") == http_method:
+            return _pick(op, "Name", "name")
+    return None
+
+
+def enrich_entry(entry, is_cache_dir):
+    """Augment a canonical entry with `is resources describe` data.
+
+    Returns the (mutated) entry. On any failure (object not found, no
+    operation match, etc.) returns the entry unchanged so the pipeline
+    degrades gracefully.
+    """
+    connector_key = entry["connector"]["key"]
+    object_name = entry["operation"]["objectName"]
+    op_name = entry["operation"]["name"]
+
+    # Fallback: no operation name from the registry — discover via httpMethod.
+    if not op_name:
+        op_name = discover_operation_name(entry, is_cache_dir) or \
+                  HTTP_METHOD_TO_OPERATION.get(entry["operation"]["httpMethod"])
+    if not op_name:
+        return entry  # nothing to do
+
+    data = is_describe_operation(connector_key, object_name, op_name, is_cache_dir)
+    # The registry's verb and the IS CLI's can DISAGREE for the same operation,
+    # and the disagreement used to end enrichment silently — the entry kept its
+    # registry `path`, gained no `pathTemplate`, and carried NO `parameters` at
+    # all, which is an operation nothing can dispatch. Measured on Data Service
+    # `QueryEntityRecordsCurated`: the registry says
+    # `connectorMethodInfo.operation: "List"`, and `describe … --operation List`
+    # answers *"Operation 'List' not found. Available: Create"*. So when the
+    # registry's name does not resolve, ask the OBJECT which operations it
+    # actually has and retry with the one whose HTTP method matches
+    # (`discover_operation_name` — already written for the empty-name case, and
+    # the same question one condition over).
+    #
+    # `operation.name` deliberately keeps the REGISTRY's verb even when the
+    # describe answered under another: it maps to a CRUD verb (List →
+    # `list`) and gen-tests synthesises the offline fixture from it, so
+    # rewriting it here would change how a correct flow replays. What the
+    # discovered name is for is reaching the schema.
+    if not data:
+        alt = discover_operation_name(entry, is_cache_dir)
+        if alt and alt != op_name:
+            data = is_describe_operation(connector_key, object_name, alt, is_cache_dir)
+    if not data:
+        return entry  # connector might be a stub or recently removed
+
+    op_data = _pick(data, "Operation", "operation") or {}
+
+    # If we'd discovered the name via fallback, persist it now.
+    op_resolved_name = _pick(op_data, "Name", "name")
+    if not entry["operation"]["name"] and op_resolved_name:
+        entry["operation"]["name"] = op_resolved_name
+
+    # Path with placeholders (supersedes the simple `path` we extracted).
+    op_path = _pick(op_data, "Path", "path")
+    if op_path:
+        entry["operation"]["pathTemplate"] = op_path
+    # Object/operation display name from `is resources` data.
+    if not entry["operation"].get("objectDisplayName"):
+        display_name = _pick(data, "DisplayName", "displayName")
+        if display_name:
+            entry["operation"]["objectDisplayName"] = display_name
+    op_curated = _pick(op_data, "Curated", "curated")
+    if op_curated and not entry["display"].get("operationLabel"):
+        entry["display"]["operationLabel"] = op_curated
+
+    # Parameters (path / query) — keep the raw shape (camelCase keys);
+    # downstream tooling filters by `type` (path | query).
+    params = _pick(data, "Parameters", "parameters") or []
+    if params:
+        entry["operation"]["parameters"] = _normalize_field_keys(params)
+
+    # Do not infer schema discovery from empty field lists: delete and file
+    # operations legitimately expose neither. Connector metadata owns that flag.
+    request_fields = _pick(data, "RequestFields", "requestFields") or []
+    response_fields = _pick(data, "ResponseFields", "responseFields") or []
+
+    if request_fields:
+        # Replace/augment the registry-derived inputSchema.
+        entry["inputSchema"] = {"fields": _normalize_field_keys(request_fields)}
+    if response_fields:
+        entry["outputSchema"] = {"fields": _normalize_field_keys(response_fields)}
+
+    return entry
+
+
+def enrich_all(entries, is_cache_dir, concurrency):
+    """Run enrich_entry on every canonical entry in parallel."""
+    os.makedirs(is_cache_dir, exist_ok=True)
+    enriched = [None] * len(entries)
+    pathTemplate_added = 0
+    schema_added = 0
+
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        futures = {pool.submit(enrich_entry, e, is_cache_dir): i
+                   for i, e in enumerate(entries)}
+        done = 0
+        for fut in as_completed(futures):
+            i = futures[fut]
+            done += 1
+            try:
+                enriched[i] = fut.result()
+            except Exception as exc:
+                # Non-fatal — keep the un-enriched entry.
+                enriched[i] = entries[i]
+                print(f"  WARN: enrichment failed for {entries[i]['nodeType']}: {exc}",
+                      file=sys.stderr)
+            if done % 100 == 0 or done == len(entries):
+                print(f"  Enriched {done}/{len(entries)}")
+
+    for e in enriched:
+        if e.get("operation", {}).get("pathTemplate"):
+            pathTemplate_added += 1
+        if e.get("inputSchema", {}).get("fields") or e.get("outputSchema", {}).get("fields"):
+            schema_added += 1
+
+    print(f"  pathTemplate added on {pathTemplate_added}/{len(entries)}")
+    print(f"  schema added/augmented on {schema_added}/{len(entries)}")
+    return enriched
+
+
+# ---------------------------------------------------------------------------
+# Generic-action expansion
+# ---------------------------------------------------------------------------
+#
+# A Generic registry action (e.g. `uipath.connector.<key>.insert-record`) is
+# an untyped runtime dispatcher: the object (Contact, Issue, …) is picked at
+# design time, not baked into the action. We materialize one library entry
+# per `(connector, object, operation)` the IS resources catalog advertises,
+# using the matching Generic action (by HTTP method) as a template.
+#
+# Layout (per the design decision):
+#   library/<connector>/generic/<object>/<op>@<ver>.json
+#
+# The expanded entries keep the *source* Generic nodeType so an emitter can produce
+# a valid Flow node by re-stamping `operation.objectName` onto the same
+# nodeType the editor uses.
+
+# Registry CRUD verbs are the recognised Generic templates. HTTP escape
+# hatches (`*-http-request`, objectName usually `httpRequest` but
+# sometimes null) are kept as-is, not expanded — there's no object catalog
+# to iterate.
+_HTTP_PASSTHROUGH_OBJECT_NAMES = {"httpRequest", "HttpRequest", "http_request"}
+
+
+def _is_http_passthrough(entry):
+    if entry["operation"].get("objectName") in _HTTP_PASSTHROUGH_OBJECT_NAMES:
+        return True
+    # Some connectors leave objectName null on the http-request action;
+    # fall back to recognising the nodeType suffix.
+    action_id = _action_id_from_node_type(entry["nodeType"])
+    return action_id.endswith("http-request")
+
+
+def _generic_templates_by_op(generic_entries):
+    """Bucket Generic CRUD entries by IS operation name per connector.
+
+    Generic CRUD actions carry an `operation` verb in their configuration
+    (e.g. `Create`/`Delete`/`Retrieve`/`List`/`Update`/`Replace`) but no
+    `httpMethod`. The IS resources catalog returns the same verb names
+    under `AvailableOperations[].Name`, so bucketing by op name lets us
+    match each (object, op) advertised by IS to the right template.
+
+    Returns {connector_key: {op_name: entry}}.
+    """
+    out = {}
+    for e in generic_entries:
+        if _is_http_passthrough(e):
+            continue
+        op_name = (e["operation"].get("name") or "").strip()
+        if not op_name:
+            continue
+        key = e["connector"]["key"]
+        if not key:
+            continue
+        out.setdefault(key, {})[op_name] = e
+    return out
+
+
+def _make_expanded_entry(template, obj, op, op_data):
+    """Build one expanded entry from a Generic template + (object, op) pair.
+
+    `obj` is one element of `uip is resources list` (PascalCase keys).
+    `op`  is one element of `Data.AvailableOperations` from
+          `uip is resources describe <key> <obj>` (PascalCase keys).
+    `op_data` is the `Data` payload of
+          `uip is resources describe <key> <obj> --operation <op_name>`
+          (may be None if the call failed — the entry is still written with
+          an empty schema). The connector-derived discovery flag is copied
+          from the template and is never inferred from field counts here.
+    """
+    entry = json.loads(json.dumps(template))  # deep copy
+
+    object_name = obj.get("Name") or ""
+    object_display = obj.get("DisplayName") or object_name
+    op_name = _pick(op, "Name", "name") or ""
+    op_method = _pick(op, "Method", "method") or template["operation"].get("httpMethod", "")
+    op_path = _pick(op, "Path", "path") or ""
+    op_description = _pick(op, "Description", "description") or ""
+
+    entry["operation"]["objectName"] = object_name
+    entry["operation"]["objectDisplayName"] = object_display
+    entry["operation"]["name"] = op_name
+    entry["operation"]["httpMethod"] = op_method
+    entry["operation"]["path"] = op_path
+    entry["operation"]["subType"] = obj.get("SubType") or template["operation"].get("subType", "")
+    entry["operation"]["activityType"] = "GenericExpanded"
+    entry["operation"]["sourceNodeType"] = template["nodeType"]
+
+    entry["display"]["label"] = f"{op_name} {object_display}".strip()
+    if op_description:
+        entry["display"]["description"] = op_description
+
+    # Pull schema + path template from the per-operation describe payload.
+    if op_data:
+        op_inner = _pick(op_data, "Operation", "operation") or {}
+        op_inner_path = _pick(op_inner, "Path", "path")
+        if op_inner_path:
+            entry["operation"]["pathTemplate"] = op_inner_path
+        params = _pick(op_data, "Parameters", "parameters") or []
+        if params:
+            entry["operation"]["parameters"] = _normalize_field_keys(params)
+        request_fields = _pick(op_data, "RequestFields", "requestFields") or []
+        response_fields = _pick(op_data, "ResponseFields", "responseFields") or []
+        entry["inputSchema"] = {"fields": _normalize_field_keys(request_fields)}
+        entry["outputSchema"] = {"fields": _normalize_field_keys(response_fields)}
+    else:
+        entry["inputSchema"] = {"fields": []}
+        entry["outputSchema"] = {"fields": []}
+
+    return entry
+
+
+def expand_generic_for_connector(
+    connector_key, templates_by_op, is_cache_dir, object_names=None
+):
+    """Materialize per-(object, op) entries for one connector.
+
+    Returns a list of expanded entries (possibly empty if the connector has
+    no object catalog or the IS calls fail).
+    """
+    # A prepared overlay usually carries one Generic template. Let the CLI
+    # filter the connected catalog by that verb before we describe objects.
+    objects = _list_generic_objects(
+        connector_key, templates_by_op, is_cache_dir, object_names=object_names
+    )
+    if not objects:
+        return []
+
+    # Dedupe by (object_name, op_name). Some IS resource catalogs list
+    # the same object twice (e.g. uipath-servicenow-servicenow exposes
+    # `curated_incident_task` twice — a 1-of-2,283 quirk that still
+    # propagates into the index as duplicate library entries with
+    # identical paths). Within one connector, the (object, op) pair
+    # should be unique; skip subsequent duplicates.
+    seen_pairs: set[tuple[str, str]] = set()
+    out = []
+    for obj in objects:
+        object_name = obj.get("Name")
+        if not object_name:
+            continue
+        if object_names is not None and object_name not in object_names:
+            continue
+        obj_data = is_describe_object(connector_key, object_name, is_cache_dir)
+        if not obj_data:
+            continue
+        available = _pick(obj_data, "AvailableOperations", "availableOperations") or []
+        for op in available:
+            op_name = _pick(op, "Name", "name")
+            if not op_name:
+                continue
+            pair = (object_name, op_name)
+            if pair in seen_pairs:
+                continue
+            seen_pairs.add(pair)
+            template = templates_by_op.get(op_name)
+            if not template:
+                # No matching Generic action — e.g. the object exposes an
+                # operation whose verb the connector doesn't ship as a
+                # registry node (rare). Skip.
+                continue
+            op_data = is_describe_operation(
+                connector_key, object_name, op_name, is_cache_dir
+            )
+            out.append(_make_expanded_entry(template, obj, op, op_data))
+    return out
+
+
+def _unique_by_name(objects):
+    """First occurrence of each `Name`, in order."""
+    unique = {}
+    for obj in objects or []:
+        object_name = obj.get("Name")
+        if object_name and object_name not in unique:
+            unique[object_name] = obj
+    return unique
+
+
+def _list_generic_objects(
+    connector_key, templates_by_op, is_cache_dir, object_names=None
+):
+    """List and deduplicate the objects available to one connector.
+
+    When the caller named specific objects and the catalog does not contain them,
+    retry once with a refresh before believing it. A stale `uip is resources
+    list` cache reports a real object as missing, and the error that follows —
+    "object X was not found or does not support action Y" — sends the reader
+    looking for a connector problem that is not there.
+    """
+    operation_filter = (
+        next(iter(templates_by_op)) if len(templates_by_op) == 1 else None
+    )
+    objects = is_resources_list(
+        connector_key, is_cache_dir, operation=operation_filter
+    )
+    unique = _unique_by_name(objects)
+    if object_names and not set(object_names).issubset(unique):
+        refreshed = _unique_by_name(is_resources_list(
+            connector_key, is_cache_dir,
+            operation=operation_filter, refresh=True,
+        ))
+        # Keep the cached answer when the refresh failed outright, so a network
+        # blip does not turn a working lookup into "not found".
+        if refreshed:
+            unique = refreshed
+    return list(unique.values())
+
+
+def _order_by_dependency(parents, fields):
+    """Cascade order for parent fields: a parent another one needs comes first.
+
+    The action's `rules` are not in cascade order — Jira lists
+    `fields.issuetype.id` before `fields.project.key` — but the order is
+    recoverable, because the dependent field's own lookup path carries the
+    other's name (`/project/{fields.project.key}/issuetypes`). `dependsOn` is
+    honoured too where a connector sets it; on the connections measured it was
+    absent even when the path made the dependency plain, so neither source is
+    sufficient alone.
+    """
+    depends = {}
+    for field in fields:
+        name = field.get("name")
+        if name not in parents:
+            continue
+        reference = field.get("reference") or {}
+        path = str(reference.get("path") or "")
+        explicit = reference.get("dependsOn") or []
+        depends[name] = {
+            other for other in parents
+            if other != name
+            and ("{" + other + "}" in path or other in explicit)
+        }
+    ordered, remaining = [], list(parents)
+    while remaining:
+        free = [p for p in remaining if not depends.get(p, set()) & set(remaining)]
+        if not free:
+            # A cycle should not happen; emit the rest rather than loop.
+            ordered.extend(remaining)
+            break
+        ordered.extend(free)
+        remaining = [p for p in remaining if p not in free]
+    return ordered
+
+
+def schema_action(connector_method_info, input_fields):
+    """The design-time action that resolves an operation's REAL field set.
+
+    Some operations do not have one field list. Jira `create-issue` describes to
+    2 fields with nothing supplied — just the parents that select the schema —
+    and to 32 once a project and an issue type are given; a different issue type
+    in the same project gives a different set again. Salesforce
+    `curated_soqlQuery` is the same mechanism driven by the query text.
+
+    Studio Web runs these automatically as the parent fields change, and
+    `uip is resources describe -f name=value` ports the same call. Neither is
+    discoverable from the catalog today, because the library drops
+    `connectorMethodInfo.design` — so an author reads 2 fields and concludes the
+    operation takes two inputs.
+
+    Recorded here as what a caller has to DO, not as the raw action:
+
+    - `parents`  the fields whose values select the schema, in cascade order
+    - `trigger`  a rule field carrying no `refFieldValues` is a button, not
+                 data: Salesforce's `generateSchema` has to be invoked
+                 explicitly, whereas Jira fires on the parents alone
+    - `replaces` which half the result replaces. Jira remaps `input`, so it
+                 yields the REQUEST fields; a SOQL query remaps `output`, so it
+                 yields the RESPONSE shape. Saying "it gives you the inputs"
+                 would be wrong for half of them.
+    """
+    design = (connector_method_info or {}).get("design") or {}
+    candidates = []
+    for action in design.get("actions") or []:
+        if action.get("actionType") != "api":
+            continue
+        parents, trigger = [], None
+        for rule in action.get("rules") or []:
+            name = rule.get("refFieldName")
+            if not name:
+                continue
+            if rule.get("refFieldValues"):
+                parents.append(name)
+            elif trigger is None:
+                trigger = name
+        if not parents:
+            continue
+        candidates.append((action, parents, trigger))
+    if not candidates:
+        return None
+
+    # A node can declare more than one. SAP OData `list-all-entity-records`
+    # offers GenerateSchemaWithExpand(entity, $expand) alongside
+    # GenerateSchema(entity), and recording the first one read demands
+    # `$expand` — an optional OData feature — before the schema resolves at
+    # all. The smallest parent set is the one every caller can satisfy. Ties
+    # keep declaration order.
+    action, parents, trigger = min(candidates, key=lambda c: len(c[1]))
+
+    remap = (action.get("onSuccess") or {}).get("remapConfiguration") or {}
+    record = {
+        "name": action.get("name") or "",
+        "parents": _order_by_dependency(parents, input_fields),
+    }
+    if trigger:
+        record["trigger"] = trigger
+    # Which half the result replaces. Jira create-issue remaps `input`, so it
+    # yields REQUEST fields; a SOQL query remaps `output`, so it yields the
+    # RESPONSE shape. Several — Drive `apply-file-labels`, SAP BAPI, SAP OData,
+    # every Data Service node — remap BOTH, and calling that "input" hides
+    # that the response shape changes too.
+    replaces_input = remap.get("input") == "replace"
+    replaces_output = remap.get("output") == "replace"
+    if replaces_input and replaces_output:
+        record["replaces"] = "both"
+    elif replaces_input:
+        record["replaces"] = "input"
+    elif replaces_output:
+        record["replaces"] = "output"
+    return record
+
+
+def objects_come_from_the_connection(entry):
+    """True when this connector's object set is only knowable per connection.
+
+    `hasObjectDiscovery` / `hasCustomObjectDiscovery` say the objects live on
+    the tenant. Expanding those offline bakes whichever objects the generation
+    tenant happened to have — a list that is incomplete by definition (it can
+    never contain a caller's custom objects) and is not necessarily the
+    caller's at all. Worse, the expansions advertise those objects as available
+    nodes while carrying no schema, and collide with the curated nodes that do:
+    Salesforce ships two entries labelled "Create Account", one with 13 fields
+    and one with none.
+
+    So for these connectors we ship one entry per verb instead, marked for
+    discovery, and let the author list the objects against their own
+    connection. Field discovery alone does NOT qualify: the object set is still
+    knowable offline, so expanding is still worth doing even though each
+    object's fields have to be described live.
+    """
+    discovery = (entry.get("connector") or {}).get("discovery") or {}
+    return bool(
+        discovery.get("hasObjectDiscovery")
+        or discovery.get("hasCustomObjectDiscovery")
+    )
+
+
+def as_discovery_entry(entry):
+    """Recast a Generic CRUD template as the discovery entry we ship for it.
+
+    The label matters as much as the flag: the expanded entries were labelled
+    per object ("Update Account"), so nothing in the catalog ever read as
+    "Update Record" and a caller asking for that found nothing.
+    """
+    entry["operation"]["objectFromDiscovery"] = True
+    entry["operation"]["objectName"] = ""
+    name = entry["operation"].get("name") or ""
+    if name:
+        entry["display"]["label"] = (
+            "List Records" if name == "List" else f"{name} Record"
+        )
+    return entry
+
+
+def disambiguate_discovery_labels(entries):
+    """Keep two discovery entries on one connector from sharing a label.
+
+    `as_discovery_entry` names by verb, so a connector carrying two List-ish
+    Generic nodes ends up with two entries both labelled "List Records":
+    Salesforce ships `list-records` AND `search-records`. The label is what an
+    agent searches on, so identical labels leave the two indistinguishable.
+    Rename only the colliding ones, from their own node type — a connector with
+    a single List node keeps the canonical label.
+    """
+    groups = {}
+    for entry in entries:
+        if not (entry.get("operation") or {}).get("objectFromDiscovery"):
+            continue
+        key = (
+            (entry.get("connector") or {}).get("key"),
+            (entry.get("display") or {}).get("label"),
+        )
+        groups.setdefault(key, []).append(entry)
+    for items in groups.values():
+        if len(items) < 2:
+            continue
+        for entry in items:
+            slug = (entry.get("nodeType") or "").rsplit(".", 1)[-1]
+            if slug:
+                entry["display"]["label"] = (
+                    slug.replace("-", " ").replace("_", " ").title()
+                )
+    return entries
+
+
+def triggers_objects_cached(connector_key, operation, cache_dir):
+    """Cached `uip is triggers objects <key> <OPERATION>` — the EVENT catalog.
+
+    A different catalog from `is resources list`, not a view of it: outlook
+    lists 42 objects for actions and exactly 2 that support the CREATED
+    event. Called WITHOUT a connection on purpose — this pass only runs for
+    connectors whose objects do not come from the connection, and for those
+    the answer is identical either way, so generation stays credential-free.
+    """
+    safe = _safe_filename(_schema_cache_scope(), connector_key, operation,
+                          "_trigger_objects")
+    cache_file = os.path.join(cache_dir, f"{safe}.json")
+    if os.path.exists(cache_file):
+        with open(cache_file) as f:
+            return json.load(f).get("objects") or []
+    try:
+        rows = _events.triggers_objects(connector_key, operation)
+    except _events.EventDiscoveryError as error:
+        print(f"  WARN: trigger objects failed for {connector_key} "
+              f"{operation}: {error}", file=sys.stderr)
+        rows = []
+    with open(cache_file, "w") as f:
+        json.dump({"objects": rows}, f)
+    return rows
+
+
+def triggers_describe_cached(connector_key, operation, object_name, cache_dir):
+    """Cached `uip is triggers describe <key> <OPERATION> <object>`.
+
+    The authority for an event's subscription vocabulary; the registry node's
+    copy is a lossy mirror of it.
+    """
+    safe = _safe_filename(_schema_cache_scope(), connector_key, operation,
+                          object_name, "_trigger_describe")
+    cache_file = os.path.join(cache_dir, f"{safe}.json")
+    if os.path.exists(cache_file):
+        with open(cache_file) as f:
+            return json.load(f).get("describe") or {}
+    try:
+        data = _events.triggers_describe(connector_key, operation, object_name)
+    except _events.EventDiscoveryError as error:
+        print(f"  WARN: trigger describe failed for {connector_key} "
+              f"{operation} {object_name}: {error}", file=sys.stderr)
+        data = {}
+    with open(cache_file, "w") as f:
+        json.dump({"describe": data}, f)
+    return data
+
+
+def _apply_event_schema(entry, describe, obj):
+    """Put an event's OWN schema on the entry, replacing the node manifest's.
+
+    A connector event's `inputDefinition` in the registry manifest is not the
+    subscription's inputs — for outlook `email-received` it is the Message
+    body (`subject`, `body.content`, `toRecipients[*]…`), i.e. the fields you
+    would send to CREATE a message, which an event never sends anywhere. The
+    subscription's actual inputs are its EVENT PARAMETERS, and the platform
+    selects those per field from `fields[*].<field>.events.<OPERATION>`:
+    verified on outlook Message, where describe answers `[parentFolderId]`
+    for EMAIL_RECEIVED (its `events` map names that operation, required) and
+    `[]` for CREATED, while FilterFields stays 15 for both.
+
+    So the entry's `inputSchema` becomes the union rule's answer — describe's
+    `EventParameters` plus the object row's own `Parameters` — and the leftover
+    manifest fields are dropped rather than advertised as inputs.
+    """
+    fields = _events.union_event_parameters(
+        (describe or {}).get("EventParameters"), (obj or {}).get("Parameters"))
+    entry["inputSchema"] = {"fields": fields}
+    output_fields = _events.camel_fields((describe or {}).get("OutputFields"))
+    if output_fields:
+        entry["outputSchema"] = {"fields": output_fields}
+    entry["eventSchema"] = {
+        "eventParameters": fields,
+        "filterFields": _events.camel_fields((describe or {}).get("FilterFields")),
+    }
+    for src, dst in (("EventMode", "eventMode"),
+                     ("ByoaConnection", "byoaConnection"),
+                     ("IsWebhookUrlVisible", "isWebhookUrlVisible")):
+        if (describe or {}).get(src) is not None:
+            entry["eventSchema"][dst] = describe[src]
+    return entry
+
+
+def _describe_curated_events(entries, is_cache_dir, concurrency):
+    """Give each CURATED event its own schema, in place.
+
+    Curated events carry a baked object, so there is nothing to expand — but
+    their vocabulary still has to come from `triggers describe` rather than
+    from the node manifest. Called WITHOUT a connection: what comes back is
+    the tenant-agnostic baseline, which is exactly what a baked library should
+    carry. A connector's custom fields stay `prepare`'s job.
+    """
+    if not entries:
+        return
+    def work(entry):
+        key = entry["connector"]["key"]
+        operation = entry["operation"].get("eventOperation") or ""
+        object_name = entry["operation"].get("objectName") or ""
+        if not operation or not object_name:
+            return entry, None, None
+        rows = triggers_objects_cached(key, operation, is_cache_dir)
+        obj = next((r for r in rows if r.get("Name") == object_name), None)
+        return (entry,
+                triggers_describe_cached(key, operation, object_name, is_cache_dir),
+                obj)
+
+    described = 0
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        for entry, describe, obj in pool.map(work, entries):
+            if not describe:
+                continue
+            _apply_event_schema(entry, describe, obj)
+            described += 1
+    print(f"  {described}/{len(entries)} curated events described "
+          f"(subscription parameters, filter fields, payload)")
+
+
+def _make_expanded_event_entry(template, obj, describe):
+    """One per-object variant of a generic connector EVENT.
+
+    The variant keeps `activityType: GenericTrigger` deliberately. That value
+    is what tells the SDK an event watches ONE object of the connection — it
+    drives `check`'s EVENT_GENERIC_NO_OBJECT and serialize's refusal to emit
+    an empty `objectName` — so renaming it the way action expansion renames
+    `Generic` to `GenericExpanded` would silently switch both off. The object
+    is carried on `operation.objectName`, which is also the index's variant
+    key, exactly as for an expanded action.
+    """
+    entry = json.loads(json.dumps(template))  # deep copy
+    object_name = obj.get("Name") or ""
+    object_display = obj.get("DisplayName") or object_name
+
+    entry["operation"]["objectName"] = object_name
+    entry["operation"]["objectDisplayName"] = object_display
+    entry["operation"]["sourceNodeType"] = template["nodeType"]
+    label = (template.get("display") or {}).get("label") or ""
+    entry["display"]["label"] = f"{label} ({object_display})".strip()
+
+    # `eventSchema` is stamped onto the sidecar by `write_library`, which is
+    # where the SDK reads a subscription's vocabulary from.
+    return _apply_event_schema(entry, describe, obj)
+
+
+def _expand_generic_events(templates, is_cache_dir, concurrency):
+    """Expand each generic EVENT template into one entry per event object."""
+    if not templates:
+        return []
+    work = []
+    for template in templates:
+        key = template["connector"]["key"]
+        operation = template["operation"].get("eventOperation") or ""
+        if not operation:
+            continue
+        for obj in triggers_objects_cached(key, operation, is_cache_dir):
+            if obj.get("Name"):
+                work.append((template, key, operation, obj))
+    if not work:
+        return []
+
+    expanded = []
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        futures = {
+            pool.submit(triggers_describe_cached, key, operation,
+                        obj["Name"], is_cache_dir): (template, obj)
+            for template, key, operation, obj in work
+        }
+        for future in as_completed(futures):
+            template, obj = futures[future]
+            expanded.append(
+                _make_expanded_event_entry(template, obj, future.result() or {}))
+    print(f"  {len(expanded)} generic EVENT variants expanded from "
+          f"{len(templates)} template(s)")
+    return expanded
+
+
+def resolve_connector_events(entries, is_cache_dir, concurrency):
+    """Give every connector EVENT its real schema; expand the expandable ones.
+
+    Deliberately NOT part of `expand_all_generics`: that function answers a
+    question about Generic CRUD ACTIONS and is skipped by
+    `--skip-generic-expansion`, and an event's schema has nothing to do with
+    that flag. Returns `(entries, expanded)` where `entries` is the input with
+    curated events described in place, and `expanded` holds the per-object
+    variants of the generic events whose objects do not come from the
+    connection.
+    """
+    os.makedirs(is_cache_dir, exist_ok=True)
+    curated, generic = [], []
+    for e in entries:
+        at = e["operation"].get("activityType", "")
+        if at == "CuratedTrigger":
+            # Not expanded — its object is baked in — but its schema still
+            # comes from the event, not from the node manifest.
+            curated.append(e)
+        elif at == "GenericTrigger":
+            # UNKNOWN is not "static". `objects_come_from_the_connection`
+            # reads two flags that are absent whenever connector enrichment
+            # was skipped or failed, and absent reads as False — so a
+            # connector whose objects DO come from the connection would be
+            # expanded with whatever the connection-free listing returns
+            # (Salesforce: its 4 declared objects, not the tenant's 1,178),
+            # and the library would then advertise those four as the whole
+            # catalog. Expand only where the connector positively says its
+            # objects do not come from the connection.
+            discovery = (e.get("connector") or {}).get("discovery")
+            if not discovery:
+                print(f"  WARN: {e['nodeType']} not expanded — no connector "
+                      f"discovery metadata, so whether its objects come from "
+                      f"the connection is unknown", file=sys.stderr)
+            elif not objects_come_from_the_connection(e):
+                generic.append(e)
+    if not curated and not generic:
+        return entries, []
+    _describe_curated_events(curated, is_cache_dir, concurrency)
+    return entries, _expand_generic_events(generic, is_cache_dir, concurrency)
+
+
+def expand_all_generics(entries, is_cache_dir, concurrency):
+    """Expand every Generic entry into per-(object, op) entries.
+
+    Returns (curated_and_passthrough_entries, expanded_entries).
+    Curated entries pass through untouched; HTTP-passthrough Generic
+    entries pass through as one-per-connector library entries; CRUD Generic
+    entries are dropped from the output in favor of their expansions.
+    """
+    os.makedirs(is_cache_dir, exist_ok=True)
+
+    curated_and_passthrough = []
+    generic_crud = []
+    discovery_entries = 0
+    for e in entries:
+        at = e["operation"].get("activityType", "")
+        if at == "Generic":
+            if _is_http_passthrough(e):
+                curated_and_passthrough.append(e)
+            elif objects_come_from_the_connection(e):
+                curated_and_passthrough.append(as_discovery_entry(e))
+                discovery_entries += 1
+            else:
+                generic_crud.append(e)
+        elif at == "GenericTrigger":
+            # A generic connector EVENT poses the same question one level up —
+            # one node type covering every object of the connection — and the
+            # SAME connector flags answer it. Verified against the platform:
+            # outlook (`hasCustomObjectDiscovery: false`) answers `is triggers
+            # objects CREATED` with Message + Calendar whether or not a
+            # connection is passed, so those variants are the same for every
+            # tenant and bake offline; Salesforce (`true`) answers 4 objects
+            # offline and 1,178 against a connection, so it stays a template
+            # the author names an object on and `prepare` materializes.
+            curated_and_passthrough.append(e)
+        else:
+            # Curated or anything else — pass through.
+            curated_and_passthrough.append(e)
+
+    disambiguate_discovery_labels(curated_and_passthrough)
+
+    templates = _generic_templates_by_op(generic_crud)
+    print(f"  {len(generic_crud)} Generic CRUD entries across {len(templates)} connectors")
+    print(f"  {discovery_entries} kept unexpanded: objects come from the connection")
+    print(f"  {sum(1 for e in entries if _is_http_passthrough(e))} HTTP-passthrough entries (kept as-is)")
+
+    expanded = []
+    if not templates:
+        return curated_and_passthrough, expanded
+
+    # Use the same global worker limit for each remote-call phase. Submitting
+    # one future per connector leaves the pool mostly idle when a connector
+    # such as Salesforce or ServiceNow has a much larger object catalog than
+    # the others. Flattening object and operation work prevents that long tail
+    # without creating nested pools that could multiply the concurrency cap.
+    connector_objects = []
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        futures = {
+            pool.submit(_list_generic_objects, k, by_method, is_cache_dir): k
+            for k, by_method in templates.items()
+        }
+        done = 0
+        for fut in as_completed(futures):
+            k = futures[fut]
+            done += 1
+            try:
+                connector_objects.extend(
+                    (k, obj) for obj in fut.result()
+                )
+            except Exception as exc:
+                print(f"  WARN: object listing failed for {k}: {exc}",
+                      file=sys.stderr)
+            if done % 25 == 0 or done == len(templates):
+                print(f"  Listed objects for {done}/{len(templates)} connectors "
+                      f"({len(connector_objects)} objects so far)")
+
+    operation_candidates = []
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        futures = {
+            pool.submit(is_describe_object, k, obj["Name"], is_cache_dir):
+                (k, obj)
+            for k, obj in connector_objects
+        }
+        done = 0
+        for fut in as_completed(futures):
+            k, obj = futures[fut]
+            done += 1
+            try:
+                obj_data = fut.result()
+            except Exception as exc:
+                obj_data = None
+                print(f"  WARN: object describe failed for {k}/"
+                      f"{obj['Name']}: {exc}", file=sys.stderr)
+            if obj_data:
+                available = (
+                    _pick(obj_data, "AvailableOperations", "availableOperations")
+                    or []
+                )
+                seen_op_names = set()
+                for op in available:
+                    op_name = _pick(op, "Name", "name")
+                    if not op_name or op_name in seen_op_names:
+                        continue
+                    seen_op_names.add(op_name)
+                    template = templates[k].get(op_name) if op_name else None
+                    if template:
+                        operation_candidates.append((k, obj, op, template))
+            if done % 100 == 0 or done == len(connector_objects):
+                print(f"  Described {done}/{len(connector_objects)} objects "
+                      f"({len(operation_candidates)} operations so far)")
+
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        futures = {
+            pool.submit(
+                is_describe_operation,
+                k,
+                obj["Name"],
+                _pick(op, "Name", "name"),
+                is_cache_dir,
+            ): (k, obj, op, template)
+            for k, obj, op, template in operation_candidates
+        }
+        done = 0
+        for fut in as_completed(futures):
+            k, obj, op, template = futures[fut]
+            done += 1
+            try:
+                op_data = fut.result()
+            except Exception as exc:
+                op_data = None
+                print(f"  WARN: operation describe failed for {k}/"
+                      f"{obj['Name']}/{_pick(op, 'Name', 'name')}: {exc}",
+                      file=sys.stderr)
+            expanded.append(_make_expanded_entry(template, obj, op, op_data))
+            if done % 100 == 0 or done == len(operation_candidates):
+                print(f"  Expanded {done}/{len(operation_candidates)} "
+                      "object operations")
+
+    schema_dynamic = sum(
+        1 for e in expanded
+        if e["runtime"].get("requiresConnectionForSchema")
+    )
+    print(f"  expanded {len(expanded)} entries from {len(generic_crud)} Generic CRUD actions")
+    print(f"  schema-dynamic among expanded: {schema_dynamic}/{len(expanded)}")
+    return curated_and_passthrough, expanded
+
+
+# ---------------------------------------------------------------------------
+# Library output
+# ---------------------------------------------------------------------------
+
+def _action_id_from_node_type(node_type):
+    """Extract the action segment from a uipath.connector.<key>.<action> nodeType."""
+    parts = node_type.split(".")
+    return parts[-1] if len(parts) >= 4 else node_type.replace(".", "-")
+
+
+def _safe_path_segment(s):
+    """Sanitize a string for use as one path segment."""
+    return re.sub(r"[^a-zA-Z0-9_.\-]+", "_", s) or "_"
+
+
+def _input_field_count(entry):
+    """How much of a schema an entry carries — the tie-break when two claim one
+    path, since whichever loses is dropped from the catalogue entirely."""
+    return len(((entry.get("inputSchema") or {}).get("fields")) or [])
+
+
+def _entry_relpath(entry):
+    """Where to write `entry` relative to the library root.
+
+    Returns the JSON path (sans `.json`); add `.json` / `.v1def.json` to get
+    the final filenames. Expanded Generic entries land under
+    `<connector>/generic/<object>/<op>@<ver>` so the original curated +
+    HTTP-passthrough files stay at the connector top level.
+    """
+    connector_key = entry["connector"]["key"] or "unknown"
+    version = entry["version"] or "0.0.0"
+    if entry["operation"].get("activityType") == "GenericExpanded":
+        obj = _safe_path_segment(entry["operation"]["objectName"] or "object")
+        op = _safe_path_segment((entry["operation"]["name"] or "op").lower())
+        return os.path.join(connector_key, "generic", obj, f"{op}@{version}")
+    action_id = _action_id_from_node_type(entry["nodeType"])
+    # An expanded generic EVENT keeps its template's nodeType (that value is
+    # load-bearing for the SDK — see `_make_expanded_event_entry`), so the
+    # action id alone is the SAME path for every object and the variants would
+    # overwrite each other down to one. The object is what separates them,
+    # exactly as it does for an expanded action.
+    if (entry["operation"].get("activityType") == "GenericTrigger"
+            and entry["operation"].get("objectName")):
+        obj = _safe_path_segment(entry["operation"]["objectName"])
+        return os.path.join(connector_key, "events", obj, f"{action_id}@{version}")
+    return os.path.join(connector_key, f"{action_id}@{version}")
+
+
+def _build_v1_definition(node_data):
+    """Project a registry `Data.Node` into the shape the Flow .flow file
+    expects under definitions[]. The registry response is a near-superset:
+    drop fields the Flow def doesn't carry (`connectorMethodInfo`,
+    `outputResponseDefinition`) and add three standard fields the editor
+    stamps on every connector definition (`supportsErrorHandling`,
+    `inputDefaults`, `debug`).
+    """
+    keep = {
+        k: v for k, v in node_data.items()
+        if k not in ("connectorMethodInfo", "outputResponseDefinition")
+    }
+    keep.setdefault("supportsErrorHandling", True)
+    keep.setdefault("inputDefaults", {})
+    keep.setdefault("debug", {"runtime": "bpmnEngine"})
+    return keep
+
+
+def _load_node_data(json_path):
+    """Pull `Data.Node` from a cached `flow registry get` response."""
+    with open(json_path) as f:
+        d = json.load(f)
+    return d.get("Data", {}).get("Node")
+
+
+def write_library(output_dir, entries, v1def_source_paths):
+    """Write one JSON file per (connector, action, version) plus a sibling
+    `.v1def.json` carrying the Flow definitions[] shape, plus an index.json.
+
+    `v1def_source_paths` maps nodeType → path of the cached registry JSON
+    so we can reach back to the raw `Data.Node` at write time.
+    """
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir)
+    os.makedirs(output_dir, exist_ok=True)
+
+    index = []
+    written = 0
+    claimed = {}
+
+    for entry in entries:
+        connector_key = entry["connector"]["key"] or "unknown"
+        version = entry["version"] or "0.0.0"
+
+        relpath = _entry_relpath(entry)  # no extension
+        # Two entries can land on one path, and the second write used to
+        # silently overwrite the first — leaving index.json one row longer than
+        # the directory. In the tier-1 catalogue it happens once, and not
+        # because of a duplicate: CURATED_OP_OVERRIDE renames Outlook365's
+        # multipart `ReplyToEmailV2` to `ReplyToEmail`, which is also a real
+        # object of its own, so the renamed entry (6 fields, still pointing at
+        # `/ReplyToEmailV2`) collides with the genuine one (10 fields).
+        #
+        # One of them has to go. Prefer the entry with more input fields rather
+        # than whichever the iteration reached first: the thinner one loses
+        # less, and the choice does not flip when the object list is reordered.
+        previous = claimed.get(relpath)
+        if previous is not None:
+            if previous == entry:
+                continue
+            if _input_field_count(entry) <= _input_field_count(previous):
+                print(f"  WARN: {relpath} claimed by two differing entries; "
+                      f"keeping the one with more inputs "
+                      f"({_input_field_count(previous)} vs "
+                      f"{_input_field_count(entry)})", file=sys.stderr)
+                continue
+            # This one is richer — drop the row already recorded for it.
+            print(f"  WARN: {relpath} claimed by two differing entries; "
+                  f"replacing the thinner one "
+                  f"({_input_field_count(previous)} -> "
+                  f"{_input_field_count(entry)})", file=sys.stderr)
+            index[:] = [row for row in index if row["path"] != relpath + ".json"]
+            written -= 1
+        claimed[relpath] = entry
+
+        path = os.path.join(output_dir, relpath + ".json")
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+
+        with open(path, "w") as f:
+            json.dump(entry, f, indent=2)
+            f.write("\n")
+        written += 1
+
+        # Flow definition sidecar — used when emitting a flow. Expanded
+        # Generic entries reuse the source Generic action's `Data.Node` as
+        # a v1def TEMPLATE; the converter is responsible for stamping the
+        # entry's `operation.objectName` and inputSchema into the Flow node
+        # at conversion time.
+        v1def_lookup_key = (
+            entry["operation"].get("sourceNodeType")
+            if entry["operation"].get("activityType") == "GenericExpanded"
+            else entry["nodeType"]
+        )
+        v1def_src = v1def_source_paths.get(v1def_lookup_key)
+        if v1def_src:
+            try:
+                node_data = _load_node_data(v1def_src)
+                if node_data:
+                    v1def = _build_v1_definition(node_data)
+                    # A Generic registry node is only a dispatch template. Its
+                    # connection/object-resolved body fields live on the
+                    # expanded entry, so stamp them into the sidecar consumed by
+                    # compile and TypeScript generation.
+                    #
+                    # A Curated node can also land here with no inputs at all.
+                    # When an operation takes only query/path/multipart
+                    # parameters, the registry leaves `inputDefinition` empty and
+                    # describes those inputs under
+                    # `connectorMethodInfo.parameters` — which
+                    # `_build_v1_definition` drops. The entry already carries
+                    # them, because building `inputSchema` falls back to
+                    # `parameters`, so fill the gap from there rather than ship a
+                    # definition with no inputs. Only fill when empty: a node
+                    # that has real `inputDefinition` fields keeps them.
+                    expanded = (
+                        entry["operation"].get("activityType") == "GenericExpanded"
+                    )
+                    resolved_fields = entry.get("inputSchema", {}).get("fields") or []
+                    # The entry's fields are the node's own fields plus whatever
+                    # the parameters filled in, so they are a superset of what a
+                    # verbatim projection would carry — prefer them whenever we
+                    # have any. An expanded Generic node stamps even an empty
+                    # list, because its template's fields belong to the dispatch
+                    # node rather than to this object.
+                    if expanded or resolved_fields:
+                        v1def.setdefault("inputDefinition", {})["fields"] = (
+                            resolved_fields
+                        )
+                    # A per-object EVENT variant carries its own subscription
+                    # vocabulary, and this sidecar is where the SDK reads one
+                    # (`Library.eventParameterFields` / `eventFilterFields`).
+                    # The template's registry node is the same for every
+                    # object, so without this stamp every variant would answer
+                    # with the template's sections — which for a generic event
+                    # are empty, and `check` would then refuse every filter
+                    # field the object actually has.
+                    event_schema = entry.get("eventSchema") or {}
+                    if event_schema:
+                        v1def["eventParameters"] = {
+                            "fields": event_schema.get("eventParameters") or []
+                        }
+                        v1def["filterFields"] = {
+                            "fields": event_schema.get("filterFields") or []
+                        }
+                        for fact in ("eventMode", "byoaConnection",
+                                     "isWebhookUrlVisible"):
+                            if event_schema.get(fact) is not None:
+                                v1def[fact] = event_schema[fact]
+                    v1def_path = os.path.join(output_dir, relpath + ".v1def.json")
+                    with open(v1def_path, "w") as f:
+                        json.dump(v1def, f, indent=2)
+                        f.write("\n")
+            except Exception as exc:
+                print(f"  WARN: v1def write failed for {entry['nodeType']}: {exc}",
+                      file=sys.stderr)
+
+        index.append({
+            "nodeType": entry["nodeType"],
+            "version": version,
+            "connectorKey": connector_key,
+            "label": entry["display"]["label"],
+            "activityType": entry["operation"].get("activityType", ""),
+            # `objectName` disambiguates expansions that share a nodeType
+            # (e.g. `insert-record` × N objects). Curated entries usually have
+            # an objectName too; those lookups omit objectName and
+            # match by nodeType alone.
+            "objectName": entry["operation"].get("objectName", "") or "",
+            "operationName": entry["operation"].get("name", "") or "",
+            "path": os.path.relpath(path, output_dir),
+        })
+        # `registry search` reads only this index, so a flag left in the entry
+        # file is invisible to the one consumer that has to branch on it.
+        # Emitted only when set, so every other row stays byte-identical.
+        if entry["operation"].get("objectFromDiscovery"):
+            index[-1]["objectFromDiscovery"] = True
+
+    # Sort index for stable diffs. Many expanded entries share the source
+    # Generic nodeType, so include `path` to break ties.
+    index.sort(key=lambda e: (e["connectorKey"], e["nodeType"], e["version"], e["path"]))
+
+    index_path = os.path.join(output_dir, "index.json")
+    with open(index_path, "w") as f:
+        json.dump({"schemaVersion": SCHEMA_VERSION, "entries": index}, f, indent=2)
+        f.write("\n")
+
+    return written
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    args = parse_args()
+
+    print(f"Cache directory: {args.cache_dir}")
+    print(f"Output directory: {args.output_dir}")
+
+    node_types = registry_search(args.cache_dir)
+    print(f"Found {len(node_types)} connector node types")
+
+    connector_records = None
+
+    # Curated subset: keep the requested connectors' action AND connector-event
+    # node types (`scoped_connector_key`). The START form
+    # (`uipath.connector.trigger.<key>.<event>`) stays out — `registry get`
+    # refuses it without a --connection-id, so including it would only buy a
+    # flood of doomed calls, and the SDK derives that form from the wait
+    # sibling this build does materialize.
+    if args.connectors:
+        allow = {c.strip() for c in args.connectors.split(",") if c.strip()}
+        before = len(node_types)
+        node_types = [
+            nt for nt in node_types
+            if scoped_connector_key(nt) in allow
+        ]
+        matched = {
+            key for key in allow
+            if any(f".{key}." in f"{nt}." for nt in node_types)
+        }
+        print(f"Curated subset: kept {len(node_types)}/{before} node types for "
+              f"{len(matched)}/{len(allow)} connectors {sorted(matched)}")
+        missing = allow - matched
+        if missing:
+            print(f"  WARN: no registry nodes matched these connector keys: "
+                  f"{sorted(missing)}", file=sys.stderr)
+    else:
+        # A full build ships the PUBLISHED catalog, not everything the build
+        # tenant happens to see.
+        before = len(node_types)
+        node_types, dropped = select_published_connectors(node_types)
+        if dropped:
+            print(f"Published catalog: kept {len(node_types)}/{before} node "
+                  f"types, dropped {len(dropped)} tenant-local connector(s) "
+                  f"{dropped}")
+
+    if args.catalog_scope in {"tier1", "tier2"}:
+        requested_tier = args.catalog_scope
+        tier_number = requested_tier[-1]
+        scope_keys = {
+            key for key in (scoped_connector_key(nt) for nt in node_types) if key
+        }
+        print(f"Resolving Tier {tier_number} scope from metadata for "
+              f"{len(scope_keys)} connector keys...")
+        connector_records = fetch_connector_records_for_keys(
+            scope_keys, args.connectors_cache_dir, args.concurrency
+        )
+        missing_metadata = sorted(
+            key for key, record in connector_records.items() if record is None
+        )
+        if missing_metadata:
+            preview = ", ".join(missing_metadata[:10])
+            remainder = (
+                f" (+{len(missing_metadata) - 10} more)"
+                if len(missing_metadata) > 10 else ""
+            )
+            sys.exit(
+                f"Tier {tier_number} filtering requires connector metadata for every "
+                f"candidate connector, but lookup failed for: {preview}{remainder}"
+            )
+        before = len(node_types)
+        node_types, matching_keys = filter_node_types_by_tier(
+            node_types, connector_records, requested_tier
+        )
+        if not matching_keys:
+            sys.exit(
+                f"Tier {tier_number} filtering selected no connectors. Expected "
+                "the Tier field from `uip is connectors metadata` to contain "
+                f"'{tier_number}'."
+            )
+        print(f"Tier {tier_number} scope: kept {len(node_types)}/{before} action "
+              f"node types for {len(matching_keys)} connectors")
+
+    # Side-file: catalog every trigger nodeType the registry search exposed.
+    # Triggers are NOT materialized into the main library because
+    # `flow registry get <trigger>` requires --connection-id; this file is
+    # the closest we get to a connection-less trigger inventory.
+    triggers_output = args.triggers_output or os.path.join(
+        os.path.dirname(os.path.normpath(args.output_dir)) or ".",
+        "registry-triggers.json",
+    )
+    print(f"Writing trigger side-file → {triggers_output}")
+    write_triggers_side_file(args.cache_dir, triggers_output)
+
+    print(f"Fetching connector details (concurrency={args.concurrency})...")
+    cache_files = fetch_all(node_types, args.cache_dir, args.concurrency)
+    print(f"Successfully fetched {len(cache_files)} connectors")
+
+    print("Extracting connector entries (Curated + Generic)...")
+    entries = []
+    v1def_source_paths = {}
+    by_activity = {}
+    for nt, path in sorted(cache_files.items()):
+        try:
+            entry = extract_canonical(path)
+            if entry:
+                entries.append(entry)
+                v1def_source_paths[entry["nodeType"]] = path
+                at = entry["operation"].get("activityType", "") or "(empty)"
+                by_activity[at] = by_activity.get(at, 0) + 1
+        except Exception as e:
+            print(f"  WARN: error processing {nt}: {e}", file=sys.stderr)
+
+    print(f"Found {len(entries)} entries total: " +
+          ", ".join(f"{k}={v}" for k, v in sorted(by_activity.items())))
+
+    if not args.skip_enrichment:
+        print(f"Enriching via `is resources describe` (concurrency={args.concurrency})...")
+        entries = enrich_all(entries, args.is_cache_dir, args.concurrency)
+
+    if not args.skip_connector_enrichment:
+        print(f"Enriching via `is connectors metadata` "
+              f"(concurrency={args.concurrency})...")
+        if connector_records is None:
+            connector_records = fetch_connector_records(
+                entries, args.connectors_cache_dir, args.concurrency
+            )
+        missing_metadata = sorted(
+            key for key, record in connector_records.items() if record is None
+        )
+        if missing_metadata:
+            preview = ", ".join(missing_metadata[:10])
+            remainder = (
+                f" (+{len(missing_metadata) - 10} more)"
+                if len(missing_metadata) > 10 else ""
+            )
+            sys.exit(
+                "Connector metadata is required to classify schema discovery, "
+                "but `uip is connectors metadata` failed for: "
+                f"{preview}{remainder}. Upgrade the UiPath CLI or rerun after "
+                "checking authentication."
+            )
+        named = 0
+        for e in entries:
+            ck = e["connector"]["key"]
+            rec = connector_records.get(ck)
+            merge_connector_record(e, rec)
+            if e["connector"].get("name"):
+                named += 1
+        schema_dynamic = sum(
+            1 for e in entries
+            if e["runtime"].get("requiresConnectionForSchema")
+        )
+        print(f"  Named {named}/{len(entries)} entries from connector records")
+        print(f"  schema-dynamic from connector capabilities: "
+              f"{schema_dynamic}/{len(entries)}")
+
+    if not args.skip_generic_expansion:
+        print(f"Expanding Generic CRUD by (object, operation) "
+              f"(concurrency={args.concurrency})...")
+        kept, expanded = expand_all_generics(entries, args.is_cache_dir, args.concurrency)
+        entries = kept + expanded
+
+    print(f"Resolving connector events (concurrency={args.concurrency})...")
+    entries, expanded_events = resolve_connector_events(
+        entries, args.is_cache_dir, args.concurrency)
+    entries = entries + expanded_events
+
+    # Curated op remaps (e.g. Outlook ReplyToEmailV2 → dispatchable ReplyToEmail) — applied
+    # last so they override anything enrichment/expansion produced.
+    entries = apply_curated_overrides(entries)
+
+    print("Writing canonical library...")
+    written = write_library(args.output_dir, entries, v1def_source_paths)
+    print(f"Wrote {written} library entries + index.json")
+
+    if not args.keep_temp:
+        print("Cleaning up caches...")
+        shutil.rmtree(args.cache_dir, ignore_errors=True)
+        shutil.rmtree(args.is_cache_dir, ignore_errors=True)
+        shutil.rmtree(args.connectors_cache_dir, ignore_errors=True)
+
+    print("Done!")
+
+
+if __name__ == "__main__":
+    main()