@uipath/maestro-builder-sdk 6.4.0 → 6.5.0

package/dist/generators/_connections.py

@@ -1,331 +0,0 @@
-#!/usr/bin/env python3
-"""Find the connection for a connector, and write its bindings.
-
-`prepare` already knows which connector it is preparing. Making the author go
-and find that connector's connection id by hand — and then its folder key, and
-then hand-write `bindings.json` around both — is work the command can do itself
-from information it already has.
-
-Measured on the eval corpus, that hand-work was 4 to 7 tool calls per task:
-listing connections, filtering them, then (because nothing said the folder key
-was on the connection record) three or four more spent searching Orchestrator
-folders for one matching the symbolic name in the prompt.
-
-THE ONE THING THIS MUST NOT DO IS GUESS. A tenant can carry several connections
-for the same connector — this repo's test tenant has five for Slack — and they
-are not interchangeable: a user who exists in one workspace does not exist in
-another, so picking the wrong one makes a lookup unresolvable for a reason that
-points nowhere near the actual mistake. That failure was observed directly
-(`skill-flow-slack-dm-lookup` named the wrong workspace and burned its whole
-turn budget), which is why ambiguity here is an error listing the candidates and
-never a silent choice.
-"""
-
-from __future__ import annotations
-
-import json
-import subprocess
-
-__all__ = [
-    "ConnectionError_",
-    "byoa_connections",
-    "byoa_listing",
-    "candidate_connections",
-    "candidate_listing",
-    "discover_connection",
-    "lookup_connection",
-    "merge_bindings",
-]
-
-
-class ConnectionError_(Exception):
-    """No usable connection, with the reason and the way forward."""
-
-
-def _list(all_folders: bool, byoa: bool = False) -> list[dict]:
-    command = ["uip", "is", "connections", "list", "--output", "json"]
-    if all_folders:
-        command.insert(4, "--all-folders")
-    if byoa:
-        command.insert(4, "--byoa")
-    result = subprocess.run(command, capture_output=True, text=True)
-    if result.returncode != 0:
-        raise ConnectionError_(
-            "listing connections failed: "
-            f"{result.stderr.strip() or 'no output'}"
-        )
-    try:
-        payload = json.loads(result.stdout)
-    except ValueError as error:
-        raise ConnectionError_(f"connection listing was not JSON: {error}") from error
-    data = payload.get("Data")
-    if isinstance(data, dict):
-        data = data.get("items")
-    return data if isinstance(data, list) else []
-
-
-def _matching(rows: list[dict], connector_key: str, name: str | None) -> list[dict]:
-    out = [
-        row for row in rows
-        if row.get("ConnectorKey") == connector_key
-        # A Failed connection is listed like any other and cannot serve a
-        # request; selecting one produces an error about the operation rather
-        # than about the connection, which sends the reader the wrong way.
-        and str(row.get("State", "")).lower() == "enabled"
-    ]
-    if name:
-        out = [row for row in out if row.get("Name") == name]
-    return out
-
-
-def discover_connection(connector_key: str, name: str | None = None) -> dict:
-    """The one enabled connection for `connector_key`, or raise.
-
-    Tries the DEFAULT listing first and only widens to `--all-folders` if that
-    finds nothing. That order matters and is not just politeness to the API: the
-    default listing is the caller's own folder, which on a real tenant is one
-    connection where the tenant-wide view is many. Widening first would turn an
-    unambiguous case into an ambiguous one.
-    """
-    rows = _matching(_list(all_folders=False), connector_key, name)
-    scope = "your folder"
-    if not rows:
-        rows = _matching(_list(all_folders=True), connector_key, name)
-        scope = "the tenant"
-
-    if not rows:
-        qualifier = f" named {name!r}" if name else ""
-        raise ConnectionError_(
-            f"no enabled {connector_key} connection{qualifier} found in {scope}. "
-            f"List what exists with:\n"
-            f"  uip is connections list --all-folders"
-        )
-    if len(rows) > 1:
-        # Every candidate line carries its id: a NAME is not a key on a tenant.
-        # The eval tenant holds three Slack connections all named
-        # `is-sandboxes` (two Enabled, in different folders), so the old remedy —
-        # "name the one you want with --connection <name>" — handed back the very
-        # flag the caller had just used, and the doc-following author dead-ended
-        # (skill-flow-e2e-escalation-orchestrator-paths, 2026-09-01: placeholder
-        # GUIDs hand-written into bindings.json, 401 at the Slack node).
-        listed = "\n".join(
-            f"    {row.get('Name')}  --connection-id {row.get('Id')}"
-            f"  (folder: {row.get('Folder')})"
-            for row in rows
-        )
-        names = {str(row.get("Name")) for row in rows}
-        if name is not None or len(names) < len(rows):
-            remedy = (
-                "They share a name, so --connection <name> cannot pick one; pass "
-                "the id of the one in the folder you mean with --connection-id:"
-            )
-        else:
-            remedy = (
-                "Name the one you want with --connection <name>, or pass its id "
-                "with --connection-id:"
-            )
-        raise ConnectionError_(
-            f"{len(rows)} enabled {connector_key} connections in {scope}, and they "
-            f"are not interchangeable — a record that exists in one workspace need "
-            f"not exist in another. {remedy}\n{listed}"
-        )
-    return rows[0]
-
-
-def candidate_connections(connector_key: str, name: str | None = None) -> list[dict]:
-    """Every enabled connection for `connector_key`, own folder FIRST.
-
-    `discover_connection` answers "which one" and stops at the first non-empty
-    scope, which is right for picking a connection and wrong for retrying one:
-    when the own-folder listing holds exactly one, the tenant-wide connections
-    are never even looked at. So a lookup that exhausts the personal-workspace
-    connection reports a bad VALUE while the record sits in another folder's
-    connection (flow-builder-sdk#744, measured on two Jira connections where
-    only the second carried project `TS`).
-
-    Ordering is the same preference `discover_connection` encodes — the caller's
-    own folder is the likeliest and is tried first — but nothing is dropped.
-    Deduplicated by `Id`, because the tenant-wide listing repeats the own-folder
-    rows.
-
-    This does NOT decide anything, and in particular does not raise on several
-    matches: choosing among them is the caller's job, and the only honest way to
-    choose is evidence (a lookup that resolves on exactly one). That keeps this
-    module's rule intact — ambiguity is never resolved by guessing.
-    """
-    ordered: list[dict] = []
-    seen: set[str] = set()
-    for all_folders in (False, True):
-        for row in _matching(_list(all_folders=all_folders), connector_key, name):
-            identifier = str(row.get("Id", ""))
-            if identifier and identifier in seen:
-                continue
-            seen.add(identifier)
-            ordered.append(row)
-    return ordered
-
-
-def candidate_listing(rows: list[dict], indent: str = "    ") -> str:
-    """The candidates, one pasteable `--connection-id` line each."""
-    return "\n".join(
-        f"{indent}{row.get('Name')}  --connection-id {row.get('Id')}"
-        f"  (folder: {row.get('Folder')})"
-        for row in rows
-    )
-
-
-def _enabled_listing(rows: list[dict], connector_key: str) -> str:
-    """The enabled connections for `connector_key`, one per line, pasteable."""
-    enabled = _matching(rows, connector_key, None)
-    if not enabled:
-        return (
-            f"    (none — this tenant has no Enabled {connector_key} connection; "
-            "repair or create one in Integration Service first)"
-        )
-    return "\n".join(
-        f"    {row.get('Name')}  --connection-id {row.get('Id')}"
-        f"  (folder: {row.get('Folder')})"
-        for row in enabled
-    )
-
-
-def lookup_connection(connector_key: str, connection_id: str) -> dict:
-    """The record for an explicitly named connection, or raise unless it can serve.
-
-    An explicit `--connection-id` used to skip every check discovery applies, and
-    that skip is where a whole class of silent failures came from. A connection
-    in `State: Failed` is listed like any other, and `uip is resources describe`
-    against it answers `Result: Success` with NO request fields — the tenant has
-    no schema to give for a connection it cannot reach. `prepare` then wrote an
-    overlay with zero body inputs, printed "0 input field(s)" as a success, and
-    the next `compile` rejected every real field as unknown, sending the author
-    hunting through the SDK for a flag that does not exist.
-
-    Measured on the eval tenant (Salesforce `Opportunity` / `Update`): the Failed
-    connection returned 0 request fields, the Enabled one 13 (`StageName` among
-    them). The state was visible in the same `connections list` the author had
-    already run; a projection that dropped the `State` column hid it.
-
-    So: resolve the id against the tenant-wide listing, and refuse — naming the
-    state found and the enabled alternatives — rather than describe through it.
-    """
-    rows = _list(all_folders=True)
-    match = next(
-        (row for row in rows if str(row.get("Id", "")) == str(connection_id)), None
-    )
-    alternatives = _enabled_listing(rows, connector_key)
-    if match is None:
-        raise ConnectionError_(
-            f"connection {connection_id} is not in this tenant's listing "
-            f"(`uip is connections list --all-folders`). Enabled {connector_key} "
-            f"connections:\n{alternatives}\n"
-            "Or omit --connection-id and prepare selects the connection itself."
-        )
-    actual_key = match.get("ConnectorKey")
-    if actual_key and actual_key != connector_key:
-        raise ConnectionError_(
-            f"connection {match.get('Name')} ({connection_id}) belongs to connector "
-            f"{actual_key}, not {connector_key}. Enabled {connector_key} "
-            f"connections:\n{alternatives}\n"
-            "Or omit --connection-id and prepare selects the connection itself."
-        )
-    state = str(match.get("State", "") or "")
-    if state.lower() != "enabled":
-        shown = state or "in an unknown state"
-        raise ConnectionError_(
-            f"connection {match.get('Name')} ({connection_id}) is {shown}, not "
-            "Enabled. A connection that is not Enabled answers field discovery "
-            "with an EMPTY schema, so the overlay would carry no fields and the "
-            "next compile would still reject every input as unknown. Enabled "
-            f"{connector_key} connections:\n{alternatives}\n"
-            "Or omit --connection-id and prepare selects the connection itself."
-        )
-    return match
-
-
-def byoa_connections(connector_key: str) -> list[dict]:
-    """The enabled BYOA connections for `connector_key`.
-
-    RAISES on a failed listing rather than answering an empty list. The
-    difference is the whole point: "you have no BYOA connection" tells the
-    caller to go create one, and a listing that failed says nothing of the
-    kind. Answering [] for both turns a broken call into confident, wrong
-    advice — the failure-is-not-emptiness rule this module already applies to
-    ordinary discovery.
-    """
-    return _matching(_list(all_folders=True, byoa=True), connector_key, None)
-
-
-def byoa_listing(rows: list[dict], connector_key: str) -> str:
-    """The BYOA candidates, one pasteable line each, or why there are none."""
-    if not rows:
-        return (
-            f"    (none — this tenant has no enabled BYOA {connector_key} "
-            "connection; create one in Integration Service with your own "
-            "OAuth app, then re-run)"
-        )
-    return "\n".join(
-        f"    {row.get('Name')}  --connection-id {row.get('Id')}"
-        f"  (folder: {row.get('Folder')})"
-        for row in rows
-    )
-
-
-def merge_bindings(
-    path: str,
-    connection: dict,
-    connection_name: str,
-    folder_name: str,
-) -> tuple[bool, bool]:
-    """Add connection + folder entries to `bindings.json`, in place.
-
-    ADDITIVE AND IDEMPOTENT. An existing entry under the same symbolic name is
-    updated, never duplicated, and every other entry is left exactly as it was —
-    `bindings.json` is an authored file that may already carry bindings for
-    connectors this run knows nothing about.
-
-    Returns `(wrote_connection, wrote_folder)` describing what changed, so the
-    caller can report the specific thing rather than "updated bindings".
-    """
-    import os
-
-    document: dict = {"schemaVersion": "1", "bindings": []}
-    if os.path.exists(path):
-        try:
-            with open(path, encoding="utf-8") as handle:
-                loaded = json.load(handle)
-            if isinstance(loaded, dict):
-                document = loaded
-                document.setdefault("schemaVersion", "1")
-                document.setdefault("bindings", [])
-        except (OSError, ValueError):
-            # A malformed bindings.json is the author's file and not ours to
-            # discard: refuse rather than overwrite work we cannot read.
-            raise ConnectionError_(
-                f"{path} exists but is not readable JSON. Fix or remove it; "
-                "this command will not overwrite a file it cannot parse."
-            )
-
-    def upsert(symbolic: str, key: str, attribute: str) -> bool:
-        for entry in document["bindings"]:
-            if entry.get("name") == symbolic or entry.get("id") == symbolic:
-                changed = entry.get("resourceKey") != key
-                entry.update({
-                    "id": entry.get("id", symbolic), "name": symbolic,
-                    "resource": "Connection", "resourceKey": key,
-                    "default": key, "propertyAttribute": attribute,
-                })
-                return changed
-        document["bindings"].append({
-            "id": symbolic, "name": symbolic, "resource": "Connection",
-            "resourceKey": key, "default": key, "propertyAttribute": attribute,
-        })
-        return True
-
-    wrote_connection = upsert(connection_name, str(connection["Id"]), "ConnectionId")
-    wrote_folder = upsert(folder_name, str(connection["FolderKey"]), "FolderKey")
-
-    with open(path, "w", encoding="utf-8") as handle:
-        json.dump(document, handle, indent=2)
-        handle.write("\n")
-    return wrote_connection, wrote_folder

package/dist/generators/_events.py

@@ -1,355 +0,0 @@
-#!/usr/bin/env python3
-"""Deterministic discovery for connector EVENTS — triggers and mid-flow waits.
-
-The activities pipeline resolves a connector operation's schema through
-`uip is resources list`/`describe`. Events have their own twin pair —
-`uip is triggers objects` / `uip is triggers describe` — plus the product
-registry's node manifest (`uip maestro flow registry get`, which for trigger
-node types REFUSES to answer without a live `--connection-id`, and which
-mirrors the describe sections when it does).
-
-Two shapes matter here and they are deliberately kept apart:
-
-- `triggers objects` answers PER EVENT OBJECT: the object catalog a generic
-  event ranges over, and per object the facts that change how a subscription
-  must be prepared (`ByoaConnection`, `IsWebhookUrlVisible`) and the
-  `Parameters` the object contributes to the input set.
-- `triggers describe` answers PER (event, object): `EventParameters`,
-  `FilterFields`, `OutputFields`.
-
-The V1 skill's source-of-truth contract is preserved verbatim: the complete
-event-input set is the UNION of `objects → Parameters` and
-`describe → EventParameters`, required if EITHER side says required. A field
-can appear in one and not the other (measured in the V1 corpus: required
-fields present only in describe), so neither call alone is trusted.
-"""
-
-from __future__ import annotations
-
-import json
-import subprocess
-
-__all__ = [
-    "EventDiscoveryError",
-    "triggers_objects",
-    "triggers_describe",
-    "camel_fields",
-    "normalize_bucket_fields",
-    "union_event_parameters",
-    "merge_describe_into_node",
-    "event_facts",
-]
-
-# `Parameters[].type` on a `triggers objects` row routes the value into one of
-# three `--detail` buckets at emit time. Everything unrecognized is an event
-# parameter — that is the designer's own fallback, and inventing a fourth
-# bucket here would emit a detail key the validator refuses.
-_BUCKETS = {"query": "query", "path": "path"}
-
-
-class EventDiscoveryError(Exception):
-    """A trigger metadata call failed, with the reason and the way forward."""
-
-
-def _run_json(command: list[str]) -> dict:
-    result = subprocess.run(command, capture_output=True, text=True)
-    try:
-        payload = json.loads(result.stdout)
-    except ValueError:
-        raise EventDiscoveryError(
-            f"`{' '.join(command[:5])} …` did not answer JSON: "
-            f"{(result.stderr or result.stdout).strip()[:300] or 'no output'}"
-        )
-    if payload.get("Result") != "Success":
-        raise EventDiscoveryError(
-            f"`{' '.join(command[:5])} …` failed: "
-            f"{payload.get('Message') or payload.get('Result')}"
-        )
-    return payload
-
-
-def triggers_objects(
-    key: str, operation: str, connection_id: str | None = None,
-) -> list[dict]:
-    """The event objects for `(connector, operation)`, PascalCase rows.
-
-    Rows carry `Name`/`DisplayName` (the same identity pair the activities
-    object ladder matches on) and, where the connector declares them,
-    `ByoaConnection`, `IsWebhookUrlVisible` and `Parameters`. Connectors that
-    declare none simply omit the keys (measured: sfdc's 1,178 CREATED rows
-    carry neither), so every reader treats them as optional.
-
-    `connection_id` is OPTIONAL, and what omitting it means depends on the
-    connector's object discovery. A connector whose objects do not come from
-    the connection answers identically either way (outlook `CREATED`:
-    Message + Calendar, with and without), which is what lets generation bake
-    those objects with no credentials at all. One whose objects DO come from
-    the connection answers with its declared set instead of the tenant's
-    (sfdc `CREATED`: 4 offline, 1,178 against a connection) — so a caller that
-    needs the tenant's objects must pass the id.
-    """
-    command = ["uip", "is", "triggers", "objects", key, operation]
-    if connection_id:
-        command += ["--connection-id", connection_id]
-    payload = _run_json(command + ["--output", "json"])
-    data = payload.get("Data")
-    if isinstance(data, dict):
-        data = data.get("items")
-    return data if isinstance(data, list) else []
-
-
-def triggers_describe(
-    key: str, operation: str, object_name: str,
-    connection_id: str | None = None,
-) -> dict:
-    """`EventParameters` / `FilterFields` / `OutputFields` for one object.
-
-    This call takes no node type — connector, operation and object only — so
-    it answers for the EVENT rather than for either of the two node forms the
-    platform ships it as. That is why both forms carry the same schema, and
-    why the product registry's per-node copy is a mirror of this: a lossy one,
-    measured on outlook `email-received` at 14 filter fields to this call's 15.
-
-    `connection_id` is optional here too; see `triggers_objects` for what
-    omitting it costs on a connector whose objects come from the connection.
-    """
-    command = ["uip", "is", "triggers", "describe", key, operation, object_name]
-    if connection_id:
-        command += ["--connection-id", connection_id]
-    payload = _run_json(command + ["--output", "json"])
-    return payload.get("Data") or {}
-
-
-def _camelize(value):
-    """Lower-case the first letter of every key, recursively.
-
-    `triggers describe` answers PascalCase all the way down, including the
-    `Reference` block: `{ObjectName, LookupNames, LookupValue, Path}`. Every
-    consumer of a reference — the lookup-spec generator, the `--resolve`
-    executor, the markdown — reads the registry's camelCase spelling, so a
-    verbatim copy is invisible to all of them: the field simply stops having
-    a lookup. One shape leaves this module, and this is what makes it one.
-    """
-    if isinstance(value, dict):
-        return {
-            (k[0].lower() + k[1:] if k[:1].isupper() else k): _camelize(v)
-            for k, v in value.items()
-        }
-    if isinstance(value, list):
-        return [_camelize(v) for v in value]
-    return value
-
-
-def _is_hidden(low: dict) -> bool:
-    """True for a hidden parameter that is safe to DROP — hidden and optional.
-
-    Outlook's `sharedMailboxAddress` is `Design.IsHidden: true` and optional:
-    a transport detail of the subscription, not something an author fills in,
-    so counting it would advertise a second field on an event whose only real
-    parameter is the mail folder.
-
-    A hidden parameter that is REQUIRED is a different animal and is kept
-    (flagged `hidden`, see `_keep_hidden_marker`). Asana's `parent` and
-    `projectId` are both — path-bucket, required, hidden — and dropping a
-    value the subscription needs at dispatch is exactly the silent wrongness
-    this design exists to remove. Keeping it flagged loses nothing: a surface
-    that should not prompt for it can read the flag, while nothing can lose
-    it by accident.
-    """
-    design = low.get("design") or {}
-    if not isinstance(design, dict):
-        return False
-    # Only the TOP-level keys are lowered by the callers, so the nested block
-    # still reads `{"IsHidden": true}`. Camelize it before asking.
-    design = _camelize(design)
-    hidden = bool(design.get("isHidden") or design.get("hidden"))
-    return hidden and not low.get("required")
-
-
-def _keep_hidden_marker(low: dict, field: dict) -> dict:
-    """Flag a kept parameter the designer hides (necessarily a required one)."""
-    design = _camelize(low.get("design") or {})
-    if isinstance(design, dict) and (design.get("isHidden") or design.get("hidden")):
-        field["hidden"] = True
-    return field
-
-
-def _with_cascade(fields: list[dict]) -> list[dict]:
-    """Mark each parameter that another one has to resolve before it.
-
-    Jira's `issuetype` reference is `/project/{project}/issuetypes` — the
-    cascade is written into the path, as a placeholder naming the parameter it
-    needs. That is the same encoding `_order_by_dependency` reads for an
-    activity's parent fields, and `_resolve.order_resolutions` already honours
-    `dependsOn`, so recording it here is what makes `prepare` resolve
-    `project` first without being told to.
-    """
-    names = {f.get("name") for f in fields}
-    for field in fields:
-        reference = field.get("reference") or {}
-        path = str(reference.get("path") or "")
-        explicit = list(reference.get("dependsOn") or [])
-        depends = sorted(
-            other for other in names
-            if other and other != field.get("name")
-            and ("{" + str(other) + "}" in path or other in explicit)
-        )
-        if depends:
-            field["dependsOn"] = depends
-            reference.setdefault("dependsOn", depends)
-    # Designer order where the connector states one, so a cascade reads
-    # parent-first in every listing rather than in dict order.
-    fields.sort(key=lambda f: (f.get("sortOrder") is None, f.get("sortOrder") or 0))
-    return fields
-
-
-def camel_fields(fields: list | None) -> list[dict]:
-    """Describe/objects fields normalized to the registry's camelCase shape.
-
-    `triggers describe` answers PascalCase (`Name`/`Type`/`DisplayName`);
-    the registry definition — and everything downstream that reads a v1def —
-    is camelCase. One shape leaves this module.
-    """
-    out = []
-    for f in fields or []:
-        if not isinstance(f, dict):
-            continue
-        low = {k[0].lower() + k[1:] if k[:1].isupper() else k: v
-               for k, v in f.items()}
-        name = low.get("name")
-        if not name:
-            continue
-        if _is_hidden(low):
-            continue
-        field = {"name": name}
-        for k in ("displayName", "description", "required", "dataType",
-                  "sortOrder"):
-            if low.get(k) is not None:
-                field[k] = low[k]
-        if low.get("reference") is not None:
-            field["reference"] = _camelize(low["reference"])
-        _keep_hidden_marker(low, field)
-        # Describe's `Type` is the DATA type; an objects-row Parameter's
-        # `type` is the BUCKET. The caller that knows which source it read
-        # passes bucketed fields through `normalize_bucket_fields` instead.
-        if low.get("type") is not None and "dataType" not in field:
-            field["type"] = low["type"]
-            field["dataType"] = low["type"]
-        elif "dataType" in field:
-            field["type"] = field["dataType"]
-        out.append(field)
-    return out
-
-
-def normalize_bucket_fields(parameters: list | None) -> list[dict]:
-    """`triggers objects → Parameters[]` rows, camelCase, bucket made explicit.
-
-    On these rows `type` selects the emit-time detail bucket (`query` →
-    `queryParameters`, `path` → `pathParameters`, anything else → event
-    parameters) and `dataType` is the value type — the OPPOSITE reading of
-    `type` from every other field list, which is exactly the kind of
-    quiet trap this normalization exists to bury.
-    """
-    out = []
-    for f in parameters or []:
-        if not isinstance(f, dict):
-            continue
-        low = {k[0].lower() + k[1:] if k[:1].isupper() else k: v
-               for k, v in f.items()}
-        name = low.get("name")
-        if not name:
-            continue
-        if _is_hidden(low):
-            continue
-        field = {"name": name,
-                 "bucket": _BUCKETS.get(str(low.get("type") or "").lower(), "event")}
-        for k in ("displayName", "description", "required", "sortOrder"):
-            if low.get(k) is not None:
-                field[k] = low[k]
-        if low.get("reference") is not None:
-            field["reference"] = _camelize(low["reference"])
-        data_type = low.get("dataType") or "string"
-        field["type"] = data_type
-        field["dataType"] = data_type
-        _keep_hidden_marker(low, field)
-        out.append(field)
-    return out
-
-
-def union_event_parameters(
-    declared: list | None, object_parameters: list | None,
-) -> list[dict]:
-    """The V1 union rule: describe's EventParameters ∪ the object row's Parameters.
-
-    Deduped by name; `required` is an OR — a field required on either side is
-    required, because each side is authoritative for fields the other omits.
-    The object row's bucket survives the merge; a field only describe knows
-    is an event parameter by definition.
-    """
-    merged: dict[str, dict] = {}
-    for field in camel_fields(declared):
-        field.setdefault("bucket", "event")
-        merged[field["name"]] = field
-    for field in normalize_bucket_fields(object_parameters):
-        existing = merged.get(field["name"])
-        if existing is None:
-            merged[field["name"]] = field
-            continue
-        existing["required"] = bool(existing.get("required")) or bool(field.get("required"))
-        existing["bucket"] = field["bucket"]
-        for k in ("displayName", "description", "reference", "sortOrder"):
-            if field.get(k) is not None and existing.get(k) is None:
-                existing[k] = field[k]
-    return _with_cascade(list(merged.values()))
-
-
-def merge_describe_into_node(
-    node: dict, describe: dict, object_parameters: list | None = None,
-) -> dict:
-    """Fold a `triggers describe` answer into a registry trigger definition.
-
-    The registry definition IS the v1def the overlay ships, and
-    `Library.eventParameterFields` already reads `v1def.eventParameters.fields`
-    — so the deterministic store is "the definition, with the describe
-    sections made true for this object" rather than a new format.
-    """
-    node = dict(node)
-    node["eventParameters"] = {"fields": union_event_parameters(
-        describe.get("EventParameters"), object_parameters,
-    )}
-    node["filterFields"] = {"fields": camel_fields(describe.get("FilterFields"))}
-    if describe.get("OutputFields"):
-        node["outputResponseDefinition"] = {
-            "fields": camel_fields(describe.get("OutputFields"))}
-    for src, dst in (("EventMode", "eventMode"),
-                     ("ByoaConnection", "byoaConnection"),
-                     ("IsWebhookUrlVisible", "isWebhookUrlVisible")):
-        if describe.get(src) is not None:
-            node[dst] = describe[src]
-    return node
-
-
-def event_facts(node: dict, object_row: dict | None) -> dict:
-    """The three facts that change how a subscription is prepared or tested.
-
-    Per-object answers (the `triggers objects` row, or a describe) win over
-    the definition's: `byoaConnection` and `isWebhookUrlVisible` are declared
-    PER EVENT OBJECT, not per connector — V1 measured connectors requiring
-    BYOA for some events and not others.
-    """
-    row = object_row or {}
-    def _fact(row_key: str, node_key: str, default):
-        if row.get(row_key) is not None:
-            return row[row_key]
-        if node.get(node_key) is not None:
-            return node[node_key]
-        return default
-    return {
-        "eventMode": str(node.get("eventMode") or "polling"),
-        "byoaConnection": bool(_fact("ByoaConnection", "byoaConnection", False)),
-        "isWebhookUrlVisible": bool(_fact("IsWebhookUrlVisible", "isWebhookUrlVisible", False)),
-        "textBlocks": [
-            str(t) for t in ((row.get("Design") or {}).get("TextBlocks") or
-                             (row.get("design") or {}).get("textBlocks") or [])
-        ],
-    }