@uipath/maestro-builder-sdk 6.4.0 → 6.5.1

package/dist/registry/generators/triggers.d.ts

@@ -0,0 +1,15 @@
+import { type TriggerCatalogue, type TriggerCatalogueRow } from "../model/library.js";
+export interface TriggerModulesOptions {
+    /** Module specifier for `import { triggerDescriptor }`. */
+    importSpecifier?: string;
+    /** Connector keys to emit; every connector when omitted or empty. */
+    connectors?: readonly string[];
+}
+/**
+ * `{ "<connector-key>.triggers.ts" → module text }` for the catalogue.
+ *
+ * Modules come out sorted by connector key, triggers within a module sorted by
+ * node type, both by code point — the order the shared symbol derivation
+ * assumes.
+ */
+export declare function renderTriggerModules(catalogue: TriggerCatalogue | TriggerCatalogueRow[], options?: TriggerModulesOptions): Map<string, string>;

package/dist/registry/generators/triggers.js

@@ -0,0 +1,85 @@
+/**
+ * Identity-only trigger descriptors from `registry-triggers.json`.
+ *
+ * The catalogue carries `{ NodeType, DisplayName, Description, Version,
+ * connectorKey }` and nothing else, because a trigger's field schema is
+ * connection-dependent. So one `triggerDescriptor()` const per event is
+ * emitted, one module per connector, and `onEvent`/`waitForEvent` take it in
+ * place of the stringly `{ connector, event }`. Ported from
+ * `generate_triggers_ts.py`. The module text was verified byte-for-byte
+ * against that script before the Python was deleted; the differential went
+ * with it, and `tests/registry-triggers-gen.test.ts` now pins the text.
+ */
+import { PACKAGE_NAME } from "../../package-name.js";
+import { pyJsonString, pyJsonStringify } from "../codecs/pyjson.js";
+import { sortedByCodePoint, sortedStrings } from "../compat/compare.js";
+import { afterLast, pyRstrip, pyStrip, upperFirst } from "../compat/pystr.js";
+import { TRIGGER_PREFIX } from "../model/library.js";
+/** The trigger generator's own pascal: same split, `Event` as the empty fallback. */
+function pascalEvent(eventId) {
+    const joined = eventId
+        .split(/[^A-Za-z0-9]+/)
+        .filter((w) => w.length > 0)
+        .map((w) => upperFirst(w))
+        .join("");
+    return joined || "Event";
+}
+function emitTrigger(row, seen) {
+    const eventId = afterLast(row.NodeType, ".");
+    let name = pascalEvent(eventId);
+    while (seen.has(name))
+        name += "_";
+    seen.add(name);
+    const version = "Version" in row ? row.Version : "1.0.0";
+    const label = row.DisplayName || eventId;
+    const description = pyStrip(String(row.Description || "")).replaceAll("\n", " ");
+    let doc = description ? `${label} — ${description}` : label;
+    doc = doc.replaceAll("*/", "* /"); // never let a description close the doc comment early
+    return [
+        `/** ${doc} */`,
+        `export const ${name} = triggerDescriptor()({`,
+        `  connector: ${pyJsonString(row.connectorKey)},`,
+        `  event: ${pyJsonString(eventId)},`,
+        `  version: ${pyJsonStringify(version)},`,
+        `  displayName: ${pyJsonString(label)},`,
+        "} as const);",
+    ];
+}
+/**
+ * `{ "<connector-key>.triggers.ts" → module text }` for the catalogue.
+ *
+ * Modules come out sorted by connector key, triggers within a module sorted by
+ * node type, both by code point — the order the shared symbol derivation
+ * assumes.
+ */
+export function renderTriggerModules(catalogue, options = {}) {
+    const rows = Array.isArray(catalogue) ? catalogue : catalogue.triggers;
+    const subset = new Set((options.connectors ?? []).filter((c) => c.length > 0));
+    const importSpecifier = options.importSpecifier ?? PACKAGE_NAME;
+    const byConnector = new Map();
+    for (const row of rows) {
+        const nodeType = row.NodeType ?? "";
+        if (!nodeType.startsWith(TRIGGER_PREFIX))
+            continue; // catalogue is trigger-only, but be defensive
+        const key = row.connectorKey;
+        if (subset.size > 0 && !subset.has(key))
+            continue;
+        const group = byConnector.get(key);
+        if (group)
+            group.push(row);
+        else
+            byConnector.set(key, [row]);
+    }
+    const modules = new Map();
+    for (const key of sortedStrings(byConnector.keys())) {
+        const seen = new Set();
+        const body = [`import { triggerDescriptor } from ${pyJsonString(importSpecifier)};`, ""];
+        for (const row of sortedByCodePoint(byConnector.get(key), (r) => r.NodeType)) {
+            body.push(...emitTrigger(row, seen), "");
+        }
+        // `"\n".join(body).rstrip() + "\n"`: `pyRstrip`, not `trimEnd`, because the
+        // two disagree on which characters are whitespace (`\x1f`, ``).
+        modules.set(`${key}.triggers.ts`, `${pyRstrip(body.join("\n"))}\n`);
+    }
+    return modules;
+}

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

@@ -0,0 +1,50 @@
+import { type TypeNode, type TypeTree } from "./type-tree.js";
+export interface NamedTypeRegistryOptions {
+    /** Appended to every interface name; `"Input"` for the input registry. */
+    suffix?: string;
+    /** Render every property optional (outputs); inputs follow `required`. */
+    allOptional?: boolean;
+    /** Merge same-named nodes into one definition (outputs) or reuse exact shapes only (inputs). */
+    mergeReused?: boolean;
+    /** Wrap property types in `ConnectorValue<…>` / `ConnectorLookupValue<…>`. */
+    isInput?: boolean;
+}
+/**
+ * Renders one property line of an interface — `descriptors.ts`'s
+ * `emitNestedProperty`, handed to {@link NamedTypeRegistry.emit} so the
+ * registry need not import the module that imports it.
+ */
+export type PropertyRenderer = (name: string, node: TypeNode, indent: string, namedTypes: NamedTypeRegistry, allOptional: boolean, isInput: boolean) => string[];
+export declare class NamedTypeRegistry {
+    readonly isInput: boolean;
+    readonly suffix: string;
+    readonly allOptional: boolean;
+    readonly mergeReused: boolean;
+    private readonly byName;
+    /** Node identity → the name it was registered under (the Python's `id(node)` map). */
+    private readonly byNode;
+    /** `(baseName, fingerprint)` → name, for the exact-shape reuse of the input registry. */
+    private readonly shapeNames;
+    /** Names in definition order; `emit()` walks it while `register()` may still append. */
+    private readonly definitions;
+    private readonly registering;
+    constructor(options?: NamedTypeRegistryOptions);
+    /** Name the node (and, recursively, its object-valued children); return the name. */
+    register(fieldName: string, node: TypeNode): string;
+    /** Register every root that renders as an interface. */
+    discover(roots: TypeTree): void;
+    /**
+     * The one registered interface an opaque `array` field can be the element
+     * type of: `Contact`, or a de-collided `Contact2`, but not when both exist.
+     */
+    private knownArrayElement;
+    /** The TypeScript type of a property whose value is `node`. */
+    typeFor(fieldName: string, node: TypeNode): string;
+    /**
+     * Every registered interface, one blank line after each. Rendering a
+     * definition may register a further nested object, so the walk is by index
+     * over a list that can grow while it runs; a definition discovered late is
+     * emitted too.
+     */
+    emit(renderProperty: PropertyRenderer): string[];
+}

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

@@ -0,0 +1,154 @@
+/**
+ * Reusable named interfaces shared by all operations in one connector module.
+ *
+ * Every nested object in a connector's field trees becomes an exported
+ * interface, named from its segment. The OUTPUT registry merges every node that
+ * takes a name into one canonical definition (`Address` is enriched by each
+ * operation that returns one). The INPUT registry reuses a name only for an
+ * exact shape, because an input type that gained a field from a sibling
+ * operation would let an author send a field this operation does not take;
+ * a different shape under the same segment gets `AddressInput2`, `…3`.
+ * Ported from `NamedTypeRegistry` in `generate_connectors_ts.py`.
+ */
+import { sortedStrings } from "../compat/compare.js";
+import { mergeTypeNodes, nestedTypeName, typeFingerprint } from "./type-tree.js";
+export class NamedTypeRegistry {
+    isInput;
+    suffix;
+    allOptional;
+    mergeReused;
+    byName = new Map();
+    /** Node identity → the name it was registered under (the Python's `id(node)` map). */
+    byNode = new Map();
+    /** `(baseName, fingerprint)` → name, for the exact-shape reuse of the input registry. */
+    shapeNames = new Map();
+    /** Names in definition order; `emit()` walks it while `register()` may still append. */
+    definitions = [];
+    registering = new Set();
+    constructor(options = {}) {
+        this.suffix = options.suffix ?? "";
+        this.allOptional = options.allOptional ?? true;
+        this.mergeReused = options.mergeReused ?? true;
+        this.isInput = options.isInput ?? false;
+    }
+    /** Name the node (and, recursively, its object-valued children); return the name. */
+    register(fieldName, node) {
+        const known = this.byNode.get(node);
+        if (known)
+            return known;
+        const baseName = nestedTypeName(fieldName, node, this.suffix);
+        let typeName;
+        if (this.mergeReused) {
+            typeName = baseName;
+        }
+        else {
+            const shapeKey = JSON.stringify([baseName, typeFingerprint(node)]);
+            typeName = this.shapeNames.get(shapeKey) ?? "";
+            if (!typeName) {
+                typeName = baseName;
+                let suffix = 2;
+                while (this.byName.has(typeName)) {
+                    typeName = `${baseName}${suffix}`;
+                    suffix += 1;
+                }
+                this.shapeNames.set(shapeKey, typeName);
+            }
+        }
+        let canonical = this.byName.get(typeName);
+        if (canonical === undefined) {
+            canonical = node;
+            this.byName.set(typeName, canonical);
+            this.definitions.push(typeName);
+        }
+        else if (canonical !== node) {
+            if (this.mergeReused)
+                mergeTypeNodes(canonical, node);
+        }
+        this.byNode.set(node, typeName);
+        // A schema can recursively repeat the same segment name
+        // (`children[*].children[*]…`). Merge it into the shared interface, but do
+        // not recursively rediscover that interface while it is active.
+        if (this.registering.has(typeName))
+            return typeName;
+        this.registering.add(typeName);
+        try {
+            // Registration can enrich a canonical node, so iterate a snapshot.
+            for (const [childName, child] of [...canonical.children]) {
+                if (child.children.size > 0 || child.opaqueObject)
+                    this.register(childName, child);
+            }
+        }
+        finally {
+            this.registering.delete(typeName);
+        }
+        return typeName;
+    }
+    /** Register every root that renders as an interface. */
+    discover(roots) {
+        for (const [fieldName, node] of roots) {
+            if (node.children.size > 0 || node.opaqueObject)
+                this.register(fieldName, node);
+        }
+    }
+    /**
+     * The one registered interface an opaque `array` field can be the element
+     * type of: `Contact`, or a de-collided `Contact2`, but not when both exist.
+     */
+    knownArrayElement(fieldName, node) {
+        const candidate = nestedTypeName(fieldName, node, this.suffix);
+        const matches = [];
+        for (const name of this.byName.keys()) {
+            if (name === candidate || (name.startsWith(candidate) && /^[2-9][0-9]*$/.test(name.slice(candidate.length)))) {
+                matches.push(name);
+            }
+        }
+        return matches.length === 1 ? matches[0] : undefined;
+    }
+    /** The TypeScript type of a property whose value is `node`. */
+    typeFor(fieldName, node) {
+        let base;
+        if (node.children.size > 0 || node.opaqueObject) {
+            base = this.register(fieldName, node);
+        }
+        else if (node.opaqueArray) {
+            const knownElement = this.knownArrayElement(fieldName, node);
+            if (knownElement)
+                return `Array<${knownElement}>`;
+            return "unknown[]";
+        }
+        else {
+            base = sortedStrings(node.declaredTypes).join(" | ") || "unknown";
+        }
+        const hasArray = node.arrayModes.has(true);
+        const hasScalar = node.arrayModes.has(false);
+        if (hasArray && hasScalar)
+            return `${base} | Array<${base}>`;
+        if (hasArray)
+            return `Array<${base}>`;
+        return base;
+    }
+    /**
+     * Every registered interface, one blank line after each. Rendering a
+     * definition may register a further nested object, so the walk is by index
+     * over a list that can grow while it runs; a definition discovered late is
+     * emitted too.
+     */
+    emit(renderProperty) {
+        const lines = [];
+        let index = 0;
+        while (index < this.definitions.length) {
+            const typeName = this.definitions[index];
+            const node = this.byName.get(typeName);
+            lines.push(`export interface ${typeName} {`);
+            if (node.opaqueObject)
+                lines.push("  [key: string]: unknown;");
+            for (const [childName, child] of node.children) {
+                lines.push(...renderProperty(childName, child, "  ", this, this.allOptional, this.isInput));
+            }
+            lines.push("}");
+            lines.push("");
+            index += 1;
+        }
+        return lines;
+    }
+}

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

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

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

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

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

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