@uipath/maestro-builder-sdk 6.3.0 → 6.5.0

package/dist/registry/prepare/event.js

@@ -0,0 +1,268 @@
+/**
+ * Prepare a connector EVENT — the trigger/wait twin of an activity.
+ *
+ * Connector events live one namespace over from actions —
+ * `uipath.connector.trigger.<key>.<event>` / `.event.<key>.<event>` — and
+ * their registry definition only answers with a connection, which `prepare`
+ * has by the time it gets here. The overlay entry is stored under the WAIT
+ * form (`uipath.connector.event.…`) because the registry only enriches the
+ * START form and the library derives the start form from its wait sibling —
+ * one stored variant serves both node roles.
+ *
+ * One stored shape: the registry definition with the `triggers describe`
+ * sections made true for this object (generic), or with the object row's
+ * `Parameters` unioned in (curated). `Library.eventParameterFields` reads
+ * `v1def.eventParameters.fields`, so the overlay v1def IS the store.
+ *
+ * Ported from `_prepare_event`, `_event_operation` and
+ * `_refuse_unless_byoa_connection` in `prepare_connector.py`. Every `uip` call
+ * goes through the {@link BuildContext}'s client; every printed line goes
+ * through its reporter, in the Python's order.
+ */
+import { extractCanonical, nodeOf } from "../library-build/canonical.js";
+import { registryGet } from "../library-build/context.js";
+import { EventDiscoveryError, eventFacts, mergeDescribeIntoNode, triggersDescribe, triggersObjects, unionEventParameters, } from "../library-build/events.js";
+import { get, isRecord } from "../library-build/py.js";
+import { planLibrary } from "../library-build/plan.js";
+import { ConnectionRefusal, byoaConnections, byoaListing, restoreBindings } from "./connections.js";
+import { writeResolutions } from "./ledger.js";
+import { PREPARE_COMMAND, PrepareRefusal, byoaListingFailedMessage, byoaRequiredMessage, describeFallbackWarning, generatedModulesLine, eventAllObjectsMessage, eventNextLine, eventParentFieldsMessage, eventSubscription, eventSummaryLine, filterableFieldsLine, genericEventNeedsObjectMessage, lookupVocabularyLines, objectNoteLine, objectOnCuratedEventMessage, objectRecordedLine, warnLine, webhookNoteLines, } from "./messages.js";
+import { RESOLUTIONS_FILENAME, matchObject, recordObjectResolution } from "./objects.js";
+import { lookupSpecsFromOverlay, mergeFilesInto } from "./overlay.js";
+import { regenerateDescriptors } from "./regenerate.js";
+import { isPlainObject, pyGet, pyOr, pyPathJoin, pyPathlibStr, pyStrAny, pyTruthy } from "./support.js";
+/**
+ * `_event_operation`: the operation key every trigger API takes.
+ *
+ * NOT `operation.name`: that is the object's CRUD verb (`Create` on outlook
+ * `email-received`), while the event's own operation is `EMAIL_RECEIVED`,
+ * which `extractCanonical` stamps as `eventOperation` from the manifest's
+ * `model.context`. `name` happens to fall back to the same value when the
+ * manifest omits `connectorMethodInfo.operation`, so reading it works or
+ * silently queries the WRONG operation depending on which fallback rung a
+ * connector's manifest exercises.
+ */
+export function eventOperation(operation) {
+    return pyStrAny(pyOr(pyOr(pyGet(operation, "eventOperation", null), pyGet(operation, "name", null)), ""));
+}
+/** The START and WAIT node types of one event. */
+export function eventNodeTypes(connectorKey, action) {
+    return {
+        trigger: `uipath.connector.trigger.${connectorKey}.${action}`,
+        event: `uipath.connector.event.${connectorKey}.${action}`,
+    };
+}
+/**
+ * The one stored shape (see the module comment): the definition with the
+ * describe folded in, or with the object row's `Parameters` unioned into its
+ * own `eventParameters`; the entry's `outputSchema` taken from the definition's
+ * `outputResponseDefinition` when that has fields. Pure — copies of both inputs.
+ */
+export function assembleEventDefinition(node, entry, describe, objectRow, eventNodeType) {
+    const objectParameters = objectRow === undefined ? null : pyGet(objectRow, "Parameters", null);
+    let stored;
+    if (describe !== undefined) {
+        stored = mergeDescribeIntoNode(node, describe, objectParameters);
+    }
+    else {
+        stored = { ...node };
+        const declared = pyOr(get(stored, "eventParameters"), {});
+        stored.eventParameters = { fields: unionEventParameters(get(declared, "fields"), objectParameters) };
+    }
+    const out = { ...entry };
+    const outputDefinition = pyOr(get(stored, "outputResponseDefinition"), {});
+    const outputFields = get(outputDefinition, "fields");
+    if (pyTruthy(outputFields))
+        out.outputSchema = { fields: outputFields };
+    stored.nodeType = eventNodeType;
+    out.nodeType = eventNodeType;
+    return { node: stored, entry: out };
+}
+/**
+ * `_refuse_unless_byoa_connection`: refuse a standard connection on an event
+ * object that requires BYOA. V1 measured the failure this prevents — the
+ * trigger deploys and then faults at runtime with a webhook error naming
+ * nothing about connections — and the requirement is knowable now.
+ *
+ * A refusal must leave nothing behind: stage 0 has already written this
+ * connection into `bindings.json` by the time the event's own metadata says it
+ * is the wrong KIND, so the file is restored first. A listing that FAILED is
+ * not a tenant with no BYOA connections; the remedies are opposite.
+ */
+export async function refuseUnlessByoaConnection(client, connectorKey, connectionId, rollback, warn) {
+    const restore = () => {
+        if (rollback)
+            restoreBindings(rollback.path, rollback.snapshot, warn, rollback.shown);
+    };
+    let rows;
+    try {
+        rows = await byoaConnections(client, connectorKey);
+    }
+    catch (error) {
+        if (!(error instanceof ConnectionRefusal))
+            throw error;
+        restore();
+        throw new PrepareRefusal(byoaListingFailedMessage(connectionId, error), "BYOA_LISTING_FAILED");
+    }
+    if (rows.some((row) => pyStrAny(pyGet(row, "Id", null)) === connectionId))
+        return;
+    restore();
+    throw new PrepareRefusal(byoaRequiredMessage(connectionId, connectorKey, byoaListing(rows, connectorKey)), "BYOA_REQUIRED");
+}
+function fieldsOf(section) {
+    const fields = pyOr(get(pyOr(section, {}), "fields"), []);
+    return Array.isArray(fields) ? fields : [];
+}
+/**
+ * `_prepare_event`. Returns `undefined` when `<key> <action>` is not an event
+ * either, so the caller can raise the ordinary unknown-action refusal;
+ * everything else is handled here, refusals included. `ctx.connectionId` must
+ * already be the connection: the trigger definition only answers with one.
+ */
+export async function prepareEvent(ctx, options) {
+    const { connectorKey, action, connectionId, out } = options;
+    const outShown = options.outShown ?? out;
+    const info = (line) => ctx.reporter.info(line);
+    const warn = (line) => ctx.reporter.warn(line);
+    const { trigger: triggerNodeType, event: eventNodeType } = eventNodeTypes(connectorKey, action);
+    const cacheName = await registryGet(ctx, triggerNodeType);
+    if (cacheName === undefined)
+        return undefined;
+    const payload = ctx.caches.registry.read(cacheName);
+    const canonical = extractCanonical(nodeOf(payload));
+    if (canonical === undefined)
+        return undefined;
+    if (pyTruthy(options.fields))
+        throw new PrepareRefusal(eventParentFieldsMessage(), "EVENT_NO_PARENT_FIELDS");
+    if (options.allObjects)
+        throw new PrepareRefusal(eventAllObjectsMessage(), "EVENT_NO_ALL_OBJECTS");
+    // `(raw.get("Data") or {}).get("Node") or raw.get("Node") or {}`.
+    const raw = isRecord(payload) ? payload : {};
+    const node = pyOr(pyOr(get(pyOr(get(raw, "Data"), {}), "Node"), get(raw, "Node")), {});
+    const entry = { ...canonical, operation: { ...canonical.operation } };
+    const op = entry.operation;
+    const operation = eventOperation(op);
+    const generic = op.activityType === "GenericTrigger";
+    // The objects listing is the generic catalog AND the per-object fact sheet
+    // (BYOA, webhook visibility, bucket-scoped Parameters). For a curated event
+    // it is advisory — the definition already carries the sections — so a
+    // listing failure degrades to a warning there and is fatal only where it is
+    // the only source of truth.
+    let rows;
+    try {
+        rows = (await triggersObjects(ctx.client, connectorKey, operation, connectionId, ctx.timeoutMs)).filter(isPlainObject);
+    }
+    catch (error) {
+        if (!(error instanceof EventDiscoveryError))
+            throw error;
+        if (generic)
+            throw error;
+        rows = [];
+        warn(warnLine(error));
+    }
+    let describe;
+    let objectRow;
+    let requestedObject;
+    let objectName = options.objectName ?? undefined;
+    if (generic) {
+        if (!pyTruthy(objectName)) {
+            throw new PrepareRefusal(genericEventNeedsObjectMessage(action, rows), "EVENT_OBJECT_REQUIRED");
+        }
+        // The author's name, not necessarily the API's — same ladder, same refusal
+        // semantics as a Generic activity. The listing is live (no CLI-side
+        // cache), so there is nothing to refresh on a miss.
+        const matched = matchObject(rows, objectName, operation);
+        if (matched.note)
+            info(objectNoteLine(matched.note));
+        objectRow = matched.row;
+        requestedObject = objectName;
+        objectName = pyStrAny(pyOr(pyGet(objectRow, "Name", null), objectName));
+        describe = await triggersDescribe(ctx.client, connectorKey, operation, objectName, connectionId, ctx.timeoutMs);
+        op.objectName = objectName;
+        op.objectDisplayName = pyStrAny(pyOr(pyGet(objectRow, "DisplayName", null), ""));
+    }
+    else {
+        if (pyTruthy(objectName)) {
+            throw new PrepareRefusal(objectOnCuratedEventMessage(action, pyGet(op, "objectName", null)), "EVENT_OBJECT_BUILT_IN");
+        }
+        const baked = pyStrAny(pyOr(pyGet(op, "objectName", null), ""));
+        objectRow = rows.find((row) => pyStrAny(pyGet(row, "Name", null)) === baked);
+        // `triggers describe` is the AUTHORITY for a curated event too: the
+        // registry definition mirrors it and the mirror is lossy (outlook
+        // `email-received`: 15 filter fields in describe, 14 in the registry).
+        // Fall back to the definition's own sections when describe cannot answer
+        // rather than failing the prepare — the mirror is still a usable vocabulary.
+        if (baked) {
+            try {
+                describe = await triggersDescribe(ctx.client, connectorKey, operation, baked, connectionId, ctx.timeoutMs);
+            }
+            catch (error) {
+                if (!(error instanceof EventDiscoveryError))
+                    throw error;
+                warn(describeFallbackWarning(error, baked));
+            }
+        }
+    }
+    const facts = eventFacts(node, objectRow ?? null);
+    if (facts.byoaConnection) {
+        await refuseUnlessByoaConnection(ctx.client, connectorKey, connectionId, options.bindings, warn);
+    }
+    const definition = assembleEventDefinition(node, entry, describe, objectRow, eventNodeType);
+    const plan = planLibrary([definition.entry], () => definition.node);
+    for (const line of plan.warnings)
+        warn(line);
+    mergeFilesInto(plan.files, out);
+    if (generic) {
+        recordObjectResolution(out, eventNodeType, requestedObject, objectRow, operation);
+        // Named as the author spelled `--out`, not as the file was resolved.
+        info(objectRecordedLine(requestedObject, objectName, pyPathJoin(outShown, RESOLUTIONS_FILENAME)));
+    }
+    if (pyTruthy(options.resolve)) {
+        // A `LookupExhausted` propagates out of here as `ResolutionsExhausted`;
+        // the pipeline owns the retry, since re-running pinned means starting the
+        // whole command over, not this stage.
+        await writeResolutions({
+            client: ctx.client,
+            connectorKey,
+            connectionId,
+            out,
+            outShown,
+            nodeType: eventNodeType,
+            objectName,
+            resolve: options.resolve,
+            refreshLookups: options.refreshLookups,
+            reporter: ctx.reporter,
+        });
+    }
+    const jsonOnly = options.jsonOnly ?? false;
+    const modules = regenerateDescriptors(out, options.importSpecifier, jsonOnly);
+    // The generator's own last line, which the Python spawned and so printed
+    // here; under --json-only it never ran and said nothing.
+    if (!jsonOnly)
+        info(generatedModulesLine(modules.length, pyPathlibStr(outShown)));
+    const whereFields = fieldsOf(get(definition.node, "eventParameters"));
+    const filterFields = fieldsOf(get(definition.node, "filterFields"));
+    const mode = facts.eventMode;
+    info(eventSummaryLine(eventNodeType, outShown, operation, mode, whereFields.length, filterFields.length));
+    const command = options.prepareCommand ?? PREPARE_COMMAND;
+    for (const line of lookupVocabularyLines(connectorKey, action, objectName, lookupSpecsFromOverlay(out, eventNodeType, objectName), command)) {
+        info(line);
+    }
+    const filterable = filterableFieldsLine(filterFields.filter(isPlainObject));
+    if (filterable !== undefined)
+        info(filterable);
+    for (const line of webhookNoteLines(mode, facts.textBlocks))
+        warn(line);
+    const subscription = eventSubscription(connectorKey, action, generic ? objectName : undefined, pyOr(options.boundConnection, "<connection>"), pyOr(options.boundFolder, "shared"));
+    info(eventNextLine(subscription));
+    return {
+        eventNodeType,
+        operation,
+        generic,
+        ...(generic ? { objectName } : {}),
+        facts,
+        whereFields,
+        filterFields,
+        definition,
+    };
+}

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

@@ -0,0 +1,21 @@
+/**
+ * `ConnectorValue<string>` → `string`, for the handoff skeleton. The generated
+ * property type says what the field ACCEPTS — the literal or an expression —
+ * which is right for the compiler and wrong for a one-line "what goes here"
+ * hint; the wrapper is not something the author types.
+ */
+export declare function unwrapValue(tsType: string): string;
+/**
+ * `_required_interface_fields`: `[name, type]` for every non-optional
+ * property of `export interface <name> { … }` in the generated module, or
+ * `undefined` when the interface is absent or a line does not parse — the
+ * caller must then say the skeleton is unavailable rather than print `{}`.
+ */
+export declare function requiredInterfaceFields(generated: string, interfaceName: string): Array<[name: string, type: string]> | undefined;
+/**
+ * `_descriptor_usage`: the handoff lines for `<outDir>/<connectorKey>.ts`,
+ * unprefixed (the caller prints each as `prepare-connector: next: …`).
+ * `cwd` is what the Python read as `Path.cwd()`: the import path is spelled
+ * relative to it, with a leading `./`.
+ */
+export declare function descriptorUsage(outDir: string, connectorKey: string, boundConnection?: string, boundFolder?: string, cwd?: string): string[];

package/dist/registry/prepare/handoff.js

@@ -0,0 +1,91 @@
+/**
+ * Teach the author how to consume the connection-resolved descriptor.
+ *
+ * The live registry may use a different action id than the baked catalog. The
+ * generated descriptor is the authority for that resolved identity, so the
+ * success message must carry the author across that boundary instead of
+ * leaving them to reverse-engineer `index.json`. With exactly one descriptor
+ * in the module the handoff is a pasteable call whose inputs skeleton names
+ * every REQUIRED field with its type; with several, it says which file to open
+ * and refuses to guess an object.
+ *
+ * Ported from `_descriptor_usage`, `_required_interface_fields` and
+ * `_unwrap_value` in `prepare_connector.py`. The text lives in `messages.ts`;
+ * this module reads the generated module and parses it.
+ */
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { relativePosix, toPosix } from "../compat/paths.js";
+import { pyStrip } from "../compat/pystr.js";
+import { descriptorUsageFallbackLines, descriptorUsageLines, descriptorUsageUnparsedLines } from "./messages.js";
+/**
+ * `ConnectorValue<string>` → `string`, for the handoff skeleton. The generated
+ * property type says what the field ACCEPTS — the literal or an expression —
+ * which is right for the compiler and wrong for a one-line "what goes here"
+ * hint; the wrapper is not something the author types.
+ */
+export function unwrapValue(tsType) {
+    const match = /^Connector(?:Lookup)?Value<(.+)>$/.exec(pyStrip(tsType));
+    return match ? match[1] : tsType;
+}
+const PROPERTY = /^ {2}([A-Za-z_$][A-Za-z0-9_$]*|"(?:\\.|[^"\\])*")(\?)?: (.+);$/;
+/** `str.splitlines()`: every line boundary Python recognises. */
+const LINE_BREAK = /\r\n|[\n\r\v\f\x1c\x1d\x1e\x85\u2028\u2029]/;
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * `_required_interface_fields`: `[name, type]` for every non-optional
+ * property of `export interface <name> { … }` in the generated module, or
+ * `undefined` when the interface is absent or a line does not parse — the
+ * caller must then say the skeleton is unavailable rather than print `{}`.
+ */
+export function requiredInterfaceFields(generated, interfaceName) {
+    const block = new RegExp(`^export interface ${escapeRegExp(interfaceName)} \\{([\\s\\S]*?)^\\}`, "m").exec(generated);
+    if (!block)
+        return undefined;
+    const required = [];
+    for (const line of block[1].split(LINE_BREAK)) {
+        const stripped = pyStrip(line);
+        if (!stripped || stripped.startsWith("/**") || stripped.startsWith("*") || stripped.startsWith("*/"))
+            continue;
+        const field = PROPERTY.exec(line);
+        if (!field)
+            return undefined;
+        if (!field[2])
+            required.push([field[1], unwrapValue(field[3])]);
+    }
+    return required;
+}
+const DESCRIPTOR_EXPORT = /^export const ([A-Za-z_$][A-Za-z0-9_$]*) = descriptor<([A-Za-z_$][A-Za-z0-9_$]*),/gm;
+/**
+ * `_descriptor_usage`: the handoff lines for `<outDir>/<connectorKey>.ts`,
+ * unprefixed (the caller prints each as `prepare-connector: next: …`).
+ * `cwd` is what the Python read as `Path.cwd()`: the import path is spelled
+ * relative to it, with a leading `./`.
+ */
+export function descriptorUsage(outDir, connectorKey, boundConnection = "<binding-name>", boundFolder = "<folder-binding-name>", cwd = process.cwd()) {
+    const source = join(outDir, `${connectorKey}.ts`);
+    let generated = "";
+    let exports = [];
+    try {
+        generated = readFileSync(resolve(cwd, source), "utf8");
+        exports = [...generated.matchAll(DESCRIPTOR_EXPORT)].map((m) => [m[1], m[2]]);
+    }
+    catch {
+        generated = "";
+        exports = [];
+    }
+    let importPath = relativePosix(cwd, resolve(cwd, source));
+    if (!importPath.startsWith("."))
+        importPath = `./${importPath}`;
+    const sourcePosix = toPosix(source);
+    if (exports.length === 1) {
+        const [descriptorName, inputsInterface] = exports[0];
+        const requiredFields = requiredInterfaceFields(generated, inputsInterface);
+        if (requiredFields === undefined)
+            return descriptorUsageUnparsedLines(sourcePosix, descriptorName);
+        return descriptorUsageLines(descriptorName, importPath, requiredFields, boundConnection, boundFolder);
+    }
+    return descriptorUsageFallbackLines(sourcePosix);
+}

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

@@ -0,0 +1,104 @@
+import type { Reporter } from "../reporter.js";
+import type { UipClient } from "../uip/client.js";
+import { type OverlayLookupSpec } from "./overlay.js";
+import { LookupExhausted, type ResolveRequest } from "./resolve.js";
+/**
+ * The key a resolution is recorded under: `JSON.stringify([nodeType, field,
+ * by, value])`, the same bytes `core/lookups.ts`'s `lookupKey` computes when
+ * `compile` looks one up.
+ *
+ * INTENTIONAL DIVERGENCE from the Python, which built the key with
+ * `json.dumps(..., separators=(",", ":"))` — compact like JavaScript, but with
+ * `ensure_ascii` left on, so a value with any character outside ASCII was
+ * written as `\uXXXX` INSIDE the key string. `JSON.stringify` writes the
+ * character itself. The two spellings of the same tuple are different strings,
+ * so every such resolution `prepare` recorded was invisible to the `compile`
+ * that had asked for it. Written raw here to match the reader;
+ * {@link findResolution} still reads the escaped spelling so a ledger the
+ * Python wrote keeps loading.
+ */
+export declare function resolutionKey(nodeType: string, field: string, by: string, value: string): string;
+/** The Python's spelling of the same key: compact separators, `ensure_ascii=True`. */
+export declare function escapedResolutionKey(nodeType: string, field: string, by: string, value: string): string;
+/** `[nodeType, field, by, match]` out of a recorded key, in either spelling, or `undefined`. */
+export declare function parseResolutionKey(key: string): [nodeType: string, field: string, by: string, match: string] | undefined;
+/** One recorded row, with the key it was found under (raw or escaped). */
+export interface FoundResolution {
+    key: string;
+    row: Record<string, unknown>;
+}
+/**
+ * The recorded row for `(nodeType, field, by, value)`, whichever spelling it
+ * was written under — raw first, then the Python's escaped form. For a pure
+ * ASCII tuple the two are the same string.
+ */
+export declare function findResolution(existing: Readonly<Record<string, unknown>>, nodeType: string, field: string, by: string, value: string): FoundResolution | undefined;
+/**
+ * What one run set out to resolve: the specs read from the overlay and the
+ * requests in dependency order — the `specs, ordered` that
+ * `_retry_or_exit(args, node_type, specs, ordered, error)` took, so a probe of
+ * another connection asks exactly the questions this run asked.
+ */
+export interface ResolutionPlan {
+    specs: ReadonlyMap<string, OverlayLookupSpec>;
+    ordered: readonly ResolveRequest[];
+}
+/**
+ * A {@link LookupExhausted} as {@link writeResolutions} surfaces it: the
+ * exhausted lookup plus the plan it belonged to. Same message, same facts,
+ * still a `LookupExhausted` — the pipeline catches this one class and has
+ * everything the retry needs, whichever path (action or event) was running.
+ *
+ * Raised ONLY for a scan that reached the collection's end. A capped scan is
+ * a `LookupExhausted` too and is deliberately NOT wrapped; see the throw site.
+ */
+export declare class ResolutionsExhausted extends LookupExhausted {
+    readonly first: LookupExhausted;
+    readonly plan: ResolutionPlan;
+    constructor(first: LookupExhausted, plan: ResolutionPlan);
+}
+/** What one `--resolve` run needs; `objectName` narrows the overlay entry the specs are read from. */
+export interface ResolveRun {
+    client: UipClient;
+    connectorKey: string;
+    connectionId: string;
+    /** The overlay directory to read and write (resolved). */
+    out: string;
+    /** `out` as the caller spelled it, for the `wrote … to` line; defaults to `out`. */
+    outShown?: string;
+    nodeType: string;
+    objectName?: string | null;
+    /** The raw `--resolve <field>:<by>=<value>` flags, in the order given. */
+    resolve: readonly string[];
+    refreshLookups?: boolean;
+    reporter: Reporter;
+}
+export interface ResolveOutcome {
+    /** The ledger written. */
+    path: string;
+    /** Rows in the ledger's `resolutions` after the write. */
+    count: number;
+    /** `field → id` for every field this run resolved or found recorded. */
+    resolved: Map<string, string>;
+}
+/**
+ * `_write_resolutions`: resolve every `--resolve` and merge the answers into
+ * the ledger. Reads and rewrites the WHOLE ledger, not just `resolutions` —
+ * the file also carries the `objects` section, and rewriting one section used
+ * to silently drop the other. A file that will not parse is REFUSED rather
+ * than reset (`readLedger`), the same rule `bindings.json` follows.
+ *
+ * `specs` defaults to the overlay's, read back from what was just written;
+ * a caller that already holds them passes them in.
+ */
+export declare function writeResolutions(run: ResolveRun, specs?: ReadonlyMap<string, OverlayLookupSpec>): Promise<ResolveOutcome>;
+/**
+ * `_resolved_parent_values`: `{parent → resolved id}` for every parent with a
+ * recorded resolution on `nodeType`, read from the ledger just written so the
+ * paste-ready `-f` re-run carries the ids THIS invocation resolved — never
+ * guessed, never retyped. A ledger that will not load answers nothing; the
+ * refusal for that belongs to the write that found it.
+ */
+export declare function resolvedParentValues(out: string, nodeType: string, parents: readonly string[]): Map<string, string>;
+/** `set(resolved_parents) == set(action_parents)`: every schema parent has a recorded resolution, the paste-ready re-run condition. */
+export declare function allParentsResolved(actionParents: readonly string[], resolvedParents: ReadonlyMap<string, string>): boolean;